Refine curator sprint planning flow

Reviewed-on: #5

Dockerfile

@@ -12,7 +12,9 @@ COPY src ./src
 RUN npx tsc -p tsconfig.json
 
 FROM base AS runtime
+ARG RIVET_RUNNER_VERSION=dev
 ENV NODE_ENV=production
+ENV RIVET_RUNNER_VERSION=$RIVET_RUNNER_VERSION
 COPY --from=deps /app/node_modules ./node_modules
 COPY --from=build /app/dist ./dist
 COPY package.json ./

docker-compose.override.yml

@@ -0,0 +1,9 @@
+# VPS override: make host.docker.internal resolve to the host so the
+# backend container can reach product services + spawned per-user
+# containers published on host ports (Linux has no built-in mapping).
+services:
+  backend:
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    environment:
+      SOCIAL_BRANDING_SERVICE_URL: http://host.docker.internal:8015

docker-compose.yml

@@ -121,6 +121,7 @@ services:
     volumes:
       # Docker-out-of-Docker: backend uses host Docker to spawn per-user OpenCode containers.
       - /var/run/docker.sock:/var/run/docker.sock
+      - ./prompts:/app/prompts
       # Shared host dir that per-user containers will also bind-mount their
       # workspace from (so backend and spawned containers see the same files).
       - ./.data/users:/data/users

docs/backend-dead-code.md

@@ -0,0 +1,84 @@
+# Backend Dead Code Inventory
+
+PRM-46 inventory pass for `growqr-backend`.
+
+No source code was deleted in this pass. Static search and manual inspection were used. Typecheck was run successfully with `pnpm typecheck`.
+
+## Summary
+
+The codebase is mostly wired, but it contains several compatibility, demo, and partially superseded paths. The main cleanup risk is accidentally removing code still used by the frontend's older workflow screens or by demo environments.
+
+## Candidates
+
+| Priority | Candidate | Recommendation | Evidence |
+| --- | --- | --- | --- |
+| High | `src/actors/product-service-actors.ts` | Keep for now; consider deleting only after confirming no Rivet clients call these actors. | Actors are registered in `src/actors/registry.ts`, but local code routes service calls through `src/routes/services.ts` and `src/services/product-service-clients.ts` directly. No local `getOrCreate` references for `interviewServiceActor`, `roleplayServiceActor`, or `resumeServiceActor` were found. |
+| High | Legacy `/workflows/job-application*` route aliases in `src/routes/workflows.ts` and large portions of `src/actors/user-actor.ts` workflow state | Keep until frontend migration is verified; likely cleanup after DB-backed workflow runs fully replace it. | `job-application` aliases call `userActor`; newer `/workflow-runs` path uses `workflowRuns`, `workflowRunModules`, and `workflowRunActor`/`executeWorkflowModule`. Two workflow systems coexist. |
+| High | `src/workflows/module-runner.ts` synchronous execution from routes | Keep, but consolidate behind `workflowRunActor` before cleanup. | Used both by `workflowRunActor` and directly by route handlers. Direct route use undercuts actor durability, but the module runner itself is active. |
+| Medium | `src/workflows/smoke-test.ts` | Keep as script if used manually; otherwise convert to documented test or remove. | Only referenced by `package.json` script `workflows:smoke`; not part of app runtime. |
+| Medium | `scripts/rivet-actors.ts` | Keep if used by ops; document or remove if not. | Standalone admin script; not imported by source. It relies on `RIVET_ENDPOINT`, `RIVET_NAMESPACE`, and admin token defaults. |
+| Medium | Demo home seeder `src/home/seed-demo-home.ts` and `/home/seed-demo` | Keep in staging/demo only; move behind explicit environment gate. | `src/routes/home.ts` exposes a seed endpoint. Schema has `generatedBy: "demo"` for notifications. This is live source behavior rather than isolated fixture code. |
+| Medium | Static fallback mission registry vs persisted registry (`src/missions/registry.ts` and `src/missions/postgres-registry.ts`) | Keep both until migration/backfill is confirmed; then decide whether DB registry or static registry is source of truth. | `routes/missions.ts` reads persisted definitions, while actor factory and conversations read static definitions. `postgres-registry` falls back to static definitions. |
+| Medium | Duplicate mission actor wrappers (`career-transition-actor.ts`, `salary-negotiation-war-room-actor.ts`, `promotion-readiness-actor.ts`, `personal-brand-opportunity-engine-actor.ts`) | Keep; low-cost wrappers are active. | Thin wrappers are mapped in routes, registry, event actor, and actor registry. |
+| Medium | `src/events/projectors/projection-agent.ts` LLM insight path | Keep, but verify product use. | Referenced by `userEventActor` and `reducer-types`, so not dead. It can silently fall back when no LLM API key exists. |
+| Medium | Legacy Redis observers in `src/events/redis-consumer.ts` | Keep until services emit canonical Grow Events. | Comments state these observe existing service A2A traffic. They are enabled by `INTERVIEW_REDIS_URL`, `ROLEPLAY_REDIS_URL`, and `RESUME_REDIS_URL`. |
+| Medium | `events` audit table in `src/db/schema.ts` | Keep until old frontend timelines and route writes are audited. | Older user/service paths still import/use `events` table, while newer Grow Event tables also exist. |
+| Low | `src/workflows/registry.ts` and `src/missions/registry.ts` duplicate product concepts | Keep; consolidate later. | Workflows are commercial product definitions; missions are actor-backed variants. The overlap is intentional but duplicative. |
+| Low | `docker/opencode/workspace-template/*/README.md` placeholders | Keep as template docs or remove if generated workspaces no longer need empty folders. | Template-only files are not runtime code, but useful for preserving folder structure. |
+| Low | `docs/architecture.html` | Keep unless replaced by Markdown architecture docs. | Existing doc artifact, not source. |
+
+## Unused or Underused Env Vars / Config Values
+
+| Env/config | Recommendation | Evidence |
+| --- | --- | --- |
+| `config.required` | Keep or remove after scanning call sites; currently exported but not used in local source. | `required` is attached to config, but no local `config.required(` references were found. |
+| `clerkPublishableKey` | Keep if clients read backend config elsewhere; otherwise remove from backend config. | Defined in `config.ts` and `.env.example`, but backend auth uses secret key. |
+| `opencodeApiKey` | Keep only if future direct OpenCode auth requires it; currently `llmApiKey` consumes `OPENCODE_API_KEY`. | Defined separately in config; most OpenCode runtime calls use per-container password, not this field. |
+| `userServiceUrl` | Keep; used by missions profile lookup. | `routes/missions.ts` fetches `/api/v1/users/me`. |
+| `legacyServiceTaskObserverGroup` | Keep while legacy Redis observers exist. | Used in `redis-consumer.ts`. |
+| `migrationVersion`, `promptVersion`, `opencodeImageVersion` | Keep; active Docker rollout labels. | Used by `docker/manager.ts` and Docker build metadata. |
+
+## Stale or Demo-Oriented Behavior
+
+- Demo generated home notifications and `/home/seed-demo` should move to a staging/demo module or be guarded by `config.environment`.
+- `service-agents.ts` includes demo-like defaults, such as `formula_version: "workflow-demo"` and synthetic Q Score fallback summaries.
+- `config.ts` defaults many production-sensitive values to local/dev values, including Gitea admin credentials, service token fallback, A2A key, and localhost URLs.
+- Docker/OpenCode scripts are active but dev-biased, using image tags like `growqr/opencode:dev`.
+
+## Prompt Workflow Inventory
+
+All prompt workflow files under `prompts/workflows/*` are referenced by `src/workflows/registry.ts` through `promptPath` values:
+
+- `career-transition/orchestrator.md`
+- `interview-to-offer/interview-plan.md`
+- `salary-negotiation-war-room/orchestrator.md`
+- `promotion-readiness/orchestrator.md`
+- `personal-brand-opportunity-engine/orchestrator.md`
+
+Additional interview-to-offer prompt files (`resume-analysis.md`, `story-bank.md`, `final-readiness-report.md`) are not referenced by `workflowDefinitions` directly in this pass. Recommendation: keep until OpenCode/agent prompt loading is audited, then either wire them into module definitions or archive them.
+
+## Delete/Keep Decisions Before Cleanup
+
+Do not delete yet:
+
+- `userActor` workflow code
+- `product-service-actors`
+- static mission/workflow registries
+- Redis legacy observers
+- demo home seeder
+- standalone scripts
+
+Good first cleanup after approval:
+
+1. Move demo seeding to `src/staging` and guard it with a staging/demo environment.
+2. Remove or document unused config fields (`config.required`, `clerkPublishableKey`, `opencodeApiKey`) after a second pass across frontend/deployment references.
+3. Convert `workflows:smoke` into a real test or delete the script.
+4. Consolidate mission actor type mapping into one helper and remove duplicate mapping functions.
+
+## Verification
+
+`pnpm typecheck` passed:
+
+```txt
+tsc -p tsconfig.json --noEmit
+```

docs/backend-organization-audit.md

@@ -0,0 +1,179 @@
+# Backend Organization Audit
+
+PRM-41 audit pass for `growqr-backend`.
+
+Scope reviewed: `src/routes`, `src/actors`, `src/events`, `src/missions`, `src/workflows`, and `src/services`.
+
+## Executive Summary
+
+The backend currently has three overlapping orchestration layers:
+
+1. HTTP routes that directly perform database writes, service calls, and some synchronous workflow execution.
+2. Rivet actors that own durable user, workflow, mission, conversation, memory, and event processing state.
+3. Event/projector code that normalizes service events into Grow Events, updates mission state, records service sessions, and projects Q Score signals.
+
+That split is workable for a demo-stage backend, but it blurs ownership. Several routes contain business logic that should live in services or actors, while actors and event consumers need stronger idempotency, retry, and replay boundaries before production traffic.
+
+## High-Level Architecture
+
+```mermaid
+flowchart LR
+  FE[Frontend / service clients] --> Hono[Hono routes]
+  Hono --> DB[(Postgres / Drizzle)]
+  Hono --> Rivet[Rivet actors]
+  Hono --> Svc[Product services]
+  Hono --> Docker[Docker + Gitea + OpenCode]
+
+  Svc --> Redis[Redis streams / pubsub]
+  Redis --> Consumer[events/redis-consumer]
+  Consumer --> GrowEvents[(grow_events)]
+  Consumer --> EventActor[userEventActor]
+  EventActor --> MissionActors[mission actors]
+  EventActor --> Projectors[QScore/session/projectors]
+  MissionActors --> DB
+
+  Rivet --> DB
+  Rivet --> Svc
+  Rivet --> Docker
+```
+
+## Route to Actor/Service/Event/Data Flow Map
+
+| Route module | Mounted path | Primary flow | Actor/service/data dependencies | Notes |
+| --- | --- | --- | --- | --- |
+| `src/routes/actors.ts` | `/actors` | Auth-gated user stack control | `docker/manager`, `actors` table | Provisions/stops OpenCode stack directly from route. |
+| `src/routes/agents.ts` | `/agents` | Catalog read | `agents/catalog` | Thin route. |
+| `src/routes/chat.ts` | `/api/chat` | Chat request, Rivet first, direct LLM fallback | `userActor`, `lib/llm`, `services/service-agents` | Contains fallback tool orchestration and timeout logic in route. |
+| `src/routes/conversations.ts` | `/conversations` | Conversation CRUD/chat/mission bridging | `conversationActor`, mission actors, `grow_conversations`, messages | Heavy route; mixes persistence, actor bootstrapping, mission resolution, and response shaping. |
+| `src/routes/events.ts` | `/events` | User/service event ingestion and listing | `recordGrowEvent`, `routeGrowEventToUserActor`, `grow_events` | Good ingestion boundary, but service auth is environment-sensitive. |
+| `src/routes/git.ts` | `/git` | Repo/file operations | `docker/manager`, `GiteaClient` | Route owns path safety and repo operation decisions. |
+| `src/routes/grow.ts` | `/grow` | Grow bootstrap and active state | `growActor` | Thin actor gateway. |
+| `src/routes/home.ts` | `/home` | Home feed, notifications, demo seed | `home-feed`, `seed-demo-home` | Includes demo seeding endpoint. |
+| `src/routes/missions.ts` | `/missions` | Mission catalog, start/pause/resume/stage/artifacts/coach | `growActor`, mission actors, user service, mission registry | Heavy route; owns mission selection, profile fallback, actor type mapping, and artifact commands. |
+| `src/routes/opencode.ts` | `/opencode` | OpenCode stack/session/message proxy | `docker/manager`, `OpencodeClient` | Directly provisions stack and opens sessions. |
+| `src/routes/services.ts` | `/services` | Product service proxy and event recording | `product-service-clients`, `recordGrowEvent`, Q Score onboarding | Very heavy route; contains service-specific payload shaping and event side effects. |
+| `src/routes/users.ts` | `/users` | User profile/bootstrap | `auth/clerk`, `users` table, onboarding Q Score | Includes Clerk profile mirroring and onboarding side effects. |
+| `src/routes/workflows.ts` | `/workflows`, `/workflow-runs` | Workflow definitions/runs/modules/approvals | `userActor`, `workflowRunActor`, `workflow/module-runner`, DB | Two paths: legacy userActor job-application flow and DB-backed workflow runs. |
+
+## Actor Inventory
+
+| Actor | Current role | Main inputs | Outputs/effects | Robustness observations |
+| --- | --- | --- | --- | --- |
+| `userActor` | Legacy unified user orchestration: chat, memory tools, workflow status, service handoffs, OpenCode/Gitea interactions | `/api/chat`, `/workflows/job-application`, workflow route aliases | Actor state, DB events, service calls, Gitea reads/writes | Very broad responsibilities; failures in service calls often become summaries rather than durable retryable jobs. |
+| `workflowRunActor` | Queued workflow module runner | `/workflow-runs/:runId/pause|resume` and direct client use | `workflowRunModules`, `workflowEvents`, `qscoreSnapshots` via module runner | Has Rivet loop retry settings for module execution, but route-level `/run` bypasses actor queue and executes synchronously. |
+| `conversationActor` | Durable streaming conversation state | `/conversations` | Actor state and generated messages | Queue usage exists for messages; needs documented idempotency per turn/message id. |
+| `memoryActor` | Durable memory file state | Internal client use | Actor state/file-like memory | Queue writes exist; external call idempotency unclear. |
+| `growActor` | Active mission list/state control | `/grow`, `/missions` | `grow_active_missions`, mission state | Mission lifecycle split across growActor, mission actors, and routes. |
+| `userEventActor` | Routes normalized Grow Events to missions/projectors | Redis consumer, `/events` ingestion | Mission stage patches, projector DB updates, event status | Central point for event idempotency, but retries/replay/DLQ are not yet formalized. |
+| Mission actors | Per-mission state machines | `/missions`, `/conversations`, event actor | `grow_active_missions`, artifacts, suggestions | Four mission actors are thin factory wrappers; interview-to-offer has custom implementation. |
+| Product service actors | Actor wrappers for interview/roleplay/resume clients | Registry only; possible client use | Service calls | Registered, but routes call clients directly. These may be underused compared to direct service proxy routes. |
+
+## Event and Projector Flow
+
+```mermaid
+sequenceDiagram
+  participant Service as Product service
+  participant Redis as Redis stream/pubsub
+  participant Route as /events or service routes
+  participant Store as grow_events
+  participant UserEvent as userEventActor
+  participant Mission as mission actor
+  participant Projection as projectors
+
+  Service->>Redis: canonical GrowEvent or legacy task response
+  Redis->>Route: redis-consumer normalizes message
+  Route->>Store: recordGrowEvent with dedupeKey
+  Route->>UserEvent: routeGrowEventToUserActor
+  UserEvent->>Mission: apply reducer-derived stage patches
+  UserEvent->>Projection: service session and Q Score projections
+  Projection->>Store: update projection tables
+```
+
+Current event strengths:
+
+- `normalizeGrowEvent` accepts multiple service field conventions.
+- `recordGrowEvent` uses `dedupeKey` and a unique index on `grow_events.dedupe_key`.
+- Legacy Redis observer bridges `tasks:*` and `responses:*` without service changes.
+- Projector surfaces exist for session tracking, Q Score, and LLM-derived insights.
+
+Current event gaps:
+
+- Redis canonical consumer always `xAck`s in `finally`, even when `recordAndRoute` fails, so failed messages do not remain pending for retry.
+- No DLQ stream/table for failed canonical or legacy event processing.
+- No replay script for `grow_events.processing_status in ('failed', 'unresolved')`.
+- Legacy task context is in-memory only, so response events can lose user/action context after a backend restart.
+
+## Business Logic in Routes
+
+Highest concentration:
+
+- `src/routes/services.ts`: service-specific request construction, event emission, Q Score baseline/onboarding side effects, mission association, and UI response shaping.
+- `src/routes/workflows.ts`: run creation, module row initialization, baseline Q Score, approval gate progression, artifact content lookup, and synchronous module execution.
+- `src/routes/missions.ts`: mission profile lookup from user service, actor type mapping, start/resume/pause/stage/artifact commands, and coach run orchestration.
+- `src/routes/conversations.ts`: active conversation persistence, mission-aware chat routing, actor fallback behavior, and response normalization.
+- `src/routes/chat.ts`: Rivet fallback, direct LLM tool loop, service agent selection, and timeout handling.
+
+Low-risk thin routes:
+
+- `src/routes/agents.ts`
+- `src/routes/grow.ts`
+- parts of `src/routes/events.ts`
+
+Recommended ownership target:
+
+- Routes validate/authenticate and translate HTTP to commands.
+- Actors own durable user/mission/workflow progression.
+- Services own outbound HTTP details.
+- Projectors own derived read models.
+- Routes should not decide retry, idempotency, or service fallback behavior beyond returning HTTP errors.
+
+## Idempotency Gaps
+
+| Area | Existing behavior | Gap |
+| --- | --- | --- |
+| Grow Event ingestion | `dedupeKey` unique index; normalizer uses explicit key or source id | Service routes do not consistently set stable dedupe keys for all service-created side effects. |
+| Workflow runs | `/workflow-runs/:runId/modules/:moduleId/run` reads `idempotency-key` header | `executeWorkflowModule` does not use the key to suppress duplicate service calls; `/run` generates timestamp keys. |
+| Workflow module rows | Has `idempotencyKey`, `retryCount`, `maxRetries` columns | Counters are mostly passive; no central retry state machine. |
+| Actor queues | Rivet queues and `loop` step names provide some dedupe for `workflowRunActor` | Several routes bypass actor queue and execute directly. |
+| Service session creation | `stableUuid` exists in service-agent helper | Not consistently used as a request id/idempotency key across service calls. |
+| OpenCode artifacts | `onConflictDoNothing` for workflow artifacts | OpenCode prompt/message send can duplicate work before artifact row conflict applies. |
+
+## Retry Gaps
+
+| Area | Existing behavior | Gap |
+| --- | --- | --- |
+| `workflowRunActor` | Rivet `loop` has `retryBackoffBase` and `retryBackoffMax` | Only applies when execution goes through actor loop. |
+| HTTP service clients | Throw on non-2xx after `fetch` | No timeout, retry classification, request id, or backoff. |
+| Gitea client | Some wait/poll helpers exist | Most API calls are single-shot. |
+| OpenCode client | Health polling exists | Session/message calls are single-shot. |
+| Redis consumer | Infinite loop catches top-level errors | Per-message failures are acked; no retry budget or DLQ. |
+| Projectors | Called by event actor | Projector failures need durable retry/replay semantics and status transitions. |
+
+## Actor Robustness Gaps
+
+- `userActor` is too broad to reason about failure domains. It owns chat, service tools, memory, workflow, Gitea, OpenCode, and DB event writes.
+- Product service actors are registered but not the primary path for service proxy routes, so actor-level durability is uneven.
+- Mission actor mapping is manually duplicated in routes, registry, and event actor.
+- Route-level synchronous workflow execution can hold HTTP requests open across slow service/OpenCode calls.
+- Actor initialization is repeated in routes; a central actor gateway could enforce init/idempotency/logging.
+
+## Priority-Ranked Recommendations
+
+1. Create a backend command layer for route-to-actor/service translation. Move mission start, workflow run, approval, service configure, and chat tool dispatch logic out of routes.
+2. Make `workflowRunActor` the only executor for workflow modules. Routes should enqueue commands and return command ids.
+3. Add a shared outbound `withRetry`/timeout/idempotency wrapper for service clients, Gitea, OpenCode, and LLM calls.
+4. Add DLQ and replay support for Redis/event processing. Do not ack canonical Redis messages until durable record/projector status is successful or DLQ-ed.
+5. Normalize mission actor mapping into a single registry source used by routes, event actor, and mission registry.
+6. Split `userActor` responsibilities: chat/memory/workflow/OpenCode paths should be smaller actors or delegated services with explicit contracts.
+7. Convert route-created side effects to stable idempotency keys. Use request id, user id, mission instance id, service id, and operation name.
+8. Add structured logging fields across routes/actors/events: `requestId`, `userId`, `missionInstanceId`, `runId`, `moduleId`, `eventId`, `idempotencyKey`, `retryAttempt`.
+9. Add focused tests around duplicate workflow module run, duplicate service event ingest, Redis failure handling, and mission projector replay.
+
+## Suggested Next Slice
+
+Use PRM-43 to introduce shared retry/idempotency primitives first. Then return to this audit and migrate the highest-risk route logic in this order:
+
+1. `/workflow-runs/*/run`
+2. `/services/interview|roleplay configure/review`
+3. `/missions/:missionId/start`
+4. `/api/chat` direct LLM fallback

docs/environment-matrix.md

@@ -0,0 +1,148 @@
+# Environment Matrix
+
+PRM-42 staging vs production separation inventory for `growqr-backend`.
+
+No refactor was performed in this pass.
+
+## Current Environment Model
+
+The backend currently uses `config.nodeEnv` plus many individual env vars. There is no explicit first-class `environment` such as `development | staging | production | demo`.
+
+Important consequence: local/dev defaults can leak into staging or production unless deployment env vars override every sensitive value.
+
+## Current Config Inventory
+
+| Area | Config/env | Current default | Production concern |
+| --- | --- | --- | --- |
+| Runtime | `PORT`, `LOG_LEVEL`, `NODE_ENV` | `4000`, `info`, `development` | `NODE_ENV` is too broad for staging/demo behavior. |
+| Database | `DATABASE_URL` | hardcoded fallback DSN in `config.ts` | Production should fail fast instead of falling back. |
+| Auth | `CLERK_SECRET_KEY`, `CLERK_PUBLISHABLE_KEY` | empty | Secret key absence changes auth behavior; publishable key appears underused. |
+| Service auth | `SERVICE_TOKEN`, `A2A_ALLOWED_KEY` | empty / `dev-a2a-key` | Dev token fallback must not be accepted in production. |
+| Redis events | `GROW_EVENTS_REDIS_URL`, `REDIS_URL`, stream/group/consumer names | disabled unless set | Staging/prod need explicit stream, group, and replay policy. |
+| Legacy Redis | `INTERVIEW_REDIS_URL`, `ROLEPLAY_REDIS_URL`, `RESUME_REDIS_URL` | fallback to event Redis | Legacy observation should be explicitly enabled per environment. |
+| LLM | `LLM_PROVIDER`, `LLM_API_KEY`, `OPENCODE_API_KEY`, `LLM_BASE_URL`, `GROW_AGENT_MODEL`, `LLM_MODEL` | `opencode`, `https://opencode.ai/zen/v1`, `kimi-k2.6` | Staging/prod should pin provider/model and require API key where features are enabled. |
+| Rivet | `RIVET_ENDPOINT`, `RIVET_CLIENT_ENDPOINT` | localhost/127.0.0.1 | Docker compose overrides endpoint; production needs internal and public separation. |
+| Product services | `INTERVIEW_SERVICE_URL`, `ROLEPLAY_SERVICE_URL`, `QSCORE_SERVICE_URL`, `RESUME_SERVICE_URL`, `USER_SERVICE_URL`, `MATCHMAKING_SERVICE_URL`, `SOCIAL_BRANDING_SERVICE_URL` | localhost ports | Production should require service URLs or feature-disable explicitly. |
+| Public URLs | `INTERVIEW_PUBLIC_URL`, `ROLEPLAY_PUBLIC_URL`, `RESUME_PUBLIC_URL`, `WORKFLOWS_DASHBOARD_URL`, `FRONTEND_ORIGIN` | localhost/frontend fallback | Public and internal service URLs need separate semantics. |
+| Gitea | `GITEA_PUBLIC_URL`, `GITEA_INTERNAL_URL`, `GITEA_ADMIN_USER`, `GITEA_ADMIN_PASSWORD`, `GITEA_ADMIN_TOKEN`, `GITEA_ORG_NAME` | localhost, `growqr-admin`, `growqr-admin-dev`, empty token | Admin password fallback is dev-only. Production should require token/secret. |
+| OpenCode | `OPENCODE_IMAGE`, `OPENCODE_IMAGE_VERSION`, `MIGRATION_VERSION`, `PROMPT_VERSION`, `USER_CONTAINER_HOST`, `USER_DATA_ROOT`, `USER_PORT_RANGE_*` | dev image/version, local paths/ports | Needs staging/prod image tags and storage policy. |
+| CORS/admin | `FRONTEND_ORIGIN`, `ADMIN_USER_IDS` | localhost / empty | Empty admin list currently allows `/workflows/admin/ops` to all authenticated users. |
+| Agent limits | `MAX_AGENT_TOKENS`, `PROJECTION_AGENT_MODEL`, `CONVERSATION_ACTOR_MODEL` | 4096 / agent model | Model overrides should be pinned by environment. |
+
+## Environment-Dependent Code Paths
+
+| File | Behavior |
+| --- | --- |
+| `src/config.ts` | Central env parsing with dev defaults for database, tokens, local service URLs, Gitea, OpenCode, Rivet, frontend, and ports. |
+| `src/auth/clerk.ts` | In non-production, `A2A_ALLOWED_KEY` is accepted as an auth fallback. Clerk client is only created when `CLERK_SECRET_KEY` exists. |
+| `src/index.ts` | Proxies `/api/rivet` only when `process.env.RIVET_ENDPOINT` is set. Starts Redis consumer opportunistically. CORS uses `FRONTEND_ORIGIN`. |
+| `src/events/redis-consumer.ts` | Canonical consumer disabled if no Redis URL. Legacy observers enabled by legacy Redis URLs. |
+| `src/events/projectors/projection-agent.ts` | Falls back if no LLM API key; model can be overridden by `PROJECTION_AGENT_MODEL`. |
+| `src/actors/conversation/agent.ts` | Requires LLM key for streaming; model can be overridden by `CONVERSATION_ACTOR_MODEL`. |
+| `src/routes/events.ts` | Service ingest auth allows no service token in non-production. |
+| `src/routes/home.ts` | Exposes demo seeding route. |
+| `src/home/seed-demo-home.ts` | Demo notifications and executable direct script behavior. |
+| `src/services/service-agents.ts` | Synthetic/demo fallbacks for some unavailable services and Q Score estimate behavior. |
+| `src/docker/manager.ts` | Uses Gitea/OpenCode image/version/host/path/port config and mutates Docker runtime. |
+| `scripts/rivet-actors.ts` | Uses dev Rivet namespace/token defaults. |
+| `docker-compose.yml` | Dev compose defaults for Postgres, Gitea, Rivet, backend, services, frontend origins, and OpenCode image. |
+| `docker/opencode/*` | Dev-oriented OpenCode image/template behavior. |
+
+## Hardcoded URL and Default Hotspots
+
+- `http://localhost:*` defaults in `src/config.ts`, `.env.example`, `README.md`, and `docker-compose.yml`.
+- `http://127.0.0.1:*` defaults for Rivet client, Gitea, and user container host.
+- `http://host.docker.internal:*` compose service defaults.
+- OpenCode base image `ghcr.io/anomalyco/opencode:latest` in `docker/opencode/Dockerfile`.
+- Dev image tag `growqr/opencode:dev`.
+- Gitea admin defaults `growqr-admin` / `growqr-admin-dev`.
+- A2A fallback `dev-a2a-key`.
+
+## Clerk / JWKS Assumptions
+
+The code uses Clerk SDK with `CLERK_SECRET_KEY`; there is no explicit JWKS URL configuration in the reviewed backend source. Service-to-service auth is token based, with dev fallback behavior. Target production should document whether auth is:
+
+- Clerk session token verification for user requests.
+- `SERVICE_TOKEN` for service-to-backend event ingestion.
+- Separate internal A2A key for legacy product service calls.
+- Optional JWKS validation if services send JWTs instead of opaque service tokens.
+
+## Target Config Model
+
+Introduce:
+
+```ts
+type RuntimeEnvironment = "development" | "test" | "staging" | "demo" | "production";
+```
+
+Recommended top-level config shape:
+
+```ts
+config.environment
+config.isProduction
+config.isStaging
+config.isDemo
+config.features.demoDataEnabled
+config.features.legacyRedisObserversEnabled
+config.features.opencodeProvisioningEnabled
+config.features.serviceProxyEnabled
+config.urls.internal.*
+config.urls.public.*
+config.auth.*
+config.retry.*
+config.events.*
+```
+
+Rules:
+
+- Production must fail fast for missing `DATABASE_URL`, `CLERK_SECRET_KEY`, `SERVICE_TOKEN`, `FRONTEND_ORIGIN`, Gitea credentials/token, and any enabled service URL.
+- Staging may use staging service URLs and demo data only when `DEMO_DATA_ENABLED=true`.
+- Development may keep local defaults.
+- Demo behavior should be impossible in production unless an explicit, audited flag is set and the route remains auth/admin-gated.
+
+## What Should Move to `src/staging`
+
+Proposed `src/staging` candidates:
+
+- `home/seed-demo-home.ts`
+- `/home/seed-demo` route handler
+- demo notification factories
+- demo Q Score formulas/fallback constants in service-agent behavior, if not product-approved
+- local-only service session scaffolding helpers
+- any future seeders/backfills used only for demos
+
+Suggested layout:
+
+```txt
+src/staging/
+  demo-home.ts
+  demo-qscore.ts
+  seed-routes.ts
+  guards.ts
+```
+
+`src/staging/guards.ts` should expose `requireStagingOrDemo(config)` and fail closed in production.
+
+## Target Environment Matrix
+
+| Behavior | Development | Staging | Demo | Production |
+| --- | --- | --- | --- | --- |
+| Localhost defaults | Allowed | Not allowed | Not allowed unless local demo | Not allowed |
+| Demo seed endpoints | Allowed | Explicit flag + admin | Enabled by flag + admin | Disabled |
+| Service token fallback | Allowed | Not allowed | Not allowed | Not allowed |
+| Legacy Redis observers | Optional | Explicit flag | Explicit flag | Disable unless migration requires |
+| Redis canonical events | Optional | Required for event demos | Required | Required |
+| OpenCode image | `:dev` ok | pinned staging tag | pinned demo tag | pinned release tag |
+| Admin ops route | Authenticated maybe ok | `ADMIN_USER_IDS` required | `ADMIN_USER_IDS` required | `ADMIN_USER_IDS` required |
+| Missing Clerk secret | Allowed only for local mock if implemented | Fail | Fail | Fail |
+| Gitea admin password default | Allowed | Fail | Fail | Fail |
+
+## Priority Recommendations
+
+1. Add `APP_ENV` or `GROWQR_ENV` and derive `config.environment`; stop relying on `NODE_ENV` for product behavior.
+2. Fail fast in staging/production for missing secrets and localhost/default service URLs.
+3. Move demo seed code into `src/staging` and guard routes with `DEMO_DATA_ENABLED` plus admin check.
+4. Require `ADMIN_USER_IDS` before enabling `/workflows/admin/ops` outside development.
+5. Split public URLs and internal URLs in config names consistently across frontend, services, Gitea, Rivet, and OpenCode.
+6. Add a deployment checklist that records every required env var per environment.
+7. Make legacy Redis observers an explicit feature flag and set a removal date.

docs/retry-idempotency-dlq-plan.md

@@ -0,0 +1,284 @@
+# Retry, Idempotency, and DLQ Plan
+
+PRM-43 design pass for `growqr-backend`.
+
+No implementation was performed in this pass.
+
+## Goals
+
+- Bound every outbound call with timeouts.
+- Retry only safe operations with classified errors.
+- Make repeated commands safe through idempotency keys.
+- Preserve failed event/workflow work in a DLQ with replay tooling.
+- Add logs that let support trace one user action across route, actor, service, Redis, projector, and database writes.
+
+## Outbound Call Site Inventory
+
+| Area | Files | Current behavior | Needed behavior |
+| --- | --- | --- | --- |
+| Product service clients | `src/services/product-service-clients.ts` | Direct `fetch`, no timeout/retry/idempotency header | Shared service client with timeout, retry, idempotency key, and request id. |
+| Service agent probes | `src/services/service-agents.ts` | Direct `fetch`, some fallback summaries | Same shared client; distinguish "unavailable" from retriable failure. |
+| Gitea | `src/lib/gitea.ts`, `src/docker/manager.ts`, `src/actors/user-actor.ts` | Direct `fetch`, some wait-for-ready helpers | Retry transient Gitea API errors; idempotent repo/user/file operations. |
+| OpenCode | `src/lib/opencode.ts`, `src/workflows/executors/opencode-executor.ts` | Direct `fetch`, health polling, no command dedupe | Timeout and retry health/session/message calls; stable command id for prompts. |
+| LLM | `src/lib/llm.ts`, `src/actors/conversation/agent.ts`, `src/events/projectors/projection-agent.ts` | Direct SDK/fetch calls | Timeout, retry on provider transient errors, no retry on content/schema errors. |
+| Actor sends | routes, `src/events/route-to-user-actor.ts`, actors | `getOrCreate(...).method(...)`, queue sends | Standard command envelope with idempotency key and correlation ids. |
+| Redis consumer | `src/events/redis-consumer.ts` | Loops forever; canonical messages ack in `finally`; no DLQ | Retry budget, pending handling, DLQ stream/table, replay. |
+| Projectors | `src/events/projectors/*`, `src/actors/events/user-event-actor.ts` | Called within event actor processing | Per-projector idempotency and failure status; replay from stored Grow Events. |
+| Workflow module runner | `src/workflows/module-runner.ts`, `src/actors/workflow-run-actor.ts` | Actor loop retries in one path; direct route execution in another | Actor-only execution, durable command id, retry state in DB. |
+
+## Shared `withRetry` API
+
+Add `src/lib/retry.ts`:
+
+```ts
+export type RetryPolicy = {
+  maxAttempts: number;
+  baseDelayMs: number;
+  maxDelayMs: number;
+  timeoutMs: number;
+  jitter: boolean;
+};
+
+export async function withRetry<T>(
+  operation: string,
+  fn: (ctx: { signal: AbortSignal; attempt: number }) => Promise<T>,
+  options: {
+    policy?: Partial<RetryPolicy>;
+    idempotencyKey?: string;
+    classify?: (error: unknown) => "retry" | "fail";
+    logFields?: Record<string, unknown>;
+  },
+): Promise<T>;
+```
+
+Default policy:
+
+- `maxAttempts: 3`
+- `baseDelayMs: 250`
+- `maxDelayMs: 5_000`
+- `timeoutMs: 10_000`
+- jitter enabled
+
+Classification:
+
+- Retry: network errors, abort/timeout, HTTP `408`, `425`, `429`, `500`, `502`, `503`, `504`.
+- Do not retry: HTTP `400`, `401`, `403`, `404`, validation/schema errors, duplicate/idempotency conflicts that already completed.
+- Special case: `409` may be success for idempotent create-if-absent operations.
+
+## Idempotency Model
+
+Add a command/event idempotency key convention:
+
+```txt
+<domain>:<userId>:<entityId>:<operation>:<version>
+```
+
+Examples:
+
+- `workflow:user_123:run_456:module:resume:v1`
+- `mission:user_123:instance_456:start:v1`
+- `service:user_123:interview:configure:session_abc`
+- `event:user_123:growEventId:project:qscore:v1`
+- `opencode:user_123:run_456:interview-plan:prompt-v4`
+
+Where to store:
+
+- `workflowRunModules.idempotencyKey` for module commands.
+- `workflowEvents.payload.idempotencyKey` for audit trail.
+- `growEvents.dedupeKey` for event ingestion.
+- Add a future `idempotency_keys` table only if multiple domains need durable response reuse.
+
+Minimum table design if needed:
+
+```txt
+idempotency_keys
+  key text primary key
+  domain text not null
+  user_id text
+  status text check (processing, completed, failed)
+  request_hash text
+  response jsonb
+  error text
+  expires_at timestamptz
+  created_at timestamptz
+  updated_at timestamptz
+```
+
+## HTTP Service Client Plan
+
+Create `src/services/http-client.ts`:
+
+- Accepts `baseUrl`, `path`, `method`, `json`, `headers`, `idempotencyKey`, `operation`, `timeoutMs`.
+- Adds:
+  - `authorization: Bearer <A2A_ALLOWED_KEY>` when configured.
+  - `x-request-id`
+  - `x-idempotency-key` or `idempotency-key`.
+  - `x-growqr-user` when user-scoped.
+- Uses `withRetry`.
+- Parses text once and returns typed JSON.
+- Logs attempt, latency, status, and error class.
+
+Then migrate:
+
+1. `product-service-clients.ts`
+2. `service-agents.ts`
+3. mission route direct user-service fetch
+4. workflow service health checks
+
+## Workflow Retry Plan
+
+Target behavior:
+
+- Routes enqueue commands to `workflowRunActor`; routes do not call `executeWorkflowModule` directly.
+- `workflowRunActor` writes command state before execution.
+- `executeWorkflowModule` receives `idempotencyKey` and passes it to service/OpenCode calls.
+- On failure, increment `workflowRunModules.retryCount`, store `error`, and emit `workflowEvents` with `retryAttempt`.
+- Exceeding retry budget marks module `blocked` or `failed` based on module type and writes a DLQ row/event.
+
+Module status transition:
+
+```mermaid
+stateDiagram-v2
+  [*] --> idle
+  idle --> queued
+  queued --> running
+  running --> done
+  running --> retry_wait
+  retry_wait --> running
+  running --> blocked
+  running --> dlq
+  dlq --> replaying
+  replaying --> running
+```
+
+## Redis Consumer and DLQ Plan
+
+Do not ack canonical Redis messages until one of these is true:
+
+- event persisted and routed/projected successfully;
+- event persisted but routing failed and a durable retry record was created;
+- message moved to DLQ after retry budget.
+
+Add DLQ options:
+
+1. Redis stream DLQ: `grow.events.dlq`
+2. Postgres table: `grow_event_dlq`
+
+Recommended to use both:
+
+- Redis DLQ for operational stream tooling.
+- Postgres DLQ for admin UI, audit, and replay metadata.
+
+DLQ row fields:
+
+```txt
+id
+source_stream
+source_message_id
+payload
+error
+attempts
+last_attempt_at
+status: pending | replaying | replayed | discarded
+created_at
+updated_at
+```
+
+Replay script:
+
+```txt
+pnpm events:replay --status failed --limit 100
+pnpm events:replay --dlq --id <dlq-id>
+pnpm events:replay --event-id <grow-event-id> --projectors qscore,service-session
+```
+
+Script responsibilities:
+
+- Re-read stored payload.
+- Re-run `recordGrowEvent` if needed.
+- Re-run `routeGrowEventToUserActor`.
+- Optionally run only selected projectors.
+- Preserve original `dedupeKey`.
+
+## Projector Idempotency Plan
+
+Projectors should be repeatable:
+
+- Q Score latest table already has `(userId, signalId)` primary key.
+- Mission service sessions have unique `(serviceId, externalId)`.
+- Artifacts should dedupe by `(missionInstanceId, serviceId, externalId, type)` or a stable artifact key.
+- Mission stage patches should be applied with deterministic status/progress and no duplicate suggestions.
+
+Add projector event logs:
+
+```txt
+grow_event_projector_runs
+  event_id
+  projector
+  status
+  attempt
+  error
+  started_at
+  completed_at
+```
+
+## Logging Fields
+
+Every route/actor/event/retry log should include as many of these as available:
+
+- `requestId`
+- `traceId`
+- `userId`
+- `orgId`
+- `actorType`
+- `actorKey`
+- `runId`
+- `moduleId`
+- `missionId`
+- `missionInstanceId`
+- `stageId`
+- `eventId`
+- `source`
+- `eventType`
+- `idempotencyKey`
+- `operation`
+- `attempt`
+- `maxAttempts`
+- `latencyMs`
+- `httpStatus`
+- `retryable`
+- `dlqId`
+
+## Test Plan
+
+Unit tests:
+
+- `withRetry` retries transient errors and stops on non-retryable errors.
+- Timeout aborts fetch and logs retry attempt.
+- Idempotency key helper returns stable keys.
+- HTTP client adds auth, request id, and idempotency headers.
+
+Integration tests:
+
+- Duplicate `/workflow-runs/:runId/modules/:moduleId/run` command does not duplicate service call.
+- Duplicate Grow Event with same `dedupeKey` is stored once and projection remains stable.
+- Redis message failure is not acked until retry/DLQ path is recorded.
+- DLQ replay reprocesses a failed event and updates projector status.
+- OpenCode module execution retry does not create duplicate artifact rows.
+
+Manual staging drills:
+
+1. Stop interview service, run interview module, verify retry and blocked/DLQ behavior.
+2. Emit duplicate Redis events, verify one `grow_events` row and stable projector state.
+3. Break Gitea token, provision stack, verify retry logs and no partial untracked state.
+4. Replay a DLQ event, verify mission progress and Q Score update.
+
+## Implementation Order
+
+1. Add `src/lib/retry.ts` and focused unit tests.
+2. Add service HTTP client and migrate product service calls.
+3. Add workflow command idempotency and route-to-actor queueing.
+4. Add Redis DLQ and replay script.
+5. Add projector run records.
+6. Migrate Gitea/OpenCode/LLM calls to `withRetry`.
+7. Add staging failure drills to deployment checklist.

drizzle/0010_mission_actions.sql

@@ -0,0 +1,34 @@
+CREATE TABLE IF NOT EXISTS "mission_actions" (
+  "id" text PRIMARY KEY DEFAULT gen_random_uuid()::text NOT NULL,
+  "user_id" text NOT NULL REFERENCES "users"("id") ON DELETE cascade,
+  "mission_instance_id" text NOT NULL REFERENCES "grow_active_missions"("instance_id") ON DELETE cascade,
+  "mission_id" text NOT NULL,
+  "stage_id" text,
+  "agent_id" text NOT NULL,
+  "agent_name" text NOT NULL,
+  "base_agent" text,
+  "service_id" text,
+  "tool_name" text,
+  "mode" text NOT NULL,
+  "status" text DEFAULT 'queued' NOT NULL,
+  "title" text NOT NULL,
+  "body" text NOT NULL,
+  "prompt" text,
+  "payload" jsonb DEFAULT '{}'::jsonb NOT NULL,
+  "result" jsonb,
+  "error" text,
+  "source_event_id" text REFERENCES "grow_events"("id") ON DELETE set null,
+  "idempotency_key" text,
+  "priority" integer DEFAULT 0 NOT NULL,
+  "urgency" text DEFAULT 'calm' NOT NULL,
+  "due_at" timestamp with time zone,
+  "created_at" timestamp with time zone DEFAULT now() NOT NULL,
+  "updated_at" timestamp with time zone DEFAULT now() NOT NULL,
+  "resolved_at" timestamp with time zone
+);
+
+CREATE INDEX IF NOT EXISTS "mission_actions_mission_idx" ON "mission_actions" ("user_id", "mission_instance_id", "status", "priority");
+CREATE INDEX IF NOT EXISTS "mission_actions_user_idx" ON "mission_actions" ("user_id", "status", "updated_at");
+CREATE INDEX IF NOT EXISTS "mission_actions_source_idx" ON "mission_actions" ("source_event_id");
+CREATE INDEX IF NOT EXISTS "mission_actions_due_idx" ON "mission_actions" ("due_at");
+CREATE UNIQUE INDEX IF NOT EXISTS "mission_actions_idempotency_idx" ON "mission_actions" ("idempotency_key");

drizzle/0011_conversation_metadata.sql

@@ -0,0 +1 @@
+ALTER TABLE "grow_conversations" ADD COLUMN IF NOT EXISTS "metadata" jsonb;

drizzle/meta/_journal.json

@@ -71,6 +71,20 @@
       "when": 1780481400000,
       "tag": "0009_mission_suggestions",
       "breakpoints": true
+    },
+    {
+      "idx": 10,
+      "version": "7",
+      "when": 1780481500000,
+      "tag": "0010_mission_actions",
+      "breakpoints": true
+    },
+    {
+      "idx": 11,
+      "version": "7",
+      "when": 1780481600000,
+      "tag": "0011_conversation_metadata",
+      "breakpoints": true
     }
   ]
-}
+}

prompts/curator-v1.md

@@ -0,0 +1,24 @@
+# Curator V1 Conversation Prompt
+
+You are currently speaking as the GrowQR V1 Curator through the Conversation Actor.
+
+## Responsibilities
+- Own 30 day direction, streak continuity, and service handoff decisions.
+- Carry state from the conversation history and captured task memory.
+- If the user gives a short answer like a role name, accept it and ask for the next missing slot.
+
+## Guardrails
+- Do not ask the same question twice.
+- Do not output checklist items as separate baked chat messages.
+- Never say: What should I capture next.
+- Do not ask about another subtask, another mission, another service, or a later checklist item from this modal.
+- When the user has answered the focused subtask enough, summarize what was captured and stop.
+- If more detail is needed, ask exactly one follow-up question for the focused subtask only.
+- Use captured task memory from previous subtasks as context. Do not ask the user to repeat details already captured there.
+
+## Task Guidance
+- For target-role tasks, collect target role, current background, constraints, then offer a resume or interview handoff.
+- For service work, prepare preview-oriented handoffs once the focused subtask has enough context.
+- Interview preview defaults: type behavioral, difficulty medium, duration 5.
+- Roleplay preview should open the builder as the preview surface.
+- Keep the tone concise, warm, and practical.

prompts/curator/streak-chat.md

@@ -0,0 +1,28 @@
+# Curator Streak Chat Prompt
+
+You are the GrowQR V1 Curator in a daily or weekly streak chat modal.
+
+Your job is to move the user from a focused streak suggestion to a service preview CTA quickly. The dashboard renders the actual CTA card, so your chat text must never include internal URLs, route names, API paths, setup paths, JSON, or tool names.
+
+## Conversation Rules
+
+- Focus only on the clicked subtask.
+- Ask at most one clarifying question before a handoff is ready.
+- If the target role is known from onboarding, do not ask for it again.
+- If no target role is known and the service is interview or roleplay, ask exactly: `What role are you targeting?`
+- If the user gives a vague answer after one question, use your best guess and proceed.
+- When enough context exists, summarize the captured intent in one short sentence and stop.
+- Do not ask the next subtask question.
+- Do not mention setup screens, preview URLs, backend services, actors, tools, or route paths.
+- Use ASCII punctuation only.
+
+## Service Defaults
+
+- Interview defaults: `type=behavioral`, `difficulty=medium`, `duration=5`.
+- Roleplay defaults: custom scenario, `difficulty=medium`, `duration=5`.
+- Prefer onboarding-derived role when available.
+- If no role is available after the single follow-up, use `Product Manager` as the MVP fallback.
+
+## Tone
+
+Be concise, calm, and action-oriented. The user should feel like the preview is prepared, not like they are filling out a form.

prompts/system.txt

@@ -1,6 +1,6 @@
-You are the Grow Agent — a unified AI orchestrator for the GrowQR platform.
+You are Grow — a unified AI career assistant for the GrowQR platform.
 
-You coordinate sub-agent capabilities (loaded as tools), maintain durable state, and execute workflows through microservices.
+You coordinate specialist capabilities (loaded as tools), maintain durable state, and execute workflows through microservices.
 
 ## CRITICAL RULES
 
@@ -43,7 +43,7 @@ You coordinate sub-agent capabilities (loaded as tools), maintain durable state,
 - After resume optimization: ask what type of interview to prepare.
 - When they choose type → call start_interview_session.
 - Then offer roleplay → call start_roleplay_session when they confirm.
-- Then offer Q-Score → call compute_qscore.
+- Then offer Q Score → call compute_qscore.
 - Use [WORKFLOW: interview-to-offer] tag throughout.
 
 ## IMPORTANT: Tool Calling Anti-Patterns
@@ -66,16 +66,16 @@ Assistant: "I'll analyze your resume right away."
 User: "analyze my resume"
 Assistant calls analyze_resume → "Here's your analysis: [results]. Your strengths are..."
 
-## Sub-Agent Capabilities
+## Specialist Capabilities
 
 {{MODULE_DESCRIPTIONS}}
 
 ## Workflow Tags (put at the VERY END, on their own line)
 
 - [WORKFLOW: interview-to-offer] — full interview prep pipeline
-- [WORKFLOW: interview-practice] — interview sessions with the Interview Agent
+- [WORKFLOW: interview-practice] — mock interview sessions
 - [WORKFLOW: resume-boost] — resume analysis and optimization
-- [WORKFLOW: roleplay-practice] — roleplay sessions with Roleplay Agent  
+- [WORKFLOW: roleplay-practice] — mock roleplay sessions  
 - [WORKFLOW: career-switch] — career change navigation
 - [WORKFLOW: job-preparation] — broad company preparation
 

src/actors/analytics/analytics-actor.ts

@@ -0,0 +1,151 @@
+import { actor } from "rivetkit";
+import { count, desc, eq, sql } from "drizzle-orm";
+import { db } from "../../db/client.js";
+import {
+  growActiveMissions,
+  growEvents,
+  growQscoreLatest,
+  growQscoreProjectionState,
+  growQscoreSignals,
+  missionActions,
+} from "../../db/schema.js";
+import { listActiveMissionsPg } from "../../grow/persistence.js";
+import { listMissionActions } from "../../missions/actions.js";
+
+async function scalarCount(table: any, where?: any) {
+  const query = db.select({ value: count() }).from(table);
+  const rows = where ? await query.where(where) : await query;
+  return rows[0]?.value ?? 0;
+}
+
+async function platformAnalytics() {
+  const [
+    totalEvents,
+    serviceEvents,
+    missionEvents,
+    activeMissions,
+    completedMissions,
+    totalActions,
+    doneActions,
+    qscoreSignalCount,
+  ] = await Promise.all([
+    scalarCount(growEvents),
+    scalarCount(growEvents, eq(growEvents.category, "service")),
+    scalarCount(growEvents, eq(growEvents.category, "mission")),
+    scalarCount(growActiveMissions),
+    scalarCount(growActiveMissions, eq(growActiveMissions.status, "completed")),
+    scalarCount(missionActions),
+    scalarCount(missionActions, eq(missionActions.status, "done")),
+    scalarCount(growQscoreSignals),
+  ]);
+
+  const serviceUsage = await db
+    .select({
+      source: growEvents.source,
+      type: growEvents.type,
+      count: sql<number>`count(*)::int`,
+    })
+    .from(growEvents)
+    .where(eq(growEvents.category, "service"))
+    .groupBy(growEvents.source, growEvents.type)
+    .orderBy(sql`count(*) desc`)
+    .limit(20);
+
+  return {
+    kind: "platform",
+    generatedAt: new Date().toISOString(),
+    totals: {
+      events: totalEvents,
+      serviceEvents,
+      missionEvents,
+      activeMissions,
+      completedMissions,
+      missionActions: totalActions,
+      completedActions: doneActions,
+      qscoreSignals: qscoreSignalCount,
+    },
+    serviceUsage,
+  };
+}
+
+async function userQscoreAnalytics(userId: string) {
+  const [projection] = await db
+    .select()
+    .from(growQscoreProjectionState)
+    .where(eq(growQscoreProjectionState.userId, userId))
+    .limit(1);
+
+  const latestSignals = await db
+    .select()
+    .from(growQscoreLatest)
+    .where(eq(growQscoreLatest.userId, userId))
+    .orderBy(desc(growQscoreLatest.updatedAt))
+    .limit(50);
+
+  const signalTimeline = await db
+    .select()
+    .from(growQscoreSignals)
+    .where(eq(growQscoreSignals.userId, userId))
+    .orderBy(desc(growQscoreSignals.occurredAt))
+    .limit(100);
+
+  return {
+    kind: "user-qscore",
+    userId,
+    generatedAt: new Date().toISOString(),
+    current: projection
+      ? {
+          score: projection.score,
+          signalCount: projection.signalCount,
+          dimensions: projection.dimensions,
+          summary: projection.summary,
+          updatedAt: projection.updatedAt.toISOString(),
+        }
+      : null,
+    latestSignals,
+    signalTimeline,
+    globalComparison: {
+      status: "placeholder",
+      percentile: null,
+      cohort: null,
+      sampleSize: null,
+      note: "Global comparison is reserved for the cohort-backed analytics release.",
+    },
+  };
+}
+
+async function userActivityAnalytics(userId: string) {
+  const [events, activeMissions, actions] = await Promise.all([
+    db.select().from(growEvents).where(eq(growEvents.userId, userId)).orderBy(desc(growEvents.occurredAt)).limit(100),
+    listActiveMissionsPg(userId),
+    listMissionActions(userId, { openOnly: false }),
+  ]);
+
+  return {
+    kind: "user-activity",
+    userId,
+    generatedAt: new Date().toISOString(),
+    events,
+    activeMissions: activeMissions.map((item) => item.mission),
+    actions,
+  };
+}
+
+export const analyticsActor = actor({
+  options: { name: "Analytics Actor", icon: "chart-no-axes-column", noSleep: true },
+  state: { updatedAt: Date.now() },
+  actions: {
+    getPlatform: async (c) => {
+      c.state.updatedAt = Date.now();
+      return platformAnalytics();
+    },
+    getUserQscore: async (c, input: { userId: string }) => {
+      c.state.updatedAt = Date.now();
+      return userQscoreAnalytics(input.userId);
+    },
+    getUserActivity: async (c, input: { userId: string }) => {
+      c.state.updatedAt = Date.now();
+      return userActivityAnalytics(input.userId);
+    },
+  },
+});

src/actors/analytics/index.ts

@@ -0,0 +1 @@
+export { analyticsActor } from "./analytics-actor.js";

src/actors/conversation/agent.ts

@@ -1,13 +1,35 @@
 import { createOpenAI } from "@ai-sdk/openai";
-import { streamText, tool } from "ai";
+import { generateText, stepCountIs, streamText, tool } from "ai";
+import { createClient } from "rivetkit/client";
 import { z } from "zod";
 import type { ConversationMessage } from "./types.js";
 import { config } from "../../config.js";
+import { listMissionDefinitions } from "../../missions/registry.js";
+import { createMissionAction, listMissionActions } from "../../missions/actions.js";
+import { getActiveMissionPg, listActiveMissionsPg, listMissionSuggestionsPg } from "../../grow/persistence.js";
+import { listServiceCapabilities } from "../../workflows/service-capabilities.js";
+import { getSubAgentModules } from "../../lib/prompt-loader.js";
+import { buildMissionServiceRoute } from "../../services/service-registry.js";
 
 const SYSTEM_PROMPT = `You are the GrowQR conversation agent.
-Keep answers concise, practical, and focused on the user's goals.
-When you learn durable information, call the memory tools. For now these tools
-are intentionally stubbed so this actor can stay isolated and unwired.`;
+Keep answers concise, practical, and focused on the user's active mission.
+Use tools when you need mission state, registry capabilities, memory, or a service handoff.
+Service tools prepare handoffs and mission actions; the interview, roleplay, and resume services own their detailed flows.
+
+Style rules:
+- Use ASCII punctuation only. Do not use em dash or en dash.
+- Do not start with filler words like Perfect, Great, Absolutely, or Sure.
+- For Daily Mission turns, ask one short direct question. Keep it under 24 words.`;
+
+export type ConversationRuntimeContext = {
+  userId?: string;
+  conversationId?: string;
+  missionInstanceId?: string;
+  missionId?: string;
+  stageId?: string;
+  source?: string;
+  systemAddendum?: string;
+};
 
 function normalizeModel(model: string): string {
   if (config.llmProvider === "opencode" && model.startsWith("opencode/")) {
@@ -31,46 +53,206 @@ export function getConversationModel() {
   return conversationProvider.chat(normalizeModel(modelId));
 }
 
-export function buildModelMessages(messages: ConversationMessage[]) {
+type ModelConversationMessage = Pick<ConversationMessage, "role" | "content">;
+
+export function buildModelMessages(messages: ModelConversationMessage[]) {
   return messages.map((message) => ({
     role: message.role,
     content: message.content,
   }));
 }
 
-export function streamConversationResponse(messages: ConversationMessage[]) {
+let _client: any | null = null;
+function getRivetClient() {
+  return (_client ??= createClient<any>(config.rivetClientEndpoint));
+}
+
+function safeAgentRegistry() {
+  try {
+    return getSubAgentModules();
+  } catch {
+    return [
+      { id: "interview", name: "Interview Agent", role: "Interview Coach", service: "interview-service", description: "Interview prep specialist.", toolNames: ["prepare_interview_handoff"] },
+      { id: "roleplay", name: "Roleplay Agent", role: "Roleplay Coach", service: "roleplay-service", description: "Workplace conversation practice specialist.", toolNames: ["prepare_roleplay_handoff"] },
+      { id: "resume", name: "Resume Agent", role: "Resume Agent", service: "resume-service", description: "Resume positioning and optimization specialist.", toolNames: ["prepare_resume_handoff"] },
+      { id: "qscore", name: "Q Score Agent", role: "Q Score Analyst", service: "qscore-service", description: "Readiness score analyst.", toolNames: ["explain_qscore"] },
+    ];
+  }
+}
+
+async function resolveMission(userId: string, missionInstanceId?: string) {
+  if (missionInstanceId) return getActiveMissionPg(userId, missionInstanceId);
+  const active = await listActiveMissionsPg(userId);
+  return active[0] ?? null;
+}
+
+function serviceHref(input: {
+  serviceId: "interview-service" | "roleplay-service" | "resume-service";
+  missionInstanceId: string;
+  missionId: string;
+  stageId?: string;
+  goal?: string;
+}) {
+  return buildMissionServiceRoute(input);
+}
+
+function buildConversationTools(ctx: ConversationRuntimeContext = {}) {
+  const userId = ctx.userId;
+  return {
+    listMissionState: tool({
+      description: "Read mission snapshot, open actions, and suggestions for the current or requested mission.",
+      inputSchema: z.object({ missionInstanceId: z.string().optional() }),
+      execute: async ({ missionInstanceId }) => {
+        if (!userId) return { error: "missing_user_context" };
+        const active = await resolveMission(userId, missionInstanceId ?? ctx.missionInstanceId);
+        if (!active) return { mission: null, actions: [], suggestions: [] };
+        return {
+          mission: active.mission,
+          snapshot: active.snapshot,
+          actions: await listMissionActions(userId, { missionInstanceId: active.mission.instanceId }),
+          suggestions: await listMissionSuggestionsPg(userId, active.mission.instanceId),
+        };
+      },
+    }),
+
+    listRegistryCapabilities: tool({
+      description: "List deterministic registry missions, service capabilities, and specialist agents. This does not rank or generate missions.",
+      inputSchema: z.object({}),
+      execute: async () => ({
+        missions: listMissionDefinitions().map((mission) => ({
+          id: mission.id,
+          missionId: mission.missionId,
+          title: mission.title,
+          shortTitle: mission.shortTitle,
+          actorBacked: mission.actorBacked,
+          modules: mission.modules.map((module) => ({
+            id: module.id,
+            title: module.title,
+            role: module.role,
+            service: module.service,
+          })),
+        })),
+        services: listServiceCapabilities(),
+        agents: safeAgentRegistry(),
+      }),
+    }),
+
+    prepareServiceHandoff: tool({
+      description: "Prepare an interview, roleplay, or resume handoff as a mission action and return the UI route. Do not directly complete the service.",
+      inputSchema: z.object({
+        serviceId: z.enum(["interview-service", "roleplay-service", "resume-service"]),
+        missionInstanceId: z.string().optional(),
+        stageId: z.string().optional(),
+        title: z.string().optional(),
+        body: z.string().optional(),
+        goal: z.string().optional(),
+      }),
+      execute: async ({ serviceId, missionInstanceId, stageId, title, body, goal }) => {
+        if (!userId) return { error: "missing_user_context" };
+        const active = await resolveMission(userId, missionInstanceId ?? ctx.missionInstanceId);
+        if (!active) return { error: "mission_not_found" };
+        const selectedStageId = stageId ?? ctx.stageId ?? active.mission.currentStageId;
+        const href = serviceHref({
+          serviceId,
+          missionInstanceId: active.mission.instanceId,
+          missionId: active.mission.missionId,
+          stageId: selectedStageId,
+          goal: goal ?? active.mission.goal,
+        });
+        const agent = safeAgentRegistry().find((item) => item.service === serviceId);
+        const action = await createMissionAction({
+          userId,
+          missionInstanceId: active.mission.instanceId,
+          missionId: active.mission.missionId,
+          stageId: selectedStageId,
+          agentId: agent?.id ?? serviceId,
+          agentName: agent?.name ?? serviceId,
+          baseAgent: agent?.role,
+          serviceId,
+          toolName: `prepare_${serviceId.replace("-service", "")}_handoff`,
+          mode: "suggestion",
+          status: "queued",
+          title: title ?? `Open ${agent?.name ?? serviceId}`,
+          body: body ?? `Continue this mission in ${agent?.name ?? serviceId}.`,
+          prompt: goal ?? active.mission.goal,
+          payload: { href, goal: goal ?? active.mission.goal, source: "conversation-actor" },
+          idempotencyKey: `conversation-handoff:${active.mission.instanceId}:${selectedStageId ?? "mission"}:${serviceId}`,
+          priority: 25,
+          urgency: "today",
+        });
+        return { action, href, serviceId, missionInstanceId: active.mission.instanceId };
+      },
+    }),
+
+    askSubAgent: tool({
+      description: "Ask a specialist sub-agent for a focused answer without starting a service session.",
+      inputSchema: z.object({
+        agentId: z.enum(["interview", "roleplay", "resume", "qscore"]),
+        question: z.string(),
+        context: z.string().optional(),
+      }),
+      execute: async ({ agentId, question, context }) => {
+        const agent = safeAgentRegistry().find((item) => item.id === agentId);
+        const answer = await generateText({
+          model: getConversationModel(),
+          system: `You are ${agent?.name ?? agentId}, a GrowQR specialist. Be concise and practical. Do not start external tools.`,
+          prompt: `Question:\n${question}\n\nContext:\n${context ?? "No extra context."}`,
+        });
+        return { agent, answerMd: answer.text };
+      },
+    }),
+
+    readMemory: tool({
+      description: "Read a markdown memory file for this user.",
+      inputSchema: z.object({ path: z.string() }),
+      execute: async ({ path }) => {
+        if (!userId) return { error: "missing_user_context" };
+        return { memory: await getRivetClient().memoryActor.getOrCreate([userId]).read(path) };
+      },
+    }),
+
+    writeMemory: tool({
+      description: "Write a durable markdown memory file for this user.",
+      inputSchema: z.object({
+        path: z.string(),
+        contentMd: z.string(),
+        tags: z.array(z.string()).optional(),
+      }),
+      execute: async ({ path, contentMd, tags }) => {
+        if (!userId) return { error: "missing_user_context" };
+        const result = await getRivetClient().memoryActor.getOrCreate([userId]).write({ path, contentMd, tags });
+        return { path, queued: result.queued };
+      },
+    }),
+  };
+}
+
+export function streamConversationResponse(messages: ModelConversationMessage[], context: ConversationRuntimeContext = {}) {
+  const system = [SYSTEM_PROMPT, context.systemAddendum].filter(Boolean).join("\n\n");
+  if (context.source === "daily-mission-start") {
+    return streamText({
+      model: getConversationModel(),
+      system,
+      messages: buildModelMessages(messages),
+    });
+  }
+
   return streamText({
     model: getConversationModel(),
-    system: SYSTEM_PROMPT,
+    system,
     messages: buildModelMessages(messages),
-    tools: {
-      readMemory: tool({
-        description: "Read a markdown memory file. Stubbed until memoryActor is wired.",
-        inputSchema: z.object({
-          path: z.string().describe("Memory path, e.g. /profile.md"),
-        }),
-        execute: async ({ path }) => ({
-          path,
-          found: false,
-          content: "",
-          note: "memoryActor is not wired yet",
-        }),
-      }),
-      writeMemory: tool({
-        description: "Write a markdown memory file. Stubbed until memoryActor is wired.",
-        inputSchema: z.object({
-          path: z.string(),
-          contentMd: z.string(),
-          reason: z.string().optional(),
-        }),
-        execute: async ({ path, contentMd, reason }) => ({
-          path,
-          bytes: contentMd.length,
-          reason,
-          saved: false,
-          note: "memoryActor is not wired yet",
-        }),
-      }),
-    },
+    tools: buildConversationTools(context),
+    stopWhen: stepCountIs(5),
+  });
+}
+
+export async function generateConversationResponse(messages: ModelConversationMessage[], context: ConversationRuntimeContext = {}) {
+  const system = [SYSTEM_PROMPT, context.systemAddendum].filter(Boolean).join("\n\n");
+  return generateText({
+    model: getConversationModel(),
+    system,
+    messages: buildModelMessages(messages),
+    tools: buildConversationTools(context),
+    stopWhen: stepCountIs(5),
   });
 }

src/actors/conversation/conversation-actor.ts

@@ -25,6 +25,10 @@ function conversationIdFromKey(key: unknown[]) {
   return String(key[1] ?? key[0] ?? "default");
 }
 
+function userIdFromKey(key: unknown[]) {
+  return String(key[0] ?? "");
+}
+
 function toPublicMessage(row: typeof conversationMessages.$inferSelect): ConversationMessage {
   return {
     id: row.id,
@@ -118,7 +122,14 @@ export const conversationActor = actor({
       c.broadcast("status", c.state.status);
 
       try {
-        const result = streamConversationResponse(history);
+        const result = streamConversationResponse(history, {
+          userId: body.context?.userId ?? userIdFromKey(c.key),
+          conversationId,
+          missionInstanceId: body.context?.missionInstanceId,
+          missionId: body.context?.missionId,
+          stageId: body.context?.stageId,
+          source: body.context?.source,
+        });
 
         let content = "";
         for await (const delta of result.textStream) {

src/actors/conversation/types.ts

@@ -18,6 +18,14 @@ export type ConversationMessage = {
 export type ConversationQueueMessage = {
   text: string;
   sender?: string;
+  context?: {
+    userId?: string;
+    conversationId?: string;
+    missionInstanceId?: string;
+    missionId?: string;
+    stageId?: string;
+    source?: string;
+  };
 };
 
 export type ConversationResponseEvent = {

src/actors/events/user-event-actor.ts

@@ -11,6 +11,7 @@ import { getProjectionInsight } from "../../events/projectors/projection-agent.j
 import { markGrowEventFailed, markGrowEventProcessed, markGrowEventProcessing } from "../../events/record-grow-event.js";
 import { reducersForMission } from "../../missions/event-reducers.js";
 import type { MissionArtifactPatch, MissionStagePatch } from "../../missions/reducer-types.js";
+import { createMissionActionsFromPatches } from "../../missions/actions.js";
 
 export type UserEventCommand = {
   userId: string;
@@ -165,20 +166,21 @@ export const userEventActor = actor({
           const client = loopCtx.client<any>();
           for (const active of activeRows) {
             const mission = active.mission;
+            const actorHandle = missionActorHandle(client, cmd.userId, mission);
+            if (!actorHandle) continue;
+            await actorHandle.ingestEvent({ eventId: row.id }).catch(() => undefined);
+
             const reducers = reducersForMission(mission.missionId);
             if (!reducers.length) continue;
             for (const reducer of reducers) {
               const reduceCtx = { userId: cmd.userId, activeMission: mission, event: row, qscoreSignals: qscoreResult.signals, insight };
               if (!reducer.accepts(reduceCtx)) continue;
               const reduction = reducer.reduce(reduceCtx);
-              if (!reduction.stagePatches.length && !reduction.artifacts.length && !reduction.eventMessage) continue;
-
-              const actorHandle = missionActorHandle(client, cmd.userId, mission);
-              if (!actorHandle) continue;
+              if (!reduction.stagePatches.length && !reduction.artifacts.length && !reduction.actions.length && !reduction.eventMessage) continue;
               if (reduction.eventMessage) {
                 await actorHandle.recordEvent({ type: row.type, message: reduction.eventMessage, payload: { sourceEventId: row.id } });
               }
-              let snapshot: MissionSnapshot | undefined = reduction.stagePatches.length ? (await applyStagePatches(actorHandle, reduction.stagePatches) ?? undefined) : undefined;
+              if (reduction.stagePatches.length) await applyStagePatches(actorHandle, reduction.stagePatches);
               await applyArtifactPatches({
                 actorHandle,
                 userId: cmd.userId,
@@ -188,6 +190,14 @@ export const userEventActor = actor({
                 externalId: typeof row.correlation?.sessionId === "string" ? row.correlation.sessionId : undefined,
                 patches: reduction.artifacts,
               });
+              if (reduction.actions.length) {
+                await createMissionActionsFromPatches({
+                  userId: cmd.userId,
+                  mission,
+                  eventId: row.id,
+                  patches: reduction.actions,
+                });
+              }
               const finalSnapshot = (await actorHandle.getState()) as MissionSnapshot;
               await upsertActiveMissionPg(cmd.userId, summarizeMissionSnapshot(finalSnapshot), finalSnapshot);
             }

src/actors/missions/interview-to-offer-actor.ts

@@ -160,6 +160,66 @@ export const interviewToOfferMissionActor = actor({
       return entry;
     },
 
+    ingestEvent: (c, input: { eventId: string }) => {
+      ensureInitialized(c.state);
+      const entry: MissionEvent = {
+        id: eventId(),
+        type: "mission.event_ingested",
+        message: `Event ${input.eventId} ingested by mission runtime.`,
+        payload: { eventId: input.eventId },
+        createdAt: nowIso(),
+      };
+      c.state.events.unshift(entry);
+      c.state.updatedAt = entry.createdAt;
+      c.broadcast("eventAdded", entry);
+      c.broadcast("updated", c.state);
+      return c.state;
+    },
+
+    planNextActions: (c, input: { reason?: string } = {}) => {
+      ensureInitialized(c.state);
+      const active = c.state.stages.find((stage) => stage.status === "ready" || stage.status === "in_progress" || stage.status === "blocked");
+      return {
+        missionInstanceId: c.state.instanceId,
+        missionId: c.state.missionId,
+        currentStageId: active?.id,
+        reason: input.reason ?? "manual",
+        recommendation: active ? `Focus next on ${active.title}.` : "No open stage requires action right now.",
+      };
+    },
+
+    runDailyScrum: (c, input: { trigger?: "manual" | "nightly" } = {}) => {
+      ensureInitialized(c.state);
+      const active = c.state.stages.find((stage) => stage.status === "ready" || stage.status === "in_progress" || stage.status === "blocked");
+      const entry: MissionEvent = {
+        id: eventId(),
+        type: "mission.daily_scrum.completed",
+        message: active ? `Daily scrum: next focus is ${active.title}.` : "Daily scrum: mission has no blocked action right now.",
+        payload: { trigger: input.trigger ?? "manual", currentStageId: active?.id },
+        createdAt: nowIso(),
+      };
+      c.state.events.unshift(entry);
+      c.state.updatedAt = entry.createdAt;
+      c.broadcast("eventAdded", entry);
+      c.broadcast("updated", c.state);
+      return { snapshot: c.state, summary: entry.message };
+    },
+
+    queueAction: (c, input: { actionId: string; title?: string }) => {
+      ensureInitialized(c.state);
+      return { queued: true, actionId: input.actionId, missionInstanceId: c.state.instanceId, title: input.title };
+    },
+
+    runAction: (c, input: { actionId: string }) => {
+      ensureInitialized(c.state);
+      return { started: true, actionId: input.actionId, missionInstanceId: c.state.instanceId };
+    },
+
+    resolveHitl: (c, input: { actionId: string; resolution: string; input?: Record<string, unknown> }) => {
+      ensureInitialized(c.state);
+      return { resolved: true, actionId: input.actionId, resolution: input.resolution, missionInstanceId: c.state.instanceId };
+    },
+
     updateStage: (c, input: { stageId: string; status?: MissionStage["status"]; progressPercent?: number; outputSummary?: string }) => {
       ensureInitialized(c.state);
       const stage = c.state.stages.find((item) => item.id === input.stageId);

src/actors/missions/mission-actor-factory.ts

@@ -166,6 +166,67 @@ export function createMissionActor(options: {
         return entry;
       },
 
+      ingestEvent: (c, input: { eventId: string }) => {
+        ensureInitialized(c.state);
+        const entry: MissionEvent = {
+          id: eventId(),
+          type: "mission.event_ingested",
+          message: `Event ${input.eventId} ingested by mission runtime.`,
+          payload: { eventId: input.eventId },
+          createdAt: nowIso(),
+        };
+        c.state.events.unshift(entry);
+        c.state.updatedAt = entry.createdAt;
+        c.broadcast("eventAdded", entry);
+        c.broadcast("updated", c.state);
+        return c.state;
+      },
+
+      planNextActions: (c, input: { reason?: string } = {}) => {
+        ensureInitialized(c.state);
+        const blocked = c.state.stages.find((stage) => stage.status === "blocked");
+        const active = blocked ?? c.state.stages.find((stage) => stage.status === "ready" || stage.status === "in_progress");
+        return {
+          missionInstanceId: c.state.instanceId,
+          missionId: c.state.missionId,
+          currentStageId: active?.id,
+          reason: input.reason ?? "manual",
+          recommendation: active ? `Focus next on ${active.title}.` : "No open stage requires action right now.",
+        };
+      },
+
+      runDailyScrum: (c, input: { trigger?: "manual" | "nightly" } = {}) => {
+        ensureInitialized(c.state);
+        const recommendation = c.state.stages.find((stage) => stage.status === "ready" || stage.status === "in_progress" || stage.status === "blocked");
+        const entry: MissionEvent = {
+          id: eventId(),
+          type: "mission.daily_scrum.completed",
+          message: recommendation ? `Daily scrum: next focus is ${recommendation.title}.` : "Daily scrum: mission has no blocked action right now.",
+          payload: { trigger: input.trigger ?? "manual", currentStageId: recommendation?.id },
+          createdAt: nowIso(),
+        };
+        c.state.events.unshift(entry);
+        c.state.updatedAt = entry.createdAt;
+        c.broadcast("eventAdded", entry);
+        c.broadcast("updated", c.state);
+        return { snapshot: c.state, summary: entry.message };
+      },
+
+      queueAction: (c, input: { actionId: string; title?: string }) => {
+        ensureInitialized(c.state);
+        return { queued: true, actionId: input.actionId, missionInstanceId: c.state.instanceId, title: input.title };
+      },
+
+      runAction: (c, input: { actionId: string }) => {
+        ensureInitialized(c.state);
+        return { started: true, actionId: input.actionId, missionInstanceId: c.state.instanceId };
+      },
+
+      resolveHitl: (c, input: { actionId: string; resolution: string; input?: Record<string, unknown> }) => {
+        ensureInitialized(c.state);
+        return { resolved: true, actionId: input.actionId, resolution: input.resolution, missionInstanceId: c.state.instanceId };
+      },
+
       updateStage: (c, input: { stageId: string; status?: MissionStage["status"]; progressPercent?: number; outputSummary?: string }) => {
         ensureInitialized(c.state);
         const stage = c.state.stages.find((item) => item.id === input.stageId);

src/actors/registry.ts

@@ -6,6 +6,7 @@ import { conversationActor } from "./conversation/index.js";
 import { memoryActor } from "./memory/index.js";
 import { growActor } from "./grow/index.js";
 import { userEventActor } from "./events/index.js";
+import { analyticsActor } from "./analytics/index.js";
 import {
   careerTransitionMissionActor,
   interviewToOfferMissionActor,
@@ -18,6 +19,7 @@ export const registry = setup({
   use: {
     growActor,
     userEventActor,
+    analyticsActor,
     conversationActor,
     memoryActor,
     interviewToOfferMissionActor,

src/actors/user-actor.ts

@@ -189,7 +189,7 @@ function buildUnifiedTools(): Array<{
       type: "function" as const,
       function: {
         name: "start_interview_session",
-        description: "Create a real interview practice session via the Interview Agent / interview-service microservice.",
+        description: "Create a real mock interview session via the interview-service microservice.",
         parameters: {
           type: "object",
           properties: { goal: { type: "string" } },
@@ -201,7 +201,7 @@ function buildUnifiedTools(): Array<{
       type: "function" as const,
       function: {
         name: "start_roleplay_session",
-        description: "Create a real roleplay practice session via the Roleplay Agent / roleplay-service microservice.",
+        description: "Create a real mock roleplay session via the roleplay-service microservice.",
         parameters: {
           type: "object",
           properties: { goal: { type: "string" } },
@@ -213,7 +213,7 @@ function buildUnifiedTools(): Array<{
       type: "function" as const,
       function: {
         name: "compute_qscore",
-        description: "Compute or refresh the user's Q-Score via the Q Score Agent / qscore-service microservice.",
+        description: "Compute or refresh the user's Q Score via the qscore-service microservice.",
         parameters: {
           type: "object",
           properties: {},
@@ -225,7 +225,7 @@ function buildUnifiedTools(): Array<{
       type: "function" as const,
       function: {
         name: "analyze_resume",
-        description: "Analyze the user's resume using the Resume Agent microservice. Returns completeness score, skill gaps, and optimization recommendations.",
+        description: "Analyze the user's resume using the Resume Building microservice. Returns completeness score, skill gaps, and optimization recommendations.",
         parameters: {
           type: "object",
           properties: {
@@ -253,7 +253,7 @@ function buildUnifiedTools(): Array<{
       type: "function" as const,
       function: {
         name: "start_interview_to_offer",
-        description: "Start the Interview-to-Offer Accelerator workflow. This is a guided end-to-end pipeline: (1) Analyze & tailor resume for the role, (2) Create interview practice session with the Interview Agent, (3) Create roleplay session with Roleplay Agent, (4) Compute Q-Score readiness. Use this when the user has a specific interview scheduled and wants comprehensive preparation.",
+        description: "Start the Interview-to-Offer Accelerator workflow. This is a guided end-to-end pipeline: (1) Analyze and tailor the resume for the role, (2) Create mock interview practice, (3) Create mock roleplay practice, (4) Compute Q Score readiness. Use this when the user has a specific interview scheduled and wants comprehensive preparation.",
         parameters: {
           type: "object",
           properties: {
@@ -563,7 +563,7 @@ export const userActor = actor({
 
       appendTimelineEvent(
         c.state,
-        { id: "grow", name: "Grow Agent" },
+        { id: "grow", name: "Grow" },
         "workflow",
         `${getWorkflowDefinition(workflowId)?.title ?? "Workflow"} started.`,
       );
@@ -581,14 +581,14 @@ export const userActor = actor({
 
     pauseWorkflow: async (c) => {
       c.state.workflowStatus = "paused";
-      appendTimelineEvent(c.state, { id: "grow", name: "Grow Agent" }, "workflow", "Workflow paused.");
+      appendTimelineEvent(c.state, { id: "grow", name: "Grow" }, "workflow", "Workflow paused.");
       c.broadcast("workflow.updated", workflowSnapshot(c.state));
       return c.state;
     },
 
     resumeWorkflow: async (c) => {
       c.state.workflowStatus = "running";
-      appendTimelineEvent(c.state, { id: "grow", name: "Grow Agent" }, "workflow", "Workflow resumed.");
+      appendTimelineEvent(c.state, { id: "grow", name: "Grow" }, "workflow", "Workflow resumed.");
       c.broadcast("workflow.updated", workflowSnapshot(c.state));
       return c.state;
     },
@@ -753,7 +753,7 @@ async function dispatchUnifiedTool(
       c.state.modules = makeModules();
       c.state.createdAt = now();
       c.state.updatedAt = now();
-      appendTimelineEvent(c.state, { id: "grow", name: "Grow Agent" }, "workflow", "Workflow started via LLM tool.");
+      appendTimelineEvent(c.state, { id: "grow", name: "Grow" }, "workflow", "Workflow started via LLM tool.");
       c.broadcast("workflow.updated", workflowSnapshot(c.state));
       return { ok: true, workflowId: c.state.workflowId, goal };
     }
@@ -799,7 +799,7 @@ async function dispatchUnifiedTool(
     case "start_roleplay_session": {
       const goal = String(input.goal ?? "");
       const roleplayModule = getSubAgentModule("roleplay");
-      if (!roleplayModule?.service) return { ok: false, error: "Roleplay Agent module not available" };
+      if (!roleplayModule?.service) return { ok: false, error: "Mock Roleplay module not available" };
       const result = await runServiceAgentProbe(
         { id: roleplayModule.id, name: roleplayModule.name, role: roleplayModule.role, kind: "microservice", description: roleplayModule.description, service: roleplayModule.service },
         { userId, goal },
@@ -855,14 +855,14 @@ async function dispatchUnifiedTool(
       c.state.createdAt = now();
       c.state.updatedAt = now();
 
-      appendTimelineEvent(c.state, { id: "grow", name: "Grow Agent" }, "workflow", `Interview-to-Offer workflow started for: ${goal}`);
+      appendTimelineEvent(c.state, { id: "grow", name: "Grow" }, "workflow", `Interview-to-Offer workflow started for: ${goal}`);
 
-      // Step 1: Resume Agent — analyze and tailor
+      // Step 1: Resume Building — analyze and tailor
       const resumeModule = getSubAgentModule("resume");
       const resumeMod = c.state.modules.find(m => m.id === "resume");
       if (resumeMod && resumeModule) {
         resumeMod.status = "running";
-        appendTimelineEvent(c.state, resumeMod, "module", "Resume Agent analyzing your profile...");
+        appendTimelineEvent(c.state, resumeMod, "module", "Resume Building is analyzing your profile...");
         c.broadcast("workflow.updated", workflowSnapshot(c.state));
 
         try {
@@ -875,18 +875,18 @@ async function dispatchUnifiedTool(
           appendTimelineEvent(c.state, resumeMod, "module", resumeResult.summary);
         } catch (err) {
           resumeMod.status = "blocked";
-          appendTimelineEvent(c.state, resumeMod, "module", `Resume Agent failed: ${err instanceof Error ? err.message : String(err)}`);
+          appendTimelineEvent(c.state, resumeMod, "module", `Resume Building failed: ${err instanceof Error ? err.message : String(err)}`);
         }
       }
 
       c.broadcast("workflow.updated", workflowSnapshot(c.state));
 
-      // Step 2: Interview Agent — create interview session
+      // Step 2: Mock Interview — create interview session
       const interviewModule = getSubAgentModule("interview");
       const interviewMod = c.state.modules.find(m => m.id === "interview");
       if (interviewMod && interviewModule?.service) {
         interviewMod.status = "running";
-        appendTimelineEvent(c.state, interviewMod, "module", "Interview Agent creating interview practice session...");
+        appendTimelineEvent(c.state, interviewMod, "module", "Mock Interview is creating an interview practice session...");
         c.broadcast("workflow.updated", workflowSnapshot(c.state));
 
         try {
@@ -905,12 +905,12 @@ async function dispatchUnifiedTool(
 
       c.broadcast("workflow.updated", workflowSnapshot(c.state));
 
-      // Step 3: Roleplay Agent — create roleplay session
+      // Step 3: Mock Roleplay — create roleplay session
       const roleplayModule = getSubAgentModule("roleplay");
       const roleplayMod = c.state.modules.find(m => m.id === "roleplay");
       if (roleplayMod && roleplayModule?.service) {
         roleplayMod.status = "running";
-        appendTimelineEvent(c.state, roleplayMod, "module", "Roleplay Agent creating roleplay scenario...");
+        appendTimelineEvent(c.state, roleplayMod, "module", "Mock Roleplay is creating a practice scenario...");
         c.broadcast("workflow.updated", workflowSnapshot(c.state));
 
         try {
@@ -923,18 +923,18 @@ async function dispatchUnifiedTool(
           appendTimelineEvent(c.state, roleplayMod, "module", roleplayResult.summary);
         } catch (err) {
           roleplayMod.status = "blocked";
-          appendTimelineEvent(c.state, roleplayMod, "module", `Roleplay Agent session failed: ${err instanceof Error ? err.message : String(err)}`);
+          appendTimelineEvent(c.state, roleplayMod, "module", `Mock Roleplay session failed: ${err instanceof Error ? err.message : String(err)}`);
         }
       }
 
       c.broadcast("workflow.updated", workflowSnapshot(c.state));
 
-      // Step 4: Q Score Agent — compute Q-Score
+      // Step 4: Q Score — compute readiness
       const qscoreModule = getSubAgentModule("qscore");
       const qscoreMod = c.state.modules.find(m => m.id === "qscore");
       if (qscoreMod && qscoreModule?.service) {
         qscoreMod.status = "running";
-        appendTimelineEvent(c.state, qscoreMod, "module", "Q Score Agent computing your readiness Q-Score...");
+        appendTimelineEvent(c.state, qscoreMod, "module", "Q Score is computing your readiness score...");
         c.broadcast("workflow.updated", workflowSnapshot(c.state));
 
         try {
@@ -947,7 +947,7 @@ async function dispatchUnifiedTool(
           appendTimelineEvent(c.state, qscoreMod, "module", qscoreResult.summary);
         } catch (err) {
           qscoreMod.status = "blocked";
-          appendTimelineEvent(c.state, qscoreMod, "module", `Q-Score computation failed: ${err instanceof Error ? err.message : String(err)}`);
+          appendTimelineEvent(c.state, qscoreMod, "module", `Q Score computation failed: ${err instanceof Error ? err.message : String(err)}`);
         }
       }
 

src/agents/catalog.ts

@@ -45,7 +45,7 @@ export function jobApplicationModuleIds(): string[] {
   return loaderJobApplicationModuleIds();
 }
 
-// Build the unified Grow Agent system prompt from disk (changes.md §3).
+// Build the unified Grow system prompt from disk (changes.md §3).
 export function buildUnifiedSystemPrompt(): string {
   return getUnifiedSystemPrompt();
 }

src/agents/daily-mission.ts

@@ -0,0 +1,449 @@
+import { generateText } from "ai";
+import { z } from "zod";
+import { getConversationModel, streamConversationResponse } from "../actors/conversation/agent.js";
+
+export const dailyMissionTaskSchema = z.object({
+  day: z.number().optional(),
+  questId: z.string().optional(),
+  questTitle: z.string(),
+  subtaskIndex: z.number().optional(),
+  subtask: z.string(),
+  service: z.string().optional(),
+  route: z.string().optional(),
+  intro: z.string().optional(),
+  context: z.array(z.object({ label: z.string(), value: z.string() })).optional(),
+  signals: z.array(z.string()).optional(),
+});
+
+export const dailyMissionMessageSchema = z.object({
+  role: z.enum(["user", "assistant"]),
+  content: z.string().min(1).max(4000),
+});
+
+export type DailyMissionTask = z.infer<typeof dailyMissionTaskSchema>;
+export type DailyMissionMessage = z.infer<typeof dailyMissionMessageSchema>;
+
+const dailyMissionResponseSchema = z.object({
+  reply: z.string(),
+  completed: z.boolean().default(false),
+  updateSummary: z.string().optional(),
+  actionLabel: z.string().optional(),
+  actionRoute: z.string().optional(),
+});
+
+export type DailyMissionResult = z.infer<typeof dailyMissionResponseSchema>;
+
+type DailyMissionAgentInput = {
+  userId: string;
+  task: DailyMissionTask;
+  messages: DailyMissionMessage[];
+  missionInstanceId?: string;
+  missionId?: string;
+  stageId?: string;
+  conversationId?: string;
+};
+
+function stripJsonFence(text: string) {
+  return text
+    .trim()
+    .replace(/^```(?:json)?\s*/i, "")
+    .replace(/\s*```$/i, "")
+    .trim();
+}
+
+function parseDailyMissionResponse(text: string) {
+  const normalize = (value: z.infer<typeof dailyMissionResponseSchema>) => {
+    const nested = maybeParseJsonReply(value.reply);
+    return nested ? { ...value, ...nested } : value;
+  };
+
+  try {
+    return normalize(dailyMissionResponseSchema.parse(JSON.parse(stripJsonFence(text))));
+  } catch {
+    return {
+      reply: cleanAssistantReply(text) || "I could not prepare the next step. Try again.",
+      completed: false,
+      updateSummary: undefined,
+      actionLabel: undefined,
+      actionRoute: undefined,
+    };
+  }
+}
+
+function maybeParseJsonReply(text: string) {
+  try {
+    return dailyMissionResponseSchema.partial().parse(JSON.parse(stripJsonFence(text)));
+  } catch {
+    return undefined;
+  }
+}
+
+function cleanAssistantReply(text: string) {
+  const stripped = stripJsonFence(text);
+  const nested = maybeParseJsonReply(stripped);
+  if (nested?.reply) return nested.reply;
+  const match = stripped.match(/^\s*\{[\s\S]*"reply"\s*:\s*"([\s\S]*?)"[\s\S]*\}\s*$/);
+  const captured = match?.[1];
+  if (!captured) return stripped.trim();
+  try {
+    return JSON.parse(`"${captured}"`);
+  } catch {
+    return captured.replace(/\\"/g, '"').replace(/\\u2011/g, "-").trim();
+  }
+}
+
+function isInterviewMission(task: DailyMissionTask) {
+  const service = (task.service ?? "").toLowerCase();
+  const routePath = task.route ? new URL(task.route, "https://growqr.local").pathname.toLowerCase() : "";
+  const text = [task.questTitle, task.subtask].filter(Boolean).join(" ").toLowerCase();
+  if (service.includes("resume") || routePath.includes("/agents/resume")) return false;
+  if (service.includes("roleplay") || routePath.includes("/agents/roleplay")) return false;
+  if (service.includes("q score") || service.includes("qscore") || routePath.includes("/agents/qscore")) return false;
+  return service.includes("interview") || routePath.includes("/agents/interview") || text.includes("mock question");
+}
+
+function getInterviewActionRoute(task: DailyMissionTask) {
+  const source = new URL(task.route ?? "/agents/interview", "https://growqr.local");
+  const roleFromContext = task.context?.find((item) => item.label.toLowerCase().includes("role"))?.value;
+  const params = new URLSearchParams();
+  params.set("role", source.searchParams.get("role") ?? roleFromContext ?? "Product Manager");
+  params.set("type", source.searchParams.get("type") ?? "behavioral");
+  params.set("persona", "payal");
+  params.set("duration", "5");
+  params.set("difficulty", source.searchParams.get("difficulty") ?? "medium");
+  params.set("media", "video");
+  params.set("source", "daily-mission");
+  return `/agents/interview/preview?${params.toString()}`;
+}
+
+function compactAnswer(answer: string) {
+  return answer.length > 180 ? `${answer.slice(0, 177).trimEnd()}...` : answer;
+}
+
+function isConfidenceCheck(task: DailyMissionTask) {
+  const haystack = [task.questTitle, task.subtask, task.service, task.intro].filter(Boolean).join(" ").toLowerCase();
+  return haystack.includes("confidence check") || (haystack.includes("qx") && haystack.includes("confidence"));
+}
+
+function buildDailyMissionSystemPrompt(task: DailyMissionTask) {
+  return `You are Daily Mission, a focused GrowQR dashboard agent.
+
+The user clicked on the main task called ${task.questTitle}${task.intro ? ` (${task.intro})` : ""} and the subtask within it called ${task.subtask}. You are going to act as an interface for the user to complete this subtask. Garner the right questions and get the input from the user.
+
+The frontend will send "Start". From there onwards, start with your first message to the user.
+
+Rules:
+- Ask one short question or give one short action at a time.
+- Do not start a larger mission, do not pitch other workflows, and do not send the user away.
+- Keep the tone warm, practical, and easy to answer.
+- When the user answer is enough to satisfy the subtask, mark the task complete by returning completed=true.
+- Return a single JSON object only. Do not wrap the object in a string. Shape: {"reply":"message to show","completed":false,"updateSummary":"optional short saved update"}.`;
+}
+
+function buildDailyMissionStreamingSystemPrompt(task: DailyMissionTask) {
+  return `You are the GrowQR conversation actor attached to a mission actor.
+
+The user clicked a mission task card:
+${formatTask(task)}
+
+Your job is to make the mission feel alive:
+- The mission actor owns progress and completion.
+- You own the chat turn and can prepare service handoffs.
+- The service capability is ${task.service ?? "unknown service"} at ${task.route ?? "unknown route"}.
+
+Rules:
+- Plain text only. Do not return JSON.
+- On the first "start" message, do not use a template line like "This is a service handoff".
+- Ask the next natural question required to advance this exact mission stage.
+- If the service is Resume, ask for the resume text/file and target role or section in a natural way.
+- If the service is Interview, ask for role, round type, and the one thing they want to improve.
+- If the service is Roleplay, ask for scenario, counterpart, and desired outcome.
+- Keep it short, warm, and specific.`;
+}
+
+function withDailyMissionActionDefaults(task: DailyMissionTask, result: z.infer<typeof dailyMissionResponseSchema>) {
+  if (!result.completed || !isInterviewMission(task)) return result;
+  return {
+    ...result,
+    actionLabel: result.actionLabel ?? "Generate room",
+    actionRoute: result.actionRoute ?? getInterviewActionRoute(task),
+  };
+}
+
+function serviceStartReply(task: DailyMissionTask) {
+  const service = (task.service ?? "").toLowerCase();
+  const routePath = task.route ? new URL(task.route, "https://growqr.local").pathname.toLowerCase() : "";
+
+  if (service.includes("resume") || routePath.includes("/agents/resume")) {
+    return "This is a Resume service handoff. Tell me the target role or resume section you want to improve, and I will save it on this mission stage.";
+  }
+  if (service.includes("roleplay") || routePath.includes("/agents/roleplay")) {
+    return "This is a Roleplay service handoff. Tell me the scenario you want to practice and the outcome you want from the conversation.";
+  }
+  if (service.includes("q score") || service.includes("qscore") || routePath.includes("/agents/qscore")) {
+    return "This is a Q Score check. Tell me the signal you want to improve or the readiness question you want scored.";
+  }
+  return undefined;
+}
+
+function latestUserMessage(messages: DailyMissionMessage[]) {
+  return [...messages].reverse().find((message) => message.role === "user")?.content.trim() ?? "";
+}
+
+function firstQuestionForTask(task: DailyMissionTask) {
+  const subtask = task.subtask.toLowerCase();
+  const title = task.questTitle.toLowerCase();
+  const intro = (task.intro ?? "").toLowerCase();
+  const service = (task.service ?? "").toLowerCase();
+  const routePath = task.route ? new URL(task.route, "https://growqr.local").pathname.toLowerCase() : "";
+  const isResume = service.includes("resume") || routePath.includes("/agents/resume");
+  const isInterview = service.includes("interview") || routePath.includes("/agents/interview");
+  const isRoleplay = service.includes("roleplay") || routePath.includes("/agents/roleplay");
+  const isPlanner = service.includes("mission planner") || title.includes("target role") || intro.includes("target role") || title.includes("career transition");
+
+  if (subtask.includes("save") || subtask.includes("next action")) {
+    if (isPlanner) return "What next career move should I save: target role, skill gap, or outreach action?";
+    if (isResume) return "What next action should I save: revise bullets, fill gaps, or generate talking points?";
+    if (isInterview) return "What interview prep action should I save for the student to do next?";
+    if (isRoleplay) return "What roleplay action should I save for the next practice round?";
+    return `What next action should I save for "${task.subtask}"?`;
+  }
+
+  if (subtask.includes("handoff") || subtask.includes("prepare")) {
+    if (isPlanner) return "Should I prepare a role shortlist, transition plan, or skill-gap plan?";
+    if (isResume) return "Which resume handoff should I prepare: role-fit proof, gap scan, or talking points?";
+    if (isInterview) return "What interview setup should I prepare: role, round type, and difficulty?";
+    if (isRoleplay) return "What roleplay setup should I prepare: scenario, counterpart, and outcome?";
+    return `What handoff should I prepare for "${task.subtask}"?`;
+  }
+
+  if (isResume) {
+    return "Please share your resume text or file and the target role.";
+  }
+
+  if (isInterview) {
+    return "What role and interview round should this prep focus on?";
+  }
+
+  if (isRoleplay) {
+    return "What conversation scenario do you want to practice?";
+  }
+
+  if (isPlanner) {
+    if (subtask.includes("target role")) {
+      return "What is your current role, target role, and biggest transition constraint?";
+    }
+    if (subtask.includes("requirements")) {
+      return "What requirement should we check first: skills, experience, location, or timeline?";
+    }
+    if (subtask.includes("review") || subtask.includes("recommendation")) {
+      return "Which role option should we review first, and what matters most to you?";
+    }
+    return "What target role are you considering, and what constraint should I account for?";
+  }
+
+  if (subtask.includes("target role")) {
+    return "What is your current role, target role, and biggest constraint?";
+  }
+
+  if (subtask.includes("requirements")) {
+    return "Which requirement should we check first: skills, experience, location, or timeline?";
+  }
+
+  return `What is the key detail for "${task.subtask}"?`;
+}
+
+function buildConversationActorMessages(input: DailyMissionAgentInput) {
+  const latest = latestUserMessage(input.messages);
+  const isStart = latest.toLowerCase() === "start";
+  const transcript = input.messages
+    .filter((message) => message.content.trim().toLowerCase() !== "start")
+    .slice(-10)
+    .map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.content}`)
+    .join("\n");
+
+  return [{
+    id: `daily-mission-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+    conversationId: input.conversationId ?? "daily-mission",
+    role: "user" as const,
+    sender: "Daily Mission UI",
+    createdAt: Date.now(),
+    content: `The user opened a mission-linked Daily Mission chat.
+
+Mission task:
+${formatTask(input.task)}
+
+Mission ids:
+- missionInstanceId: ${input.missionInstanceId ?? "not linked yet"}
+- missionId: ${input.missionId ?? "unknown"}
+- stageId: ${input.stageId ?? "unknown"}
+
+${transcript ? `Conversation so far:\n${transcript}\n\n` : ""}${isStart
+  ? "This is the first assistant turn. Ask one short direct question that advances this stage. No greeting. No filler. No em dash. No long paragraph. For resume, ask for resume text/file and target role."
+  : `The user just replied: ${latest}\nRespond as the GrowQR conversation agent. If the answer is enough for this subtask, acknowledge what will be saved. Keep it concise. Use ASCII punctuation only.`}`,
+  }];
+}
+
+function runInterviewRoomSetup(task: DailyMissionTask, messages: DailyMissionMessage[]) {
+  const latestUser = latestUserMessage(messages);
+  const subtask = task.subtask.toLowerCase();
+  const actionRoute = getInterviewActionRoute(task);
+
+  if (latestUser.toLowerCase() === "start") {
+    if (subtask.includes("generate") || subtask.includes("jump") || subtask.includes("start")) {
+      return {
+        reply: "The interview room setup is ready. Review the details and tap Generate room to open the interview UI.",
+        completed: true,
+        updateSummary: "Interview room setup ready.",
+        actionLabel: "Generate room",
+        actionRoute,
+      };
+    }
+
+    if (subtask.includes("pressure") || subtask.includes("difficulty")) {
+      return {
+        reply: "Pick the pressure level for the student: easy, medium, or hard.",
+        completed: false,
+        updateSummary: undefined,
+        actionLabel: undefined,
+        actionRoute: undefined,
+      };
+    }
+
+    return {
+      reply: "What should this interview room be for? Share the role, round type, and one thing the student wants to improve.",
+      completed: false,
+      updateSummary: undefined,
+      actionLabel: undefined,
+      actionRoute: undefined,
+    };
+  }
+
+  const updateSummary = compactAnswer(latestUser);
+  return {
+    reply: `Got it. I saved this for the student: ${updateSummary}. Tap Generate room when you are ready to open the interview UI.`,
+    completed: true,
+    updateSummary,
+    actionLabel: "Generate room",
+    actionRoute,
+  };
+}
+
+function formatTask(task: DailyMissionTask) {
+  const lines = [
+    task.day ? `Sprint day: ${task.day}` : undefined,
+    `Quest: ${task.questTitle}`,
+    `Subtask: ${task.subtask}`,
+    task.service ? `Service: ${task.service}` : undefined,
+    task.route ? `Service route: ${task.route}` : undefined,
+    task.intro ? `Quest intent: ${task.intro}` : undefined,
+    task.context?.length
+      ? `Visible context: ${task.context.map((item) => `${item.label}: ${item.value}`).join("; ")}`
+      : undefined,
+    task.signals?.length ? `Signals to improve: ${task.signals.join(", ")}` : undefined,
+  ].filter(Boolean);
+
+  return lines.map((line) => `- ${line}`).join("\n");
+}
+
+
+
+export async function runDailyMissionAgent(input: DailyMissionAgentInput) {
+  const started = input.messages.some(
+    (message) => message.role === "user" && message.content.trim().toLowerCase() === "start",
+  );
+  if (!started) {
+    return {
+      reply: "I am ready to begin this daily mission.",
+      completed: false,
+      updateSummary: undefined,
+      actionLabel: undefined,
+      actionRoute: undefined,
+    };
+  }
+
+  if (isInterviewMission(input.task)) {
+    return runInterviewRoomSetup(input.task, input.messages);
+  }
+
+  const transcript = input.messages
+    .slice(-12)
+    .map((message) => `${message.role === "user" ? "Student" : "Daily Mission"}: ${message.content}`)
+    .join("\n");
+
+  try {
+    const result = await generateText({
+      model: getConversationModel(),
+      system: buildDailyMissionSystemPrompt(input.task),
+      prompt: `User id: ${input.userId}
+
+Daily task context:
+${formatTask(input.task)}
+
+Conversation so far:
+${transcript}`,
+    });
+
+    return withDailyMissionActionDefaults(input.task, parseDailyMissionResponse(result.text));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn("daily mission model failed; returning unavailable state", { message });
+    return {
+      reply: "Daily mission is temporarily unavailable right now. No progress was saved. Please retry in a moment.",
+      completed: false,
+      updateSummary: undefined,
+      actionLabel: undefined,
+      actionRoute: undefined,
+    };
+  }
+}
+
+export async function streamDailyMissionAgent(input: DailyMissionAgentInput) {
+  const started = input.messages.some(
+    (message) => message.role === "user" && message.content.trim().toLowerCase() === "start",
+  );
+  if (!started) {
+    return { kind: "static" as const, result: await runDailyMissionAgent(input) };
+  }
+
+  const latest = latestUserMessage(input.messages);
+  const userMessagesAfterStart = input.messages.filter((message) => message.role === "user");
+  const isStart = latest.toLowerCase() === "start";
+
+  if (isStart) {
+    return {
+      kind: "static" as const,
+      result: {
+        reply: firstQuestionForTask(input.task),
+        completed: false,
+        updateSummary: undefined,
+        actionLabel: undefined,
+        actionRoute: undefined,
+      },
+    };
+  }
+
+  const result = streamConversationResponse(buildConversationActorMessages(input), {
+    userId: input.userId,
+    conversationId: input.conversationId,
+    missionInstanceId: input.missionInstanceId,
+    missionId: input.missionId,
+    stageId: input.stageId,
+    source: isStart ? "daily-mission-start" : "daily-mission",
+  });
+
+  return {
+    kind: "stream" as const,
+    textStream: result.textStream,
+    finalize: (reply: string): DailyMissionResult => {
+      const completed = !isStart && userMessagesAfterStart.length > 1 && reply.trim().length > 0;
+      return {
+        reply: cleanAssistantReply(reply),
+        completed,
+        updateSummary: completed ? compactAnswer(latest) : undefined,
+        actionLabel: undefined,
+        actionRoute: undefined,
+      };
+    },
+  };
+}

src/auth/clerk.ts

@@ -26,7 +26,7 @@ export const requireUser = createMiddleware<AuthContext>(async (c, next) => {
   const auth = c.req.header("authorization") ?? "";
   const token = auth.replace(/^Bearer\s+/i, "").trim();
 
-  // Service-to-service path (Grow Agent actor calling backend).
+  // Service-to-service path (Grow stack calling backend).
   // Header `x-growqr-user` is REQUIRED so we can scope the call.
   const trustedServiceTokens = new Set(
     [

src/db/schema.ts

@@ -280,6 +280,7 @@ export const growConversations = pgTable(
     userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
     title: text("title").notNull().default("Talk to Me"),
     active: boolean("active").notNull().default(true),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>(),
     createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
     updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
   },
@@ -458,6 +459,52 @@ export const growQscoreProjectionState = pgTable("grow_qscore_projection_state",
   updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
 });
 
+export const missionActions = pgTable(
+  "mission_actions",
+  {
+    id: text("id").primaryKey().default(sql`gen_random_uuid()::text`),
+    userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    missionInstanceId: text("mission_instance_id").notNull().references(() => growActiveMissions.instanceId, { onDelete: "cascade" }),
+    missionId: text("mission_id").notNull(),
+    stageId: text("stage_id"),
+
+    agentId: text("agent_id").notNull(),
+    agentName: text("agent_name").notNull(),
+    baseAgent: text("base_agent"),
+    serviceId: text("service_id"),
+    toolName: text("tool_name"),
+
+    mode: text("mode", { enum: ["autonomous", "approval_required", "user_input_required", "suggestion"] }).notNull(),
+    status: text("status", {
+      enum: ["queued", "running", "waiting_approval", "waiting_user_input", "done", "failed", "dismissed", "snoozed"],
+    }).notNull().default("queued"),
+
+    title: text("title").notNull(),
+    body: text("body").notNull(),
+    prompt: text("prompt"),
+    payload: jsonb("payload").$type<Record<string, unknown>>().notNull().default(sql`'{}'::jsonb`),
+    result: jsonb("result").$type<Record<string, unknown>>(),
+    error: text("error"),
+
+    sourceEventId: text("source_event_id").references(() => growEvents.id, { onDelete: "set null" }),
+    idempotencyKey: text("idempotency_key"),
+    priority: integer("priority").notNull().default(0),
+    urgency: text("urgency", { enum: ["now", "today", "soon", "calm"] }).notNull().default("calm"),
+    dueAt: timestamp("due_at", { withTimezone: true }),
+
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+    resolvedAt: timestamp("resolved_at", { withTimezone: true }),
+  },
+  (t) => ({
+    missionIdx: index("mission_actions_mission_idx").on(t.userId, t.missionInstanceId, t.status, t.priority),
+    userIdx: index("mission_actions_user_idx").on(t.userId, t.status, t.updatedAt),
+    sourceIdx: index("mission_actions_source_idx").on(t.sourceEventId),
+    dueIdx: index("mission_actions_due_idx").on(t.dueAt),
+    idempotencyIdx: uniqueIndex("mission_actions_idempotency_idx").on(t.idempotencyKey),
+  }),
+);
+
 export const missionSuggestions = pgTable(
   "mission_suggestions",
   {
@@ -544,6 +591,8 @@ export const growHomeNotifications = pgTable(
 
 export type GrowEventRow = typeof growEvents.$inferSelect;
 export type NewGrowEvent = typeof growEvents.$inferInsert;
+export type MissionActionRow = typeof missionActions.$inferSelect;
+export type NewMissionAction = typeof missionActions.$inferInsert;
 export type MissionSuggestionRow = typeof missionSuggestions.$inferSelect;
 export type NewMissionSuggestion = typeof missionSuggestions.$inferInsert;
 export type MissionCoachRunRow = typeof missionCoachRuns.$inferSelect;

src/events/onboarding-qscore.ts

@@ -0,0 +1,152 @@
+import { and, eq } from "drizzle-orm";
+import { db } from "../db/client.js";
+import { growQscoreLatest, growQscoreProjectionState, growQscoreSignals } from "../db/schema.js";
+
+export const ONBOARDING_BASELINE_SIGNAL_ID = "onboarding.completed_baseline";
+export const ONBOARDING_BASELINE_QSCORE = 35;
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+function onboardingCompletedAt(preferences: Record<string, unknown> | undefined): Date | null {
+  const onboarding = asRecord(preferences?.onboarding);
+  const completedAt = onboarding.completed_at;
+  if (typeof completedAt !== "string" || !completedAt.trim()) return null;
+  const parsed = new Date(completedAt);
+  return Number.isNaN(parsed.getTime()) ? new Date() : parsed;
+}
+
+/**
+ * Seed the first real Q Score projection when onboarding is completed.
+ *
+ * The onboarding UI tells users their QX baseline starts at 35. Previously that
+ * number was only cosmetic, while the header showed a separate home-feed
+ * fallback and the Q Score page stayed empty. This makes the onboarding
+ * baseline a persisted readiness signal, but only when the user has no Q Score
+ * signals/projection yet so we do not overwrite mature accounts.
+ */
+export async function ensureOnboardingBaselineQscore(
+  userId: string,
+  preferences: Record<string, unknown> | undefined,
+): Promise<boolean> {
+  const completedAt = onboardingCompletedAt(preferences);
+  if (!completedAt) return false;
+
+  const latestSignals = await db
+    .select({ signalId: growQscoreLatest.signalId, score: growQscoreLatest.score })
+    .from(growQscoreLatest)
+    .where(and(eq(growQscoreLatest.userId, userId), eq(growQscoreLatest.present, true)));
+
+  const [existingProjection] = await db
+    .select({ score: growQscoreProjectionState.score, signalCount: growQscoreProjectionState.signalCount })
+    .from(growQscoreProjectionState)
+    .where(eq(growQscoreProjectionState.userId, userId))
+    .limit(1);
+
+  const now = new Date();
+
+  // Repair users affected by the old resume-upload projector, which treated a
+  // plain upload as a perfect 100 score. Uploading a resume during onboarding is
+  // only baseline evidence; parsed resume/interview/roleplay results should be
+  // what moves the score upward.
+  if (
+    latestSignals.length === 1 &&
+    latestSignals[0]?.signalId === "resume.uploaded" &&
+    latestSignals[0].score > ONBOARDING_BASELINE_QSCORE
+  ) {
+    await db
+      .update(growQscoreLatest)
+      .set({
+        score: ONBOARDING_BASELINE_QSCORE,
+        raw: {
+          reason: "resume upload baseline correction",
+          correctedFrom: latestSignals[0].score,
+          correctedAt: now.toISOString(),
+        },
+        updatedAt: now,
+      })
+      .where(and(eq(growQscoreLatest.userId, userId), eq(growQscoreLatest.signalId, "resume.uploaded")));
+
+    await db
+      .insert(growQscoreProjectionState)
+      .values({
+        userId,
+        score: ONBOARDING_BASELINE_QSCORE,
+        signalCount: 1,
+        dimensions: { baseline: true, latestSignalIds: ["resume.uploaded"], corrected: true },
+        summary: "Baseline Q Score from onboarding resume upload.",
+        updatedAt: now,
+      })
+      .onConflictDoUpdate({
+        target: growQscoreProjectionState.userId,
+        set: {
+          score: ONBOARDING_BASELINE_QSCORE,
+          signalCount: 1,
+          dimensions: { baseline: true, latestSignalIds: ["resume.uploaded"], corrected: true },
+          summary: "Baseline Q Score from onboarding resume upload.",
+          updatedAt: now,
+        },
+      });
+
+    return true;
+  }
+
+  if (latestSignals.length > 0 || (existingProjection?.score ?? 0) > 0) {
+    return false;
+  }
+  const raw = {
+    reason: "completed onboarding baseline",
+    completedAt: completedAt.toISOString(),
+  };
+
+  const inserted = await db
+    .insert(growQscoreLatest)
+    .values({
+      userId,
+      signalId: ONBOARDING_BASELINE_SIGNAL_ID,
+      score: ONBOARDING_BASELINE_QSCORE,
+      present: true,
+      source: "onboarding",
+      raw,
+      occurredAt: completedAt,
+      updatedAt: now,
+    })
+    .onConflictDoNothing()
+    .returning({ signalId: growQscoreLatest.signalId });
+
+  if (!inserted.length) return false;
+
+  await db.insert(growQscoreSignals).values({
+    userId,
+    signalId: ONBOARDING_BASELINE_SIGNAL_ID,
+    score: ONBOARDING_BASELINE_QSCORE,
+    present: true,
+    source: "onboarding",
+    raw,
+    occurredAt: completedAt,
+  });
+
+  await db
+    .insert(growQscoreProjectionState)
+    .values({
+      userId,
+      score: ONBOARDING_BASELINE_QSCORE,
+      signalCount: 1,
+      dimensions: { baseline: true, latestSignalIds: [ONBOARDING_BASELINE_SIGNAL_ID] },
+      summary: "Baseline Q Score from completed onboarding.",
+      updatedAt: now,
+    })
+    .onConflictDoUpdate({
+      target: growQscoreProjectionState.userId,
+      set: {
+        score: ONBOARDING_BASELINE_QSCORE,
+        signalCount: 1,
+        dimensions: { baseline: true, latestSignalIds: [ONBOARDING_BASELINE_SIGNAL_ID] },
+        summary: "Baseline Q Score from completed onboarding.",
+        updatedAt: now,
+      },
+    });
+
+  return true;
+}

src/events/projectors/qscore-projector.ts

@@ -15,6 +15,8 @@ function nestedNumber(record: Record<string, unknown>, keys: string[]): number |
   return undefined;
 }
 
+const RESUME_UPLOAD_BASELINE_SCORE = 35;
+
 function extractResumeSignals(event: GrowEventRow): QscoreSignal[] {
   const payload = event.payload ?? {};
   const analysis = asRecord(payload.analysis ?? payload.result ?? payload);
@@ -38,8 +40,11 @@ function extractResumeSignals(event: GrowEventRow): QscoreSignal[] {
   }
 
   const signals: QscoreSignal[] = [];
-  if (event.type.includes("uploaded") || event.type.includes("created") || event.type.includes("analysis")) {
-    signals.push(signal("resume.uploaded", 100, { eventId: event.id }));
+  if (event.type.includes("uploaded") || event.type.includes("created")) {
+    // Uploading a resume is only a baseline readiness signal. The actual Q Score
+    // should rise from parsed resume/interview/roleplay evidence, not jump to 100
+    // immediately after onboarding.
+    signals.push(signal("resume.uploaded", RESUME_UPLOAD_BASELINE_SCORE, { eventId: event.id }));
   }
   const ats = byCategory.get("ATS Compatibility") ?? nestedNumber(analysis, ["ats_score", "ats_compatibility", "atsCompatibility"]);
   if (ats !== undefined) signals.push(signal("resume.ats_compatibility", ats, { eventId: event.id }));

src/grow/persistence.ts

@@ -1,4 +1,4 @@
-import { asc, desc, eq, and } from "drizzle-orm";
+import { asc, desc, eq, and, sql } from "drizzle-orm";
 import { db } from "../db/client.js";
 import { growActiveMissions, growConversationMessages, growConversations, missionCoachRuns, missionSuggestions } from "../db/schema.js";
 import type { GrowActiveMission, MissionSnapshot } from "../actors/missions/types.js";
@@ -42,6 +42,118 @@ export async function createConversationPg(userId: string, title = "Talk to Me")
   return toConversation(row);
 }
 
+export async function ensureCuratorTaskConversationPg(input: {
+  userId: string;
+  curatorTaskId: string;
+  subtaskIndex?: number;
+  subtask?: string;
+  missionInstanceId?: string;
+  missionId?: string;
+  stageId?: string;
+  title?: string;
+}): Promise<GrowConversation> {
+  const curatorTaskKey = `${input.curatorTaskId}:${input.subtaskIndex ?? "task"}`;
+  const [existing] = await db
+    .select()
+    .from(growConversations)
+    .where(and(
+      eq(growConversations.userId, input.userId),
+      sql`${growConversations.metadata}->>'curatorTaskKey' = ${curatorTaskKey}`,
+    ))
+    .orderBy(desc(growConversations.updatedAt))
+    .limit(1);
+
+  const metadata = {
+    source: "curator-v1",
+    curatorTaskId: input.curatorTaskId,
+    curatorTaskKey,
+    ...(Number.isInteger(input.subtaskIndex) ? { subtaskIndex: input.subtaskIndex } : {}),
+    ...(input.subtask ? { subtask: input.subtask } : {}),
+    ...(input.missionInstanceId ? { missionInstanceId: input.missionInstanceId } : {}),
+    ...(input.missionId ? { missionId: input.missionId } : {}),
+    ...(input.stageId ? { stageId: input.stageId } : {}),
+  };
+
+  if (existing) {
+    const [row] = await db.update(growConversations).set({
+      title: input.title?.trim() || existing.title,
+      metadata,
+      updatedAt: new Date(),
+    }).where(and(eq(growConversations.userId, input.userId), eq(growConversations.id, existing.id))).returning();
+    if (!row) throw new Error("Failed to update curator task conversation");
+    return toConversation(row);
+  }
+
+  const now = new Date();
+  const [row] = await db.insert(growConversations).values({
+    id: buildId("conversation"),
+    userId: input.userId,
+    title: input.title?.trim() || input.subtask?.trim() || "V1 Curator chat",
+    metadata,
+    createdAt: now,
+    updatedAt: now,
+  }).returning();
+  if (!row) throw new Error("Failed to create curator task conversation");
+  return toConversation(row);
+}
+
+export async function ensureMissionConversationPg(input: {
+  userId: string;
+  missionInstanceId: string;
+  missionId: string;
+  stageId?: string;
+  title?: string;
+  source?: string;
+}): Promise<GrowConversation> {
+  const [existing] = await db
+    .select()
+    .from(growConversations)
+    .where(and(
+      eq(growConversations.userId, input.userId),
+      sql`${growConversations.metadata}->>'missionInstanceId' = ${input.missionInstanceId}`,
+    ))
+    .orderBy(desc(growConversations.updatedAt))
+    .limit(1);
+
+  const metadata = {
+    missionInstanceId: input.missionInstanceId,
+    missionId: input.missionId,
+    ...(input.stageId ? { stageId: input.stageId } : {}),
+    source: input.source ?? "mission",
+  };
+
+  if (existing) {
+    const [row] = await db.update(growConversations).set({
+      title: input.title?.trim() || existing.title,
+      metadata,
+      updatedAt: new Date(),
+    }).where(and(eq(growConversations.userId, input.userId), eq(growConversations.id, existing.id))).returning();
+    if (!row) throw new Error("Failed to update mission conversation");
+    return toConversation(row);
+  }
+
+  const now = new Date();
+  const [row] = await db.insert(growConversations).values({
+    id: buildId("conversation"),
+    userId: input.userId,
+    title: input.title?.trim() || "Mission chat",
+    metadata,
+    createdAt: now,
+    updatedAt: now,
+  }).returning();
+  if (!row) throw new Error("Failed to create mission conversation");
+  return toConversation(row);
+}
+
+export async function getConversationMetadataPg(userId: string, conversationId: string) {
+  const [row] = await db
+    .select({ metadata: growConversations.metadata })
+    .from(growConversations)
+    .where(and(eq(growConversations.userId, userId), eq(growConversations.id, conversationId)))
+    .limit(1);
+  return row?.metadata ?? {};
+}
+
 export async function getConversationPg(userId: string, conversationId: string): Promise<GrowConversation | null> {
   const [row] = await db.select().from(growConversations).where(and(eq(growConversations.userId, userId), eq(growConversations.id, conversationId))).limit(1);
   return row ? toConversation(row) : null;

src/home/home-feed-agent.ts

@@ -1,9 +1,9 @@
-import { Output, generateText } from "ai";
+import { generateText } from "ai";
 import { z } from "zod";
 import { getConversationModel } from "../actors/conversation/agent.js";
 import { config } from "../config.js";
 import { log } from "../log.js";
-import { ALLOWED_NOTIFICATION_HREFS, MODULE_IDS, type HomeModuleId, type HomeNotification, type HomeUrgency } from "./types.js";
+import { isAllowedNotificationHref, MODULE_IDS, type HomeModuleId, type HomeNotification, type HomeUrgency } from "./types.js";
 
 const notificationSchema = z.object({
   moduleId: z.enum(MODULE_IDS as [HomeModuleId, ...HomeModuleId[]]),
@@ -20,6 +20,8 @@ const feedSchema = z.object({
   notifications: z.array(notificationSchema).min(6).max(24),
 });
 
+const HOME_FEED_AGENT_TIMEOUT_MS = Number(process.env.HOME_FEED_AGENT_TIMEOUT_MS ?? 20000);
+
 export type AgentHomeNotification = z.infer<typeof notificationSchema>;
 
 const SYSTEM = `You are GrowQR's Home Feed Agent.
@@ -39,12 +41,8 @@ Use minimal iPhone-notification copy: title <= 72 chars, subtitle <= 110 chars,
 Use urgency truthfully: now = needs immediate user action, today = useful today, soon = next few days, calm = informational.`;
 
 function sanitizeHref(href: string, moduleId: HomeModuleId) {
-  if (ALLOWED_NOTIFICATION_HREFS.has(href)) return href;
-  if (href.startsWith("/agents/resume")) return "/agents/resume";
-  if (href.startsWith("/agents/interview")) return "/agents/interview";
-  if (href.startsWith("/agents/roleplay")) return "/agents/roleplay";
-  if (href.startsWith("/agents/qscore")) return "/agents/qscore";
-  if (href.startsWith("/missions")) return "/missions";
+  if (isAllowedNotificationHref(href)) return href;
+  if (href.startsWith("/missions")) return "/missions/active";
   if (href.startsWith("/social")) return "/social";
   if (href.startsWith("/pathways")) return "/pathways";
   if (href.startsWith("/rewards")) return "/rewards";
@@ -56,6 +54,18 @@ function stableId(prefix: string, index: number) {
   return `${prefix}-${index + 1}`;
 }
 
+function parseJsonObject(text: string) {
+  const cleaned = text.trim().replace(/^```(?:json)?/i, "").replace(/```$/i, "").trim();
+  try {
+    return JSON.parse(cleaned);
+  } catch {
+    const start = cleaned.indexOf("{");
+    const end = cleaned.lastIndexOf("}");
+    if (start === -1 || end === -1 || end <= start) throw new Error("home_feed_agent_invalid_json");
+    return JSON.parse(cleaned.slice(start, end + 1));
+  }
+}
+
 export async function refineHomeNotificationsWithAgent(input: {
   userId: string;
   context: Record<string, unknown>;
@@ -66,8 +76,12 @@ export async function refineHomeNotificationsWithAgent(input: {
   try {
     const result = await generateText({
       model: getConversationModel(),
-      output: Output.object({ schema: feedSchema }),
-      system: SYSTEM,
+      system: [
+        SYSTEM,
+        "Return JSON only. Shape: {\"notifications\": [...]}. Do not use markdown.",
+        "Use ASCII punctuation only.",
+      ].join("\n"),
+      timeout: HOME_FEED_AGENT_TIMEOUT_MS,
       prompt: JSON.stringify({
         task: "Create coherent GrowQR home dashboard notifications from the provided service context and deterministic candidates.",
         userId: input.userId,
@@ -76,8 +90,9 @@ export async function refineHomeNotificationsWithAgent(input: {
       }),
     });
 
+    const parsed = feedSchema.parse(parseJsonObject(result.text));
     const now = new Date().toISOString();
-    return result.output.notifications.map((n, index) => ({
+    return parsed.notifications.map((n, index) => ({
       ...n,
       href: sanitizeHref(n.href, n.moduleId),
       urgency: n.urgency as HomeUrgency,

src/home/home-feed.ts

@@ -8,15 +8,19 @@ import {
   growQscoreProjectionState,
   missionArtifacts,
   missionServiceSessions,
+  missionSuggestions,
   qscoreSnapshots,
   users,
   type GrowHomeNotificationRow,
   type NewGrowHomeNotification,
 } from "../db/schema.js";
 import { interviewService, resumeService, roleplayService } from "../services/product-service-clients.js";
+import { ensureOnboardingBaselineQscore } from "../events/onboarding-qscore.js";
 import { refineHomeNotificationsWithAgent } from "./home-feed-agent.js";
+import { listAvailableMissionDefinitions } from "../missions/registry.js";
+import { listServiceCapabilities } from "../workflows/service-capabilities.js";
 import {
-  ALLOWED_NOTIFICATION_HREFS,
+  isAllowedNotificationHref,
   MODULE_IDS,
   MODULE_META,
   type HomeFeedResponse,
@@ -35,7 +39,7 @@ const SERVICE_HREFS = {
   interview: "/agents/interview",
   roleplay: "/agents/roleplay",
   qscore: "/agents/qscore",
-  mission: "/missions",
+  mission: "/missions/active",
   social: "/social",
   pathways: "/pathways",
   rewards: "/rewards",
@@ -50,10 +54,13 @@ type HomeContext = {
   qscore: { score: number; signalCount: number; summary: string | null; dimensions: Record<string, unknown> | null } | undefined;
   qscoreSignals: Array<{ signalId: string; score: number; source: string | null; updatedAt: Date }>;
   activeMissions: Array<{ instanceId: string; missionId: string; title: string; status: string; progressPercent: number; currentStageId: string | null; updatedAt: Date }>;
+  missionSuggestions: Array<{ id: string; missionInstanceId: string; missionId: string; stageId: string | null; role: string; type: string; title: string; body: string; reason: string | null; priority: number; urgency: string; ctaLabel: string; ctaHref: string; updatedAt: Date }>;
   sessions: Array<{ serviceId: string; externalId: string; status: string; updatedAt: Date; metadata: Record<string, unknown> | null }>;
   artifacts: Array<{ serviceId: string | null; type: string; title: string; status: string; summary: string | null; createdAt: Date }>;
   events: Array<{ source: string; type: string; occurredAt: Date; payload: Record<string, unknown> }>;
   serviceStates: Record<string, unknown>;
+  userProfile?: Record<string, unknown>;
+  preferences: Record<string, unknown>;
 };
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -64,13 +71,68 @@ function numberFrom(value: unknown): number | undefined {
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 
+function arrayOfStrings(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string" && item.trim().length > 0) : [];
+}
+
+function recordOf(value: unknown): Record<string, unknown> {
+  return isRecord(value) ? value : {};
+}
+
+function profileFromPreferences(preferences: Record<string, unknown>) {
+  const onboarding = recordOf(preferences.onboarding);
+  const interview = recordOf(preferences.interview_preferences);
+  const resume = recordOf(preferences.resume_preferences);
+  const mission = recordOf(preferences.mission_preferences);
+  const targetRoles = arrayOfStrings(preferences.target_roles);
+  const targetCompanies = arrayOfStrings(preferences.target_companies);
+  const focusAreas = arrayOfStrings(interview.focus_areas);
+  return {
+    targetRole: targetRoles[0] ?? (typeof resume.target_title === "string" ? resume.target_title : "Senior Data Scientist"),
+    targetCompany: targetCompanies[0] ?? "target company",
+    industry: typeof preferences.industry === "string" ? preferences.industry : "AI / SaaS",
+    focusAreas,
+    weakSpots: arrayOfStrings(interview.weak_spots),
+    jobDescription: typeof interview.job_description === "string" ? interview.job_description : undefined,
+    activeGoal: typeof mission.active_goal === "string" ? mission.active_goal : typeof onboarding.goal === "string" ? onboarding.goal : undefined,
+    onboardingComplete: Boolean(onboarding.completed_at),
+  };
+}
+
+function serviceHref(service: "resume" | "interview" | "roleplay" | "qscore", ctx: HomeContext, mission?: { instanceId?: string; missionId?: string; stageId?: string | null }) {
+  const profile = profileFromPreferences(ctx.preferences);
+  const params = new URLSearchParams({ source: "home" });
+  if (mission?.instanceId) params.set("missionInstanceId", mission.instanceId);
+  if (mission?.missionId) params.set("missionId", mission.missionId);
+  if (mission?.stageId) params.set("stageId", mission.stageId);
+  params.set("targetRole", profile.targetRole);
+  if (profile.targetCompany !== "target company") params.set("targetCompany", profile.targetCompany);
+  if (profile.industry) params.set("industry", profile.industry);
+  if (profile.focusAreas.length) params.set("focusAreas", profile.focusAreas.slice(0, 4).join(","));
+  if (profile.weakSpots.length) params.set("weakSpots", profile.weakSpots.slice(0, 3).join(","));
+  if (profile.jobDescription) params.set("jobDescription", profile.jobDescription.slice(0, 900));
+  if (service === "interview") return `/agents/interview/setup?${params.toString()}`;
+  if (service === "roleplay") return `/agents/roleplay/setup?${params.toString()}`;
+  if (service === "resume") return `/agents/resume?${params.toString()}`;
+  return `/agents/qscore?${params.toString()}`;
+}
+
+function sourceFromSuggestionRole(role: string): HomeSource {
+  const value = role.toLowerCase();
+  if (value.includes("resume")) return "resume";
+  if (value.includes("roleplay")) return "roleplay";
+  if (value.includes("interview")) return "interview";
+  if (value.includes("q")) return "qscore";
+  return "mission";
+}
+
 function sanitizeUrgency(value: string): HomeUrgency {
   if (value === "now" || value === "today" || value === "soon" || value === "calm") return value;
   return "calm";
 }
 
 function sanitizeHref(href: string | undefined, fallback: string) {
-  if (href && ALLOWED_NOTIFICATION_HREFS.has(href)) return href;
+  if (href && isAllowedNotificationHref(href)) return href;
   return fallback;
 }
 
@@ -97,28 +159,65 @@ function hasAnyRealActivity(ctx: HomeContext) {
       ctx.activeMissions.length ||
       ctx.sessions.length ||
       ctx.artifacts.length ||
-      ctx.events.length,
+      ctx.events.length ||
+      ctx.missionSuggestions.length ||
+      profileFromPreferences(ctx.preferences).onboardingComplete,
   );
 }
 
 function buildDayOneSeeds(): SeedNotification[] {
   const seeds: SeedNotification[] = [];
-  pushSeed(seeds, { moduleId: "suggestions", title: "Start with your Q Score", subtitle: "A quick readiness scan calibrates resume, interview, and roleplay tips.", tag: "Start", urgency: "now", href: SERVICE_HREFS.qscore, source: "qscore", priority: 90 });
-  pushSeed(seeds, { moduleId: "suggestions", title: "Add your target role", subtitle: "One role goal makes every recommendation sharper.", tag: "Profile", urgency: "today", href: SERVICE_HREFS.suggestions, source: "system", priority: 80 });
-  pushSeed(seeds, { moduleId: "missions", title: "Explore Interview-to-Offer", subtitle: "A guided mission connects resume fit, mock practice, and readiness scoring.", tag: "Browse", urgency: "today", href: SERVICE_HREFS.mission, source: "mission", priority: 80 });
-  pushSeed(seeds, { moduleId: "missions", title: "No approvals pending yet", subtitle: "Start a mission and this tile will track missing steps and progress.", tag: "Quiet", urgency: "calm", href: SERVICE_HREFS.mission, source: "mission", priority: 55 });
-  pushSeed(seeds, { moduleId: "social", title: "Connect LinkedIn when ready", subtitle: "Social branding recommendations unlock after your profile is available.", tag: "Setup", urgency: "soon", href: SERVICE_HREFS.social, source: "social", priority: 60 });
-  pushSeed(seeds, { moduleId: "social", title: "Build proof before posting", subtitle: "Resume and mock interview artifacts can become stronger featured pins.", tag: "Proof", urgency: "calm", href: SERVICE_HREFS.social, source: "social", priority: 50 });
-  pushSeed(seeds, { moduleId: "pathways", title: "Pathways are warming up", subtitle: "Complete resume + interview activity to unlock better route recommendations.", tag: "Soon", urgency: "calm", href: SERVICE_HREFS.pathways, source: "pathways", priority: 40 });
-  pushSeed(seeds, { moduleId: "productivity", title: "Open Resume Builder", subtitle: "Upload or create a resume to generate ATS and content recommendations.", tag: "Resume", urgency: "now", href: SERVICE_HREFS.resume, source: "resume", priority: 85 });
-  pushSeed(seeds, { moduleId: "productivity", title: "Try a 10-minute mock interview", subtitle: "The interview service creates a role-aware live practice session.", tag: "Mock", urgency: "soon", href: SERVICE_HREFS.interview, source: "interview", priority: 70 });
-  pushSeed(seeds, { moduleId: "productivity", title: "Roleplay is available for pressure practice", subtitle: "Use it for recruiter screens, salary asks, or manager conversations.", tag: "Roleplay", urgency: "calm", href: SERVICE_HREFS.roleplay, source: "roleplay", priority: 55 });
-  pushSeed(seeds, { moduleId: "rewards", title: "Rewards unlock after activity", subtitle: "Finish readiness actions to start earning demo streaks and perks.", tag: "Locked", urgency: "calm", href: SERVICE_HREFS.rewards, source: "rewards", priority: 35 });
+
+  const missions = listAvailableMissionDefinitions();
+  for (const [index, mission] of missions.slice(0, 3).entries()) {
+    const firstServiceModule = mission.modules.find((module) => module.execution === "service" && module.service);
+    pushSeed(seeds, {
+      moduleId: "missions",
+      title: mission.shortTitle || mission.title,
+      subtitle: mission.promise,
+      tag: mission.urgency === "high" ? "High" : mission.estimatedDuration,
+      urgency: mission.urgency === "high" ? "today" : "soon",
+      href: `/missions/available?missionId=${encodeURIComponent(mission.missionId)}`,
+      source: "mission",
+      reason: firstServiceModule ? `Registry workflow using ${firstServiceModule.role}.` : "Registry workflow.",
+      priority: 92 - index * 4,
+    });
+  }
+
+  const services = listServiceCapabilities().filter((service) => service.enabled);
+  const serviceCards = [
+    { id: "resume-service", moduleId: "productivity" as const, href: SERVICE_HREFS.resume, source: "resume" as const, urgency: "today" as const },
+    { id: "interview-service", moduleId: "productivity" as const, href: SERVICE_HREFS.interview, source: "interview" as const, urgency: "today" as const },
+    { id: "roleplay-service", moduleId: "productivity" as const, href: SERVICE_HREFS.roleplay, source: "roleplay" as const, urgency: "soon" as const },
+    { id: "qscore-service", moduleId: "suggestions" as const, href: SERVICE_HREFS.qscore, source: "qscore" as const, urgency: "now" as const },
+    { id: "social-branding-service", moduleId: "social" as const, href: SERVICE_HREFS.social, source: "social" as const, urgency: "soon" as const },
+    { id: "matchmaking-service", moduleId: "pathways" as const, href: SERVICE_HREFS.pathways, source: "pathways" as const, urgency: "calm" as const },
+  ];
+
+  for (const [index, card] of serviceCards.entries()) {
+    const service = services.find((item) => item.id === card.id);
+    if (!service) continue;
+    pushSeed(seeds, {
+      moduleId: card.moduleId,
+      title: service.name,
+      subtitle: service.operations.slice(0, 3).join(", ") || "Registered GrowQR service capability.",
+      tag: service.featureId?.replaceAll("-", " ").slice(0, 14) || "Service",
+      urgency: card.urgency,
+      href: card.href,
+      source: card.source,
+      reason: `From service registry: ${service.promptModulePath ?? service.id}.`,
+      priority: 84 - index * 3,
+    });
+  }
+
+  pushSeed(seeds, { moduleId: "suggestions", title: "Set your target outcome", subtitle: "One role or career goal sharpens every registry mission and service handoff.", tag: "Profile", urgency: "today", href: SERVICE_HREFS.suggestions, source: "system", priority: 80 });
+  pushSeed(seeds, { moduleId: "rewards", title: "Rewards unlock from mission progress", subtitle: "Complete registry-backed mission stages to earn streak and coin progress.", tag: "Locked", urgency: "calm", href: SERVICE_HREFS.rewards, source: "rewards", priority: 35 });
   return seeds;
 }
 
 function buildDynamicSeeds(ctx: HomeContext): SeedNotification[] {
   const seeds = buildDayOneSeeds().filter((seed) => seed.moduleId === "pathways" || seed.moduleId === "rewards");
+  const profile = profileFromPreferences(ctx.preferences);
   const qscore = ctx.qscore?.score ?? Math.round(ctx.qscoreSignals.reduce((sum, s) => sum + s.score, 0) / Math.max(ctx.qscoreSignals.length, 1));
   const ats = latestScore(ctx.qscoreSignals, "resume.ats_compatibility");
   const interviewOverall = latestScore(ctx.qscoreSignals, "interview.overall_score");
@@ -130,14 +229,55 @@ function buildDynamicSeeds(ctx: HomeContext): SeedNotification[] {
   const roleplayReview = serviceEvent(ctx, "roleplay.", "review");
   const resumeAnalysis = serviceEvent(ctx, "resume.", "analysis");
 
+  for (const suggestion of ctx.missionSuggestions.slice(0, 5)) {
+    const mission = ctx.activeMissions.find((item) => item.instanceId === suggestion.missionInstanceId);
+    const source = sourceFromSuggestionRole(suggestion.role);
+    const href = sanitizeHref(suggestion.ctaHref, mission ? `/missions/active?missionInstanceId=${encodeURIComponent(mission.instanceId)}` : SERVICE_HREFS.mission);
+    pushSeed(seeds, {
+      moduleId: "suggestions",
+      title: suggestion.title,
+      subtitle: suggestion.body,
+      tag: suggestion.ctaLabel.replace(/\s+/g, " ").slice(0, 14),
+      urgency: sanitizeUrgency(suggestion.urgency),
+      href,
+      source,
+      reason: suggestion.reason ?? undefined,
+      priority: Math.max(100, suggestion.priority + 10),
+    });
+    pushSeed(seeds, {
+      moduleId: suggestion.role.toLowerCase().includes("resume") || suggestion.role.toLowerCase().includes("interview") || suggestion.role.toLowerCase().includes("roleplay") ? "productivity" : "missions",
+      title: `${suggestion.role}: ${suggestion.title}`,
+      subtitle: mission ? `${mission.title} · ${suggestion.body}` : suggestion.body,
+      tag: suggestion.urgency === "now" ? "Now" : suggestion.urgency === "today" ? "Today" : "Next",
+      urgency: sanitizeUrgency(suggestion.urgency),
+      href,
+      source,
+      reason: suggestion.reason ?? undefined,
+      priority: suggestion.priority,
+    });
+  }
+
+  if (profile.onboardingComplete) {
+    pushSeed(seeds, {
+      moduleId: "suggestions",
+      title: `${profile.targetRole} plan is calibrated`,
+      subtitle: profile.activeGoal ?? `Today's recommendations are tuned for ${profile.targetRole}${profile.targetCompany !== "target company" ? ` at ${profile.targetCompany}` : ""}.`,
+      tag: "Profile",
+      urgency: "today",
+      href: "/suggestions",
+      source: "system",
+      priority: 91,
+    });
+  }
+
   if (ctx.qscore || ctx.qscoreSignals.length) {
     pushSeed(seeds, {
       moduleId: "suggestions",
       title: qscore >= 80 ? "Protect your Q Score momentum" : "Raise your Q Score next",
-      subtitle: qscore >= 80 ? `Readiness is trending at ${qscore}. Keep one proof action moving.` : `Current estimate is ${qscore || 64}. Resume + mock practice are the fastest signals.`,
+      subtitle: qscore >= 80 ? `Readiness is trending at ${qscore}. Keep one proof action moving for ${profile.targetRole}.` : `Current estimate is ${qscore || 64}. Resume + mock practice are fastest for ${profile.targetRole}.`,
       tag: "Q Score",
       urgency: qscore >= 80 ? "today" : "now",
-      href: SERVICE_HREFS.qscore,
+      href: serviceHref("qscore", ctx),
       source: "qscore",
       priority: 95,
     });
@@ -147,10 +287,10 @@ function buildDynamicSeeds(ctx: HomeContext): SeedNotification[] {
     pushSeed(seeds, {
       moduleId: "suggestions",
       title: ats >= 80 ? "ATS is demo-ready" : "Resume ATS needs one pass",
-      subtitle: ats >= 80 ? `ATS ${Math.round(ats)} — review role-specific keywords before applying.` : `ATS ${Math.round(ats)} — add JD keywords and measurable bullets.`,
+      subtitle: ats >= 80 ? `ATS ${Math.round(ats)} — review ${profile.targetRole} keywords before applying.` : `ATS ${Math.round(ats)} — add JD keywords and measurable data-science bullets.`,
       tag: ats >= 80 ? "Ready" : "Fix",
       urgency: ats >= 80 ? "today" : "now",
-      href: SERVICE_HREFS.resume,
+      href: serviceHref("resume", ctx),
       source: "resume",
       priority: 92,
     });
@@ -163,7 +303,7 @@ function buildDynamicSeeds(ctx: HomeContext): SeedNotification[] {
       subtitle: mission.currentStageId ? `Current stage: ${mission.currentStageId.replaceAll("-", " ")}` : "Next action is ready on the mission dashboard.",
       tag: mission.status === "paused" ? "Paused" : "Active",
       urgency: mission.status === "paused" ? "soon" : "today",
-      href: SERVICE_HREFS.mission,
+      href: `/missions/active?missionInstanceId=${encodeURIComponent(mission.instanceId)}`,
       source: "mission",
       priority: 90 - mission.progressPercent,
     });
@@ -186,7 +326,7 @@ function buildDynamicSeeds(ctx: HomeContext): SeedNotification[] {
   pushSeed(seeds, {
     moduleId: "social",
     title: "Turn proof into LinkedIn updates",
-    subtitle: ctx.artifacts.length ? `${ctx.artifacts.length} artifact${ctx.artifacts.length === 1 ? "" : "s"} can feed headline, featured, or post ideas.` : "Connect LinkedIn and use mission proof to improve your profile.",
+    subtitle: ctx.artifacts.length ? `${ctx.artifacts.length} artifact${ctx.artifacts.length === 1 ? "" : "s"} can feed headline, featured, or post ideas.` : `Connect LinkedIn and use ${profile.targetRole} proof to improve your profile.`,
     tag: ctx.artifacts.length ? "Proof" : "Setup",
     urgency: ctx.artifacts.length ? "today" : "soon",
     href: SERVICE_HREFS.social,
@@ -198,51 +338,52 @@ function buildDynamicSeeds(ctx: HomeContext): SeedNotification[] {
     pushSeed(seeds, {
       moduleId: "productivity",
       title: ats !== undefined ? `Resume ATS ${Math.round(ats)}` : "Resume analysis is ready",
-      subtitle: ats !== undefined && ats >= 80 ? "Use this version for role-fit scan or final polish." : "Open Resume Builder for recommendations and bullet fixes.",
+      subtitle: ats !== undefined && ats >= 80 ? `Use this version for ${profile.targetRole} role-fit scan or final polish.` : "Open Resume Builder for recommendations and bullet fixes.",
       tag: "Resume",
       urgency: ats !== undefined && ats < 75 ? "now" : "today",
-      href: SERVICE_HREFS.resume,
+      href: serviceHref("resume", ctx),
       source: "resume",
       priority: 90,
     });
   }
 
+  const firstMission = ctx.activeMissions[0];
   if (interviewReview || interviewOverall !== undefined || interviewSession) {
     pushSeed(seeds, {
       moduleId: "productivity",
       title: interviewOverall !== undefined ? `Mock interview score ${Math.round(interviewOverall)}` : "Mock interview review is tracking",
-      subtitle: interviewReview?.type.includes("processing") ? "Review is still processing; check back from the interview page." : "Open interview practice for review, next drill, or a new session.",
+      subtitle: interviewReview?.type.includes("processing") ? "Review is still processing; check back from the interview page." : `Open ${profile.targetRole} interview practice for review, next drill, or a new session.`,
       tag: interviewReview?.type.includes("processing") ? "Wait" : "Mock",
       urgency: interviewReview?.type.includes("processing") ? "soon" : "today",
-      href: SERVICE_HREFS.interview,
+      href: serviceHref("interview", ctx, { instanceId: firstMission?.instanceId, missionId: firstMission?.missionId, stageId: firstMission?.currentStageId }),
       source: "interview",
       priority: 86,
     });
   } else {
-    pushSeed(seeds, { moduleId: "productivity", title: "Schedule a mock interview", subtitle: "Generate a behavioral or role-related session from your target role.", tag: "Mock", urgency: "soon", href: SERVICE_HREFS.interview, source: "interview", priority: 72 });
+    pushSeed(seeds, { moduleId: "productivity", title: `Schedule a ${profile.targetRole} mock`, subtitle: "Generate a behavioral or role-related session from your target role.", tag: "Mock", urgency: "soon", href: serviceHref("interview", ctx, { instanceId: firstMission?.instanceId, missionId: firstMission?.missionId, stageId: firstMission?.currentStageId }), source: "interview", priority: 72 });
   }
 
   if (roleplayReview || roleplayComms !== undefined || roleplaySession) {
     pushSeed(seeds, {
       moduleId: "productivity",
       title: roleplayComms !== undefined ? `Roleplay communication ${Math.round(roleplayComms)}` : "Roleplay scenario is ready",
-      subtitle: "Practice recruiter, manager, salary, or stakeholder conversations.",
+      subtitle: `Practice recruiter, manager, salary, or stakeholder conversations for ${profile.targetRole}.`,
       tag: "Roleplay",
       urgency: "soon",
-      href: SERVICE_HREFS.roleplay,
+      href: serviceHref("roleplay", ctx, { instanceId: firstMission?.instanceId, missionId: firstMission?.missionId, stageId: firstMission?.currentStageId }),
       source: "roleplay",
       priority: 78,
     });
   }
 
   if (!ctx.activeMissions.length) {
-    pushSeed(seeds, { moduleId: "missions", title: "Start Interview-to-Offer", subtitle: "Bundle resume fit, mock practice, and Q Score deltas into one journey.", tag: "Begin", urgency: "today", href: SERVICE_HREFS.mission, source: "mission", priority: 80 });
+    pushSeed(seeds, { moduleId: "missions", title: "Start Interview-to-Offer", subtitle: `Bundle resume fit, mock practice, and Q Score deltas for ${profile.targetRole}.`, tag: "Begin", urgency: "today", href: "/missions/available", source: "mission", priority: 80 });
   }
 
   return seeds;
 }
 
-async function collectContext(userId: string): Promise<HomeContext> {
+async function collectContext(userId: string, input: { userProfile?: Record<string, unknown>; preferences?: Record<string, unknown> } = {}): Promise<HomeContext> {
   const [user] = await db.select({ id: users.id, email: users.email, displayName: users.displayName }).from(users).where(eq(users.id, userId)).limit(1);
   const [qscore] = await db.select().from(growQscoreProjectionState).where(eq(growQscoreProjectionState.userId, userId)).limit(1);
   const qscoreSignals = await db
@@ -257,6 +398,27 @@ async function collectContext(userId: string): Promise<HomeContext> {
     .where(eq(growActiveMissions.userId, userId))
     .orderBy(desc(growActiveMissions.updatedAt))
     .limit(6);
+  const suggestions = await db
+    .select({
+      id: missionSuggestions.id,
+      missionInstanceId: missionSuggestions.missionInstanceId,
+      missionId: missionSuggestions.missionId,
+      stageId: missionSuggestions.stageId,
+      role: missionSuggestions.role,
+      type: missionSuggestions.type,
+      title: missionSuggestions.title,
+      body: missionSuggestions.body,
+      reason: missionSuggestions.reason,
+      priority: missionSuggestions.priority,
+      urgency: missionSuggestions.urgency,
+      ctaLabel: missionSuggestions.ctaLabel,
+      ctaHref: missionSuggestions.ctaHref,
+      updatedAt: missionSuggestions.updatedAt,
+    })
+    .from(missionSuggestions)
+    .where(and(eq(missionSuggestions.userId, userId), eq(missionSuggestions.status, "active")))
+    .orderBy(desc(missionSuggestions.priority), desc(missionSuggestions.updatedAt))
+    .limit(12);
   const sessions = await db
     .select({ serviceId: missionServiceSessions.serviceId, externalId: missionServiceSessions.externalId, status: missionServiceSessions.status, updatedAt: missionServiceSessions.updatedAt, metadata: missionServiceSessions.metadata })
     .from(missionServiceSessions)
@@ -296,10 +458,13 @@ async function collectContext(userId: string): Promise<HomeContext> {
       : undefined,
     qscoreSignals,
     activeMissions,
+    missionSuggestions: suggestions,
     sessions: sessions.map((s) => ({ ...s, metadata: isRecord(s.metadata) ? s.metadata : null })),
     artifacts,
     events: events.map((e) => ({ ...e, payload: isRecord(e.payload) ? e.payload : {} })),
     serviceStates: { resume: resumeState, interview: interviewState, roleplay: roleplayState },
+    userProfile: input.userProfile,
+    preferences: input.preferences ?? {},
   };
 }
 
@@ -327,6 +492,21 @@ async function readPersistedNotifications(userId: string) {
     .limit(60);
 }
 
+function hasLegacyMockSeed(rows: GrowHomeNotificationRow[]) {
+  const legacyTitles = new Set([
+    "Complete your QX self-check",
+    "Create your interview room",
+    "Browse 1 career pathway",
+    "Start with your Q Score",
+    "Explore Interview-to-Offer",
+    "Pathways are warming up",
+    "Open Resume Builder",
+    "Try a 10-minute mock interview",
+    "Rewards unlock after activity",
+  ]);
+  return rows.some((row) => legacyTitles.has(row.title));
+}
+
 async function replaceGeneratedNotifications(userId: string, notifications: Array<SeedNotification>, generatedBy: "deterministic" | "agent") {
   await db
     .delete(growHomeNotifications)
@@ -430,14 +610,16 @@ async function buildIdentity(ctx: HomeContext) {
   };
 }
 
-export async function getHomeFeed(userId: string, opts: { refresh?: boolean } = {}): Promise<HomeFeedResponse> {
-  const ctx = await collectContext(userId);
+export async function getHomeFeed(userId: string, opts: { refresh?: boolean; userProfile?: Record<string, unknown>; preferences?: Record<string, unknown> } = {}): Promise<HomeFeedResponse> {
+  await ensureOnboardingBaselineQscore(userId, opts.preferences);
+  const ctx = await collectContext(userId, { userProfile: opts.userProfile, preferences: opts.preferences });
   const persisted = await readPersistedNotifications(userId);
   const newest = persisted[0]?.createdAt?.getTime() ?? 0;
   const hasDemo = persisted.some((row) => row.generatedBy === "demo");
+  const hasLegacyMock = hasLegacyMockSeed(persisted);
   const fresh = newest > Date.now() - FRESH_MS;
 
-  if (persisted.length && (hasDemo || (!opts.refresh && fresh))) {
+  if (persisted.length && !hasLegacyMock && (hasDemo || (!opts.refresh && fresh))) {
     const mode = hasDemo ? "demo" : hasAnyRealActivity(ctx) ? "dynamic" : "day1";
     return {
       generatedAt: new Date().toISOString(),
@@ -459,6 +641,9 @@ export async function getHomeFeed(userId: string, opts: { refresh?: boolean } =
       artifacts: ctx.artifacts,
       recentEvents: ctx.events,
       serviceStates: ctx.serviceStates,
+      missionSuggestions: ctx.missionSuggestions,
+      userProfile: ctx.userProfile,
+      preferences: ctx.preferences,
       routeRules: SERVICE_HREFS,
     },
     seeds: deterministic,

src/home/types.ts

@@ -40,25 +40,57 @@ export type HomeFeedResponse = {
 };
 
 export const MODULE_META: Record<HomeModuleId, Omit<HomeModule, "count" | "notifications">> = {
-  suggestions: { id: "suggestions", label: "Suggestions", href: "/suggestions", accent: "orange" },
+  suggestions: { id: "suggestions", label: "Today's Queue", href: "/suggestions", accent: "orange" },
   missions: { id: "missions", label: "Missions", href: "/missions", accent: "orange" },
   social: { id: "social", label: "Social Branding", href: "/social", accent: "blue" },
   pathways: { id: "pathways", label: "Pathways", href: "/pathways", accent: "teal" },
-  productivity: { id: "productivity", label: "Productivity", href: "/productivity", accent: "orange" },
+  productivity: { id: "productivity", label: "Interview · Roleplay · Resume", href: "/agents", accent: "orange" },
   rewards: { id: "rewards", label: "Rewards", href: "/rewards", accent: "amber" },
 };
 
-export const MODULE_IDS: HomeModuleId[] = ["suggestions", "missions", "social", "pathways", "productivity", "rewards"];
+export const MODULE_IDS: HomeModuleId[] = [
+  "suggestions",
+  "missions",
+  "social",
+  "pathways",
+  "productivity",
+  "rewards",
+];
 
 export const ALLOWED_NOTIFICATION_HREFS = new Set([
   "/suggestions",
   "/missions",
+  "/missions/active",
+  "/missions/available",
   "/social",
   "/pathways",
   "/productivity",
   "/rewards",
   "/agents/resume",
   "/agents/interview",
+  "/agents/interview/setup",
   "/agents/roleplay",
+  "/agents/roleplay/setup",
   "/agents/qscore",
 ]);
+
+export const ALLOWED_NOTIFICATION_HREF_PREFIXES = [
+  "/missions/",
+  "/missions/active",
+  "/missions/available",
+  "/agents/resume",
+  "/agents/interview",
+  "/agents/interview/setup",
+  "/agents/roleplay",
+  "/agents/roleplay/setup",
+  "/agents/qscore",
+] as const;
+
+export function isAllowedNotificationHref(href: string) {
+  if (ALLOWED_NOTIFICATION_HREFS.has(href)) return true;
+  return ALLOWED_NOTIFICATION_HREF_PREFIXES.some((prefix) =>
+    prefix.endsWith("/")
+      ? href.startsWith(prefix)
+      : href === prefix || href.startsWith(`${prefix}?`),
+  );
+}

src/index.ts

@@ -18,6 +18,10 @@ import { growRoutes } from "./routes/grow.js";
 import { missionRoutes } from "./routes/missions.js";
 import { eventRoutes } from "./routes/events.js";
 import { homeRoutes } from "./routes/home.js";
+import { dailyMissionRoutes } from "./routes/daily-mission.js";
+import { analyticsRoutes } from "./routes/analytics.js";
+import { logRoutes } from "./routes/logs.js";
+import { v1Routes } from "./v1/index.js";
 import { startGrowEventsRedisConsumer } from "./events/redis-consumer.js";
 import { db } from "./db/client.js";
 import { hydratePortAllocator, reconcileOnBoot, ensureCentralGiteaReady } from "./docker/manager.js";
@@ -86,7 +90,11 @@ async function main() {
   app.route("/grow", growRoutes());
   app.route("/missions", missionRoutes());
   app.route("/events", eventRoutes());
+  app.route("/analytics", analyticsRoutes());
+  app.route("/v1", v1Routes());
+  app.route("/logs", logRoutes());
   app.route("/home", homeRoutes());
+  app.route("/daily-mission", dailyMissionRoutes());
   app.route("/conversations", conversationRoutes());
   app.route("/opencode", opencodeRoutes());
   app.route("/git", gitRoutes());

src/lib/prompt-loader.ts

@@ -164,7 +164,7 @@ export async function loadPromptsFromDisk(): Promise<void> {
   } catch (err) {
     log.error({ err, path: SYSTEM_PROMPT_FILE }, "failed to load system prompt — using fallback");
     // Fallback: assemble from modules without a template file.
-    const fallback = `You are the Grow Agent — a unified AI orchestrator for the GrowQR platform.\n\n## Sub-Agent Capabilities\n\n${modules.map((m) => `- **${m.name}**: ${m.description}`).join("\n")}`;
+    const fallback = `You are Grow — a unified AI career assistant for the GrowQR platform.\n\n## Specialist Capabilities\n\n${modules.map((m) => `- **${m.name}**: ${m.description}`).join("\n")}`;
     cachedSystemPrompt = fallback;
   }
 }

src/missions/action-types.ts

@@ -0,0 +1,80 @@
+import type { InferSelectModel } from "drizzle-orm";
+import type { missionActions } from "../db/schema.js";
+
+export type MissionActionMode = "autonomous" | "approval_required" | "user_input_required" | "suggestion";
+export type MissionActionStatus =
+  | "queued"
+  | "running"
+  | "waiting_approval"
+  | "waiting_user_input"
+  | "done"
+  | "failed"
+  | "dismissed"
+  | "snoozed";
+export type MissionActionUrgency = "now" | "today" | "soon" | "calm";
+
+export type MissionActionRow = InferSelectModel<typeof missionActions>;
+
+export type MissionActionDto = {
+  id: string;
+  userId: string;
+  missionInstanceId: string;
+  missionId: string;
+  stageId?: string;
+  agentId: string;
+  agentName: string;
+  baseAgent?: string;
+  serviceId?: string;
+  toolName?: string;
+  mode: MissionActionMode;
+  status: MissionActionStatus;
+  title: string;
+  body: string;
+  prompt?: string;
+  payload: Record<string, unknown>;
+  result?: Record<string, unknown>;
+  error?: string;
+  sourceEventId?: string;
+  idempotencyKey?: string;
+  priority: number;
+  urgency: MissionActionUrgency;
+  dueAt?: string;
+  createdAt: string;
+  updatedAt: string;
+  resolvedAt?: string;
+};
+
+export type NewMissionActionInput = {
+  userId: string;
+  missionInstanceId: string;
+  missionId: string;
+  stageId?: string;
+  agentId: string;
+  agentName: string;
+  baseAgent?: string;
+  serviceId?: string;
+  toolName?: string;
+  mode: MissionActionMode;
+  status?: MissionActionStatus;
+  title: string;
+  body: string;
+  prompt?: string;
+  payload?: Record<string, unknown>;
+  result?: Record<string, unknown>;
+  error?: string;
+  sourceEventId?: string;
+  idempotencyKey?: string;
+  priority?: number;
+  urgency?: MissionActionUrgency;
+  dueAt?: Date | string;
+};
+
+export function defaultMissionActionStatus(mode: MissionActionMode): MissionActionStatus {
+  if (mode === "approval_required") return "waiting_approval";
+  if (mode === "user_input_required") return "waiting_user_input";
+  return "queued";
+}
+
+export function isOpenMissionActionStatus(status: MissionActionStatus) {
+  return status === "queued" || status === "running" || status === "waiting_approval" || status === "waiting_user_input" || status === "failed";
+}

src/missions/actions.ts

@@ -0,0 +1,191 @@
+import { and, desc, eq, inArray } from "drizzle-orm";
+import { db } from "../db/client.js";
+import { missionActions, missionSuggestions } from "../db/schema.js";
+import type { GrowActiveMission } from "../actors/missions/types.js";
+import type { MissionActionPatch } from "./reducer-types.js";
+import { defaultMissionActionStatus, type MissionActionDto, type MissionActionRow, type MissionActionStatus, type NewMissionActionInput } from "./action-types.js";
+import { missionDetailHref, serviceHref } from "./reducer-helpers.js";
+
+const OPEN_STATUSES: MissionActionStatus[] = ["queued", "running", "waiting_approval", "waiting_user_input", "failed"];
+const DONE_STATUSES: MissionActionStatus[] = ["done", "dismissed", "snoozed"];
+
+function toDate(value?: Date | string) {
+  if (!value) return undefined;
+  return value instanceof Date ? value : new Date(value);
+}
+
+export function actionToDto(row: MissionActionRow): MissionActionDto {
+  return {
+    id: row.id,
+    userId: row.userId,
+    missionInstanceId: row.missionInstanceId,
+    missionId: row.missionId,
+    stageId: row.stageId ?? undefined,
+    agentId: row.agentId,
+    agentName: row.agentName,
+    baseAgent: row.baseAgent ?? undefined,
+    serviceId: row.serviceId ?? undefined,
+    toolName: row.toolName ?? undefined,
+    mode: row.mode,
+    status: row.status,
+    title: row.title,
+    body: row.body,
+    prompt: row.prompt ?? undefined,
+    payload: row.payload ?? {},
+    result: row.result ?? undefined,
+    error: row.error ?? undefined,
+    sourceEventId: row.sourceEventId ?? undefined,
+    idempotencyKey: row.idempotencyKey ?? undefined,
+    priority: row.priority,
+    urgency: row.urgency,
+    dueAt: row.dueAt?.toISOString(),
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    resolvedAt: row.resolvedAt?.toISOString(),
+  };
+}
+
+function ctaForAction(action: MissionActionRow | NewMissionActionInput) {
+  const payload = action.payload && typeof action.payload === "object" && !Array.isArray(action.payload) ? action.payload as Record<string, unknown> : {};
+  const hrefFromPayload = typeof payload.href === "string" ? payload.href : undefined;
+  const serviceId = action.serviceId ?? "";
+  const missionHref = missionDetailHref(action.missionInstanceId);
+  const href = hrefFromPayload ??
+    (serviceId.includes("interview") ? serviceHref("interview", action.missionInstanceId, action.missionId, action.stageId ?? undefined) :
+     serviceId.includes("roleplay") ? serviceHref("roleplay", action.missionInstanceId, action.missionId, action.stageId ?? undefined) :
+     serviceId.includes("resume") ? serviceHref("resume", action.missionInstanceId, action.missionId, action.stageId ?? undefined) : missionHref);
+
+  if (action.mode === "approval_required") return { ctaLabel: "Review", ctaHref: missionHref };
+  if (action.mode === "user_input_required") return { ctaLabel: "Answer", ctaHref: missionHref };
+  if (serviceId.includes("interview")) return { ctaLabel: "Start mock", ctaHref: href };
+  if (serviceId.includes("roleplay")) return { ctaLabel: "Run drill", ctaHref: href };
+  if (serviceId.includes("resume")) return { ctaLabel: "Open resume", ctaHref: href };
+  return { ctaLabel: "Open", ctaHref: href };
+}
+
+function suggestionTypeForAction(action: MissionActionRow | NewMissionActionInput) {
+  if (action.mode === "user_input_required") return "blocked" as const;
+  if (action.mode === "approval_required") return "review" as const;
+  if ((action.serviceId ?? "").includes("interview") || (action.serviceId ?? "").includes("roleplay")) return "practice" as const;
+  if ((action.serviceId ?? "").includes("resume")) return "artifact" as const;
+  return "action" as const;
+}
+
+async function refreshSuggestionForAction(row: MissionActionRow) {
+  const active = OPEN_STATUSES.includes(row.status);
+  const { ctaLabel, ctaHref } = ctaForAction(row);
+  const status = active ? "active" : row.status === "done" ? "done" : "dismissed";
+
+  await db.insert(missionSuggestions).values({
+    id: `suggestion:${row.id}`,
+    userId: row.userId,
+    missionInstanceId: row.missionInstanceId,
+    missionId: row.missionId,
+    stageId: row.stageId,
+    role: row.agentName,
+    type: suggestionTypeForAction(row),
+    title: row.title,
+    body: row.body,
+    reason: row.prompt,
+    priority: row.priority,
+    urgency: row.urgency,
+    status,
+    ctaLabel,
+    ctaHref,
+    sourceRefs: { actionId: row.id, sourceEventId: row.sourceEventId, toolName: row.toolName },
+    generatedBy: "agent",
+    updatedAt: new Date(),
+  }).onConflictDoUpdate({
+    target: missionSuggestions.id,
+    set: {
+      stageId: row.stageId,
+      role: row.agentName,
+      type: suggestionTypeForAction(row),
+      title: row.title,
+      body: row.body,
+      reason: row.prompt,
+      priority: row.priority,
+      urgency: row.urgency,
+      status,
+      ctaLabel,
+      ctaHref,
+      sourceRefs: { actionId: row.id, sourceEventId: row.sourceEventId, toolName: row.toolName },
+      generatedBy: "agent",
+      updatedAt: new Date(),
+    },
+  });
+}
+
+export async function createMissionAction(input: NewMissionActionInput) {
+  const [row] = await db.insert(missionActions).values({
+    ...input,
+    status: input.status ?? defaultMissionActionStatus(input.mode),
+    priority: input.priority ?? 0,
+    urgency: input.urgency ?? "calm",
+    payload: input.payload ?? {},
+    result: input.result,
+    dueAt: toDate(input.dueAt),
+    updatedAt: new Date(),
+  }).onConflictDoNothing().returning();
+  if (!row) return null;
+  await refreshSuggestionForAction(row);
+  return actionToDto(row);
+}
+
+export async function createMissionActionsFromPatches(input: { userId: string; mission: GrowActiveMission; eventId: string; patches: MissionActionPatch[] }) {
+  const created: MissionActionDto[] = [];
+  for (const patch of input.patches) {
+    const action = await createMissionAction({
+      userId: input.userId,
+      missionInstanceId: input.mission.instanceId,
+      missionId: input.mission.missionId,
+      stageId: patch.stageId,
+      agentId: patch.agentId,
+      agentName: patch.agentName,
+      baseAgent: patch.baseAgent,
+      serviceId: patch.serviceId,
+      toolName: patch.toolName,
+      mode: patch.mode,
+      status: patch.status,
+      title: patch.title,
+      body: patch.body,
+      prompt: patch.prompt,
+      payload: patch.payload ?? {},
+      sourceEventId: patch.sourceEventId ?? input.eventId,
+      idempotencyKey: patch.idempotencyKey,
+      priority: patch.priority,
+      urgency: patch.urgency,
+      dueAt: patch.dueAt,
+    });
+    if (action) created.push(action);
+  }
+  return created;
+}
+
+export async function listMissionActions(userId: string, opts: { missionInstanceId?: string; openOnly?: boolean } = {}) {
+  const conditions = [eq(missionActions.userId, userId)];
+  if (opts.missionInstanceId) conditions.push(eq(missionActions.missionInstanceId, opts.missionInstanceId));
+  if (opts.openOnly ?? true) conditions.push(inArray(missionActions.status, OPEN_STATUSES));
+  const rows = await db.select().from(missionActions).where(and(...conditions)).orderBy(desc(missionActions.priority), desc(missionActions.updatedAt));
+  return rows.map(actionToDto);
+}
+
+export async function getMissionAction(userId: string, actionId: string) {
+  const [row] = await db.select().from(missionActions).where(and(eq(missionActions.userId, userId), eq(missionActions.id, actionId))).limit(1);
+  return row ?? null;
+}
+
+export async function updateMissionActionStatus(userId: string, actionId: string, patch: { status: MissionActionStatus; result?: Record<string, unknown>; error?: string; payload?: Record<string, unknown> }) {
+  const resolvedAt = DONE_STATUSES.includes(patch.status) ? new Date() : undefined;
+  const [row] = await db.update(missionActions).set({
+    status: patch.status,
+    result: patch.result,
+    error: patch.error,
+    payload: patch.payload,
+    resolvedAt,
+    updatedAt: new Date(),
+  }).where(and(eq(missionActions.userId, userId), eq(missionActions.id, actionId))).returning();
+  if (!row) return null;
+  await refreshSuggestionForAction(row);
+  return actionToDto(row);
+}

src/missions/career-transition/reducer.ts

@@ -0,0 +1,89 @@
+import type { MissionReducer, MissionReduction, MissionStagePatch } from "../reducer-types.js";
+import { actionForAgent, extractResumeSignals, extractWeakAreas, isInterviewEvent, isRelevantServiceEvent, isResumeEvent, isRoleplayEvent, missionExplicitlyMatches, serviceHref } from "../reducer-helpers.js";
+
+export const careerTransitionReducer: MissionReducer = {
+  missionId: "career-transition",
+  accepts(ctx) {
+    return ctx.activeMission.missionId === "career-transition" &&
+      (missionExplicitlyMatches(ctx.event.mission, "career-transition") || isRelevantServiceEvent(ctx.event.source, ctx.event.type));
+  },
+  reduce(ctx): MissionReduction {
+    const { event, activeMission } = ctx;
+    const type = event.type;
+    const payload = event.payload ?? {};
+    const stagePatches: MissionStagePatch[] = [];
+    const artifacts: MissionReduction["artifacts"] = [];
+    const actions: MissionReduction["actions"] = [];
+    let eventMessage = ctx.insight.summary;
+
+    if (!activeMission.goal && (type === "mission.started" || type.startsWith("mission."))) {
+      actions.push(actionForAgent("career-transition", "planner", {
+        stageId: "clarify-target",
+        mode: "user_input_required",
+        title: "Choose the target role for your transition",
+        body: "Career transition needs a clear adjacent role before resume repositioning or practice will be useful.",
+        prompt: "What role are you exploring next, and what role/background are you moving from?",
+        payload: { fields: ["current_role", "target_role", "constraints"] },
+        idempotencyKey: `${activeMission.instanceId}:clarify-target-role`,
+        priority: 100,
+        urgency: "now",
+      }));
+    }
+
+    if (isResumeEvent(event.source, type) && (type.includes("analysis") || type.includes("parsed") || type.includes("analyzed"))) {
+      const signals = extractResumeSignals(payload);
+      stagePatches.push({ stageId: "resume", status: "done", progressPercent: 100, outputSummary: "Transferable skills mapped from resume evidence." });
+      stagePatches.push({ stageId: "interview", status: "ready", progressPercent: 0, outputSummary: "Validate the transition story in an adjacent-role mock interview." });
+      artifacts.push({ type: "transferable_skills_map", title: "Transferable skills map", stageId: "resume", summary: signals[0] ?? "Resume proof was mapped into transition evidence.", metadata: { sourceEventId: event.id, signals } });
+      actions.push(actionForAgent("career-transition", "resume", {
+        stageId: "resume",
+        serviceId: "resume-service",
+        toolName: "resume.create_version_prompt_draft",
+        mode: "approval_required",
+        title: "Draft a repositioned resume for the target role?",
+        body: "Approve a Resume Agent draft that reframes your transferable skills for the career switch.",
+        payload: { signals, href: serviceHref("resume", activeMission.instanceId, activeMission.missionId, "resume") },
+        sourceEventId: event.id,
+        idempotencyKey: `${activeMission.instanceId}:resume-transition-draft:${event.id}`,
+        priority: 95,
+        urgency: "today",
+      }));
+      eventMessage = "Transferable skills map created; repositioned resume action is ready.";
+    }
+
+    if (isInterviewEvent(event.source, type) && type.includes("configured")) {
+      stagePatches.push({ stageId: "interview", status: "in_progress", progressPercent: 40, outputSummary: "Adjacent-role mock interview configured." });
+      eventMessage = "Adjacent-role interview practice started.";
+    }
+
+    if (isInterviewEvent(event.source, type) && type.includes("review_completed")) {
+      const weakAreas = extractWeakAreas(payload);
+      stagePatches.push({ stageId: "interview", status: "done", progressPercent: 100, outputSummary: "Adjacent-role credibility checked." });
+      stagePatches.push({ stageId: "roleplay", status: "ready", progressPercent: 0, outputSummary: "Practice the 'why I am switching' narrative next." });
+      artifacts.push({ type: "transition_interview_diagnosis", title: "Adjacent-role credibility diagnosis", stageId: "interview", summary: weakAreas.length ? `Needs work: ${weakAreas.join(", ")}` : "Interview review completed for transition credibility.", metadata: { sourceEventId: event.id, weakAreas } });
+      actions.push(actionForAgent("career-transition", "roleplay", {
+        stageId: "roleplay",
+        serviceId: "roleplay-service",
+        toolName: "roleplay.configure_practice",
+        mode: "suggestion",
+        title: "Practice your 'why I am switching' pitch",
+        body: "Turn the adjacent-role feedback into a confident transition narrative before real conversations.",
+        payload: { weakAreas, href: serviceHref("roleplay", activeMission.instanceId, activeMission.missionId, "roleplay") },
+        sourceEventId: event.id,
+        idempotencyKey: `${activeMission.instanceId}:transition-pitch-roleplay:${event.id}`,
+        priority: 92,
+        urgency: "today",
+      }));
+      eventMessage = "Career transition interview feedback produced the next pitch-practice action.";
+    }
+
+    if (isRoleplayEvent(event.source, type) && type.includes("review_completed")) {
+      stagePatches.push({ stageId: "roleplay", status: "done", progressPercent: 100, outputSummary: "Transition pitch practice reviewed." });
+      stagePatches.push({ stageId: "qscore", status: "in_progress", progressPercent: 70, outputSummary: "Transition confidence signals updated." });
+      eventMessage = "Transition narrative practice completed.";
+    }
+
+    if (ctx.qscoreSignals.length) stagePatches.push({ stageId: "qscore", status: "in_progress", progressPercent: Math.min(90, 45 + ctx.qscoreSignals.length * 10), outputSummary: "Transition readiness signals updated." });
+    return { stagePatches, artifacts, actions, eventMessage };
+  },
+};

src/missions/event-reducers.ts

@@ -1,7 +1,17 @@
 import type { MissionReducer } from "./reducer-types.js";
 import { interviewToOfferReducer } from "./interview-to-offer/reducer.js";
+import { careerTransitionReducer } from "./career-transition/reducer.js";
+import { salaryNegotiationReducer } from "./salary-negotiation-war-room/reducer.js";
+import { promotionReadinessReducer } from "./promotion-readiness/reducer.js";
+import { personalBrandOpportunityReducer } from "./personal-brand-opportunity-engine/reducer.js";
 
-export const missionEventReducers: MissionReducer[] = [interviewToOfferReducer];
+export const missionEventReducers: MissionReducer[] = [
+  interviewToOfferReducer,
+  careerTransitionReducer,
+  salaryNegotiationReducer,
+  promotionReadinessReducer,
+  personalBrandOpportunityReducer,
+];
 
 export function reducersForMission(missionId: string) {
   return missionEventReducers.filter((reducer) => reducer.missionId === missionId);

src/missions/interview-to-offer/reducer.ts

@@ -1,99 +1,147 @@
-import { asRecord, getNumber, getString } from "../../events/envelope.js";
-import type { MissionArtifactPatch, MissionReducer, MissionReduction, MissionStagePatch } from "../reducer-types.js";
+import { getString } from "../../events/envelope.js";
+import type { MissionReducer, MissionReduction, MissionStagePatch } from "../reducer-types.js";
+import {
+  actionForAgent,
+  extractOverallScore,
+  extractResumeSignals,
+  extractWeakAreas,
+  isInterviewEvent,
+  isQscoreEvent,
+  isRelevantServiceEvent,
+  isResumeEvent,
+  isRoleplayEvent,
+  missionExplicitlyMatches,
+  serviceHref,
+} from "../reducer-helpers.js";
 
-function eventMatchesSource(source: string, type: string) {
-  return (
-    source.includes("resume") ||
-    source.includes("interview") ||
-    source.includes("qscore") ||
-    type.startsWith("resume.") ||
-    type.startsWith("interview.") ||
-    type.startsWith("qscore.") ||
-    type.startsWith("mission.interview_to_offer")
-  );
+function acceptsMission(ctx: Parameters<MissionReducer["accepts"]>[0]) {
+  return ctx.activeMission.missionId === "interview-to-offer" &&
+    (missionExplicitlyMatches(ctx.event.mission, "interview-to-offer") || isRelevantServiceEvent(ctx.event.source, ctx.event.type));
 }
 
 function reviewSummary(payload: Record<string, unknown>) {
-  const review = asRecord(payload.review ?? payload.result ?? payload);
-  const overall = getNumber(review.overall_score ?? review.overallScore);
-  const summary = getString(review.summary ?? review.feedback_summary ?? review.overall_feedback);
-  if (overall !== undefined && summary) return `Mock interview review completed with score ${overall}. ${summary}`;
-  if (overall !== undefined) return `Mock interview review completed with score ${overall}.`;
+  const score = extractOverallScore(payload);
+  const summary = getString(payload.summary ?? payload.feedback_summary ?? payload.overall_feedback);
+  if (score !== undefined && summary) return `Mock interview review completed with score ${score}. ${summary}`;
+  if (score !== undefined) return `Mock interview review completed with score ${score}.`;
   return summary ?? "Mock interview review completed.";
 }
 
 export const interviewToOfferReducer: MissionReducer = {
   missionId: "interview-to-offer",
-
-  accepts(ctx) {
-    if (ctx.activeMission.missionId !== "interview-to-offer") return false;
-    const mission = asRecord(ctx.event.mission);
-    const explicitMissionId = getString(mission.missionId ?? mission.mission_id);
-    return explicitMissionId === "interview-to-offer" || eventMatchesSource(ctx.event.source.toLowerCase(), ctx.event.type);
-  },
+  accepts: acceptsMission,
 
   reduce(ctx): MissionReduction {
-    const type = ctx.event.type;
-    const payload = ctx.event.payload ?? {};
+    const { event, activeMission } = ctx;
+    const type = event.type;
+    const payload = event.payload ?? {};
     const stagePatches: MissionStagePatch[] = [...ctx.insight.missionStageHints.map((hint) => ({
       stageId: hint.stageId,
       status: hint.status,
       progressPercent: hint.progressPercent,
       outputSummary: hint.reason,
     }))];
-    const artifacts: MissionArtifactPatch[] = [];
+    const artifacts: MissionReduction["artifacts"] = [];
+    const actions: MissionReduction["actions"] = [];
     let eventMessage = ctx.insight.summary;
 
-    if (type.startsWith("resume.") && (type.includes("analysis_completed") || type.includes("analysis.complete") || type.includes("analyzed"))) {
-      stagePatches.push({ stageId: "resume", status: "done", progressPercent: 100, outputSummary: "Resume fit scan completed." });
-      stagePatches.push({ stageId: "interview-plan", status: "ready", progressPercent: 0 });
+    if (isResumeEvent(event.source, type) && (type.includes("analysis_completed") || type.includes("analysis.complete") || type.includes("analyzed"))) {
+      const signals = extractResumeSignals(payload);
+      stagePatches.push({ stageId: "resume", status: "done", progressPercent: 100, outputSummary: "Resume talking points and fit scan are ready." });
+      stagePatches.push({ stageId: "interview", status: "ready", progressPercent: 0 });
       artifacts.push({
-        type: "resume_fit_scan",
-        title: "Resume Fit Scan",
+        type: "resume_talking_points",
+        title: "Resume-based talking points",
         stageId: "resume",
-        summary: getString(payload.summary) ?? "Resume analysis completed and readiness signals were updated.",
-        metadata: { sourceEventId: ctx.event.id, payload },
+        summary: signals[0] ?? "Resume analysis completed and role-fit talking points are ready.",
+        metadata: { sourceEventId: event.id, signals, payload },
       });
-      eventMessage = "Resume fit scan completed for Interview-to-Offer.";
+      actions.push(actionForAgent("interview-to-offer", "interview", {
+        stageId: "interview",
+        serviceId: "interview-service",
+        toolName: "interview.configure_practice",
+        mode: "suggestion",
+        title: "Start the first mock interview",
+        body: "Your resume proof is ready. Run a targeted mock interview for the scheduled role now.",
+        payload: { href: serviceHref("interview", activeMission.instanceId, activeMission.missionId, "interview") },
+        sourceEventId: event.id,
+        idempotencyKey: `${activeMission.instanceId}:resume-analysis:start-interview:${event.id}`,
+        priority: 92,
+        urgency: "today",
+      }));
+      eventMessage = "Resume fit scan completed; mock interview is ready to run.";
     }
 
-    if (type.startsWith("interview.") && (type.includes("configured") || type.includes("created"))) {
+    if (isInterviewEvent(event.source, type) && (type.includes("configured") || type.includes("created"))) {
       stagePatches.push({ stageId: "interview", status: "in_progress", progressPercent: 35, outputSummary: "Mock interview session configured." });
       eventMessage = "Mock interview session configured.";
     }
 
-    if (type.startsWith("interview.") && (type.includes("session_completed") || type.includes("session.completed"))) {
+    if (isInterviewEvent(event.source, type) && (type.includes("session_completed") || type.includes("session.completed"))) {
       stagePatches.push({ stageId: "interview", status: "in_progress", progressPercent: 75, outputSummary: "Interview completed; review is being prepared." });
       eventMessage = "Mock interview completed; waiting for review.";
     }
 
-    if (type.startsWith("interview.") && (type.includes("review_completed") || type.includes("review.completed"))) {
+    if (isInterviewEvent(event.source, type) && (type.includes("review_completed") || type.includes("review.completed"))) {
+      const weakAreas = extractWeakAreas(payload);
       stagePatches.push({ stageId: "interview", status: "done", progressPercent: 100, outputSummary: reviewSummary(payload) });
+      stagePatches.push({ stageId: "roleplay", status: "ready", progressPercent: 0, outputSummary: "Practice the communication gaps surfaced by interview feedback." });
       stagePatches.push({ stageId: "qscore", status: "in_progress", progressPercent: 60, outputSummary: "Readiness signals updated from interview review." });
       artifacts.push({
         type: "mock_interview_review",
-        title: "Mock Interview Review",
+        title: "Weakness diagnosis",
         stageId: "interview",
         summary: reviewSummary(payload),
-        metadata: { sourceEventId: ctx.event.id, payload },
+        metadata: { sourceEventId: event.id, weakAreas, payload },
       });
-      eventMessage = "Mock interview review completed and mission readiness was updated.";
+      actions.push(actionForAgent("interview-to-offer", "resume", {
+        stageId: "resume",
+        serviceId: "resume-service",
+        toolName: "resume.create_version_prompt_draft",
+        mode: "approval_required",
+        title: "Create a tailored resume version from this interview feedback?",
+        body: weakAreas.length
+          ? `The interview exposed ${weakAreas.slice(0, 3).join(", ")}. Approve a Resume Agent draft that turns this feedback into targeted bullets and talking points.`
+          : "Approve a Resume Agent draft that turns the interview feedback into targeted bullets and talking points.",
+        payload: { weakAreas, sourceReviewEventId: event.id, href: serviceHref("resume", activeMission.instanceId, activeMission.missionId, "resume") },
+        sourceEventId: event.id,
+        idempotencyKey: `${activeMission.instanceId}:interview-review:tailor-resume:${event.id}`,
+        priority: 100,
+        urgency: "now",
+      }));
+      if (weakAreas.some((area) => /communication|story|clarity|confidence|concise/i.test(area))) {
+        actions.push(actionForAgent("interview-to-offer", "roleplay", {
+          stageId: "roleplay",
+          serviceId: "roleplay-service",
+          toolName: "roleplay.configure_practice",
+          mode: "suggestion",
+          title: "Run a communication recovery drill",
+          body: "Practice the exact communication weakness from the mock interview before the real interview.",
+          payload: { weakAreas, href: serviceHref("roleplay", activeMission.instanceId, activeMission.missionId, "roleplay") },
+          sourceEventId: event.id,
+          idempotencyKey: `${activeMission.instanceId}:interview-review:roleplay:${event.id}`,
+          priority: 94,
+          urgency: "today",
+        }));
+      }
+      eventMessage = "Interview review completed; resume and roleplay next actions were created.";
     }
 
-    if (ctx.qscoreSignals.length > 0) {
+    if (isRoleplayEvent(event.source, type) && type.includes("review_completed")) {
+      stagePatches.push({ stageId: "roleplay", status: "done", progressPercent: 100, outputSummary: "Communication drill reviewed." });
+      stagePatches.push({ stageId: "qscore", status: "in_progress", progressPercent: 75, outputSummary: "Communication readiness updated." });
+      eventMessage = "Roleplay review improved interview communication readiness.";
+    }
+
+    if (ctx.qscoreSignals.length > 0 || (isQscoreEvent(event.source, type) && type.includes("updated"))) {
       stagePatches.push({
         stageId: "qscore",
-        status: "in_progress",
-        progressPercent: Math.max(40, Math.min(90, ctx.qscoreSignals.length * 15)),
-        outputSummary: `${ctx.qscoreSignals.length} readiness signal${ctx.qscoreSignals.length === 1 ? "" : "s"} updated.`,
+        status: type.startsWith("qscore.") ? "done" : "in_progress",
+        progressPercent: type.startsWith("qscore.") ? 100 : Math.max(40, Math.min(90, ctx.qscoreSignals.length * 15)),
+        outputSummary: `${ctx.qscoreSignals.length || 1} readiness signal${ctx.qscoreSignals.length === 1 ? "" : "s"} updated.`,
       });
     }
 
-    if (type.startsWith("qscore.") && (type.includes("snapshot") || type.includes("computed") || type.includes("updated"))) {
-      stagePatches.push({ stageId: "qscore", status: "done", progressPercent: 100, outputSummary: "Readiness Q Score updated." });
-      eventMessage = "Readiness Q Score updated.";
-    }
-
-    return { stagePatches, artifacts, eventMessage };
+    return { stagePatches, artifacts, actions, eventMessage };
   },
 };

src/missions/personal-brand-opportunity-engine/reducer.ts

@@ -0,0 +1,83 @@
+import type { MissionReducer, MissionReduction, MissionStagePatch } from "../reducer-types.js";
+import { actionForAgent, extractResumeSignals, extractWeakAreas, isInterviewEvent, isRelevantServiceEvent, isResumeEvent, isRoleplayEvent, missionDetailHref, missionExplicitlyMatches, serviceHref } from "../reducer-helpers.js";
+
+export const personalBrandOpportunityReducer: MissionReducer = {
+  missionId: "personal-brand-opportunity-engine",
+  accepts(ctx) {
+    return ctx.activeMission.missionId === "personal-brand-opportunity-engine" &&
+      (missionExplicitlyMatches(ctx.event.mission, "personal-brand-opportunity-engine") || isRelevantServiceEvent(ctx.event.source, ctx.event.type));
+  },
+  reduce(ctx): MissionReduction {
+    const { event, activeMission } = ctx;
+    const type = event.type;
+    const payload = event.payload ?? {};
+    const stagePatches: MissionStagePatch[] = [];
+    const artifacts: MissionReduction["artifacts"] = [];
+    const actions: MissionReduction["actions"] = [];
+    let eventMessage = ctx.insight.summary;
+
+    if (type === "mission.started" || type.startsWith("mission.")) {
+      actions.push(actionForAgent("personal-brand-opportunity-engine", "planner", {
+        stageId: "positioning",
+        mode: "user_input_required",
+        title: "Pick the audience you want to be known by",
+        body: "Personal brand only works when the target audience and credibility theme are explicit.",
+        prompt: "Who should notice you, and what do you want to be known for?",
+        payload: { fields: ["target_audience", "positioning_theme", "proof_points"] },
+        idempotencyKey: `${activeMission.instanceId}:brand-positioning`,
+        priority: 96,
+        urgency: "today",
+      }));
+    }
+
+    if (isResumeEvent(event.source, type) && (type.includes("analysis") || type.includes("parsed") || type.includes("analyzed"))) {
+      const signals = extractResumeSignals(payload);
+      stagePatches.push({ stageId: "resume", status: "done", progressPercent: 100, outputSummary: "Proof points extracted for positioning." });
+      stagePatches.push({ stageId: "roleplay", status: "ready", progressPercent: 0, outputSummary: "Practice networking pitch next." });
+      artifacts.push({ type: "positioning_statement", title: "Positioning statement draft", stageId: "resume", summary: signals[0] ?? "Strongest proof points were extracted from resume evidence.", metadata: { sourceEventId: event.id, signals } });
+      actions.push(actionForAgent("personal-brand-opportunity-engine", "resume", {
+        stageId: "resume",
+        serviceId: "resume-service",
+        toolName: "resume.create_version_prompt_draft",
+        mode: "approval_required",
+        title: "Draft your profile positioning statement?",
+        body: "Approve a draft that turns your strongest resume proof into a clear LinkedIn/profile positioning statement.",
+        payload: { signals, href: serviceHref("resume", activeMission.instanceId, activeMission.missionId, "resume") },
+        sourceEventId: event.id,
+        idempotencyKey: `${activeMission.instanceId}:brand-positioning-draft:${event.id}`,
+        priority: 92,
+        urgency: "today",
+      }));
+      eventMessage = "Resume proof points created a profile positioning action.";
+    }
+
+    if (isRoleplayEvent(event.source, type) && type.includes("review_completed")) {
+      const weakAreas = extractWeakAreas(payload);
+      stagePatches.push({ stageId: "roleplay", status: "done", progressPercent: 100, outputSummary: "Networking pitch reviewed." });
+      stagePatches.push({ stageId: "qscore", status: "in_progress", progressPercent: 70, outputSummary: "Brand voice/readiness signals updated." });
+      artifacts.push({ type: "networking_scripts", title: "Networking script improvements", stageId: "roleplay", summary: weakAreas.length ? `Improve: ${weakAreas.join(", ")}` : "Networking pitch practice completed.", metadata: { sourceEventId: event.id, weakAreas } });
+      actions.push(actionForAgent("personal-brand-opportunity-engine", "planner", {
+        stageId: "positioning",
+        mode: "suggestion",
+        title: "Turn this pitch into weekly content pillars",
+        body: "Use the networking practice feedback to draft 3 credibility themes for weekly posts.",
+        payload: { weakAreas, href: missionDetailHref(activeMission.instanceId) },
+        sourceEventId: event.id,
+        idempotencyKey: `${activeMission.instanceId}:content-pillars:${event.id}`,
+        priority: 82,
+        urgency: "soon",
+      }));
+      eventMessage = "Networking pitch review created brand content next steps.";
+    }
+
+    if (isInterviewEvent(event.source, type) && type.includes("review_completed")) {
+      const weakAreas = extractWeakAreas(payload);
+      stagePatches.push({ stageId: "interview", status: "done", progressPercent: 100, outputSummary: "Credibility signals mined from interview review." });
+      artifacts.push({ type: "credibility_signal_map", title: "Credibility signal map", stageId: "interview", summary: weakAreas.length ? `Recurring gaps/themes: ${weakAreas.join(", ")}` : "Interview review mined for positioning signals.", metadata: { sourceEventId: event.id, weakAreas } });
+      eventMessage = "Interview feedback was mined for brand positioning signals.";
+    }
+
+    if (ctx.qscoreSignals.length) stagePatches.push({ stageId: "qscore", status: "in_progress", progressPercent: Math.min(90, 45 + ctx.qscoreSignals.length * 10), outputSummary: "Brand growth/readiness signals updated." });
+    return { stagePatches, artifacts, actions, eventMessage };
+  },
+};

src/missions/promotion-readiness/reducer.ts

@@ -0,0 +1,86 @@
+import type { MissionReducer, MissionReduction, MissionStagePatch } from "../reducer-types.js";
+import { actionForAgent, extractResumeSignals, extractWeakAreas, isInterviewEvent, isRelevantServiceEvent, isResumeEvent, isRoleplayEvent, missionExplicitlyMatches, serviceHref } from "../reducer-helpers.js";
+
+export const promotionReadinessReducer: MissionReducer = {
+  missionId: "promotion-readiness",
+  accepts(ctx) {
+    return ctx.activeMission.missionId === "promotion-readiness" &&
+      (missionExplicitlyMatches(ctx.event.mission, "promotion-readiness") || isRelevantServiceEvent(ctx.event.source, ctx.event.type));
+  },
+  reduce(ctx): MissionReduction {
+    const { event, activeMission } = ctx;
+    const type = event.type;
+    const payload = event.payload ?? {};
+    const stagePatches: MissionStagePatch[] = [];
+    const artifacts: MissionReduction["artifacts"] = [];
+    const actions: MissionReduction["actions"] = [];
+    let eventMessage = ctx.insight.summary;
+
+    if (type === "mission.started" || type.startsWith("mission.")) {
+      actions.push(actionForAgent("promotion-readiness", "planner", {
+        stageId: "promotion-context",
+        mode: "user_input_required",
+        title: "Clarify your promotion target",
+        body: "Promotion readiness needs the desired level, timeline, manager context, and stakeholder map.",
+        prompt: "What role/level are you targeting, by when, and what does your manager care about most?",
+        payload: { fields: ["current_role", "desired_role", "timeline", "manager_context", "stakeholders"] },
+        idempotencyKey: `${activeMission.instanceId}:promotion-context`,
+        priority: 100,
+        urgency: "today",
+      }));
+    }
+
+    if (isResumeEvent(event.source, type) && (type.includes("analysis") || type.includes("parsed") || type.includes("analyzed"))) {
+      const signals = extractResumeSignals(payload);
+      stagePatches.push({ stageId: "resume", status: "done", progressPercent: 100, outputSummary: "Promotion evidence extracted from achievement history." });
+      stagePatches.push({ stageId: "roleplay", status: "ready", progressPercent: 0, outputSummary: "Manager conversation practice is ready." });
+      artifacts.push({ type: "promotion_evidence_packet", title: "Promotion evidence packet", stageId: "resume", summary: signals[0] ?? "Achievement evidence extracted for promotion case.", metadata: { sourceEventId: event.id, signals } });
+      actions.push(actionForAgent("promotion-readiness", "roleplay", {
+        stageId: "roleplay",
+        serviceId: "roleplay-service",
+        toolName: "roleplay.configure_practice",
+        mode: "suggestion",
+        title: "Practice the manager promotion conversation",
+        body: "Use your achievement evidence in a realistic manager conversation drill.",
+        payload: { signals, href: serviceHref("roleplay", activeMission.instanceId, activeMission.missionId, "roleplay") },
+        sourceEventId: event.id,
+        idempotencyKey: `${activeMission.instanceId}:promotion-manager-roleplay:${event.id}`,
+        priority: 94,
+        urgency: "today",
+      }));
+      eventMessage = "Promotion evidence packet is ready; manager conversation practice is next.";
+    }
+
+    if (isRoleplayEvent(event.source, type) && type.includes("review_completed")) {
+      const weakAreas = extractWeakAreas(payload);
+      stagePatches.push({ stageId: "roleplay", status: "done", progressPercent: 100, outputSummary: "Manager conversation drill reviewed." });
+      stagePatches.push({ stageId: "interview", status: "ready", progressPercent: 0, outputSummary: "Practice leadership narratives next if gaps remain." });
+      artifacts.push({ type: "manager_conversation_script", title: "Manager conversation script", stageId: "roleplay", summary: weakAreas.length ? `Follow-up focus: ${weakAreas.join(", ")}` : "Manager conversation review completed.", metadata: { sourceEventId: event.id, weakAreas } });
+      actions.push(actionForAgent("promotion-readiness", "interview", {
+        stageId: "interview",
+        serviceId: "interview-service",
+        toolName: "interview.configure_practice",
+        mode: "suggestion",
+        title: "Practice leadership stories",
+        body: "Run a leadership-style mock interview to tighten the promotion case.",
+        payload: { weakAreas, href: serviceHref("interview", activeMission.instanceId, activeMission.missionId, "interview") },
+        sourceEventId: event.id,
+        idempotencyKey: `${activeMission.instanceId}:promotion-leadership-interview:${event.id}`,
+        priority: 86,
+        urgency: "soon",
+      }));
+      eventMessage = "Manager conversation review updated promotion readiness.";
+    }
+
+    if (isInterviewEvent(event.source, type) && type.includes("review_completed")) {
+      const weakAreas = extractWeakAreas(payload);
+      stagePatches.push({ stageId: "interview", status: "done", progressPercent: 100, outputSummary: "Leadership communication gap check completed." });
+      stagePatches.push({ stageId: "qscore", status: "in_progress", progressPercent: 75, outputSummary: "Leadership readiness signals updated." });
+      artifacts.push({ type: "leadership_gap_map", title: "Leadership gap map", stageId: "interview", summary: weakAreas.length ? weakAreas.join(", ") : "Leadership practice review completed.", metadata: { sourceEventId: event.id, weakAreas } });
+      eventMessage = "Leadership practice review updated the promotion gap map.";
+    }
+
+    if (ctx.qscoreSignals.length) stagePatches.push({ stageId: "qscore", status: "in_progress", progressPercent: Math.min(90, 45 + ctx.qscoreSignals.length * 10), outputSummary: "Promotion readiness signals updated." });
+    return { stagePatches, artifacts, actions, eventMessage };
+  },
+};

src/missions/reducer-helpers.ts

@@ -0,0 +1,147 @@
+import { asRecord, getNumber, getString } from "../events/envelope.js";
+import type { MissionActionPatch } from "./reducer-types.js";
+
+export function isResumeEvent(source: string, type: string) {
+  const value = source.toLowerCase();
+  return value.includes("resume") || type.startsWith("resume.");
+}
+
+export function isInterviewEvent(source: string, type: string) {
+  const value = source.toLowerCase();
+  return value.includes("interview") || type.startsWith("interview.");
+}
+
+export function isRoleplayEvent(source: string, type: string) {
+  const value = source.toLowerCase();
+  return value.includes("roleplay") || type.startsWith("roleplay.");
+}
+
+export function isQscoreEvent(source: string, type: string) {
+  const value = source.toLowerCase();
+  return value.includes("qscore") || type.startsWith("qscore.");
+}
+
+export function reviewRecord(payload: Record<string, unknown>) {
+  return asRecord(payload.review ?? payload.result ?? payload.data ?? payload);
+}
+
+export function extractOverallScore(payload: Record<string, unknown>) {
+  const review = reviewRecord(payload);
+  return getNumber(review.overall_score ?? review.overallScore ?? review.score ?? payload.overall_score);
+}
+
+export function extractWeakAreas(payload: Record<string, unknown>): string[] {
+  const review = reviewRecord(payload);
+  const candidates = [
+    review.weak_areas,
+    review.weakAreas,
+    review.improvement_areas,
+    review.improvementAreas,
+    review.recommendations,
+    review.gaps,
+  ];
+  const areas: string[] = [];
+  for (const candidate of candidates) {
+    if (Array.isArray(candidate)) {
+      for (const item of candidate) {
+        if (typeof item === "string" && item.trim()) areas.push(item.trim());
+        else if (item && typeof item === "object" && !Array.isArray(item)) {
+          const row = item as Record<string, unknown>;
+          const text = getString(row.title ?? row.area ?? row.name ?? row.label ?? row.summary);
+          if (text) areas.push(text);
+        }
+      }
+    } else if (typeof candidate === "string" && candidate.trim()) {
+      areas.push(...candidate.split(/[;,]/).map((part) => part.trim()).filter(Boolean));
+    }
+  }
+  const summary = getString(review.summary ?? review.feedback_summary ?? review.overall_feedback);
+  if (!areas.length && summary) {
+    const lower = summary.toLowerCase();
+    if (lower.includes("communication") || lower.includes("clarity") || lower.includes("story")) areas.push("communication clarity");
+    if (lower.includes("technical") || lower.includes("role")) areas.push("role-fit depth");
+    if (lower.includes("confidence") || lower.includes("concise")) areas.push("confidence and concision");
+  }
+  return Array.from(new Set(areas)).slice(0, 5);
+}
+
+export function extractResumeSignals(payload: Record<string, unknown>): string[] {
+  const analysis = asRecord(payload.analysis ?? payload.result ?? payload.data ?? payload);
+  const signals: string[] = [];
+  const summary = getString(analysis.summary ?? analysis.overall_feedback ?? payload.summary);
+  if (summary) signals.push(summary);
+  for (const key of ["strengths", "gaps", "recommendations", "missing_keywords", "keyword_gaps"]) {
+    const value = analysis[key];
+    if (Array.isArray(value)) {
+      for (const item of value.slice(0, 4)) if (typeof item === "string") signals.push(item);
+    }
+  }
+  return signals.slice(0, 8);
+}
+
+export function missionExplicitlyMatches(eventMission: unknown, missionId: string) {
+  const mission = asRecord(eventMission);
+  const explicit = getString(mission.missionId ?? mission.mission_id);
+  return explicit === missionId;
+}
+
+export function isRelevantServiceEvent(source: string, type: string) {
+  return isResumeEvent(source, type) || isInterviewEvent(source, type) || isRoleplayEvent(source, type) || isQscoreEvent(source, type);
+}
+
+const AGENT_NAMES: Record<string, Record<string, { agentId: string; baseAgent: string; agentName: string }>> = {
+  "interview-to-offer": {
+    planner: { agentId: "planner", baseAgent: "mission-planner", agentName: "Offer Strategist" },
+    resume: { agentId: "resume", baseAgent: "resume-strategist", agentName: "Resume Fit Agent" },
+    interview: { agentId: "interview", baseAgent: "interview-coach", agentName: "Mock Interviewer" },
+    roleplay: { agentId: "roleplay", baseAgent: "roleplay-coach", agentName: "Communication Coach" },
+    qscore: { agentId: "qscore", baseAgent: "qscore-analyst", agentName: "Readiness Analyst" },
+  },
+  "career-transition": {
+    planner: { agentId: "planner", baseAgent: "mission-planner", agentName: "Transition Strategist" },
+    resume: { agentId: "resume", baseAgent: "resume-strategist", agentName: "Transferable Skills Agent" },
+    interview: { agentId: "interview", baseAgent: "interview-coach", agentName: "Adjacent Role Interviewer" },
+    roleplay: { agentId: "roleplay", baseAgent: "roleplay-coach", agentName: "Transition Pitch Coach" },
+    qscore: { agentId: "qscore", baseAgent: "qscore-analyst", agentName: "Transition Readiness Analyst" },
+  },
+  "salary-negotiation-war-room": {
+    planner: { agentId: "planner", baseAgent: "mission-planner", agentName: "Negotiation Strategist" },
+    resume: { agentId: "resume", baseAgent: "resume-strategist", agentName: "Value Evidence Agent" },
+    interview: { agentId: "interview", baseAgent: "interview-coach", agentName: "Confidence Coach" },
+    roleplay: { agentId: "roleplay", baseAgent: "roleplay-coach", agentName: "Negotiation Drill Coach" },
+    qscore: { agentId: "qscore", baseAgent: "qscore-analyst", agentName: "Confidence Analyst" },
+  },
+  "promotion-readiness": {
+    planner: { agentId: "planner", baseAgent: "mission-planner", agentName: "Promotion Strategist" },
+    resume: { agentId: "resume", baseAgent: "resume-strategist", agentName: "Achievement Evidence Agent" },
+    interview: { agentId: "interview", baseAgent: "interview-coach", agentName: "Leadership Interview Coach" },
+    roleplay: { agentId: "roleplay", baseAgent: "roleplay-coach", agentName: "Manager Conversation Coach" },
+    qscore: { agentId: "qscore", baseAgent: "qscore-analyst", agentName: "Leadership Readiness Analyst" },
+  },
+  "personal-brand-opportunity-engine": {
+    planner: { agentId: "planner", baseAgent: "mission-planner", agentName: "Brand Strategist" },
+    resume: { agentId: "resume", baseAgent: "resume-strategist", agentName: "Proof Point Agent" },
+    interview: { agentId: "interview", baseAgent: "interview-coach", agentName: "Credibility Coach" },
+    roleplay: { agentId: "roleplay", baseAgent: "roleplay-coach", agentName: "Networking Pitch Coach" },
+    qscore: { agentId: "qscore", baseAgent: "qscore-analyst", agentName: "Visibility Analyst" },
+  },
+};
+
+export function actionForAgent(missionId: string, agent: "planner" | "resume" | "interview" | "roleplay" | "qscore", patch: Omit<MissionActionPatch, "agentId" | "agentName" | "baseAgent">): MissionActionPatch {
+  const fallback = AGENT_NAMES["interview-to-offer"]?.[agent] ?? { agentId: agent, baseAgent: agent, agentName: agent };
+  const spec = AGENT_NAMES[missionId]?.[agent] ?? fallback;
+  return { ...spec, ...patch };
+}
+
+export function serviceHref(service: "resume" | "interview" | "roleplay" | "qscore", missionInstanceId: string, missionId: string, stageId?: string) {
+  const params = new URLSearchParams({ source: "mission", missionInstanceId, missionId });
+  if (stageId) params.set("stageId", stageId);
+  if (service === "interview") return `/agents/interview/setup?${params.toString()}`;
+  if (service === "roleplay") return `/agents/roleplay/setup?${params.toString()}`;
+  if (service === "resume") return `/agents/resume?${params.toString()}`;
+  return `/agents/qscore?${params.toString()}`;
+}
+
+export function missionDetailHref(missionInstanceId: string) {
+  return `/missions/${encodeURIComponent(missionInstanceId)}`;
+}

src/missions/reducer-types.ts

@@ -2,6 +2,7 @@ import type { GrowEventRow } from "../db/schema.js";
 import type { ProjectionInsight } from "../events/projectors/projection-agent.js";
 import type { QscoreSignal } from "../events/envelope.js";
 import type { GrowActiveMission, MissionStageStatus } from "../actors/missions/types.js";
+import type { MissionActionMode, MissionActionStatus, MissionActionUrgency } from "./action-types.js";
 
 export type MissionReducerContext = {
   userId: string;
@@ -27,9 +28,30 @@ export type MissionStagePatch = {
   outputSummary?: string;
 };
 
+export type MissionActionPatch = {
+  stageId?: string;
+  agentId: string;
+  agentName: string;
+  baseAgent?: string;
+  serviceId?: string;
+  toolName?: string;
+  mode: MissionActionMode;
+  status?: MissionActionStatus;
+  title: string;
+  body: string;
+  prompt?: string;
+  payload?: Record<string, unknown>;
+  sourceEventId?: string;
+  idempotencyKey?: string;
+  priority?: number;
+  urgency?: MissionActionUrgency;
+  dueAt?: string;
+};
+
 export type MissionReduction = {
   stagePatches: MissionStagePatch[];
   artifacts: MissionArtifactPatch[];
+  actions: MissionActionPatch[];
   eventMessage?: string;
 };
 

src/missions/salary-negotiation-war-room/reducer.ts

@@ -0,0 +1,88 @@
+import type { MissionReducer, MissionReduction, MissionStagePatch } from "../reducer-types.js";
+import { actionForAgent, extractResumeSignals, extractWeakAreas, isInterviewEvent, isRelevantServiceEvent, isResumeEvent, isRoleplayEvent, missionExplicitlyMatches, serviceHref } from "../reducer-helpers.js";
+
+export const salaryNegotiationReducer: MissionReducer = {
+  missionId: "salary-negotiation-war-room",
+  accepts(ctx) {
+    return ctx.activeMission.missionId === "salary-negotiation-war-room" &&
+      (missionExplicitlyMatches(ctx.event.mission, "salary-negotiation-war-room") || isRelevantServiceEvent(ctx.event.source, ctx.event.type));
+  },
+  reduce(ctx): MissionReduction {
+    const { event, activeMission } = ctx;
+    const type = event.type;
+    const payload = event.payload ?? {};
+    const stagePatches: MissionStagePatch[] = [];
+    const artifacts: MissionReduction["artifacts"] = [];
+    const actions: MissionReduction["actions"] = [];
+    let eventMessage = ctx.insight.summary;
+
+    if (type === "mission.started" || type.startsWith("mission.")) {
+      actions.push(actionForAgent("salary-negotiation-war-room", "planner", {
+        stageId: "offer-context",
+        mode: "user_input_required",
+        title: "Add your offer and negotiation constraints",
+        body: "The war room needs your current offer, target range, deadline, and leverage before scripts or drills are accurate.",
+        prompt: "What is the current offer/raise, your target, deadline, and any competing leverage?",
+        payload: { fields: ["current_offer", "target_range", "deadline", "competing_offers", "constraints"] },
+        idempotencyKey: `${activeMission.instanceId}:offer-context`,
+        priority: 100,
+        urgency: "now",
+      }));
+    }
+
+    if (isResumeEvent(event.source, type) && (type.includes("analysis") || type.includes("parsed") || type.includes("analyzed"))) {
+      const signals = extractResumeSignals(payload);
+      stagePatches.push({ stageId: "resume", status: "done", progressPercent: 100, outputSummary: "Value evidence extracted from resume proof." });
+      stagePatches.push({ stageId: "roleplay", status: "ready", progressPercent: 0, outputSummary: "Use value evidence in negotiation roleplay." });
+      artifacts.push({ type: "value_evidence_map", title: "Value evidence map", stageId: "resume", summary: signals[0] ?? "Impact proof extracted for negotiation leverage.", metadata: { sourceEventId: event.id, signals } });
+      actions.push(actionForAgent("salary-negotiation-war-room", "roleplay", {
+        stageId: "roleplay",
+        serviceId: "roleplay-service",
+        toolName: "roleplay.configure_practice",
+        mode: "suggestion",
+        title: "Run the first counteroffer drill",
+        body: "Practice anchoring your number and defending value with the evidence now extracted.",
+        payload: { signals, href: serviceHref("roleplay", activeMission.instanceId, activeMission.missionId, "roleplay") },
+        sourceEventId: event.id,
+        idempotencyKey: `${activeMission.instanceId}:value-evidence-roleplay:${event.id}`,
+        priority: 96,
+        urgency: "today",
+      }));
+      eventMessage = "Value evidence is ready for negotiation practice.";
+    }
+
+    if (isRoleplayEvent(event.source, type) && type.includes("configured")) {
+      stagePatches.push({ stageId: "roleplay", status: "in_progress", progressPercent: 45, outputSummary: "Negotiation drill configured." });
+      eventMessage = "Negotiation drill started.";
+    }
+
+    if (isRoleplayEvent(event.source, type) && type.includes("review_completed")) {
+      const weakAreas = extractWeakAreas(payload);
+      stagePatches.push({ stageId: "roleplay", status: "done", progressPercent: 100, outputSummary: "Negotiation drill reviewed." });
+      stagePatches.push({ stageId: "qscore", status: "in_progress", progressPercent: 70, outputSummary: "Confidence signals updated." });
+      artifacts.push({ type: "negotiation_objection_map", title: "Objection handling map", stageId: "roleplay", summary: weakAreas.length ? `Practice objections: ${weakAreas.join(", ")}` : "Negotiation practice review completed.", metadata: { sourceEventId: event.id, weakAreas } });
+      actions.push(actionForAgent("salary-negotiation-war-room", "roleplay", {
+        stageId: "roleplay",
+        serviceId: "roleplay-service",
+        toolName: "roleplay.configure_practice",
+        mode: "approval_required",
+        title: "Run one more objection-handling drill?",
+        body: weakAreas.length ? `Recommended focus: ${weakAreas.slice(0, 3).join(", ")}. Approve another drill before the live negotiation.` : "Approve one more objection-handling drill before the live negotiation.",
+        payload: { weakAreas, href: serviceHref("roleplay", activeMission.instanceId, activeMission.missionId, "roleplay") },
+        sourceEventId: event.id,
+        idempotencyKey: `${activeMission.instanceId}:negotiation-followup:${event.id}`,
+        priority: 94,
+        urgency: "today",
+      }));
+      eventMessage = "Negotiation drill review created the next objection-handling action.";
+    }
+
+    if (isInterviewEvent(event.source, type) && type.includes("review_completed")) {
+      stagePatches.push({ stageId: "interview", status: "done", progressPercent: 100, outputSummary: "Communication confidence signal captured from interview review." });
+      eventMessage = "Interview feedback updated negotiation confidence signals.";
+    }
+
+    if (ctx.qscoreSignals.length) stagePatches.push({ stageId: "qscore", status: "in_progress", progressPercent: Math.min(90, 45 + ctx.qscoreSignals.length * 10), outputSummary: "Negotiation confidence signals updated." });
+    return { stagePatches, artifacts, actions, eventMessage };
+  },
+};

src/missions/suggestions.ts

@@ -1,4 +1,5 @@
 import type { MissionSnapshot, MissionStage } from "../actors/missions/types.js";
+import { missionDetailHref } from "./reducer-helpers.js";
 
 export type MissionSuggestionType = "action" | "practice" | "review" | "artifact" | "blocked" | "insight";
 export type MissionSuggestionUrgency = "now" | "today" | "soon" | "calm";
@@ -103,7 +104,7 @@ function ctaFor(stage: MissionStage, snapshot: MissionSnapshot, context?: Missio
     return { label: "Open resume", href: `/agents/resume?${params.toString()}` };
   }
   if (role === "Q Score") return { label: "View Q Score", href: `/agents/qscore?${params.toString()}` };
-  return { label: "Continue", href: `/missions/active?${params.toString()}` };
+  return { label: "Continue", href: `${missionDetailHref(snapshot.instanceId)}?${params.toString()}` };
 }
 
 function suggestionId(snapshot: MissionSnapshot, stage: MissionStage, suffix: string) {

src/routes/analytics.ts

@@ -0,0 +1,31 @@
+import { Hono } from "hono";
+import { createClient, type Client } from "rivetkit/client";
+import { config } from "../config.js";
+import { requireUser, type AuthContext } from "../auth/clerk.js";
+import type { Registry } from "../actors/registry.js";
+
+let _client: Client<Registry> | null = null;
+function getClient(): Client<Registry> {
+  return (_client ??= createClient<Registry>(config.rivetClientEndpoint));
+}
+
+export function analyticsRoutes() {
+  const app = new Hono<AuthContext>();
+  app.use("*", requireUser);
+
+  app.get("/platform", async (c) => {
+    return c.json(await getClient().analyticsActor.getOrCreate(["platform"]).getPlatform());
+  });
+
+  app.get("/user/qscore", async (c) => {
+    const userId = c.get("userId");
+    return c.json(await getClient().analyticsActor.getOrCreate(["user", userId]).getUserQscore({ userId }));
+  });
+
+  app.get("/user/activity", async (c) => {
+    const userId = c.get("userId");
+    return c.json(await getClient().analyticsActor.getOrCreate(["user", userId]).getUserActivity({ userId }));
+  });
+
+  return app;
+}

src/routes/chat.ts

@@ -52,7 +52,7 @@ function buildTools() {
       type: "function" as const,
       function: {
         name: "start_interview_session",
-        description: "Create a real interview practice session via the Interview Agent / interview-service microservice. Call this when the user asks to start or launch an interview.",
+        description: "Create a real mock interview session via the interview-service microservice. Call this when the user asks to start or launch interview practice.",
         parameters: {
           type: "object",
           properties: {
@@ -66,7 +66,7 @@ function buildTools() {
       type: "function" as const,
       function: {
         name: "start_roleplay_session",
-        description: "Create a real roleplay session via Roleplay Agent / roleplay-service. Call when user asks for roleplay or negotiation practice.",
+        description: "Create a real mock roleplay session via roleplay-service. Call when the user asks for roleplay or negotiation practice.",
         parameters: {
           type: "object",
           properties: {
@@ -80,7 +80,7 @@ function buildTools() {
       type: "function" as const,
       function: {
         name: "analyze_resume",
-        description: "Analyze user's resume using the Resume Agent. Returns completeness, skills, and gaps.",
+        description: "Analyze the user's resume using Resume Building. Returns completeness, skills, and gaps.",
         parameters: {
           type: "object",
           properties: {
@@ -94,7 +94,7 @@ function buildTools() {
       type: "function" as const,
       function: {
         name: "compute_qscore",
-        description: "Compute user's readiness Q-Score via Q Score Agent / qscore-service.",
+        description: "Compute the user's readiness Q Score via qscore-service.",
         parameters: {
           type: "object",
           properties: {},
@@ -174,14 +174,14 @@ export function chatRoutes() {
           switch (toolCall.name) {
             case "start_interview_session": {
               toolResult = await runServiceAgentProbe(
-                { id: "interview", name: "Interview Agent", role: "Interview Agent", kind: "microservice", description: "Interview practice", service: "interview-service" },
+                { id: "interview", name: "Mock Interview", role: "Interview practice", kind: "microservice", description: "Interview practice", service: "interview-service" },
                 { userId, goal: String(toolCall.arguments.target_role ?? "general preparation") },
               );
               if (toolResult.status === "ok" && toolResult.detail) {
                 const detail = toolResult.detail as Record<string, unknown>;
                 sessions.push({
                   moduleId: "interview",
-                  moduleName: "Interview Agent",
+                  moduleName: "Mock Interview",
                   status: "done",
                   sessionId: detail.session_id as string,
                   sessionUrl: typeof detail.ui_session_url === "string"
@@ -194,14 +194,14 @@ export function chatRoutes() {
             }
             case "start_roleplay_session": {
               toolResult = await runServiceAgentProbe(
-                { id: "roleplay", name: "Roleplay Agent", role: "Roleplay Agent", kind: "microservice", description: "Roleplay practice", service: "roleplay-service" },
+                { id: "roleplay", name: "Mock Roleplay", role: "Roleplay practice", kind: "microservice", description: "Roleplay practice", service: "roleplay-service" },
                 { userId, goal: String(toolCall.arguments.goal ?? "general practice") },
               );
               if (toolResult.status === "ok" && toolResult.detail) {
                 const detail = toolResult.detail as Record<string, unknown>;
                 sessions.push({
                   moduleId: "roleplay",
-                  moduleName: "Roleplay Agent",
+                  moduleName: "Mock Roleplay",
                   status: "done",
                   sessionId: detail.session_id as string,
                   sessionUrl: typeof detail.ui_session_url === "string"

src/routes/conversations.ts

@@ -9,7 +9,8 @@ import { getConversationModel } from "../actors/conversation/agent.js";
 import { getMissionDefinition, isActorBackedMission, listMissionDefinitions } from "../missions/registry.js";
 import type { GrowActiveMission, MissionActorType, MissionSnapshot } from "../actors/missions/types.js";
 import { getSubAgentModules } from "../lib/prompt-loader.js";
-import { addMessagePg, createConversationPg, ensureConversation, getConversationPg, listActiveMissionsPg, listConversationsPg, listMessagesPg, resetConversationPg, touchConversationPg, upsertActiveMissionPg } from "../grow/persistence.js";
+import { addMessagePg, createConversationPg, ensureConversation, ensureMissionConversationPg, getActiveMissionPg, getConversationMetadataPg, getConversationPg, listActiveMissionsPg, listConversationsPg, listMessagesPg, resetConversationPg, touchConversationPg, upsertActiveMissionPg } from "../grow/persistence.js";
+import { getMissionAction, listMissionActions, updateMissionActionStatus } from "../missions/actions.js";
 
 let _client: Client<Registry> | null = null;
 function getClient(): Client<Registry> {
@@ -101,6 +102,12 @@ function missionActorFor(userId: string, instanceId: string, actorType: MissionA
 }
 
 const createConversationSchema = z.object({ title: z.string().optional() });
+const createMissionConversationSchema = z.object({
+  missionInstanceId: z.string().min(1),
+  stageId: z.string().optional(),
+  title: z.string().optional(),
+  source: z.string().optional(),
+});
 const streamSchema = z.object({
   messages: z.array(z.custom<UIMessage>()),
   conversationId: z.string().optional(),
@@ -163,7 +170,27 @@ function forcedToolForPrompt(text: string) {
   return undefined;
 }
 
-function buildSystemPrompt() {
+async function buildMissionContextPrompt(userId: string, conversationId: string) {
+  const metadata = await getConversationMetadataPg(userId, conversationId);
+  const missionInstanceId = typeof metadata.missionInstanceId === "string" ? metadata.missionInstanceId : undefined;
+  if (!missionInstanceId) return "";
+  const active = await getActiveMissionPg(userId, missionInstanceId);
+  if (!active) return "";
+  const actions = await listMissionActions(userId, { missionInstanceId });
+  return `\n\nCurrent mission context:
+- missionInstanceId: ${active.mission.instanceId}
+- missionId: ${active.mission.missionId}
+- title: ${active.mission.title}
+- status: ${active.mission.status}
+- progress: ${active.mission.progressPercent}%
+- currentStageId: ${active.mission.currentStageId ?? "none"}
+- goal: ${active.mission.goal ?? "none"}
+- openActions: ${actions.length}
+
+Use this mission context when answering. If a service is needed, prepare a handoff/action instead of completing the service directly.`;
+}
+
+function buildSystemPrompt(missionContext = "") {
   return `You are Grow — a friendly, normal career buddy inside GrowQR. Talk like a real person, not a coach or a robot.
 
 Personality & Tone:
@@ -182,7 +209,7 @@ How to help:
 - When the user asks about interview prep, roleplay, resume, or Q Score — just answer normally. Only route to a specialist tool if they explicitly say something like "connect me to the interview specialist" or "let me talk to the roleplay agent".
 - When the user asks to see missions or plans, call discoverWorkflows or showMissions. When they ask about memory, use the memory tools. Otherwise, just chat.
 - Only start a mission if the user clearly says yes to starting one. Don't push.
-- When you write memory, a quick "Saved." is enough. No need to over-confirm.`
+- When you write memory, a quick "Saved." is enough. No need to over-confirm.${missionContext}`
 }
 
 function safeAgentRegistry() {
@@ -443,6 +470,49 @@ function buildConversationTools(userId: string) {
       },
     }),
 
+    listMissionActions: tool({
+      description: "List open mission queue actions/approvals/questions for the user. Use for: what should I do today, what are my agents doing, why is my mission blocked, show approvals.",
+      inputSchema: z.object({ missionInstanceId: z.string().optional() }),
+      execute: async ({ missionInstanceId }) => ({
+        kind: "mission-actions",
+        actions: await listMissionActions(userId, { missionInstanceId }),
+      }),
+    }),
+
+    approveMissionAction: tool({
+      description: "Approve a mission action by id. Only use when the user explicitly asks to approve a specific action.",
+      inputSchema: z.object({ actionId: z.string() }),
+      execute: async ({ actionId }) => {
+        const action = await getMissionAction(userId, actionId);
+        if (!action) return { kind: "mission-action-approved", actionId, error: "Action not found" };
+        return { kind: "mission-action-approved", action: await updateMissionActionStatus(userId, actionId, { status: "queued", result: { approvedAt: new Date().toISOString() } }) };
+      },
+    }),
+
+    rejectMissionAction: tool({
+      description: "Reject/dismiss a mission action by id. Only use when the user explicitly asks to reject or dismiss a specific action.",
+      inputSchema: z.object({ actionId: z.string() }),
+      execute: async ({ actionId }) => ({
+        kind: "mission-action-rejected",
+        action: await updateMissionActionStatus(userId, actionId, { status: "dismissed", result: { rejectedAt: new Date().toISOString() } }),
+      }),
+    }),
+
+    explainMissionProgress: tool({
+      description: "Explain active mission progress using snapshots and open actions.",
+      inputSchema: z.object({ missionInstanceId: z.string().optional() }),
+      execute: async ({ missionInstanceId }) => {
+        const persisted = await listActiveMissionsPg(userId);
+        const selected = missionInstanceId ? persisted.filter((item) => item.mission.instanceId === missionInstanceId) : persisted;
+        return {
+          kind: "mission-progress",
+          missions: selected.map((item) => item.mission),
+          snapshots: selected.map((item) => item.snapshot).filter(Boolean),
+          actions: await listMissionActions(userId, { missionInstanceId }),
+        };
+      },
+    }),
+
     listMemory: tool({
       description: "List memory files for this user by path prefix.",
       inputSchema: z.object({ prefix: z.string().optional() }),
@@ -526,6 +596,28 @@ export function conversationRoutes() {
     return c.json({ conversation }, 201);
   });
 
+  app.post("/mission", async (c) => {
+    const userId = c.get("userId");
+    const body = createMissionConversationSchema.parse(await c.req.json().catch(() => ({})));
+    const active = await getActiveMissionPg(userId, body.missionInstanceId);
+    if (!active) return c.json({ error: "mission_not_found" }, 404);
+    const conversation = await ensureMissionConversationPg({
+      userId,
+      missionInstanceId: active.mission.instanceId,
+      missionId: active.mission.missionId,
+      stageId: body.stageId,
+      title: body.title ?? active.mission.shortTitle,
+      source: body.source ?? "mission",
+    });
+    setupGrow(userId).then((grow) => grow.touchConversation({ conversationId: conversation.id, title: conversation.title })).catch((err) => console.warn("growActor mission conversation mirror failed", err));
+    return c.json({
+      conversation,
+      mission: active.mission,
+      snapshot: active.snapshot,
+      messages: await listMessagesPg(userId, conversation.id),
+    }, 201);
+  });
+
   app.get("/:conversationId", async (c) => {
     const userId = c.get("userId");
     const conversationId = c.req.param("conversationId");
@@ -566,9 +658,10 @@ export function conversationRoutes() {
     }
 
     const visualTool = forcedToolForPrompt(latestUserText);
+    const missionContext = await buildMissionContextPrompt(userId, conversationId);
     const result = streamText({
       model: getConversationModel(),
-      system: buildSystemPrompt(),
+      system: buildSystemPrompt(missionContext),
       messages: await convertToModelMessages(body.messages),
       tools: buildConversationTools(userId),
       toolChoice: visualTool ? { type: "tool", toolName: visualTool } : "auto",

src/routes/daily-mission.ts

@@ -0,0 +1,299 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { createClient, type Client } from "rivetkit/client";
+import { requireUser, type AuthContext } from "../auth/clerk.js";
+import { config } from "../config.js";
+import { log } from "../log.js";
+import {
+  dailyMissionMessageSchema,
+  dailyMissionTaskSchema,
+  type DailyMissionResult,
+  runDailyMissionAgent,
+  streamDailyMissionAgent,
+} from "../agents/daily-mission.js";
+import type { Registry } from "../actors/registry.js";
+import type { MissionActorType, MissionSnapshot } from "../actors/missions/types.js";
+import { addMessagePg, ensureMissionConversationPg, getActiveMissionPg, listMessagesPg, upsertActiveMissionPg } from "../grow/persistence.js";
+
+const chatSchema = z.object({
+  task: dailyMissionTaskSchema,
+  messages: z.array(dailyMissionMessageSchema).min(1).max(24),
+  missionInstanceId: z.string().optional(),
+  missionId: z.string().optional(),
+  stageId: z.string().optional(),
+  conversationId: z.string().optional(),
+});
+
+let _client: Client<Registry> | null = null;
+function getClient(): Client<Registry> {
+  return (_client ??= createClient<Registry>(config.rivetClientEndpoint));
+}
+
+function missionActorFor(userId: string, instanceId: string, actorType: MissionActorType) {
+  const client = getClient();
+  switch (actorType) {
+    case "interviewToOfferMissionActor": return client.interviewToOfferMissionActor.getOrCreate([userId, instanceId]);
+    case "careerTransitionMissionActor": return client.careerTransitionMissionActor.getOrCreate([userId, instanceId]);
+    case "salaryNegotiationWarRoomMissionActor": return client.salaryNegotiationWarRoomMissionActor.getOrCreate([userId, instanceId]);
+    case "promotionReadinessMissionActor": return client.promotionReadinessMissionActor.getOrCreate([userId, instanceId]);
+    case "personalBrandOpportunityEngineMissionActor": return client.personalBrandOpportunityEngineMissionActor.getOrCreate([userId, instanceId]);
+  }
+}
+
+function buildId(prefix: string) {
+  return `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function latestUserText(messages: z.infer<typeof dailyMissionMessageSchema>[]) {
+  return [...messages].reverse().find((message) => message.role === "user")?.content.trim();
+}
+
+const encoder = new TextEncoder();
+
+function sse(event: string, payload: Record<string, unknown>) {
+  return encoder.encode(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`);
+}
+
+function sanitizeAssistantText(text: string) {
+  return text
+    .replace(/[\u2013\u2014]/g, ". ")
+    .replace(/[\u2018\u2019]/g, "'")
+    .replace(/[\u201C\u201D]/g, '"')
+    .replace(/\u2026/g, "...")
+    .replace(/^\s*(Perfect|Great|Absolutely|Sure)[.!,:;-]*\s*/i, "")
+    .replace(/\s+\./g, ".")
+    .replace(/\.{2,}/g, ".")
+    .replace(/\s{2,}/g, " ");
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function visibleTextChunks(text: string) {
+  const words = text.match(/\S+\s*/g) ?? [text];
+  const chunks: string[] = [];
+  let current = "";
+
+  for (const word of words) {
+    current += word;
+    if (current.length >= 12 || /[.!?]\s*$/.test(current)) {
+      chunks.push(current);
+      current = "";
+    }
+  }
+
+  if (current) chunks.push(current);
+  return chunks;
+}
+
+async function enqueueVisibleText(controller: ReadableStreamDefaultController<Uint8Array>, text: string) {
+  for (const chunk of visibleTextChunks(sanitizeAssistantText(text))) {
+    controller.enqueue(sse("delta", { text: chunk }));
+    await sleep(28);
+  }
+}
+
+async function applyDailyMissionResult(input: {
+  userId: string;
+  body: z.infer<typeof chatSchema>;
+  result: DailyMissionResult;
+}) {
+  const { userId, body, result } = input;
+  let conversationId = body.conversationId;
+  let missionInstanceId = body.missionInstanceId;
+  let responseStageId = body.stageId ?? body.task.questId;
+  let snapshot: MissionSnapshot | null | undefined;
+
+  if (missionInstanceId) {
+    const active = await getActiveMissionPg(userId, missionInstanceId);
+    if (active) {
+      const requestedStageId = body.stageId ?? body.task.questId;
+      const stageId = active.snapshot?.stages.some((stage) => stage.id === requestedStageId)
+        ? requestedStageId
+        : active.mission.currentStageId;
+      responseStageId = stageId ?? responseStageId;
+
+      const conversation = await ensureMissionConversationPg({
+        userId,
+        missionInstanceId: active.mission.instanceId,
+        missionId: active.mission.missionId,
+        stageId,
+        title: body.task.questTitle,
+        source: "daily-mission",
+      });
+      log.info({
+        userId,
+        agent: "conversation-actor",
+        conversationId: conversation.id,
+        missionInstanceId: active.mission.instanceId,
+        missionId: active.mission.missionId,
+        stageId,
+        service: body.task.service,
+      }, "conversation actor linked to daily mission");
+      conversationId = conversation.id;
+      missionInstanceId = active.mission.instanceId;
+      const conversationActor = getClient().conversationActor.getOrCreate([userId, conversation.id]);
+      const latestUser = latestUserText(body.messages);
+      if (latestUser) {
+        const userMessage = {
+          id: buildId("user"),
+          conversationId: conversation.id,
+          role: "user" as const,
+          sender: "User",
+          content: latestUser,
+        };
+        await addMessagePg(userId, userMessage);
+        conversationActor.addMessage(userMessage).catch(() => undefined);
+      }
+      const assistantMessage = {
+        id: buildId("assistant"),
+        conversationId: conversation.id,
+        role: "assistant" as const,
+        sender: "Daily Mission",
+        content: result.reply,
+      };
+      await addMessagePg(userId, assistantMessage);
+      conversationActor.addMessage(assistantMessage).catch(() => undefined);
+
+      if (result.completed && active.mission.actorType && stageId) {
+        snapshot = await missionActorFor(userId, active.mission.instanceId, active.mission.actorType).updateStage({
+          stageId,
+          status: "done",
+          progressPercent: 100,
+          outputSummary: result.updateSummary,
+        }).catch(() => active.snapshot ?? null);
+        log.info({
+          userId,
+          agent: active.mission.actorType,
+          missionInstanceId: active.mission.instanceId,
+          missionId: active.mission.missionId,
+          stageId,
+          completed: result.completed,
+          progressPercent: snapshot?.progressPercent,
+          currentStageId: snapshot?.currentStageId,
+        }, "mission actor stage update requested from daily mission");
+        if (snapshot) {
+          await upsertActiveMissionPg(userId, {
+            instanceId: snapshot.instanceId,
+            missionId: snapshot.missionId,
+            workflowId: snapshot.workflowId,
+            title: snapshot.title,
+            shortTitle: snapshot.shortTitle,
+            status: snapshot.status,
+            progressPercent: snapshot.progressPercent,
+            currentStageId: snapshot.currentStageId,
+            goal: snapshot.goal,
+            actorType: active.mission.actorType,
+            createdAt: new Date(snapshot.createdAt).getTime(),
+            updatedAt: new Date(snapshot.updatedAt).getTime(),
+          }, snapshot);
+        }
+      } else {
+        snapshot = active.snapshot;
+      }
+    }
+  }
+
+  return {
+    agent: "daily-mission",
+    message: result.reply,
+    completed: result.completed,
+    updateSummary: result.updateSummary,
+    actionLabel: result.actionLabel,
+    actionRoute: result.actionRoute,
+    conversationId,
+    missionInstanceId,
+    stageId: responseStageId,
+    snapshot,
+    messages: conversationId ? await listMessagesPg(userId, conversationId) : undefined,
+  };
+}
+
+export function dailyMissionRoutes() {
+  const app = new Hono<AuthContext>();
+  app.use("*", requireUser);
+
+  app.post("/chat", async (c) => {
+    const userId = c.get("userId");
+    const body = chatSchema.parse(await c.req.json());
+    log.info({
+      userId,
+      agent: "daily-mission",
+      missionInstanceId: body.missionInstanceId,
+      missionId: body.missionId,
+      stageId: body.stageId,
+      service: body.task.service,
+      route: body.task.route,
+      questTitle: body.task.questTitle,
+      subtask: body.task.subtask,
+    }, "daily mission actor request");
+    const result = await runDailyMissionAgent({ userId, ...body });
+    return c.json(await applyDailyMissionResult({ userId, body, result }));
+  });
+
+  app.post("/chat/stream", async (c) => {
+    const userId = c.get("userId");
+    const body = chatSchema.parse(await c.req.json());
+    log.info({
+      userId,
+      agent: "daily-mission",
+      missionInstanceId: body.missionInstanceId,
+      missionId: body.missionId,
+      stageId: body.stageId,
+      service: body.task.service,
+      route: body.task.route,
+      questTitle: body.task.questTitle,
+      subtask: body.task.subtask,
+      streaming: true,
+    }, "daily mission actor stream request");
+
+    const stream = new ReadableStream<Uint8Array>({
+      async start(controller) {
+        try {
+          const streamed = await streamDailyMissionAgent({ userId, ...body });
+          let reply = "";
+          if (streamed.kind === "static") {
+            reply = streamed.result.reply;
+            await enqueueVisibleText(controller, reply);
+            const finalPayload = await applyDailyMissionResult({ userId, body, result: streamed.result });
+            controller.enqueue(sse("final", finalPayload));
+            controller.close();
+            return;
+          }
+
+          for await (const delta of streamed.textStream) {
+            const cleanDelta = sanitizeAssistantText(delta);
+            reply += cleanDelta;
+            controller.enqueue(sse("delta", { text: cleanDelta }));
+          }
+          let result = streamed.finalize(reply);
+          result = {
+            ...result,
+            reply: sanitizeAssistantText(result.reply),
+            updateSummary: result.updateSummary ? sanitizeAssistantText(result.updateSummary) : result.updateSummary,
+          };
+          if (!result.reply.trim()) {
+            throw new Error("daily_mission_empty_model_reply");
+          }
+          const finalPayload = await applyDailyMissionResult({ userId, body, result });
+          controller.enqueue(sse("final", finalPayload));
+          controller.close();
+        } catch (error) {
+          controller.enqueue(sse("error", { error: error instanceof Error ? error.message : String(error) }));
+          controller.close();
+        }
+      },
+    });
+
+    return new Response(stream, {
+      headers: {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-transform",
+        connection: "keep-alive",
+      },
+    });
+  });
+
+  return app;
+}

src/routes/home.ts

@@ -3,18 +3,38 @@ import { config } from "../config.js";
 import { requireUser, type AuthContext } from "../auth/clerk.js";
 import { dismissHomeNotification, getHomeFeed, getHomeFeedDebugCounts } from "../home/home-feed.js";
 import { seedDemoHome } from "../home/seed-demo-home.js";
+import { log } from "../log.js";
 
 function canSeedDemo(userId: string) {
   return config.nodeEnv !== "production" || config.adminUserIds.includes(userId);
 }
 
+async function getUserServiceProfile(req: Request): Promise<{ userProfile?: Record<string, unknown>; preferences?: Record<string, unknown> }> {
+  const target = new URL("/api/v1/users/me", config.userServiceUrl.replace(/\/$/, ""));
+  const headers = new Headers(req.headers);
+  headers.delete("host");
+  headers.delete("cookie");
+  const res = await fetch(target, { method: "GET", headers });
+  if (!res.ok) return {};
+  const userProfile = await res.json().catch(() => null) as Record<string, unknown> | null;
+  const preferences = userProfile?.preferences;
+  return {
+    userProfile: userProfile ?? undefined,
+    preferences: preferences && typeof preferences === "object" && !Array.isArray(preferences) ? preferences as Record<string, unknown> : {},
+  };
+}
+
 export function homeRoutes() {
   const app = new Hono<AuthContext>();
   app.use("*", requireUser);
 
   app.get("/feed", async (c) => {
     const refresh = c.req.query("refresh") === "1" || c.req.query("refresh") === "true";
-    return c.json(await getHomeFeed(c.get("userId"), { refresh }));
+    const profile = await getUserServiceProfile(c.req.raw).catch((err) => {
+      log.warn({ err, userId: c.get("userId") }, "home feed continuing without user-service profile");
+      return {};
+    });
+    return c.json(await getHomeFeed(c.get("userId"), { refresh, ...profile }));
   });
 
   app.post("/notifications/:id/dismiss", async (c) => {

src/routes/logs.ts

@@ -0,0 +1,117 @@
+import Docker from "dockerode";
+import { PassThrough } from "node:stream";
+import { Hono } from "hono";
+import { requireUser, type AuthContext } from "../auth/clerk.js";
+
+const LOG_CONTAINERS = {
+  backend: "growqr-backend",
+  dashboard: "growqr-dashboard",
+  actors: "growqr-rivet",
+  interview: "interview-service-api-1",
+  roleplay: "roleplay-service-api-1",
+  social: "growqr_social_api",
+  pathways: "pathways-service-api-1",
+  courses: "courses_service-api-1",
+  assessment: "assessment-service-api-1",
+  matchmaking: "matchmaking-service-api-1",
+} as const;
+
+type LogService = keyof typeof LOG_CONTAINERS;
+
+const encoder = new TextEncoder();
+
+function parseServices(value: string | undefined): LogService[] {
+  const requested = (value ?? "backend,dashboard,actors,interview,roleplay")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+  const services = requested.filter((item): item is LogService => item in LOG_CONTAINERS);
+  return services.length ? services : ["backend", "dashboard", "actors", "interview", "roleplay"];
+}
+
+function sse(event: string, payload: Record<string, unknown>) {
+  return encoder.encode(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`);
+}
+
+function splitLines(chunk: Buffer | string) {
+  return chunk
+    .toString("utf8")
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter(Boolean);
+}
+
+export function logRoutes() {
+  const app = new Hono<AuthContext>();
+  app.use("*", requireUser);
+
+  app.get("/stream", (c) => {
+    const services = parseServices(c.req.query("services"));
+    const tail = Math.max(10, Math.min(500, Number(c.req.query("tail") ?? 120)));
+    const docker = new Docker({ socketPath: "/var/run/docker.sock" });
+    const openStreams: Array<{ destroy: () => void }> = [];
+    let closed = false;
+    let heartbeat: NodeJS.Timeout | undefined;
+
+    const body = new ReadableStream<Uint8Array>({
+      async start(controller) {
+        const send = (event: string, payload: Record<string, unknown>) => {
+          if (!closed) controller.enqueue(sse(event, payload));
+        };
+
+        send("ready", { services, tail, at: new Date().toISOString() });
+
+        for (const service of services) {
+          const containerName = LOG_CONTAINERS[service];
+          try {
+            const stream = await docker.getContainer(containerName).logs({
+              follow: true,
+              stdout: true,
+              stderr: true,
+              timestamps: true,
+              tail,
+            });
+            const stdout = new PassThrough();
+            const stderr = new PassThrough();
+            docker.modem.demuxStream(stream, stdout, stderr);
+            openStreams.push(stream as unknown as { destroy: () => void }, stdout, stderr);
+
+            stdout.on("data", (chunk) => {
+              for (const line of splitLines(chunk)) send("log", { service, stream: "stdout", line });
+            });
+            stderr.on("data", (chunk) => {
+              for (const line of splitLines(chunk)) send("log", { service, stream: "stderr", line });
+            });
+            stream.on("end", () => send("status", { service, status: "ended" }));
+            stream.on("error", (error) => send("error", { service, error: error instanceof Error ? error.message : String(error) }));
+          } catch (error) {
+            send("error", { service, container: containerName, error: error instanceof Error ? error.message : String(error) });
+          }
+        }
+
+        heartbeat = setInterval(() => send("ping", { at: new Date().toISOString() }), 20_000);
+        c.req.raw.signal.addEventListener("abort", () => {
+          closed = true;
+          if (heartbeat) clearInterval(heartbeat);
+          for (const stream of openStreams) stream.destroy();
+          controller.close();
+        });
+      },
+      cancel() {
+        closed = true;
+        if (heartbeat) clearInterval(heartbeat);
+        for (const stream of openStreams) stream.destroy();
+      },
+    });
+
+    return new Response(body, {
+      headers: {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-transform",
+        connection: "keep-alive",
+      },
+    });
+  });
+
+  return app;
+}

src/routes/missions.ts

@@ -9,6 +9,10 @@ import { isActorBackedMission } from "../missions/registry.js";
 import { getPersistedMissionDefinition, listPersistedMissionDefinitions } from "../missions/postgres-registry.js";
 import { completeMissionCoachRunPg, createMissionCoachRunPg, getActiveMissionPg, listActiveMissionsPg, listMissionSuggestionsPg, replaceMissionSuggestionsPg, upsertActiveMissionPg } from "../grow/persistence.js";
 import { buildDeterministicMissionSuggestions } from "../missions/suggestions.js";
+import { createMissionAction, getMissionAction, listMissionActions, updateMissionActionStatus } from "../missions/actions.js";
+import { recordGrowEvent } from "../events/record-grow-event.js";
+import { routeGrowEventToUserActor } from "../events/route-to-user-actor.js";
+import { missionDetailHref } from "../missions/reducer-helpers.js";
 
 let _client: Client<Registry> | null = null;
 function getClient(): Client<Registry> {
@@ -55,6 +59,15 @@ const addArtifactSchema = z.object({
   metadata: z.record(z.unknown()).optional(),
 });
 
+const answerActionSchema = z.object({
+  input: z.record(z.unknown()).optional(),
+  answer: z.string().optional(),
+});
+
+const snoozeActionSchema = z.object({
+  until: z.string().datetime().optional(),
+});
+
 const createInstanceId = (missionId: string) =>
   `${missionId}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
 
@@ -126,10 +139,15 @@ export function missionRoutes() {
     await Promise.all(persisted.map(async (item) => {
       suggestionsByMission[item.mission.instanceId] = await listMissionSuggestionsPg(userId, item.mission.instanceId);
     }));
+    const actionsByMission: Record<string, unknown[]> = {};
+    await Promise.all(persisted.map(async (item) => {
+      actionsByMission[item.mission.instanceId] = await listMissionActions(userId, { missionInstanceId: item.mission.instanceId });
+    }));
     return c.json({
       missions: persisted.map((item) => item.mission),
       snapshots: persisted.map((item) => item.snapshot).filter((snapshot): snapshot is MissionSnapshot => Boolean(snapshot)),
       suggestionsByMission,
+      actionsByMission,
     });
   });
 
@@ -138,7 +156,24 @@ export function missionRoutes() {
     const active = await getActiveMissionPg(userId, c.req.param("instanceId"));
     if (!active) return c.json({ error: "mission_not_found" }, 404);
     const suggestions = await listMissionSuggestionsPg(userId, active.mission.instanceId);
-    return c.json({ mission: active.mission, snapshot: active.snapshot, suggestions });
+    const actions = await listMissionActions(userId, { missionInstanceId: active.mission.instanceId });
+    return c.json({ mission: active.mission, snapshot: active.snapshot, suggestions, actions });
+  });
+
+  app.get("/active/:instanceId/actions", async (c) => {
+    const userId = c.get("userId");
+    const active = await getActiveMissionPg(userId, c.req.param("instanceId"));
+    if (!active) return c.json({ error: "mission_not_found" }, 404);
+    return c.json({ actions: await listMissionActions(userId, { missionInstanceId: active.mission.instanceId }) });
+  });
+
+  app.post("/active/:instanceId/scrum/run", async (c) => {
+    const userId = c.get("userId");
+    const active = await getActiveMissionPg(userId, c.req.param("instanceId"));
+    if (!active?.mission.actorType) return c.json({ error: "mission_not_found" }, 404);
+    const result = await missionActorFor(userId, active.mission.instanceId, active.mission.actorType).runDailyScrum({ trigger: "manual" });
+    if (result.snapshot) await upsertActiveMissionPg(userId, activeMissionFromSnapshot(result.snapshot), result.snapshot);
+    return c.json({ summary: result.summary, snapshot: result.snapshot });
   });
 
   app.post("/active/:instanceId/coach/run", async (c) => {
@@ -190,6 +225,77 @@ export function missionRoutes() {
     return c.json({ coachRunId: run.id, summary, suggestions });
   });
 
+  app.post("/actions/:actionId/approve", async (c) => {
+    const userId = c.get("userId");
+    const action = await getMissionAction(userId, c.req.param("actionId"));
+    if (!action) return c.json({ error: "action_not_found" }, 404);
+    const updated = await updateMissionActionStatus(userId, action.id, {
+      status: "queued",
+      result: { approvedAt: new Date().toISOString() },
+      payload: { ...(action.payload ?? {}), approved: true },
+    });
+    const active = await getActiveMissionPg(userId, action.missionInstanceId);
+    if (active?.mission.actorType) {
+      await missionActorFor(userId, active.mission.instanceId, active.mission.actorType).resolveHitl({ actionId: action.id, resolution: "approved" }).catch(() => undefined);
+    }
+    return c.json({ action: updated });
+  });
+
+  app.post("/actions/:actionId/reject", async (c) => {
+    const userId = c.get("userId");
+    const action = await updateMissionActionStatus(userId, c.req.param("actionId"), { status: "dismissed", result: { rejectedAt: new Date().toISOString() } });
+    if (!action) return c.json({ error: "action_not_found" }, 404);
+    return c.json({ action });
+  });
+
+  app.post("/actions/:actionId/run", async (c) => {
+    const userId = c.get("userId");
+    const existing = await getMissionAction(userId, c.req.param("actionId"));
+    if (!existing) return c.json({ error: "action_not_found" }, 404);
+    const active = await getActiveMissionPg(userId, existing.missionInstanceId);
+    if (active?.mission.actorType) {
+      await missionActorFor(userId, active.mission.instanceId, active.mission.actorType).runAction({ actionId: existing.id }).catch(() => undefined);
+    }
+    const href = typeof existing.payload?.href === "string" ? existing.payload.href : missionDetailHref(existing.missionInstanceId);
+    const action = await updateMissionActionStatus(userId, existing.id, {
+      status: "done",
+      result: {
+        ranAt: new Date().toISOString(),
+        message: existing.toolName?.startsWith("resume.")
+          ? "Resume Agent prepared the draft brief. Open Resume Builder to apply it."
+          : "Action marked complete. Continue from the linked GrowQR surface.",
+        href,
+      },
+    });
+    return c.json({ action });
+  });
+
+  app.post("/actions/:actionId/answer", async (c) => {
+    const userId = c.get("userId");
+    const existing = await getMissionAction(userId, c.req.param("actionId"));
+    if (!existing) return c.json({ error: "action_not_found" }, 404);
+    const body = answerActionSchema.parse(await c.req.json().catch(() => ({})));
+    const input = body.input ?? (body.answer ? { answer: body.answer } : {});
+    const action = await updateMissionActionStatus(userId, existing.id, {
+      status: "done",
+      result: { answeredAt: new Date().toISOString(), input },
+      payload: { ...(existing.payload ?? {}), userInput: input },
+    });
+    const active = await getActiveMissionPg(userId, existing.missionInstanceId);
+    if (active?.mission.actorType) {
+      await missionActorFor(userId, active.mission.instanceId, active.mission.actorType).resolveHitl({ actionId: existing.id, resolution: "answered", input }).catch(() => undefined);
+    }
+    return c.json({ action });
+  });
+
+  app.post("/actions/:actionId/snooze", async (c) => {
+    const userId = c.get("userId");
+    const body = snoozeActionSchema.parse(await c.req.json().catch(() => ({})));
+    const action = await updateMissionActionStatus(userId, c.req.param("actionId"), { status: "snoozed", result: { snoozedAt: new Date().toISOString(), until: body.until } });
+    if (!action) return c.json({ error: "action_not_found" }, 404);
+    return c.json({ action });
+  });
+
   app.post("/:missionId/start", async (c) => {
     const userId = c.get("userId");
     const missionId = c.req.param("missionId");
@@ -215,6 +321,16 @@ export function missionRoutes() {
     await upsertActiveMissionPg(userId, activeMission, snapshot);
     const grow = growFor(userId);
     grow.setup({ userId }).then(() => grow.registerActiveMission(activeMission)).catch((err) => console.warn("growActor mission mirror failed", err));
+    recordGrowEvent({
+      source: "growqr-backend:missions",
+      type: "mission.started",
+      category: "mission",
+      userId,
+      occurredAt: new Date().toISOString(),
+      mission: { instanceId, missionId, stageId: snapshot.currentStageId },
+      payload: { goal: body.goal, input: body.input ?? {}, title: snapshot.title },
+      dedupeKey: `mission-started:${instanceId}`,
+    }).then((event) => routeGrowEventToUserActor(event)).catch((err) => console.warn("mission start event routing failed", err));
     return c.json({ mission: activeMission, snapshot }, 201);
   });
 

src/routes/services.ts

@@ -8,18 +8,13 @@ import { db } from "../db/client.js";
 import { events, growQscoreLatest, growQscoreProjectionState } from "../db/schema.js";
 import { recordGrowEvent } from "../events/record-grow-event.js";
 import { routeGrowEventToUserActor } from "../events/route-to-user-actor.js";
+import { ensureOnboardingBaselineQscore } from "../events/onboarding-qscore.js";
 import { log } from "../log.js";
 
 const LANDING_AGENTS = [
-  { id: "resume", title: "The Resume Expert", agent: "AI Resume Expert", description: "Writes resumes and cover letters that get past ATS and into human hands.", route: "/agents/resume" },
-  { id: "interview", title: "The Interviewer", agent: "AI Interviewer", description: "Puts you through real interviews before the real one. Brutal feedback included.", route: "/agents/interview" },
-  { id: "roleplay", title: "The Roleplay Coach", agent: "AI Roleplay Coach", description: "Practises the hard conversations with you — so you're never caught off guard.", route: "/agents/roleplay" },
-  { id: "assessments", title: "The Skill Trainer", agent: "AI Skill Trainer", description: "Finds exactly what's holding you back — then builds a plan to close it.", route: "/agents/assessments" },
-  { id: "social-branding", title: "The Brand Voice", agent: "AI Brand Voice", description: "Makes you impossible to ignore online — posts, profiles, and positioning sorted.", route: "/agents/social-branding" },
-  { id: "pathways-report", title: "The Pathway Guide", agent: "AI Pathway Guide", description: "Maps career options, pivots, and what-fits-next at every stage of your journey.", route: "/agents/pathways-report" },
-  { id: "courses", title: "The Learning Curator", agent: "AI Learning Curator", description: "Picks only what's worth your time — courses and paths that move you forward.", route: "/agents/courses" },
-  { id: "jobs", title: "The Opportunity Finder", agent: "AI Job Finder", description: "Daily, agent-sourced shortlist of roles matched to your QX and goals.", route: "/agents/jobs" },
-  { id: "presence", title: "The Presence Coach", agent: "AI Presence Coach", description: "Tells you what to wear, how to speak, and how to carry yourself in every room.", route: "/agents/presence" },
+  { id: "resume", title: "Resume", agent: "Resume Strategist", description: "Resume proof, versions, parsing, analysis, and mission artifacts.", route: "/agents/resume" },
+  { id: "interview", title: "Interview", agent: "Interview Coach", description: "Mock interviews, reviews, weakness diagnosis, and readiness signals.", route: "/agents/interview" },
+  { id: "roleplay", title: "Roleplay", agent: "Roleplay Coach", description: "Negotiation, promotion, transition, and communication drills.", route: "/agents/roleplay" },
 ] as const;
 
 const DEFAULT_QSCORE = {
@@ -48,6 +43,38 @@ function missionFromBody(body: JsonObject): Record<string, unknown> | undefined
   return mission && typeof mission === "object" && !Array.isArray(mission) ? (mission as Record<string, unknown>) : undefined;
 }
 
+function missionFromRequest(req: Request, body?: JsonObject): Record<string, unknown> | undefined {
+  const fromBody = body ? missionFromBody(body) : undefined;
+  if (fromBody) return fromBody;
+
+  const url = new URL(req.url);
+  const instanceId = getString(url.searchParams.get("missionInstanceId"));
+  const missionId = getString(url.searchParams.get("missionId"));
+  const stageId = getString(url.searchParams.get("stageId"));
+  const source = getString(url.searchParams.get("source"));
+
+  if (!instanceId && !missionId && !stageId) return undefined;
+  return {
+    instanceId,
+    missionId,
+    stageId,
+    source: source ?? "mission",
+  };
+}
+
+function curatorTaskIdFromRequest(req: Request, body?: JsonObject) {
+  const fromBody = body ? getString((body as Record<string, unknown>).curatorTaskId) : undefined;
+  if (fromBody) return fromBody;
+  const url = new URL(req.url);
+  return getString(url.searchParams.get("curatorTaskId"));
+}
+
+function stripMissionFromBody(body: JsonObject): JsonObject {
+  if (!("mission" in body)) return body;
+  const { mission: _mission, ...rest } = body;
+  return rest;
+}
+
 async function recordGatewayEvent(input: {
   userId: string;
   source: string;
@@ -84,6 +111,26 @@ function eventTypeForReview(prefix: "interview" | "roleplay", result: Record<str
   return `${prefix}.review_processing`;
 }
 
+function resumeEventTypeForRest(method: string, rest: string, ok: boolean) {
+  if (!ok) return "resume.request_failed";
+  if (method === "POST" && /^resumes\/upload/.test(rest)) return "resume.uploaded";
+  if (method === "POST" && /^parse\/resume\/[^/]+\/parse/.test(rest)) return "resume.parsed";
+  if (method === "POST" && /^ai\/analyze\//.test(rest)) return "resume.analysis_completed";
+  if ((method === "POST" || method === "PUT" || method === "PATCH") && /versions?/.test(rest)) return "resume.version_created";
+  if (method !== "GET") return "resume.updated";
+  return "resume.loaded";
+}
+
+function parseJsonBody(body: ArrayBuffer | undefined, headers: Headers): JsonObject {
+  if (!body || !headers.get("content-type")?.includes("application/json")) return {};
+  try {
+    const parsed = JSON.parse(Buffer.from(body).toString("utf8"));
+    return isRecord(parsed) ? parsed as JsonObject : {};
+  } catch {
+    return {};
+  }
+}
+
 async function proxyResumeRequest(req: Request, rest: string, userId: string) {
   const incoming = new URL(req.url);
   const normalizedRest = rest
@@ -92,8 +139,13 @@ async function proxyResumeRequest(req: Request, rest: string, userId: string) {
     .replace(/^resumes\/([^/]+)\/analyze$/, "ai/analyze/$1")
     .replace(/^resumes\/([^/]+)\/suggestions$/, "ai/suggestions/$1")
     .replace(/^resumes\/([^/]+)\/preview$/, "export/resumes/$1/preview");
+  const forwardedQuery = new URLSearchParams(incoming.searchParams);
+  forwardedQuery.delete("missionInstanceId");
+  forwardedQuery.delete("missionId");
+  forwardedQuery.delete("stageId");
+  forwardedQuery.delete("source");
   const target = new URL(
-    `/api/v1/${normalizedRest}${incoming.search}`,
+    `/api/v1/${normalizedRest}${forwardedQuery.toString() ? `?${forwardedQuery.toString()}` : ""}`,
     config.resumeServiceUrl.replace(/\/$/, ""),
   );
 
@@ -105,19 +157,263 @@ async function proxyResumeRequest(req: Request, rest: string, userId: string) {
 
   const method = req.method.toUpperCase();
   const body = ["GET", "HEAD"].includes(method) ? undefined : await req.arrayBuffer();
+  const requestJson = parseJsonBody(body, headers);
+  const mission = missionFromRequest(req, requestJson);
+  const forwardBody =
+    body && headers.get("content-type")?.includes("application/json")
+      ? Buffer.from(JSON.stringify(stripMissionFromBody(requestJson)))
+      : body;
+  if (forwardBody !== body) headers.delete("content-length");
   const res = await fetch(target, {
     method,
     headers,
-    body,
+    body: forwardBody,
   });
 
-  return new Response(res.body, {
+  if (method === "GET" || method === "HEAD") {
+    return new Response(res.body, { status: res.status, statusText: res.statusText, headers: res.headers });
+  }
+
+  const responseBuffer = await res.arrayBuffer();
+  const responseText = Buffer.from(responseBuffer).toString("utf8");
+  let responseJson: unknown;
+  try { responseJson = responseText ? JSON.parse(responseText) : undefined; } catch { responseJson = undefined; }
+  const responseObj = isRecord(responseJson) ? responseJson : { body: responseText.slice(0, 2000) };
+
+  await recordGatewayEvent({
+    userId,
+    source: "resume-builder",
+    type: resumeEventTypeForRest(method, normalizedRest, res.ok),
+    payload: { request: requestJson, result: responseObj, status: res.status, path: normalizedRest },
+    correlation: {
+      resumeId: getString(responseObj.resume_id ?? responseObj.resumeId ?? responseObj.id) ?? getString(requestJson.resume_id ?? requestJson.resumeId),
+      externalId: getString(responseObj.resume_id ?? responseObj.resumeId ?? responseObj.id) ?? getString(requestJson.resume_id ?? requestJson.resumeId),
+      taskId: curatorTaskIdFromRequest(req, requestJson),
+    },
+    mission,
+  }).catch((err) => log.warn({ err, path: normalizedRest }, "failed to record resume gateway event"));
+
+  return new Response(responseBuffer, {
     status: res.status,
     statusText: res.statusText,
     headers: res.headers,
   });
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.map((item) => String(item).trim()).filter(Boolean) : [];
+}
+
+async function getUserServiceProfile(req: Request): Promise<{ userProfile?: Record<string, unknown>; preferences?: Record<string, unknown> }> {
+  const target = new URL("/api/v1/users/me", config.userServiceUrl.replace(/\/$/, ""));
+  const headers = new Headers(req.headers);
+  headers.delete("host");
+  headers.delete("cookie");
+  const res = await fetch(target, { method: "GET", headers });
+  if (!res.ok) return {};
+  const userProfile = await res.json().catch(() => null) as Record<string, unknown> | null;
+  const preferences = userProfile?.preferences;
+  return {
+    userProfile: userProfile ?? undefined,
+    preferences: isRecord(preferences) ? preferences : {},
+  };
+}
+
+async function getUserServicePreferences(req: Request): Promise<Record<string, unknown> | undefined> {
+  return (await getUserServiceProfile(req)).preferences;
+}
+
+async function getServiceState(baseUrl: string, path: string): Promise<Record<string, unknown> | undefined> {
+  const target = new URL(path, baseUrl.replace(/\/$/, ""));
+  const res = await fetch(target, {
+    method: "GET",
+    headers: {
+      ...(config.a2aAllowedKey ? { authorization: `Bearer ${config.a2aAllowedKey}` } : {}),
+    },
+  }).catch(() => null);
+  if (!res?.ok) return undefined;
+  const json = await res.json().catch(() => null);
+  return isRecord(json) ? json : undefined;
+}
+
+function mergeUniqueSkills(existing: unknown, incoming: unknown): string[] {
+  const seen = new Set<string>();
+  const merged: string[] = [];
+  for (const skill of [...stringArray(existing), ...stringArray(incoming)]) {
+    const key = skill.toLowerCase();
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    merged.push(skill);
+  }
+  return merged;
+}
+
+async function resolveGrowUserContext(req: Request, userId: string): Promise<Record<string, unknown>> {
+  const { userProfile } = await getUserServiceProfile(req);
+  const userContext: Record<string, unknown> = { ...(userProfile ?? {}) };
+  userContext.clerk_id = String(userContext.clerk_id ?? userId);
+
+  const clerkId = String(userContext.clerk_id || userId);
+  const [resumeState, socialState] = await Promise.all([
+    getServiceState(config.resumeServiceUrl, `/api/state/${encodeURIComponent(clerkId)}`),
+    getServiceState(config.socialBrandingServiceUrl, `/api/state/${encodeURIComponent(clerkId)}`),
+  ]);
+
+  if (resumeState) {
+    const resumeSkills = resumeState.skills ?? [
+      ...stringArray(resumeState.technical_skills),
+      ...stringArray(resumeState.soft_skills),
+    ];
+    userContext.skills = mergeUniqueSkills(userContext.skills, resumeSkills);
+    if (resumeState.current_role && !userContext.current_role) userContext.current_role = resumeState.current_role;
+    if (resumeState.current_company && !userContext.current_company) userContext.current_company = resumeState.current_company;
+    if (Array.isArray(resumeState.experience_history)) userContext.experience_history = resumeState.experience_history;
+    if (Array.isArray(resumeState.education)) userContext.education = resumeState.education;
+  }
+
+  if (socialState) {
+    userContext.skills = mergeUniqueSkills(userContext.skills, socialState.skills ?? socialState.linkedin_skills);
+    if (socialState.headline) userContext.linkedin_headline = socialState.headline;
+    if (socialState.summary) userContext.linkedin_summary = socialState.summary;
+    if (Array.isArray(socialState.experience)) userContext.linkedin_experience = socialState.experience;
+    userContext.linkedin_connected = Boolean(socialState.linkedin_connected);
+  }
+
+  return userContext;
+}
+
+function hasResumeContext(userContext: Record<string, unknown>): boolean {
+  return Boolean(
+    (Array.isArray(userContext.experience_history) && userContext.experience_history.length > 0) ||
+      (Array.isArray(userContext.skills) && userContext.skills.length > 0) ||
+      getString(userContext.current_role)
+  );
+}
+
+function hasLinkedInContext(userContext: Record<string, unknown>): boolean {
+  return Boolean(
+    userContext.linkedin_connected ||
+      getString(userContext.linkedin_headline) ||
+      getString(userContext.linkedin_summary) ||
+      (Array.isArray(userContext.linkedin_experience) && userContext.linkedin_experience.length > 0)
+  );
+}
+
+function composeCandidateProfile(userContext: Record<string, unknown>): string {
+  const lines: string[] = [];
+  const currentRole = getString(userContext.current_role);
+  const headline = getString(userContext.linkedin_headline);
+  if (currentRole) lines.push(`Current role: ${currentRole}`);
+  if (headline && headline.toLowerCase() !== currentRole?.toLowerCase()) lines.push(`LinkedIn headline: ${headline}`);
+
+  const skills = stringArray(userContext.skills);
+  if (skills.length) lines.push(`Key skills: ${skills.slice(0, 12).join(", ")}`);
+
+  const roles: string[] = [];
+  const seen = new Set<string>();
+  const addRole = (title?: unknown, company?: unknown) => {
+    const roleTitle = String(title ?? "").trim();
+    const roleCompany = String(company ?? "").trim();
+    if (!roleTitle && !roleCompany) return;
+    const key = `${roleTitle.toLowerCase()}|${roleCompany.toLowerCase()}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    roles.push(roleTitle && roleCompany ? `${roleTitle} at ${roleCompany}` : roleTitle || roleCompany);
+  };
+  for (const item of Array.isArray(userContext.experience_history) ? userContext.experience_history : []) {
+    if (isRecord(item)) addRole(item.position ?? item.title, item.company);
+  }
+  for (const item of Array.isArray(userContext.linkedin_experience) ? userContext.linkedin_experience : []) {
+    if (isRecord(item)) addRole(item.title ?? item.position, item.company);
+  }
+  if (roles.length) lines.push(`Experience: ${roles.slice(0, 6).join("; ")}`);
+
+  const education: string[] = [];
+  for (const item of Array.isArray(userContext.education) ? userContext.education : []) {
+    if (!isRecord(item)) continue;
+    const degree = getString(item.degree);
+    const field = getString(item.field_of_study);
+    const institution = getString(item.institution ?? item.school);
+    let piece = [degree, field].filter(Boolean).join(" ").trim();
+    if (institution) piece = piece ? `${piece} — ${institution}` : institution;
+    if (piece) education.push(piece);
+  }
+  if (education.length) lines.push(`Education: ${education.slice(0, 3).join("; ")}`);
+
+  const summary = getString(userContext.linkedin_summary);
+  if (summary) lines.push(`Profile summary: ${summary.length > 300 ? `${summary.slice(0, 300).trimEnd()}…` : summary}`);
+
+  const text = lines.join("\n");
+  return text.length > 1200 ? `${text.slice(0, 1200).trimEnd()}…` : text;
+}
+
+async function buildPersonalizedConfigurePayload(req: Request, body: JsonObject, userId: string): Promise<JsonObject> {
+  const { mission: _mission, ...rest } = body;
+  const userContext = await resolveGrowUserContext(req, userId).catch((err) => {
+    log.warn({ err, userId }, "failed to resolve Grow user context for interview configure");
+    return {} as Record<string, unknown>;
+  });
+  const incomingContext = isRecord(rest.context) ? rest.context : {};
+  const context: Record<string, unknown> = {
+    ...incomingContext,
+    candidate_name: getString(incomingContext.candidate_name) ?? getString(userContext.first_name) ?? "",
+    target_role: getString(incomingContext.target_role) ?? "",
+    company_name: getString(incomingContext.company_name) ?? "",
+    job_description: getString(incomingContext.job_description) ?? "",
+    difficulty: getString(incomingContext.difficulty) ?? "medium",
+  };
+
+  if (incomingContext.personalize) {
+    const candidateProfile = composeCandidateProfile(userContext);
+    if (candidateProfile) context.candidate_profile = candidateProfile;
+  }
+
+  return {
+    ...rest,
+    user_id: String(rest.user_id ?? userId),
+    org_id: String(rest.org_id ?? "growqr"),
+    context,
+  };
+}
+
+async function buildPersonalizedRoleplayConfigurePayload(req: Request, body: JsonObject, userId: string): Promise<JsonObject> {
+  const { mission: _mission, ...rest } = body;
+  const userContext = await resolveGrowUserContext(req, userId).catch((err) => {
+    log.warn({ err, userId }, "failed to resolve Grow user context for roleplay configure");
+    return {} as Record<string, unknown>;
+  });
+  const incomingMetadata = isRecord(rest.metadata) ? rest.metadata : {};
+  const metadata: Record<string, unknown> = {
+    ...incomingMetadata,
+    candidate_name: getString(incomingMetadata.candidate_name) ?? getString(userContext.first_name) ?? "",
+    target_role: getString(incomingMetadata.target_role) ?? getString(userContext.current_role) ?? "General",
+    candidate_role: getString(incomingMetadata.candidate_role) ?? getString(incomingMetadata.target_role) ?? getString(userContext.current_role) ?? "General",
+    difficulty: getString(incomingMetadata.difficulty) ?? "medium",
+  };
+
+  // Match the production orchestrator behavior: roleplay-service receives the
+  // same enriched user context the websocket orchestrator attached to A2A tasks,
+  // plus prompt-safe metadata that can personalize scenario planning/review.
+  const candidateProfile = composeCandidateProfile(userContext);
+  if (candidateProfile && (incomingMetadata.personalize ?? true)) {
+    metadata.candidate_profile = candidateProfile;
+    metadata.context_notes = getString(incomingMetadata.context_notes) ?? candidateProfile;
+  }
+
+  return {
+    ...rest,
+    user_id: String(rest.user_id ?? userId),
+    org_id: String(rest.org_id ?? "growqr"),
+    metadata,
+    qscore: (rest.qscore as JsonObject | undefined) ?? (isRecord(userContext.qscore) ? userContext.qscore : DEFAULT_QSCORE),
+    user_context: userContext,
+  };
+}
+
 async function proxySocialRequest(req: Request, rest: string, userId: string) {
   const incoming = new URL(req.url);
   const normalizedRest = rest.replace(/^\/+/, "");
@@ -194,6 +490,12 @@ export function serviceRoutes() {
 
   app.get("/qscore/current", async (c) => {
     const userId = c.get("userId");
+    try {
+      await ensureOnboardingBaselineQscore(userId, await getUserServicePreferences(c.req.raw));
+    } catch (err) {
+      log.warn({ err, userId }, "failed to seed onboarding Q Score baseline before current Q Score read");
+    }
+
     const [projection] = await db
       .select()
       .from(growQscoreProjectionState)
@@ -252,15 +554,26 @@ export function serviceRoutes() {
     });
   });
 
-  app.get("/interview/page-state", async (c) => c.json(await interviewService.pageState(c.get("userId"))));
+  app.get("/interview/page-state", async (c) => {
+    const userId = c.get("userId");
+    const [state, userContext] = await Promise.all([
+      interviewService.pageState(userId),
+      resolveGrowUserContext(c.req.raw, userId).catch((err) => {
+        log.warn({ err, userId }, "failed to resolve Grow user context for interview page-state");
+        return {} as Record<string, unknown>;
+      }),
+    ]);
+    return c.json({
+      ...state,
+      resume_available: hasResumeContext(userContext),
+      linkedin_available: hasLinkedInContext(userContext),
+    });
+  });
   app.post("/interview/configure", async (c) => {
     const userId = c.get("userId");
     const body = await c.req.json<JsonObject>();
-    const payload = {
-      ...body,
-      user_id: String(body.user_id ?? userId),
-      org_id: String(body.org_id ?? "growqr"),
-    } satisfies JsonObject;
+    const mission = missionFromRequest(c.req.raw, body);
+    const payload = await buildPersonalizedConfigurePayload(c.req.raw, body, userId);
     const result = await interviewService.configure(payload);
     const resultObj = result as Record<string, unknown>;
     await recordGatewayEvent({
@@ -268,8 +581,8 @@ export function serviceRoutes() {
       source: "interview-service",
       type: "interview.configured",
       payload: { request: payload, result: resultObj },
-      correlation: { sessionId: getSessionId(resultObj), requestId: getString(body.request_id) },
-      mission: missionFromBody(body),
+      correlation: { sessionId: getSessionId(resultObj), requestId: getString(body.request_id), taskId: curatorTaskIdFromRequest(c.req.raw, body) },
+      mission,
     }).catch((err) => log.warn({ err }, "failed to record interview configured event"));
     return c.json(result);
   });
@@ -293,25 +606,35 @@ export function serviceRoutes() {
       source: "interview-service",
       type: eventTypeForReview("interview", resultObj),
       payload: resultObj,
-      correlation: { sessionId },
+      correlation: { sessionId, taskId: curatorTaskIdFromRequest(c.req.raw) },
     }).catch((err) => log.warn({ err }, "failed to record interview review event"));
     return c.json(result);
   });
   app.get("/interview/leaderboard", async (c) => c.json(await interviewService.leaderboard()));
   app.get("/interview/artifacts/:sessionId/:artifactType", async (c) => c.json(await interviewService.artifact(c.req.param("sessionId"), c.req.param("artifactType"))));
-  app.post("/interview/sessions/:sessionId/video/upload-url", async (c) => c.json(await interviewService.createVideoUploadUrl(c.req.param("sessionId"), await c.req.json<JsonObject>())));
-  app.post("/interview/sessions/:sessionId/video/uploaded", async (c) => c.json(await interviewService.markVideoUploaded(c.req.param("sessionId"), await c.req.json<JsonObject>())));
+  app.post("/interview/sessions/:sessionId/video/upload-url", async (c) => c.json(await interviewService.createVideoUploadUrl(c.req.param("sessionId"))));
+  app.post("/interview/sessions/:sessionId/video/uploaded", async (c) => c.json(await interviewService.markVideoUploaded(c.req.param("sessionId"))));
 
-  app.get("/roleplay/page-state", async (c) => c.json(await roleplayService.pageState(c.get("userId"))));
+  app.get("/roleplay/page-state", async (c) => {
+    const userId = c.get("userId");
+    const [state, userContext] = await Promise.all([
+      roleplayService.pageState(userId),
+      resolveGrowUserContext(c.req.raw, userId).catch((err) => {
+        log.warn({ err, userId }, "failed to resolve Grow user context for roleplay page-state");
+        return {} as Record<string, unknown>;
+      }),
+    ]);
+    return c.json({
+      ...state,
+      resume_available: hasResumeContext(userContext),
+      linkedin_available: hasLinkedInContext(userContext),
+    });
+  });
   app.post("/roleplay/configure", async (c) => {
     const userId = c.get("userId");
     const body = await c.req.json<JsonObject>();
-    const payload = {
-      ...body,
-      user_id: String(body.user_id ?? userId),
-      org_id: String(body.org_id ?? "growqr"),
-      qscore: (body.qscore as JsonObject | undefined) ?? DEFAULT_QSCORE,
-    } satisfies JsonObject;
+    const mission = missionFromRequest(c.req.raw, body);
+    const payload = await buildPersonalizedRoleplayConfigurePayload(c.req.raw, body, userId);
     const result = await roleplayService.configure(payload);
     const resultObj = result as Record<string, unknown>;
     await recordGatewayEvent({
@@ -319,8 +642,8 @@ export function serviceRoutes() {
       source: "roleplay-service",
       type: "roleplay.configured",
       payload: { request: payload, result: resultObj },
-      correlation: { sessionId: getSessionId(resultObj), requestId: getString(body.request_id) },
-      mission: missionFromBody(body),
+      correlation: { sessionId: getSessionId(resultObj), requestId: getString(body.request_id), taskId: curatorTaskIdFromRequest(c.req.raw, body) },
+      mission,
     }).catch((err) => log.warn({ err }, "failed to record roleplay configured event"));
     return c.json(result);
   });
@@ -344,14 +667,14 @@ export function serviceRoutes() {
       source: "roleplay-service",
       type: eventTypeForReview("roleplay", resultObj),
       payload: resultObj,
-      correlation: { sessionId },
+      correlation: { sessionId, taskId: curatorTaskIdFromRequest(c.req.raw) },
     }).catch((err) => log.warn({ err }, "failed to record roleplay review event"));
     return c.json(result);
   });
   app.get("/roleplay/leaderboard", async (c) => c.json(await roleplayService.leaderboard()));
   app.get("/roleplay/artifacts/:sessionId/:artifactType", async (c) => c.json(await roleplayService.artifact(c.req.param("sessionId"), c.req.param("artifactType"))));
-  app.post("/roleplay/sessions/:sessionId/video/upload-url", async (c) => c.json(await roleplayService.createVideoUploadUrl(c.req.param("sessionId"), await c.req.json<JsonObject>())));
-  app.post("/roleplay/sessions/:sessionId/video/uploaded", async (c) => c.json(await roleplayService.markVideoUploaded(c.req.param("sessionId"), await c.req.json<JsonObject>())));
+  app.post("/roleplay/sessions/:sessionId/video/upload-url", async (c) => c.json(await roleplayService.createVideoUploadUrl(c.req.param("sessionId"))));
+  app.post("/roleplay/sessions/:sessionId/video/uploaded", async (c) => c.json(await roleplayService.markVideoUploaded(c.req.param("sessionId"))));
 
   app.get("/resume/state/:clerkId", async (c) => c.json(await resumeService.state(c.req.param("clerkId"))));
   app.post("/resume/tasks", async (c) => {
@@ -364,7 +687,9 @@ export function serviceRoutes() {
   // resumes, templates, uploads, parsing, exports, cover letters, versions,
   // restore, primary selection, and AI endpoints.
   app.all("/resume/*", async (c) => {
-    const rest = c.req.path.split("/resume/")[1] ?? "";
+    const marker = "/resume/";
+    const markerIndex = c.req.path.indexOf(marker);
+    const rest = markerIndex >= 0 ? c.req.path.slice(markerIndex + marker.length) : "";
     return proxyResumeRequest(c.req.raw, rest, c.get("userId"));
   });
 

src/routes/users.ts

@@ -6,6 +6,7 @@ import { eq } from "drizzle-orm";
 import { provisionUserStack } from "../docker/manager.js";
 import { log } from "../log.js";
 import { config } from "../config.js";
+import { ensureOnboardingBaselineQscore } from "../events/onboarding-qscore.js";
 
 function publicStack(stack: UserStack | null | undefined) {
   if (!stack) return stack;
@@ -17,7 +18,7 @@ function userServiceTarget(path: string, search = "") {
   return new URL(`/api/v1/users${path}${search}`, config.userServiceUrl.replace(/\/$/, ""));
 }
 
-async function proxyUserService(req: Request, path: string) {
+async function fetchUserService(req: Request, path: string) {
   const incoming = new URL(req.url);
   const target = userServiceTarget(path, incoming.search);
   const headers = new Headers(req.headers);
@@ -26,7 +27,11 @@ async function proxyUserService(req: Request, path: string) {
 
   const method = req.method.toUpperCase();
   const body = ["GET", "HEAD"].includes(method) ? undefined : await req.arrayBuffer();
-  const res = await fetch(target, { method, headers, body });
+  return fetch(target, { method, headers, body });
+}
+
+async function proxyUserService(req: Request, path: string) {
+  const res = await fetchUserService(req, path);
   return new Response(res.body, {
     status: res.status,
     statusText: res.statusText,
@@ -89,7 +94,31 @@ export function userRoutes() {
   });
 
   app.get("/me", async (c) => proxyUserService(c.req.raw, "/me"));
-  app.patch("/me", async (c) => proxyUserService(c.req.raw, "/me"));
+  app.patch("/me", async (c) => {
+    const res = await fetchUserService(c.req.raw, "/me");
+    const text = await res.text();
+
+    if (res.ok) {
+      try {
+        const userProfile = JSON.parse(text) as Record<string, unknown>;
+        const preferences = userProfile.preferences;
+        await ensureOnboardingBaselineQscore(
+          c.get("userId"),
+          preferences && typeof preferences === "object" && !Array.isArray(preferences)
+            ? (preferences as Record<string, unknown>)
+            : undefined,
+        );
+      } catch (err) {
+        log.warn({ err, userId: c.get("userId") }, "failed to seed onboarding Q Score baseline after user update");
+      }
+    }
+
+    return new Response(text, {
+      status: res.status,
+      statusText: res.statusText,
+      headers: res.headers,
+    });
+  });
   app.get("/me/plan", async (c) => proxyUserService(c.req.raw, "/me/plan"));
   app.post("/me/photo", async (c) => proxyUserService(c.req.raw, "/me/photo"));
   app.delete("/me/photo", async (c) => proxyUserService(c.req.raw, "/me/photo"));

src/services/product-service-clients.ts

@@ -6,8 +6,12 @@ export type ServiceCallOptions = {
   method?: string;
   body?: unknown;
   headers?: Record<string, string>;
+  timeoutMs?: number;
 };
 
+const DEFAULT_SERVICE_TIMEOUT_MS = Number(process.env.PRODUCT_SERVICE_TIMEOUT_MS ?? 3500);
+const INTERACTIVE_SERVICE_TIMEOUT_MS = Number(process.env.PRODUCT_INTERACTIVE_SERVICE_TIMEOUT_MS ?? 120000);
+
 async function serviceJson<T = JsonObject>(
   baseUrl: string,
   path: string,
@@ -21,6 +25,7 @@ async function serviceJson<T = JsonObject>(
       ...(opts.headers ?? {}),
     },
     body: opts.body === undefined ? undefined : JSON.stringify(opts.body),
+    signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_SERVICE_TIMEOUT_MS),
   });
   const text = await res.text();
   if (!res.ok) throw new Error(`${path} returned HTTP ${res.status}: ${text}`);
@@ -30,12 +35,12 @@ async function serviceJson<T = JsonObject>(
 export const interviewService = {
   health: () => serviceJson(config.interviewServiceUrl, "/health"),
   pageState: (userId: string) => serviceJson(config.interviewServiceUrl, `/api/v1/interviews/page-state?${new URLSearchParams({ user_id: userId })}`),
-  configure: (payload: JsonObject) => serviceJson(config.interviewServiceUrl, "/api/v1/configure", { body: payload }),
-  preview: (payload: JsonObject) => serviceJson(config.interviewServiceUrl, "/api/v1/configure/preview", { body: payload }),
+  configure: (payload: JsonObject) => serviceJson(config.interviewServiceUrl, "/api/v1/configure", { body: payload, timeoutMs: INTERACTIVE_SERVICE_TIMEOUT_MS }),
+  preview: (payload: JsonObject) => serviceJson(config.interviewServiceUrl, "/api/v1/configure/preview", { body: payload, timeoutMs: INTERACTIVE_SERVICE_TIMEOUT_MS }),
   editQuestions: (payload: { session_id: string; questions: Array<JsonObject | string> }) =>
-    serviceJson(config.interviewServiceUrl, "/api/v1/configure/questions", { body: payload }),
+    serviceJson(config.interviewServiceUrl, "/api/v1/configure/questions", { body: payload, timeoutMs: INTERACTIVE_SERVICE_TIMEOUT_MS }),
   approve: (sessionId: string) =>
-    serviceJson(config.interviewServiceUrl, "/api/v1/configure/approve", { body: { session_id: sessionId } }),
+    serviceJson(config.interviewServiceUrl, "/api/v1/configure/approve", { body: { session_id: sessionId }, timeoutMs: INTERACTIVE_SERVICE_TIMEOUT_MS }),
   createAssignments: (payload: { organization_id: string; role: string; round: "warm_up" | "behavioral" | "technical"; assignee_emails: string[] }) =>
     serviceJson(config.interviewServiceUrl, "/api/v1/interviews/assignments", { body: payload }),
   listAssignments: (email: string, status = "pending", limit = 20) =>
@@ -48,21 +53,27 @@ export const interviewService = {
   leaderboard: () => serviceJson(config.interviewServiceUrl, "/api/v1/leaderboard"),
   artifact: (sessionId: string, artifactType: string) =>
     serviceJson(config.interviewServiceUrl, `/api/v1/artifacts/${encodeURIComponent(sessionId)}/${encodeURIComponent(artifactType)}`),
-  createVideoUploadUrl: (sessionId: string, payload: JsonObject) =>
-    serviceJson(config.interviewServiceUrl, `/api/v1/sessions/${encodeURIComponent(sessionId)}/video/upload-url`, { body: payload }),
-  markVideoUploaded: (sessionId: string, payload: JsonObject) =>
-    serviceJson(config.interviewServiceUrl, `/api/v1/sessions/${encodeURIComponent(sessionId)}/video/uploaded`, { body: payload }),
+  createVideoUploadUrl: (sessionId: string, payload?: JsonObject) =>
+    serviceJson(config.interviewServiceUrl, `/api/v1/sessions/${encodeURIComponent(sessionId)}/video/upload-url`, {
+      method: "POST",
+      ...(payload === undefined ? {} : { body: payload }),
+    }),
+  markVideoUploaded: (sessionId: string, payload?: JsonObject) =>
+    serviceJson(config.interviewServiceUrl, `/api/v1/sessions/${encodeURIComponent(sessionId)}/video/uploaded`, {
+      method: "POST",
+      ...(payload === undefined ? {} : { body: payload }),
+    }),
 };
 
 export const roleplayService = {
   health: () => serviceJson(config.roleplayServiceUrl, "/health"),
   pageState: (userId: string) => serviceJson(config.roleplayServiceUrl, `/api/v1/roleplays/page-state?${new URLSearchParams({ user_id: userId })}`),
-  configure: (payload: JsonObject) => serviceJson(config.roleplayServiceUrl, "/api/v1/roleplays/configure", { body: payload }),
-  preview: (payload: JsonObject) => serviceJson(config.roleplayServiceUrl, "/api/v1/roleplays/configure/preview", { body: payload }),
+  configure: (payload: JsonObject) => serviceJson(config.roleplayServiceUrl, "/api/v1/roleplays/configure", { body: payload, timeoutMs: INTERACTIVE_SERVICE_TIMEOUT_MS }),
+  preview: (payload: JsonObject) => serviceJson(config.roleplayServiceUrl, "/api/v1/roleplays/configure/preview", { body: payload, timeoutMs: INTERACTIVE_SERVICE_TIMEOUT_MS }),
   editQuestions: (payload: { session_id: string; questions: Array<JsonObject | string> }) =>
-    serviceJson(config.roleplayServiceUrl, "/api/v1/roleplays/configure/questions", { body: payload }),
+    serviceJson(config.roleplayServiceUrl, "/api/v1/roleplays/configure/questions", { body: payload, timeoutMs: INTERACTIVE_SERVICE_TIMEOUT_MS }),
   approve: (sessionId: string) =>
-    serviceJson(config.roleplayServiceUrl, "/api/v1/roleplays/configure/approve", { body: { session_id: sessionId } }),
+    serviceJson(config.roleplayServiceUrl, "/api/v1/roleplays/configure/approve", { body: { session_id: sessionId }, timeoutMs: INTERACTIVE_SERVICE_TIMEOUT_MS }),
   createAssignments: (payload: { organization_id: string; name: string; scenario: string; assignee_emails: string[] }) =>
     serviceJson(config.roleplayServiceUrl, "/api/v1/roleplays/assignments", { body: payload }),
   listAssignments: (email: string, status = "pending", limit = 20) =>
@@ -75,10 +86,16 @@ export const roleplayService = {
   leaderboard: () => serviceJson(config.roleplayServiceUrl, "/api/v1/roleplays/leaderboard"),
   artifact: (sessionId: string, artifactType: string) =>
     serviceJson(config.roleplayServiceUrl, `/api/v1/artifacts/${encodeURIComponent(sessionId)}/${encodeURIComponent(artifactType)}`),
-  createVideoUploadUrl: (sessionId: string, payload: JsonObject) =>
-    serviceJson(config.roleplayServiceUrl, `/api/v1/sessions/${encodeURIComponent(sessionId)}/video/upload-url`, { body: payload }),
-  markVideoUploaded: (sessionId: string, payload: JsonObject) =>
-    serviceJson(config.roleplayServiceUrl, `/api/v1/sessions/${encodeURIComponent(sessionId)}/video/uploaded`, { body: payload }),
+  createVideoUploadUrl: (sessionId: string, payload?: JsonObject) =>
+    serviceJson(config.roleplayServiceUrl, `/api/v1/sessions/${encodeURIComponent(sessionId)}/video/upload-url`, {
+      method: "POST",
+      ...(payload === undefined ? {} : { body: payload }),
+    }),
+  markVideoUploaded: (sessionId: string, payload?: JsonObject) =>
+    serviceJson(config.roleplayServiceUrl, `/api/v1/sessions/${encodeURIComponent(sessionId)}/video/uploaded`, {
+      method: "POST",
+      ...(payload === undefined ? {} : { body: payload }),
+    }),
 };
 
 export const resumeService = {

src/services/service-agents.ts

@@ -1,5 +1,6 @@
 import { config } from "../config.js";
 import { createHash } from "node:crypto";
+import { buildServiceSessionPath } from "./service-registry.js";
 
 // Lightweight agent reference (works with both old AgentProfile and new SubAgentModule).
 export type ServiceAgentRef = {
@@ -28,32 +29,17 @@ export function buildServiceSessionUrl(
   detail: Record<string, unknown> | undefined,
   goal?: string,
 ): string | undefined {
-  const base = config.workflowsDashboardUrl.replace(/\/$/, "");
-  const sessionId = detail?.session_id ?? detail?.sessionId;
-  const params = new URLSearchParams();
-  if (sessionId && typeof sessionId === "string") params.set("session_id", sessionId);
-  if (goal) params.set("goal", goal);
-
-  if (service === "interview-service") {
-    if (!sessionId || typeof sessionId !== "string") return undefined;
-    params.set("role", String(detail?.target_role ?? goal ?? "Interview practice"));
-    params.set("type", String(detail?.interview_type ?? "behavioral"));
-    return `${base}/v2/service-sessions/interview?${params.toString()}`;
+  if (
+    service !== "interview-service" &&
+    service !== "roleplay-service" &&
+    service !== "resume-service"
+  ) {
+    return undefined;
   }
 
-  if (service === "roleplay-service") {
-    if (!sessionId || typeof sessionId !== "string") return undefined;
-    params.set("role", String(detail?.target_role ?? goal ?? "Roleplay practice"));
-    params.set("type", String(detail?.roleplay_type ?? "custom"));
-    return `${base}/v2/service-sessions/roleplay?${params.toString()}`;
-  }
-
-  if (service === "resume-service") {
-    if (goal) params.set("role", goal);
-    return `${base}/v2/service-sessions/resume${params.size ? `?${params.toString()}` : ""}`;
-  }
-
-  return undefined;
+  const path = buildServiceSessionPath(service, detail, goal);
+  if (!path) return undefined;
+  return `${config.workflowsDashboardUrl.replace(/\/$/, "")}${path}`;
 }
 
 function stableUuid(input: string): string {
@@ -129,7 +115,7 @@ async function runInterviewService(ctx: ServiceAgentContext): Promise<ServiceAge
   );
   return {
     status: "ok",
-    summary: `Interview Agent created interview session ${detail.session_id ?? "(pending id)"} for ${ctx.goal}.`,
+    summary: `Mock Interview created interview session ${detail.session_id ?? "(pending id)"} for ${ctx.goal}.`,
     detail: {
       ...detail,
       target_role: payload.context.target_role,
@@ -173,7 +159,7 @@ async function runRoleplayService(ctx: ServiceAgentContext): Promise<ServiceAgen
   );
   return {
     status: "ok",
-    summary: `Roleplay Agent created roleplay session ${detail.session_id ?? "(pending id)"} for ${ctx.goal}.`,
+    summary: `Mock Roleplay created roleplay session ${detail.session_id ?? "(pending id)"} for ${ctx.goal}.`,
     detail: {
       ...detail,
       target_role: payload.metadata.target_role,
@@ -256,7 +242,7 @@ async function runQScoreService(ctx: ServiceAgentContext): Promise<ServiceAgentR
     );
     return {
       status: "ok",
-      summary: `Q Score Agent estimated Q-Score ~${avgSignalScore} (service compute unavailable: formula store may not be seeded). Based on ${signals.length} signals.`,
+      summary: `Q Score estimated Q Score ~${avgSignalScore} (service compute unavailable: formula store may not be seeded). Based on ${signals.length} signals.`,
       detail: {
         ingest,
         estimated_q_score: avgSignalScore,
@@ -269,12 +255,12 @@ async function runQScoreService(ctx: ServiceAgentContext): Promise<ServiceAgentR
 
   return {
     status: "ok",
-    summary: `Q Score Agent computed Q-Score ${compute.q_score ?? "(unknown)"} for ${ctx.goal}.`,
+    summary: `Q Score computed Q Score ${compute.q_score ?? "(unknown)"} for ${ctx.goal}.`,
     detail: { ingest, compute, qscore_user_id: qscoreUserId },
   };
 }
 
-// ── Resume Agent (resume-builder service from growqr-app) ──
+// ── Resume Building (resume-builder service from growqr-app) ──
 
 async function runResumeAnalyze(ctx: ServiceAgentContext): Promise<ServiceAgentResult> {
   // Probe resume state for the user
@@ -289,8 +275,8 @@ async function runResumeAnalyze(ctx: ServiceAgentContext): Promise<ServiceAgentR
     return {
       status: "ok",
       summary: hasResume
-        ? `Resume Agent found ${detail.resume_count} resume(s) at ${completeness}% completeness. Current role: ${detail.current_role ?? "unknown"}.`
-        : "No existing resume found. Resume Agent is ready to build one from scratch.",
+        ? `Resume Building found ${detail.resume_count} resume(s) at ${completeness}% completeness. Current role: ${detail.current_role ?? "unknown"}.`
+        : "No existing resume found. Resume Building is ready to build one from scratch.",
       detail: {
         resume_count: detail.resume_count,
         completeness,
@@ -302,7 +288,7 @@ async function runResumeAnalyze(ctx: ServiceAgentContext): Promise<ServiceAgentR
   } catch (err) {
     return {
       status: "unavailable",
-      summary: `Resume Agent unavailable: ${err instanceof Error ? err.message : String(err)}`,
+      summary: `Resume Building unavailable: ${err instanceof Error ? err.message : String(err)}`,
     };
   }
 }
@@ -317,7 +303,7 @@ async function runResumeTailor(ctx: ServiceAgentContext): Promise<ServiceAgentRe
     // Return summary with optimization guidance
     return {
       status: "ok",
-      summary: `Resume Agent analyzed your profile for the role "${ctx.goal}". Skills detected: ${(stateResult.detail as any)?.skills?.slice(0, 5).join(", ") ?? "none"}. Resume ready for optimization.`,
+      summary: `Resume Building analyzed your profile for the role "${ctx.goal}". Skills detected: ${(stateResult.detail as any)?.skills?.slice(0, 5).join(", ") ?? "none"}. Resume ready for optimization.`,
       detail: {
         ...(stateResult.detail as Record<string, unknown> ?? {}),
         goal: ctx.goal,
@@ -382,11 +368,11 @@ export async function runServiceAgentProbe(
       case "interview-service":
         return ctx
           ? await runInterviewService(ctx)
-          : healthCheck(config.interviewServiceUrl, "Interview Agent / interview-service");
+          : healthCheck(config.interviewServiceUrl, "Mock Interview / interview-service");
       case "roleplay-service":
         return ctx
           ? await runRoleplayService(ctx)
-          : healthCheck(config.roleplayServiceUrl, "Roleplay Agent / roleplay-service");
+          : healthCheck(config.roleplayServiceUrl, "Mock Roleplay / roleplay-service");
       case "qscore-service":
         return ctx
           ? await runQScoreService(ctx)
@@ -394,7 +380,7 @@ export async function runServiceAgentProbe(
       case "resume-service":
         return ctx
           ? await runResumeTailor(ctx)
-          : healthCheck(config.resumeServiceUrl, "Resume Agent / resume-service");
+          : healthCheck(config.resumeServiceUrl, "Resume Building / resume-service");
       case "matchmaking-service":
         return ctx
           ? await runMatchmaking(ctx)

src/services/service-registry.ts

@@ -0,0 +1,195 @@
+import type { CuratorServiceId, CuratorTask } from "../v1/curator/curator-types.js";
+
+type QueryValue = string | number | undefined | null;
+
+type MissionServiceId = Extract<CuratorServiceId, "interview-service" | "roleplay-service" | "resume-service">;
+
+type MissionRouteInput = {
+  serviceId: MissionServiceId;
+  missionInstanceId: string;
+  missionId: string;
+  stageId?: string;
+  goal?: string;
+};
+
+type CuratorRouteInput = {
+  serviceId?: CuratorServiceId;
+  missionInstanceId?: string;
+  missionId?: string;
+  stageId?: string;
+  taskId?: string;
+  targetRole?: string;
+  durationMinutes?: number;
+  difficulty?: string;
+  personaId?: string;
+  requestedMode?: string;
+  roleplayBrief?: string;
+};
+
+function appendQuery(
+  pathname: string,
+  params: Record<string, QueryValue>,
+) {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined || value === null || value === "") continue;
+    search.set(key, String(value));
+  }
+  const query = search.toString();
+  return query ? `${pathname}?${query}` : pathname;
+}
+
+function getString(value: unknown) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function getSessionId(detail?: Record<string, unknown>) {
+  return getString(detail?.session_id ?? detail?.sessionId ?? detail?.id);
+}
+
+export function buildServiceSessionPath(
+  serviceId: MissionServiceId,
+  detail?: Record<string, unknown>,
+  goal?: string,
+) {
+  const sessionId = getSessionId(detail);
+
+  if (serviceId === "interview-service") {
+    if (!sessionId) return undefined;
+    return appendQuery("/v2/service-sessions/interview", {
+      session_id: sessionId,
+      goal,
+      role: getString(detail?.target_role) ?? goal ?? "Interview practice",
+      type: getString(detail?.interview_type) ?? "behavioral",
+    });
+  }
+
+  if (serviceId === "roleplay-service") {
+    if (!sessionId) return undefined;
+    return appendQuery("/v2/service-sessions/roleplay", {
+      session_id: sessionId,
+      goal,
+      role: getString(detail?.target_role) ?? goal ?? "Roleplay practice",
+      type: getString(detail?.roleplay_type) ?? "custom",
+    });
+  }
+
+  return appendQuery("/v2/service-sessions/resume", {
+    goal,
+    role: goal,
+  });
+}
+
+export function buildMissionServiceRoute(input: MissionRouteInput) {
+  const baseParams = {
+    source: "mission",
+    missionInstanceId: input.missionInstanceId,
+    missionId: input.missionId,
+    stageId: input.stageId,
+    goal: input.goal,
+  };
+
+  if (input.serviceId === "interview-service") {
+    return appendQuery("/agents/interview/setup", baseParams);
+  }
+
+  if (input.serviceId === "roleplay-service") {
+    return appendQuery("/agents/roleplay/setup", baseParams);
+  }
+
+  return appendQuery("/agents/resume", baseParams);
+}
+
+function curatorBaseParams(input: CuratorRouteInput) {
+  return {
+    source: "curator-v1",
+    missionInstanceId: input.missionInstanceId,
+    missionId: input.missionId,
+    stageId: input.stageId,
+    curatorTaskId: input.taskId,
+  };
+}
+
+export function buildCuratorServiceRoute(input: CuratorRouteInput) {
+  if (input.serviceId === "interview-service") {
+    return appendQuery("/agents/interview/preview", {
+      ...curatorBaseParams(input),
+      role: input.targetRole?.trim() || "Product Manager",
+      type: "behavioral",
+      persona: input.personaId ?? "payal",
+      duration: input.durationMinutes ?? 5,
+      difficulty: input.difficulty ?? "medium",
+      media: input.requestedMode ?? "video",
+    });
+  }
+
+  if (input.serviceId === "roleplay-service") {
+    return appendQuery("/agents/roleplay/builder", {
+      ...curatorBaseParams(input),
+      role: input.targetRole?.trim() || "Professional",
+      persona: input.personaId ?? "emma",
+      duration: input.durationMinutes ?? 5,
+      mode: input.requestedMode ?? "video",
+      brief: input.roleplayBrief,
+    });
+  }
+
+  if (input.serviceId === "resume-service") {
+    return appendQuery("/agents/resume", curatorBaseParams(input));
+  }
+  if (input.serviceId === "qscore-service") {
+    return appendQuery("/analytics", curatorBaseParams(input));
+  }
+  if (input.serviceId === "social-branding-service") {
+    return appendQuery("/social", curatorBaseParams(input));
+  }
+  if (input.serviceId === "matchmaking-service") {
+    return appendQuery("/pathways", curatorBaseParams(input));
+  }
+
+  return input.missionInstanceId
+    ? appendQuery("/missions/active", { missionInstanceId: input.missionInstanceId })
+    : "/missions/active";
+}
+
+export function getServiceDisplayName(serviceId?: CuratorServiceId, fallback = "Mission planner") {
+  if (serviceId === "interview-service") return "Interview service";
+  if (serviceId === "roleplay-service") return "Roleplay service";
+  if (serviceId === "resume-service") return "Resume service";
+  if (serviceId === "qscore-service") return "Q Score service";
+  if (serviceId === "social-branding-service") return "Social branding service";
+  if (serviceId === "matchmaking-service") return "Pathways service";
+  return fallback;
+}
+
+export function getServiceToolName(serviceId?: CuratorServiceId) {
+  if (serviceId === "interview-service") return "prepare_interview_preview";
+  if (serviceId === "roleplay-service") return "prepare_roleplay_preview";
+  if (serviceId === "resume-service") return "prepare_resume_upload";
+  if (serviceId === "qscore-service") return "prepare_qscore_review";
+  return "prepare_mission_step";
+}
+
+export function getServiceCompletionEvents(serviceId?: CuratorServiceId) {
+  if (serviceId === "interview-service") {
+    return ["interview.configured", "interview.review_completed", "interview.completed"];
+  }
+  if (serviceId === "roleplay-service") {
+    return ["roleplay.configured", "roleplay.review_completed", "roleplay.completed"];
+  }
+  if (serviceId === "resume-service") {
+    return ["resume.analysis_completed", "resume.parsed", "resume.updated"];
+  }
+  if (serviceId === "qscore-service") {
+    return ["qscore.updated", "qscore.signal_projected"];
+  }
+  return ["curator.task.completed"];
+}
+
+export function getServiceActionLabel(task: CuratorTask) {
+  if (task.serviceId === "interview-service") return "Open interview preview";
+  if (task.serviceId === "roleplay-service") return "Open roleplay preview";
+  if (task.serviceId === "resume-service") return "Open resume workspace";
+  if (task.serviceId === "qscore-service") return "Review Q Score";
+  return task.cta || "Open";
+}

src/v1/analytics/README.md

@@ -0,0 +1,10 @@
+# V1 Analytics
+
+V1 Analytics reuses the existing Analytics Actor for platform, Q-score, and activity reads.
+
+The added responsibility here is the nightly improvement loop:
+
+1. Read Grow events, service events, Q-score signals, and conversation summaries.
+2. Generate validated improvement signal objects with the Vercel AI SDK.
+3. Apply those signals to the V1 Curator as events.
+4. The Curator uses them on the next day when shaping tasks and nudges.

src/v1/analytics/analytics-actor.ts

@@ -0,0 +1,136 @@
+import { generateText, tool } from "ai";
+import { z } from "zod";
+import { desc, eq, gte } from "drizzle-orm";
+import { createClient, type Client } from "rivetkit/client";
+import { config } from "../../config.js";
+import type { Registry } from "../../actors/registry.js";
+import { getConversationModel } from "../../actors/conversation/agent.js";
+import { db } from "../../db/client.js";
+import { growConversationMessages, growEvents } from "../../db/schema.js";
+import { curatorActor } from "../curator/curator-actor.js";
+import { curatorImprovementSignalSchema } from "../curator/curator-types.js";
+
+let _client: Client<Registry> | null = null;
+function getClient(): Client<Registry> {
+  return (_client ??= createClient<Registry>(config.rivetClientEndpoint));
+}
+
+const signalsSchema = z.object({
+  signals: z.array(curatorImprovementSignalSchema.omit({ userId: true, date: true }).extend({
+    id: z.string(),
+  })).max(5),
+});
+
+function parseJsonObject(text: string) {
+  const cleaned = text.trim().replace(/^```(?:json)?/i, "").replace(/```$/i, "").trim();
+  try {
+    return JSON.parse(cleaned);
+  } catch {
+    const start = cleaned.indexOf("{");
+    const end = cleaned.lastIndexOf("}");
+    if (start === -1 || end === -1 || end <= start) throw new Error("analytics_actor_invalid_json");
+    return JSON.parse(cleaned.slice(start, end + 1));
+  }
+}
+
+export const analyticsTools = {
+  read_platform_events: tool({
+    description: "Read latest platform events.",
+    inputSchema: z.object({ limit: z.number().int().min(1).max(100).default(50) }),
+    execute: async ({ limit }) => db.select().from(growEvents).orderBy(desc(growEvents.occurredAt)).limit(limit),
+  }),
+  read_user_service_events: tool({
+    description: "Read latest service events for a user.",
+    inputSchema: z.object({ userId: z.string(), limit: z.number().int().min(1).max(100).default(50) }),
+    execute: async ({ userId, limit }) => db.select().from(growEvents).where(eq(growEvents.userId, userId)).orderBy(desc(growEvents.occurredAt)).limit(limit),
+  }),
+  read_conversation_summaries: tool({
+    description: "Read latest conversation messages for a user.",
+    inputSchema: z.object({ userId: z.string(), limit: z.number().int().min(1).max(100).default(30) }),
+    execute: async ({ userId, limit }) => db.select().from(growConversationMessages).where(eq(growConversationMessages.userId, userId)).orderBy(desc(growConversationMessages.createdAt)).limit(limit),
+  }),
+  generate_improvement_signals: tool({
+    description: "Generate curator improvement signals for a user.",
+    inputSchema: z.object({ userId: z.string(), date: z.string() }),
+    execute: async ({ userId, date }) => v1AnalyticsActor.generateImprovementSignals({ userId, date }),
+  }),
+  apply_improvement_to_curator: tool({
+    description: "Apply generated improvement signals to the curator.",
+    inputSchema: z.object({ userId: z.string(), date: z.string(), signals: z.array(curatorImprovementSignalSchema) }),
+    execute: async ({ userId, date, signals }) => curatorActor.applyImprovementSignals({ userId, date, signals }),
+  }),
+};
+
+export const v1AnalyticsActor = {
+  async getPlatform() {
+    return getClient().analyticsActor.getOrCreate(["platform"]).getPlatform();
+  },
+
+  async getUserQscore(input: { userId: string }) {
+    return getClient().analyticsActor.getOrCreate(["user", input.userId]).getUserQscore(input);
+  },
+
+  async getUserActivity(input: { userId: string }) {
+    return getClient().analyticsActor.getOrCreate(["user", input.userId]).getUserActivity(input);
+  },
+
+  async generateImprovementSignals(input: { userId: string; date: string }) {
+    const events = await db.select().from(growEvents).where(eq(growEvents.userId, input.userId)).orderBy(desc(growEvents.occurredAt)).limit(80);
+    const messages = await db.select().from(growConversationMessages).where(eq(growConversationMessages.userId, input.userId)).orderBy(desc(growConversationMessages.createdAt)).limit(40);
+    try {
+      const result = await generateText({
+        model: getConversationModel(),
+        system: [
+          "You are the GrowQR V1 Analytics Actor. Generate small overnight improvement signals for the Curator.",
+          "Return JSON only. Shape: {\"signals\": [...]}. Do not use markdown.",
+          "Use ASCII punctuation.",
+        ].join("\n"),
+        prompt: JSON.stringify({ date: input.date, events, messages }).slice(0, 20000),
+      });
+      const parsed = signalsSchema.parse(parseJsonObject(result.text));
+      return parsed.signals.map((signal) => curatorImprovementSignalSchema.parse({ ...signal, userId: input.userId, date: input.date }));
+    } catch {
+      return [curatorImprovementSignalSchema.parse({
+        id: `improvement:${input.userId}:${input.date}:streak`,
+        userId: input.userId,
+        date: input.date,
+        priority: 50,
+        reason: "Keep service usage meaningful and preserve streak momentum.",
+        nudgeText: "Pick one task that opens a real service today.",
+        status: "created",
+      })];
+    }
+  },
+
+  async applyImprovementSignals(input: { userId: string; date: string; signals: z.infer<typeof curatorImprovementSignalSchema>[] }) {
+    return curatorActor.applyImprovementSignals(input);
+  },
+
+  async runNightly(input: { date: string; userId?: string }) {
+    const userRows = input.userId
+      ? [{ id: input.userId }]
+      : await db
+          .selectDistinct({ id: growEvents.userId })
+          .from(growEvents)
+          .where(gte(growEvents.occurredAt, new Date(Date.now() - 7 * 86400000)))
+          .limit(200);
+    let improvementSignalsCreated = 0;
+    for (const user of userRows) {
+      if (!user.id) continue;
+      const signals = await this.generateImprovementSignals({ userId: user.id, date: input.date });
+      improvementSignalsCreated += signals.length;
+      await this.applyImprovementSignals({ userId: user.id, date: input.date, signals });
+    }
+    return { date: input.date, usersProcessed: userRows.length, improvementSignalsCreated };
+  },
+
+  async explain(input: { userId: string; question: string }) {
+    const answer = await generateText({
+      model: getConversationModel(),
+      system: "You are the GrowQR V1 Analytics Actor. Explain analytics and Q-score movement concisely.",
+      prompt: input.question,
+      tools: analyticsTools,
+    });
+    return { answer: answer.text };
+  },
+};

src/v1/analytics/analytics-routes.ts

@@ -0,0 +1,36 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { requireUser, type AuthContext } from "../../auth/clerk.js";
+import { v1AnalyticsActor } from "./analytics-actor.js";
+
+export function v1AnalyticsRoutes() {
+  const app = new Hono<AuthContext>();
+  app.use("*", requireUser);
+
+  app.get("/platform", async (c) => c.json(await v1AnalyticsActor.getPlatform()));
+
+  app.get("/user/qscore", async (c) => {
+    const userId = c.get("userId");
+    return c.json(await v1AnalyticsActor.getUserQscore({ userId }));
+  });
+
+  app.get("/user/activity", async (c) => {
+    const userId = c.get("userId");
+    return c.json(await v1AnalyticsActor.getUserActivity({ userId }));
+  });
+
+  app.post("/nightly/run", async (c) => {
+    const userId = c.get("userId");
+    const body = z.object({
+      date: z.string().optional(),
+      userId: z.string().optional(),
+      runForAll: z.boolean().optional(),
+    }).parse(await c.req.json().catch(() => ({})));
+    return c.json(await v1AnalyticsActor.runNightly({
+      date: body.date ?? new Date().toISOString().slice(0, 10),
+      userId: body.runForAll ? undefined : (body.userId ?? userId),
+    }));
+  });
+
+  return app;
+}

src/v1/curator/README.md

@@ -0,0 +1,10 @@
+# V1 Curator
+
+V1 replaces the old Daily Mission path with a single Curator layer.
+
+- Curator owns the 30 day plan JSON, today's tasks, streak state, service direction, and task status.
+- Conversation Actor still owns chat persistence and long lived conversations.
+- Analytics Actor owns the nightly loop and writes improvement signals back into Curator events.
+- Services still own their workflows. Curator tools prepare handoffs and routes.
+
+Completion is event gated. A checkbox or chat message cannot complete a task unless a matching service or platform event exists.

src/v1/curator/curator-actor.ts

@@ -0,0 +1,104 @@
+import { buildCuratorPlan, buildCuratorSprint, buildCuratorStreak, buildCuratorTasks, todayIsoDate } from "./curator-store.js";
+import { curatorPlanSchema, curatorSprintResponseSchema, type CuratorImprovementSignal } from "./curator-types.js";
+import { emitCuratorEvent } from "./curator-events.js";
+import { runCuratorChat } from "./curator-agent.js";
+import { prepareHandoffForTask } from "./curator-tools.js";
+
+export const curatorActor = {
+  async generatePlanRange(input: { userId: string; startDate?: string; endDate?: string; goals?: string[]; forceRegenerate?: boolean }) {
+    const startDate = input.startDate ?? todayIsoDate();
+    const endDate = input.endDate ?? startDate;
+    const plan = curatorPlanSchema.parse(await buildCuratorPlan(input.userId, { startDate, endDate, goals: input.goals }));
+    await emitCuratorEvent({ userId: input.userId, type: "curator.plan.generated", payload: { startDate, endDate, goals: input.goals ?? [] } });
+    return { plan };
+  },
+
+  async getPlan(input: { userId: string; startDate?: string; endDate?: string }) {
+    return this.generatePlanRange(input);
+  },
+
+  async getToday(input: { userId: string; date?: string }) {
+    const date = input.date ?? todayIsoDate();
+    const sprint = curatorSprintResponseSchema.parse(await buildCuratorSprint(input.userId, date));
+    await emitCuratorEvent({ userId: input.userId, type: "curator.day.opened", payload: { date } });
+    return {
+      date,
+      plan: sprint.plan,
+      tasks: sprint.todayTasks,
+      streak: sprint.streak,
+      completedCount: sprint.completedCount,
+      totalCount: sprint.totalCount,
+      sprint,
+      source: "curator-v1" as const,
+    };
+  },
+
+  async getSprint(input: { userId: string; date?: string }) {
+    const date = input.date ?? todayIsoDate();
+    const sprint = curatorSprintResponseSchema.parse(await buildCuratorSprint(input.userId, date));
+    await emitCuratorEvent({ userId: input.userId, type: "curator.day.opened", payload: { date, sprintId: sprint.sprintId } });
+    return sprint;
+  },
+
+  async chat(input: { userId: string; conversationId?: string; date?: string; taskId?: string; subtaskIndex?: number; subtask?: string; messages: Array<{ role: "user" | "assistant"; content: string }> }) {
+    return runCuratorChat(input);
+  },
+
+  async startTask(input: { userId: string; taskId: string; date?: string }) {
+    const date = input.date ?? todayIsoDate();
+    const task = (await buildCuratorTasks(input.userId, date)).find((item) => item.id === input.taskId);
+    if (!task) throw new Error("curator_task_not_found");
+    const event = await emitCuratorEvent({
+      userId: input.userId,
+      type: "curator.task.started",
+      mission: { missionId: task.missionId, missionInstanceId: task.missionInstanceId, stageId: task.stageId },
+      payload: { taskId: task.id, date },
+    });
+    return { task: { ...task, status: "started" as const }, eventId: event.id };
+  },
+
+  async prepareTaskHandoff(input: { userId: string; taskId: string; date?: string }) {
+    const date = input.date ?? todayIsoDate();
+    const task = (await buildCuratorTasks(input.userId, date)).find((item) => item.id === input.taskId);
+    if (!task) throw new Error("curator_task_not_found");
+    if (task.serviceId) return prepareHandoffForTask(input.userId, task, task.serviceId);
+    throw new Error("curator_task_has_no_handoff");
+  },
+
+  async completeTask(input: { userId: string; taskId: string; date?: string; reason?: string }) {
+    const date = input.date ?? todayIsoDate();
+    const task = (await buildCuratorTasks(input.userId, date)).find((item) => item.id === input.taskId);
+    if (!task) throw new Error("curator_task_not_found");
+    const reason = input.reason ?? "subtasks_completed";
+    const allowDirectServiceCompletion = task.serviceId === "qscore-service" && reason === "qscore_review_opened";
+    if (task.serviceId && !allowDirectServiceCompletion) {
+      throw new Error("curator_service_task_requires_service_event");
+    }
+    const event = await emitCuratorEvent({
+      userId: input.userId,
+      type: "curator.task.completed",
+      mission: { missionId: task.missionId, missionInstanceId: task.missionInstanceId, stageId: task.stageId },
+      payload: { taskId: task.id, date, reason },
+    });
+    return { task: { ...task, status: "completed" as const }, eventId: event.id };
+  },
+
+  async recordServiceImpact(input: { userId: string; eventId: string }) {
+    const streak = await buildCuratorStreak(input.userId);
+    const sprint = await buildCuratorSprint(input.userId, todayIsoDate());
+    return { matched: true, completedTasks: sprint.todayTasks, streak, sprint };
+  },
+
+  async applyImprovementSignals(input: { userId: string; date: string; signals: CuratorImprovementSignal[] }) {
+    for (const signal of input.signals) {
+      await emitCuratorEvent({ userId: input.userId, type: "curator.improvement_signal.applied", payload: { signal } });
+    }
+    const sprint = await buildCuratorSprint(input.userId, input.date);
+    return { applied: input.signals.length, plan: sprint.plan, sprint };
+  },
+
+  async getState(input: { userId: string }) {
+    const sprint = await buildCuratorSprint(input.userId, todayIsoDate());
+    return { tasks: sprint.todayTasks, streak: sprint.streak, sprint };
+  },
+};

src/v1/curator/curator-agent.ts

@@ -0,0 +1,684 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { generateText } from "ai";
+import { z } from "zod";
+import { and, desc, eq } from "drizzle-orm";
+import { db } from "../../db/client.js";
+import { growEvents } from "../../db/schema.js";
+import { addMessagePg, createConversationPg, ensureCuratorTaskConversationPg, getConversationMetadataPg, listMessagesPg } from "../../grow/persistence.js";
+import { generateConversationResponse, getConversationModel } from "../../actors/conversation/agent.js";
+import { buildCuratorTasks, todayIsoDate } from "./curator-store.js";
+import { emitCuratorEvent } from "./curator-events.js";
+import type { CuratorChatResponse, CuratorSubtaskStatusUpdate } from "./curator-types.js";
+import { prepareHandoffForTask } from "./curator-tools.js";
+import { fallbackCuratorRole, resolveCuratorTargetRole } from "./curator-user-context.js";
+
+const CURATOR_STREAK_CHAT_PROMPT = path.resolve(process.cwd(), "prompts/curator/streak-chat.md");
+
+const FALLBACK_CURATOR_STREAK_CHAT_PROMPT = [
+  "You are the GrowQR V1 Curator in a daily or weekly streak chat modal.",
+  "Ask at most one clarifying question before a service preview handoff is ready.",
+  "If no target role is known for interview or roleplay, ask exactly: What role are you targeting?",
+  "If the target role is known, do not ask again. Proceed to a short summary and let the dashboard show the CTA.",
+  "Never include internal URLs, setup routes, API paths, JSON, or tool names in chat text.",
+  "Interview defaults: type=behavioral, difficulty=medium, duration=5.",
+  "Use ASCII punctuation only.",
+].join("\n");
+
+async function loadCuratorStreakPrompt() {
+  return readFile(CURATOR_STREAK_CHAT_PROMPT, "utf8").catch(() => FALLBACK_CURATOR_STREAK_CHAT_PROMPT);
+}
+
+const chatExtractSchema = z.object({
+  summary: z.string(),
+  userGoal: z.string().optional(),
+  serviceIntent: z.string().optional(),
+  shouldPrepareHandoff: z.boolean().default(false),
+});
+
+const subtaskStatusUpdateSchema = z.object({
+  status: z.enum(["needs_more_context", "ready_to_capture", "handoff_ready"]),
+  summary: z.string().min(1).max(280),
+  confidence: z.number().min(0).max(1).default(0.5),
+  nextMissingInfo: z.string().max(180).optional(),
+});
+
+function parseJsonObject(text: string) {
+  const trimmed = text.trim();
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const match = trimmed.match(/\{[\s\S]*\}/);
+    if (!match) throw new Error("model_did_not_return_json");
+    return JSON.parse(match[0]);
+  }
+}
+
+function buildId(prefix: string) {
+  return `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function sanitize(text: string) {
+  const withoutControlLines = text
+    .split(/\r?\n/)
+    .filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return true;
+      if (/^(date|curator task id|focused subtask|curator task title|curator task context|curator task subtasks|curator service|expected completion events|captured task memory|task title|task service|task context|all task subtasks|visible history):/i.test(trimmed)) return false;
+      if (/setup route|mission instance id|curator task id|access the setup at/i.test(trimmed)) return false;
+      if (/\/agents\/(interview|roleplay|resume|qscore)|\/analytics\?|\/social\?|\/pathways\?/i.test(trimmed)) return false;
+      if (/^```/.test(trimmed)) return false;
+      return true;
+    })
+    .join("\n")
+    .trim();
+  const withoutJsonEnvelope = withoutControlLines.replace(/^\s*\{[\s\S]*"reply"\s*:\s*"([^"]+)"[\s\S]*\}\s*$/i, "$1");
+  const withoutRoutes = withoutJsonEnvelope
+    .replace(/\b(?:Interview|Roleplay|Resume|Q Score)?\s*setup route:\s*\/\S+/gi, "")
+    .replace(/\/agents\/(?:interview|roleplay|resume|qscore)\/?\S*/gi, "")
+    .replace(/\/analytics\?\S*/gi, "")
+    .replace(/\/social\?\S*/gi, "")
+    .replace(/\/pathways\?\S*/gi, "");
+  return withoutRoutes
+    .replace(/[\u2013\u2014]/g, "-")
+    .replace(/[\u2018\u2019]/g, "'")
+    .replace(/[\u201C\u201D]/g, '"')
+    .replace(/\u2026/g, "...")
+    .replace(/^\s*(Perfect|Great|Absolutely|Sure)[.!,:;-]*\s*/i, "")
+    .trim();
+}
+
+function pushField(lines: string[], label: string, value?: string | number | null) {
+  if (value === undefined || value === null) return;
+  const stringValue = String(value).trim();
+  if (!stringValue) return;
+  lines.push(`${label}: ${stringValue}`);
+}
+
+function pushList(lines: string[], label: string, values?: string[]) {
+  const cleanValues = values?.map((value) => value.trim()).filter(Boolean) ?? [];
+  if (cleanValues.length === 0) return;
+  lines.push(`${label}: ${cleanValues.join(" | ")}`);
+}
+
+type CuratorMessage = Awaited<ReturnType<typeof listMessagesPg>>[number];
+
+async function capturedSubtaskMemory(userId: string, taskId?: string) {
+  if (!taskId) return [];
+  const rows = await db
+    .select()
+    .from(growEvents)
+    .where(and(
+      eq(growEvents.userId, userId),
+      eq(growEvents.type, "curator.subtask.captured"),
+    ))
+    .orderBy(desc(growEvents.occurredAt))
+    .limit(80);
+
+  return rows
+    .map((row) => row.payload ?? {})
+    .filter((payload) => payload.taskId === taskId)
+    .map((payload) => ({
+      subtaskIndex: typeof payload.subtaskIndex === "number" ? payload.subtaskIndex : undefined,
+      subtask: typeof payload.subtask === "string" ? payload.subtask : undefined,
+      summary: typeof (payload.statusUpdate as any)?.summary === "string" ? (payload.statusUpdate as any).summary : undefined,
+    }))
+    .filter((item) => item.summary)
+    .reverse();
+}
+
+function visibleCuratorMessages(messages: CuratorMessage[]) {
+  const filtered = messages.filter((message) => {
+    const content = message.content.trim();
+    if (message.role === "user") {
+      if (/^start$/i.test(content)) return false;
+      if (/^i opened /i.test(content)) return false;
+      return true;
+    }
+    return !/what should i capture/i.test(content);
+  });
+  return filtered.filter((message, index) => {
+    const previous = filtered[index - 1];
+    return !previous || previous.role !== message.role || previous.content.trim() !== message.content.trim();
+  });
+}
+
+function usefulUserMessages(messages: CuratorMessage[]) {
+  return messages
+    .filter((message) => message.role === "user")
+    .map((message) => message.content.trim())
+    .filter((content) => content && !/^start$/i.test(content) && !content.toLowerCase().includes("i opened "));
+}
+
+function targetRoleState(messages: CuratorMessage[], latest: string) {
+  const userMessages = usefulUserMessages(messages);
+  const all = [...userMessages, latest.trim()].filter(Boolean);
+  const lowerAll = all.join("\n").toLowerCase();
+  const shortAnswers = all.filter((content) => content.length <= 80);
+  const targetRole = shortAnswers.find((content) => {
+    const lower = content.toLowerCase();
+    return /manager|engineer|designer|analyst|developer|product|marketing|sales|founder|consultant|operator|lead|head|director/.test(lower);
+  });
+  const currentBackground = all.find((content) => {
+    const lower = content.toLowerCase();
+    return lower.includes("currently") || lower.includes("right now") || lower.includes("i am ") || lower.includes("i'm ") || lower.includes("my background") || lower.includes("experience");
+  });
+  const constraints = all.find((content) => {
+    const lower = content.toLowerCase();
+    return lower.includes("month") || lower.includes("week") || lower.includes("salary") || lower.includes("remote") || lower.includes("location") || lower.includes("visa") || lower.includes("timeline");
+  });
+  return {
+    targetRole,
+    currentBackground,
+    constraints,
+    hasAskedCurrent: lowerAll.includes("current background") || lowerAll.includes("current role") || lowerAll.includes("where you are starting"),
+    hasAskedConstraints: lowerAll.includes("constraint") || lowerAll.includes("timeline"),
+  };
+}
+
+const CURATOR_PROMPT_FILE = path.resolve(process.cwd(), "prompts", "curator-v1.md");
+
+const DEFAULT_CURATOR_PROMPT = `You are currently speaking as the GrowQR V1 Curator through the Conversation Actor.
+Own 30 day direction, streak continuity, and service handoff decisions.
+Do not ask the same question twice.
+Use captured task memory and keep the user on the focused subtask.
+When the user has answered enough, summarize what was captured and stop.
+If more detail is needed, ask exactly one follow-up question.
+For service work, prepare preview-oriented handoffs once enough context exists.`;
+
+async function loadCuratorPromptTemplate() {
+  try {
+    return await readFile(CURATOR_PROMPT_FILE, "utf8");
+  } catch {
+    return DEFAULT_CURATOR_PROMPT;
+  }
+}
+
+async function curatorSystemAddendum(input: {
+  date: string;
+  taskId?: string;
+  subtaskIndex?: number;
+  subtask?: string;
+  task?: Awaited<ReturnType<typeof buildCuratorTasks>>[number];
+  taskMemory?: Array<{ subtaskIndex?: number; subtask?: string; summary?: string }>;
+  promptText: string;
+  targetRole?: string;
+}) {
+  const template = await loadCuratorPromptTemplate();
+  const lines = [
+    input.promptText,
+    "",
+    ...template
+      .split(/\r?\n/)
+      .map((line) => line.trimEnd())
+      .filter(Boolean),
+  ];
+  pushField(lines, "Known target role", input.targetRole);
+  pushField(lines, "Date", input.date);
+  pushField(lines, "Curator task id", input.taskId);
+  pushField(lines, "Focused subtask index", Number.isInteger(input.subtaskIndex) ? input.subtaskIndex : undefined);
+  pushField(lines, "Focused subtask title", input.subtask);
+  pushField(lines, "Curator task title", input.task?.title);
+  pushField(lines, "Curator task context", input.task?.contextNarrative);
+  pushList(lines, "Curator task subtasks", input.task?.subtasks);
+  pushField(lines, "Curator service", input.task?.serviceName);
+  pushList(lines, "Expected completion events", input.task?.completionEvents);
+  const memory = input.taskMemory
+    ?.map((item) => {
+      if (!item.summary) return "";
+      const subtask = item.subtask?.trim() || "Subtask";
+      const index = Number.isInteger(item.subtaskIndex) ? `[${item.subtaskIndex}] ` : "";
+      return `${index}${subtask}: ${item.summary}`;
+    })
+    .filter(Boolean);
+  pushList(lines, "Captured task memory", memory);
+  return lines.join("\n");
+}
+
+function curatorTaskKey(taskId?: string, subtaskIndex?: number) {
+  if (!taskId) return undefined;
+  return `${taskId}:${subtaskIndex ?? "task"}`;
+}
+
+function firstTurnPrompt(input: {
+  subtask?: string;
+  task?: Awaited<ReturnType<typeof buildCuratorTasks>>[number];
+  targetRole?: string;
+}) {
+  return [
+    `The user opened this focused subtask: ${input.subtask ?? input.task?.title ?? "curator task"}.`,
+    "Generate the first live conversational question for this exact subtask.",
+    input.targetRole ? `Known target role: ${input.targetRole}. Do not ask for the role again.` : "If this is an interview or roleplay task and no target role is known, ask exactly: What role are you targeting?",
+    "Ask only one question. Do not use canned wording. Do not prepare any service handoff yet.",
+  ].join("\n");
+}
+
+function isExplicitHandoffRequest(text: string) {
+  const trimmed = text.trim();
+  if (/^start$/i.test(trimmed)) return false;
+  return /\b(start|open|launch|begin|set up|setup|create|generate|room|ready|go|give)\b/i.test(trimmed);
+}
+
+function shouldPrepareServiceHandoff(status: CuratorSubtaskStatusUpdate, task?: Awaited<ReturnType<typeof buildCuratorTasks>>[number]) {
+  if (!task?.serviceId) return false;
+  return status.status === "ready_to_capture" || status.status === "handoff_ready";
+}
+
+function isPreviewHandoffService(task?: Awaited<ReturnType<typeof buildCuratorTasks>>[number]) {
+  return task?.serviceId === "interview-service" || task?.serviceId === "roleplay-service";
+}
+
+function servicePreviewSummary(task: Awaited<ReturnType<typeof buildCuratorTasks>>[number], targetRole?: string) {
+  const role = fallbackCuratorRole(targetRole);
+  if (task.serviceId === "interview-service") {
+    return `Prepared a 5-minute behavioral interview preview for ${role}.`;
+  }
+  if (task.serviceId === "roleplay-service") {
+    return `Prepared a 5-minute roleplay preview for ${role}.`;
+  }
+  return `${task.serviceName} handoff is ready.`;
+}
+
+function fallbackCuratorReply(input: {
+  latest: string;
+  task?: Awaited<ReturnType<typeof buildCuratorTasks>>[number];
+  subtask?: string;
+  targetRole?: string;
+}) {
+  const latest = input.latest.trim();
+  const lowerTitle = input.task?.title.toLowerCase() ?? "";
+  const lowerSubtask = input.subtask?.toLowerCase() ?? "";
+  const role = fallbackCuratorRole(input.targetRole);
+
+  if ((input.task?.serviceId === "interview-service" || input.task?.serviceId === "roleplay-service") && !input.targetRole) {
+    return "What role are you targeting?";
+  }
+
+  if (/^start$/i.test(latest)) {
+    if (input.task?.serviceId === "qscore-service") {
+      return "Open your current Q Score and tell me which readiness signal looks weakest today.";
+    }
+    if (input.task?.serviceId === "resume-service") {
+      return "Upload your current resume or paste three recent wins so I can anchor this proof task.";
+    }
+    if (input.task?.serviceId === "interview-service" || input.task?.serviceId === "roleplay-service") {
+      return `I have your target role as ${role}. Say start when you want the preview opened.`;
+    }
+    if (lowerTitle.includes("role direction") || lowerSubtask.includes("role direction")) {
+      return "Which role family do you want this sprint to optimize toward?";
+    }
+    if (input.task?.taskType === "measurement") {
+      return "Open the current view and tell me the one gap or signal that stands out most.";
+    }
+    if (input.task?.taskType === "proof") {
+      return "Share the strongest proof you already have so we can build from something real.";
+    }
+    return "What is the single outcome you want from this task today?";
+  }
+
+  if (input.task?.serviceId === "interview-service" || input.task?.serviceId === "roleplay-service") {
+    if (isExplicitHandoffRequest(latest)) {
+      return servicePreviewSummary(input.task, input.targetRole);
+    }
+    return `Captured ${role} as the target role. Say start when you want the preview opened.`;
+  }
+
+  if (lowerTitle.includes("role direction") || lowerSubtask.includes("role direction")) {
+    return `Captured ${latest}. I will use that as the role direction for this sprint.`;
+  }
+
+  if (input.task?.serviceId === "resume-service") {
+    return "Captured. Open the resume flow when you are ready to turn this into proof.";
+  }
+
+  if (input.task?.serviceId === "qscore-service") {
+    return "Captured. Open the Q Score view and save the main readiness gap you want to work on.";
+  }
+
+  if (input.task?.taskType === "measurement") {
+    return "Captured the baseline signal for today.";
+  }
+
+  if (input.task?.taskType === "proof") {
+    return "Captured the proof point for today.";
+  }
+
+  if (input.task?.taskType === "practice") {
+    return "Captured the practice focus for today.";
+  }
+
+  return "Captured. We can use this to move the task forward.";
+}
+
+async function evaluateSubtaskStatus(input: {
+  task?: Awaited<ReturnType<typeof buildCuratorTasks>>[number];
+  subtask?: string;
+  subtaskIndex?: number;
+  latest: string;
+  reply: string;
+  history: CuratorMessage[];
+}): Promise<CuratorSubtaskStatusUpdate> {
+  if (!input.subtask || /^start$/i.test(input.latest.trim())) {
+    return { status: "needs_more_context", summary: "Subtask opened.", confidence: 0.2 };
+  }
+
+  try {
+    const result = await generateText({
+      model: getConversationModel(),
+      system: [
+        "You are the GrowQR V1 Curator Actor state evaluator.",
+        "Return JSON only. Do not wrap it in markdown.",
+        "Shape: {\"status\": \"needs_more_context\" | \"ready_to_capture\" | \"handoff_ready\", \"summary\": string, \"confidence\": number, \"nextMissingInfo\"?: string}.",
+        "Evaluate only the focused subtask. Ignore other missions, other subtasks, and later checklist items.",
+        "Use ready_to_capture only when the latest user answer directly satisfies the focused subtask.",
+        "Use needs_more_context if the assistant reply asks another question or if the answer is too vague for this exact subtask.",
+        "Use handoff_ready only when the focused subtask explicitly asks to open or preview a service and the service setup details are present.",
+        "Use handoff_ready when the user explicitly says to start, open, launch, set up, or begin the service and the necessary setup context is already present.",
+        "Never mark ready just because one message exists.",
+        "Use ASCII punctuation only.",
+      ].join("\n"),
+      prompt: (() => {
+        const lines: string[] = [];
+        pushField(lines, "Task title", input.task?.title);
+        pushField(lines, "Task service", input.task?.serviceName);
+        pushField(lines, "Focused subtask index", Number.isInteger(input.subtaskIndex) ? input.subtaskIndex : undefined);
+        pushField(lines, "Focused subtask", input.subtask);
+        pushField(lines, "Task context", input.task?.contextNarrative);
+        pushList(lines, "All task subtasks", input.task?.subtasks);
+        pushField(lines, "Latest user answer", input.latest);
+        pushField(lines, "Assistant reply", input.reply);
+        pushField(lines, "Visible history", input.history.map((message) => `${message.role}: ${message.content}`).join("\n"));
+        return lines.join("\n");
+      })(),
+    });
+    return subtaskStatusUpdateSchema.parse(parseJsonObject(result.text));
+  } catch (error) {
+    console.warn("curator status evaluation failed; keeping subtask open", {
+      taskId: input.task?.id,
+      subtaskIndex: input.subtaskIndex,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return { status: "needs_more_context", summary: "The curator needs one more answer before updating this subtask.", confidence: 0.1 };
+  }
+}
+
+async function ensureCuratorConversation(input: { userId: string; taskId?: string; date: string; subtaskIndex?: number; subtask?: string }) {
+  if (!input.taskId) return createConversationPg(input.userId, "V1 Curator chat");
+  const task = (await buildCuratorTasks(input.userId, input.date)).find((item) => item.id === input.taskId);
+  if (task) {
+    return ensureCuratorTaskConversationPg({
+      userId: input.userId,
+      curatorTaskId: task.id,
+      subtaskIndex: input.subtaskIndex,
+      subtask: input.subtask,
+      missionInstanceId: task.missionInstanceId,
+      missionId: task.missionId,
+      stageId: task.stageId,
+      title: input.subtask ?? task.title,
+    });
+  }
+  return createConversationPg(input.userId, "V1 Curator chat");
+}
+
+export async function runCuratorChat(input: {
+  userId: string;
+  conversationId?: string;
+  taskId?: string;
+  subtaskIndex?: number;
+  subtask?: string;
+  date?: string;
+  messages: Array<{ role: "user" | "assistant"; content: string }>;
+}): Promise<CuratorChatResponse> {
+  const date = input.date ?? todayIsoDate();
+  const expectedTaskKey = curatorTaskKey(input.taskId, input.subtaskIndex);
+  let conversation = input.conversationId ? { id: input.conversationId } : undefined;
+  if (conversation?.id && expectedTaskKey) {
+    const metadata = await getConversationMetadataPg(input.userId, conversation.id);
+    if (metadata?.curatorTaskKey !== expectedTaskKey) {
+      conversation = undefined;
+    }
+  }
+  conversation ??= await ensureCuratorConversation({
+    userId: input.userId,
+    taskId: input.taskId,
+    date,
+    subtaskIndex: input.subtaskIndex,
+    subtask: input.subtask,
+  });
+  const latest = [...input.messages].reverse().find((message) => message.role === "user")?.content?.trim() ?? "start";
+  const tasks = await buildCuratorTasks(input.userId, date);
+  const task = input.taskId ? tasks.find((item) => item.id === input.taskId) : undefined;
+  const taskMemory = await capturedSubtaskMemory(input.userId, input.taskId);
+  const promptText = await loadCuratorStreakPrompt();
+
+  await addMessagePg(input.userId, {
+    id: buildId("user"),
+    conversationId: conversation.id,
+    role: "user",
+    sender: "User",
+    content: latest,
+  });
+  const conversationHistory = visibleCuratorMessages(await listMessagesPg(input.userId, conversation.id));
+  const targetRole = await resolveCuratorTargetRole({
+    userId: input.userId,
+    task,
+    latest,
+    history: conversationHistory,
+  });
+
+  const isInitialOpen = /^start$/i.test(latest);
+  if (isInitialOpen && isPreviewHandoffService(task) && targetRole) {
+    const statusUpdate: CuratorSubtaskStatusUpdate = {
+      status: "handoff_ready",
+      summary: servicePreviewSummary(task!, targetRole),
+      confidence: 0.95,
+    };
+    const handoff = await prepareHandoffForTask(input.userId, task!, task!.serviceId, targetRole);
+    const reply = sanitize(statusUpdate.summary);
+
+    await emitCuratorEvent({
+      userId: input.userId,
+      type: "curator.subtask.captured",
+      mission: task ? { missionId: task.missionId, missionInstanceId: task.missionInstanceId, stageId: task.stageId } : undefined,
+      payload: {
+        taskId: input.taskId,
+        subtaskIndex: input.subtaskIndex,
+        subtask: input.subtask,
+        statusUpdate,
+      },
+    });
+
+    await addMessagePg(input.userId, {
+      id: buildId("assistant"),
+      conversationId: conversation.id,
+      role: "assistant",
+      sender: "V1 Curator",
+      content: reply,
+    });
+
+    return {
+      conversationId: conversation.id,
+      taskId: input.taskId,
+      reply,
+      messages: visibleCuratorMessages(await listMessagesPg(input.userId, conversation.id)),
+      statusUpdate,
+      handoff,
+    };
+  }
+
+  if (isInitialOpen && isPreviewHandoffService(task) && !targetRole) {
+    const statusUpdate: CuratorSubtaskStatusUpdate = {
+      status: "needs_more_context",
+      summary: "Target role needed before preparing the preview.",
+      confidence: 0.4,
+      nextMissingInfo: "target role",
+    };
+    const reply = "What role are you targeting?";
+
+    await addMessagePg(input.userId, {
+      id: buildId("assistant"),
+      conversationId: conversation.id,
+      role: "assistant",
+      sender: "V1 Curator",
+      content: reply,
+    });
+
+    return {
+      conversationId: conversation.id,
+      taskId: input.taskId,
+      reply,
+      messages: visibleCuratorMessages(await listMessagesPg(input.userId, conversation.id)),
+      statusUpdate,
+    };
+  }
+
+  let reply = "";
+  let usedFallbackReply = false;
+  try {
+    try {
+      const extract = await generateText({
+        model: getConversationModel(),
+        system: [
+          "Extract compact curator memory from the user's latest message.",
+          "Return JSON only: {\"summary\": string, \"userGoal\"?: string, \"serviceIntent\"?: string, \"shouldPrepareHandoff\": boolean}.",
+          "Use ASCII punctuation only.",
+        ].join("\n"),
+        prompt: (() => {
+          const lines: string[] = [];
+          pushField(lines, "Task", task?.title);
+          pushField(lines, "Subtask", input.subtask);
+          pushField(lines, "Service", task?.serviceName);
+          pushField(lines, "Message", latest);
+          return lines.join("\n");
+        })(),
+      });
+      const parsedExtract = chatExtractSchema.parse(parseJsonObject(extract.text));
+      await emitCuratorEvent({
+        userId: input.userId,
+        type: "curator.chat.context_extracted",
+        mission: task ? { missionId: task.missionId, missionInstanceId: task.missionInstanceId, stageId: task.stageId } : undefined,
+        payload: { taskId: input.taskId, extract: parsedExtract },
+      });
+    } catch (error) {
+      console.warn("curator memory extraction failed; continuing chat", {
+        taskId: input.taskId,
+        subtaskIndex: input.subtaskIndex,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+
+    const modelMessages = conversationHistory.map((message) => ({
+      role: message.role,
+      content: message.content,
+    }));
+    if (/^start$/i.test(latest) && modelMessages.length === 0) {
+      modelMessages.push({ role: "user", content: firstTurnPrompt({ subtask: input.subtask, task, targetRole }) });
+    }
+
+    const result = await generateConversationResponse(modelMessages, {
+      userId: input.userId,
+      conversationId: conversation.id,
+      missionInstanceId: task?.missionInstanceId,
+      missionId: task?.missionId,
+      stageId: task?.stageId,
+      source: "curator-v1",
+      systemAddendum: await curatorSystemAddendum({ date, taskId: input.taskId, subtaskIndex: input.subtaskIndex, subtask: input.subtask, task, taskMemory, promptText, targetRole }),
+    });
+    reply = sanitize(result.text);
+    if (/what should i capture next/i.test(reply) || !reply) {
+      throw new Error("curator_generation_failed");
+    }
+  } catch (error) {
+    console.warn("curator chat generation failed", {
+      taskId: input.taskId,
+      subtaskIndex: input.subtaskIndex,
+      subtask: input.subtask,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    reply = sanitize(fallbackCuratorReply({
+      latest,
+      task,
+      subtask: input.subtask,
+      targetRole,
+    }));
+    usedFallbackReply = true;
+  }
+
+  if (!reply) {
+    reply = sanitize(fallbackCuratorReply({
+      latest,
+      task,
+      subtask: input.subtask,
+      targetRole,
+    }));
+    usedFallbackReply = true;
+  }
+
+  let statusUpdate = await evaluateSubtaskStatus({
+    task,
+    subtask: input.subtask,
+    subtaskIndex: input.subtaskIndex,
+    latest,
+    reply,
+    history: conversationHistory,
+  });
+  if (task?.serviceId && (isExplicitHandoffRequest(latest) || statusUpdate.status === "ready_to_capture")) {
+    statusUpdate = {
+      status: "handoff_ready",
+      summary: servicePreviewSummary(task, targetRole),
+      confidence: Math.max(statusUpdate.confidence, 0.9),
+    };
+  }
+  if (usedFallbackReply && statusUpdate.status === "needs_more_context" && !statusUpdate.nextMissingInfo) {
+    statusUpdate = {
+      ...statusUpdate,
+      summary: reply,
+    };
+  }
+  if (isPreviewHandoffService(task) && !isInitialOpen && usefulUserMessages(conversationHistory).length >= 1) {
+    statusUpdate = {
+      status: "handoff_ready",
+      summary: servicePreviewSummary(task!, targetRole),
+      confidence: Math.max(statusUpdate.confidence, 0.9),
+    };
+  }
+
+  const handoff = shouldPrepareServiceHandoff(statusUpdate, task)
+    ? await prepareHandoffForTask(input.userId, task!, task!.serviceId, targetRole)
+    : undefined;
+
+  if (statusUpdate.status !== "needs_more_context") {
+    if (reply.includes("?") || handoff) {
+      reply = sanitize(statusUpdate.summary);
+    }
+
+    await emitCuratorEvent({
+      userId: input.userId,
+      type: "curator.subtask.captured",
+      mission: task ? { missionId: task.missionId, missionInstanceId: task.missionInstanceId, stageId: task.stageId } : undefined,
+      payload: {
+        taskId: input.taskId,
+        subtaskIndex: input.subtaskIndex,
+        subtask: input.subtask,
+        statusUpdate,
+      },
+    });
+  }
+
+  await addMessagePg(input.userId, {
+    id: buildId("assistant"),
+    conversationId: conversation.id,
+    role: "assistant",
+    sender: "V1 Curator",
+    content: reply,
+  });
+
+  return {
+    conversationId: conversation.id,
+    taskId: input.taskId,
+    reply,
+    messages: visibleCuratorMessages(await listMessagesPg(input.userId, conversation.id)),
+    statusUpdate,
+    handoff,
+  };
+}

src/v1/curator/curator-events.ts

@@ -0,0 +1,36 @@
+import { recordGrowEvent } from "../../events/record-grow-event.js";
+
+function curatorDedupeKey(input: {
+  userId: string;
+  type: string;
+  payload?: Record<string, unknown>;
+}) {
+  const payload = input.payload ?? {};
+  const stableId =
+    payload.taskId ??
+    payload.sprintId ??
+    payload.startDate ??
+    payload.sourceEventId ??
+    payload.eventId ??
+    payload.date;
+
+  return `${input.userId}:${input.type}:${stableId ?? Date.now()}`;
+}
+
+export async function emitCuratorEvent(input: {
+  userId: string;
+  type: string;
+  payload?: Record<string, unknown>;
+  mission?: Record<string, unknown>;
+}) {
+  return recordGrowEvent({
+    source: "curator-v1",
+    type: input.type,
+    category: "mission",
+    userId: input.userId,
+    occurredAt: new Date().toISOString(),
+    mission: input.mission,
+    payload: input.payload ?? {},
+    dedupeKey: curatorDedupeKey(input),
+  }, { userId: input.userId, source: "curator-v1" });
+}

src/v1/curator/curator-routes.ts

@@ -0,0 +1,83 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { requireUser, type AuthContext } from "../../auth/clerk.js";
+import { curatorActor } from "./curator-actor.js";
+
+const chatSchema = z.object({
+  conversationId: z.string().optional(),
+  taskId: z.string().optional(),
+  subtaskIndex: z.number().int().min(0).optional(),
+  subtask: z.string().optional(),
+  date: z.string().optional(),
+  messages: z.array(z.object({ role: z.enum(["user", "assistant"]), content: z.string() })).min(1).max(50),
+});
+
+export function v1CuratorRoutes() {
+  const app = new Hono<AuthContext>();
+  app.use("*", requireUser);
+
+  app.post("/plan/generate", async (c) => {
+    const userId = c.get("userId");
+    const body = z.object({
+      startDate: z.string().optional(),
+      endDate: z.string().optional(),
+      goals: z.array(z.string()).optional(),
+      forceRegenerate: z.boolean().optional(),
+    }).parse(await c.req.json().catch(() => ({})));
+    return c.json(await curatorActor.generatePlanRange({ userId, ...body }));
+  });
+
+  app.get("/plan", async (c) => {
+    const userId = c.get("userId");
+    return c.json(await curatorActor.getPlan({
+      userId,
+      startDate: c.req.query("startDate"),
+      endDate: c.req.query("endDate"),
+    }));
+  });
+
+  app.get("/today", async (c) => {
+    const userId = c.get("userId");
+    return c.json(await curatorActor.getToday({ userId, date: c.req.query("date") }));
+  });
+
+  app.get("/sprint", async (c) => {
+    const userId = c.get("userId");
+    return c.json(await curatorActor.getSprint({ userId, date: c.req.query("date") }));
+  });
+
+  app.post("/chat", async (c) => {
+    const userId = c.get("userId");
+    const body = chatSchema.parse(await c.req.json());
+    return c.json(await curatorActor.chat({ userId, ...body }));
+  });
+
+  app.post("/tasks/:taskId/start", async (c) => {
+    const userId = c.get("userId");
+    return c.json(await curatorActor.startTask({ userId, taskId: c.req.param("taskId"), date: c.req.query("date") }));
+  });
+
+  app.post("/tasks/:taskId/handoff", async (c) => {
+    const userId = c.get("userId");
+    return c.json(await curatorActor.prepareTaskHandoff({ userId, taskId: c.req.param("taskId"), date: c.req.query("date") }));
+  });
+
+  app.post("/tasks/:taskId/complete", async (c) => {
+    const userId = c.get("userId");
+    const body = z.object({ reason: z.string().optional() }).parse(await c.req.json().catch(() => ({})));
+    return c.json(await curatorActor.completeTask({ userId, taskId: c.req.param("taskId"), date: c.req.query("date"), reason: body.reason }));
+  });
+
+  app.post("/events/service-impact", async (c) => {
+    const userId = c.get("userId");
+    const body = z.object({ eventId: z.string() }).parse(await c.req.json());
+    return c.json(await curatorActor.recordServiceImpact({ userId, eventId: body.eventId }));
+  });
+
+  app.get("/state", async (c) => {
+    const userId = c.get("userId");
+    return c.json(await curatorActor.getState({ userId }));
+  });
+
+  return app;
+}

src/v1/curator/curator-service-links.ts

@@ -0,0 +1,42 @@
+import {
+  buildCuratorServiceRoute,
+  getServiceActionLabel,
+  getServiceCompletionEvents,
+  getServiceDisplayName,
+  getServiceToolName,
+} from "../../services/service-registry.js";
+import type { CuratorServiceId, CuratorTask } from "./curator-types.js";
+
+type ServiceRouteInput = {
+  serviceId?: CuratorServiceId;
+  missionInstanceId?: string;
+  missionId?: string;
+  stageId?: string;
+  taskId?: string;
+  targetRole?: string;
+  durationMinutes?: number;
+  difficulty?: string;
+  personaId?: string;
+  requestedMode?: string;
+  roleplayBrief?: string;
+};
+
+export function serviceRoute(input: ServiceRouteInput) {
+  return buildCuratorServiceRoute(input);
+}
+
+export function serviceName(serviceId?: CuratorServiceId, fallback = "Mission planner") {
+  return getServiceDisplayName(serviceId, fallback);
+}
+
+export function serviceToolName(serviceId?: CuratorServiceId) {
+  return getServiceToolName(serviceId);
+}
+
+export function completionEventsForService(serviceId?: CuratorServiceId) {
+  return getServiceCompletionEvents(serviceId);
+}
+
+export function actionLabel(task: CuratorTask) {
+  return getServiceActionLabel(task);
+}

src/v1/curator/curator-tools.ts

@@ -0,0 +1,548 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { eq, desc, and, inArray } from "drizzle-orm";
+import { db } from "../../db/client.js";
+import { growEvents, growQscoreLatest, growQscoreProjectionState } from "../../db/schema.js";
+import { interviewService, resumeService, roleplayService } from "../../services/product-service-clients.js";
+import { createMissionAction, listMissionActions } from "../../missions/actions.js";
+import { listActiveMissionsPg, listMessagesPg } from "../../grow/persistence.js";
+import { buildCuratorStreak, buildCuratorTasks, listCuratorRegistryCapabilities } from "./curator-store.js";
+import { actionLabel, serviceRoute } from "./curator-service-links.js";
+import { curatorServiceIdSchema, type CuratorServiceHandoff, type CuratorTask } from "./curator-types.js";
+import { emitCuratorEvent } from "./curator-events.js";
+import { fallbackCuratorRole, resolveCuratorTargetRole } from "./curator-user-context.js";
+
+async function findTask(userId: string, taskId: string, date: string) {
+  const tasks = await buildCuratorTasks(userId, date);
+  return tasks.find((task) => task.id === taskId) ?? null;
+}
+
+function conciseRoleHint(value: string | undefined) {
+  const trimmed = value?.trim();
+  if (!trimmed) return undefined;
+  return trimmed.length > 80 ? `${trimmed.slice(0, 77).trimEnd()}...` : trimmed;
+}
+
+function buildRoleplayBrief(task: CuratorTask, targetRole: string) {
+  return `Practice a realistic ${task.title.toLowerCase()} conversation for ${targetRole}. Include one pushback moment, concise answers, and a clear next step.`;
+}
+
+async function missionGoalHint(userId: string, task: CuratorTask) {
+  if (!task.missionInstanceId) return undefined;
+  const active = await listActiveMissionsPg(userId);
+  const match = active.find((item) => item.mission.instanceId === task.missionInstanceId);
+  const goal = typeof match?.mission.goal === "string" ? match.mission.goal : undefined;
+  return conciseRoleHint(goal);
+}
+
+function asText(value: unknown): string | undefined {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return undefined;
+}
+
+function reviewField(payload: Record<string, unknown>, keys: string[]) {
+  for (const key of keys) {
+    const direct = asText(payload[key]);
+    if (direct) return direct;
+  }
+  const review = payload.review && typeof payload.review === "object" ? payload.review as Record<string, unknown> : undefined;
+  if (!review) return undefined;
+  for (const key of keys) {
+    const nested = asText(review[key]);
+    if (nested) return nested;
+  }
+  return undefined;
+}
+
+async function latestInterviewResumeEvidence(userId: string) {
+  const rows = await db.select({
+    id: growEvents.id,
+    type: growEvents.type,
+    source: growEvents.source,
+    payload: growEvents.payload,
+    occurredAt: growEvents.occurredAt,
+  }).from(growEvents)
+    .where(and(
+      eq(growEvents.userId, userId),
+      inArray(growEvents.type as any, [
+        "interview.review_completed",
+        "interview.completed",
+        "roleplay.review_completed",
+        "roleplay.completed",
+      ]),
+    ))
+    .orderBy(desc(growEvents.occurredAt))
+    .limit(5);
+
+  const latest = rows[0];
+  if (!latest) return null;
+
+  const payload = latest.payload ?? {};
+  const strongestAnswer = reviewField(payload, [
+    "strongest_answer",
+    "strongestAnswer",
+    "best_answer",
+    "bestAnswer",
+    "top_answer",
+    "topAnswer",
+  ]);
+  const improvementArea = reviewField(payload, [
+    "improvement_area",
+    "improvementArea",
+    "biggest_gap",
+    "biggestGap",
+    "coaching_note",
+    "coachingNote",
+  ]);
+  const summary = reviewField(payload, [
+    "summary",
+    "feedback_summary",
+    "feedbackSummary",
+    "overall_feedback",
+    "overallFeedback",
+  ]);
+
+  const carryForward = [
+    summary ? `Review summary: ${summary}` : undefined,
+    strongestAnswer ? `Strongest answer to convert into proof: ${strongestAnswer}` : undefined,
+    improvementArea ? `Weakest area to repair in resume positioning: ${improvementArea}` : undefined,
+  ].filter((item): item is string => Boolean(item));
+
+  return {
+    eventId: latest.id,
+    source: latest.source,
+    type: latest.type,
+    occurredAt: latest.occurredAt,
+    carryForward,
+  };
+}
+
+export async function prepareHandoffForTask(
+  userId: string,
+  task: CuratorTask,
+  serviceId = task.serviceId,
+  targetRoleOverride?: string,
+): Promise<CuratorServiceHandoff> {
+  if (!serviceId) throw new Error("Task has no service handoff.");
+  const resolvedTargetRole =
+    targetRoleOverride ??
+    (await missionGoalHint(userId, task)) ??
+    (await resolveCuratorTargetRole({ userId, task }));
+  const targetRole = fallbackCuratorRole(resolvedTargetRole);
+  const route = serviceRoute({
+    serviceId,
+    missionId: task.missionId,
+    missionInstanceId: task.missionInstanceId,
+    stageId: task.stageId,
+    taskId: task.id,
+    targetRole,
+    durationMinutes: 5,
+    difficulty: "medium",
+    personaId: serviceId === "roleplay-service" ? "emma" : "payal",
+    requestedMode: "video",
+    roleplayBrief: serviceId === "roleplay-service" ? buildRoleplayBrief(task, targetRole) : undefined,
+  });
+
+  let actionId: string | undefined;
+  if (task.missionInstanceId && task.missionId !== "curator-sprint") {
+    const action = await createMissionAction({
+      userId,
+      missionInstanceId: task.missionInstanceId,
+      missionId: task.missionId,
+      stageId: task.stageId,
+      agentId: "curator-v1",
+      agentName: "V1 Curator Actor",
+      baseAgent: "Curator Agent",
+      serviceId,
+      toolName: task.toolName,
+      mode: "suggestion",
+      status: "queued",
+      title: task.title,
+      body: task.subtitle,
+      prompt: `Prepare ${task.serviceName} handoff for ${task.title}.`,
+      payload: { href: route, route, taskId: task.id, source: "curator-v1" },
+      idempotencyKey: `curator-v1:${task.id}:${serviceId}`,
+      priority: 50,
+      urgency: "today",
+    });
+    actionId = action?.id;
+  }
+
+  await emitCuratorEvent({
+    userId,
+    type: "curator.service_handoff.opened",
+    mission: { missionId: task.missionId, missionInstanceId: task.missionInstanceId, stageId: task.stageId },
+    payload: { taskId: task.id, serviceId, route, actionId },
+  });
+
+  return {
+    taskId: task.id,
+    serviceId,
+    route,
+    actionId,
+    actionRoute: route,
+    actionLabel: actionLabel({ ...task, serviceId }),
+    status: "prepared",
+  };
+}
+
+export function buildCuratorTools(ctx: { userId: string; date: string; conversationId?: string; taskId?: string }) {
+  return {
+    get_onboarding_context: tool({
+      description: "Read available onboarding and profile context from recent platform events.",
+      inputSchema: z.object({}),
+      execute: async () => {
+        const events = await db.select().from(growEvents)
+          .where(and(eq(growEvents.userId, ctx.userId), eq(growEvents.category, "usage")))
+          .orderBy(desc(growEvents.occurredAt))
+          .limit(20);
+        return { events };
+      },
+    }),
+
+    get_user_goals: tool({
+      description: "Infer currently known goals from active missions and mission goals.",
+      inputSchema: z.object({}),
+      execute: async () => {
+        const active = await listActiveMissionsPg(ctx.userId);
+        return { goals: active.map((item) => ({ missionId: item.mission.missionId, title: item.mission.title, goal: item.mission.goal })) };
+      },
+    }),
+
+    get_curator_plan: tool({
+      description: "Read today's curator tasks and streak state.",
+      inputSchema: z.object({}),
+      execute: async () => ({ date: ctx.date, tasks: await buildCuratorTasks(ctx.userId, ctx.date), streak: await buildCuratorStreak(ctx.userId) }),
+    }),
+
+    get_today_tasks: tool({
+      description: "List today's V1 curator tasks.",
+      inputSchema: z.object({}),
+      execute: async () => ({ tasks: await buildCuratorTasks(ctx.userId, ctx.date) }),
+    }),
+
+    get_curator_streak: tool({
+      description: "Read the user's curator streak from allowed completion events.",
+      inputSchema: z.object({}),
+      execute: async () => ({ streak: await buildCuratorStreak(ctx.userId) }),
+    }),
+
+    read_curator_memory: tool({
+      description: "Read recent curator memory from existing grow events.",
+      inputSchema: z.object({ limit: z.number().int().min(1).max(50).default(10) }),
+      execute: async ({ limit }) => {
+        const events = await db.select().from(growEvents)
+          .where(and(eq(growEvents.userId, ctx.userId), eq(growEvents.source, "curator-v1")))
+          .orderBy(desc(growEvents.occurredAt))
+          .limit(limit);
+        return { events };
+      },
+    }),
+
+    write_curator_memory: tool({
+      description: "Write a durable curator memory event. Use this for chat extracts and status updates.",
+      inputSchema: z.object({ summary: z.string(), tags: z.array(z.string()).default([]) }),
+      execute: async ({ summary, tags }) => emitCuratorEvent({ userId: ctx.userId, type: "curator.memory.updated", payload: { summary, tags } }),
+    }),
+
+    read_conversation_context: tool({
+      description: "Read the current conversation history from existing conversation storage.",
+      inputSchema: z.object({ conversationId: z.string().optional() }),
+      execute: async ({ conversationId }) => ({ messages: conversationId || ctx.conversationId ? await listMessagesPg(ctx.userId, conversationId ?? ctx.conversationId!) : [] }),
+    }),
+
+    list_service_capabilities: tool({
+      description: "List deterministic service capabilities from existing service registries.",
+      inputSchema: z.object({}),
+      execute: listCuratorRegistryCapabilities,
+    }),
+
+    list_available_service_routes: tool({
+      description: "Return known handoff routes for registered services.",
+      inputSchema: z.object({ taskId: z.string().optional() }),
+      execute: async ({ taskId }) => {
+        const task = taskId ? await findTask(ctx.userId, taskId, ctx.date) : null;
+        return {
+          routes: ["interview-service", "resume-service", "roleplay-service", "qscore-service"].map((serviceId) => ({
+            serviceId,
+            route: serviceRoute({ serviceId: serviceId as any, missionId: task?.missionId, missionInstanceId: task?.missionInstanceId, stageId: task?.stageId, taskId: task?.id }),
+          })),
+        };
+      },
+    }),
+
+    validate_service_handoff: tool({
+      description: "Validate whether a requested service handoff exists in the registry.",
+      inputSchema: z.object({ serviceId: curatorServiceIdSchema }),
+      execute: async ({ serviceId }) => {
+        const capabilities = await listCuratorRegistryCapabilities();
+        return { valid: capabilities.services.some((service) => service.id === serviceId), serviceId };
+      },
+    }),
+
+    map_task_to_service: tool({
+      description: "Map a curator task to its service capability and handoff route.",
+      inputSchema: z.object({ taskId: z.string() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId, ctx.date);
+        return { task, route: task ? serviceRoute({ serviceId: task.serviceId, missionId: task.missionId, missionInstanceId: task.missionInstanceId, stageId: task.stageId, taskId }) : null };
+      },
+    }),
+
+    prepare_interview_setup: tool({
+      description: "Prepare an interview setup handoff. This creates a mission action and route, not the full interview workflow.",
+      inputSchema: z.object({ taskId: z.string().optional() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId ?? ctx.taskId ?? "", ctx.date);
+        if (!task) return { error: "task_not_found" };
+        return prepareHandoffForTask(ctx.userId, task, "interview-service");
+      },
+    }),
+
+    prepare_interview_preview: tool({
+      description: "Prepare the interview preview route after setup context exists.",
+      inputSchema: z.object({ taskId: z.string().optional() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId ?? ctx.taskId ?? "", ctx.date);
+        if (!task) return { error: "task_not_found" };
+        return prepareHandoffForTask(ctx.userId, task, "interview-service");
+      },
+    }),
+
+    read_interview_report: tool({
+      description: "Read available interview page/report state from the existing interview service.",
+      inputSchema: z.object({ sessionId: z.string().optional() }),
+      execute: async ({ sessionId }) => sessionId ? interviewService.review(sessionId) : interviewService.pageState(ctx.userId),
+    }),
+
+    list_interview_sessions: tool({
+      description: "List interview service page state for the user.",
+      inputSchema: z.object({}),
+      execute: async () => interviewService.pageState(ctx.userId),
+    }),
+
+    get_interview_latest_status: tool({
+      description: "Read the latest interview-related events.",
+      inputSchema: z.object({ limit: z.number().int().min(1).max(20).default(5) }),
+      execute: async ({ limit }) => db.select().from(growEvents).where(and(eq(growEvents.userId, ctx.userId), eq(growEvents.source, "interview"))).orderBy(desc(growEvents.occurredAt)).limit(limit),
+    }),
+
+    prepare_resume_upload: tool({
+      description: "Prepare resume upload or resume builder handoff.",
+      inputSchema: z.object({ taskId: z.string().optional() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId ?? ctx.taskId ?? "", ctx.date);
+        if (!task) return { error: "task_not_found" };
+        return prepareHandoffForTask(ctx.userId, task, "resume-service");
+      },
+    }),
+
+    extract_resume_context: tool({
+      description: "Extract basic context from pasted resume text for curator reasoning.",
+      inputSchema: z.object({ text: z.string().min(1) }),
+      execute: async ({ text }) => ({
+        length: text.length,
+        hasExperience: /experience|work|employment/i.test(text),
+        hasEducation: /education|degree|university|college/i.test(text),
+        hasSkills: /skills|tools|technologies/i.test(text),
+        preview: text.slice(0, 500),
+      }),
+    }),
+
+    read_resume_report: tool({
+      description: "Read existing resume service state.",
+      inputSchema: z.object({ resumeId: z.string().optional() }),
+      execute: async ({ resumeId }) => resumeId ? resumeService.getResume(resumeId) : resumeService.state(ctx.userId),
+    }),
+
+    prepare_resume_rewrite: tool({
+      description: "Prepare a resume rewrite handoff.",
+      inputSchema: z.object({ taskId: z.string().optional() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId ?? ctx.taskId ?? "", ctx.date);
+        if (!task) return { error: "task_not_found" };
+        return prepareHandoffForTask(ctx.userId, task, "resume-service");
+      },
+    }),
+
+    prepare_resume_talking_points: tool({
+      description: "Prepare resume talking point handoff.",
+      inputSchema: z.object({ taskId: z.string().optional() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId ?? ctx.taskId ?? "", ctx.date);
+        if (!task) return { error: "task_not_found" };
+        return prepareHandoffForTask(ctx.userId, task, "resume-service");
+      },
+    }),
+
+    prepare_resume_gap_scan: tool({
+      description: "Prepare resume gap scan handoff.",
+      inputSchema: z.object({ taskId: z.string().optional() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId ?? ctx.taskId ?? "", ctx.date);
+        if (!task) return { error: "task_not_found" };
+        return prepareHandoffForTask(ctx.userId, task, "resume-service");
+      },
+    }),
+
+    prepare_resume_from_interview_evidence: tool({
+      description: "Prepare a resume handoff that carries forward recent interview or roleplay review evidence into the proof task.",
+      inputSchema: z.object({ taskId: z.string().optional() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId ?? ctx.taskId ?? "", ctx.date);
+        if (!task) return { error: "task_not_found" };
+        const handoff = await prepareHandoffForTask(ctx.userId, task, "resume-service");
+        const evidence = await latestInterviewResumeEvidence(ctx.userId);
+        if (!evidence?.carryForward?.length) {
+          const interviewFallback = await prepareHandoffForTask(ctx.userId, task, "interview-service");
+          return {
+            handoff,
+            carryForward: [],
+            requiresInterviewEvidence: true,
+            recommendedNextAction: "No recent interview or roleplay review evidence is available yet. Run an interview rep first so the resume proof can be generated from real conversation evidence.",
+            fallbackHandoff: interviewFallback,
+          };
+        }
+        return {
+          handoff,
+          carryForward: evidence?.carryForward ?? [],
+          sourceEventId: evidence?.eventId,
+          sourceEventType: evidence?.type,
+          sourceService: evidence?.source,
+          sourceOccurredAt: evidence?.occurredAt,
+        };
+      },
+    }),
+
+    prepare_roleplay_setup: tool({
+      description: "Prepare roleplay setup handoff.",
+      inputSchema: z.object({ taskId: z.string().optional() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId ?? ctx.taskId ?? "", ctx.date);
+        if (!task) return { error: "task_not_found" };
+        return prepareHandoffForTask(ctx.userId, task, "roleplay-service");
+      },
+    }),
+
+    prepare_roleplay_preview: tool({
+      description: "Prepare roleplay preview handoff.",
+      inputSchema: z.object({ taskId: z.string().optional() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId ?? ctx.taskId ?? "", ctx.date);
+        if (!task) return { error: "task_not_found" };
+        return prepareHandoffForTask(ctx.userId, task, "roleplay-service");
+      },
+    }),
+
+    suggest_roleplay_scenario: tool({
+      description: "Suggest a roleplay scenario from current task context.",
+      inputSchema: z.object({ taskId: z.string().optional() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId ?? ctx.taskId ?? "", ctx.date);
+        return { scenario: task?.title ?? "Practice a high-stakes workplace conversation", outcome: "Clear next step and confident response" };
+      },
+    }),
+
+    read_roleplay_report: tool({
+      description: "Read roleplay service report or page state.",
+      inputSchema: z.object({ sessionId: z.string().optional() }),
+      execute: async ({ sessionId }) => sessionId ? roleplayService.review(sessionId) : roleplayService.pageState(ctx.userId),
+    }),
+
+    list_roleplay_sessions: tool({
+      description: "List roleplay service page state for the user.",
+      inputSchema: z.object({}),
+      execute: async () => roleplayService.pageState(ctx.userId),
+    }),
+
+    read_qscore_state: tool({
+      description: "Read current Q-score projection state.",
+      inputSchema: z.object({}),
+      execute: async () => db.select().from(growQscoreProjectionState).where(eq(growQscoreProjectionState.userId, ctx.userId)).limit(1),
+    }),
+
+    read_qscore_signals: tool({
+      description: "Read latest Q-score signals.",
+      inputSchema: z.object({ limit: z.number().int().min(1).max(50).default(20) }),
+      execute: async ({ limit }) => db.select().from(growQscoreLatest).where(eq(growQscoreLatest.userId, ctx.userId)).orderBy(desc(growQscoreLatest.updatedAt)).limit(limit),
+    }),
+
+    explain_qscore_movement: tool({
+      description: "Explain recent Q-score movement from available signals.",
+      inputSchema: z.object({}),
+      execute: async () => ({ state: await db.select().from(growQscoreProjectionState).where(eq(growQscoreProjectionState.userId, ctx.userId)).limit(1), signals: await db.select().from(growQscoreLatest).where(eq(growQscoreLatest.userId, ctx.userId)).orderBy(desc(growQscoreLatest.updatedAt)).limit(10) }),
+    }),
+
+    map_task_to_qscore_signals: tool({
+      description: "Map a curator task to the Q-score signals it can affect.",
+      inputSchema: z.object({ taskId: z.string() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId, ctx.date);
+        return { taskId, signals: task?.signals ?? [] };
+      },
+    }),
+
+    prepare_qscore_review: tool({
+      description: "Prepare a Q-score review handoff.",
+      inputSchema: z.object({ taskId: z.string().optional() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId ?? ctx.taskId ?? "", ctx.date);
+        if (!task) return { error: "task_not_found" };
+        return prepareHandoffForTask(ctx.userId, task, "qscore-service");
+      },
+    }),
+
+    emit_curator_event: tool({
+      description: "Emit a curator event through existing Grow event ingestion.",
+      inputSchema: z.object({ type: z.string(), payload: z.record(z.string(), z.unknown()).default({}) }),
+      execute: async ({ type, payload }) => emitCuratorEvent({ userId: ctx.userId, type, payload }),
+    }),
+
+    read_recent_grow_events: tool({
+      description: "Read recent Grow events for this user.",
+      inputSchema: z.object({ limit: z.number().int().min(1).max(50).default(20) }),
+      execute: async ({ limit }) => db.select().from(growEvents).where(eq(growEvents.userId, ctx.userId)).orderBy(desc(growEvents.occurredAt)).limit(limit),
+    }),
+
+    find_matching_service_event: tool({
+      description: "Find service events that can complete a task.",
+      inputSchema: z.object({ taskId: z.string() }),
+      execute: async ({ taskId }) => {
+        const task = await findTask(ctx.userId, taskId, ctx.date);
+        if (!task) return { task: null, events: [] };
+        const events = await db.select().from(growEvents).where(and(eq(growEvents.userId, ctx.userId), inArray(growEvents.type as any, task.completionEvents))).orderBy(desc(growEvents.occurredAt)).limit(20);
+        return { task, events };
+      },
+    }),
+
+    complete_task_from_event: tool({
+      description: "Complete a task only when a valid service or platform event exists.",
+      inputSchema: z.object({ taskId: z.string(), eventId: z.string() }),
+      execute: async ({ taskId, eventId }) => {
+        const task = await findTask(ctx.userId, taskId, ctx.date);
+        if (!task) return { error: "task_not_found" };
+        const [event] = await db.select().from(growEvents).where(and(eq(growEvents.userId, ctx.userId), eq(growEvents.id, eventId))).limit(1);
+        if (!event || !task.completionEvents.includes(event.type)) return { completed: false, reason: "event_not_allowed" };
+        return emitCuratorEvent({ userId: ctx.userId, type: "curator.task.completed", mission: { missionId: task.missionId, missionInstanceId: task.missionInstanceId, stageId: task.stageId }, payload: { taskId, sourceEventId: eventId } });
+      },
+    }),
+
+    update_streak_from_completion: tool({
+      description: "Read streak after completion events.",
+      inputSchema: z.object({}),
+      execute: async () => ({ streak: await buildCuratorStreak(ctx.userId) }),
+    }),
+
+    list_mission_actions: tool({
+      description: "List existing mission actions so the curator does not duplicate handoffs.",
+      inputSchema: z.object({}),
+      execute: async () => listMissionActions(ctx.userId, { openOnly: false }),
+    }),
+  };
+}

src/v1/curator/curator-types.ts

@@ -0,0 +1,181 @@
+import { z } from "zod";
+
+export const curatorServiceIdSchema = z.enum([
+  "interview-service",
+  "resume-service",
+  "roleplay-service",
+  "qscore-service",
+  "social-branding-service",
+  "matchmaking-service",
+]);
+
+export type CuratorServiceId = z.infer<typeof curatorServiceIdSchema>;
+
+export const curatorTaskTypeSchema = z.enum(["measurement", "proof", "practice"]);
+export type CuratorTaskType = z.infer<typeof curatorTaskTypeSchema>;
+
+export const curatorTaskStatusSchema = z.enum([
+  "ready",
+  "started",
+  "handoff_prepared",
+  "completed",
+  "blocked",
+]);
+
+export const curatorWeekLifecycleSchema = z.enum(["done", "active", "upcoming"]);
+export const curatorWeekPerformanceSchema = z.enum(["Missed", "Okayish", "Avg", "Excelling"]);
+
+export const curatorTaskSchema = z.object({
+  id: z.string(),
+  date: z.string(),
+  dayIndex: z.number().int().min(1).max(30),
+  dayIndexInWeek: z.number().int().min(1).max(7),
+  weekIndex: z.number().int().min(1).max(5),
+  taskType: curatorTaskTypeSchema,
+  title: z.string(),
+  subtitle: z.string(),
+  missionId: z.string(),
+  missionInstanceId: z.string().optional(),
+  stageId: z.string().optional(),
+  serviceId: curatorServiceIdSchema.optional(),
+  serviceName: z.string(),
+  actorName: z.string(),
+  toolName: z.string(),
+  status: curatorTaskStatusSchema,
+  rewardCoins: z.number().int().min(0),
+  qxImpact: z.string(),
+  effort: z.string(),
+  route: z.string(),
+  cta: z.string(),
+  context: z.array(z.object({ label: z.string(), value: z.string() })),
+  contextNarrative: z.string(),
+  subtasks: z.array(z.string()).length(3),
+  signals: z.array(z.string()),
+  completionEvents: z.array(z.string()),
+  source: z.enum(["curator-v1", "mission-registry", "service-registry"]),
+});
+
+export const curatorStreakSchema = z.object({
+  current: z.number().int().min(0),
+  longest: z.number().int().min(0),
+  lastCompletedDate: z.string().nullable(),
+});
+
+export const curatorPlanDaySchema = z.object({
+  date: z.string(),
+  dayIndex: z.number().int().min(1).max(30),
+  dayIndexInWeek: z.number().int().min(1).max(7),
+  weekIndex: z.number().int().min(1).max(5),
+  weekTheme: z.string(),
+  weekSummary: z.string(),
+  focus: z.string().optional(),
+  plannedServices: z.array(curatorServiceIdSchema).max(3).default([]),
+  generationStatus: z.enum(["seeded", "generated", "adapted"]).default("seeded"),
+  adaptationReason: z.string().optional(),
+  completedCount: z.number().int().min(0),
+  totalCount: z.number().int().min(0),
+  unlockState: z.enum(["completed", "active", "upcoming"]),
+  tasks: z.array(curatorTaskSchema),
+});
+
+export const curatorWeekSchema = z.object({
+  weekIndex: z.number().int().min(1).max(5),
+  title: z.string(),
+  theme: z.string(),
+  summary: z.string(),
+  startDayIndex: z.number().int().min(1).max(30),
+  endDayIndex: z.number().int().min(1).max(30),
+  lifecycle: curatorWeekLifecycleSchema,
+  performance: curatorWeekPerformanceSchema,
+  completedTaskCount: z.number().int().min(0),
+  totalTaskCount: z.number().int().min(0),
+  completionPercent: z.number().min(0).max(100),
+  days: z.array(curatorPlanDaySchema).min(2).max(7),
+});
+
+export const curatorPlanSchema = z.object({
+  id: z.string(),
+  userId: z.string(),
+  startDate: z.string(),
+  endDate: z.string(),
+  goals: z.array(z.string()),
+  generatedAt: z.string(),
+  durationDays: z.literal(30),
+  weeks: z.array(curatorWeekSchema).length(5),
+  days: z.array(curatorPlanDaySchema).length(30),
+  streak: curatorStreakSchema,
+  source: z.literal("curator-v1"),
+});
+
+export const curatorImprovementSignalSchema = z.object({
+  id: z.string(),
+  userId: z.string(),
+  date: z.string(),
+  priority: z.number().int().min(0).max(100),
+  reason: z.string(),
+  recommendedServiceId: curatorServiceIdSchema.optional(),
+  recommendedMissionId: z.string().optional(),
+  memoryPatch: z.string().optional(),
+  nudgeText: z.string().optional(),
+  status: z.enum(["created", "applied", "skipped"]).default("created"),
+});
+
+export const curatorSprintResponseSchema = z.object({
+  date: z.string(),
+  sprintId: z.string(),
+  plan: curatorPlanSchema,
+  activeWeek: curatorWeekSchema,
+  activeWeekIndex: z.number().int().min(1).max(5),
+  activeDay: curatorPlanDaySchema,
+  activeDayIndex: z.number().int().min(1).max(30),
+  todayTasks: z.array(curatorTaskSchema).length(3),
+  streak: curatorStreakSchema,
+  completedCount: z.number().int().min(0),
+  totalCount: z.number().int().min(0),
+  overallProgressPercent: z.number().min(0).max(100),
+  source: z.literal("curator-v1"),
+});
+
+export type CuratorTask = z.infer<typeof curatorTaskSchema>;
+export type CuratorPlanDay = z.infer<typeof curatorPlanDaySchema>;
+export type CuratorWeek = z.infer<typeof curatorWeekSchema>;
+export type CuratorPlan = z.infer<typeof curatorPlanSchema>;
+export type CuratorStreak = z.infer<typeof curatorStreakSchema>;
+export type CuratorImprovementSignal = z.infer<typeof curatorImprovementSignalSchema>;
+export type CuratorSprintResponse = z.infer<typeof curatorSprintResponseSchema>;
+
+export type CuratorTodayResponse = {
+  date: string;
+  plan: CuratorPlan;
+  tasks: CuratorTask[];
+  streak: CuratorStreak;
+  completedCount: number;
+  totalCount: number;
+  source: "curator-v1";
+};
+
+export type CuratorSubtaskStatusUpdate = {
+  status: "needs_more_context" | "ready_to_capture" | "handoff_ready";
+  summary: string;
+  confidence: number;
+  nextMissingInfo?: string;
+};
+
+export type CuratorChatResponse = {
+  conversationId: string;
+  taskId?: string;
+  reply: string;
+  messages: Array<{ id: string; role: "user" | "assistant"; sender: string; content: string; createdAt: number }>;
+  statusUpdate?: CuratorSubtaskStatusUpdate;
+  handoff?: CuratorServiceHandoff;
+};
+
+export type CuratorServiceHandoff = {
+  taskId: string;
+  serviceId: CuratorServiceId;
+  route: string;
+  actionId?: string;
+  actionRoute: string;
+  actionLabel: string;
+  status: "prepared";
+};

src/v1/curator/curator-user-context.ts

@@ -0,0 +1,132 @@
+import { and, desc, eq } from "drizzle-orm";
+import { db } from "../../db/client.js";
+import { growEvents } from "../../db/schema.js";
+import { asRecord, getString } from "../../events/envelope.js";
+import type { CuratorTask } from "./curator-types.js";
+
+const ROLE_PATTERN = /\b(pm|swe|manager|engineer|designer|analyst|developer|product|marketing|sales|founder|consultant|operator|lead|head|director|recruiter|student|intern|data scientist|software)\b/i;
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === "string" && item.trim().length > 0)
+    : [];
+}
+
+function firstRoleFromValue(value: unknown): string | undefined {
+  const direct = getString(value);
+  if (direct) return direct;
+  const record = asRecord(value);
+  return getString(
+    record.target_role ??
+      record.targetRole ??
+      record.current_role ??
+      record.currentRole ??
+      record.role ??
+      record.title ??
+      record.position,
+  );
+}
+
+function roleFromPreferences(preferences: Record<string, unknown>) {
+  const targetRoles = stringArray(preferences.target_roles ?? preferences.targetRoles);
+  if (targetRoles[0]) return targetRoles[0];
+  const onboarding = asRecord(preferences.onboarding);
+  return firstRoleFromValue(
+    onboarding.target_role ??
+      onboarding.targetRole ??
+      onboarding.role ??
+      onboarding.goal ??
+      onboarding.current_role,
+  );
+}
+
+function roleFromPayload(payload: Record<string, unknown>) {
+  const preferences = asRecord(payload.preferences);
+  const fromPreferences = roleFromPreferences(preferences);
+  if (fromPreferences) return fromPreferences;
+  const explicitRole = firstRoleFromValue(
+    payload.target_role ??
+      payload.targetRole ??
+      payload.current_role ??
+      payload.currentRole ??
+      payload.role,
+  );
+  if (explicitRole) return explicitRole;
+  return inferRoleFromText(getString(payload.goal ?? payload.userGoal ?? payload.serviceIntent));
+}
+
+function roleFromTask(task?: CuratorTask) {
+  for (const item of task?.context ?? []) {
+    if (/role|target|focus/i.test(item.label)) {
+      const role = firstRoleFromValue(item.value);
+      if (role && ROLE_PATTERN.test(role)) return role;
+    }
+  }
+  const raw = `${task?.title ?? ""} ${task?.subtitle ?? ""}`;
+  const productManager = raw.match(/\bproduct manager\b/i)?.[0];
+  if (productManager) return "Product Manager";
+  return undefined;
+}
+
+export function inferRoleFromText(text?: string) {
+  const value = text?.trim();
+  if (!value) return undefined;
+  const cleanRole = (raw?: string) => {
+    if (!raw) return undefined;
+    const normalized = raw
+      .replace(/^(?:i am |i'm |im )/i, "")
+      .replace(/^(?:targeting|aiming for|looking for)\s+/i, "")
+      .replace(/[.?!,]+$/, "")
+      .replace(/\broles?\b/gi, "")
+      .replace(/\b(this|next)\s+(week|month|quarter|year)\b/gi, "")
+      .replace(/\b(right now|currently)\b/gi, "")
+      .replace(/\s+/g, " ")
+      .trim();
+    if (!normalized) return undefined;
+    if (/^pm$/i.test(normalized)) return "Product Manager";
+    if (/^swe$/i.test(normalized)) return "Software Engineer";
+    return normalized;
+  };
+
+  const explicit = value.match(/(?:targeting|for|as|toward|towards|role is|role:)\s+([A-Za-z][A-Za-z0-9 +/&.-]{2,60}?)(?=\s+roles?\b|\s+(?:this|next)\s+(?:week|month|quarter|year)\b|[.?!,]|$)/i)?.[1];
+  if (explicit) return cleanRole(explicit);
+  if (value.length <= 80 && ROLE_PATTERN.test(value)) return cleanRole(value);
+  return undefined;
+}
+
+export async function resolveCuratorTargetRole(input: {
+  userId: string;
+  task?: CuratorTask;
+  latest?: string;
+  history?: Array<{ role: "user" | "assistant"; content: string }>;
+}) {
+  const latestRole = inferRoleFromText(input.latest);
+  if (latestRole) return latestRole;
+
+  const historyRole = [...(input.history ?? [])]
+    .reverse()
+    .filter((message) => message.role === "user")
+    .map((message) => inferRoleFromText(message.content))
+    .find(Boolean);
+  if (historyRole) return historyRole;
+
+  const taskRole = roleFromTask(input.task);
+  if (taskRole) return taskRole;
+
+  const rows = await db
+    .select({ payload: growEvents.payload })
+    .from(growEvents)
+    .where(and(eq(growEvents.userId, input.userId), eq(growEvents.category, "usage")))
+    .orderBy(desc(growEvents.occurredAt))
+    .limit(30);
+
+  for (const row of rows) {
+    const role = roleFromPayload(row.payload ?? {});
+    if (role) return role;
+  }
+  return undefined;
+}
+
+export function fallbackCuratorRole(role?: string) {
+  return role?.trim() || "Product Manager";
+}

src/v1/index.ts

@@ -0,0 +1,10 @@
+import { Hono } from "hono";
+import { v1CuratorRoutes } from "./curator/curator-routes.js";
+import { v1AnalyticsRoutes } from "./analytics/analytics-routes.js";
+
+export function v1Routes() {
+  const app = new Hono();
+  app.route("/curator", v1CuratorRoutes());
+  app.route("/analytics", v1AnalyticsRoutes());
+  return app;
+}

src/workflows/registry.ts

@@ -2,7 +2,7 @@ import type { WorkflowDefinition } from "./types.js";
 import { displayLabelForExecution, displayLabelForService } from "../features/registry.js";
 
 const serviceLabel = (serviceId: string) => displayLabelForService(serviceId) ?? serviceId;
-const planningLabel = displayLabelForExecution("opencode") ?? "Mission Planning";
+const planningLabel = displayLabelForExecution("manual") ?? "Mission Planner";
 
 const commonInputs = [
   { id: "goal", label: "Target outcome", type: "text", required: true },
@@ -11,53 +11,151 @@ const commonInputs = [
 
 export const workflowDefinitions: WorkflowDefinition[] = [
   {
-    id: "interview-to-offer", version: "1.0.0", title: "Interview to Offer", shortTitle: "Interview to Offer",
-    promise: "Turn a scheduled interview into a focused prep plan, practice sessions, and a readiness report.", segment: ["job-seekers", "interviewing"], urgency: "high", estimatedDuration: "2-5 days", priceTier: "starter", sku: "workflow_interview_to_offer", isPurchasable: true, isFreePreview: true,
-    visual: { icon: "briefcase-business", color: "emerald", mascotAgentIds: ["interview", "roleplay", "qscore"] }, requiredInputs: commonInputs,
+    id: "interview-to-offer",
+    version: "2.0.0",
+    title: "Interview-to-Offer Accelerator",
+    shortTitle: "Interview to Offer",
+    promise: "Prepare me for this specific interview and help me convert it into an offer.",
+    segment: ["job-seekers", "interviewing", "urgent"],
+    urgency: "high",
+    estimatedDuration: "2-5 days",
+    priceTier: "starter",
+    sku: "workflow_interview_to_offer",
+    isPurchasable: true,
+    isFreePreview: true,
+    visual: { icon: "briefcase-business", color: "emerald", mascotAgentIds: ["interview", "roleplay", "resume", "qscore"] },
+    requiredInputs: commonInputs,
     modules: [
-      { id: "resume", title: "Resume fit scan", role: serviceLabel("resume-service"), description: "Analyze resume readiness for the target role.", execution: "service", service: "resume-service" },
-      { id: "interview-plan", title: "Interview prep plan", role: planningLabel, description: "Generate a prep plan and likely questions artifact.", execution: "opencode", promptPath: "prompts/workflows/interview-to-offer/interview-plan.md", artifactTypes: ["interview_plan"], approvalGateAfter: "review-plan" },
-      { id: "interview", title: "Mock interview", role: serviceLabel("interview-service"), description: "Create a real interview practice session.", execution: "service", service: "interview-service" },
-      { id: "roleplay", title: "Communication roleplay", role: serviceLabel("roleplay-service"), description: "Create a realistic roleplay session.", execution: "service", service: "roleplay-service" },
-      { id: "branding", title: "Social branding", role: serviceLabel("social-branding-service"), description: "Optimize LinkedIn and professional presence.", execution: "service", service: "social-branding-service" },
-      { id: "matchmaking", title: "Matchmaking", role: serviceLabel("matchmaking-service"), description: "Connect with mentors and opportunities.", execution: "service", service: "matchmaking-service" },
-      { id: "qscore", title: "Readiness Q Score", role: serviceLabel("qscore-service"), description: "Compute readiness score.", execution: "service", service: "qscore-service" },
+      { id: "plan", title: "Interview prep plan", role: planningLabel, description: "Clarify target role, company context, likely questions, and prep priorities.", execution: "manual" },
+      { id: "resume", title: "Resume-based talking points", role: serviceLabel("resume-service"), description: "Extract role-fit proof, gaps, and tailored talking points from the resume.", execution: "service", service: "resume-service" },
+      { id: "interview", title: "Mock interview sessions", role: serviceLabel("interview-service"), description: "Run interview practice and collect weakness diagnosis.", execution: "service", service: "interview-service" },
+      { id: "roleplay", title: "Behavioral/story bank practice", role: serviceLabel("roleplay-service"), description: "Practice concise stories, objections, and communication recovery.", execution: "service", service: "roleplay-service" },
+      { id: "qscore", title: "Final readiness score", role: serviceLabel("qscore-service"), description: "Continuously score readiness from resume, interview, and roleplay signals.", execution: "service", service: "qscore-service" },
     ],
-    outputs: [{ id: "interview_plan", type: "markdown", title: "Interview prep plan", path: "artifacts/interview-to-offer/interview-plan.md" }], qscoreDimensions: ["clarity", "communication", "role_fit"], approvalGates: [{ id: "review-plan", title: "Review prep plan", description: "User reviews generated plan before practice.", required: false }],
+    outputs: [
+      { id: "interview_prep_plan", type: "markdown", title: "Interview prep plan" },
+      { id: "story_bank", type: "markdown", title: "Behavioral/story bank" },
+      { id: "readiness_report", type: "scorecard", title: "Final readiness score" },
+    ],
+    qscoreDimensions: ["role_fit", "communication", "confidence"],
+    approvalGates: [],
   },
   {
-    id: "career-transition", version: "1.0.0", title: "Switch Careers", shortTitle: "Switch Careers", promise: "Map transferable abilities and produce a transition narrative.", segment: ["career-changers"], urgency: "medium", estimatedDuration: "1-2 weeks", priceTier: "starter", sku: "workflow_career_transition", isPurchasable: true, isFreePreview: true, visual: { icon: "route", color: "blue", mascotAgentIds: ["resume", "qscore"] }, requiredInputs: commonInputs,
+    id: "career-transition",
+    version: "2.0.0",
+    title: "Career Transition Accelerator",
+    shortTitle: "Career Transition",
+    promise: "Help me reposition from my current career into a better-fit role.",
+    segment: ["career-changers"],
+    urgency: "medium",
+    estimatedDuration: "1-2 weeks",
+    priceTier: "starter",
+    sku: "workflow_career_transition",
+    isPurchasable: true,
+    isFreePreview: true,
+    visual: { icon: "route", color: "blue", mascotAgentIds: ["resume", "interview", "roleplay", "qscore"] },
+    requiredInputs: commonInputs,
     modules: [
-      { id: "transition-map", title: "Transition map", role: planningLabel, description: "Generate skills map and positioning narrative.", execution: "opencode", promptPath: "prompts/workflows/career-transition/orchestrator.md", artifactTypes: ["transition_map"] },
-      { id: "resume", title: "Resume fit scan", role: serviceLabel("resume-service"), description: "Analyze resume for target path.", execution: "service", service: "resume-service" },
-      { id: "branding", title: "Social branding", role: serviceLabel("social-branding-service"), description: "Build transition narrative on LinkedIn.", execution: "service", service: "social-branding-service" },
-      { id: "matchmaking", title: "Matchmaking", role: serviceLabel("matchmaking-service"), description: "Connect with mentors in the target field.", execution: "service", service: "matchmaking-service" },
-    ], outputs: [{ id: "transition_map", type: "markdown", title: "Transition map" }], qscoreDimensions: ["positioning", "skills", "confidence"], approvalGates: [],
+      { id: "clarify-target", title: "Target role recommendation", role: planningLabel, description: "Clarify current role, target role, constraints, and transition thesis.", execution: "manual" },
+      { id: "resume", title: "Transferable skills map", role: serviceLabel("resume-service"), description: "Map transferable skills and reposition resume proof for the target lane.", execution: "service", service: "resume-service" },
+      { id: "interview", title: "Adjacent-role interview narrative", role: serviceLabel("interview-service"), description: "Validate credibility for the new role through mock interview practice.", execution: "service", service: "interview-service" },
+      { id: "roleplay", title: "Why I am switching practice", role: serviceLabel("roleplay-service"), description: "Practice the transition pitch and hard follow-up questions.", execution: "service", service: "roleplay-service" },
+      { id: "qscore", title: "Transition readiness delta", role: serviceLabel("qscore-service"), description: "Track readiness gains and the next missing proof.", execution: "service", service: "qscore-service" },
+    ],
+    outputs: [
+      { id: "target_role_recommendation", type: "markdown", title: "Target role recommendation" },
+      { id: "transition_plan", type: "markdown", title: "30/60/90 transition plan" },
+    ],
+    qscoreDimensions: ["positioning", "transferable_skills", "confidence"],
+    approvalGates: [],
   },
   {
-    id: "salary-negotiation-war-room", version: "1.0.0", title: "Negotiate Salary", shortTitle: "Negotiate Salary", promise: "Prepare scripts, ranges, and roleplay for an offer conversation.", segment: ["offer-stage"], urgency: "high", estimatedDuration: "24-72 hours", priceTier: "premium", sku: "workflow_salary_negotiation", isPurchasable: true, isFreePreview: false, visual: { icon: "badge-dollar-sign", color: "amber", mascotAgentIds: ["roleplay"] }, requiredInputs: commonInputs,
+    id: "salary-negotiation-war-room",
+    version: "2.0.0",
+    title: "Salary / Offer Negotiation War Room",
+    shortTitle: "Negotiation War Room",
+    promise: "Help me negotiate my offer, raise, or promotion conversation.",
+    segment: ["offer-stage", "employed"],
+    urgency: "high",
+    estimatedDuration: "24-72 hours",
+    priceTier: "premium",
+    sku: "workflow_salary_negotiation",
+    isPurchasable: true,
+    isFreePreview: false,
+    visual: { icon: "badge-dollar-sign", color: "amber", mascotAgentIds: ["roleplay", "resume", "qscore"] },
+    requiredInputs: commonInputs,
     modules: [
-      { id: "negotiation-script", title: "Negotiation script", role: planningLabel, description: "Generate negotiation strategy and scripts.", execution: "opencode", promptPath: "prompts/workflows/salary-negotiation-war-room/orchestrator.md", artifactTypes: ["negotiation_script"] },
-      { id: "roleplay", title: "Negotiation roleplay", role: serviceLabel("roleplay-service"), description: "Create offer negotiation roleplay.", execution: "service", service: "roleplay-service" },
-      { id: "matchmaking", title: "Matchmaking", role: serviceLabel("matchmaking-service"), description: "Connect with mentors who navigated similar negotiations.", execution: "service", service: "matchmaking-service" },
-    ], outputs: [{ id: "negotiation_script", type: "markdown", title: "Negotiation script" }], qscoreDimensions: ["voice", "confidence", "strategy"], approvalGates: [],
+      { id: "offer-context", title: "Offer analysis", role: planningLabel, description: "Capture offer, target range, leverage, constraints, and deadline.", execution: "manual" },
+      { id: "resume", title: "Value evidence map", role: serviceLabel("resume-service"), description: "Extract measurable impact and proof points from resume history.", execution: "service", service: "resume-service" },
+      { id: "roleplay", title: "Live-call negotiation practice", role: serviceLabel("roleplay-service"), description: "Practice counteroffer, objection handling, and calm assertiveness.", execution: "service", service: "roleplay-service" },
+      { id: "interview", title: "Confidence signal check", role: serviceLabel("interview-service"), description: "Use interview signals when available to assess communication confidence.", execution: "service", service: "interview-service" },
+      { id: "qscore", title: "Confidence score", role: serviceLabel("qscore-service"), description: "Track negotiation confidence and communication readiness.", execution: "service", service: "qscore-service" },
+    ],
+    outputs: [
+      { id: "counteroffer_script", type: "markdown", title: "Counteroffer script" },
+      { id: "objection_map", type: "markdown", title: "Objection handling map" },
+    ],
+    qscoreDimensions: ["confidence", "value_evidence", "communication"],
+    approvalGates: [],
   },
   {
-    id: "promotion-readiness", version: "1.0.0", title: "Get Promoted", shortTitle: "Get Promoted", promise: "Build an evidence packet and manager conversation plan.", segment: ["employed"], urgency: "medium", estimatedDuration: "1 week", priceTier: "starter", sku: "workflow_promotion_readiness", isPurchasable: true, isFreePreview: true, visual: { icon: "trending-up", color: "purple", mascotAgentIds: ["roleplay", "qscore"] }, requiredInputs: commonInputs,
+    id: "promotion-readiness",
+    version: "2.0.0",
+    title: "Promotion & Leadership Readiness System",
+    shortTitle: "Promotion Readiness",
+    promise: "Help me become promotion-ready and make a strong case for my next level.",
+    segment: ["employed"],
+    urgency: "medium",
+    estimatedDuration: "1 week",
+    priceTier: "starter",
+    sku: "workflow_promotion_readiness",
+    isPurchasable: true,
+    isFreePreview: true,
+    visual: { icon: "trending-up", color: "purple", mascotAgentIds: ["roleplay", "resume", "interview", "qscore"] },
+    requiredInputs: commonInputs,
     modules: [
-      { id: "evidence-packet", title: "Evidence packet", role: planningLabel, description: "Generate promotion evidence packet.", execution: "opencode", promptPath: "prompts/workflows/promotion-readiness/orchestrator.md", artifactTypes: ["promotion_packet"] },
-      { id: "roleplay", title: "Manager conversation roleplay", role: serviceLabel("roleplay-service"), description: "Practice the promotion conversation.", execution: "service", service: "roleplay-service" },
-      { id: "branding", title: "Social branding", role: serviceLabel("social-branding-service"), description: "Showcase promotion-worthy impact on LinkedIn.", execution: "service", service: "social-branding-service" },
-      { id: "matchmaking", title: "Matchmaking", role: serviceLabel("matchmaking-service"), description: "Connect with senior leaders for sponsorship.", execution: "service", service: "matchmaking-service" },
-    ], outputs: [{ id: "promotion_packet", type: "markdown", title: "Promotion evidence packet" }], qscoreDimensions: ["impact", "leadership", "communication"], approvalGates: [],
+      { id: "promotion-context", title: "Promotion target", role: planningLabel, description: "Clarify desired level, timeline, stakeholders, and manager context.", execution: "manual" },
+      { id: "resume", title: "Achievement evidence packet", role: serviceLabel("resume-service"), description: "Extract impact bullets and leadership proof from resume history.", execution: "service", service: "resume-service" },
+      { id: "roleplay", title: "Manager conversation script", role: serviceLabel("roleplay-service"), description: "Practice the promotion conversation with objections and follow-ups.", execution: "service", service: "roleplay-service" },
+      { id: "interview", title: "Leadership gap practice", role: serviceLabel("interview-service"), description: "Practice leadership narratives and detect communication gaps.", execution: "service", service: "interview-service" },
+      { id: "qscore", title: "Leadership readiness score", role: serviceLabel("qscore-service"), description: "Track readiness and confidence trend.", execution: "service", service: "qscore-service" },
+    ],
+    outputs: [
+      { id: "promotion_packet", type: "markdown", title: "Promotion evidence packet" },
+      { id: "manager_script", type: "markdown", title: "Manager conversation script" },
+    ],
+    qscoreDimensions: ["impact", "leadership", "communication"],
+    approvalGates: [],
   },
   {
-    id: "personal-brand-opportunity-engine", version: "1.0.0", title: "Build Your Brand", shortTitle: "Build Your Brand", promise: "Draft profile positioning and a weekly opportunity/content plan.", segment: ["networking", "creators"], urgency: "low", estimatedDuration: "1 week", priceTier: "starter", sku: "workflow_brand_engine", isPurchasable: true, isFreePreview: true, visual: { icon: "sparkles", color: "pink", mascotAgentIds: ["qscore"] }, requiredInputs: commonInputs,
+    id: "personal-brand-opportunity-engine",
+    version: "2.0.0",
+    title: "Personal Brand & Opportunity Engine",
+    shortTitle: "Brand Engine",
+    promise: "Make me visible and credible so better opportunities come to me.",
+    segment: ["networking", "creators", "job-seekers"],
+    urgency: "low",
+    estimatedDuration: "1 week",
+    priceTier: "starter",
+    sku: "workflow_brand_engine",
+    isPurchasable: true,
+    isFreePreview: true,
+    visual: { icon: "sparkles", color: "pink", mascotAgentIds: ["resume", "roleplay", "qscore"] },
+    requiredInputs: commonInputs,
     modules: [
-      { id: "profile-rewrite", title: "Profile rewrite", role: planningLabel, description: "Generate LinkedIn/profile rewrite draft.", execution: "opencode", promptPath: "prompts/workflows/personal-brand-opportunity-engine/orchestrator.md", artifactTypes: ["profile_rewrite", "content_plan"] },
-      { id: "branding", title: "Social branding", role: serviceLabel("social-branding-service"), description: "Optimize profile and content strategy.", execution: "service", service: "social-branding-service" },
-      { id: "matchmaking", title: "Matchmaking", role: serviceLabel("matchmaking-service"), description: "Connect with collaborators and brand amplifiers.", execution: "service", service: "matchmaking-service" },
-    ], outputs: [{ id: "profile_rewrite", type: "markdown", title: "Profile rewrite" }, { id: "content_plan", type: "markdown", title: "Weekly content plan" }], qscoreDimensions: ["visibility", "network", "voice"], approvalGates: [],
+      { id: "positioning", title: "Positioning statement", role: planningLabel, description: "Clarify target audience, positioning, and credibility theme.", execution: "manual" },
+      { id: "resume", title: "Proof point extraction", role: serviceLabel("resume-service"), description: "Turn resume proof into brand themes and profile claims.", execution: "service", service: "resume-service" },
+      { id: "roleplay", title: "Networking scripts", role: serviceLabel("roleplay-service"), description: "Practice intros, outreach, and opportunity conversations.", execution: "service", service: "roleplay-service" },
+      { id: "interview", title: "Credibility signal mining", role: serviceLabel("interview-service"), description: "Use interview strengths and gaps as brand signal when available.", execution: "service", service: "interview-service" },
+      { id: "qscore", title: "Brand growth score", role: serviceLabel("qscore-service"), description: "Track visibility/readiness signals from practice and profile proof.", execution: "service", service: "qscore-service" },
+    ],
+    outputs: [
+      { id: "profile_rewrite", type: "markdown", title: "LinkedIn/profile rewrite" },
+      { id: "content_pillars", type: "markdown", title: "Content pillars" },
+      { id: "weekly_post_drafts", type: "markdown", title: "Weekly post drafts" },
+    ],
+    qscoreDimensions: ["visibility", "credibility", "voice"],
+    approvalGates: [],
   },
 ];