chatroom-cli 1.77.5 → 1.79.0

package/dist/index.js

@@ -9916,10 +9916,6 @@ var init_api2 = __esm(() => {
 });
 
 // src/api.ts
-var exports_api = {};
-__export(exports_api, {
-  api: () => api
-});
 var init_api3 = __esm(() => {
   init_api2();
 });
@@ -33039,6 +33035,7 @@ function startSessionEventForwarder(client4, options) {
       }
       case "busy": {
         clearRetryIdleTimeout();
+        options.onActivity?.();
         return;
       }
       default: {
@@ -76374,24 +76371,6 @@ 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;
@@ -76410,60 +76389,20 @@ 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();
 });
@@ -76485,14 +76424,6 @@ 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(() => {
@@ -76500,65 +76431,16 @@ 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
@@ -77373,35 +77255,52 @@ var init_builder_to_planner = __esm(() => {
   init_role_guidance_disclosure();
 });
 
-// ../../services/backend/prompts/teams/duo/handoff-templates/enhancer-to-planner.ts
-function getEnhancerToPlannerHandoffTemplate() {
-  return `${getHandoffRecipientVisibilityCallout("planner")}
-
-${getHandoffReportTemplateIntro("Planning Feedback (Enhancer → Planner)")}
-
-The planner sent you three XML sections. Your job is **advisory adversarial review** — raise risks, challenge assumptions, and help the planner align with user intent. **Do not prescribe file-level changes or rewrite their builder brief.** The planner makes the final call.
-
-\`\`\`markdown
+// ../../services/backend/prompts/utils/enhancer-feedback-template-body.ts
+function getEnhancerFeedbackTemplateBody() {
+  return `<handoff-overview>
 ## Summary
 <one paragraph: overall assessment — strengths, main risks, and whether the approach is sound>
 
 ## User intent alignment
 <does the planner's reading of the user request match what was asked? misreadings or missing constraints?>
+</handoff-overview>
 
-## Risks &amp; failure modes
-<what could go wrong if they proceed as planned? common pitfalls for this kind of work?>
+<!-- UI collapses proofs, direction, and notes by default; overview and action required are expanded -->
 
+<handoff-proofs>
+## Reasoning review
+<logical errors, weak inference, contradictions — challenge assumptions>
+</handoff-proofs>
+
+<handoff-direction>
+## Alignment with eventual user handoff
+<will this approach produce a credible planner→user report? what's missing for user-facing completeness?>
+</handoff-direction>
+
+<handoff-notes>
 ## Knowledge gaps
 <facts, context, or research the planner should verify — advisory questions, not answers from codebase>
+</handoff-notes>
 
-## Reasoning review
-<logical errors, weak inference, contradictions — challenge assumptions>
+<handoff-action>
+## Risks & failure modes
+<what could go wrong if they proceed as planned? common pitfalls for this kind of work?>
 
 ## Questions for the planner
 <specific questions they should answer before delegating — not instructions disguised as questions>
+</handoff-action>`;
+}
 
-## Alignment with eventual user handoff
-<will this approach produce a credible planner→user report? what's missing for user-facing completeness?>
+// ../../services/backend/prompts/teams/duo/handoff-templates/enhancer-to-planner.ts
+function getEnhancerToPlannerHandoffTemplate() {
+  return `${getHandoffRecipientVisibilityCallout("planner")}
+
+${getHandoffReportTemplateIntro("Planning Feedback (Enhancer → Planner)")}
+
+The planner sent you three XML sections. Your job is **advisory adversarial review** — raise risks, challenge assumptions, and help the planner align with user intent. **Do not prescribe file-level changes or rewrite their builder brief.** The planner makes the final call.
+
+\`\`\`markdown
+${getEnhancerFeedbackTemplateBody()}
 \`\`\`
 
 Return only the feedback markdown — no preamble. Follow this structure; omit sections that truly do not apply.`;
@@ -77910,24 +77809,6 @@ 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 = [
     "",
@@ -77943,103 +77824,10 @@ 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();
@@ -78048,650 +77836,25 @@ 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 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
-\`\`\``
-  };
-});
+var init_code_review = () => {};
 
 // ../../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();
@@ -78742,257 +77905,10 @@ 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
-
-**Completion gates (before PR or handoff):**
-- All **(Required)** files done; **verified end-to-end** (user-facing entry point works: CLI command runnable, API reachable, or UI action functional)
-- If blocked → ## Blockers / questions to planner. No PR or \`mark-for-review\` until gates pass — unless the user explicitly requested a draft or incremental PR
-`;
-}
 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.
-- **A slice is shippable only when verified end-to-end** — infra/helper files alone are not a complete slice.
-- **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 → replan or hand back to planner as blocked. No partial PR, \`mark-for-review\`, or user delivery.
-
-**Review loop:**
-- Review completed work before moving to the next slice.
-- Send back with specific feedback if requirements aren't met.
-- ${feedingNote}.
-
-**When enhancement is enabled:** See \`<handoff-enhancer>\` in task delivery — one check-in per delegation before builder.`;
-}
-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)",
-    config3.hasBuilder ? "- **When enhancement is enabled** → See `<handoff-enhancer>` in task delivery before each builder delegation" : null,
-    "- **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"
-  ].filter((line) => line !== null).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 (including partial work) → hand back to `builder` for rework" : "3. If requirements are NOT met (including partial work) → revise 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
@@ -79002,126 +77918,17 @@ 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();
@@ -79129,229 +77936,32 @@ 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();
@@ -79359,151 +77969,19 @@ 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
-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"
-    }
-  };
-});
+var init_templates = () => {};
 
 // ../../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();
@@ -79513,46 +77991,11 @@ 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();
@@ -79560,118 +78003,23 @@ 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
@@ -79876,571 +78224,9 @@ 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 isEnhancerCheckInQueuedHandoff(params) {
   return params.enhancerCheckInQueued === true && params.role.toLowerCase() === "planner" && params.nextRole.toLowerCase() === "enhancer";
 }
@@ -80480,17 +78266,6 @@ 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();
@@ -99284,6 +97059,30 @@ var init_assigned_task_snapshot_store = __esm(() => {
   rows = [];
 });
 
+// src/commands/machine/daemon-start/restart-orchestrator-in-flight.ts
+function roleKey2(chatroomId, role) {
+  return `${chatroomId}:${role.toLowerCase()}`;
+}
+function markRestartOrchestratorInFlight(chatroomId, role, correlationId) {
+  inFlight.set(roleKey2(chatroomId, role), correlationId);
+}
+function clearRestartOrchestratorInFlight(chatroomId, role, correlationId) {
+  const key = roleKey2(chatroomId, role);
+  if (correlationId !== undefined && inFlight.get(key) !== correlationId)
+    return;
+  inFlight.delete(key);
+}
+function isRestartOrchestratorInFlight(chatroomId, role) {
+  return inFlight.has(roleKey2(chatroomId, role));
+}
+function filterSnapshotsExcludingRestartInFlight(snapshots) {
+  return snapshots.filter((row) => !isRestartOrchestratorInFlight(row.chatroomId, row.agentConfig.role));
+}
+var inFlight;
+var init_restart_orchestrator_in_flight = __esm(() => {
+  inFlight = new Map;
+});
+
 // src/commands/machine/daemon-start/native-task-delivery-coordinator.ts
 class NativeTaskDeliveryCoordinator {
   onSessionLost(params) {
@@ -99296,6 +97095,8 @@ class NativeTaskDeliveryCoordinator {
     getRoleDeliveryState().resetDeliveryState(chatroomId, role);
   }
   tryInjectNextForRole(chatroomId, role) {
+    if (isRestartOrchestratorInFlight(chatroomId, role))
+      return;
     const session2 = getNativeDeliverySession();
     if (!session2)
       return;
@@ -99315,7 +97116,10 @@ class NativeTaskDeliveryCoordinator {
     });
   }
   reconcileAssignedTasks(params) {
-    const { tasks, runtime: runtime4, effectContext: effectContext2, agentMgr, sessionDeps, machineId } = params;
+    const tasks = filterSnapshotsExcludingRestartInFlight(params.tasks);
+    if (tasks.length === 0)
+      return;
+    const { runtime: runtime4, effectContext: effectContext2, agentMgr, sessionDeps, machineId } = params;
     const deliveryState = getRoleDeliveryState();
     const ledger = getNativeDeliveryLedger();
     const pendingFirst = [...tasks].sort((a, b) => {
@@ -99404,6 +97208,8 @@ function resetRoleDeliveryState(chatroomId, role) {
   getRoleDeliveryState().resetDeliveryState(chatroomId, role);
 }
 function notifyNativeTurnIdle(params) {
+  if (isRestartOrchestratorInFlight(params.chatroomId, params.role))
+    return;
   logNativeDeliveryPrimary(params.role, params.chatroomId);
   getNativeTaskDeliveryCoordinator().tryInjectNextForRole(params.chatroomId, params.role);
 }
@@ -99416,6 +97222,7 @@ var init_native_task_delivery_coordinator = __esm(() => {
   init_api3();
   init_assigned_task_snapshot_store();
   init_convex_error();
+  init_restart_orchestrator_in_flight();
 });
 
 // src/commands/machine/daemon-start/restart-orchestrator.ts
@@ -99438,14 +97245,6 @@ async function waitForHarnessSessionId(deps, event, pid) {
   if (initial?.harnessSessionId) {
     return initial.harnessSessionId;
   }
-  await deps.session.backend.mutation(api.machines.emitHarnessSessionAwaiting, {
-    sessionId: deps.session.sessionId,
-    machineId: deps.session.machineId,
-    chatroomId: event.chatroomId,
-    role: event.role,
-    pid,
-    timeoutMs: HARNESS_SESSION_READY_TIMEOUT_MS
-  });
   const deadline = Date.now() + HARNESS_SESSION_READY_TIMEOUT_MS;
   while (Date.now() < deadline) {
     const slot = deps.agentMgr.getSlot(event.chatroomId, event.role);
@@ -99454,14 +97253,6 @@ async function waitForHarnessSessionId(deps, event, pid) {
     }
     await sleep5(100);
   }
-  await deps.session.backend.mutation(api.machines.emitHarnessSessionTimeout, {
-    sessionId: deps.session.sessionId,
-    machineId: deps.session.machineId,
-    chatroomId: event.chatroomId,
-    role: event.role,
-    pid,
-    timeoutMs: HARNESS_SESSION_READY_TIMEOUT_MS
-  });
   await deps.agentMgr.stop({
     chatroomId: event.chatroomId,
     role: event.role,
@@ -99556,15 +97347,14 @@ async function deliverPendingTasks(deps, event) {
 }
 async function runRestartOrchestrator(deps, event) {
   const { chatroomId, role } = event;
+  markRestartOrchestratorInFlight(chatroomId, role, event.correlationId);
   try {
-    await emitPhase(deps, event, "reset");
     resetRoleDeliveryState(chatroomId, role);
     await deps.agentMgr.stop({
       chatroomId,
       role,
       reason: "user.restart"
     });
-    await emitPhase(deps, event, "spawn");
     const spawnResult = await exports_Effect.runPromise(deps.agentMgr.ensureRunning({
       chatroomId,
       role,
@@ -99578,23 +97368,12 @@ async function runRestartOrchestrator(deps, event) {
       await emitPhase(deps, event, "failed", spawnResult.error ?? "spawn failed");
       return;
     }
-    await emitPhase(deps, event, "await_session");
     const harnessSessionId = await waitForHarnessSessionId(deps, event, spawnResult.pid);
     if (!harnessSessionId) {
       await emitPhase(deps, event, "failed", "harnessSessionId timeout");
       return;
     }
-    await deps.session.backend.mutation(api.machines.emitHarnessSessionReady, {
-      sessionId: deps.session.sessionId,
-      machineId: deps.session.machineId,
-      chatroomId,
-      role,
-      harnessSessionId,
-      pid: spawnResult.pid
-    });
     await forceNativeWaiting(deps, event);
-    await emitPhase(deps, event, "ready");
-    await emitPhase(deps, event, "deliver");
     const deliveredTaskIds = await deliverPendingTasks(deps, event);
     await deps.session.backend.mutation(api.machines.emitRestartCompleted, {
       sessionId: deps.session.sessionId,
@@ -99604,10 +97383,11 @@ async function runRestartOrchestrator(deps, event) {
       correlationId: event.correlationId,
       deliveredTaskIds
     });
-    await emitPhase(deps, event, "completed");
   } catch (err) {
     console.warn(`[RestartOrchestrator] failed for ${role}@${chatroomId}: ${getErrorMessage(err)}`);
     await emitPhase(deps, event, "failed", getErrorMessage(err));
+  } finally {
+    clearRestartOrchestratorInFlight(chatroomId, role, event.correlationId);
   }
 }
 var init_restart_orchestrator = __esm(() => {
@@ -99621,6 +97401,7 @@ var init_restart_orchestrator = __esm(() => {
   init_native_task_injector();
   init_api3();
   init_convex_error();
+  init_restart_orchestrator_in_flight();
 });
 
 // src/events/daemon/agent/on-request-restart-agent.ts
@@ -100742,6 +98523,17 @@ async function openFinder(workingDir) {
   execFireAndForget(`${cmd} ${escapeShellArg(workingDir)}`, "open-finder");
   return { success: true };
 }
+async function openCursor(workingDir) {
+  const available = await isCliAvailable("cursor");
+  if (!available) {
+    return {
+      success: false,
+      error: "Cursor CLI (cursor) not found. Install via: Cursor → Cmd+Shift+P → 'Shell Command: Install cursor in PATH'"
+    };
+  }
+  execFireAndForget(`cursor ${escapeShellArg(workingDir)}`, "open-cursor");
+  return { success: true };
+}
 async function openGithubDesktop(workingDir) {
   const available = await isCliAvailable("github");
   if (!available) {
@@ -100816,6 +98608,7 @@ var init_execute_local_action = __esm(() => {
   actionHandlers = {
     "open-vscode": openVscode,
     "open-finder": openFinder,
+    "open-cursor": openCursor,
     "open-github-desktop": openGithubDesktop,
     "git-discard-file": gitDiscardFileAction,
     "git-discard-all": gitDiscardAllAction,
@@ -103236,7 +101029,7 @@ var init_open_pending_session = __esm(() => {
 
 // src/commands/machine/daemon-start/direct-harness/session-subscriber.ts
 function startSessionSubscriber(daemonSession, wsClient2, deps) {
-  const inFlight = new Set;
+  const inFlight2 = new Set;
   const unsub = wsClient2.onUpdate(api.daemon.directHarness.sessions.listPendingSessionsForMachine, {
     sessionId: daemonSession.sessionId,
     machineId: daemonSession.machineId
@@ -103245,9 +101038,9 @@ function startSessionSubscriber(daemonSession, wsClient2, deps) {
       return;
     for (const session2 of pendingSessions) {
       const rowId = session2._id;
-      if (inFlight.has(rowId))
+      if (inFlight2.has(rowId))
         continue;
-      inFlight.add(rowId);
+      inFlight2.add(rowId);
       (async () => {
         const harnessName = session2.opencode?.harnessName ?? "opencode-sdk";
         const agent = session2.opencode?.lastUsedConfig?.agent ?? "build";
@@ -103258,7 +101051,7 @@ function startSessionSubscriber(daemonSession, wsClient2, deps) {
           harnessName,
           lastUsedConfig: { agent, ...model ? { model } : {} }
         }, { logPrefix: "[direct-harness]", handleProviderIdEvents: true });
-      })().finally(() => inFlight.delete(rowId));
+      })().finally(() => inFlight2.delete(rowId));
     }
   }, (err) => {
     console.warn("[direct-harness] Session subscription error:", err instanceof Error ? err.message : String(err));
@@ -103793,21 +101586,21 @@ var init_prompt_subscriber2 = __esm(() => {
 
 // src/commands/machine/daemon-start/agentic-query/session-subscriber.ts
 function startSessionSubscriber2(daemonSession, wsClient2, deps) {
-  const inFlight = new Set;
+  const inFlight2 = new Set;
   const unsub = wsClient2.onUpdate(api.daemon.agenticQuery.runs.pendingForMachine, { sessionId: daemonSession.sessionId, machineId: daemonSession.machineId }, (pendingSessions) => {
     if (!pendingSessions || pendingSessions.length === 0)
       return;
     for (const session2 of pendingSessions) {
       const rowId = session2.runId;
-      if (inFlight.has(rowId))
+      if (inFlight2.has(rowId))
         continue;
-      inFlight.add(rowId);
+      inFlight2.add(rowId);
       openPendingHarnessSession(daemonSession, deps, {
         rowId: session2.runId,
         workspaceId: session2.workspaceId,
         harnessName: session2.harnessName,
         lastUsedConfig: session2.lastUsedConfig
-      }, { logPrefix: "[agentic-query]", handleProviderIdEvents: false }).finally(() => inFlight.delete(rowId));
+      }, { logPrefix: "[agentic-query]", handleProviderIdEvents: false }).finally(() => inFlight2.delete(rowId));
     }
   }, (err) => {
     console.warn("[agentic-query] Session subscription error:", err instanceof Error ? err.message : String(err));
@@ -104100,12 +101893,12 @@ var init_wait_for_enhancer_job = __esm(() => {
 
 // src/commands/machine/daemon-start/enhancer/job-subscriber.ts
 function startEnhancerJobSubscriber(sessionId, machineId, convexUrl, backend2, wsClient2, agentServices) {
-  const inFlight = new Set;
+  const inFlight2 = new Set;
   const unsub = wsClient2.onUpdate(api.daemon.enhancer.index.pendingForMachine, { sessionId, machineId }, (jobs) => {
     for (const job of jobs ?? []) {
-      if (inFlight.has(job.jobId))
+      if (inFlight2.has(job.jobId))
         continue;
-      inFlight.add(job.jobId);
+      inFlight2.add(job.jobId);
       (async () => {
         let claimed = false;
         let chatroomId = job.chatroomId;
@@ -104139,7 +101932,7 @@ function startEnhancerJobSubscriber(sessionId, machineId, convexUrl, backend2, w
             });
             return;
           }
-          spawnResult = await service3.spawn({
+          const spawned = await service3.spawn({
             workingDir: payload.workingDir,
             prompt: createSpawnPrompt(payload.taskEnvelope),
             systemPrompt: payload.systemPrompt,
@@ -104151,18 +101944,18 @@ function startEnhancerJobSubscriber(sessionId, machineId, convexUrl, backend2, w
             },
             resolvedConvexUrl: convexUrl
           });
-          spawnResult.onLogLine?.((line) => {
+          spawnResult = spawned;
+          spawned.onLogLine?.((line) => {
             writeEnhancerLog(line);
           });
-          const sr = spawnResult;
-          const outcome = await waitForEnhancerJobResolution({
+          await waitForEnhancerJobResolution({
             sessionId,
             chatroomId: payload.chatroomId,
             jobId: payload.jobId,
             backend: backend2,
-            onAssistantText: sr.onAssistantText ? (cb) => sr.onAssistantText(cb) : undefined,
-            onAgentEnd: sr.onAgentEnd ? (cb) => sr.onAgentEnd(cb) : undefined,
-            onExit: (cb) => sr.onExit(() => cb()),
+            onAssistantText: spawned.onAssistantText ? (cb) => spawned.onAssistantText?.(cb) : undefined,
+            onAgentEnd: spawned.onAgentEnd ? (cb) => spawned.onAgentEnd?.(cb) : undefined,
+            onExit: (cb) => spawned.onExit(() => cb()),
             onSalvageComplete: async (content) => {
               await backend2.mutation(api.web.enhancer.index.complete, {
                 sessionId,
@@ -104193,7 +101986,7 @@ function startEnhancerJobSubscriber(sessionId, machineId, convexUrl, backend2, w
             });
           }
         } finally {
-          inFlight.delete(job.jobId);
+          inFlight2.delete(job.jobId);
           if (spawnResult && service3) {
             try {
               await service3.stop(spawnResult.pid);
@@ -109435,6 +107228,53 @@ var init_crash_loop_tracker = __esm(() => {
   ];
 });
 
+// src/infrastructure/services/remote-agents/native-spawn-presence.ts
+async function emitNativeWaitingAfterSpawn(ctx, harness, opts) {
+  if (!getHarnessCapabilities(harness).supportsNativeIntegration) {
+    return false;
+  }
+  try {
+    await ctx.backend.mutation(api.participants.join, {
+      sessionId: ctx.sessionId,
+      chatroomId: ctx.chatroomId,
+      role: ctx.role,
+      action: NATIVE_WAITING_ACTION
+    });
+    return true;
+  } catch (err) {
+    const error51 = err instanceof Error ? err : new Error(String(err));
+    if (opts?.onError) {
+      opts.onError(error51);
+    }
+    return false;
+  }
+}
+function wireThrottledTokenActivityOnOutput(opts) {
+  const now = opts.now ?? (() => Date.now());
+  const throttleMs = opts.throttleMs ?? NATIVE_TOKEN_ACTIVITY_THROTTLE_MS;
+  let lastReportedTokenAt = 0;
+  const register = opts.spawnResult.onOutput;
+  if (!register)
+    return;
+  register(() => {
+    const t = now();
+    if (lastReportedTokenAt === 0 || t - lastReportedTokenAt >= throttleMs) {
+      lastReportedTokenAt = t;
+      opts.backend.mutation(api.participants.updateTokenActivity, {
+        sessionId: opts.sessionId,
+        chatroomId: opts.chatroomId,
+        role: opts.role
+      }).catch(() => {});
+    }
+  });
+}
+var NATIVE_TOKEN_ACTIVITY_THROTTLE_MS = 30000;
+var init_native_spawn_presence = __esm(() => {
+  init_participant();
+  init_types();
+  init_api3();
+});
+
 // src/infrastructure/services/agent-process-manager/turn-completed-backend.ts
 function createTurnCompletedBackend(deps) {
   return {
@@ -111275,17 +109115,13 @@ class AgentProcessManager {
         this.applyHarnessSessionIdUpdate(slotKey, slot, opts.chatroomId, opts.role, info);
       });
     }
-    let lastReportedTokenAt = 0;
-    spawnResult.onOutput(() => {
-      const now = this.deps.clock.now();
-      if (lastReportedTokenAt === 0 || now - lastReportedTokenAt >= 30000) {
-        lastReportedTokenAt = now;
-        this.deps.backend.mutation(api.participants.updateTokenActivity, {
-          sessionId: this.deps.sessionId,
-          chatroomId: opts.chatroomId,
-          role: opts.role
-        }).catch(() => {});
-      }
+    wireThrottledTokenActivityOnOutput({
+      backend: this.deps.backend,
+      sessionId: this.deps.sessionId,
+      chatroomId: opts.chatroomId,
+      role: opts.role,
+      spawnResult,
+      now: () => this.deps.clock.now()
     });
   }
   async finalizeRunningSlot(key, slot, opts, spawnResult, wantResume) {
@@ -111302,20 +109138,16 @@ class AgentProcessManager {
     await this.emitNativeWaiting(opts.chatroomId, opts.role, opts.agentHarness);
   }
   async emitNativeWaiting(chatroomId, role, harness) {
-    if (!getHarnessCapabilities(harness).supportsNativeIntegration)
-      return false;
-    try {
-      await this.deps.backend.mutation(api.participants.join, {
-        sessionId: this.deps.sessionId,
-        chatroomId,
-        role,
-        action: NATIVE_WAITING_ACTION
-      });
-      return true;
-    } catch (err) {
-      console.log(`   ⚠️  Failed to emit native:waiting for ${role}: ${err.message}`);
-      return false;
-    }
+    return emitNativeWaitingAfterSpawn({
+      backend: this.deps.backend,
+      sessionId: this.deps.sessionId,
+      chatroomId,
+      role
+    }, harness, {
+      onError: (err) => {
+        console.log(`   ⚠️  Failed to emit native:waiting for ${role}: ${err.message}`);
+      }
+    });
   }
   async doEnsureRunning(key, slot, opts) {
     slot.state = "spawning";
@@ -111503,6 +109335,7 @@ var AGENT_EXIT_RETRY_INTERVAL_MS = 1e4, STOPPING_TIMEOUT_MS = 30000;
 var init_agent_process_manager = __esm(() => {
   init_types();
   init_participant();
+  init_native_spawn_presence();
   init_esm();
   init_turn_completed_backend();
   init_api3();
@@ -114513,6 +112346,8 @@ async function nudgeStuckTasks(tasks, now, cooldown, runtime4, effectContext2, a
 }
 async function reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId) {
   for (const row of listNativeTasksNeedingRevive(tasks, localHealth, now, cooldown)) {
+    if (isRestartOrchestratorInFlight(row.chatroomId, row.agentConfig.role))
+      continue;
     await clearStuckStoppingSlotIfNeeded(agentMgr, row.chatroomId, row.agentConfig.role);
     const full = await fetchTaskForAction(sessionDeps, machineId, row);
     if (!full)
@@ -114521,6 +112356,7 @@ async function reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, ef
   }
 }
 async function processTasksUpdate(tasks, runtime4, effectContext2, cooldown, agentMgr, sessionDeps, machineId, _pass) {
+  tasks = filterSnapshotsExcludingRestartInFlight(tasks);
   if (tasks.length === 0)
     return;
   const now = Date.now();
@@ -114557,7 +112393,7 @@ function runLocalStoreReconcilePass(params) {
   const { stopped, monitorPassInFlight, agentMgr, runtime: runtime4, effectContext: effectContext2, sessionDeps, machineId } = params;
   if (stopped || monitorPassInFlight)
     return;
-  const deliverable = listDeliverablePendingFromStore(agentMgr);
+  const deliverable = filterSnapshotsExcludingRestartInFlight(listDeliverablePendingFromStore(agentMgr));
   if (deliverable.length === 0)
     return;
   const first = deliverable[0];
@@ -114700,6 +112536,7 @@ var init_task_monitor = __esm(() => {
   init_esm();
   init_daemon_services();
   init_native_ready_invariant();
+  init_restart_orchestrator_in_flight();
   init_native_task_delivery_coordinator();
   init_native_task_injector_logic();
   init_task_monitor_logic();
@@ -115973,51 +113810,6 @@ handoffCommandGroup.requiredOption("--chatroom-id <id>", "Chatroom identifier").
     console.error("❌ Message is empty");
     process.exit(1);
   }
-  const shouldEnhance = options.role.toLowerCase() === "planner" && options.nextRole.toLowerCase() === "enhancer";
-  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,
-            enhancerCheckInQueued: true
-          }));
-          return;
-        }
-      } catch (err) {
-        const error51 = err;
-        if (error51?.data?.code !== "ENHANCER_NOT_ENABLED") {
-          console.error(`
-❌ ERROR: Enhancer check-in 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,
@@ -116359,4 +114151,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=139534CD91C868F464756E2164756E21
+//# debugId=8401A70A2CD118D564756E2164756E21