chatroom-cli 1.73.1 → 1.75.0

package/dist/index.js

@@ -2167,6 +2167,7 @@ __export(exports_stdin_heredoc, {
   findReservedDelimiterLines: () => findReservedDelimiterLines,
   HANDOFF_STDIN_DELIMITER: () => HANDOFF_STDIN_DELIMITER,
   HANDOFF_MESSAGE_MARKER: () => HANDOFF_MESSAGE_MARKER,
+  ENHANCER_STDIN_DELIMITER: () => ENHANCER_STDIN_DELIMITER,
   CONTEXT_STDIN_DELIMITER: () => CONTEXT_STDIN_DELIMITER,
   BACKLOG_STDIN_DELIMITER: () => BACKLOG_STDIN_DELIMITER,
   AGENTIC_QUERY_STDIN_DELIMITER: () => AGENTIC_QUERY_STDIN_DELIMITER
@@ -2205,13 +2206,14 @@ function findReservedDelimiterLines(content) {
   }
   return hits;
 }
-var HANDOFF_STDIN_DELIMITER = "CHATROOM_HANDOFF_END", CONTEXT_STDIN_DELIMITER = "CHATROOM_CONTEXT_END", BACKLOG_STDIN_DELIMITER = "CHATROOM_BACKLOG_END", AGENTIC_QUERY_STDIN_DELIMITER = "CHATROOM_AGENTIC_QUERY_END", CLASSIFY_STDIN_DELIMITER = "CHATROOM_CLASSIFY_END", HANDOFF_MESSAGE_MARKER = "---MESSAGE---", RESERVED_STDIN_HEREDOC_DELIMITERS, RESERVED_STRUCTURED_PARAM_MARKERS;
+var HANDOFF_STDIN_DELIMITER = "CHATROOM_HANDOFF_END", CONTEXT_STDIN_DELIMITER = "CHATROOM_CONTEXT_END", BACKLOG_STDIN_DELIMITER = "CHATROOM_BACKLOG_END", AGENTIC_QUERY_STDIN_DELIMITER = "CHATROOM_AGENTIC_QUERY_END", ENHANCER_STDIN_DELIMITER = "CHATROOM_ENHANCER_END", CLASSIFY_STDIN_DELIMITER = "CHATROOM_CLASSIFY_END", HANDOFF_MESSAGE_MARKER = "---MESSAGE---", RESERVED_STDIN_HEREDOC_DELIMITERS, RESERVED_STRUCTURED_PARAM_MARKERS;
 var init_stdin_heredoc = __esm(() => {
   RESERVED_STDIN_HEREDOC_DELIMITERS = [
     HANDOFF_STDIN_DELIMITER,
     CONTEXT_STDIN_DELIMITER,
     BACKLOG_STDIN_DELIMITER,
     AGENTIC_QUERY_STDIN_DELIMITER,
+    ENHANCER_STDIN_DELIMITER,
     CLASSIFY_STDIN_DELIMITER
   ];
   RESERVED_STRUCTURED_PARAM_MARKERS = [
@@ -9914,6 +9916,10 @@ var init_api2 = __esm(() => {
 });
 
 // src/api.ts
+var exports_api = {};
+__export(exports_api, {
+  api: () => api
+});
 var init_api3 = __esm(() => {
   init_api2();
 });
@@ -76368,6 +76374,24 @@ var init_register_agent = __esm(() => {
   init_services();
   init_convex_error();
 });
+
+// ../../services/backend/prompts/base/shared/context-rule.ts
+function getContextRuleBlock(contextNewCmd, contextHint) {
+  return `**Context Rule:** Set a new context for every user message by default — skip ONLY when the message is clearly a follow-up of the current chatroom task. **Before running \`context new\`, run \`context read\` — if the pinned context already uses the same \`--trigger-message-id\` as this task's Origin Message ID, do NOT create another context** (avoids duplicate timeline dividers). Only the entry point role can set contexts:
+\`\`\`bash
+${contextNewCmd}
+\`\`\`
+${contextHint}`;
+}
+
+// ../../services/backend/prompts/base/shared/token-activity-note.ts
+function getTokenActivityInProgressNote() {
+  return "Begin working from the task content above. The daemon detects harness output (stdout tokens) and marks the task `in_progress` automatically — **do not run `task read`** unless you need backlog items or context details not shown in the delivery.";
+}
+function getNativeTokenActivityInProgressNote() {
+  return "Begin working from the task content above. The daemon detects harness output (stdout tokens) and marks the task `in_progress` automatically.";
+}
+
 // ../../services/backend/prompts/cli/context/context-template.ts
 function getContextViewTemplate() {
   return CONTEXT_VIEW_TEMPLATE;
@@ -76386,20 +76410,60 @@ var CONTEXT_VIEW_TEMPLATE = `## Goal
 - _Out-of-scope work or anti-patterns to skip._`;
 
 // ../../services/backend/prompts/cli/context/view-template.ts
+function contextViewTemplateCommand(params) {
+  const prefix = params.cliEnvPrefix || "";
+  return `${prefix}chatroom context view-template`;
+}
 var init_view_template = () => {};
 
 // ../../services/backend/prompts/cli/context/new.ts
+function contextNewHint(params) {
+  const viewTemplateCmd = contextViewTemplateCommand({ cliEnvPrefix: params.cliEnvPrefix });
+  return `REQUIRED: All context content MUST conform to the template. Run \`${viewTemplateCmd}\` (no flags). \`--trigger-message-id\` must be the task's \`origin-message-id\` attribute (never \`task-id\`). Use the pre-filled value in the command above when provided.`;
+}
+function contextNewCommand(params) {
+  const prefix = params.cliEnvPrefix || "";
+  const chatroomId = params.chatroomId || "CHATROOM_ID";
+  const role = params.role || "ROLE";
+  const triggerMessageId = params.triggerMessageId ?? "ORIGIN_MESSAGE_ID";
+  const commandPrefix = `${prefix}chatroom context new --chatroom-id="${chatroomId}" --role="${role}" --trigger-message-id="${triggerMessageId}"`;
+  return formatStdinHeredocCommand(commandPrefix, CONTEXT_STDIN_DELIMITER, getContextViewTemplate());
+}
 var init_new = __esm(() => {
   init_stdin_heredoc();
   init_view_template();
 });
 
 // ../../services/backend/prompts/cli/task-started/main-prompt.ts
+function getTaskStartedPrompt(ctx) {
+  const { chatroomId, role, cliEnvPrefix, triggerMessageId } = ctx;
+  const contextNewCmd = contextNewCommand({
+    chatroomId,
+    role,
+    cliEnvPrefix,
+    triggerMessageId
+  });
+  return `### Start working
+
+${getTokenActivityInProgressNote()}
+
+${getContextRuleBlock(contextNewCmd, contextNewHint({ cliEnvPrefix }))}`;
+}
+function getTaskStartedPromptForHandoffRecipient(_ctx) {
+  return `### Start Working
+
+The task body contains your work description. ${getTokenActivityInProgressNote()}`;
+}
 var init_main_prompt = __esm(() => {
   init_new();
 });
 
 // ../../services/backend/prompts/cli/task-started/index.ts
+var exports_task_started = {};
+__export(exports_task_started, {
+  getTaskStartedPromptForHandoffRecipient: () => getTaskStartedPromptForHandoffRecipient,
+  getTaskStartedPrompt: () => getTaskStartedPrompt
+});
 var init_task_started = __esm(() => {
   init_main_prompt();
 });
@@ -76421,6 +76485,14 @@ Exactly one active waiter should own task delivery at a time. Additional or back
 
 After interruption or restart: complete any in-progress work, then restore a single foreground blocking \`get-next-task\` so chatroom tasks can arrive again.`;
 }
+function getCompactionRecoveryNote(params) {
+  const { cliEnvPrefix, chatroomId, role } = params;
+  return `NOTE: If you are an agent that has undergone compaction or summarization, run:
+  ${cliEnvPrefix}chatroom get-system-prompt --chatroom-id="${chatroomId}" --role="${role}"
+to reload your full system and role prompt. Then run:
+  ${cliEnvPrefix}chatroom context read --chatroom-id="${chatroomId}" --role="${role}"
+to see your current chatroom task context.`;
+}
 var init_reminder = () => {};
 // ../../services/backend/prompts/utils/index.ts
 var init_utils3 = __esm(() => {
@@ -76428,16 +76500,65 @@ var init_utils3 = __esm(() => {
 });
 
 // ../../services/backend/prompts/base/shared/getting-started-content.ts
+function getContextGainingGuidance(params) {
+  const { chatroomId, role, convexUrl, agentType } = params;
+  const cliEnvPrefix = getCliEnvPrefix(convexUrl);
+  const typeValue = agentType && agentType !== "unset" ? agentType : "<remote|custom>";
+  return `## Getting Started
+
+### Workflow Loop
+
+\`\`\`mermaid
+flowchart LR
+    A([Start]) --> B[register-agent]
+    B --> C[get-next-task
+chatroom task delivery]
+    C --> D[Do Work]
+    D --> E[handoff]
+    E --> C
+\`\`\`
+
+### Task delivery and activity
+
+When \`get-next-task\` delivers a chatroom task, the **full task content is included in the output**. ${getTokenActivityInProgressNote()}
+
+⚠️ Remember your two-level model: completing a **chatroom task** (Level B) does NOT end your **session** (Level A). After every handoff, you must run \`get-next-task\` again to continue the session.
+
+### Context Recovery (after compaction/summarization)
+
+${getCompactionRecoveryNote({ cliEnvPrefix, chatroomId, role })}
+
+CLI harnesses do not support in-session compaction. After context is lost, the daemon performs a hard restart — you must run \`get-next-task\` again to rejoin the chatroom.
+
+### Register Agent
+Register your agent type before starting work.
+
+\`\`\`bash
+${cliEnvPrefix}chatroom register-agent --chatroom-id="${chatroomId}" --role="${role}" --type=${typeValue}
+\`\`\`
+
+### Get Next Task
+Listen for incoming tasks assigned to your role. A foreground \`get-next-task\` blocks until the user or team message is ready, then resolves with that message as a chatroom task—infer intent from the message rather than following numbered next-steps blindly.
+
+\`\`\`bash
+${cliEnvPrefix}chatroom get-next-task --chatroom-id="${chatroomId}" --role="${role}"
+\`\`\`
+
+**This loop never ends.** A session (Level A) processes many chatroom tasks (Level B). Each handoff completes Level B — \`get-next-task\` continues Level A. Do not stop or exit after a handoff.
+`;
+}
 var init_getting_started_content = __esm(() => {
   init_reminder();
   init_utils3();
 });
 
 // ../../services/backend/prompts/cli/index.ts
+var getTaskStartedPrompt2, getTaskStartedPromptForHandoffRecipient2;
 var init_cli = __esm(() => {
   init_task_started();
   init_reminder();
   init_getting_started_content();
+  ({ getTaskStartedPrompt: getTaskStartedPrompt2, getTaskStartedPromptForHandoffRecipient: getTaskStartedPromptForHandoffRecipient2 } = exports_task_started);
 });
 
 // src/commands/get-next-task/get-next-task-session-service.ts
@@ -77736,6 +77857,24 @@ function formatDecodeError(error) {
 }
 
 // ../../services/backend/prompts/native/session-continuity.ts
+function getSessionContinuityLine(nativeIntegration) {
+  if (nativeIntegration) {
+    return "";
+  }
+  return "Completing a **chatroom task** (Level B) does NOT end your **session** (Level A). After every handoff, run `get-next-task` to continue.";
+}
+function getHandoffContinuityRule(nativeIntegration) {
+  if (nativeIntegration) {
+    return "";
+  }
+  return "⚠️ After ANY handoff (including to `user`), you must run `get-next-task` to stay in the session.";
+}
+function getOperatingModelLoopFooter(nativeIntegration) {
+  return nativeIntegration ? "Hand off when complete" : "Run get-next-task";
+}
+function getNativePlannerDelegationWaitNote() {
+  return `After delegating to the builder, **run handoff as your last action and end your turn** — no further tool calls after handoff. The system delivers their handback when they finish — do not poll \`messages list\`, sleep, or run other tools while waiting.`;
+}
 function getNativeHandoffTurnEndGuidance(nextRole) {
   const lines = [
     "",
@@ -77751,10 +77890,103 @@ function getNativeHandoffTurnEndGuidance(nextRole) {
 }
 
 // ../../services/backend/prompts/cli/handoff/command.ts
+function handoffCommand(params) {
+  const prefix = params.cliEnvPrefix || "";
+  const chatroomId = params.chatroomId || "<chatroom-id>";
+  const role = params.role || "<role>";
+  const nextRole = params.nextRole || "<target>";
+  const placeholder = params.messagePlaceholder ?? "[Your message here]";
+  const commandPrefix = `${prefix}chatroom handoff --chatroom-id="${chatroomId}" --role="${role}" --next-role="${nextRole}"`;
+  return formatStdinHeredocCommand(commandPrefix, HANDOFF_STDIN_DELIMITER, placeholder, {
+    messageMarker: HANDOFF_MESSAGE_MARKER
+  });
+}
 var init_command2 = __esm(() => {
   init_stdin_heredoc();
 });
+
+// ../../services/backend/prompts/types/sections.ts
+function createSection(id3, type, content) {
+  return { id: id3, type, content };
+}
+function composeSections(sections) {
+  return sections.filter((s) => s.content.trim()).map((s) => s.content).join(`
+
+`).trim();
+}
+
 // ../../services/backend/prompts/sections/commands-reference.ts
+function getCommandsReferenceSection(params) {
+  const cliEnvPrefix = getCliEnvPrefix(params.convexUrl);
+  const handoffCmd = handoffCommand({
+    chatroomId: params.chatroomId,
+    role: params.role,
+    nextRole: "<target>",
+    cliEnvPrefix
+  });
+  const waitCmd = getNextTaskCommand({
+    chatroomId: params.chatroomId,
+    role: params.role,
+    cliEnvPrefix
+  });
+  const content = `### Commands
+
+**Complete chatroom task and hand off:**
+
+\`\`\`bash
+${handoffCmd}
+\`\`\`
+
+${HANDOFF_BODY_GUIDANCE}
+
+**Continue receiving messages after \`handoff\`:**
+\`\`\`
+${waitCmd}
+\`\`\`
+
+${getNextTaskReminder()}
+
+**Reference commands:**
+- List recent messages: \`${cliEnvPrefix}chatroom messages list --chatroom-id="${params.chatroomId}" --role="${params.role}" --sender-role=user --limit=5 --full\`
+- Git log: \`git log --oneline -10\`
+
+**Recovery commands** (only needed after compaction/restart):
+- Reload system prompt: \`${cliEnvPrefix}chatroom get-system-prompt --chatroom-id="${params.chatroomId}" --role="${params.role}"\`
+- Reload role guidance: \`${roleGuidanceCommand({ chatroomId: params.chatroomId, role: params.role, cliEnvPrefix })}\`
+- Read current chatroom task context: \`${cliEnvPrefix}chatroom context read --chatroom-id="${params.chatroomId}" --role="${params.role}"\``;
+  return createSection("commands-reference", "knowledge", content);
+}
+function getNativeCommandsReferenceSection(params) {
+  const cliEnvPrefix = getCliEnvPrefix(params.convexUrl);
+  const handoffCmd = handoffCommand({
+    chatroomId: params.chatroomId,
+    role: params.role,
+    nextRole: "<target>",
+    cliEnvPrefix
+  });
+  const content = `### Commands
+
+**Complete chatroom task and hand off:**
+
+\`\`\`bash
+${handoffCmd}
+\`\`\`
+
+${HANDOFF_BODY_GUIDANCE}
+
+**Do not run \`register-agent\`** — your session was registered when the harness started.
+
+**Reference commands:**
+- List recent messages: \`${cliEnvPrefix}chatroom messages list --chatroom-id="${params.chatroomId}" --role="${params.role}" --sender-role=user --limit=5 --full\`
+- Git log: \`git log --oneline -10\`
+
+**Recovery commands** (only needed after compaction/restart):
+- Reload system prompt: \`${cliEnvPrefix}chatroom get-system-prompt --chatroom-id="${params.chatroomId}" --role="${params.role}"\`
+- Reload role guidance: \`${roleGuidanceCommand({ chatroomId: params.chatroomId, role: params.role, cliEnvPrefix })}\`
+- Read current chatroom task context: \`${cliEnvPrefix}chatroom context read --chatroom-id="${params.chatroomId}" --role="${params.role}"\``;
+  return createSection("commands-reference-native", "knowledge", content);
+}
+var HANDOFF_BODY_GUIDANCE = `Fill in the message using the matching template from \`<handoff-templates>\` in your task delivery output. Replace \`[Your message here]\` with that template content. The closing line must be exactly \`CHATROOM_HANDOFF_END\` (not \`EOF\`).`;
 var init_commands_reference = __esm(() => {
   init_command();
   init_reminder();
@@ -77763,25 +77995,650 @@ var init_commands_reference = __esm(() => {
 });
 
 // ../../services/backend/prompts/cli/backlog/command.ts
+function backlogAddCommand(params) {
+  const prefix = params.cliEnvPrefix || "";
+  const chatroomId = params.chatroomId || "<id>";
+  const role = params.role || "<role>";
+  const placeholder = params.contentPlaceholder ?? "Your backlog item content here";
+  const commandPrefix = `${prefix}chatroom backlog add --chatroom-id=${chatroomId} --role=${role}`;
+  return formatStdinHeredocCommand(commandPrefix, BACKLOG_STDIN_DELIMITER, placeholder);
+}
+function backlogUpdateCommand(params) {
+  const prefix = params.cliEnvPrefix || "";
+  const chatroomId = params.chatroomId || "<id>";
+  const role = params.role || "<role>";
+  const backlogItemId = params.backlogItemId || "<id>";
+  const placeholder = params.contentPlaceholder ?? "New content here";
+  const commandPrefix = `${prefix}chatroom backlog update --chatroom-id=${chatroomId} --role=${role} --backlog-item-id=${backlogItemId}`;
+  return formatStdinHeredocCommand(commandPrefix, BACKLOG_STDIN_DELIMITER, placeholder);
+}
 var init_command3 = __esm(() => {
   init_stdin_heredoc();
 });
 
 // ../../services/backend/src/domain/usecase/skills/modules/backlog/index.ts
+var backlogSkill;
 var init_backlog = __esm(() => {
   init_command3();
+  backlogSkill = {
+    skillId: "backlog",
+    name: "Backlog Reference",
+    description: "Full backlog command reference: list/add/update, scoring, completion, close, export/import, and workflow guides.",
+    getPrompt: (cliEnvPrefix) => `You have been activated with the "backlog" skill.
+
+## Command Reference
+
+### List
+\`\`\`
+${cliEnvPrefix}chatroom backlog list --chatroom-id=<id> --role=<role>
+\`\`\`
+Options: \`--limit=<n>\`, \`--sort=date:desc|priority:desc\`, \`--filter=unscored\` (only items without a priority score)
+
+The list output shows scoring info (complexity, value, priority) for each item if it has been scored.
+
+### History
+\`\`\`
+${cliEnvPrefix}chatroom backlog history --chatroom-id=<id> --role=<role>
+\`\`\`
+Options: \`--from=YYYY-MM-DD\`, \`--to=YYYY-MM-DD\`, \`--limit=<n>\`
+
+Defaults: last 30 days through today; shows completed and closed tasks in range.
+
+Use \`history\` for finished work; use \`list\` for active backlog items.
+
+### Add
+Content via **stdin / heredoc** or \`--content-file\`:
+
+\`\`\`
+${backlogAddCommand({ cliEnvPrefix })}
+\`\`\`
+
+\`\`\`
+${cliEnvPrefix}chatroom backlog add --chatroom-id=<id> --role=<role> --content-file=./task.md
+\`\`\`
+
+### Update
+Replace the **text content** of an existing item. Allowed only while the item is in \`backlog\` status. Same input pattern as **add** (stdin/heredoc or \`--content-file\`).
+
+\`\`\`
+${backlogUpdateCommand({ cliEnvPrefix })}
+\`\`\`
+
+\`\`\`
+${cliEnvPrefix}chatroom backlog update --chatroom-id=<id> --role=<role> --backlog-item-id=<id> --content-file=./revised.md
+\`\`\`
+
+Use **update** to revise a description in place instead of adding a superseding item.
+
+### Score
+**Requires at least one** of \`--complexity\`, \`--value\`, or \`--priority\` (you can combine multiple).
+
+\`\`\`
+${cliEnvPrefix}chatroom backlog score --chatroom-id=<id> --role=<role> --backlog-item-id=<id> \\
+  [--complexity=<low|medium|high>] \\
+  [--value=<low|medium|high>] \\
+  [--priority=<n>]
+\`\`\`
+
+\`--priority\` must be an integer (higher = more important). There is no enforced max in the CLI.
+
+**Important**: Only score items that do not already have all three fields set (complexity, value, priority).
+Check the list output — items showing "Score: ..." are already scored. Skip them to avoid overwriting.
+
+### Complete
+\`\`\`
+${cliEnvPrefix}chatroom backlog complete --chatroom-id=<id> --role=<role> --backlog-item-id=<id> [-f|--force]
+\`\`\`
+
+Optional \`-f\` / \`--force\` is a registered flag (see \`chatroom backlog complete --help\`). It is **not** forwarded to the Convex mutation yet, so it does not change server behavior today; omit it unless your runbook says otherwise.
+
+### Reopen
+\`\`\`
+${cliEnvPrefix}chatroom backlog reopen --chatroom-id=<id> --role=<role> --backlog-item-id=<id>
+\`\`\`
+
+### Mark for Review
+\`\`\`
+${cliEnvPrefix}chatroom backlog mark-for-review --chatroom-id=<id> --role=<role> --backlog-item-id=<id>
+\`\`\`
+
+### Export
+\`\`\`
+${cliEnvPrefix}chatroom backlog export --chatroom-id=<id> --role=<role> [--path=<directory>]
+\`\`\`
+Exports all backlog items (status=\`backlog\`) to a \`backlog-export.json\` file in the specified directory.
+Creates the directory if it doesn't exist.
+Default path (if \`--path\` is omitted): \`<cwd>/.chatroom/exports/\`
+
+### Import
+\`\`\`
+${cliEnvPrefix}chatroom backlog import --chatroom-id=<id> --role=<role> [--path=<directory>]
+\`\`\`
+Imports backlog items from a \`backlog-export.json\` file in the specified directory.
+- **Idempotent**: skips items whose content already exists (matched by SHA-256 content hash)
+- **Staleness warning**: warns if the export is older than 7 days
+Default path (if \`--path\` is omitted): \`<cwd>/.chatroom/exports/\`
+
+### Close
+Retires an item as stale, superseded, or duplicate. **\`--reason\` is required** (audit trail).
+
+\`\`\`
+${cliEnvPrefix}chatroom backlog close --chatroom-id=<id> --role=<role> --backlog-item-id=<id> --reason="duplicate of XYZ"
+\`\`\`
+
+⚠️ **RESTRICTED: Only use when the user explicitly asks you to close an item.**
+Agents must NEVER close backlog items autonomously. If an item looks stale or already implemented, prefer \`mark-for-review\` so the user decides.
+
+Give a concise, factual reason (e.g. \`User confirmed: shipped in PR #119\`).
+
+---
+
+## Lifecycle
+
+Backlog items move through explicit statuses. **When you raise a PR for user review, use \`mark-for-review\` — not \`complete\`.** Only mark \`complete\` after the PR is merged and verified (or the user confirms).
+
+\`\`\`mermaid
+stateDiagram-v2
+    [*] --> backlog: user creates
+    backlog --> pending_user_review: agent raises PR (mark-for-review)
+    pending_user_review --> closed: user confirms / PR merged (complete)
+    backlog --> closed: stale/superseded (close)
+    closed --> backlog: reopen
+\`\`\`
+
+### Command decision table
+
+| Situation | Command |
+|-----------|---------|
+| Fix PR opened, awaiting user review/merge | \`mark-for-review\` |
+| PR merged and verified | \`complete\` |
+| Stale/duplicate/won't fix | \`close --reason=...\` |
+| Mistakenly completed early | \`reopen\` then \`mark-for-review\` |
+
+Reference: \`docs/plans/backlog-item-lifecycle-and-attachments.md\`
+
+---
+
+## Workflows
+
+### 1. Score Unscored Items
+
+\`\`\`mermaid
+flowchart TD
+  A([Start]) --> B[List backlog items]
+  B --> C{Any unscored?}
+  C -->|No| D([Done])
+  C -->|Yes| E["Check item: does it already have complexity + value + priority set?"]
+  E -->|Already scored| F[Skip — do not overwrite existing score]
+  F --> C
+  E -->|Not scored| G[Score item: complexity, value, priority]
+  G --> C
+\`\`\`
+
+An item is "already scored" if the list output shows "Score: complexity=... | value=... | priority=...".
+
+### 2. After Completing a Backlog Task (PR raised)
+
+\`\`\`mermaid
+flowchart TD
+  A([Implementation complete]) --> B[Open PR for user review]
+  B --> C["mark-for-review (NOT complete)"]
+  C --> D[Hand off to user with PR link + summary]
+  D --> E([User reviews in Pending Review section])
+\`\`\`
+
+Moves item to \`pending_user_review\`. User confirms completion (\`complete\`) or sends back for rework (\`reopen\`).
+
+### 3. Continuous Backlog Execution
+
+Only activate when the user explicitly instructs autonomous execution
+(e.g. "work through the backlog", "autonomously implement backlog items").
+
+\`\`\`mermaid
+flowchart TD
+  A([Start]) --> B[List all backlog items]
+  B --> C{Any unscored?}
+  C -->|Yes| D["Score only items missing complexity/value/priority\\n(skip already-scored items)"] --> E[Re-list]
+  C -->|No| E
+  E --> F["Select items: complexity=low AND value=high"]
+  F --> G{Qualifying items?}
+  G -->|No| H([Hand off — no high-ROI items found])
+  G -->|Yes| I[Take next item]
+  I --> J{Already implemented?\\nCheck codebase / recent commits}
+  J -->|Yes — stale| K["Mark for review\\n(note: already implemented)"]
+  J -->|No| L[Implement: code changes + PR]
+  L --> K
+  K --> M[Mark item for review]
+  M --> N{More items?}
+  N -->|Yes| I
+  N -->|No| O[Hand off to user with full summary]
+  O --> P([Done])
+\`\`\`
+
+Stale item = backlog task already present in the codebase. Mark immediately; skip implementation.
+ROI = low complexity × high value.
+
+### 4. Backlog Cleanup
+
+Follow these steps to clean up the backlog by identifying and closing stale items.
+
+1. List all backlog items:
+   \`\`\`
+   ${cliEnvPrefix}chatroom backlog list --chatroom-id=<id> --role=<role>
+   \`\`\`
+
+2. For each item, assess staleness:
+   - Read the content carefully
+   - If the item is still valid but the **wording is wrong**, use \`backlog update\` to fix the description in place (do not add a duplicate item)
+   - Check if already implemented (look at recent commits, PRs, or existing code)
+   - Check if superseded by a newer backlog item
+
+3. For stale items, mark for review:
+   \`\`\`
+   ${cliEnvPrefix}chatroom backlog mark-for-review --chatroom-id=<id> --role=<role> --backlog-item-id=<item-id>
+   \`\`\`
+   **Important:** Always mark for review — do NOT close directly. Let the user confirm.
+
+4. If you are the coordinator, delegate assessment to workers:
+   - Builder checks codebase to determine if items are stale
+   - Builder marks stale items for review and reports back
+
+5. Report summary: items reviewed, marked for review, kept, needs clarification
+
+### 5. Export / Import Backlog
+
+Use export/import to transfer backlog items between workspaces or for backup.
+Default path: \`<cwd>/.chatroom/exports/\` — omit \`--path\` to use this.
+
+**Export workflow:**
+\`\`\`mermaid
+flowchart TD
+  A([Start]) --> B["Export backlog"]
+  B --> C["chatroom backlog export\\n(writes to <cwd>/.chatroom/exports/ by default)"]
+  C --> D["File written: backlog-export.json"]
+  D --> E([Done — report file path to user])
+\`\`\`
+
+**Import workflow:**
+\`\`\`mermaid
+flowchart TD
+  A([Start]) --> B["Import backlog"]
+  B --> C["chatroom backlog import\\n(reads from <cwd>/.chatroom/exports/ by default)"]
+  C --> D{Staleness warning?}
+  D -->|Yes — export > 7 days old| E["Warn user: export may be stale"]
+  D -->|No| F["Import items (skip duplicates)"]
+  E --> F
+  F --> G["Report: total / imported / skipped"]
+  G --> H([Done])
+\`\`\`
+
+**Key points:**
+- Default path is \`<cwd>/.chatroom/exports/\` — no \`--path\` needed for standard usage
+- Use \`--path=<dir>\` to override with a custom directory
+- Imports are idempotent — running import twice with the same file won't create duplicates
+- Each item is identified by a SHA-256 hash of its content`
+  };
 });
 
 // ../../services/backend/src/domain/usecase/skills/modules/code-review/index.ts
-var init_code_review = () => {};
+var codeReviewSkill;
+var init_code_review = __esm(() => {
+  codeReviewSkill = {
+    skillId: "code-review",
+    name: "Code Review",
+    description: "Use this skill when reviewing, auditing, or giving feedback on code. Covers ten pillars: simplification, type drift, duplication, design patterns, security, test quality, ownership/observability, dead code elimination, incomplete implementations, and hallucinated content.",
+    getPrompt: (_cliEnvPrefix) => `You have been activated with the "code-review" skill.
+
+# AI Code Review — Tech Debt Prevention
+
+You are reviewing code that was fully or partially generated by an AI tool. Your job is not
+just to check if it works — working code is the floor, not the ceiling. Your job is to assess
+whether it is maintainable, secure, and coherent with the broader codebase.
+
+AI code is highly functional but architecturally blind. It implements the prompt without
+considering existing patterns, refactoring opportunities, or long-term cost. Research from
+2025–2026 shows AI code carries 1.75x more logic errors, 1.64x more maintainability issues,
+and 1.57x more security findings than human-written code (CodeRabbit, 2025). 66% of developers
+report spending more time fixing AI output than it saved (Stack Overflow, 2026).
+
+Apply the ten pillars below in priority order.
+
+---
+
+## How to run a review
+
+1. Read the code in full before making any comments — do not flag issues as you scan
+2. Apply each pillar in order; stop and note findings as you go
+3. Classify each finding as BLOCK (must fix before merge) or FLAG (must be addressed by author)
+4. Summarise findings at the end using the output template below
+5. If the PR is over ~300 lines of net-new AI code, recommend decomposition before review
+
+---
+
+## Pillar 1 — Simplification (Highest Priority)
+
+AI generates more code than needed. The average developer checked in 75% more code in 2025
+than in 2022 — volume that the team now has to maintain. AI agents never suggest refactoring,
+so complexity accumulates silently.
+
+Look for:
+- Functions over ~40 lines or classes over ~200 lines with no clear single responsibility
+- Monolithic architecture: 40–50% of AI code defaults to tightly-coupled structures that
+  reverse a decade of modular progress (OX Security, 2025)
+- Phantom Bugs: logic handling highly improbable edge cases, adding complexity with no benefit
+  (found in 20–30% of AI code)
+- Dead code, unused imports, or leftover scaffolding from generation
+- PRs that touch services, libraries, infrastructure, and tests in a single change
+
+Ask: Is there a simpler path to the same outcome? Would a new team member understand this
+without help? Can this function be split without losing meaning?
+
+Action: Flag any function over ~40 lines. Require decomposition or written justification
+before merge.
+
+---
+
+## Pillar 2 — Type Drift (High Priority)
+
+AI generates code in isolation from the broader type system. Type inconsistencies introduced
+here surface later as null pointer exceptions, silent failures, and cross-service contract
+mismatches. A University of Naples study of 500k+ samples (Aug 2025) confirmed these are the
+most reliably catchable issues via static analysis — meaning they should never reach review.
+
+Look for:
+- \`any\` usage: defeats TypeScript entirely; AI reaches for it when uncertain
+- Unsafe \`as\` assertions: suppresses the compiler rather than satisfying it
+- Missing \`strictNullChecks\` compliance — null/undefined slipping through unchecked
+- Boundary drift: API endpoints returning different shapes across execution paths
+- Configuration drift: divergent \`tsconfig\` settings or ESLint rules added incrementally
+- Leaked internals: AI exposing implementation details that should be encapsulated
+
+Ask: Are all return types and parameters explicitly typed? Are API contract types shared and
+stable? Does this match existing type conventions, or introduce a new pattern?
+
+Action: \`strict: true\` in \`tsconfig.json\` is a hard gate. Any PR disabling strict settings
+requires explicit team sign-off.
+
+---
+
+## Pillar 3 — Duplication (High Priority)
+
+GitClear's 2025 analysis of 211 million changed lines found duplicated code blocks grew 8x
+in one year, and copy/pasted code surpassed refactored code for the first time in history.
+OX Security found "Bugs Déjà-Vu" in 70–80% of AI codebases: identical bugs recurring in
+multiple locations because logic was never abstracted.
+
+Look for:
+- Duplicate utility logic across files — each instance works, but no shared abstraction exists
+- "Vanilla Style" rebuilds: AI reconstructing functionality from scratch instead of using
+  existing libraries, SDKs, or internal utilities (40–50% of AI code, OX Security)
+- Duplicated validation, auth checks, and input sanitization
+- Copy-pasted try/catch blocks instead of centralised error handling
+- New dependencies that the existing codebase already covers
+
+Ask: Does an equivalent utility already exist? Is this logic duplicated anywhere else?
+Use AST-level search, not just grep.
+
+Action: Require a codebase search before approving any new utility function. Run SonarQube,
+CodeClimate, or Codacy as a PR gate for duplication thresholds.
+
+---
+
+## Pillar 4 — Design Pattern Compliance (Standard Priority)
+
+AI implements the prompt. It does not check the ADR log, existing service patterns, or
+architectural conventions. OX Security identified "By-The-Book Fixation" in 80–90% of AI
+code: rigid application of generic best practices, missing the better solution for this
+specific context.
+
+Look for:
+- Pattern violations: raw \`fetch\` where an API service layer exists; new state patterns where
+  a store convention is already established
+- SOLID violations:
+  - Single Responsibility: see Pillar 1
+  - Open/Closed: code requiring modification rather than extension to add new behaviour
+  - Dependency Inversion: hard-coded dependencies instead of injection
+- No refactoring suggestions — AI never proposes that a feature should trigger a refactor
+- Context blindness: ignoring ADRs, versioning strategy, or team-level conventions
+
+Ask: Does this follow the patterns in this area of the codebase? Can this be extended without
+modification? Are dependencies injected?
+
+Action: Maintain a living \`ARCHITECTURE.md\` or ADR log. Pass it as context to AI tools before
+generation, not after.
+
+---
+
+## Pillar 5 — Security (Standard Priority)
+
+45% of AI-generated code samples introduced OWASP Top 10 vulnerabilities in Veracode's 2025
+test of 100+ LLMs. CodeRabbit found AI code is 2.74x more likely to introduce XSS, 1.88x more
+likely to mishandle passwords, 1.82x more likely to implement insecure deserialization.
+OX Security calls this "insecure by dumbness" — not malicious, but structurally blind to
+security requirements that were not in the prompt.
+
+Look for:
+- OWASP Top 10: injection (SQL, XSS, command), broken auth, insecure deserialization
+- "Worked on My Machine" syndrome (60–70% of AI code): missing environment awareness,
+  hard-coded localhost references, assumed-present secrets
+- Missing auth/ownership checks — AI assumes the happy path; role gates rarely appear unprompted
+- Secrets, tokens, or credentials in source code
+- Deprecated API patterns from the model's training data
+- Excessive I/O (~8x human rate) and concurrency misuse (~2x human rate)
+
+Ask: Are all inputs validated before use? Are auth checks present at every trust boundary?
+Does this code behave differently across environments?
+
+Action: Run SAST tooling (Snyk, Semgrep, SonarQube) on every AI-generated PR as a CI gate.
+Manual review alone cannot keep pace with AI generation velocity.
+
+---
+
+## Pillar 6 — Test Quality (Standard Priority)
+
+AI generates tests that look comprehensive but frequently are not. OX Security found "Fake
+Test Coverage" in 40–50% of AI codebases: inflated metrics, low signal. The failure mode is
+precise: AI tests its own assumptions, not the developer's intent. University of Naples (2025)
+confirmed that even code passing all functional benchmarks averaged 1.45–1.77 static issues
+per task.
+
+Look for:
+- Tests that verify AI output is stable, not that it is correct by domain rules
+- Missing edge cases: empty inputs, boundary values, null handling, race conditions,
+  business-rule violations
+- Coverage theater: tests that assert no exception was thrown and nothing more
+- No integration or contract tests — AI generates unit tests almost exclusively
+- Tests coupled to implementation: must be updated every time the code changes
+
+Ask: Do these tests verify the domain intent? Would they catch a logic regression in the
+next PR? Are cross-service interactions tested?
+
+Action: Test review is a separate pass from code review. Use mutation testing (Stryker,
+PITest) to validate whether tests catch real defects — coverage percentage is not sufficient.
+
+---
+
+## Pillar 7 — Ownership, Observability, Deployment (Standard Priority)
+
+The most consistently missed category. ISACA's 2026 incident review found that the biggest
+AI failures of 2025 were organisational, not technical: weak controls and unclear ownership.
+Bright Security (2026) identified unclear ownership as one of the most dangerous patterns:
+code that works well enough that no one feels responsible for it. IBM's 2025 breach data found
+shadow AI added $670,000 average to breach costs.
+
+Look for:
+- No named human owner — every AI-generated module needs someone who can explain it in a
+  postmortem without reading it fresh
+- Missing structured logs, metrics emission, or tracing hooks
+- Swallowed exceptions: retry logic with no alerting; fallback paths invisible to operators
+- No environment-specific configuration, secrets management, or health check endpoints
+- Model versioning chaos: inconsistencies from team members using different AI tool versions
+- Shadow AI: code with no record of which tool or prompt produced it
+
+Ask: Who owns this? Will production failures surface to operators? Does this behave
+differently across environments?
+
+Action: Require every AI-generated module to have a named owner in CODEOWNERS. Add logging
+requirements to the PR template. Establish a team AI governance policy that tracks tools
+and model versions — treat this like any other dependency.
+
+---
+
+## Pillar 8 — Dead Code Elimination (Standard Priority)
+
+AI generates code speculatively. It adds helper functions "just in case", creates abstractions
+for paths that never materialise, and leaves behind scaffolding from earlier generation
+attempts. GitClear's 2025 data showed a 75% increase in total code volume, much of it never
+executed. Dead code is not harmless — it misleads future readers, inflates bundle sizes, creates
+false positive search results, and adds surface area for bugs and security vulnerabilities
+in code that serves no purpose.
+
+Look for:
+- Unreachable code: functions, methods, or branches that no call site ever invokes
+- Unused imports: modules imported but never referenced — common in AI-generated files
+- Commented-out code: old implementations left inline instead of being removed; version
+  control already preserves history
+- Feature flags that are permanently off: conditional paths that were never enabled or have
+  been superseded but not cleaned up
+- Orphaned configuration: environment variables, constants, or config entries with no consumer
+- Stale types and interfaces: type definitions for data shapes that no longer exist in the
+  system
+- Unused dependencies: packages listed in \`package.json\` (or equivalent) that no source file
+  imports
+- Vestigial error handling: catch blocks or fallback paths for conditions that can no longer
+  occur due to upstream changes
+- Test helpers and fixtures for tests that have been deleted
+
+Ask: Is every function called? Is every import used? Is every dependency exercised?
+Would removing this code change any observable behaviour?
+
+Action: Run tree-shaking analysis and dead code detection tools (e.g., \`ts-prune\`,
+\`knip\`, \`depcheck\`, IDE unused-symbol highlighting) as part of CI. Treat dead code
+the same as duplication — it compounds over time and must be actively managed.
+
+---
+
+## Pillar 9 — Incomplete Implementations (Standard Priority)
+
+AI tools often leave TODOs, stubs, "throw new Error('not implemented')", or placeholder
+returns when they hit uncertainty. The default assumption MUST be that these are bugs to fix,
+not features — unless the human explicitly requested a stub (e.g., scaffolding a future module).
+
+Look for:
+- \`TODO\`, \`FIXME\`, \`XXX\`, \`HACK\` comments — especially without an assignee or ticket reference
+- Functions that throw "not implemented" / "unimplemented" errors
+- Empty function bodies or bodies that only return null/undefined/empty object as a placeholder
+- Switch/case branches with \`// handle later\` style comments
+- Conditional branches that silently fall through without handling a real case
+- Type definitions with fields marked \`any\` or \`unknown\` "to be refined later"
+- Tests with \`it.skip\`, \`xit\`, \`it.todo\` left in committed code without justification
+
+Ask: Is every code path fully implemented? If a TODO exists, is there a tracked ticket and
+explicit reason it wasn't done now?
+
+Action: Treat any TODO or stub as BLOCK unless the PR description or commit message explicitly
+justifies it (e.g., "scaffolding for follow-up PR #N"). Generated code with unprompted TODOs
+should be completed before merge, not after.
+
+---
+
+## Pillar 10 — Hallucinated Content & Magic Strings (Standard Priority)
+
+AI generation frequently invents plausible-looking but incorrect values — API endpoints,
+env var names, library functions, config keys — and scatters magic strings/numbers across
+the codebase instead of consolidating them as named constants. Both fail at runtime or rot
+the codebase over time.
+
+Look for:
+- Fabricated API endpoints, library functions, or package names that don't exist (verify against
+  actual SDK docs / \`package.json\`)
+- Magic strings: status codes, role names, event types, feature flag keys appearing as inline
+  literals across multiple files
+- Magic numbers: timeouts, limits, retry counts, port numbers without named constants
+- Placeholder content left in production paths: "lorem ipsum", "foo/bar", "example.com",
+  "test@test.com"
+- Hardcoded URLs, file paths, or table/collection names that should come from config
+- Duplicated string literals that should be a single enum / const object
+- Configuration keys invented by the AI that don't match the project's actual config schema
+
+Ask: Does every literal that carries domain meaning have a named home? Is every external
+reference (API, package, env var) verified to exist? Where SHOULD this constant live (entity
+enum, config module, shared constants file)?
+
+Action: Consolidate magic literals into the canonical location for the codebase (typically
+enums alongside the relevant entity, or a dedicated constants module). For hallucinated
+references, treat as BLOCK — code that compiles against fictional APIs will fail in production.
+
+---
+
+## Output template
+
+Use this format for every review. Do not skip sections.
+
+\`\`\`
+## AI Code Review — [filename or PR title]
+
+### Summary
+[2–3 sentences: overall quality signal, highest-risk area, recommended action]
+
+### BLOCK — must fix before merge
+[List findings. Format: PILLAR | finding | why it matters | suggested fix]
+
+### FLAG — author must respond
+[List findings. Same format.]
+
+### Passed
+[Pillars or areas with no significant findings]
+
+### Recommendation
+[ ] Approve  [ ] Approve with flags addressed  [ ] Decompose PR first  [ ] Reject — rework required
+\`\`\``
+  };
+});
 
 // ../../services/backend/src/domain/usecase/skills/registry.ts
+var SKILLS_REGISTRY;
 var init_registry3 = __esm(() => {
   init_backlog();
   init_code_review();
+  SKILLS_REGISTRY = [backlogSkill, codeReviewSkill];
 });
 
 // ../../services/backend/prompts/sections/glossary.ts
+function formatGlossaryEntry(entry) {
+  const skillNote = entry.linkedSkillId ? " (1 skill available)" : "";
+  return [`- \`${entry.term}\`${skillNote}`, `    - ${entry.definition}`, ""];
+}
+function buildSkillsSection(cliEnvPrefix) {
+  const lines = ["# Skills", ""];
+  lines.push(`Run \`${cliEnvPrefix}chatroom skill list --chatroom-id=<id> --role=<role>\` to list all available skills.`);
+  lines.push("");
+  lines.push("## When to Activate Skills");
+  lines.push("");
+  lines.push("**Proactively activate skills** when your task matches their purpose:");
+  for (const skill of SKILLS_REGISTRY) {
+    lines.push(`- **${skill.skillId}**: ${skill.description}`);
+  }
+  lines.push("");
+  lines.push("Don't wait for the user to ask — proactively activate the skill that matches the task.");
+  return lines;
+}
+function getGlossarySection(params) {
+  const cliEnvPrefix = getCliEnvPrefix(params.convexUrl);
+  const lines = ["# Glossary", ""];
+  const terms = params.nativeIntegration ? NATIVE_GLOSSARY_TERMS : GLOSSARY_TERMS;
+  for (const entry of terms) {
+    lines.push(...formatGlossaryEntry(entry));
+  }
+  if (params.compactSkills) {
+    lines.push("# Skills", "");
+    lines.push(`Run \`${cliEnvPrefix}chatroom skill list --chatroom-id=<id> --role=<role>\` to list available skills. Activate skills proactively when your task matches their purpose.`);
+  } else {
+    lines.push(...buildSkillsSection(cliEnvPrefix));
+  }
+  return createSection("glossary", "knowledge", lines.join(`
+`));
+}
 var GLOSSARY_TERMS, NATIVE_GLOSSARY_TERMS;
 var init_glossary = __esm(() => {
   init_registry3();
@@ -77832,10 +78689,249 @@ var init_glossary = __esm(() => {
 });
 
 // ../../services/backend/prompts/cli/roles/builder.ts
+function getBuilderFlowMermaid(nativeIntegration, codeChangesTarget, questionTarget) {
+  const handoffNodes = `    D --> E[Commit work]
+    E --> F{Code changes?}
+    F -->|yes| G[Hand off to **${codeChangesTarget}**]
+    F -->|no| H[Hand off to **${questionTarget}**]`;
+  if (nativeIntegration) {
+    return `flowchart TD
+    A([Start]) --> B[Receive task]
+    B --> D[Implement changes]
+${handoffNodes}`;
+  }
+  return `flowchart TD
+    A([Start]) --> B[Receive chatroom task]
+    B --> D[Implement changes]
+${handoffNodes}`;
+}
+function getBuilderGuidance(params) {
+  const {
+    questionTarget: questionTargetParam,
+    codeChangesTarget: codeChangesTargetParam,
+    nativeIntegration
+  } = params;
+  const questionTarget = questionTargetParam ?? "user";
+  const codeChangesTarget = codeChangesTargetParam ?? "planner";
+  return `
+## Builder Operating Model
+
+${getSessionContinuityLine(nativeIntegration)}
+
+You are responsible for implementing code changes based on requirements.
+
+**Typical Flow:**
+
+\`\`\`mermaid
+${getBuilderFlowMermaid(nativeIntegration, codeChangesTarget, questionTarget)}
+\`\`\`
+
+**Handoff Rules:**
+- **After code changes** → Hand off to \`${codeChangesTarget}\`
+- **For simple questions** → Can hand off directly to \`${questionTarget}\`
+  ⚠️ If \`${questionTarget}\` is the user: the user can ONLY see the handoff-to-user message — progress reports and all other messages are invisible to them. Write the handoff as a complete, self-contained document: include all relevant context, results, and next steps without assuming the user read any prior conversation.
+
+**Implementation Guidelines:**
+- Write clean, maintainable, well-documented code
+- Follow established patterns and best practices from the codebase
+- Handle edge cases and error scenarios
+- Commit work with descriptive, atomic commit messages
+`;
+}
 var init_builder = () => {};
+
+// ../../services/backend/prompts/cli/sections/core-responsibilities.ts
+function getCoreResponsibilitiesSection(config3) {
+  const qualityLine = config3.hasBuilder ? "If the user's requirements are not met, hand work back to the builder for rework." : "If the work doesn't meet requirements, revise it yourself before delivering.";
+  return `**Core Responsibilities:**
+- **User Communication**: You are the ONLY role that communicates with the user. All responses to the user come through you.
+  - **Handoff completeness**: The user can ONLY see the final handoff-to-\`user\` message. Write it as a complete, standalone document — do not reference prior messages or assume the user has context from earlier session text.
+- **Quality Accountability**: You are ultimately accountable for all work. ${qualityLine}`;
+}
+
+// ../../services/backend/prompts/cli/sections/delegation-and-decomposition.ts
+function getDelegationAndDecompositionSection(config3) {
+  if (!config3.hasBuilder) {
+    return "";
+  }
+  return `**Delegation & Decomposition:**
+
+Any task that requires code changes must be delegated to the builder — break it into small, focused slices and delegate them one at a time using a **Delegation Brief** (see **Delegation Guidelines** below).`;
+}
+
+// ../../services/backend/prompts/cli/sections/delegation-guidelines.ts
+function buildCmdHelper(cliEnvPrefix, chatroomIdArg, roleArg) {
+  return (subcommand) => `\`${cliEnvPrefix}chatroom ${subcommand} --chatroom-id=${chatroomIdArg} --role=${roleArg}\``;
+}
+function getDelegationBriefReference() {
+  return "Use the **Handoff to `builder`** template in the task delivery `<handoff-templates>` section — follow that structure in your handoff message.";
+}
+function getSoloImplementationGuidelines(cmd, feedingNote) {
+  return `**Implementation Guidelines:**
+
+Break complex features into small, focused slices. For code review guidance, activate the \`code-review\` skill: ${cmd("skill activate code-review")}.
+
+- Implement one slice at a time; each slice ≈ one focused review surface.
+- Review your own work before moving on; re-validate after rework.
+- ${feedingNote}.`;
+}
+function getBuilderDelegationGuidelines(cmd, feedingNote, delegationBriefRef) {
+  return `**Delegation Guidelines:**
+
+Break features into small, focused slices, then delegate them to the builder one at a time. For code review guidance, activate the \`code-review\` skill: ${cmd("skill activate code-review")}.
+
+**Delegation rule:** If the task requires **any code changes** (new files, edits, deletions), you **must delegate to the builder** — regardless of how small the change is.
+
+**Decision flow:**
+\`\`\`mermaid
+flowchart TD
+    A[Receive task] --> B{Code changes needed?}
+    B -->|Yes — any size| D[Write a Delegation Brief]
+    D --> E[Hand off ONE slice to builder]
+    E --> F[Review output]
+    F -->|Not acceptable| G[Hand back with feedback]
+    G --> E
+    F -->|Acceptable| H{More slices?}
+    H -->|Yes| E
+    H -->|No| I[Deliver to user]
+    B -->|No: question or clarification only| C[Answer directly → deliver to user]
+\`\`\`
+
+**Default: delegate with a Delegation Brief.** ${delegationBriefRef}
+
+**How to slice the work** — think about the phases a human engineer would actually go through to ship the work, then make each phase a slice. Some heuristics:
+
+- **Each slice should name a concrete artifact** ("the X schema", "the Y entity", "the Z endpoint") — not a vague layer ("backend work", "implementation"). Weak builders fail when scope is unbounded.
+- **File-level detail, zero ambiguity.** List every file (full paths) and paste snippets until the builder cannot guess wrong — not vague layers ("backend work", "the component").
+- **You own technical design; the builder executes.** Per-file target code plus shared contracts in the brief — do not leave API shape for the builder to invent.
+- **Spell out what to avoid** — anti-patterns and recurring mistakes you have seen from builders on similar work (scope creep, wrong abstractions, forbidden refactors).
+- **One slice ≈ one focused review surface.** If you can't imagine reviewing it in one sitting, split it.
+- **Order by dependency**, not by team convention. A slice should be runnable/testable when its dependencies are done.
+- **Skip phases that don't apply** (e.g., no frontend for a backend-only change, no schema for a pure refactor).
+
+**Code review:** For code-producing work, review before delivering. Activate the review framework with: ${cmd("skill activate code-review")}.
+
+**Backlog items:** When the task originates from a backlog item, activate the backlog skill: ${cmd("skill activate backlog")}.
+
+**If stuck:** After 2 failed rework attempts → step back, replan the slice, or deliver partial results with a clear explanation.
+
+**Review loop:**
+- Review completed work before moving to the next slice.
+- Send back with specific feedback if requirements aren't met.
+- ${feedingNote}.`;
+}
+function getDelegationGuidelinesSection(config3, options) {
+  const feedingNote = config3.hasBuilder ? "Feed slices to the builder incrementally — one at a time, not all at once" : "When implementing yourself, tackle one layer at a time — avoid large monolithic changes";
+  const cliEnvPrefix = options?.cliEnvPrefix ?? "";
+  const chatroomIdArg = options?.chatroomId ? `"${options.chatroomId}"` : "<id>";
+  const roleArg = options?.role ? `"${options.role}"` : "<role>";
+  const cmd = buildCmdHelper(cliEnvPrefix, chatroomIdArg, roleArg);
+  if (!config3.hasBuilder) {
+    return getSoloImplementationGuidelines(cmd, feedingNote);
+  }
+  return getBuilderDelegationGuidelines(cmd, feedingNote, getDelegationBriefReference());
+}
+
 // ../../services/backend/prompts/cli/sections/handoff-rules.ts
+function buildHandoffRuleLines(config3) {
+  return [
+    config3.hasBuilder ? "- **To delegate implementation** → Hand off to `builder` with clear requirements" : "- **To implement** → Work on the chatroom task directly (you are acting as implementer)",
+    "- **To deliver to user** → Hand off to `user` with a complete, standalone summary\n  ⚠️ The user can ONLY see the handoff-to-user message — progress reports and all other messages are invisible to them. Write the handoff as a self-contained document: include all relevant context, results, and next steps without assuming the user read any prior conversation.",
+    config3.hasBuilder ? "- **For rework** → Hand off back to `builder` with specific feedback on what needs to change" : "- **For rework** → Revise your implementation directly and re-validate"
+  ].join(`
+`);
+}
+function getHandoffRulesSection(config3, nativeIntegration) {
+  const continuityRule = getHandoffContinuityRule(nativeIntegration);
+  const continuityBlock = continuityRule ? `${continuityRule}
+
+` : "";
+  return `**Handoff Rules:**
+
+${continuityBlock}${buildHandoffRuleLines(config3)}`;
+}
 var init_handoff_rules = () => {};
+
+// ../../services/backend/prompts/cli/sections/when-work-comes-back.ts
+function getWhenWorkComesBackSection(config3) {
+  const reworkLine = config3.hasBuilder ? "3. If requirements are NOT met → hand back to `builder` for rework" : "3. If requirements are NOT met → revise your own implementation and re-validate";
+  return `**When you receive work back from team members:**
+1. Review the completed work against the original user request
+2. If requirements are met → deliver to \`user\`
+${reworkLine}
+4. **No ceremonial handoffs** — never hand back just to acknowledge, thank, or echo receipt. A handback to the sender is only valid when it carries concrete rework feedback (step 3). Handoffs to \`user\` are reserved for the final deliverable from the entry-point role.`;
+}
+
+// ../../services/backend/prompts/cli/sections/team-composition.ts
+function getTeamCompositionSection(teamMembers) {
+  const isSoloRole = teamMembers.length === 1 && teamMembers[0]?.toLowerCase() === "solo";
+  const nonPlannerMembers = teamMembers.filter((r) => r.toLowerCase() !== "planner");
+  if (isSoloRole || nonPlannerMembers.length === 0) {
+    return `**Team composition:** Solo team — you handle planning and implementation yourself.`;
+  }
+  const roleList = nonPlannerMembers.map((r) => `\`${r}\``).join(", ");
+  return `**Team composition:** Duo team — you coordinate with ${roleList} for implementation.
+
+**Agent presence:** This prompt does **not** tell you who is online. Other agents may be offline. Delegate code-changing work by handing off when appropriate; do not infer availability from team configuration or prior chat history.`;
+}
+
 // ../../services/backend/prompts/cli/sections/operating-model.ts
+function getTaskIntakeNodes(nativeIntegration) {
+  if (nativeIntegration) {
+    return `    A([Start]) --> B[Receive user message]
+    B --> E[Decompose into phases]`;
+  }
+  return `    A([Start]) --> B[Receive chatroom task from get-next-task]
+    B --> E[Decompose into phases]`;
+}
+function getOperatingModelSection(config3, nativeIntegration) {
+  if (config3.hasBuilder) {
+    return getPlannerPlusBuilderOperatingModel(nativeIntegration);
+  }
+  return getPlannerSoloOperatingModel(nativeIntegration);
+}
+function getPlannerPlusBuilderOperatingModel(nativeIntegration) {
+  const footer = getOperatingModelLoopFooter(nativeIntegration);
+  const delegationNote = nativeIntegration ? getNativePlannerDelegationWaitNote() : "After delegating to the builder, hand off and wait for work to return.";
+  return `**Operating model: Planner + Builder**
+
+${delegationNote}
+
+\`\`\`mermaid
+flowchart TD
+${getTaskIntakeNodes(nativeIntegration)}
+    E --> F[Delegate ONE phase to builder]
+    F --> G[Builder completes phase]
+    G --> H[Builder hands off to planner]
+    H --> I[Review builder output]
+    I --> J{phase acceptable?}
+    J -->|no| K[Hand back to builder with feedback]
+    K --> F
+    J -->|yes| L{more phases?}
+    L -->|yes| F
+    L -->|no| O[Deliver final result to user]
+    O --> P[${footer}] --> B
+\`\`\``;
+}
+function getPlannerSoloOperatingModel(nativeIntegration) {
+  const continueStep = nativeIntegration ? "Hand off when complete" : "Run `get-next-task` to continue the session (Level A continues after Level B completes)";
+  const intakeSteps = nativeIntegration ? `1. Receive user message
+2. Plan and implement` : `1. Receive chatroom task from get-next-task
+2. Plan and implement`;
+  if (nativeIntegration) {
+    return `**Operating model: Planner Solo**
+
+${intakeSteps}
+3. Deliver to **user**
+4. ${continueStep}`;
+  }
+  return `**Operating model: Planner Solo**
+
+${intakeSteps}
+3. Review your own work for quality
+4. Deliver to **user**
+5. ${continueStep}`;
+}
 var init_operating_model = () => {};
 
 // ../../services/backend/prompts/cli/sections/index.ts
@@ -77845,17 +78941,126 @@ var init_sections = __esm(() => {
 });
 
 // ../../services/backend/prompts/cli/roles/planner.ts
+function getPlannerGuidance(params) {
+  const { convexUrl, teamRoles, chatroomId, role, nativeIntegration } = params;
+  const cliEnvPrefix = getCliEnvPrefix(convexUrl);
+  const members = teamRoles;
+  const hasBuilder = members.some((r) => r.toLowerCase() === "builder");
+  const teamConfig = { hasBuilder };
+  return `## Planner Operating Model
+
+${getSessionContinuityLine(nativeIntegration)}
+
+You are the team coordinator and the **single point of contact** for the user.
+
+${getTeamCompositionSection(members)}
+
+${getOperatingModelSection(teamConfig, nativeIntegration)}
+
+${getCoreResponsibilitiesSection(teamConfig)}
+
+${getDelegationAndDecompositionSection(teamConfig)}
+
+${getDelegationGuidelinesSection(teamConfig, { cliEnvPrefix, chatroomId, role })}
+
+${getHandoffRulesSection(teamConfig, nativeIntegration)}
+
+${getWhenWorkComesBackSection(teamConfig)}`;
+}
 var init_planner = __esm(() => {
   init_env();
   init_sections();
 });
 
 // ../../services/backend/prompts/teams/solo/prompts/solo.ts
+function getSoloGuidance(ctx) {
+  const { teamRoles, nativeIntegration } = ctx;
+  return `## Solo Operating Model
+
+${getSessionContinuityLine(nativeIntegration)}
+
+You are an autonomous agent responsible for BOTH planning and implementing chatroom tasks independently.
+
+**Solo Team Context:**
+- You are the ONLY team member — you plan, implement, and deliver
+- You communicate directly with the user (single point of contact)
+- There is no separate builder or planner — you fill all roles
+- You hand off directly to the user when work is complete
+
+${getTeamCompositionSection(teamRoles)}
+
+${getPlannerSoloOperatingModel(nativeIntegration)}
+
+${getCoreResponsibilitiesSection(SOLO_TEAM_CONFIG)}
+
+**Implementation Guidelines:**
+- Write clean, maintainable, well-documented code
+- Follow established patterns and best practices from the codebase
+- Handle edge cases and error scenarios
+- Commit work with descriptive, atomic commit messages
+
+${getHandoffRulesSection(SOLO_TEAM_CONFIG, nativeIntegration)}
+
+${getWhenWorkComesBackSection(SOLO_TEAM_CONFIG)}`;
+}
+var SOLO_TEAM_CONFIG;
 var init_solo = __esm(() => {
   init_sections();
+  SOLO_TEAM_CONFIG = { hasBuilder: false };
 });
 
 // ../../services/backend/prompts/cli/roles/fromContext.ts
+function toBuilderParams(ctx) {
+  return {
+    role: ctx.role,
+    teamRoles: ctx.teamRoles,
+    isEntryPoint: ctx.isEntryPoint,
+    convexUrl: ctx.convexUrl,
+    nativeIntegration: ctx.nativeIntegration
+  };
+}
+function toPlannerParams(ctx) {
+  return {
+    role: ctx.role,
+    teamRoles: ctx.teamRoles,
+    isEntryPoint: ctx.isEntryPoint,
+    convexUrl: ctx.convexUrl,
+    chatroomId: ctx.chatroomId,
+    nativeIntegration: ctx.nativeIntegration
+  };
+}
+function getBaseBuilderGuidanceFromContext(ctx) {
+  return getBuilderGuidance(toBuilderParams(ctx));
+}
+function toSoloParams(ctx) {
+  return {
+    role: ctx.role,
+    teamRoles: ctx.teamRoles,
+    isEntryPoint: ctx.isEntryPoint,
+    convexUrl: ctx.convexUrl,
+    chatroomId: ctx.chatroomId,
+    nativeIntegration: ctx.nativeIntegration
+  };
+}
+function getSoloGuidanceFromContext(ctx) {
+  return getSoloGuidance(toSoloParams(ctx));
+}
+function getBasePlannerGuidanceFromContext(ctx) {
+  return getPlannerGuidance(toPlannerParams(ctx));
+}
+function getBaseRoleGuidanceFromContext(ctx) {
+  const normalizedRole = ctx.role.toLowerCase();
+  if (normalizedRole === "planner") {
+    return getBasePlannerGuidanceFromContext(ctx);
+  }
+  if (normalizedRole === "builder") {
+    return getBaseBuilderGuidanceFromContext(ctx);
+  }
+  if (normalizedRole === "solo") {
+    return getSoloGuidanceFromContext(ctx);
+  }
+  return "";
+}
 var init_fromContext = __esm(() => {
   init_builder();
   init_planner();
@@ -77863,32 +79068,229 @@ var init_fromContext = __esm(() => {
 });
 
 // ../../services/backend/prompts/teams/duo/prompts/builder.ts
+function getBuilderGuidance2(ctx) {
+  return `
+ **Duo Team Context:**
+ - You work with a planner who coordinates work and communicates with the user
+ - You do NOT communicate directly with the user — hand off to the planner instead
+ - Focus on implementation; the planner handles user communication and delivery
+ - After completing work, hand off back to planner
+ - **NEVER hand off directly to \`user\`** — always go through the planner
+ 
+ ${getBuilderGuidance({ ...ctx, questionTarget: "planner", codeChangesTarget: "planner" })}
+ `;
+}
 var init_builder2 = __esm(() => {
   init_builder();
 });
 
 // ../../services/backend/prompts/cli/roles/planner-guidance-context.ts
+function getPlannerGuidanceContext(ctx) {
+  const { convexUrl, teamRoles, chatroomId, role } = ctx;
+  const cliEnvPrefix = getCliEnvPrefix(convexUrl);
+  const members = teamRoles;
+  return {
+    ...ctx,
+    cliEnvPrefix,
+    members,
+    chatroomId,
+    role
+  };
+}
 var init_planner_guidance_context = __esm(() => {
   init_env();
 });
 
 // ../../services/backend/prompts/teams/duo/prompts/planner.ts
+function getPlannerGuidance2(ctx) {
+  const { nativeIntegration, members, cliEnvPrefix, chatroomId, role } = getPlannerGuidanceContext(ctx);
+  const operatingModelGuidance = getPlannerPlusBuilderOperatingModel(nativeIntegration);
+  return `## Planner Operating Model
+
+${getSessionContinuityLine(nativeIntegration)}
+
+You are the team coordinator and the **single point of contact** for the user.
+
+**Duo Team Context:**
+- You are the entry point — you communicate directly with the user
+- You coordinate with the builder for implementation tasks
+- You are ultimately accountable for all work quality
+- After reviewing builder output, deliver results to the user
+- **Only you can hand off to \`user\`**
+
+${getTeamCompositionSection(members)}
+
+${operatingModelGuidance}
+
+${getCoreResponsibilitiesSection(DUO_TEAM_CONFIG)}
+
+${getDelegationAndDecompositionSection(DUO_TEAM_CONFIG)}
+
+${getDelegationGuidelinesSection(DUO_TEAM_CONFIG, {
+    cliEnvPrefix,
+    chatroomId,
+    role
+  })}
+
+${getHandoffRulesSection(DUO_TEAM_CONFIG, nativeIntegration)}
+
+${getWhenWorkComesBackSection(DUO_TEAM_CONFIG)}`;
+}
+var DUO_TEAM_CONFIG;
 var init_planner2 = __esm(() => {
   init_planner_guidance_context();
   init_sections();
+  DUO_TEAM_CONFIG = { hasBuilder: true };
 });
 
 // ../../services/backend/prompts/teams/duo/prompts/fromContext.ts
+function toDuoBuilderParams(ctx) {
+  return {
+    role: ctx.role,
+    teamRoles: ctx.teamRoles,
+    isEntryPoint: ctx.isEntryPoint,
+    convexUrl: ctx.convexUrl,
+    nativeIntegration: ctx.nativeIntegration
+  };
+}
+function toDuoPlannerParams(ctx) {
+  return {
+    role: ctx.role,
+    teamRoles: ctx.teamRoles,
+    isEntryPoint: ctx.isEntryPoint,
+    convexUrl: ctx.convexUrl,
+    chatroomId: ctx.chatroomId,
+    nativeIntegration: ctx.nativeIntegration
+  };
+}
+function getDuoBuilderGuidanceFromContext(ctx) {
+  return getBuilderGuidance2(toDuoBuilderParams(ctx));
+}
+function getDuoPlannerGuidanceFromContext(ctx) {
+  return getPlannerGuidance2(toDuoPlannerParams(ctx));
+}
+function getDuoRoleGuidanceFromContext(ctx) {
+  const normalizedRole = ctx.role.toLowerCase();
+  if (normalizedRole === "planner") {
+    return getDuoPlannerGuidanceFromContext(ctx);
+  }
+  if (normalizedRole === "builder") {
+    return getDuoBuilderGuidanceFromContext(ctx);
+  }
+  return null;
+}
 var init_fromContext2 = __esm(() => {
   init_builder2();
   init_planner2();
 });
 
 // ../../services/backend/prompts/teams/solo/prompts/fromContext.ts
+function toSoloParams2(ctx) {
+  return {
+    role: ctx.role,
+    teamRoles: ctx.teamRoles,
+    isEntryPoint: ctx.isEntryPoint,
+    convexUrl: ctx.convexUrl,
+    chatroomId: ctx.chatroomId,
+    nativeIntegration: ctx.nativeIntegration
+  };
+}
+function getSoloGuidanceFromContext2(ctx) {
+  return getSoloGuidance(toSoloParams2(ctx));
+}
+function getSoloRoleGuidanceFromContext(ctx) {
+  const normalizedRole = ctx.role.toLowerCase();
+  if (normalizedRole === "solo") {
+    return getSoloGuidanceFromContext2(ctx);
+  }
+  return null;
+}
 var init_fromContext3 = __esm(() => {
   init_solo();
 });
+
+// ../../services/backend/src/domain/entities/team.ts
+function toTeam(chatroom) {
+  if (!chatroom.teamId || !chatroom.teamRoles || chatroom.teamRoles.length === 0) {
+    return null;
+  }
+  const entryPoint = chatroom.teamEntryPoint ?? chatroom.teamRoles[0];
+  if (!entryPoint)
+    return null;
+  return {
+    id: chatroom.teamId,
+    name: chatroom.teamName ?? chatroom.teamId,
+    roles: chatroom.teamRoles,
+    entryPoint
+  };
+}
+function getTeamEntryPoint(team) {
+  return team.teamEntryPoint ?? team.teamRoles?.[0] ?? null;
+}
+
 // ../../services/backend/prompts/selector-context.ts
+function detectTeamTypeByName(teamName) {
+  const normalizedName = (teamName || "").toLowerCase();
+  if (normalizedName.includes("solo"))
+    return "solo";
+  if (normalizedName.includes("duo"))
+    return "duo";
+  return null;
+}
+function isSoloTeamByRoles(teamRoles) {
+  return teamRoles.some((r) => r.toLowerCase() === "solo") && teamRoles.length === 1;
+}
+function isDuoTeamByRoles(teamRoles) {
+  const hasPlanner = teamRoles.some((r) => r.toLowerCase() === "planner");
+  const hasBuilder = teamRoles.some((r) => r.toLowerCase() === "builder");
+  return hasPlanner && hasBuilder && teamRoles.length === 2;
+}
+function detectTeamType(teamRoles, teamName) {
+  const byName = detectTeamTypeByName(teamName);
+  if (byName)
+    return byName;
+  if (isSoloTeamByRoles(teamRoles))
+    return "solo";
+  if (isDuoTeamByRoles(teamRoles))
+    return "duo";
+  return "unknown";
+}
+function buildSelectorContext(params) {
+  const entryPoint = getTeamEntryPoint({ teamEntryPoint: params.teamEntryPoint, teamRoles: params.teamRoles }) ?? "builder";
+  const teamConfig = toTeam({
+    teamId: params.teamId,
+    teamName: params.teamName,
+    teamRoles: params.teamRoles,
+    teamEntryPoint: params.teamEntryPoint
+  }) ?? undefined;
+  return {
+    role: params.role,
+    team: detectTeamType(params.teamRoles, params.teamName),
+    teamConfig,
+    workflow: params.workflow,
+    teamRoles: params.teamRoles,
+    isEntryPoint: params.role.toLowerCase() === entryPoint.toLowerCase(),
+    convexUrl: params.convexUrl,
+    chatroomId: params.chatroomId,
+    agentType: params.agentType ?? "unset",
+    nativeIntegration: params.nativeIntegration
+  };
+}
+function getRoleGuidanceFromContext(ctx) {
+  try {
+    if (ctx.team === "solo") {
+      const result = getSoloRoleGuidanceFromContext(ctx);
+      if (result !== null)
+        return result;
+    }
+    if (ctx.team === "duo") {
+      const result = getDuoRoleGuidanceFromContext(ctx);
+      if (result !== null)
+        return result;
+    }
+  } catch {}
+  return getBaseRoleGuidanceFromContext(ctx);
+}
 var init_selector_context = __esm(() => {
   init_fromContext();
   init_fromContext2();
@@ -77896,19 +79298,151 @@ var init_selector_context = __esm(() => {
 });
 
 // ../../services/backend/prompts/sections/role-guidance.ts
+function getRoleGuidanceSection(ctx) {
+  const content = getRoleGuidanceFromContext(ctx);
+  return createSection("role-guidance", "knowledge", content);
+}
 var init_role_guidance = __esm(() => {
   init_selector_context();
 });
 
 // ../../services/backend/prompts/templates.ts
-var init_templates = () => {};
+function getRoleTemplate(role) {
+  const normalizedRole = role.toLowerCase();
+  const template = ROLE_TEMPLATES[normalizedRole];
+  if (template) {
+    return template;
+  }
+  return {
+    role,
+    title: role.charAt(0).toUpperCase() + role.slice(1),
+    description: `You are participating as the ${role} in this collaborative workflow.`,
+    responsibilities: [
+      "Complete tasks assigned to your role",
+      "Communicate clearly with other participants",
+      "Hand off to the next appropriate role when done"
+    ],
+    defaultHandoffTarget: "user"
+  };
+}
+var ROLE_TEMPLATES;
+var init_templates = __esm(() => {
+  ROLE_TEMPLATES = {
+    builder: {
+      role: "builder",
+      title: "Builder",
+      description: "You are the implementer responsible for writing code and building solutions.",
+      responsibilities: [
+        "Implement solutions based on requirements",
+        "Write clean, maintainable, well-documented code",
+        "Follow established patterns and best practices",
+        "Handle edge cases and error scenarios",
+        "Provide clear summaries of what was built"
+      ],
+      defaultHandoffTarget: "planner"
+    },
+    planner: {
+      role: "planner",
+      title: "Planner",
+      description: "You are the team coordinator responsible for user communication, task decomposition, and team management.",
+      responsibilities: [
+        "Communicate with the user as the single point of contact",
+        "Decompose complex tasks into actionable work items",
+        "Delegate work to available team members",
+        "Review completed work against user requirements",
+        "Manage the backlog and prioritize tasks",
+        "Hand back work for rework if requirements are not met"
+      ],
+      defaultHandoffTarget: "builder"
+    },
+    architect: {
+      role: "architect",
+      title: "Architect",
+      description: "You are the system designer responsible for planning and high-level architecture.",
+      responsibilities: [
+        "Analyze requirements and break down complex tasks",
+        "Design system architecture and component structure",
+        "Make technology and pattern decisions",
+        "Create clear specifications for the builder",
+        "Consider scalability, maintainability, and best practices"
+      ],
+      defaultHandoffTarget: "builder"
+    },
+    tester: {
+      role: "tester",
+      title: "Tester",
+      description: "You are the QA specialist responsible for testing and validation.",
+      responsibilities: [
+        "Write and execute test cases",
+        "Verify functionality works as expected",
+        "Test edge cases and error handling",
+        "Report bugs and issues clearly",
+        "Confirm quality standards are met"
+      ],
+      defaultHandoffTarget: "user"
+    },
+    solo: {
+      role: "solo",
+      title: "Solo",
+      description: "You are the autonomous agent responsible for both planning and executing tasks independently.",
+      responsibilities: [
+        "Communicate directly with the user as the single point of contact",
+        "Decompose complex tasks into actionable work items",
+        "Implement solutions: write clean, maintainable code",
+        "Follow established patterns and best practices",
+        "Handle edge cases and error scenarios",
+        "Review and validate your own work for quality",
+        "Deliver completed results to the user"
+      ],
+      defaultHandoffTarget: "user"
+    }
+  };
+});
 
 // ../../services/backend/prompts/sections/role-identity.ts
+function getTeamHeaderSection(teamName) {
+  return createSection("team-header", "knowledge", `# ${teamName}`);
+}
+function getRoleTitleSection(ctx) {
+  const template = getRoleTemplate(ctx.role);
+  return createSection("role-title", "knowledge", `## Your Role: ${template.title.toUpperCase()}`);
+}
+function getRoleDescriptionSection(ctx) {
+  const template = getRoleTemplate(ctx.role);
+  return createSection("role-description", "knowledge", template.description);
+}
 var init_role_identity = __esm(() => {
   init_templates();
 });
 
 // ../../services/backend/prompts/native/system-prompt.ts
+function composeNativeSystemPrompt(input) {
+  const { chatroomId, role, teamId, teamName, teamRoles, teamEntryPoint, convexUrl } = input;
+  const selectorCtx = buildSelectorContext({
+    role,
+    teamRoles,
+    teamId,
+    teamName,
+    teamEntryPoint,
+    convexUrl,
+    chatroomId,
+    agentType: input.agentType,
+    nativeIntegration: true
+  });
+  const sections = [
+    getRoleTitleSection(selectorCtx),
+    getGlossarySection({
+      convexUrl,
+      chatroomId,
+      role,
+      nativeIntegration: true,
+      compactSkills: true
+    }),
+    getRoleGuidanceSection(selectorCtx),
+    getNativeCommandsReferenceSection({ chatroomId, role, convexUrl })
+  ];
+  return composeSections(sections);
+}
 var init_system_prompt = __esm(() => {
   init_commands_reference();
   init_glossary();
@@ -77918,11 +79452,46 @@ var init_system_prompt = __esm(() => {
 });
 
 // ../../services/backend/prompts/native/task-started-content.ts
+function getNativeTaskStartedPrompt(ctx) {
+  const contextNewCmd = contextNewCommand({
+    chatroomId: ctx.chatroomId,
+    role: ctx.role,
+    cliEnvPrefix: ctx.cliEnvPrefix,
+    triggerMessageId: ctx.triggerMessageId
+  });
+  return `### Start working
+
+Entry-point roles receive user messages directly. ${getNativeTokenActivityInProgressNote()}
+
+${getContextRuleBlock(contextNewCmd, contextNewHint({ cliEnvPrefix: ctx.cliEnvPrefix }))}`;
+}
+function getNativeTaskStartedPromptForHandoffRecipient() {
+  return `### Start Working
+
+The task body contains your work description. Begin immediately.`;
+}
 var init_task_started_content = __esm(() => {
   init_new();
 });
 
 // ../../services/backend/prompts/sections/classification-guide.ts
+function getTaskIntakeContent(ctx) {
+  const cliEnvPrefix = getCliEnvPrefix(ctx.convexUrl);
+  const chatroomId = ctx.chatroomId ?? "";
+  if (ctx.isEntryPoint) {
+    return ctx.nativeIntegration ? getNativeTaskStartedPrompt({ chatroomId, role: ctx.role, cliEnvPrefix }) : getTaskStartedPrompt2({ chatroomId, role: ctx.role, cliEnvPrefix });
+  }
+  return ctx.nativeIntegration ? getNativeTaskStartedPromptForHandoffRecipient() : getTaskStartedPromptForHandoffRecipient2({
+    chatroomId,
+    role: ctx.role,
+    cliEnvPrefix
+  });
+}
+function getClassificationGuideSection(ctx) {
+  const content = getTaskIntakeContent(ctx);
+  const sectionId = ctx.isEntryPoint ? "task-intake-guide" : "handoff-recipient-guide";
+  return createSection(sectionId, "knowledge", content);
+}
 var init_classification_guide = __esm(() => {
   init_cli();
   init_task_started_content();
@@ -77930,23 +79499,118 @@ var init_classification_guide = __esm(() => {
 });
 
 // ../../services/backend/prompts/sections/current-classification.ts
+function getCurrentClassificationSection(classification) {
+  const info = {
+    question: {
+      label: "QUESTION",
+      description: "User is asking a question. Can respond directly after answering."
+    },
+    new_feature: {
+      label: "NEW FEATURE",
+      description: "New functionality request."
+    },
+    follow_up: {
+      label: "FOLLOW-UP",
+      description: "Follow-up to previous task. Same rules as the original apply."
+    }
+  };
+  const { label, description } = info[classification];
+  const content = `### Current Task: ${label}
+${description}`;
+  return createSection("current-classification", "guidance", content);
+}
 var init_current_classification = () => {};
 
 // ../../services/backend/prompts/sections/getting-started.ts
+function getGettingStartedSection(ctx) {
+  const content = getContextGainingGuidance({
+    chatroomId: ctx.chatroomId ?? "",
+    role: ctx.role,
+    convexUrl: ctx.convexUrl,
+    agentType: ctx.agentType
+  });
+  return createSection("getting-started", "knowledge", content);
+}
 var init_getting_started = __esm(() => {
   init_getting_started_content();
 });
 
 // ../../services/backend/prompts/sections/handoff-options.ts
+function getHandoffOptionsSection(params) {
+  const roles = params.availableHandoffRoles.join(", ");
+  const content = `### Handoff Options
+Available targets: ${roles}`;
+  return createSection("handoff-options", "guidance", content);
+}
 var init_handoff_options = () => {};
 
 // ../../services/backend/prompts/sections/next-step.ts
+function getNextStepSection(params) {
+  const cliEnvPrefix = getCliEnvPrefix(params.convexUrl);
+  const waitCmd = getNextTaskCommand({
+    chatroomId: params.chatroomId,
+    role: params.role,
+    cliEnvPrefix
+  });
+  const content = `### Next
+
+Run:
+
+\`\`\`bash
+${waitCmd}
+\`\`\``;
+  return createSection("next-step", "guidance", content);
+}
 var init_next_step = __esm(() => {
   init_command();
   init_utils3();
 });
 
 // ../../services/backend/prompts/sections/session-vs-chatroom-task.ts
+function getTwoLevelsTableSection() {
+  return `## Two-Level Model: Session vs Chatroom Task
+
+| Level | Name | Scope | Ends when |
+|-------|------|-------|-----------|
+| **A** | **Session** (harness turn) | The entire agent invocation — from startup to shutdown | You deliberately shut down or the harness exits |
+| **B** | **Chatroom task** | One discrete unit of work delivered by \`get-next-task\` | You run \`handoff\` to pass work to the next role |
+
+**Completing Level B does NOT end Level A.**
+After every \`handoff\`, you must run \`get-next-task\` again to stay in the session and receive the next chatroom task.`;
+}
+function getSessionLifecycleSection() {
+  return `### Session Lifecycle
+
+A session starts when your harness launches you and ends only when the harness shuts down (or you explicitly stop).
+Within a session, you process many chatroom tasks sequentially:
+
+\`get-next-task\` → do work → \`handoff\` → \`get-next-task\` → do work → \`handoff\` → …
+
+Never exit or stop after a handoff — that closes the session (Level A) before the user is done with you.`;
+}
+function getSessionAntiPatternsSection() {
+  return `### Common Mistakes
+
+❌ **Wrong:** Run \`handoff\`, then stop or wait for the user to re-invoke you.
+✅ **Right:** Run \`handoff\`, then immediately run \`get-next-task\` in the foreground.
+
+❌ **Wrong:** Think "I finished the task, I'm done."
+✅ **Right:** Think "I finished this chatroom task (Level B). The session (Level A) continues — run \`get-next-task\`."
+
+❌ **Wrong:** Run \`get-next-task\` in the background or skip it.
+✅ **Right:** \`get-next-task\` must run in the **foreground** so the harness can deliver the next chatroom task.`;
+}
+function getSessionVsChatroomTaskSection() {
+  const content = [
+    getTwoLevelsTableSection(),
+    "",
+    getSessionLifecycleSection(),
+    "",
+    getSessionAntiPatternsSection()
+  ].join(`
+`);
+  return createSection("session-vs-chatroom-task", "guidance", content);
+}
 var init_session_vs_chatroom_task = () => {};
 
 // ../../services/backend/src/domain/entities/harness/claude-sdk.config.ts
@@ -78151,9 +79815,571 @@ var init_types = __esm(() => {
     "pi-sdk": piSdkCapabilities
   };
 });
+
+// ../../services/backend/prompts/review-guidelines/review.ts
+function getReviewGuidelines() {
+  return [REVIEW_PRINCIPLES, REVIEW_PROCESS, GUIDELINE_FILE_LOCATIONS, REJECTION_GUIDANCE].join(`
+
+`);
+}
+var REVIEW_PRINCIPLES = `
+## Review Principles
+
+When reviewing completed work, you serve as the quality guardian between implementation and delivery.
+
+### Primary Goal: Maintainability & Extensibility
+
+**The ultimate purpose of code review is to ensure the changes make it possible to continue building on the application.**
+
+Every piece of code must be:
+- Easy to understand and modify later
+- Following patterns that scale
+- Not creating technical debt that slows future development
+
+If code is hard to extend, hard to understand, or creates mess - it should be rejected or refactored, regardless of whether it "works."
+
+### Core Values
+
+1. **User Goal Alignment**
+   The implementation must accomplish what the user originally requested.
+   Compare the work against the ORIGINAL user request, not just the handoff summary.
+
+2. **Code Quality Over Speed**
+   Maintain code quality: Use \`handoff\` to reject messy code that creates technical debt and slows future development.
+
+3. **Codebase Consistency**
+   New code should follow existing patterns and conventions.
+   Check guideline files for project-specific rules.
+   Inconsistent code creates confusion and bugs.
+
+4. **Verification Over Trust**
+   Check the actual changes, not just the summary.
+   If something seems off, investigate. Trust but verify.
+
+5. **Be Direct and Specific**
+   Be specific and clear in your \`handoff\` message: Vague feedback leads to confusion and rework. If something is wrong, say exactly what and why.
+   If a refactor is needed, propose the exact approach.
+`, REVIEW_PROCESS = `
+## Review Process
+
+### Phase 1: Context Review
+
+Before looking at code, understand what was requested:
+
+1. Read the **original user request** in the context window
+2. Note all requirements, constraints, and acceptance criteria
+3. If a feature has metadata (title, description, tech-specs), review each point
+4. If there are attached tasks, read their content
+
+### Phase 2: Change Inspection
+
+Run these commands to inspect the implementation:
+
+\`\`\`bash
+# Check for linting issues
+pnpm lint:fix
+
+# View uncommitted changes
+git status
+git diff
+
+# View recent commits
+git log --oneline -5
+git show HEAD
+\`\`\`
+
+### Phase 3: Code Review Checklist
+
+**Functional Requirements:**
+- [ ] All requirements from original request are addressed
+- [ ] Edge cases are handled
+- [ ] Error handling is appropriate
+
+**Code Quality:**
+- [ ] No \`any\` types - proper TypeScript typing required
+- [ ] No type assertions (\`as\`) hiding real type issues
+- [ ] React hooks used correctly (deps arrays, memoization)
+- [ ] No inline workarounds or hacks
+
+**Codebase Consistency:**
+- [ ] Follows existing patterns in the codebase
+- [ ] Uses existing components/utilities where applicable
+- [ ] Styling follows design system (semantic tokens, not hardcoded colors)
+
+**Guidelines Compliance:**
+- [ ] Check relevant guideline files were followed (see list below)
+
+### Phase 4: Decision
+
+**Your feedback must be SPECIFIC and ACTIONABLE. Include clear guidance in your \`handoff\` message to help the builder make the right changes.**
+
+**If changes are needed:**
+- State EXACTLY what is wrong (file, line, code snippet)
+- Explain WHY it's a problem (not just that it's wrong)
+- Provide the EXACT fix or approach you want to see
+- If multiple issues, number them clearly
+
+Example of BAD feedback:
+> "The code could be cleaner"
+
+Example of GOOD feedback:
+> "In \`TaskQueue.tsx\` line 45, you're using \`any\` type for the task parameter.
+> This hides type errors. Change to: \`task: Task\` using the imported Task type."
+
+**If the code is a mess - REJECT IT:**
+- Use \`handoff\` to reject messy code that "works"
+- Propose the refactor approach explicitly in your \`handoff\` message
+- Large refactors are acceptable if they improve maintainability
+- The goal is code that can be built upon, not just code that runs
+
+**If approved:**
+- Confirm ALL requirements from original request are met
+- Briefly summarize what was verified
+- Hand off to user
+`, GUIDELINE_FILE_LOCATIONS = `
+## Guideline Files to Check
+
+Different AI tools use different guideline file locations. Check any that exist:
+
+### Cursor IDE
+- \`.cursor/rules/*.md\` - Cursor rules files
+- \`.cursorrules\` - Root cursor rules
+
+### GitHub Copilot
+- \`.github/copilot-instructions.md\` - Copilot instructions
+- \`.github/copilot/*.md\` - Additional Copilot files
+
+### Claude / Anthropic
+- \`CLAUDE.md\` - Claude-specific instructions
+- \`.claude/*.md\` - Claude rules directory
+
+### OpenAI / Codex
+- \`.openai/guidelines.md\` - OpenAI guidelines
+- \`CODEX.md\` - Codex instructions
+
+### Generic Agent Files
+- \`AGENTS.md\` - Generic agent guidelines
+- \`.ai/*.md\` - AI-related instructions
+- \`DEVELOPMENT.md\` - Development guidelines
+- \`CONTRIBUTING.md\` - Contribution guidelines
+
+### Project-Specific
+- \`docs/design/*.md\` - Design guidelines
+- \`docs/style-guide.md\` - Style guides
+- \`guides/*.md\` - Project guides
+
+**Important:** Adapt to what exists in THIS codebase. Not all projects have all files.
+`, REJECTION_GUIDANCE = `
+## When to Reject or Request Refactors
+
+**Use \`handoff\` to maintain code quality:** The goal is a maintainable codebase.
+
+### Reject When:
+
+1. **Requirements Not Met**
+   - The original user request is not fully addressed
+   - Key features are missing or only partially implemented
+
+2. **Significant Technical Debt**
+   - Hacks or workarounds that will cause problems later
+   - Code that is hard to understand or modify
+   - Patterns that don't scale or won't work with future features
+
+3. **Type Safety Violations**
+   - Widespread use of \`any\` or type assertions
+   - Missing proper error types or return types
+   - Type errors being suppressed rather than fixed
+
+4. **Architectural Issues**
+   - Code in wrong location (logic in UI, UI in logic)
+   - Duplication of existing functionality
+   - Tight coupling that prevents testing/reuse
+
+### Propose Refactors When:
+
+1. **The fix is bigger than the feature**
+   If cleaning up the code would take more effort than the original change,
+   but the mess will compound over time - propose the refactor.
+
+2. **Patterns are inconsistent**
+   If new code follows different patterns than existing code,
+   propose alignment to the established pattern.
+
+3. **Abstractions are wrong**
+   If the code is solving the problem at the wrong level of abstraction,
+   propose the right approach even if it means starting over.
+
+### How to Propose Refactors:
+
+1. Explain the problem clearly
+2. Describe the desired end state
+3. Suggest whether to:
+   - Fix now before merging
+   - Create a follow-up task for later
+   - Block on the refactor
+
+**Remember:** Approving bad code costs more than rejecting it.
+`;
+
 // ../../services/backend/prompts/review-guidelines/index.ts
 var init_review_guidelines = () => {};
+
+// ../../services/backend/prompts/policies/security.ts
+function getSecurityPolicy() {
+  return SECURITY_POLICY;
+}
+var SECURITY_POLICY = `
+## Security Review Policy
+
+These are general security principles. Adapt to your codebase's specific security requirements.
+
+### Authentication & Authorization
+
+- [ ] Authentication checks are in place where required
+- [ ] Authorization verifies user has permission for the action
+- [ ] Session handling follows established patterns
+- [ ] No hardcoded credentials or secrets
+
+### Input Validation
+
+- [ ] User input is validated before use
+- [ ] Input sanitization for database queries (SQL injection prevention)
+- [ ] Path traversal protection for file operations
+- [ ] Proper escaping for output contexts (XSS prevention)
+
+### Data Handling
+
+- [ ] Sensitive data is not logged
+- [ ] PII is handled according to privacy requirements
+- [ ] Secrets use environment variables, not hardcoded values
+- [ ] .env files are not committed
+
+### API Security
+
+- [ ] Rate limiting considerations for public endpoints
+- [ ] CORS configuration is appropriate
+- [ ] API responses don't leak sensitive information
+- [ ] Error messages don't expose internal details
+
+### Common Vulnerabilities to Check
+
+1. **Injection Attacks**
+   - SQL/NoSQL injection
+   - Command injection
+   - Template injection
+
+2. **Broken Access Control**
+   - Missing authorization checks
+   - IDOR (Insecure Direct Object Reference)
+   - Privilege escalation
+
+3. **Security Misconfiguration**
+   - Debug mode in production
+   - Exposed admin interfaces
+   - Default credentials
+
+4. **Cryptographic Issues**
+   - Weak hashing algorithms
+   - Insecure random number generation
+   - Improper key management
+
+### Codebase-Specific Security
+
+Check these locations for security-related guidelines:
+- Security documentation in \`docs/security*.md\`
+- Authentication patterns in existing auth code
+- Existing security middleware/helpers
+- Security comments in sensitive code areas
+
+**Important:** These are general guidelines. Always verify against your project's specific security requirements and compliance needs.
+`;
+
+// ../../services/backend/prompts/policies/design.ts
+function getDesignPolicy() {
+  return DESIGN_POLICY;
+}
+var DESIGN_POLICY = `
+## Design Review Policy
+
+These are general design principles. Adapt to your codebase's specific design system.
+
+### Design System Compliance
+
+- [ ] Uses existing design tokens (colors, spacing, typography)
+- [ ] Follows established component patterns
+- [ ] Reuses existing components instead of creating duplicates
+- [ ] Styling uses semantic values, not hardcoded ones
+
+### Color Usage
+
+**Semantic colors should be preferred:**
+- Use \`text-foreground\` not \`text-black\`
+- Use \`bg-card\` not \`bg-white\`
+- Use \`border-border\` not \`border-gray-200\`
+
+**Dark mode support:**
+- All UI should work in both light and dark mode
+- Brand/status colors need dark variants (e.g., \`bg-red-50 dark:bg-red-950/20\`)
+
+### Component Patterns
+
+- [ ] Components follow existing file structure conventions
+- [ ] Props are typed properly
+- [ ] Components are accessible (keyboard navigation, ARIA)
+- [ ] Responsive design is considered
+
+### Typography
+
+- [ ] Uses established font sizes from the design system
+- [ ] Heading hierarchy is semantic (h1, h2, etc.)
+- [ ] Text is readable at all sizes
+- [ ] Font weights follow conventions
+
+### Spacing & Layout
+
+- [ ] Uses design system spacing tokens
+- [ ] Layout is responsive
+- [ ] Alignment is consistent
+- [ ] Proper use of flexbox/grid patterns
+
+### UX Considerations
+
+- [ ] Loading states are handled
+- [ ] Error states have clear messaging
+- [ ] Empty states are designed
+- [ ] Interactive elements have hover/focus states
+
+### Common Design Issues to Catch
+
+1. **Inconsistent Styling**
+   - Different button styles for similar actions
+   - Inconsistent spacing between elements
+   - Mixed font sizes within components
+
+2. **Accessibility Gaps**
+   - Missing keyboard navigation
+   - Low color contrast
+   - Missing ARIA labels
+   - Focus states not visible
+
+3. **Hardcoded Values**
+   - Magic numbers for spacing (use tokens)
+   - Hardcoded colors (use semantic colors)
+   - Fixed widths that break responsive
+
+4. **Component Duplication**
+   - Recreating existing components
+   - Copy-paste instead of abstraction
+   - Similar patterns implemented differently
+
+### Codebase-Specific Design
+
+Check these locations for design guidelines:
+- \`docs/design/*.md\` - Design documentation
+- \`components/ui/\` - Existing UI component library
+- \`tailwind.config.*\` - Theme configuration
+- \`globals.css\` or theme files - CSS custom properties
+- \`AGENTS.md\` or \`CLAUDE.md\` - May contain UI guidelines
+
+**Important:** These are general guidelines. Always verify against your project's specific design system.
+`;
+
+// ../../services/backend/prompts/policies/performance.ts
+function getPerformancePolicy() {
+  return PERFORMANCE_POLICY;
+}
+var PERFORMANCE_POLICY = `
+## Performance Review Policy
+
+These are general performance principles. Adapt to your codebase's specific requirements.
+
+### Frontend Performance
+
+**React/Component Performance:**
+- [ ] \`useMemo\` used for expensive computations
+- [ ] \`useCallback\` used for callback props passed to child components
+- [ ] \`React.memo\` considered for components receiving stable props
+- [ ] No unnecessary re-renders (check dependency arrays)
+- [ ] Large lists use virtualization where appropriate
+
+**Bundle Size:**
+- [ ] No large dependencies added for simple functionality
+- [ ] Dynamic imports (\`lazy\`) used for route-level code splitting
+- [ ] Tree-shaking friendly imports (avoid \`import * as\`)
+- [ ] Images/assets are appropriately sized and optimized
+
+**Rendering:**
+- [ ] No layout thrashing (reading and writing DOM in loops)
+- [ ] CSS animations use \`transform\` and \`opacity\` where possible
+- [ ] Avoid inline styles that change frequently
+- [ ] Consider \`will-change\` for animated elements
+
+### Backend Performance
+
+**Database Queries:**
+- [ ] Queries use appropriate indexes
+- [ ] N+1 query patterns are avoided or justified
+- [ ] Pagination used for large result sets
+- [ ] Expensive queries are cached where appropriate
+
+**API Design:**
+- [ ] Responses don't include unnecessary data
+- [ ] Batch endpoints available for bulk operations
+- [ ] Expensive operations are async/background where possible
+- [ ] Rate limiting considered for resource-intensive endpoints
+
+**Memory & Resources:**
+- [ ] No memory leaks (event listeners cleaned up, subscriptions closed)
+- [ ] Large data structures are streamed, not loaded entirely
+- [ ] Connection pooling used for database/external services
+- [ ] Temporary files/resources are cleaned up
+
+### Common Performance Issues to Catch
+
+1. **Unnecessary Computation**
+   - Computing values on every render
+   - Recalculating derived data without memoization
+   - Expensive operations in hot paths
+
+2. **Over-fetching**
+   - Requesting more data than needed
+   - Missing pagination on large datasets
+   - Not using projection/select for specific fields
+
+3. **Under-caching**
+   - Repeated identical API calls
+   - Not caching expensive computations
+   - Missing server-side caching for static data
+
+4. **Blocking Operations**
+   - Synchronous operations blocking the event loop
+   - Not using async patterns for I/O
+   - Long-running operations without progress feedback
+
+5. **React-Specific Issues**
+   - Missing dependency arrays causing infinite loops
+   - Creating new objects/functions in render
+   - Not using \`key\` prop properly in lists
+   - State updates in useEffect without proper deps
+
+### Platform-Specific Considerations
+
+**Next.js:**
+- Server Components for static content
+- Client Components for interactive elements
+- Image optimization with next/image
+- Route segment config for caching
+
+**Convex:**
+- Query indexing for filtered/sorted data
+- Pagination for large result sets
+- Optimistic updates for better UX
+- Reactive queries vs. one-time fetches
+
+**General Web:**
+- Core Web Vitals (LCP, FID, CLS)
+- Time to Interactive (TTI)
+- First Contentful Paint (FCP)
+
+### Questions to Ask
+
+1. "Will this scale with 10x/100x more data?"
+2. "What happens with slow network conditions?"
+3. "Are there any O(n²) or worse algorithms?"
+4. "Could this operation be batched or debounced?"
+5. "Is this computation necessary on every render?"
+
+**Important:** These are general guidelines. Performance requirements vary by application.
+Focus on user-facing performance impact rather than micro-optimizations.
+`;
+
 // ../../services/backend/prompts/generator.ts
+var exports_generator = {};
+__export(exports_generator, {
+  getSecurityPolicy: () => getSecurityPolicy,
+  getReviewGuidelines: () => getReviewGuidelines,
+  getPerformancePolicy: () => getPerformancePolicy,
+  getDesignPolicy: () => getDesignPolicy,
+  generateRolePrompt: () => generateRolePrompt,
+  generateHandoffOutput: () => generateHandoffOutput,
+  generateGeneralInstructions: () => generateGeneralInstructions,
+  composeSystemPrompt: () => composeSystemPrompt2,
+  composeInitPrompt: () => composeInitPrompt,
+  composeInitMessage: () => composeInitMessage
+});
+function generateGeneralInstructions(_input) {
+  const sections = [];
+  sections.push(getNextTaskGuidance());
+  return sections.join(`
+
+`);
+}
+function generateRolePrompt(ctx) {
+  const selectorCtx = buildSelectorContext({
+    role: ctx.role,
+    teamRoles: ctx.teamRoles,
+    teamId: ctx.teamId,
+    teamName: ctx.teamName,
+    teamEntryPoint: ctx.teamEntryPoint,
+    convexUrl: ctx.convexUrl,
+    chatroomId: ctx.chatroomId,
+    workflow: ctx.currentClassification
+  });
+  const sections = [];
+  sections.push(getRoleTitleSection(selectorCtx));
+  sections.push(getRoleDescriptionSection(selectorCtx));
+  sections.push(getGlossarySection({ convexUrl: ctx.convexUrl ?? "", chatroomId: ctx.chatroomId }));
+  sections.push(getRoleGuidanceSection(selectorCtx));
+  if (ctx.currentClassification) {
+    sections.push(getCurrentClassificationSection(ctx.currentClassification));
+  }
+  sections.push(getHandoffOptionsSection({
+    availableHandoffRoles: ctx.availableHandoffRoles
+  }));
+  sections.push(getCommandsReferenceSection({
+    chatroomId: ctx.chatroomId,
+    role: ctx.role,
+    convexUrl: ctx.convexUrl
+  }));
+  return composeSections(sections);
+}
+function buildInitPromptSections(input, selectorCtx) {
+  const { chatroomId, role, teamRoles, convexUrl } = input;
+  const otherRoles = teamRoles.filter((r) => r.toLowerCase() !== role.toLowerCase());
+  const handoffTargets = [...new Set([...otherRoles, "user"])];
+  const sections = [
+    getTeamHeaderSection(input.teamName),
+    getRoleTitleSection(selectorCtx),
+    getRoleDescriptionSection(selectorCtx),
+    getGlossarySection({ convexUrl: convexUrl ?? "", chatroomId }),
+    getSessionVsChatroomTaskSection(),
+    getGettingStartedSection(selectorCtx),
+    getClassificationGuideSection(selectorCtx),
+    getRoleGuidanceSection(selectorCtx),
+    getHandoffOptionsSection({ availableHandoffRoles: handoffTargets }),
+    getCommandsReferenceSection({ chatroomId, role, convexUrl }),
+    getNextStepSection({ chatroomId, role, convexUrl })
+  ];
+  return sections;
+}
+function composeSystemPrompt2(input) {
+  if (isNativeHarness(input.agentHarness)) {
+    return composeNativeSystemPrompt(input);
+  }
+  const { chatroomId, role, teamId, teamName, teamRoles, teamEntryPoint, convexUrl } = input;
+  const selectorCtx = buildSelectorContext({
+    role,
+    teamRoles,
+    teamId,
+    teamName,
+    teamEntryPoint,
+    convexUrl,
+    chatroomId,
+    agentType: input.agentType,
+    nativeIntegration: false
+  });
+  return composeSections(buildInitPromptSections(input, selectorCtx));
+}
 function generateHandoffOutput(params) {
   const { role, nextRole, chatroomId, convexUrl, supportsNativeIntegration } = params;
   const cliEnvPrefix = getCliEnvPrefix(convexUrl);
@@ -78171,6 +80397,17 @@ function generateHandoffOutput(params) {
   return lines.join(`
 `);
 }
+function composeInitMessage(_input) {
+  return "";
+}
+function composeInitPrompt(input) {
+  const systemPrompt = composeSystemPrompt2(input);
+  const initMessage = composeInitMessage(input);
+  const initPrompt = initMessage ? `${systemPrompt}
+
+${initMessage}` : systemPrompt;
+  return { systemPrompt, initMessage, initPrompt };
+}
 var init_generator = __esm(() => {
   init_command();
   init_reminder();
@@ -79085,6 +81322,83 @@ var init_complete = __esm(() => {
   init_error_formatting();
 });
 
+// src/commands/enhancer/complete.ts
+var exports_complete2 = {};
+__export(exports_complete2, {
+  enhancerComplete: () => enhancerComplete
+});
+async function createDefaultDeps10() {
+  const client4 = await getConvexClient();
+  return {
+    backend: {
+      mutation: (endpoint, args2) => client4.mutation(endpoint, args2),
+      query: (endpoint, args2) => client4.query(endpoint, args2)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    }
+  };
+}
+function handleCompleteError2(err) {
+  return exports_Effect.sync(() => {
+    if (err._tag === "NotAuthenticated") {
+      formatAuthError(err.convexUrl, err.otherUrls);
+      process.exit(1);
+    }
+    if (err._tag === "InvalidChatroomId") {
+      formatChatroomIdError(err.id);
+      process.exit(1);
+    }
+    console.error(`
+❌ ERROR: Enhancer complete failed`);
+    console.error(`
+${err.errorData?.message ?? err.cause.message}`);
+    process.exit(1);
+  });
+}
+async function enhancerComplete(chatroomId, options) {
+  const deps = await createDefaultDeps10();
+  await exports_Effect.runPromise(enhancerCompleteEffect(chatroomId, options).pipe(exports_Effect.provide(commandServicesLayerFromDeps(deps)), exports_Effect.catchAll(handleCompleteError2)));
+}
+var enhancerCompleteEffect = (chatroomId, options) => exports_Effect.gen(function* () {
+  const backend2 = yield* BackendService;
+  const sessionId = yield* requireSessionIdEffect((a) => ({
+    _tag: "NotAuthenticated",
+    convexUrl: a.convexUrl,
+    otherUrls: a.otherUrls
+  }));
+  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
+    _tag: "InvalidChatroomId",
+    id: id3
+  }));
+  yield* backend2.mutation(api.web.enhancer.index.complete, {
+    sessionId,
+    chatroomId,
+    jobId: options.jobId,
+    enhancedContent: options.enhancedContent
+  }).pipe(exports_Effect.mapError((cause3) => {
+    let errorData;
+    if (cause3 instanceof ConvexError) {
+      errorData = cause3.data;
+    }
+    return { _tag: "CompleteFailed", cause: cause3, errorData };
+  }));
+  yield* exports_Effect.sync(() => {
+    console.log(`✅ Enhancer job ${options.jobId} completed`);
+  });
+});
+var init_complete2 = __esm(() => {
+  init_values();
+  init_esm();
+  init_api3();
+  init_storage();
+  init_client2();
+  init_services();
+  init_error_formatting();
+});
+
 // src/commands/backlog/backlog-fs-service.ts
 import * as nodeFs from "node:fs/promises";
 var BacklogFsService, BacklogFsServiceLive, BacklogFsServiceFrom = (ops) => exports_Layer.succeed(BacklogFsService, {
@@ -79191,7 +81505,7 @@ function buildBaseLayer(d) {
 function buildFsLayer(fs11) {
   return fs11 ? BacklogFsServiceFrom(fs11) : BacklogFsServiceLive;
 }
-async function createDefaultDeps10() {
+async function createDefaultDeps11() {
   const client4 = await getConvexClient();
   const fs11 = await import("node:fs/promises");
   return {
@@ -79247,47 +81561,47 @@ function computeContentHash(content) {
   return createHash("sha256").update(content).digest("hex");
 }
 async function listBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   await exports_Effect.runPromise(listBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function addBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   await exports_Effect.runPromise(addBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function completeBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   await exports_Effect.runPromise(completeBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function reopenBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   await exports_Effect.runPromise(reopenBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function patchBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   await exports_Effect.runPromise(patchBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function scoreBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   await exports_Effect.runPromise(scoreBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function markForReviewBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   await exports_Effect.runPromise(markForReviewBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function historyBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   await exports_Effect.runPromise(historyBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function updateBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   await exports_Effect.runPromise(updateBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function closeBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   await exports_Effect.runPromise(closeBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(buildBaseLayer(d))));
 }
 async function exportBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   if (!d.fs) {
     console.error("❌ File system operations not available");
     process.exit(1);
@@ -79296,7 +81610,7 @@ async function exportBacklog(chatroomId, options, deps) {
   await exports_Effect.runPromise(exportBacklogEffect(chatroomId, options).pipe(exports_Effect.catchAll(handleBacklogError), exports_Effect.provide(exports_Layer.merge(buildBaseLayer(d), buildFsLayer(d.fs)))));
 }
 async function importBacklog(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps10();
+  const d = deps ?? await createDefaultDeps11();
   if (!d.fs) {
     console.error("❌ File system operations not available");
     process.exit(1);
@@ -80057,7 +82371,7 @@ __export(exports_read, {
   taskReadEffect: () => taskReadEffect,
   taskRead: () => taskRead
 });
-async function createDefaultDeps11() {
+async function createDefaultDeps12() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80099,7 +82413,7 @@ function handleTaskReadError(err) {
   });
 }
 async function taskRead(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps11();
+  const d = deps ?? await createDefaultDeps12();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(taskReadEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleTaskReadError(err)), exports_Effect.provide(layer)));
 }
@@ -80190,7 +82504,7 @@ __export(exports_skill, {
   activateSkillEffect: () => activateSkillEffect,
   activateSkill: () => activateSkill
 });
-async function createDefaultDeps12() {
+async function createDefaultDeps13() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80259,12 +82573,12 @@ function handleActivateSkillError(err) {
   });
 }
 async function listSkills(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps12();
+  const d = deps ?? await createDefaultDeps13();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(listSkillsEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleListSkillsError(err)), exports_Effect.provide(layer)));
 }
 async function activateSkill(chatroomId, skillId, options, deps) {
-  const d = deps ?? await createDefaultDeps12();
+  const d = deps ?? await createDefaultDeps13();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(activateSkillEffect(chatroomId, skillId, options).pipe(exports_Effect.catchAll((err) => handleActivateSkillError(err)), exports_Effect.provide(layer)));
 }
@@ -80342,7 +82656,7 @@ __export(exports_messages, {
   listBySenderRoleEffect: () => listBySenderRoleEffect,
   listBySenderRole: () => listBySenderRole
 });
-async function createDefaultDeps13() {
+async function createDefaultDeps14() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80403,12 +82717,12 @@ function handleMessagesError(err) {
   });
 }
 async function listBySenderRole(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps13();
+  const d = deps ?? await createDefaultDeps14();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(listBySenderRoleEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleMessagesError(err)), exports_Effect.provide(layer)));
 }
 async function listSinceMessage(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps13();
+  const d = deps ?? await createDefaultDeps14();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(listSinceMessageEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleMessagesError(err)), exports_Effect.provide(layer)));
 }
@@ -80538,7 +82852,7 @@ __export(exports_context2, {
   inspectContextEffect: () => inspectContextEffect,
   inspectContext: () => inspectContext
 });
-async function createDefaultDeps14() {
+async function createDefaultDeps15() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80579,17 +82893,17 @@ function handleContextError(err) {
   });
 }
 async function readContext(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps14();
+  const d = deps ?? await createDefaultDeps15();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(readContextEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleContextError(err)), exports_Effect.provide(layer)));
 }
 async function newContext(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps14();
+  const d = deps ?? await createDefaultDeps15();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(newContextEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleContextError(err)), exports_Effect.provide(layer)));
 }
 async function listContexts(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps14();
+  const d = deps ?? await createDefaultDeps15();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(listContextsEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleContextError(err)), exports_Effect.provide(layer)));
 }
@@ -80597,7 +82911,7 @@ function viewTemplate() {
   return getContextViewTemplate();
 }
 async function inspectContext(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps14();
+  const d = deps ?? await createDefaultDeps15();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(inspectContextEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleContextError(err)), exports_Effect.provide(layer)));
 }
@@ -80838,7 +83152,7 @@ __export(exports_guidelines, {
   listGuidelineTypesEffect: () => listGuidelineTypesEffect,
   listGuidelineTypes: () => listGuidelineTypes
 });
-async function createDefaultDeps15() {
+async function createDefaultDeps16() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80879,12 +83193,12 @@ function handleListGuidelineTypesError(err) {
   });
 }
 async function viewGuidelines(options, deps) {
-  const d = deps ?? await createDefaultDeps15();
+  const d = deps ?? await createDefaultDeps16();
   const layer = layerFromDeps7(d);
   await exports_Effect.runPromise(viewGuidelinesEffect(options).pipe(exports_Effect.catchAll((err) => handleViewGuidelinesError(err)), exports_Effect.provide(layer)));
 }
 async function listGuidelineTypes(deps) {
-  const d = deps ?? await createDefaultDeps15();
+  const d = deps ?? await createDefaultDeps16();
   const layer = layerFromDeps7(d);
   await exports_Effect.runPromise(listGuidelineTypesEffect().pipe(exports_Effect.catchAll((err) => handleListGuidelineTypesError(err)), exports_Effect.provide(layer)));
 }
@@ -80954,7 +83268,7 @@ __export(exports_artifact, {
   createArtifactEffect: () => createArtifactEffect,
   createArtifact: () => createArtifact
 });
-async function createDefaultDeps16() {
+async function createDefaultDeps17() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -80976,19 +83290,19 @@ function handleArtifactError(err) {
   });
 }
 async function createArtifact(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps16();
+  const d = deps ?? await createDefaultDeps17();
   const layer = commandServicesLayerFromDeps(d);
   return exports_Effect.runPromise(createArtifactEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleArtifactError(err).pipe(exports_Effect.map(() => {
     return;
   }))), exports_Effect.provide(layer)));
 }
 async function viewArtifact(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps16();
+  const d = deps ?? await createDefaultDeps17();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(viewArtifactEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleArtifactError(err)), exports_Effect.provide(layer)));
 }
 async function viewManyArtifacts(chatroomId, options, deps) {
-  const d = deps ?? await createDefaultDeps16();
+  const d = deps ?? await createDefaultDeps17();
   const layer = commandServicesLayerFromDeps(d);
   await exports_Effect.runPromise(viewManyArtifactsEffect(chatroomId, options).pipe(exports_Effect.catchAll((err) => handleArtifactError(err)), exports_Effect.provide(layer)));
 }
@@ -81338,7 +83652,7 @@ __export(exports_telegram, {
   sendMessageEffect: () => sendMessageEffect,
   sendMessage: () => sendMessage
 });
-async function createDefaultDeps17() {
+async function createDefaultDeps18() {
   const client4 = await getConvexClient();
   return {
     backend: {
@@ -81420,7 +83734,7 @@ ${err.cause.message}`);
   });
 }
 async function sendMessage(options, deps) {
-  const d = deps ?? await createDefaultDeps17();
+  const d = deps ?? await createDefaultDeps18();
   const layer = layerFromDeps8(d);
   await exports_Effect.runPromise(sendMessageEffect(options).pipe(exports_Effect.catchAll((err) => handleSendMessageError(err)), exports_Effect.provide(layer)));
 }
@@ -81472,7 +83786,7 @@ var init_featureFlags = __esm(() => {
 });
 
 // ../../services/backend/config/reliability.ts
-var HARNESS_SESSION_READY_TIMEOUT_MS = 5000, NATIVE_DELIVERY_RECONCILE_MS = 1e4, DAEMON_HEARTBEAT_INTERVAL_MS, DAEMON_HEARTBEAT_TTL_MS, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVED_FULL_PUSH_INTERVAL_MS, OBSERVED_SAFETY_POLL_MS = 30000, OBSERVED_SYNC_RECONCILE_MS, WORKSPACE_RECENCY_WINDOW_MS, WORKSPACE_LIST_RECONCILE_MS, CONNECTION_CLOSE_REQUEST_TTL_MS;
+var HARNESS_SESSION_READY_TIMEOUT_MS = 5000, NATIVE_DELIVERY_RECONCILE_MS = 1e4, DAEMON_HEARTBEAT_INTERVAL_MS, DAEMON_HEARTBEAT_TTL_MS, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVED_FULL_PUSH_INTERVAL_MS, OBSERVED_SAFETY_POLL_MS = 30000, OBSERVED_SYNC_RECONCILE_MS, WORKSPACE_RECENCY_WINDOW_MS, WORKSPACE_LIST_RECONCILE_MS, CONNECTION_CLOSE_REQUEST_TTL_MS, ENHANCER_TERMINAL_JOB_RETENTION_MS;
 var init_reliability = __esm(() => {
   DAEMON_HEARTBEAT_INTERVAL_MS = 5 * 60000;
   DAEMON_HEARTBEAT_TTL_MS = 6 * DAEMON_HEARTBEAT_INTERVAL_MS;
@@ -81481,6 +83795,7 @@ var init_reliability = __esm(() => {
   WORKSPACE_RECENCY_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
   WORKSPACE_LIST_RECONCILE_MS = 60 * 60 * 1000;
   CONNECTION_CLOSE_REQUEST_TTL_MS = 10 * 60000;
+  ENHANCER_TERMINAL_JOB_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
 });
 
 // src/commands/machine/daemon-start/command-event-types.ts
@@ -101470,6 +103785,108 @@ var init_start_subscriptions2 = __esm(() => {
   init_convex_agentic_query_run_repository();
 });
 
+// src/commands/machine/daemon-start/enhancer/constants.ts
+var ENHANCER_AGENT_ROLE = "enhancer";
+
+// src/commands/machine/daemon-start/enhancer/job-subscriber.ts
+function startEnhancerJobSubscriber(sessionId, machineId, convexUrl, backend2, wsClient2, agentServices) {
+  const inFlight = new Set;
+  const unsub = wsClient2.onUpdate(api.daemon.enhancer.index.pendingForMachine, { sessionId, machineId }, (jobs) => {
+    for (const job of jobs ?? []) {
+      if (inFlight.has(job.jobId))
+        continue;
+      inFlight.add(job.jobId);
+      (async () => {
+        let claimed = false;
+        let chatroomId = job.chatroomId;
+        let jobId = job.jobId;
+        try {
+          const claim = await backend2.mutation(api.daemon.enhancer.index.claimForSpawn, {
+            sessionId,
+            jobId: job.jobId,
+            machineId
+          });
+          if (!claim.claimed)
+            return;
+          claimed = true;
+          const payload = await backend2.query(api.daemon.enhancer.index.getSpawnPayload, {
+            sessionId,
+            jobId: job.jobId
+          });
+          chatroomId = payload.chatroomId;
+          jobId = payload.jobId;
+          const service3 = agentServices.get(payload.agentHarness);
+          if (!service3) {
+            await backend2.mutation(api.web.enhancer.index.recordAttemptFailure, {
+              sessionId,
+              chatroomId: payload.chatroomId,
+              jobId: payload.jobId,
+              error: `Harness ${payload.agentHarness} not available on machine`
+            });
+            return;
+          }
+          const spawnResult = await service3.spawn({
+            workingDir: payload.workingDir,
+            prompt: createSpawnPrompt(payload.taskEnvelope),
+            systemPrompt: payload.systemPrompt,
+            model: payload.model,
+            context: {
+              machineId,
+              chatroomId: payload.chatroomId,
+              role: ENHANCER_AGENT_ROLE
+            },
+            resolvedConvexUrl: convexUrl
+          });
+          spawnResult.onLogLine?.((line) => {
+            process.stdout.write(`${line}
+`);
+          });
+          await new Promise((resolve4) => {
+            spawnResult.onExit(() => resolve4());
+          });
+          const status3 = await backend2.query(api.web.enhancer.index.getJob, {
+            sessionId,
+            chatroomId: payload.chatroomId,
+            jobId: payload.jobId
+          });
+          if (status3?.status === "running") {
+            await backend2.mutation(api.web.enhancer.index.recordAttemptFailure, {
+              sessionId,
+              chatroomId: payload.chatroomId,
+              jobId: payload.jobId,
+              error: "Agent exited without completing enhancer job"
+            });
+          }
+        } catch (err) {
+          console.warn("[enhancer] spawn error:", err instanceof Error ? err.message : String(err));
+          if (claimed) {
+            await backend2.mutation(api.web.enhancer.index.recordAttemptFailure, {
+              sessionId,
+              chatroomId,
+              jobId,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
+        } finally {
+          inFlight.delete(job.jobId);
+        }
+      })();
+    }
+  }, (err) => console.warn("[enhancer] subscription error:", err));
+  return { stop: unsub };
+}
+var init_job_subscriber = __esm(() => {
+  init_api3();
+});
+
+// src/commands/machine/daemon-start/enhancer/start-subscriptions.ts
+function startEnhancerSubscriptions(sessionId, machineId, convexUrl, backend2, wsClient2, agentServices) {
+  return startEnhancerJobSubscriber(sessionId, machineId, convexUrl, backend2, wsClient2, agentServices);
+}
+var init_start_subscriptions3 = __esm(() => {
+  init_job_subscriber();
+});
+
 // src/commands/machine/daemon-start/file-content-classifier.ts
 function extensionOf(path3) {
   const lastDot = path3.lastIndexOf(".");
@@ -108912,7 +111329,7 @@ async function discoverModelsForHarness(harness, service3) {
 async function discoverModels(agentServices) {
   return exports_Effect.runPromise(discoverModelsEffect(agentServices));
 }
-function createDefaultDeps18() {
+function createDefaultDeps19() {
   return {
     backend: {
       mutation: async () => {
@@ -109250,7 +111667,7 @@ var init_init2 = __esm(() => {
       convexUrl,
       agentServices,
       cachedModels,
-      deps: createDefaultDeps18()
+      deps: createDefaultDeps19()
     });
     yield* registerEventListenersEffect().pipe(exports_Effect.provide(daemonSessionToLayers(init2)));
     yield* logStartupEffect(cachedModels).pipe(exports_Effect.provide(daemonSessionToLayers(init2)));
@@ -112217,6 +114634,7 @@ var init_command_loop = __esm(() => {
   init_daemon_services();
   init_start_subscriptions();
   init_start_subscriptions2();
+  init_start_subscriptions3();
   init_file_content_subscription();
   init_file_tree_subscription();
   init_file_write_subscription();
@@ -112403,6 +114821,7 @@ var init_command_loop = __esm(() => {
       }, wsClient2, activeSessions, harnesses);
       aqPendingPromptSubscriptionHandle = aqHandles.pendingPromptSubscriptionHandle;
       aqPendingHarnessSessionSubscriptionHandle = aqHandles.pendingHarnessSessionSubscriptionHandle;
+      const enhancerSub = startEnhancerSubscriptions(session2.sessionId, session2.machineId, session2.convexUrl, session2.backend, wsClient2, session2.agentServices);
     }
     console.log(`
 Listening for commands...`);
@@ -112597,7 +115016,7 @@ async function isChatroomInstalledDefault() {
     return false;
   }
 }
-async function createDefaultDeps19() {
+async function createDefaultDeps20() {
   const client4 = await getConvexClient();
   const fs12 = await import("fs/promises");
   return {
@@ -112672,7 +115091,7 @@ After installation, run this command again.`;
   });
 }
 async function installTool(options = {}, deps) {
-  const d = deps ?? await createDefaultDeps19();
+  const d = deps ?? await createDefaultDeps20();
   const layer = layerFromDeps9(d);
   return exports_Effect.runPromise(installToolEffect(options).pipe(exports_Effect.catchAll((err) => handleInstallError(err)), exports_Effect.provide(layer)));
 }
@@ -113223,6 +115642,50 @@ handoffCommandGroup.requiredOption("--chatroom-id <id>", "Chatroom identifier").
     console.error("❌ Message is empty");
     process.exit(1);
   }
+  const shouldEnhance = options.role.toLowerCase() === "planner" && options.nextRole.toLowerCase() === "builder";
+  if (shouldEnhance) {
+    const { api: api3 } = await Promise.resolve().then(() => (init_api3(), exports_api));
+    const { getConvexClient: getConvexClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+    const { getSessionId: getSessionId2 } = await Promise.resolve().then(() => (init_storage(), exports_storage));
+    const client4 = await getConvexClient2();
+    const sessionId = await getSessionId2();
+    if (sessionId) {
+      try {
+        const config4 = await client4.query(api3.web.enhancer.index.getConfig, {
+          sessionId,
+          chatroomId: options.chatroomId
+        });
+        if (config4 && config4.enabled) {
+          await client4.mutation(api3.web.enhancer.index.enqueueHandoff, {
+            sessionId,
+            chatroomId: options.chatroomId,
+            senderRole: options.role,
+            targetRole: options.nextRole,
+            content: message
+          });
+          const { generateHandoffOutput: generateHandoffOutput2 } = await Promise.resolve().then(() => (init_generator(), exports_generator));
+          const { getConvexUrl: getConvexUrl2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+          const convexUrl = await getConvexUrl2();
+          console.log(generateHandoffOutput2({
+            role: options.role,
+            nextRole: options.nextRole,
+            chatroomId: options.chatroomId,
+            convexUrl
+          }));
+          return;
+        }
+      } catch (err) {
+        const error51 = err;
+        if (error51?.data?.code !== "ENHANCER_NOT_ENABLED") {
+          console.error(`
+❌ ERROR: Enhancer interception failed`);
+          console.error(`
+${error51?.data?.message ?? err.message}`);
+          process.exit(1);
+        }
+      }
+    }
+  }
   const { handoff: handoff2 } = await Promise.resolve().then(() => (init_handoff(), exports_handoff));
   await handoff2(options.chatroomId, {
     role: options.role,
@@ -113257,6 +115720,29 @@ agenticQueryCommand.command("complete").description("Submit the structured agent
     result
   });
 });
+var enhancerCommand = program2.command("enhancer").description("Handoff enhancer commands");
+enhancerCommand.command("complete").description("Submit the enhanced handoff markdown").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--job-id <id>", "Enhancer job identifier").action(async (options) => {
+  await maybeRequireAuth();
+  const { decode: decode5 } = await Promise.resolve().then(() => exports_decode);
+  const stdinContent = await readStdin();
+  let body;
+  try {
+    const { ENHANCER_STDIN_DELIMITER: ENHANCER_STDIN_DELIMITER2, HANDOFF_MESSAGE_MARKER: HANDOFF_MESSAGE_MARKER2, validateStdinHeredocBody: validateStdinHeredocBody2 } = await Promise.resolve().then(() => (init_stdin_heredoc(), exports_stdin_heredoc));
+    const decoded = decode5(stdinContent, { singleParam: "result" });
+    body = decoded.result;
+    body = body.replace(new RegExp(`^(${HANDOFF_MESSAGE_MARKER2}\\s*)+`, "i"), "").trim();
+    validateStdinHeredocBody2(body, ENHANCER_STDIN_DELIMITER2);
+  } catch (err) {
+    console.error(`❌ Failed to decode stdin: ${err.message}`);
+    process.exit(1);
+  }
+  if (!body?.trim()) {
+    console.error("❌ Enhanced handoff body is empty");
+    process.exit(1);
+  }
+  const { enhancerComplete: enhancerComplete2 } = await Promise.resolve().then(() => (init_complete2(), exports_complete2));
+  await enhancerComplete2(options.chatroomId, { jobId: options.jobId, enhancedContent: body });
+});
 var backlogCommand = program2.command("backlog").description("Manage task queue and backlog");
 backlogCommand.command("list").description("List backlog items").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").option("--limit <n>", "Maximum number of items to show").option("--sort <sort>", "Sort order: date:desc (default) | priority:desc").option("--filter <filter>", "Filter: unscored (only items without priority score)").action(async (options) => {
   await maybeRequireAuth();
@@ -113541,4 +116027,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=5D81C0C1AF371BE564756E2164756E21
+//# debugId=84E53044E3B850A464756E2164756E21