chatroom-cli 1.131.2 → 1.132.1

package/dist/index.js

@@ -20412,6 +20412,10 @@ var init_agent_role = __esm(() => {
         { teamId: "duo", order: 45 },
         { teamId: "solo", order: 45 }
       ]
+    },
+    reviewer: {
+      tags: ["ephemeral" /* Ephemeral */],
+      teams: [{ teamId: "duo", order: 35 }]
     }
   };
   AGENT_ROLE_DEFINITIONS = Object.fromEntries(Object.entries(roleMetadata).map(([role, metadata]) => [role, { role, ...metadata }]));
@@ -100027,7 +100031,7 @@ var init_team_presets = __esm(() => {
     duo: {
       structureId: TEAM_STRUCTURE_IDS.duo,
       name: "Duo",
-      description: "A planner and builder working as a pair, planner as coordinator, with optional ephemeral architect, researcher, triage, uiux-engineer, and verifier roles",
+      description: "A planner and builder working as a pair, planner as coordinator, with optional ephemeral architect, researcher, triage, reviewer, uiux-engineer, and verifier roles",
       roles: getBuiltinRolesForTeam("duo"),
       entryPoint: "planner"
     },
@@ -100231,6 +100235,119 @@ var init_agent2 = __esm(() => {
   init_storage2();
 });
 
+// ../../services/backend/prompts/cli/handoff-templates/pair.ts
+function normalizeHandoffRole(value2) {
+  if (value2 === undefined)
+    return;
+  const normalized = value2.trim().toLowerCase();
+  return normalized === "" ? undefined : normalized;
+}
+function normalizeHandoffMode(value2) {
+  if (value2 === undefined)
+    return;
+  const normalized = value2.trim().toLowerCase();
+  return normalized === "" ? undefined : normalized;
+}
+function isConversationMode2(value2) {
+  return CONVERSATION_MODES.includes(value2);
+}
+function modeBucket(mode) {
+  return mode === "chat" ? "chat" : "code";
+}
+function formatHandoffTemplateKey(selection) {
+  const { pair, mode } = selection;
+  return `${pair.teamId}:${pair.fromRole}->${pair.toRole}@${modeBucket(mode)}`;
+}
+function isTeamPresetId(value2) {
+  return TEAM_PRESET_IDS.includes(value2);
+}
+function formatHandoffPairLabel(pair) {
+  return `\`${pair.fromRole}\` → \`${pair.toRole}\``;
+}
+function formatHandoffTemplateCommand(command, pair, cliEnvPrefix = "", modeArg) {
+  const modeFlag = modeArg === undefined ? "" : ` --mode="${modeArg}"`;
+  return `${cliEnvPrefix}chatroom handoff ${command} --from="${pair.fromRole}" --to="${pair.toRole}"${modeFlag} --team-id="${pair.teamId}"`;
+}
+function missingPairMessage(command, missing) {
+  return [
+    `handoff ${command} requires both --from and --to (missing: ${missing}). Handoff templates are keyed by the (sender, recipient) pair.`,
+    `Example: chatroom handoff ${command} --from="planner" --to="builder" --mode="code" --team-id="duo"`
+  ].join(`
+`);
+}
+function missingModeMessage(command) {
+  return [
+    `handoff ${command} requires --mode (missing: --mode). Handoff templates are keyed by the (sender, recipient) pair and the conversation mode.`,
+    `Example: chatroom handoff ${command} --from="planner" --to="user" --mode="chat" --team-id="duo"`
+  ].join(`
+`);
+}
+function unknownModeMessage(mode) {
+  return `Unknown mode "${mode}". Valid modes: ${CONVERSATION_MODES.join(", ")}.`;
+}
+function legacyRoleFlagsMessage(command, input) {
+  const header = `handoff ${command} no longer accepts --role/--next-role. Handoff templates are keyed by the (sender, recipient) pair.`;
+  const modeArg = input.mode ?? "<chat|code|code:enhanced>";
+  if (input.legacyRole !== undefined && input.legacyNextRole !== undefined) {
+    return [
+      header,
+      `Use: ${formatHandoffTemplateCommand(command, {
+        teamId: input.teamId,
+        fromRole: input.legacyRole,
+        toRole: input.legacyNextRole
+      }, "", modeArg)}`
+    ].join(`
+`);
+  }
+  if (input.legacyRole !== undefined && input.rolePairs && input.rolePairs.length > 0) {
+    return [
+      header,
+      `Pairs from "${input.legacyRole}" in team "${input.teamId}":`,
+      ...input.rolePairs.map((pair) => `  ${formatHandoffTemplateCommand(command, pair, "", modeArg)}`)
+    ].join(`
+`);
+  }
+  const to = input.legacyNextRole ?? "<recipient-role>";
+  return [
+    header,
+    `Use: chatroom handoff ${command} --from="<your-role>" --to="${to}" --mode="${modeArg}" --team-id="${input.teamId}"`
+  ].join(`
+`);
+}
+function unknownTeamMessage(team) {
+  return `Unknown team "${team}". Known teams: ${TEAM_PRESET_IDS.join(", ")}.`;
+}
+function unknownFromRoleMessage(input) {
+  return `Role "${input.from}" has no handoff templates in team "${input.team}". Roles with handoff templates: ${input.roles.join(", ")}.`;
+}
+function unknownPairMessage(input) {
+  return `No handoff template for "${input.from}" → "${input.to}" in team "${input.team}". Valid recipients for "${input.from}": ${input.recipients.join(", ")}.`;
+}
+function unrenderablePairMessage(pair) {
+  return `No handoff template for "${pair.fromRole}" → "${pair.toRole}" in team "${pair.teamId}".`;
+}
+var HandoffTemplatePairError, DEFAULT_HANDOFF_TEAM_ID = "duo";
+var init_pair = __esm(() => {
+  init_conversation_mode();
+  init_team_kind();
+  HandoffTemplatePairError = class HandoffTemplatePairError extends Error {
+    code;
+    constructor(code2, message) {
+      super(message);
+      this.code = code2;
+      this.name = "HandoffTemplatePairError";
+    }
+  };
+});
+
+// ../../services/backend/prompts/native/handoff-visibility.ts
+function getHandoffRecipientVisibilityCallout(toRole) {
+  const recipient = toRole.toLowerCase() === "user" ? "user" : `\`${toRole}\` agent`;
+  const sendCommand = `\`handoff --next-role="${toRole}"\``;
+  return `> ⚠️ **Template notice — not part of the message. Do not copy this notice into your handoff.**
+> Recipient visibility: the ${recipient} receives only the text inside your ${sendCommand} command${toRole.toLowerCase() === "user" ? ", plus any `notify-user` notices you sent earlier in this task" : ""}. It cannot see anything you write in this agent session${toRole.toLowerCase() === "user" ? " (including direct replies)" : ""}, or tool output. Put your complete deliverable in the handoff message.`;
+}
+
 // ../../services/backend/prompts/cli/handoff/command.ts
 function handoffCommand(params) {
   const prefix = params.cliEnvPrefix || "";
@@ -100247,39 +100364,6 @@ var init_command2 = __esm(() => {
   init_stdin_heredoc();
 });
 
-// ../../services/backend/prompts/native/handoff-visibility.ts
-function getHandoffRecipientVisibilityCallout(toRole) {
-  if (toRole.toLowerCase() === "user") {
-    return `---
-
-⚠️ **CRITICAL — Recipient visibility**
-
-The user receives the text inside your \`handoff --next-role="user"\` command, plus any \`notify-user\` notices you sent earlier in this task.
-
-They **cannot** see:
-- Anything you write in this agent session (including direct replies like "Hello!")
-- Tool output
-
-When you write this handoff, put your **complete** deliverable in the handoff message. Do not rely on session text or on earlier notices.
-
----`;
-  }
-  return `---
-
-⚠️ **CRITICAL — Recipient visibility**
-
-The \`${toRole}\` agent **only** receives the text inside your \`handoff --next-role="${toRole}"\` command.
-
-They **cannot** see:
-- Anything you write in this agent session
-- \`notify-user\` notices (notices go to the user only)
-- Tool output
-
-When you write this handoff, put your **complete** deliverable in the handoff message — not in session text.
-
----`;
-}
-
 // ../../services/backend/prompts/utils/file-reference-guidance.ts
 function getFileReferenceGuidanceComment() {
   return `<!-- File references (clickable in workspace UI): use repo-relative paths with a file extension — e.g. \`apps/webapp/src/modules/chatroom/foo.ts\` or [apps/webapp/src/foo.ts](apps/webapp/src/foo.ts). Avoid absolute paths, file:// prefixes, and paths without / or extension. -->`;
@@ -100290,9 +100374,6 @@ function getFileReferenceProofOfCompletionExample() {
 }
 
 // ../../services/backend/prompts/teams/architect-handoff-templates.ts
-function normalizeEntryPointRole(entryPointRole) {
-  return entryPointRole.trim().toLowerCase() || "planner";
-}
 function getArchitectFocus() {
   return "module boundaries, APIs, schemas, indexes and queries, invariants, failure and recovery handling, tests, and implementation sequence";
 }
@@ -100305,13 +100386,9 @@ function getArchitectRequirements() {
 - Account for Convex reactivity and bandwidth: query invalidation patterns, avoiding unnecessary reactive fanout, and separating high-frequency heartbeat/liveness/status fields from low-frequency identity/configuration fields.
 - Specify concrete schema, query, and mutation changes; migration/backfill sequence; tests; and verification order.`;
 }
-function getEntryPointToArchitectHandoffTemplate(entryPointRole) {
-  const entryPoint = normalizeEntryPointRole(entryPointRole);
-  return `${getHandoffRecipientVisibilityCallout("architect")}
-
-## Handoff Template (${entryPoint} → architect)
-
-The automatically injected \`<user-message>\` is the authoritative request. Add only concise context that the Architect needs to design within the existing repository and team scope.
+function getEntryPointToArchitectHandoffTemplate(query) {
+  const entryPoint = query.fromRole;
+  return `The automatically injected \`<user-message>\` is the authoritative request. Add only concise context that the Architect needs to design within the existing repository and team scope.
 
 Provide the request, relevant constraints, and the files or product surfaces that need inspection. Ask for one evidence-backed design focused on ${getArchitectFocus()}.
 
@@ -100326,20 +100403,10 @@ ${handoffCommand({
   })}
 \`\`\``;
 }
-function getArchitectToEntryPointHandoffTemplate(entryPointRole) {
-  return renderArchitectToEntryPointHandoffTemplate(normalizeEntryPointRole(entryPointRole));
-}
-function getGenericArchitectToEntryPointHandoffTemplate() {
-  return renderArchitectToEntryPointHandoffTemplate("<entry-point-role>", true);
-}
-function renderArchitectToEntryPointHandoffTemplate(entryPoint, generic = false) {
-  const sharedContractsHeading = !generic && entryPoint === "planner" ? "## Shared contracts (planner-owned)" : "## Shared contracts (configured entry-point-owned)";
-  const placeholderInstruction = generic ? " Replace `<entry-point-role>` with the configured entry-point role before running it." : "";
-  return `${getHandoffRecipientVisibilityCallout(entryPoint)}
-
-## Handoff Template (Architect → Entry Point)
-
-Return exactly one recommended, evidence-backed design brief for the authoritative user request to the configured entry point. This is an advisory handback: do not implement code, edit files, spawn subagents, present alternatives, or expand scope. The injected \`<handoff-templates>\` block is the authoritative structure for this handoff; complete every section in order. Use \`Not Applicable.\` only when a section is genuinely inapplicable, with no explanation or filler.
+function getArchitectToEntryPointHandoffTemplate(query) {
+  const entryPoint = query.toRole;
+  const sharedContractsHeading = `## Shared contracts (${entryPoint}-owned)`;
+  return `Instructions (not part of the message): Return exactly one recommended, evidence-backed design brief for the authoritative user request to \`${entryPoint}\`. This is an advisory handback: do not implement code, edit files, spawn subagents, present alternatives, or expand scope. The injected \`<handoff-templates>\` block is the authoritative structure for this handoff; complete every section in order. Use \`Not Applicable.\` only when a section is genuinely inapplicable, with no explanation or filler.
 
 ## Summary
 <describe the design problem being solved, the repository/product surface where it fits, and the evidence-backed context; do not refer to hidden session text>
@@ -100387,7 +100454,7 @@ ${sharedContractsHeading}
 ## Requirements (acceptance criteria)
 - <one concrete, verifiable requirement per bullet; include exact data shape, API contract, migration result, and failure behavior>
 - Include repository test coverage for domain, concurrency, read-pattern, migration, and recovery risk areas.
-- Verify the implemented user-facing entry point or task-delivery path end-to-end; unit tests alone are insufficient.
+- Verify the implemented user-facing feature or task-delivery path end-to-end; unit tests alone are insufficient.
 
 ## What to avoid
 - Do not implement code or edit files as the architect; this handoff is advisory only.
@@ -100401,8 +100468,7 @@ ${sharedContractsHeading}
 ## Out of scope
 - <explicit files, flows, behavior, or migration work the implementer must not touch>
 
-## Handoff
-Run the normal handoff command to the configured entry point with this complete design, then stop.${placeholderInstruction}
+Instructions after the body (not part of the message): run the normal handoff command to \`${entryPoint}\` with the complete body above, then stop.
 
 \`\`\`bash
 ${handoffCommand({
@@ -100417,145 +100483,162 @@ var init_architect_handoff_templates = __esm(() => {
   init_command2();
 });
 
-// ../../services/backend/prompts/teams/uiux-engineer-handoff-templates.ts
-function normalizeEntryPointRole2(entryPointRole) {
-  return entryPointRole.trim().toLowerCase() || "planner";
-}
-function getUiuxEngineerFocus() {
-  return "complete user flows, loading/empty/error/success states, component ownership, theme tokens and layout, responsive details, and UI tests";
+// ../../services/backend/prompts/teams/duo/handoff-templates/architect-planner-code.ts
+function getArchitectPlannerCodeTemplate(query) {
+  return getArchitectToEntryPointHandoffTemplate(query);
 }
-function getUiuxEngineerRequirements() {
-  return `
-- Specify complete user flows with explicit loading, empty, error, success, disabled, and retry states where applicable.
-- Define component hierarchy and ownership, props/state/events, data boundaries, and interaction behavior.
-- Choose concrete existing ShadCN components with the Base UI backend and lucide-react/react-icons conventions; do not write "use an appropriate component."
-- Specify Tailwind utility classes or semantic theme-token classes for layout, spacing, sizing, typography, states, responsive behavior, and dark mode.
-- Provide the target HTML markup with exact class attributes and any required CSS/styles in the handoff.
-- Specify responsive breakpoints/layout behavior, visual feedback, destructive-action safeguards, exact files/components, and the UI/integration test plan.
-- Do not propose or require web accessibility implementation work unless the user explicitly requests it.`;
-}
-function getEntryPointToUiuxEngineerHandoffTemplate(entryPointRole) {
-  const entryPoint = normalizeEntryPointRole2(entryPointRole);
-  return `${getHandoffRecipientVisibilityCallout("uiux-engineer")}
-
-## Handoff Template (${entryPoint} → uiux-engineer)
-
-The automatically injected \`<user-message>\` is the authoritative request. Add only concise context that the UI/UX Engineer needs to design within the existing repository and team scope.
+var init_architect_planner_code = __esm(() => {
+  init_architect_handoff_templates();
+});
 
-Provide the request, relevant constraints, and the files or product surfaces that need inspection. Ask for one evidence-backed design focused on ${getUiuxEngineerFocus()}.
+// ../../services/backend/prompts/teams/duo/handoff-templates/architect-planner-chat.ts
+var init_architect_planner_chat = __esm(() => {
+  init_architect_planner_code();
+});
 
-After completing the design, hand it back to \`${entryPoint}\` with the normal handoff command. Stop after the successful handoff; do not implement the design or delegate further work.
+// ../shared/src/domain/chatroom-role.ts
+var CHATROOM_ROLE_USER = "user";
+var init_chatroom_role = __esm(() => {
+  init_agent_role();
+});
 
-\`\`\`bash
-${handoffCommand({
-    chatroomId: "<chatroom-id>",
-    role: "uiux-engineer",
-    nextRole: entryPoint,
-    cliEnvPrefix: ""
-  })}
-\`\`\``;
+// ../../services/backend/prompts/cli/handoff-templates/contracts.ts
+function handoffTemplateByMode(getters) {
+  return (query) => query.conversationMode === "chat" ? getters.chat(query) : getters.code(query);
+}
+function validateRoleHandoffContracts(contracts) {
+  const byRole = new Map;
+  for (const contract of contracts) {
+    const key = contract.role.toLowerCase();
+    if (byRole.has(key)) {
+      throw new Error(`Duplicate role handoff contract: "${contract.role}"`);
+    }
+    byRole.set(key, contract);
+  }
+  for (const contract of contracts) {
+    const ownerKey = contract.role.toLowerCase();
+    for (const target of Object.keys(contract.outboundTemplates)) {
+      const targetKey = target.toLowerCase();
+      if (targetKey === "user")
+        continue;
+      const targetContract = byRole.get(targetKey);
+      if (!targetContract) {
+        throw new Error(`Role "${contract.role}" declares an outbound template to "${target}", which is neither 'user' nor a role listed in the catalogue`);
+      }
+      const declaresOwner = (targetContract.receivesFrom ?? []).some((from) => from.toLowerCase() === ownerKey);
+      if (!declaresOwner) {
+        throw new Error(`Reciprocity failure: role "${targetContract.role}" receives from "${contract.role}" (via the ${contract.role} → ${target} template) but does not declare "${contract.role}" in receivesFrom`);
+      }
+    }
+  }
+}
+function validateBuiltinOwners(teamName, expectedRoles, contracts) {
+  const actualRoles = new Set;
+  const byRole = new Map;
+  for (const contract of contracts) {
+    const normalizedOwner = contract.role.trim().toLowerCase();
+    if (!normalizedOwner || contract.role !== normalizedOwner) {
+      throw new Error(`${teamName} handoff owner "${contract.role}" is not canonical`);
+    }
+    if (actualRoles.has(normalizedOwner)) {
+      throw new Error(`${teamName} has duplicate handoff contract owner "${contract.role}"`);
+    }
+    if (!expectedRoles.has(normalizedOwner)) {
+      throw new Error(`${teamName} has unexpected handoff contract role "${contract.role}"`);
+    }
+    actualRoles.add(normalizedOwner);
+    byRole.set(normalizedOwner, contract);
+  }
+  for (const role of expectedRoles) {
+    if (!actualRoles.has(role)) {
+      throw new Error(`${teamName} is missing handoff contract for role "${role}"`);
+    }
+  }
+  return byRole;
 }
-function getUiuxEngineerToEntryPointHandoffTemplate(entryPointRole) {
-  return renderUiuxEngineerToEntryPointHandoffTemplate(normalizeEntryPointRole2(entryPointRole));
+function validateReferenceTargets(teamName, owner, label, targets, allowedTargets) {
+  const seen = new Set;
+  for (const target of targets) {
+    const normalizedTarget = target.trim().toLowerCase();
+    if (target !== normalizedTarget || !allowedTargets.has(normalizedTarget)) {
+      throw new Error(`${teamName} role "${owner}" has invalid ${label} target "${target}"`);
+    }
+    if (seen.has(normalizedTarget)) {
+      throw new Error(`${teamName} role "${owner}" has duplicate ${label} target "${target}"`);
+    }
+    seen.add(normalizedTarget);
+  }
 }
-function getGenericUiuxEngineerToEntryPointHandoffTemplate() {
-  return renderUiuxEngineerToEntryPointHandoffTemplate("<entry-point-role>", true);
+function validateBuiltinReferences(teamName, allowedTargets, contracts) {
+  for (const contract of contracts) {
+    const owner = contract.role;
+    validateReferenceTargets(teamName, owner, "receivesFrom", contract.receivesFrom, allowedTargets);
+    validateReferenceTargets(teamName, owner, "returnsTo", contract.returnsTo, allowedTargets);
+    const outboundTargets = Object.keys(contract.outboundTemplates);
+    if (outboundTargets.length === 0) {
+      throw new Error(`${teamName} role "${owner}" must have an outbound handoff capability`);
+    }
+    const returnsTo = new Set(contract.returnsTo);
+    const outbound = new Set(outboundTargets);
+    validateReferenceTargets(teamName, owner, "outbound", outboundTargets, allowedTargets);
+    for (const target of outboundTargets) {
+      if (typeof contract.outboundTemplates[target] !== "function") {
+        throw new Error(`${teamName} role "${owner}" has no outbound getter for target "${target}"`);
+      }
+    }
+    if (returnsTo.size !== outbound.size || [...returnsTo].some((target) => !outbound.has(target))) {
+      throw new Error(`${teamName} role "${owner}" returnsTo targets must exactly match outbound targets`);
+    }
+  }
 }
-function renderUiuxEngineerToEntryPointHandoffTemplate(entryPoint, generic = false) {
-  const sharedContractsHeading = !generic && entryPoint === "planner" ? "## Shared contracts (planner-owned)" : "## Shared contracts (configured entry-point-owned)";
-  const placeholderInstruction = generic ? " Replace `<entry-point-role>` with the configured entry-point role before running it." : "";
-  return `${getHandoffRecipientVisibilityCallout(entryPoint)}
-
-## Handoff Template (UI/UX Engineer → Entry Point)
-
-Return exactly one recommended, evidence-backed design brief for the authoritative user request to the configured entry point. This is an advisory handback: do not implement code, edit files, spawn subagents, present alternatives, or expand scope. The injected \`<handoff-templates>\` block is the authoritative structure for this handoff; complete every section in order. Use \`Not Applicable.\` only when a section is genuinely inapplicable, with no explanation or filler.
-
-## Summary
-<describe the design problem being solved, the repository/product surface where it fits, and the evidence-backed context; do not refer to hidden session text>
-
-## Goal
-<state the one-sentence outcome this design delivers>
-
-## Key Knowledge for High Quality Bar
-<cite the inspected repository patterns and complete the UI/UX engineer checklist below; do not provide a high-level essay>
-- Produce exactly one recommended design for ${getUiuxEngineerFocus()}.
-- Name concrete repository paths, existing components/tokens, props/state/events, data boundaries, acceptance criteria, risks, and verification steps.
-${getUiuxEngineerRequirements()}
-
-## Force Multipliers
-<name the existing components, patterns, tokens, utilities, and platform conventions to reuse, and state why each reduces implementation risk or duplication>
-- Keep the design within the repository's established source-of-truth boundaries and avoid introducing a new registry or abstraction without evidence.
-
-## Files to implement (exhaustive, file-level)
-List every file or product surface the implementer must create or modify. Mark each \`(Required)\` or \`(Optional)\`. For every file, give the exact responsibility, exported types/signatures/props, state/data/event boundaries, component hierarchy, and target Tailwind/theme-token snippet detailed enough to implement without guessing.
-${getFileReferenceGuidanceComment()}
-
-### \`<repo-relative/path.ext>\` (Required)
-**Change:** <precise add/modify/remove responsibility and why>
-
-\`\`\`text
-// Target HTML markup, exact class attributes, and required CSS/styles.
-// Include component hierarchy and props/state/events needed for implementation.
-\`\`\`
-
-<add one block per file; do not collapse multiple files into a directory or vague layer>
-
-${sharedContractsHeading}
-<list cross-file interfaces, component/data contracts, state boundaries, or write exactly \`Not Applicable.\` when genuinely inapplicable>
-
-### Interfaces & types
-\`\`\`typescript
-// Shared props, state, events, query shapes, or interaction contracts.
-\`\`\`
-
-### Reference snippets
-\`\`\`tsx
-// Canonical component imports, hook usage, or layout examples.
-\`\`\`
-
-## Requirements (acceptance criteria)
-- <one concrete, verifiable requirement per bullet; include exact states, interactions, classes/tokens, and responsive behavior>
-- Include UI and integration test coverage for the design's risk areas.
-- Verify the implemented user-facing entry point end-to-end; unit tests alone are insufficient.
-
-## What to avoid
-- Do not implement code or edit files as the UI/UX engineer; this handoff is advisory only.
-- Do not present alternative designs, generic advice, or requirements without concrete evidence and file-level consequences.
-- Do not invent components, props, tokens, interaction behavior, or source-of-truth locations when existing repository patterns apply.
-- <explicit task-specific anti-patterns, scope boundaries, and destructive-action/source-of-truth pitfalls>
-
-## Skills to activate
-- <relevant repository skills and why they apply, or write exactly \`Not Applicable.\` when none apply>
-
-## Out of scope
-- <explicit files, flows, behavior, or migration work the implementer must not touch>
-
-## Handoff
-Run the normal handoff command to the configured entry point with this complete design, then stop.${placeholderInstruction}
-
-\`\`\`bash
-${handoffCommand({
-    chatroomId: "<chatroom-id>",
-    role: "uiux-engineer",
-    nextRole: entryPoint,
-    cliEnvPrefix: ""
-  })}
-\`\`\``;
+function validateBuiltinReciprocity(teamName, byRole, contracts) {
+  for (const contract of contracts) {
+    const owner = contract.role;
+    for (const receivedFrom of contract.receivesFrom) {
+      if (receivedFrom === CHATROOM_ROLE_USER)
+        continue;
+      const source = byRole.get(receivedFrom);
+      if (!source?.outboundTemplates[owner]) {
+        throw new Error(`${teamName} role "${owner}" receives from "${receivedFrom}" without a reverse outbound edge`);
+      }
+    }
+  }
+  try {
+    validateRoleHandoffContracts(contracts);
+  } catch (error51) {
+    const contextualError = new Error(`${teamName}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    Object.defineProperty(contextualError, "cause", { value: error51, configurable: true });
+    throw contextualError;
+  }
 }
-var init_uiux_engineer_handoff_templates = __esm(() => {
-  init_command2();
+function validateBuiltinTeamRoleHandoffContracts(teamId, contracts) {
+  const teamName = TEAM_PRESETS[teamId].name;
+  const expectedRoles = new Set(TEAM_PRESETS[teamId].roles);
+  const byRole = validateBuiltinOwners(teamName, expectedRoles, contracts);
+  const allowedTargets = new Set([...expectedRoles, CHATROOM_ROLE_USER]);
+  validateBuiltinReferences(teamName, allowedTargets, contracts);
+  validateBuiltinReciprocity(teamName, byRole, contracts);
+}
+var init_contracts = __esm(() => {
+  init_chatroom_role();
+  init_team_presets();
 });
 
 // ../../services/backend/prompts/teams/duo/handoff-templates/architect.ts
 var duoArchitectHandoffContract;
 var init_architect = __esm(() => {
-  init_architect_handoff_templates();
+  init_architect_planner_chat();
+  init_architect_planner_code();
+  init_contracts();
   duoArchitectHandoffContract = {
     role: "architect",
     receivesFrom: ["planner"],
     returnsTo: ["planner"],
     outboundTemplates: {
-      planner: () => getArchitectToEntryPointHandoffTemplate("planner")
+      planner: handoffTemplateByMode({
+        chat: getArchitectPlannerCodeTemplate,
+        code: getArchitectPlannerCodeTemplate
+      })
     }
   };
 });
@@ -100577,13 +100660,16 @@ var DELEGATION_BRIEF_DISCLOSURE_CHECKBOX = "- [ ] I confirm the delegation brief
 function getHandoffNotApplicableSectionComment(context3) {
   return `<!-- REQUIRED. ${context3}, or write exactly "${HANDOFF_NOT_APPLICABLE_EXACT_TEXT}" with no explanation. Do not omit this section. -->`;
 }
-function getHandoffReportTemplateIntro(templateLabel) {
-  return `**${templateLabel}** — complete every section below. Do not omit sections, principles, or XML wrappers:
+function getHandoffTemplateTitleLine(pair) {
+  return `Handoff template \`${pair.fromRole}\` → \`${pair.toRole}\` (copy only the body sections below; do not copy this line, the notice, or the instructions after the body):`;
+}
+function getHandoffReportTemplateIntro() {
+  return `Instructions (not part of the message): complete every section below. Do not omit sections, principles, or XML wrappers.
 
 When a section has no content, write exactly \`${HANDOFF_NOT_APPLICABLE_EXACT_TEXT}\` — no explanation, no em-dash, no additional text.`;
 }
 function getDelegationBriefIntro() {
-  return `**Delegation Brief (Planner → Builder)** — paste into the handoff message. Include every field that applies. **Omit fields that do not apply** — do not write \`Not Applicable\` as filler.`;
+  return `**Delegation Brief** — paste into the handoff message. Include every field that applies. **Omit fields that do not apply** — do not write \`Not Applicable\` as filler.`;
 }
 var HANDOFF_NOT_APPLICABLE_EXACT_TEXT = "Not Applicable.";
 
@@ -100657,11 +100743,9 @@ ${getRoleGuidanceDisclosureComment(params)}`;
 var ROLE_GUIDANCE_DISCLOSURE_CHECKBOX = "- [ ] I confirm that I've read and followed the role guidance before starting any work";
 var init_role_guidance_disclosure = () => {};
 
-// ../../services/backend/prompts/teams/duo/handoff-templates/builder-to-planner.ts
-function getBuilderToPlannerHandoffTemplate(roleGuidanceContext) {
-  return `${getHandoffRecipientVisibilityCallout("planner")}
-
-${getHandoffReportTemplateIntro("Handoff Template (Builder → Planner)")}
+// ../../services/backend/prompts/teams/duo/handoff-templates/builder-planner-code.ts
+function getBuilderPlannerCodeBody(roleGuidanceContext) {
+  return `${getHandoffReportTemplateIntro()}
 
 \`\`\`markdown
 ## Summary
@@ -100690,34 +100774,58 @@ ${getHandoffNotApplicableSectionComment("List review notes")}
 <specific areas for planner to check>
 \`\`\``;
 }
-var init_builder_to_planner = __esm(() => {
+function getBuilderPlannerCodeTemplate(query) {
+  return getBuilderPlannerCodeBody({
+    chatroomId: query.chatroomId,
+    role: query.role,
+    cliEnvPrefix: query.cliEnvPrefix
+  });
+}
+var init_builder_planner_code = __esm(() => {
   init_handoff_quality_principles();
   init_role_guidance_disclosure();
 });
 
+// ../../services/backend/prompts/teams/duo/handoff-templates/builder-planner-chat.ts
+var init_builder_planner_chat = __esm(() => {
+  init_builder_planner_code();
+});
+
 // ../../services/backend/prompts/teams/duo/handoff-templates/builder.ts
 var duoBuilderHandoffContract;
 var init_builder = __esm(() => {
-  init_builder_to_planner();
+  init_builder_planner_chat();
+  init_builder_planner_code();
+  init_contracts();
   duoBuilderHandoffContract = {
     role: "builder",
     receivesFrom: ["planner"],
     returnsTo: ["planner"],
     outboundTemplates: {
-      planner: (query) => getBuilderToPlannerHandoffTemplate({
-        chatroomId: query.chatroomId,
-        role: query.role,
-        cliEnvPrefix: query.cliEnvPrefix
+      planner: handoffTemplateByMode({
+        chat: getBuilderPlannerCodeTemplate,
+        code: getBuilderPlannerCodeTemplate
       })
     }
   };
 });
 
-// ../../services/backend/prompts/teams/duo/handoff-templates/planner-to-builder.ts
-function getPlannerToBuilderHandoffTemplate() {
-  return `${getHandoffRecipientVisibilityCallout("builder")}
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-architect-code.ts
+function getPlannerArchitectCodeTemplate(query) {
+  return getEntryPointToArchitectHandoffTemplate(query);
+}
+var init_planner_architect_code = __esm(() => {
+  init_architect_handoff_templates();
+});
 
-${getDelegationBriefIntro()}
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-architect-chat.ts
+var init_planner_architect_chat = __esm(() => {
+  init_planner_architect_code();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-builder-code.ts
+function getPlannerBuilderCodeBody() {
+  return `${getDelegationBriefIntro()}
 
 **Before you delegate:** if this slice introduces anything not yet grounded in the repository (a new library, API, external platform behavior, or an unresolved design choice), hand off to \`researcher\` first and delegate only after its brief returns. Skip this for small, well-understood edits. The \`researcher\` handoff template defines the criteria.
 
@@ -100727,7 +100835,9 @@ ${getDelegationBriefIntro()}
 
 **Detail bar:** Specify down to **every file** the builder will create or modify (full repo paths). Include code snippets — types, signatures, stubs, or target implementations — until a competent builder **cannot misinterpret** what to write. Vague layers ("update the backend", "fix the component") are not acceptable.
 
-\`\`\`markdown
+Guidance for you (not part of the message): Keep one slice ≈ one focused review surface. Delegate slices incrementally — one at a time, not all at once.
+
+\`\`\`\`markdown
 ## Summary
 <brief context for this delegation slice — what problem it solves and where it fits in the larger task>
 
@@ -100784,14 +100894,380 @@ Cross-file types, interfaces, or patterns that apply beyond a single file. Omit
 - <e.g. "Do not add new abstractions", "Do not refactor unrelated files", "Do not change existing public APIs">
 
 ## Skills to activate
-- <e.g. chatroom skill activate code-review --chatroom-id=<id> --role=builder>
+- e.g. \`chatroom skill activate code-review --chatroom-id=<id> --role=builder\`
 
 ## Out of scope
 - <files or areas the builder must NOT touch in this slice>
 
-Keep one slice ≈ one focused review surface. Delegate slices incrementally — one at a time, not all at once.`;
+\`\`\`\``;
+}
+function getPlannerBuilderCodeTemplate(_query) {
+  return getPlannerBuilderCodeBody();
+}
+var init_planner_builder_code = () => {};
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-builder-chat.ts
+var init_planner_builder_chat = __esm(() => {
+  init_planner_builder_code();
+});
+
+// ../../services/backend/prompts/teams/researcher-handoff-templates.ts
+function getEntryPointToResearcherHandoffTemplate(query) {
+  const entryPoint = query.fromRole;
+  return `The automatically injected \`<user-message>\` is the authoritative request. Pass the decisions the research must ground, the specific research questions, known constraints, and the files or areas already suspected. Ask the researcher for a report only: do not edit files, implement code, or design alternative architectures.
+
+### When to research
+
+Research before delegating when the slice introduces something not already grounded in this repository:
+- a new library, API, external service, platform behavior, or version-sensitive dependency;
+- an unfamiliar subsystem;
+- a change with several plausible designs;
+- any ambiguity the user has not resolved.
+
+Skip research when the change is a small, well-understood edit in code you have already inspected.
+
+After completing the research, the researcher must return the evidence-backed brief to \`${entryPoint}\` with the normal handoff command.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: entryPoint,
+    nextRole: "researcher",
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+function getResearcherToEntryPointHandoffTemplate(query) {
+  const entryPoint = query.toRole;
+  return `Instructions (not part of the message): Return a complete, evidence-backed research brief for the authoritative request. The researcher is advisory: do not edit files, implement code, or present alternative architectures beyond what grounds the decision. Answer only the questions asked. Separate every finding into confirmed (with evidence), inferred (with reasoning), or unknown. Never present a guess as fact. External claims must cite the source URL together with the version or date checked. Use the exact sections below, in this order.
+
+## Summary
+<state the answer to the core question in two to four sentences and whether any decision remains open>
+
+## Research questions
+<list each question exactly as asked or as derived from the request, numbered>
+
+## Answers
+<one entry per question, each tagged \`confirmed\` (with evidence), \`inferred\` (with reasoning), or \`unknown\`>
+
+## Repository evidence
+<concrete repository paths and symbols with what each shows; quote the relevant lines briefly>
+
+## External sources
+<URL, version or date checked, and the specific claim each source supports; write exactly \`None consulted.\` if no external source was needed, and say why>
+
+## Grounded facts for the plan
+<the facts the planner can rely on when decomposing and delegating, each tagged confirmed or inferred>
+
+## Remaining ambiguity
+<each open decision, who must decide it, and a recommended default; write exactly \`None observed.\` if none remain>
+
+## Risks and constraints
+<constraints from the repository or external platform, and risks the plan must account for>
+
+## Work completed
+<paths inspected, searches run, and sources opened, with the result of each>
+
+Instructions after the body (not part of the message): run the normal handoff command to \`${entryPoint}\` with the complete body above, then stop.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: "researcher",
+    nextRole: entryPoint,
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+var init_researcher_handoff_templates = __esm(() => {
+  init_command2();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-researcher-code.ts
+function getPlannerResearcherCodeTemplate(query) {
+  return getEntryPointToResearcherHandoffTemplate(query);
+}
+var init_planner_researcher_code = __esm(() => {
+  init_researcher_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-researcher-chat.ts
+var init_planner_researcher_chat = __esm(() => {
+  init_planner_researcher_code();
+});
+
+// ../../services/backend/prompts/teams/reviewer-handoff-templates.ts
+function getEntryPointToReviewerHandoffTemplate(query) {
+  const entryPoint = query.fromRole;
+  return `Pass the review target and the review focus. State the exact commit range, branch, pull request, or file list to inspect, the focus areas (for example security, correctness, or test quality), and any known context or constraints. Ask the reviewer for a report only: do not edit files, run builds or tests, or implement fixes.
+
+### When to review
+
+Review before delivery for code-producing work:
+- a builder slice has just completed and is about to be delivered;
+- the user asks for a code review;
+- a change is large, risky, or touches security-sensitive or shared code.
+
+Skip review for a trivial edit that has already been verified.
+
+After completing the review, the reviewer must return its issue report to \`${entryPoint}\` with the normal handoff command.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: entryPoint,
+    nextRole: "reviewer",
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+function getReviewerToEntryPointHandoffTemplate(query) {
+  const entryPoint = query.toRole;
+  return `Instructions (not part of the message): Return a complete review report for the target the planner named. The reviewer is advisory: do not edit files, implement fixes, run builds or tests, or propose architecture rewrites beyond each issue's suggested fix. Report only what you observed and mark anything unverified as such. Label every issue with a severity: \`blocker\`, \`major\`, \`minor\`, or \`nit\`. Group the issues by severity with blockers first, and cite the repository-relative file and line or line range for each. Use the exact sections below, in this order.
+
+## Summary
+<one to three sentences: overall state of the target and the count of blocker/major issues>
+
+## Review scope
+<commits, paths, and PR/branch inspected; commands run, if any>
+
+## Issues
+<numbered list grouped by severity (blocker, major, minor, nit); each item: \`file:line\` — summary — evidence — suggested fix; write exactly \`None observed.\` if none>
+
+## Not reviewed
+<anything out of scope or unreadable; write exactly \`None.\` if none>
+
+Instructions after the body (not part of the message): run the normal handoff command to \`${entryPoint}\` with the complete body above, then stop.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: "reviewer",
+    nextRole: entryPoint,
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+var init_reviewer_handoff_templates = __esm(() => {
+  init_command2();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-reviewer-code.ts
+function getPlannerReviewerCodeTemplate(query) {
+  return getEntryPointToReviewerHandoffTemplate(query);
+}
+var init_planner_reviewer_code = __esm(() => {
+  init_reviewer_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-reviewer-chat.ts
+var init_planner_reviewer_chat = __esm(() => {
+  init_planner_reviewer_code();
+});
+
+// ../../services/backend/prompts/teams/triage-handoff-templates.ts
+function getEntryPointToTriageHandoffTemplate(query) {
+  const entryPoint = query.fromRole;
+  return `The automatically injected \`<user-message>\` is the authoritative request. Pass the reported bug, observed and expected behavior, reproduction details and commands, relevant constraints, and the files or symbols already suspected. Ask triage to investigate and report only. Triage may inspect code and attempt a focused automated regression test as evidence, but must not edit implementation files or implement a fix.
+
+After completing the investigation, triage must return the evidence-backed report to \`${entryPoint}\` with the normal handoff command.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: entryPoint,
+    nextRole: "triage",
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+function getTriageToEntryPointHandoffTemplate(query) {
+  const entryPoint = query.toRole;
+  return `Instructions (not part of the message): Return a complete, evidence-backed investigation of the authoritative reported bug. Triage is advisory: do not edit implementation files or implement the proposed fix. Begin with the \`## Summary\` section, then use the remaining sections below in order. Use \`###\` for sub-items within a section. Cite concrete repository paths and symbols, observed behavior, commands, and test output. Distinguish confirmed findings from hypotheses; never claim a test proved behavior unless its failing assertion demonstrates the report.
+
+## Summary
+<briefly state the diagnosis and whether the root cause was confirmed or remains a hypothesis>
+
+## Reported behavior
+<state the reported symptoms and expected behavior, including reproduction details and constraints recovered from the request or relevant history>
+
+## Root cause
+<trace the relevant ownership, data, and control flow using concrete repository paths and symbols; explain the causal reasoning and explicitly label the finding as confirmed or a hypothesis>
+
+## Reproduction attempt
+<give the focused test path and exact command, the failing assertion or exact blocker, and the outcome; if reproduction was blocked, state what was tried and what additional information would help; do not fabricate proof>
+
+## Proposed immediate fix
+<recommend the smallest appropriate change, naming the likely files and the specific change; do not implement it>
+
+## Systemic issues
+<list each separate systemic concern with repository evidence, impact, and follow-up concern, or write exactly: None observed.>
+
+## Work completed
+<state the code paths inspected and every test or reproduction action taken, including results>
+
+Instructions after the body (not part of the message): run the normal handoff command to \`${entryPoint}\` with the complete body above, then stop.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: "triage",
+    nextRole: entryPoint,
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+var init_triage_handoff_templates = __esm(() => {
+  init_command2();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-triage-code.ts
+function getPlannerTriageCodeTemplate(query) {
+  return getEntryPointToTriageHandoffTemplate(query);
+}
+var init_planner_triage_code = __esm(() => {
+  init_triage_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-triage-chat.ts
+var init_planner_triage_chat = __esm(() => {
+  init_planner_triage_code();
+});
+
+// ../../services/backend/prompts/teams/uiux-engineer-handoff-templates.ts
+function getUiuxEngineerFocus() {
+  return "complete user flows, loading/empty/error/success states, component ownership, theme tokens and layout, responsive details, and UI tests";
+}
+function getUiuxEngineerRequirements() {
+  return `
+- Specify complete user flows with explicit loading, empty, error, success, disabled, and retry states where applicable.
+- Define component hierarchy and ownership, props/state/events, data boundaries, and interaction behavior.
+- Choose concrete existing ShadCN components with the Base UI backend and lucide-react/react-icons conventions; do not write "use an appropriate component."
+- Specify Tailwind utility classes or semantic theme-token classes for layout, spacing, sizing, typography, states, responsive behavior, and dark mode.
+- Provide the target HTML markup with exact class attributes and any required CSS/styles in the handoff.
+- Specify responsive breakpoints/layout behavior, visual feedback, destructive-action safeguards, exact files/components, and the UI/integration test plan.
+- Do not propose or require web accessibility implementation work unless the user explicitly requests it.`;
+}
+function getEntryPointToUiuxEngineerHandoffTemplate(query) {
+  const entryPoint = query.fromRole;
+  return `The automatically injected \`<user-message>\` is the authoritative request. Add only concise context that the UI/UX Engineer needs to design within the existing repository and team scope.
+
+Provide the request, relevant constraints, and the files or product surfaces that need inspection. Ask for one evidence-backed design focused on ${getUiuxEngineerFocus()}.
+
+After completing the design, hand it back to \`${entryPoint}\` with the normal handoff command. Stop after the successful handoff; do not implement the design or delegate further work.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: "uiux-engineer",
+    nextRole: entryPoint,
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
 }
-var init_planner_to_builder = () => {};
+function getUiuxEngineerToEntryPointHandoffTemplate(query) {
+  const entryPoint = query.toRole;
+  const sharedContractsHeading = `## Shared contracts (${entryPoint}-owned)`;
+  return `Instructions (not part of the message): Return exactly one recommended, evidence-backed design brief for the authoritative user request to \`${entryPoint}\`. This is an advisory handback: do not implement code, edit files, spawn subagents, present alternatives, or expand scope. The injected \`<handoff-templates>\` block is the authoritative structure for this handoff; complete every section in order. Use \`Not Applicable.\` only when a section is genuinely inapplicable, with no explanation or filler.
+
+## Summary
+<describe the design problem being solved, the repository/product surface where it fits, and the evidence-backed context; do not refer to hidden session text>
+
+## Goal
+<state the one-sentence outcome this design delivers>
+
+## Key Knowledge for High Quality Bar
+<cite the inspected repository patterns and complete the UI/UX engineer checklist below; do not provide a high-level essay>
+- Produce exactly one recommended design for ${getUiuxEngineerFocus()}.
+- Name concrete repository paths, existing components/tokens, props/state/events, data boundaries, acceptance criteria, risks, and verification steps.
+${getUiuxEngineerRequirements()}
+
+## Force Multipliers
+<name the existing components, patterns, tokens, utilities, and platform conventions to reuse, and state why each reduces implementation risk or duplication>
+- Keep the design within the repository's established source-of-truth boundaries and avoid introducing a new registry or abstraction without evidence.
+
+## Files to implement (exhaustive, file-level)
+List every file or product surface the implementer must create or modify. Mark each \`(Required)\` or \`(Optional)\`. For every file, give the exact responsibility, exported types/signatures/props, state/data/event boundaries, component hierarchy, and target Tailwind/theme-token snippet detailed enough to implement without guessing.
+${getFileReferenceGuidanceComment()}
+
+### \`<repo-relative/path.ext>\` (Required)
+**Change:** <precise add/modify/remove responsibility and why>
+
+\`\`\`text
+// Target HTML markup, exact class attributes, and required CSS/styles.
+// Include component hierarchy and props/state/events needed for implementation.
+\`\`\`
+
+<add one block per file; do not collapse multiple files into a directory or vague layer>
+
+${sharedContractsHeading}
+<list cross-file interfaces, component/data contracts, state boundaries, or write exactly \`Not Applicable.\` when genuinely inapplicable>
+
+### Interfaces & types
+\`\`\`typescript
+// Shared props, state, events, query shapes, or interaction contracts.
+\`\`\`
+
+### Reference snippets
+\`\`\`tsx
+// Canonical component imports, hook usage, or layout examples.
+\`\`\`
+
+## Requirements (acceptance criteria)
+- <one concrete, verifiable requirement per bullet; include exact states, interactions, classes/tokens, and responsive behavior>
+- Include UI and integration test coverage for the design's risk areas.
+- Verify the implemented user-facing feature end-to-end; unit tests alone are insufficient.
+
+## What to avoid
+- Do not implement code or edit files as the UI/UX engineer; this handoff is advisory only.
+- Do not present alternative designs, generic advice, or requirements without concrete evidence and file-level consequences.
+- Do not invent components, props, tokens, interaction behavior, or source-of-truth locations when existing repository patterns apply.
+- <explicit task-specific anti-patterns, scope boundaries, and destructive-action/source-of-truth pitfalls>
+
+## Skills to activate
+- <relevant repository skills and why they apply, or write exactly \`Not Applicable.\` when none apply>
+
+## Out of scope
+- <explicit files, flows, behavior, or migration work the implementer must not touch>
+
+Instructions after the body (not part of the message): run the normal handoff command to \`${entryPoint}\` with the complete body above, then stop.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: "uiux-engineer",
+    nextRole: entryPoint,
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+var init_uiux_engineer_handoff_templates = __esm(() => {
+  init_command2();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-uiux-engineer-code.ts
+function getPlannerUiuxEngineerCodeTemplate(query) {
+  return getEntryPointToUiuxEngineerHandoffTemplate(query);
+}
+var init_planner_uiux_engineer_code = __esm(() => {
+  init_uiux_engineer_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-uiux-engineer-chat.ts
+var init_planner_uiux_engineer_chat = __esm(() => {
+  init_planner_uiux_engineer_code();
+});
+
+// ../../services/backend/prompts/utils/chat-handoff-template.ts
+function getChatToUserHandoffTemplate() {
+  return `Instructions (not part of the message): chat response — 
+\`\`\`markdown
+<write only the concise response the user should see; do not add handoff XML sections, proofs, context evidence, or placeholder text>
+\`\`\``;
+}
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-user-chat.ts
+var init_planner_user_chat = () => {};
 
 // ../../services/backend/prompts/utils/context-disclosure.ts
 function getContextReadDisclosureComment(params = {}) {
@@ -100814,16 +101290,9 @@ function getHandoffSeverityGuidanceBlock() {
 }
 
 // ../../services/backend/prompts/teams/verifier-handoff-templates.ts
-function normalizeEntryPointRole3(entryPointRole) {
-  return entryPointRole.trim().toLowerCase() || "planner";
-}
-function getEntryPointToVerifierHandoffTemplate(entryPointRole) {
-  const entryPoint = normalizeEntryPointRole3(entryPointRole);
-  return `${getHandoffRecipientVisibilityCallout("verifier")}
-
-## Handoff Template (${entryPoint} → verifier)
-
-The verifier judges, from chatroom logs only, whether the user's last message was achieved. It ${VERIFIER_TEST_RULE}; list any user-requested tests under Requested test runs. Treat the claimed outcome as a claim, not as evidence: the verifier does not trust it and checks every requirement against the logs themselves. Request this review only when the task involved code changes, in any conversation mode. The verdict returns to \`${entryPoint}\`.
+function getEntryPointToVerifierHandoffTemplate(query) {
+  const entryPoint = query.fromRole;
+  return `Instructions (not part of the message): The verifier judges, from chatroom logs only, whether the user's last message was achieved. It ${VERIFIER_TEST_RULE}; list any user-requested tests under Requested test runs. Treat the claimed outcome as a claim, not as evidence: the verifier does not trust it and checks every requirement against the logs themselves. Request this review only when the task involved code changes, in any conversation mode. The verdict returns to \`${entryPoint}\`.
 
 ## Round
 <1 or 2; for 2, cite the round-1 verdict message id>
@@ -100849,8 +101318,7 @@ The verifier judges, from chatroom logs only, whether the user's last message wa
 ## Known gaps
 <anything incomplete, or exactly \`None.\`>
 
-## Handoff
-Send this request to the verifier with the command below, then stop. The verdict returns to \`${entryPoint}\`.
+Instructions after the body (not part of the message): run the normal handoff command to \`${entryPoint}\` with the complete body above, then stop.
 
 \`\`\`bash
 ${handoffCommand({
@@ -100861,13 +101329,9 @@ ${handoffCommand({
   })}
 \`\`\``;
 }
-function getVerifierToEntryPointHandoffTemplate(entryPointRole) {
-  const entryPoint = normalizeEntryPointRole3(entryPointRole);
-  return `${getHandoffRecipientVisibilityCallout(entryPoint)}
-
-## Handoff Template (Verifier → ${entryPoint})
-
-Return one advisory verdict for the authoritative request. This review is non-binding: it uses chatroom logs, plus the requested test runs listed in the request, if any, deciding every requirement from the evidence those logs and runs actually contain. It also checks the work against the user's expectations (\`## User Expectations\`) under the same logs-only, claim-is-not-evidence rule. It ${VERIFIER_TEST_RULE}. Never accept the claimed outcome as proof. Use the exact sections below, in this order.
+function getVerifierToEntryPointHandoffTemplate(query) {
+  const entryPoint = query.toRole;
+  return `Instructions (not part of the message): Return one advisory verdict for the authoritative request. This review is non-binding: it uses chatroom logs, plus the requested test runs listed in the request, if any, deciding every requirement from the evidence those logs and runs actually contain. It also checks the work against the user's expectations (\`## User Expectations\`) under the same logs-only, claim-is-not-evidence rule. It ${VERIFIER_TEST_RULE}. Never accept the claimed outcome as proof. Use the exact sections below, in this order.
 
 ## Verdict
 <exactly one of ${VERIFIER_VERDICTS.join(", ")} as the value; ${ACHIEVED} only if every requirement and user expectation is met; ${NOT_ACHIEVED} if any requirement or user expectation is unmet (logs show it was not done, or contradict it); ${INCONCLUSIVE} if none is unmet but any is unverified (logs are silent)>
@@ -100890,8 +101354,7 @@ Return one advisory verdict for the authoritative request. This review is non-bi
 ## Scope and limits
 <state the test runs the verifier executed (command and exit result), or "No tests were run; none were requested."; log range read; whether the download was truncated; context id read and whether it matched the request>
 
-## Handoff
-Run the normal handoff command to \`${entryPoint}\` with this complete verdict, then stop.
+Instructions after the body (not part of the message): run the normal handoff command to \`${entryPoint}\` with the complete body above, then stop.
 
 \`\`\`bash
 ${handoffCommand({
@@ -101067,195 +101530,51 @@ var init_handoff_report_template_body = __esm(() => {
   init_unresolved_decisions();
 });
 
-// ../../services/backend/prompts/teams/duo/handoff-templates/planner-to-user.ts
-function getPlannerToUserReportTemplate(roleGuidanceContext) {
-  return `${getHandoffRecipientVisibilityCallout("user")}
-
-${getHandoffReportTemplateIntro("Report Template (Planner → User)")}
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-user-code.ts
+function getPlannerUserCodeTemplate(roleGuidanceContext) {
+  return `${getHandoffReportTemplateIntro()}
 
 \`\`\`markdown
 ${getHandoffReportTemplateBody(roleGuidanceContext, { includeProofOfVerification: true })}
 \`\`\``;
 }
-var init_planner_to_user = __esm(() => {
+var init_planner_user_code = __esm(() => {
   init_handoff_report_template_body();
 });
 
-// ../../services/backend/prompts/utils/chat-handoff-template.ts
-function getChatToUserHandoffTemplate() {
-  return `${getHandoffRecipientVisibilityCallout("user")}
-
-**Chat Response Template**
-
-\`\`\`markdown
-<write only the concise response the user should see; do not add handoff XML sections, proofs, context evidence, or placeholder text>
-\`\`\``;
-}
-var init_chat_handoff_template = () => {};
-
-// ../../services/backend/prompts/teams/researcher-handoff-templates.ts
-function normalizeEntryPointRole4(entryPointRole) {
-  return entryPointRole.trim().toLowerCase() || "planner";
-}
-function getEntryPointToResearcherHandoffTemplate(entryPointRole) {
-  const entryPoint = normalizeEntryPointRole4(entryPointRole);
-  return `${getHandoffRecipientVisibilityCallout("researcher")}
-
-## Handoff Template (${entryPoint} → researcher)
-
-The automatically injected \`<user-message>\` is the authoritative request. Pass the decisions the research must ground, the specific research questions, known constraints, and the files or areas already suspected. Ask the researcher for a report only: do not edit files, implement code, or design alternative architectures.
-
-### When to research
-
-Research before delegating when the slice introduces something not already grounded in this repository:
-- a new library, API, external service, platform behavior, or version-sensitive dependency;
-- an unfamiliar subsystem;
-- a change with several plausible designs;
-- any ambiguity the user has not resolved.
-
-Skip research when the change is a small, well-understood edit in code you have already inspected.
-
-After completing the research, the researcher must return the evidence-backed brief to \`${entryPoint}\` with the normal handoff command.
-
-\`\`\`bash
-${handoffCommand({
-    chatroomId: "<chatroom-id>",
-    role: entryPoint,
-    nextRole: "researcher",
-    cliEnvPrefix: ""
-  })}
-\`\`\``;
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-verifier-code.ts
+function getPlannerVerifierCodeTemplate(query) {
+  return getEntryPointToVerifierHandoffTemplate(query);
 }
-function getResearcherToEntryPointHandoffTemplate(entryPointRole) {
-  const entryPoint = normalizeEntryPointRole4(entryPointRole);
-  return `${getHandoffRecipientVisibilityCallout(entryPoint)}
-
-## Handoff Template (Researcher → ${entryPoint})
-
-Return a complete, evidence-backed research brief for the authoritative request. The researcher is advisory: do not edit files, implement code, or present alternative architectures beyond what grounds the decision. Answer only the questions asked. Separate every finding into confirmed (with evidence), inferred (with reasoning), or unknown. Never present a guess as fact. External claims must cite the source URL together with the version or date checked. Use the exact sections below, in this order.
-
-## Summary
-<state the answer to the core question in two to four sentences and whether any decision remains open>
-
-## Research questions
-<list each question exactly as asked or as derived from the request, numbered>
-
-## Answers
-<one entry per question, each tagged \`confirmed\` (with evidence), \`inferred\` (with reasoning), or \`unknown\`>
-
-## Repository evidence
-<concrete repository paths and symbols with what each shows; quote the relevant lines briefly>
-
-## External sources
-<URL, version or date checked, and the specific claim each source supports; write exactly \`None consulted.\` if no external source was needed, and say why>
-
-## Grounded facts for the plan
-<the facts the planner can rely on when decomposing and delegating, each tagged confirmed or inferred>
-
-## Remaining ambiguity
-<each open decision, who must decide it, and a recommended default; write exactly \`None observed.\` if none remain>
-
-## Risks and constraints
-<constraints from the repository or external platform, and risks the plan must account for>
-
-## Work completed
-<paths inspected, searches run, and sources opened, with the result of each>
-
-## Handoff
-Run the normal handoff command to \`${entryPoint}\` with this complete brief, then stop.
-
-\`\`\`bash
-${handoffCommand({
-    chatroomId: "<chatroom-id>",
-    role: "researcher",
-    nextRole: entryPoint,
-    cliEnvPrefix: ""
-  })}
-\`\`\``;
-}
-var init_researcher_handoff_templates = __esm(() => {
-  init_command2();
+var init_planner_verifier_code = __esm(() => {
+  init_verifier_handoff_templates();
 });
 
-// ../../services/backend/prompts/teams/triage-handoff-templates.ts
-function normalizeEntryPointRole5(entryPointRole) {
-  return entryPointRole.trim().toLowerCase() || "planner";
-}
-function getEntryPointToTriageHandoffTemplate(entryPointRole) {
-  const entryPoint = normalizeEntryPointRole5(entryPointRole);
-  return `${getHandoffRecipientVisibilityCallout("triage")}
-
-## Handoff Template (${entryPoint} → triage)
-
-The automatically injected \`<user-message>\` is the authoritative request. Pass the reported bug, observed and expected behavior, reproduction details and commands, relevant constraints, and the files or symbols already suspected. Ask triage to investigate and report only. Triage may inspect code and attempt a focused automated regression test as evidence, but must not edit implementation files or implement a fix.
-
-After completing the investigation, triage must return the evidence-backed report to \`${entryPoint}\` with the normal handoff command.
-
-\`\`\`bash
-${handoffCommand({
-    chatroomId: "<chatroom-id>",
-    role: entryPoint,
-    nextRole: "triage",
-    cliEnvPrefix: ""
-  })}
-\`\`\``;
-}
-function getTriageToEntryPointHandoffTemplate(entryPointRole) {
-  const entryPoint = normalizeEntryPointRole5(entryPointRole);
-  return `${getHandoffRecipientVisibilityCallout(entryPoint)}
-
-## Handoff Template (Triage → ${entryPoint})
-
-Return a complete, evidence-backed investigation of the authoritative reported bug. Triage is advisory: do not edit implementation files or implement the proposed fix. Begin with the \`## Summary\` section, then use the remaining sections below in order. Use \`###\` for sub-items within a section. Cite concrete repository paths and symbols, observed behavior, commands, and test output. Distinguish confirmed findings from hypotheses; never claim a test proved behavior unless its failing assertion demonstrates the report.
-
-## Summary
-<briefly state the diagnosis and whether the root cause was confirmed or remains a hypothesis>
-
-## Reported behavior
-<state the reported symptoms and expected behavior, including reproduction details and constraints recovered from the request or relevant history>
-
-## Root cause
-<trace the relevant ownership, data, and control flow using concrete repository paths and symbols; explain the causal reasoning and explicitly label the finding as confirmed or a hypothesis>
-
-## Reproduction attempt
-<give the focused test path and exact command, the failing assertion or exact blocker, and the outcome; if reproduction was blocked, state what was tried and what additional information would help; do not fabricate proof>
-
-## Proposed immediate fix
-<recommend the smallest appropriate change, naming the likely files and the specific change; do not implement it>
-
-## Systemic issues
-<list each separate systemic concern with repository evidence, impact, and follow-up concern, or write exactly: None observed.>
-
-## Work completed
-<state the code paths inspected and every test or reproduction action taken, including results>
-
-## Handoff
-Run the normal handoff command to \`${entryPoint}\` with this complete report, then stop.
-
-\`\`\`bash
-${handoffCommand({
-    chatroomId: "<chatroom-id>",
-    role: "triage",
-    nextRole: entryPoint,
-    cliEnvPrefix: ""
-  })}
-\`\`\``;
-}
-var init_triage_handoff_templates = __esm(() => {
-  init_command2();
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-verifier-chat.ts
+var init_planner_verifier_chat = __esm(() => {
+  init_planner_verifier_code();
 });
 
 // ../../services/backend/prompts/teams/duo/handoff-templates/planner.ts
 var duoPlannerHandoffContract;
 var init_planner = __esm(() => {
-  init_planner_to_builder();
-  init_planner_to_user();
-  init_chat_handoff_template();
-  init_architect_handoff_templates();
-  init_researcher_handoff_templates();
-  init_triage_handoff_templates();
-  init_uiux_engineer_handoff_templates();
-  init_verifier_handoff_templates();
+  init_planner_architect_chat();
+  init_planner_architect_code();
+  init_planner_builder_chat();
+  init_planner_builder_code();
+  init_planner_researcher_chat();
+  init_planner_researcher_code();
+  init_planner_reviewer_chat();
+  init_planner_reviewer_code();
+  init_planner_triage_chat();
+  init_planner_triage_code();
+  init_planner_uiux_engineer_chat();
+  init_planner_uiux_engineer_code();
+  init_planner_user_chat();
+  init_planner_user_code();
+  init_planner_verifier_chat();
+  init_planner_verifier_code();
+  init_contracts();
   duoPlannerHandoffContract = {
     role: "planner",
     receivesFrom: [
@@ -101265,223 +101584,227 @@ var init_planner = __esm(() => {
       "uiux-engineer",
       "triage",
       "researcher",
+      "reviewer",
+      "verifier"
+    ],
+    returnsTo: [
+      "user",
+      "builder",
+      "architect",
+      "uiux-engineer",
+      "triage",
+      "researcher",
+      "reviewer",
       "verifier"
     ],
-    returnsTo: ["builder", "architect", "uiux-engineer", "triage", "researcher", "verifier", "user"],
     outboundTemplates: {
-      builder: () => getPlannerToBuilderHandoffTemplate(),
-      architect: () => getEntryPointToArchitectHandoffTemplate("planner"),
-      "uiux-engineer": () => getEntryPointToUiuxEngineerHandoffTemplate("planner"),
-      triage: () => getEntryPointToTriageHandoffTemplate("planner"),
-      researcher: () => getEntryPointToResearcherHandoffTemplate("planner"),
-      verifier: () => getEntryPointToVerifierHandoffTemplate("planner"),
-      user: (query) => query.conversationMode === "chat" ? getChatToUserHandoffTemplate() : getPlannerToUserReportTemplate({
-        chatroomId: query.chatroomId,
-        role: query.role,
-        cliEnvPrefix: query.cliEnvPrefix
+      builder: handoffTemplateByMode({
+        chat: getPlannerBuilderCodeTemplate,
+        code: getPlannerBuilderCodeTemplate
+      }),
+      architect: handoffTemplateByMode({
+        chat: getPlannerArchitectCodeTemplate,
+        code: getPlannerArchitectCodeTemplate
+      }),
+      "uiux-engineer": handoffTemplateByMode({
+        chat: getPlannerUiuxEngineerCodeTemplate,
+        code: getPlannerUiuxEngineerCodeTemplate
+      }),
+      triage: handoffTemplateByMode({
+        chat: getPlannerTriageCodeTemplate,
+        code: getPlannerTriageCodeTemplate
+      }),
+      researcher: handoffTemplateByMode({
+        chat: getPlannerResearcherCodeTemplate,
+        code: getPlannerResearcherCodeTemplate
+      }),
+      reviewer: handoffTemplateByMode({
+        chat: getPlannerReviewerCodeTemplate,
+        code: getPlannerReviewerCodeTemplate
+      }),
+      verifier: handoffTemplateByMode({
+        chat: getPlannerVerifierCodeTemplate,
+        code: getPlannerVerifierCodeTemplate
+      }),
+      user: handoffTemplateByMode({
+        chat: getChatToUserHandoffTemplate,
+        code: getPlannerUserCodeTemplate
       })
     }
   };
 });
 
+// ../../services/backend/prompts/teams/duo/handoff-templates/researcher-planner-code.ts
+function getResearcherPlannerCodeTemplate(query) {
+  return getResearcherToEntryPointHandoffTemplate(query);
+}
+var init_researcher_planner_code = __esm(() => {
+  init_researcher_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/researcher-planner-chat.ts
+var init_researcher_planner_chat = __esm(() => {
+  init_researcher_planner_code();
+});
+
 // ../../services/backend/prompts/teams/duo/handoff-templates/researcher.ts
 var duoResearcherHandoffContract;
 var init_researcher = __esm(() => {
-  init_researcher_handoff_templates();
+  init_researcher_planner_chat();
+  init_researcher_planner_code();
+  init_contracts();
   duoResearcherHandoffContract = {
     role: "researcher",
     receivesFrom: ["planner"],
     returnsTo: ["planner"],
     outboundTemplates: {
-      planner: () => getResearcherToEntryPointHandoffTemplate("planner")
+      planner: handoffTemplateByMode({
+        chat: getResearcherPlannerCodeTemplate,
+        code: getResearcherPlannerCodeTemplate
+      })
     }
   };
 });
 
+// ../../services/backend/prompts/teams/duo/handoff-templates/reviewer-planner-code.ts
+function getReviewerPlannerCodeTemplate(query) {
+  return getReviewerToEntryPointHandoffTemplate(query);
+}
+var init_reviewer_planner_code = __esm(() => {
+  init_reviewer_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/reviewer-planner-chat.ts
+var init_reviewer_planner_chat = __esm(() => {
+  init_reviewer_planner_code();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/reviewer.ts
+var duoReviewerHandoffContract;
+var init_reviewer = __esm(() => {
+  init_reviewer_planner_chat();
+  init_reviewer_planner_code();
+  init_contracts();
+  duoReviewerHandoffContract = {
+    role: "reviewer",
+    receivesFrom: ["planner"],
+    returnsTo: ["planner"],
+    outboundTemplates: {
+      planner: handoffTemplateByMode({
+        chat: getReviewerPlannerCodeTemplate,
+        code: getReviewerPlannerCodeTemplate
+      })
+    }
+  };
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/triage-planner-code.ts
+function getTriagePlannerCodeTemplate(query) {
+  return getTriageToEntryPointHandoffTemplate(query);
+}
+var init_triage_planner_code = __esm(() => {
+  init_triage_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/triage-planner-chat.ts
+var init_triage_planner_chat = __esm(() => {
+  init_triage_planner_code();
+});
+
 // ../../services/backend/prompts/teams/duo/handoff-templates/triage.ts
 var duoTriageHandoffContract;
 var init_triage = __esm(() => {
-  init_triage_handoff_templates();
+  init_triage_planner_chat();
+  init_triage_planner_code();
+  init_contracts();
   duoTriageHandoffContract = {
     role: "triage",
     receivesFrom: ["planner"],
     returnsTo: ["planner"],
     outboundTemplates: {
-      planner: () => getTriageToEntryPointHandoffTemplate("planner")
+      planner: handoffTemplateByMode({
+        chat: getTriagePlannerCodeTemplate,
+        code: getTriagePlannerCodeTemplate
+      })
     }
   };
 });
 
+// ../../services/backend/prompts/teams/duo/handoff-templates/uiux-engineer-planner-code.ts
+function getUiuxEngineerPlannerCodeTemplate(query) {
+  return getUiuxEngineerToEntryPointHandoffTemplate(query);
+}
+var init_uiux_engineer_planner_code = __esm(() => {
+  init_uiux_engineer_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/uiux-engineer-planner-chat.ts
+var init_uiux_engineer_planner_chat = __esm(() => {
+  init_uiux_engineer_planner_code();
+});
+
 // ../../services/backend/prompts/teams/duo/handoff-templates/uiux-engineer.ts
 var duoUiuxEngineerHandoffContract;
 var init_uiux_engineer = __esm(() => {
-  init_uiux_engineer_handoff_templates();
+  init_uiux_engineer_planner_chat();
+  init_uiux_engineer_planner_code();
+  init_contracts();
   duoUiuxEngineerHandoffContract = {
     role: "uiux-engineer",
     receivesFrom: ["planner"],
     returnsTo: ["planner"],
     outboundTemplates: {
-      planner: () => getUiuxEngineerToEntryPointHandoffTemplate("planner")
+      planner: handoffTemplateByMode({
+        chat: getUiuxEngineerPlannerCodeTemplate,
+        code: getUiuxEngineerPlannerCodeTemplate
+      })
     }
   };
 });
 
+// ../../services/backend/prompts/teams/duo/handoff-templates/verifier-planner-code.ts
+function getVerifierPlannerCodeTemplate(query) {
+  return getVerifierToEntryPointHandoffTemplate(query);
+}
+var init_verifier_planner_code = __esm(() => {
+  init_verifier_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/verifier-planner-chat.ts
+var init_verifier_planner_chat = __esm(() => {
+  init_verifier_planner_code();
+});
+
 // ../../services/backend/prompts/teams/duo/handoff-templates/verifier.ts
 var duoVerifierHandoffContract;
 var init_verifier = __esm(() => {
-  init_verifier_handoff_templates();
+  init_verifier_planner_chat();
+  init_verifier_planner_code();
+  init_contracts();
   duoVerifierHandoffContract = {
     role: "verifier",
     receivesFrom: ["planner"],
     returnsTo: ["planner"],
     outboundTemplates: {
-      planner: () => getVerifierToEntryPointHandoffTemplate("planner")
+      planner: handoffTemplateByMode({
+        chat: getVerifierPlannerCodeTemplate,
+        code: getVerifierPlannerCodeTemplate
+      })
     }
   };
 });
 
-// ../shared/src/domain/chatroom-role.ts
-var CHATROOM_ROLE_USER = "user";
-var init_chatroom_role = __esm(() => {
-  init_agent_role();
-});
-
-// ../../services/backend/prompts/cli/handoff-templates/contracts.ts
-function validateRoleHandoffContracts(contracts) {
-  const byRole = new Map;
-  for (const contract of contracts) {
-    const key = contract.role.toLowerCase();
-    if (byRole.has(key)) {
-      throw new Error(`Duplicate role handoff contract: "${contract.role}"`);
-    }
-    byRole.set(key, contract);
-  }
-  for (const contract of contracts) {
-    const ownerKey = contract.role.toLowerCase();
-    for (const target of Object.keys(contract.outboundTemplates)) {
-      const targetKey = target.toLowerCase();
-      if (targetKey === "user")
-        continue;
-      const targetContract = byRole.get(targetKey);
-      if (!targetContract) {
-        throw new Error(`Role "${contract.role}" declares an outbound template to "${target}", which is neither 'user' nor a role listed in the catalogue`);
-      }
-      const declaresOwner = (targetContract.receivesFrom ?? []).some((from) => from.toLowerCase() === ownerKey);
-      if (!declaresOwner) {
-        throw new Error(`Reciprocity failure: role "${targetContract.role}" receives from "${contract.role}" (via the ${contract.role} → ${target} template) but does not declare "${contract.role}" in receivesFrom`);
-      }
-    }
-  }
-}
-function validateBuiltinOwners(teamName, expectedRoles, contracts) {
-  const actualRoles = new Set;
-  const byRole = new Map;
-  for (const contract of contracts) {
-    const normalizedOwner = contract.role.trim().toLowerCase();
-    if (!normalizedOwner || contract.role !== normalizedOwner) {
-      throw new Error(`${teamName} handoff owner "${contract.role}" is not canonical`);
-    }
-    if (actualRoles.has(normalizedOwner)) {
-      throw new Error(`${teamName} has duplicate handoff contract owner "${contract.role}"`);
-    }
-    if (!expectedRoles.has(normalizedOwner)) {
-      throw new Error(`${teamName} has unexpected handoff contract role "${contract.role}"`);
-    }
-    actualRoles.add(normalizedOwner);
-    byRole.set(normalizedOwner, contract);
-  }
-  for (const role of expectedRoles) {
-    if (!actualRoles.has(role)) {
-      throw new Error(`${teamName} is missing handoff contract for role "${role}"`);
-    }
-  }
-  return byRole;
-}
-function validateReferenceTargets(teamName, owner, label, targets, allowedTargets) {
-  const seen = new Set;
-  for (const target of targets) {
-    const normalizedTarget = target.trim().toLowerCase();
-    if (target !== normalizedTarget || !allowedTargets.has(normalizedTarget)) {
-      throw new Error(`${teamName} role "${owner}" has invalid ${label} target "${target}"`);
-    }
-    if (seen.has(normalizedTarget)) {
-      throw new Error(`${teamName} role "${owner}" has duplicate ${label} target "${target}"`);
-    }
-    seen.add(normalizedTarget);
-  }
-}
-function validateBuiltinReferences(teamName, allowedTargets, contracts) {
-  for (const contract of contracts) {
-    const owner = contract.role;
-    validateReferenceTargets(teamName, owner, "receivesFrom", contract.receivesFrom, allowedTargets);
-    validateReferenceTargets(teamName, owner, "returnsTo", contract.returnsTo, allowedTargets);
-    const outboundTargets = Object.keys(contract.outboundTemplates);
-    if (outboundTargets.length === 0) {
-      throw new Error(`${teamName} role "${owner}" must have an outbound handoff capability`);
-    }
-    const returnsTo = new Set(contract.returnsTo);
-    const outbound = new Set(outboundTargets);
-    validateReferenceTargets(teamName, owner, "outbound", outboundTargets, allowedTargets);
-    for (const target of outboundTargets) {
-      if (typeof contract.outboundTemplates[target] !== "function") {
-        throw new Error(`${teamName} role "${owner}" has no outbound getter for target "${target}"`);
-      }
-    }
-    if (returnsTo.size !== outbound.size || [...returnsTo].some((target) => !outbound.has(target))) {
-      throw new Error(`${teamName} role "${owner}" returnsTo targets must exactly match outbound targets`);
-    }
-  }
-}
-function validateBuiltinReciprocity(teamName, byRole, contracts) {
-  for (const contract of contracts) {
-    const owner = contract.role;
-    for (const receivedFrom of contract.receivesFrom) {
-      if (receivedFrom === CHATROOM_ROLE_USER)
-        continue;
-      const source = byRole.get(receivedFrom);
-      if (!source?.outboundTemplates[owner]) {
-        throw new Error(`${teamName} role "${owner}" receives from "${receivedFrom}" without a reverse outbound edge`);
-      }
-    }
-  }
-  try {
-    validateRoleHandoffContracts(contracts);
-  } catch (error51) {
-    const contextualError = new Error(`${teamName}: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    Object.defineProperty(contextualError, "cause", { value: error51, configurable: true });
-    throw contextualError;
-  }
-}
-function validateBuiltinTeamRoleHandoffContracts(teamId, contracts) {
-  const teamName = TEAM_PRESETS[teamId].name;
-  const expectedRoles = new Set(TEAM_PRESETS[teamId].roles);
-  const byRole = validateBuiltinOwners(teamName, expectedRoles, contracts);
-  const allowedTargets = new Set([...expectedRoles, CHATROOM_ROLE_USER]);
-  validateBuiltinReferences(teamName, allowedTargets, contracts);
-  validateBuiltinReciprocity(teamName, byRole, contracts);
-}
-var init_contracts = __esm(() => {
-  init_chatroom_role();
-  init_team_presets();
-});
-
 // ../../services/backend/prompts/teams/duo/handoff-templates/index.ts
 function listDuoRoleHandoffContracts() {
   return validatedDuoRoleHandoffContracts;
 }
-function getDuoHandoffTemplate(query) {
-  const fromRole = query.fromRole.toLowerCase();
-  const toRole = query.toRole.toLowerCase();
-  const contract = validatedDuoRoleHandoffContracts.find((candidate) => candidate.role.toLowerCase() === fromRole);
-  const getter = contract?.outboundTemplates[toRole];
-  return getter?.(query) ?? null;
-}
 var DUO_ROLE_HANDOFF_CATALOG, DUO_ROLE_HANDOFF_CONTRACTS, validatedDuoRoleHandoffContracts;
 var init_handoff_templates = __esm(() => {
   init_architect();
   init_builder();
   init_planner();
   init_researcher();
+  init_reviewer();
   init_triage();
   init_uiux_engineer();
   init_verifier();
@@ -101491,6 +101814,7 @@ var init_handoff_templates = __esm(() => {
     builder: duoBuilderHandoffContract,
     architect: duoArchitectHandoffContract,
     researcher: duoResearcherHandoffContract,
+    reviewer: duoReviewerHandoffContract,
     "uiux-engineer": duoUiuxEngineerHandoffContract,
     triage: duoTriageHandoffContract,
     verifier: duoVerifierHandoffContract
@@ -101502,99 +101826,240 @@ var init_handoff_templates = __esm(() => {
   })();
 });
 
+// ../../services/backend/prompts/teams/solo/handoff-templates/architect-solo-code.ts
+function getArchitectSoloCodeTemplate(query) {
+  return getArchitectToEntryPointHandoffTemplate(query);
+}
+var init_architect_solo_code = __esm(() => {
+  init_architect_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/solo/handoff-templates/architect-solo-chat.ts
+var init_architect_solo_chat = __esm(() => {
+  init_architect_solo_code();
+});
+
 // ../../services/backend/prompts/teams/solo/handoff-templates/architect.ts
 var soloArchitectHandoffContract;
 var init_architect2 = __esm(() => {
-  init_architect_handoff_templates();
+  init_architect_solo_chat();
+  init_architect_solo_code();
+  init_contracts();
   soloArchitectHandoffContract = {
     role: "architect",
     receivesFrom: ["solo"],
     returnsTo: ["solo"],
     outboundTemplates: {
-      solo: () => getArchitectToEntryPointHandoffTemplate("solo")
+      solo: handoffTemplateByMode({
+        chat: getArchitectSoloCodeTemplate,
+        code: getArchitectSoloCodeTemplate
+      })
     }
   };
 });
 
-// ../../services/backend/prompts/teams/solo/handoff-templates/solo-to-user.ts
-function getSoloToUserReportTemplate(roleGuidanceContext) {
-  return `${getHandoffRecipientVisibilityCallout("user")}
+// ../../services/backend/prompts/teams/solo/handoff-templates/solo-architect-code.ts
+function getSoloArchitectCodeTemplate(query) {
+  return getEntryPointToArchitectHandoffTemplate(query);
+}
+var init_solo_architect_code = __esm(() => {
+  init_architect_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/solo/handoff-templates/solo-architect-chat.ts
+var init_solo_architect_chat = __esm(() => {
+  init_solo_architect_code();
+});
 
-${getHandoffReportTemplateIntro("Report Template (Solo → User)")}
+// ../../services/backend/prompts/teams/solo/handoff-templates/solo-triage-code.ts
+function getSoloTriageCodeTemplate(query) {
+  return getEntryPointToTriageHandoffTemplate(query);
+}
+var init_solo_triage_code = __esm(() => {
+  init_triage_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/solo/handoff-templates/solo-triage-chat.ts
+var init_solo_triage_chat = __esm(() => {
+  init_solo_triage_code();
+});
+
+// ../../services/backend/prompts/teams/solo/handoff-templates/solo-uiux-engineer-code.ts
+function getSoloUiuxEngineerCodeTemplate(query) {
+  return getEntryPointToUiuxEngineerHandoffTemplate(query);
+}
+var init_solo_uiux_engineer_code = __esm(() => {
+  init_uiux_engineer_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/solo/handoff-templates/solo-uiux-engineer-chat.ts
+var init_solo_uiux_engineer_chat = __esm(() => {
+  init_solo_uiux_engineer_code();
+});
+
+// ../../services/backend/prompts/teams/solo/handoff-templates/solo-user-chat.ts
+var init_solo_user_chat = () => {};
+
+// ../../services/backend/prompts/teams/solo/handoff-templates/solo-user-code.ts
+function getSoloUserCodeTemplate(roleGuidanceContext) {
+  return `${getHandoffReportTemplateIntro()}
 
 \`\`\`markdown
 ${getHandoffReportTemplateBody(roleGuidanceContext, { includeProofOfVerification: true })}
 \`\`\``;
 }
-var init_solo_to_user = __esm(() => {
+var init_solo_user_code = __esm(() => {
   init_handoff_report_template_body();
 });
 
+// ../../services/backend/prompts/teams/solo/handoff-templates/solo-verifier-code.ts
+function getSoloVerifierCodeTemplate(query) {
+  return getEntryPointToVerifierHandoffTemplate(query);
+}
+var init_solo_verifier_code = __esm(() => {
+  init_verifier_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/solo/handoff-templates/solo-verifier-chat.ts
+var init_solo_verifier_chat = __esm(() => {
+  init_solo_verifier_code();
+});
+
 // ../../services/backend/prompts/teams/solo/handoff-templates/solo.ts
 var soloHandoffContract;
 var init_solo = __esm(() => {
-  init_solo_to_user();
-  init_chat_handoff_template();
-  init_architect_handoff_templates();
-  init_triage_handoff_templates();
-  init_uiux_engineer_handoff_templates();
-  init_verifier_handoff_templates();
+  init_solo_architect_chat();
+  init_solo_architect_code();
+  init_solo_triage_chat();
+  init_solo_triage_code();
+  init_solo_uiux_engineer_chat();
+  init_solo_uiux_engineer_code();
+  init_solo_user_chat();
+  init_solo_user_code();
+  init_solo_verifier_chat();
+  init_solo_verifier_code();
+  init_contracts();
   soloHandoffContract = {
     role: "solo",
     receivesFrom: ["user", "architect", "uiux-engineer", "triage", "verifier"],
-    returnsTo: ["architect", "uiux-engineer", "triage", "verifier", "user"],
+    returnsTo: ["user", "architect", "uiux-engineer", "triage", "verifier"],
     outboundTemplates: {
-      architect: () => getEntryPointToArchitectHandoffTemplate("solo"),
-      "uiux-engineer": () => getEntryPointToUiuxEngineerHandoffTemplate("solo"),
-      triage: () => getEntryPointToTriageHandoffTemplate("solo"),
-      verifier: () => getEntryPointToVerifierHandoffTemplate("solo"),
-      user: (query) => query.conversationMode === "chat" ? getChatToUserHandoffTemplate() : getSoloToUserReportTemplate({
-        chatroomId: query.chatroomId,
-        role: query.role,
-        cliEnvPrefix: query.cliEnvPrefix
+      architect: handoffTemplateByMode({
+        chat: getSoloArchitectCodeTemplate,
+        code: getSoloArchitectCodeTemplate
+      }),
+      "uiux-engineer": handoffTemplateByMode({
+        chat: getSoloUiuxEngineerCodeTemplate,
+        code: getSoloUiuxEngineerCodeTemplate
+      }),
+      triage: handoffTemplateByMode({
+        chat: getSoloTriageCodeTemplate,
+        code: getSoloTriageCodeTemplate
+      }),
+      verifier: handoffTemplateByMode({
+        chat: getSoloVerifierCodeTemplate,
+        code: getSoloVerifierCodeTemplate
+      }),
+      user: handoffTemplateByMode({
+        chat: getChatToUserHandoffTemplate,
+        code: getSoloUserCodeTemplate
       })
     }
   };
 });
 
+// ../../services/backend/prompts/teams/solo/handoff-templates/triage-solo-code.ts
+function getTriageSoloCodeTemplate(query) {
+  return getTriageToEntryPointHandoffTemplate(query);
+}
+var init_triage_solo_code = __esm(() => {
+  init_triage_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/solo/handoff-templates/triage-solo-chat.ts
+var init_triage_solo_chat = __esm(() => {
+  init_triage_solo_code();
+});
+
 // ../../services/backend/prompts/teams/solo/handoff-templates/triage.ts
 var soloTriageHandoffContract;
 var init_triage2 = __esm(() => {
-  init_triage_handoff_templates();
+  init_triage_solo_chat();
+  init_triage_solo_code();
+  init_contracts();
   soloTriageHandoffContract = {
     role: "triage",
     receivesFrom: ["solo"],
     returnsTo: ["solo"],
     outboundTemplates: {
-      solo: () => getTriageToEntryPointHandoffTemplate("solo")
+      solo: handoffTemplateByMode({
+        chat: getTriageSoloCodeTemplate,
+        code: getTriageSoloCodeTemplate
+      })
     }
   };
 });
 
+// ../../services/backend/prompts/teams/solo/handoff-templates/uiux-engineer-solo-code.ts
+function getUiuxEngineerSoloCodeTemplate(query) {
+  return getUiuxEngineerToEntryPointHandoffTemplate(query);
+}
+var init_uiux_engineer_solo_code = __esm(() => {
+  init_uiux_engineer_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/solo/handoff-templates/uiux-engineer-solo-chat.ts
+var init_uiux_engineer_solo_chat = __esm(() => {
+  init_uiux_engineer_solo_code();
+});
+
 // ../../services/backend/prompts/teams/solo/handoff-templates/uiux-engineer.ts
 var soloUiuxEngineerHandoffContract;
 var init_uiux_engineer2 = __esm(() => {
-  init_uiux_engineer_handoff_templates();
+  init_uiux_engineer_solo_chat();
+  init_uiux_engineer_solo_code();
+  init_contracts();
   soloUiuxEngineerHandoffContract = {
     role: "uiux-engineer",
     receivesFrom: ["solo"],
     returnsTo: ["solo"],
     outboundTemplates: {
-      solo: () => getUiuxEngineerToEntryPointHandoffTemplate("solo")
+      solo: handoffTemplateByMode({
+        chat: getUiuxEngineerSoloCodeTemplate,
+        code: getUiuxEngineerSoloCodeTemplate
+      })
     }
   };
 });
 
+// ../../services/backend/prompts/teams/solo/handoff-templates/verifier-solo-code.ts
+function getVerifierSoloCodeTemplate(query) {
+  return getVerifierToEntryPointHandoffTemplate(query);
+}
+var init_verifier_solo_code = __esm(() => {
+  init_verifier_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/solo/handoff-templates/verifier-solo-chat.ts
+var init_verifier_solo_chat = __esm(() => {
+  init_verifier_solo_code();
+});
+
 // ../../services/backend/prompts/teams/solo/handoff-templates/verifier.ts
 var soloVerifierHandoffContract;
 var init_verifier2 = __esm(() => {
-  init_verifier_handoff_templates();
+  init_verifier_solo_chat();
+  init_verifier_solo_code();
+  init_contracts();
   soloVerifierHandoffContract = {
     role: "verifier",
     receivesFrom: ["solo"],
     returnsTo: ["solo"],
     outboundTemplates: {
-      solo: () => getVerifierToEntryPointHandoffTemplate("solo")
+      solo: handoffTemplateByMode({
+        chat: getVerifierSoloCodeTemplate,
+        code: getVerifierSoloCodeTemplate
+      })
     }
   };
 });
@@ -101603,13 +102068,6 @@ var init_verifier2 = __esm(() => {
 function listSoloRoleHandoffContracts() {
   return validatedSoloRoleHandoffContracts;
 }
-function getSoloHandoffTemplate(query) {
-  const fromRole = query.fromRole.toLowerCase();
-  const toRole = query.toRole.toLowerCase();
-  const contract = validatedSoloRoleHandoffContracts.find((candidate) => candidate.role.toLowerCase() === fromRole);
-  const getter = contract?.outboundTemplates[toRole];
-  return getter?.(query) ?? null;
-}
 var SOLO_ROLE_HANDOFF_CATALOG, SOLO_ROLE_HANDOFF_CONTRACTS, validatedSoloRoleHandoffContracts;
 var init_handoff_templates2 = __esm(() => {
   init_architect2();
@@ -101633,85 +102091,117 @@ var init_handoff_templates2 = __esm(() => {
 });
 
 // ../../services/backend/prompts/cli/handoff-templates/index.ts
-function resolveTeamContracts(teamId) {
-  const team = (teamId ?? "duo").toLowerCase();
-  if (team === "duo")
-    return listDuoRoleHandoffContracts();
-  if (team === "solo")
-    return listSoloRoleHandoffContracts();
-  return null;
+function listHandoffTemplatePairs(teamId, fromRole) {
+  const team = (teamId ?? DEFAULT_HANDOFF_TEAM_ID).trim().toLowerCase();
+  if (!isTeamPresetId(team))
+    return [];
+  const normalizedFrom = fromRole === undefined ? undefined : fromRole.trim().toLowerCase();
+  const contracts = normalizedFrom === undefined ? BUILTIN_TEAM_HANDOFF_CONTRACTS[team] : BUILTIN_TEAM_HANDOFF_CONTRACTS[team].filter((contract) => contract.role.toLowerCase() === normalizedFrom);
+  return contracts.flatMap((contract) => contract.returnsTo.map((toRole) => ({
+    teamId: team,
+    fromRole: contract.role,
+    toRole
+  })));
+}
+function resolveHandoffTemplatePair(input, command) {
+  const from = normalizeHandoffRole(input.from);
+  const to = normalizeHandoffRole(input.to);
+  const legacyRole = normalizeHandoffRole(input.legacyRole);
+  const legacyNextRole = normalizeHandoffRole(input.legacyNextRole);
+  const team = (input.teamId ?? DEFAULT_HANDOFF_TEAM_ID).trim().toLowerCase();
+  if (from !== undefined && to !== undefined) {
+    if (!isTeamPresetId(team)) {
+      throw new HandoffTemplatePairError("UNKNOWN_TEAM", unknownTeamMessage(team));
+    }
+    const contracts = BUILTIN_TEAM_HANDOFF_CONTRACTS[team];
+    const contract = contracts.find((candidate) => candidate.role.toLowerCase() === from);
+    if (!contract) {
+      throw new HandoffTemplatePairError("UNKNOWN_FROM_ROLE", unknownFromRoleMessage({ from, team, roles: contracts.map((c) => c.role) }));
+    }
+    if (!contract.returnsTo.includes(to)) {
+      throw new HandoffTemplatePairError("UNKNOWN_PAIR", unknownPairMessage({ from, to, team, recipients: contract.returnsTo }));
+    }
+    return { teamId: team, fromRole: contract.role, toRole: to };
+  }
+  if (legacyRole !== undefined || legacyNextRole !== undefined) {
+    throw new HandoffTemplatePairError("LEGACY_ROLE_FLAGS", legacyRoleFlagsMessage(command, {
+      teamId: team,
+      legacyRole,
+      legacyNextRole,
+      mode: normalizeHandoffMode(input.mode),
+      rolePairs: legacyRole === undefined ? undefined : listHandoffTemplatePairs(team, legacyRole)
+    }));
+  }
+  const missing = from === undefined && to === undefined ? "--from, --to" : from === undefined ? "--from" : "--to";
+  throw new HandoffTemplatePairError("MISSING_PAIR", missingPairMessage(command, missing));
+}
+function resolveHandoffTemplateSelection(input, command) {
+  const pair = resolveHandoffTemplatePair(input, command);
+  const mode = normalizeHandoffMode(input.mode);
+  if (mode === undefined) {
+    throw new HandoffTemplatePairError("MISSING_MODE", missingModeMessage(command));
+  }
+  if (!isConversationMode2(mode)) {
+    throw new HandoffTemplatePairError("UNKNOWN_MODE", unknownModeMessage(mode));
+  }
+  return { pair, mode };
 }
-function listHandoffTemplates(query) {
-  const teamId = (query.teamId ?? "duo").toLowerCase();
-  const contracts = resolveTeamContracts(teamId);
-  if (!contracts)
+function renderHandoffTemplate(pair, options) {
+  const contract = BUILTIN_TEAM_HANDOFF_CONTRACTS[pair.teamId].find((candidate) => candidate.role.toLowerCase() === pair.fromRole);
+  const getter = contract?.outboundTemplates[pair.toRole];
+  if (!getter)
     return null;
-  const contract = contracts.find((candidate) => candidate.role.toLowerCase() === query.role.toLowerCase());
-  if (!contract)
+  const body = getter({
+    ...options,
+    teamId: pair.teamId,
+    fromRole: pair.fromRole,
+    toRole: pair.toRole,
+    role: pair.fromRole
+  });
+  if (!body)
     return null;
-  const templates = [];
-  for (const toRole of Object.keys(contract.outboundTemplates).sort()) {
-    const getter = contract.outboundTemplates[toRole];
-    const template = getter?.({
-      fromRole: contract.role,
-      toRole,
-      teamId,
-      nativeIntegration: query.nativeIntegration,
-      chatroomId: query.chatroomId,
-      role: contract.role,
-      cliEnvPrefix: query.cliEnvPrefix,
-      conversationMode: query.conversationMode
-    });
-    if (!template)
-      continue;
-    templates.push({ fromRole: contract.role, toRole, template });
-  }
-  return {
-    teamId,
-    role: contract.role,
-    receivesFrom: [...contract.receivesFrom],
-    returnsTo: [...contract.returnsTo],
-    templates
-  };
-}
-function getHandoffTemplate(query) {
-  const team = (query.teamId ?? "duo").toLowerCase();
-  if (team === "duo")
-    return getDuoHandoffTemplate(query);
-  if (team === "solo")
-    return getSoloHandoffTemplate(query);
-  return null;
+  return [
+    getHandoffRecipientVisibilityCallout(pair.toRole),
+    getHandoffTemplateTitleLine(pair),
+    body
+  ].join(`
+
+`);
+}
+function getReplyHandoffTemplatePair(pair) {
+  const contract = BUILTIN_TEAM_HANDOFF_CONTRACTS[pair.teamId].find((candidate) => candidate.role.toLowerCase() === pair.toRole);
+  const getter = contract?.outboundTemplates[pair.fromRole];
+  if (!getter)
+    return null;
+  return { teamId: pair.teamId, fromRole: pair.toRole, toRole: pair.fromRole };
 }
+var BUILTIN_TEAM_HANDOFF_CONTRACTS;
 var init_handoff_templates3 = __esm(() => {
+  init_pair();
   init_handoff_templates();
   init_handoff_templates2();
+  BUILTIN_TEAM_HANDOFF_CONTRACTS = {
+    duo: listDuoRoleHandoffContracts(),
+    solo: listSoloRoleHandoffContracts()
+  };
 });
 
 // ../../services/backend/prompts/cli/handoff/view-template.ts
 function viewHandoffTemplate(params) {
-  if (params.nextRole === undefined) {
-    const role = params.role.trim().toLowerCase();
-    if (role === "architect")
-      return getGenericArchitectToEntryPointHandoffTemplate();
-    if (role === "uiux-engineer")
-      return getGenericUiuxEngineerToEntryPointHandoffTemplate();
-    throw new Error(`Role-only handoff template viewing is supported only for architect or uiux-engineer, not ${params.role}`);
-  }
-  const template = getHandoffTemplate({
-    fromRole: params.role,
-    toRole: params.nextRole,
-    teamId: params.teamId,
-    nativeIntegration: params.nativeIntegration ?? true
+  const { pair, mode } = resolveHandoffTemplateSelection(params, "view-template");
+  const template = renderHandoffTemplate(pair, {
+    nativeIntegration: params.nativeIntegration ?? true,
+    cliEnvPrefix: params.cliEnvPrefix,
+    conversationMode: mode
   });
   if (!template) {
-    throw new Error(`No handoff template for ${params.role} → ${params.nextRole}`);
+    throw new HandoffTemplatePairError("UNKNOWN_PAIR", unrenderablePairMessage(pair));
   }
   return template;
 }
 var init_view_template2 = __esm(() => {
-  init_architect_handoff_templates();
-  init_uiux_engineer_handoff_templates();
   init_handoff_templates3();
+  init_pair();
 });
 
 // src/commands/handoff/view-template.ts
@@ -101720,48 +102210,49 @@ __export(exports_view_template, {
   printHandoffViewTemplate: () => printHandoffViewTemplate
 });
 function printHandoffViewTemplate(options) {
-  const template = viewHandoffTemplate({
-    role: options.role,
-    nextRole: options.nextRole,
-    teamId: options.teamId,
-    nativeIntegration: true
-  });
-  console.log(template);
+  try {
+    console.log(viewHandoffTemplate({ ...options, nativeIntegration: true }));
+  } catch (err) {
+    console.error(`❌ ${err.message}`);
+    process.exit(1);
+  }
 }
 var init_view_template3 = __esm(() => {
   init_view_template2();
 });
 
 // ../../services/backend/prompts/cli/handoff-templates/list-templates.ts
-function formatHandoffTemplateListing(listing) {
-  const receives = listing.receivesFrom.length ? listing.receivesFrom.map((role) => `\`${role}\``).join(", ") : "(none)";
-  const returns = listing.returnsTo.length ? listing.returnsTo.map((role) => `\`${role}\``).join(", ") : "(none)";
-  const lines = [
-    `Handoff contract for \`${listing.role}\` (team: \`${listing.teamId}\`)`,
-    "",
-    `Receives from: ${receives}`,
-    `Returns to: ${returns}`,
-    "",
-    "Renderable outbound templates:",
-    ...listing.templates.map((template) => `- \`${template.fromRole}\` → \`${template.toRole}\``)
-  ];
-  return lines.join(`
-`);
-}
 function listHandoffTemplatesCommand(params) {
-  const listing = listHandoffTemplates({
-    role: params.role,
-    teamId: params.teamId,
-    cliEnvPrefix: params.cliEnvPrefix
+  const { pair, mode } = resolveHandoffTemplateSelection(params, "list-templates");
+  const reply = getReplyHandoffTemplatePair(pair);
+  const template = renderHandoffTemplate(pair, {
+    nativeIntegration: true,
+    cliEnvPrefix: params.cliEnvPrefix,
+    conversationMode: mode
   });
-  if (!listing) {
-    const teamId = params.teamId ?? "duo";
-    throw new Error(`No handoff contract for role "${params.role}" in team "${teamId}". Known roles: planner, builder (duo) or solo.`);
+  if (!template) {
+    throw new HandoffTemplatePairError("UNKNOWN_PAIR", unrenderablePairMessage(pair));
   }
-  return formatHandoffTemplateListing(listing);
+  const sendCommand = handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: pair.fromRole,
+    nextRole: pair.toRole,
+    cliEnvPrefix: params.cliEnvPrefix ?? ""
+  }).split(`
+`)[0];
+  return [
+    `Handoff template ${formatHandoffPairLabel(pair)} (team: \`${pair.teamId}\`, mode: \`${mode}\`, key: \`${formatHandoffTemplateKey({ pair, mode })}\`)`,
+    `Send with: ${sendCommand}`,
+    reply ? `Reply pair: ${formatHandoffPairLabel(reply)} (view: ${formatHandoffTemplateCommand("view-template", reply, params.cliEnvPrefix, mode)})` : `Reply pair: none (\`${pair.toRole}\` replies free-form)`,
+    "",
+    template
+  ].join(`
+`);
 }
 var init_list_templates = __esm(() => {
   init_handoff_templates3();
+  init_pair();
+  init_command2();
 });
 
 // src/commands/handoff/list-templates.ts
@@ -101771,12 +102262,7 @@ __export(exports_list_templates, {
 });
 function printHandoffListTemplates(options) {
   try {
-    const output = listHandoffTemplatesCommand({
-      role: options.role,
-      teamId: options.teamId,
-      cliEnvPrefix: options.cliEnvPrefix
-    });
-    console.log(output);
+    console.log(listHandoffTemplatesCommand(options));
   } catch (err) {
     console.error(`❌ ${err.message}`);
     process.exit(1);
@@ -102071,8 +102557,17 @@ var init_commands_reference = __esm(() => {
   init_command4();
   init_utils3();
 });
+
+// ../../services/backend/prompts/cli/sections/handoff-template-discovery.ts
+var init_handoff_template_discovery = __esm(() => {
+  init_handoff_templates3();
+  init_pair();
+});
+
 // ../../services/backend/prompts/cli/sections/core-responsibilities.ts
-var init_core_responsibilities = () => {};
+var init_core_responsibilities = __esm(() => {
+  init_handoff_template_discovery();
+});
 // ../../services/backend/prompts/cli/sections/inter-role-handoff-rule.ts
 function getInterRoleHandoffRule() {
   return [
@@ -102095,6 +102590,7 @@ var init_operating_model = () => {};
 // ../../services/backend/prompts/cli/sections/index.ts
 var init_sections = __esm(() => {
   init_core_responsibilities();
+  init_handoff_template_discovery();
   init_handoff_rules();
   init_proof_of_verification2();
   init_operating_model();
@@ -102118,13 +102614,13 @@ ${getInterRoleHandoffRule()}
 4. Analyze concurrent writers and races, idempotency, ordering/monotonicity, retries, transactions, failure/recovery, primary read paths, indexes, projections/read models, query shapes, scan/transaction limits, and invalidation/subscription scope.
 5. Account for Convex reactivity and bandwidth: avoid unnecessary reactive fanout and separate high-frequency heartbeat/liveness/status fields from low-frequency identity/configuration fields. Specify migration/backfill sequence, tests, acceptance criteria, and the implementation and verification sequence.
 6. Keep the proposal within the user's request and the repository's established patterns. Do not expand scope, spawn subagents, implement the design, edit files, or act as the builder.
-7. Hand the complete design brief to the configured entry point with the normal command, then stop:
+7. Hand the complete design brief to \`{ENTRY_POINT_ROLE}\` with the normal command, then stop:
 
 \`\`\`bash
 chatroom handoff --chatroom-id="<chatroom-id>" --role="architect" --next-role="{ENTRY_POINT_ROLE}"
 \`\`\`
 
-The handoff must contain every required brief section, repository evidence, chosen design, exact file/API/schema details, risks, acceptance criteria, tests, and implementation sequence the configured entry point needs to coordinate implementation. It must not contain implementation edits or alternative designs.`;
+The handoff must contain every required brief section, repository evidence, chosen design, exact file/API/schema details, risks, acceptance criteria, tests, and implementation sequence \`{ENTRY_POINT_ROLE}\` needs to coordinate implementation. It must not contain implementation edits or alternative designs.`;
 });
 
 // ../../services/backend/prompts/cli/roles/builder.ts
@@ -102156,20 +102652,44 @@ ${getInterRoleHandoffRule()}
 4. Label every finding \`confirmed\`, \`inferred\`, or \`unknown\`. Never present a guess as fact.
 5. Resolve ambiguity where evidence allows. For the rest, state the open question, who must decide it, and a recommended default.
 6. Follow the injected \`<handoff-templates>\` research brief exactly, in its order. Answer only the questions asked. Do not present alternative architectures beyond what grounds the decision.
-7. Hand the brief to the configured entry point with the normal command, then stop:
+7. Hand the brief to \`{ENTRY_POINT_ROLE}\` with the normal command, then stop:
 
 \`\`\`bash
 chatroom handoff --chatroom-id="<chatroom-id>" --role="researcher" --next-role="{ENTRY_POINT_ROLE}"
 \`\`\``;
 });
 
+// ../../services/backend/prompts/cli/roles/reviewer.ts
+var REVIEWER_GUIDANCE;
+var init_reviewer2 = __esm(() => {
+  init_sections();
+  REVIEWER_GUIDANCE = `## Reviewer Operating Model
+
+You are the reviewer responsible for inspecting the code artifacts the planner names and reporting the issues you observe. You are advisory only: do not edit files, implement fixes, or act as the builder or planner.
+
+${"{SESSION_CONTINUITY}"}
+
+${getInterRoleHandoffRule()}
+
+1. Recover the review target and focus from the injected task and the \`<handoff-templates>\` brief. If the target is not explicit, ask the planner through the handoff; do not guess a range.
+2. Inspect the target: the diff or commits, the changed files, and the surrounding code they depend on. Read the actual files; do not review from summaries.
+3. Look for correctness bugs, security issues, missing or weak tests, unclear ownership or error handling, dead code, duplication, and type drift. Stay within the stated focus when one is given.
+4. Label every issue with a severity (\`blocker\`, \`major\`, \`minor\`, \`nit\`) and cite the file and line. Only report what you observed; mark anything unverified as such.
+5. Follow the injected \`<handoff-templates>\` review report exactly, in its order.
+6. Hand the report to \`{ENTRY_POINT_ROLE}\` with the normal command, then stop:
+
+\`\`\`bash
+chatroom handoff --chatroom-id="<chatroom-id>" --role="reviewer" --next-role="{ENTRY_POINT_ROLE}"
+\`\`\``;
+});
+
 // ../../services/backend/prompts/cli/roles/triage.ts
 var TRIAGE_GUIDANCE;
 var init_triage3 = __esm(() => {
   init_sections();
   TRIAGE_GUIDANCE = `## Triage Operating Model
 
-You are the triage agent responsible for investigating a reported bug so the entry point can delegate a precise fix. You are advisory only: do not edit implementation files or implement the fix.
+You are the triage agent responsible for investigating a reported bug so the recipient can delegate a precise fix. You are advisory only: do not edit implementation files or implement the fix.
 
 ${"{SESSION_CONTINUITY}"}
 
@@ -102179,7 +102699,7 @@ ${getInterRoleHandoffRule()}
 2. Trace the relevant code paths with concrete repository paths and symbols. Label every finding \`confirmed\` or \`hypothesis\`. Never present a hypothesis as fact.
 3. Attempt a focused reproduction only when it is cheap and safe. A focused regression test may be written as evidence. Do not edit implementation files.
 4. Write the report using the sections in the injected \`<handoff-templates>\`, in the order given, beginning with the \`## Summary\` section.
-5. Hand the report to the configured entry point with the normal command, then stop:
+5. Hand the report to \`{ENTRY_POINT_ROLE}\` with the normal command, then stop:
 
 \`\`\`bash
 chatroom handoff --chatroom-id="<chatroom-id>" --role="triage" --next-role="{ENTRY_POINT_ROLE}"
@@ -102204,20 +102724,19 @@ ${getInterRoleHandoffRule()}
 4. Specify exact keyboard shortcuts, focus order, keyboard navigation, focus restoration, accessible semantics and labels, component hierarchy and ownership, props/state/events, data boundaries, and interaction behavior.
 5. Choose concrete ShadCN components using the Base UI backend and existing icon conventions. Specify exact Tailwind utility or semantic theme-token classes for layout, spacing, sizing, typography, states, responsive behavior, and dark mode; keep the styling theme-aware and make state ownership explicit. Also specify responsive breakpoints, visual feedback, destructive-action safeguards, and the UI/integration/accessibility test plan.
 6. Keep the proposal within the user's request and the repository's established patterns. Do not expand scope, spawn subagents, implement the design, edit files, or act as the builder.
-7. Hand the complete design brief to the configured entry point with the normal command, then stop:
+7. Hand the complete design brief to \`{ENTRY_POINT_ROLE}\` with the normal command, then stop:
 
 \`\`\`bash
 chatroom handoff --chatroom-id="<chatroom-id>" --role="uiux-engineer" --next-role="{ENTRY_POINT_ROLE}"
 \`\`\`
 
-The handoff must contain every required brief section, repository evidence, chosen flow, exact component/prop/state details, explicit states, accessibility details, ownership decisions, concrete classes/tokens, risks, acceptance criteria, tests, and implementation sequence the configured entry point needs to coordinate implementation. It must not contain implementation edits or alternative designs.`;
+The handoff must contain every required brief section, repository evidence, chosen flow, exact component/prop/state details, explicit states, accessibility details, ownership decisions, concrete classes/tokens, risks, acceptance criteria, tests, and implementation sequence \`{ENTRY_POINT_ROLE}\` needs to coordinate implementation. It must not contain implementation edits or alternative designs.`;
 });
 
 // ../../services/backend/prompts/cli/roles/verifier.ts
 var ACHIEVED2, NOT_ACHIEVED2, INCONCLUSIVE2, VERIFIER_GUIDANCE;
 var init_verifier3 = __esm(() => {
   init_verifier_handoff_templates();
-  init_chat_handoff_template();
   init_handoff_report_template_body();
   init_sections();
   [ACHIEVED2, NOT_ACHIEVED2, INCONCLUSIVE2] = VERIFIER_VERDICTS;
@@ -102237,7 +102756,7 @@ ${getInterRoleHandoffRule()}
 4a. User expectations: the user's handoff template defines what the user expects from the work. In a code mode, turn each applicable item that concerns the work into a user expectation: each requirement's evidence (PR, commit, or file), files changed, Code Change Verification, backlog items moved to \`pending_user_review\` after a verified end-to-end feature with a PR, and any manual steps or unresolved decisions the user must act on. Skip presentation-only items: template disclosure checkboxes, section order, collapsing, diagram format, and Proof of Planning. In \`chat\` mode the template asks only for a direct, concise answer, so add no expectations beyond the requirements.
 5. Find evidence for every requirement in the logs alone: builder handoff reports, planner delegations, quoted test output, commits, and PRs. \`met\` requires concrete evidence in the logs. The planner's claimed outcome is a claim, not evidence. Silence means \`unverified\`. A contradiction, or a log showing the requirement was not done, means \`unmet\`. Never state that tests passed unless a log reports it, or you ran the requested tests yourself.
 6. Choose exactly one verdict from ${VERIFIER_VERDICTS.join(", ")}: ${ACHIEVED2} only if every requirement and every user expectation is met; ${NOT_ACHIEVED2} if any requirement or user expectation is unmet; ${INCONCLUSIVE2} if none is unmet but any is unverified.
-7. Follow the injected \`<handoff-templates>\` verdict template exactly, in its order, and put the complete verdict in the handoff. Then hand off to the configured entry point with the normal command, then stop:
+7. Follow the injected \`<handoff-templates>\` verdict template exactly, in its order, and put the complete verdict in the handoff. Then hand off to \`{ENTRY_POINT_ROLE}\` with the normal command, then stop:
 
 \`\`\`bash
 chatroom handoff --chatroom-id="<chatroom-id>" --role="verifier" --next-role="{ENTRY_POINT_ROLE}"
@@ -102266,10 +102785,12 @@ var init_fromContext2 = __esm(() => {
   init_builder2();
   init_planner2();
   init_researcher2();
+  init_reviewer2();
   init_triage3();
   init_uiux_engineer3();
   init_verifier3();
   init_fromContext();
+  init_handoff_templates3();
 });
 
 // ../../services/backend/prompts/teams/duo/prompts/builder.ts
@@ -102358,6 +102879,19 @@ var init_templates = __esm(() => {
       ],
       defaultHandoffTarget: "planner"
     },
+    reviewer: {
+      role: "reviewer",
+      title: "Reviewer",
+      description: "You are the reviewer responsible for inspecting the code artifacts the planner names and reporting the issues you observe; you are advisory only and do not implement fixes.",
+      responsibilities: [
+        "Recover the review target and focus from the planner brief",
+        "Inspect the diff or commits and the surrounding code they depend on",
+        "Look for correctness, security, test quality, ownership, dead code, duplication, and type drift",
+        "Label each issue with a severity and cite the file and line",
+        "Hand one review report to the planner, separating reviewed scope from what was not reviewed"
+      ],
+      defaultHandoffTarget: "planner"
+    },
     verifier: {
       role: "verifier",
       title: "Verifier",
@@ -102381,7 +102915,7 @@ var init_templates = __esm(() => {
         "Attempt to reproduce the issue with the smallest focused automated test and report the result honestly",
         "Recommend the smallest immediate fix without implementing it",
         "Report systemic design risks separately from the immediate fix",
-        "Hand the complete investigation report to the configured entry point"
+        "Hand the complete investigation report to the planner"
       ],
       defaultHandoffTarget: "planner"
     },
@@ -138304,37 +138838,29 @@ teamCommand.command("set").description("Set the team preset for a chatroom").req
   const { setTeam: setTeam2 } = await Promise.resolve().then(() => (init_team(), exports_team));
   await setTeam2(options.chatroomId, options.team);
 });
-handoffCommandGroup.command("view-template").description("Print a handoff message template; omit --next-role to inspect a generic architect or UI/UX engineer template").option("--team-id <teamId>", "Team id (solo, duo); defaults to duo").action(async function(options) {
+handoffCommandGroup.command("view-template").description("Print the handoff template for one sender → recipient pair in one conversation mode (requires --from, --to, and --mode)").option("--from <role>", "Sending role (the role that runs the handoff)").option("--to <role>", "Receiving role (the --next-role of the handoff)").option("--mode <mode>", "Conversation mode: chat | code | code:enhanced (required)").option("--team-id <teamId>", "Team id (solo, duo); defaults to duo").action(async function(options) {
   const parentOpts = this.parent?.opts() ?? {};
-  if (!parentOpts.role) {
-    console.error(`error: required option '--role <role>' not specified`);
-    process.exit(1);
-  }
   const { printHandoffViewTemplate: printHandoffViewTemplate2 } = await Promise.resolve().then(() => (init_view_template3(), exports_view_template));
-  try {
-    printHandoffViewTemplate2({
-      role: parentOpts.role,
-      nextRole: parentOpts.nextRole,
-      teamId: options.teamId
-    });
-  } catch (err) {
-    console.error(`❌ ${err.message}`);
-    process.exit(1);
-  }
+  printHandoffViewTemplate2({
+    from: options.from,
+    to: options.to,
+    mode: options.mode,
+    teamId: options.teamId,
+    legacyRole: parentOpts.role,
+    legacyNextRole: parentOpts.nextRole
+  });
 });
-handoffCommandGroup.command("list-templates").description("List the role-owned handoff contract and renderable templates (static, no chatroom required)").option("--team-id <teamId>", "Team id (solo, duo); defaults to duo").action(async function(options) {
+handoffCommandGroup.command("list-templates").description("Show the pair descriptor and handoff template for one sender → recipient pair in one conversation mode (requires --from, --to, and --mode; static, no chatroom required)").option("--from <role>", "Sending role (the role that runs the handoff)").option("--to <role>", "Receiving role (the --next-role of the handoff)").option("--mode <mode>", "Conversation mode: chat | code | code:enhanced (required)").option("--team-id <teamId>", "Team id (solo, duo); defaults to duo").action(async function(options) {
   const parentOpts = this.parent?.opts() ?? {};
-  if (!parentOpts.role) {
-    console.error(`error: required option '--role <role>' not specified`);
-    process.exit(1);
-  }
   const { printHandoffListTemplates: printHandoffListTemplates2 } = await Promise.resolve().then(() => (init_list_templates2(), exports_list_templates));
-  try {
-    printHandoffListTemplates2({ role: parentOpts.role, teamId: options.teamId });
-  } catch (err) {
-    console.error(`❌ ${err.message}`);
-    process.exit(1);
-  }
+  printHandoffListTemplates2({
+    from: options.from,
+    to: options.to,
+    mode: options.mode,
+    teamId: options.teamId,
+    legacyRole: parentOpts.role,
+    legacyNextRole: parentOpts.nextRole
+  });
 });
 handoffCommandGroup.option("--chatroom-id <id>", "Chatroom identifier").option("--role <role>", "Your role").option("--next-role <nextRole>", "Role to hand off to").action(async (options) => {
   const missing = [
@@ -138776,4 +139302,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=BF04636703AF51D164756E2164756E21
+//# debugId=BCEF986EF291738664756E2164756E21