chatroom-cli 1.99.0 → 1.99.1

package/dist/index.js

@@ -78980,19 +78980,19 @@ function getDelegationBriefIntro() {
 var HANDOFF_NOT_APPLICABLE_EXACT_TEXT = "Not Applicable.";
 
 // ../../services/backend/prompts/utils/handoff-quality-principles.ts
-function getHandoffQualityPrinciplesTemplateBlock() {
+function getHandoffQualityPrinciplesTemplateBlock(subject = "work") {
   const lines = HANDOFF_QUALITY_PRINCIPLES.flatMap((p) => [
-    `- **${p.name}:** <how this work demonstrates ${p.name.toLowerCase()}, or exactly "${HANDOFF_NOT_APPLICABLE_EXACT_TEXT}">`,
+    `- **${p.name}:** <how this ${subject} demonstrates ${p.name.toLowerCase()}, or exactly "${HANDOFF_NOT_APPLICABLE_EXACT_TEXT}">`,
     `<!-- ${p.name}: ${p.description} -->`,
     ""
   ]);
   return lines.join(`
 `).trimEnd();
 }
-function getHandoffQualityPrinciplesSectionBlock() {
+function getHandoffQualityPrinciplesSectionBlock(subject = "work") {
   return `${PROOF_OF_PRINCIPLES_HEADING_H2}
 ${PROOF_OF_PRINCIPLES_MANDATORY_COMMENT}
-${getHandoffQualityPrinciplesTemplateBlock()}`;
+${getHandoffQualityPrinciplesTemplateBlock(subject)}`;
 }
 var HANDOFF_QUALITY_PRINCIPLES, PROOF_OF_PRINCIPLES_HEADING_H2 = "## Proof of Principles", PROOF_OF_PRINCIPLES_MANDATORY_COMMENT;
 var init_handoff_quality_principles = __esm(() => {
@@ -79087,163 +79087,195 @@ var init_builder_to_planner = __esm(() => {
   init_role_guidance_disclosure();
 });
 
-// ../../services/backend/prompts/enhancer/defragmentation-reference.ts
-function renderDefragmentationHandoffReference() {
-  return [
-    "### Defragmentation workflow checklist",
-    'Complete the optional **Defragmentation** section when the planner check-in addresses a large or multi-surface system revision, including refactoring, consolidation, or consistency work. Write exactly "Not Applicable." only when no such revision is proposed.',
-    "",
-    "1. **Study surfaces** — map all call sites, use cases, and complexity variants before proposing slices; name every relevant file/module",
-    "2. **Golden implementation** — build a standalone canonical solution first; introduce canonical domain entities/types only when the studied variants require them, then shared use cases, UI components, or utilities; do not patch duplicates in place",
-    "3. **Migrate callers** — refactor all consumers to the golden path; each slice must be shippable end-to-end",
-    "4. **Delete legacy** — remove old implementations only after migration is complete; no dead-code leftovers",
-    "",
-    "### Anti-patterns to flag",
-    "- Incremental copy-paste fixes across N files without a golden SSOT",
-    "- New abstraction without studying all existing variants",
-    '- Leaving old code "for safety" after migration',
-    "- Slices that add helpers/infra without a runnable end-to-end outcome",
-    "- Parallel implementations coexisting without a deletion plan",
-    "",
-    "### Structural decisions",
-    "- Identify SSOT locations for domain entities, shared use cases, and UI components",
-    "- Align with `structural-decisions` glossary: folder structure, file naming, interface locations",
-    "- Flag when the plan scatters the canonical implementation across unrelated modules"
-  ].join(`
-`);
-}
+// ../../services/backend/src/domain/usecase/enhancer/enhancer-handoff-content.ts
+var ENHANCER_USER_MESSAGE_PLACEHOLDER = "{{USER_MESSAGE}}";
 
-// ../../services/backend/prompts/enhancer/webapp-ux-reference.ts
-function renderWebappUxHandoffReference() {
-  return [
-    "### UX review checklist",
-    'Complete the optional **UX** section in your output when the planner proposes UI changes. Write exactly "Not Applicable." for non-UI tasks. Put code snippets in **Suggested edits** only.',
-    "",
-    "1. **Flows** — is the primary path straightforward? simpler alternatives exist?",
-    "2. **Patterns** — consistent with existing project components and conventions? recommend one when multiple exist.",
-    "3. **Layout** — unnecessary complexity or wrappers? layout stable across loading/empty/error transitions (no layout shift when async content arrives or state changes)?",
-    "4. **Shortcuts** — aligned with the project keyboard/shortcut conventions? gaps or conflicts?",
-    "5. **States** — loading, error, and empty states explicitly handled for async surfaces (no blank panels, silent failures, or missing retry affordances)?",
-    "6. **Error boundaries** — failures scoped so one subtree does not crash the whole app?",
-    "7. **Feedback** — timely response for async user actions?",
-    "8. **Interaction affordance** — clickable/interactive elements use pointer cursor (or the project's established equivalent) where applicable?",
-    "9. **Destructive actions** — irreversible or high-impact single actions gated by confirmation?",
-    "10. **Bulk actions** — batch/multi-item operations confirmed with scope or impact summary?",
-    "",
-    "### Review principles",
-    "- Ground feedback in the planner check-in and the project codebase — cite existing patterns rather than inventing generic UI preferences.",
-    "- Flag missing states, layout-shift risk, and missing interaction affordances when the plan omits them; recommend consistency with established project conventions.",
-    "- Do **not** prescribe style choices the project has not adopted (e.g. specific flex layouts, canonical card chrome, responsive utility patterns, button label copy).",
-    "- When multiple valid patterns exist in the codebase, recommend one and explain the tradeoff."
-  ].join(`
-`);
+// ../../services/backend/prompts/utils/frontend-design-ux-checklist.ts
+function getFrontendDesignUxPlanningPrinciplesBlock() {
+  return `<!-- Ground every flow in user history and repository patterns. Recommend one existing pattern when multiple exist; do not prescribe style choices the project has not adopted. -->`;
+}
+function getFrontendDesignUxFlowChecklistBlock() {
+  return `**UX quality (complete for every interactive step in this flow):**
+- **States:** loading | empty | error | success — no blank panels, silent failures, or missing retry affordances
+- **Layout:** stable across async transitions — no layout shift when content arrives or state changes
+- **Patterns:** consistent with existing project components — cite the chosen pattern and repo-relative file
+- **Shortcuts:** aligned with project keyboard/shortcut conventions; document tab order and gaps
+- **Feedback:** timely response for async user actions
+- **Interaction affordance:** pointer cursor (or project equivalent) on clickable elements
+- **Safeguards:** confirmation before destructive actions; bulk operations confirmed with scope summary`;
 }
 
 // ../../services/backend/prompts/utils/enhancer-feedback-template-body.ts
 function getEnhancerFeedbackTemplateBody() {
   return `<handoff-overview>
 ## Summary
-<overall assessment — cite specific strengths, risks, and whether the approach is sound; reference concrete elements from the check-in>
+<one paragraph: what we're building and the single design direction>
 
-## User intent alignment
-<specific misreadings or missing constraints — what the user asked vs what the planner proposed>
+## User intent and constraints
+<explicit requirements from user messages; hard constraints that must not be violated>
 </handoff-overview>
 
-<!-- UI collapses proofs, direction, ux, defragmentation, and notes by default; overview and action required are expanded -->
+<!-- UI collapses proofs, direction, frontend design, data design, and notes by default; overview and action required are expanded -->
 
 <handoff-proofs>
-## Reasoning review
-<specific logical errors, weak inference, or contradictions — cite the claim and why it fails>
+## Repository evidence
+<files read, current behavior verified, patterns reused — cite repo-relative paths and short snippets only>
+
+${getHandoffQualityPrinciplesSectionBlock("design")}
 </handoff-proofs>
 
 <handoff-direction>
-## Alignment with eventual user handoff
-<specific gaps for user-facing completeness — what proof or report sections would be missing>
+## Recommended design
+<!-- ONE design only. No Option A/B/C. -->
+
+<2–4 sentences: the chosen architecture and why it fits the request and existing system>
 </handoff-direction>
 
-<handoff-ux>
-<!-- Optional — write exactly "Not Applicable." when no UI changes are proposed -->
-<!-- When UI is proposed: specific findings tied to the planner's proposal. No code blocks (use Suggested edits). -->
-- **Flows:** <click count, nested modals, simpler alternatives>
-- **Patterns:** <consistency with existing project components; recommend one when multiple>
-- **Layout:** <complexity, wrappers, layout stable across state transitions — no layout shift>
-- **Shortcuts:** <alignment with catalog; gaps or conflicts>
-- **States:** <loading/error/empty explicitly handled; no blank panels or silent failures>
-- **Error boundaries:** <error boundary placement; failure isolated from the whole app>
-- **Feedback:** <timely response for async actions>
-- **Interaction affordance:** <pointer cursor or project equivalent on clickable elements where applicable>
-- **Destructive safeguards:** <confirmation before irreversible/high-impact actions>
-- **Bulk safeguards:** <confirmation with scope summary for batch operations>
-</handoff-ux>
-
-<handoff-defragmentation>
-<!-- Optional — write exactly "Not Applicable." when no large or multi-surface system revision is proposed -->
-<!-- When revision work is proposed: specific findings tied to the planner's proposal. No code blocks (use Suggested edits). -->
-- **Surfaces:** <call sites and modules identified; gaps in surface mapping>
-- **Golden path:** <whether planner builds standalone canonical implementation first>
-- **Domain model:** <canonical types/entities needed or "not needed">
-- **Shared components:** <shared abstractions planned (use cases, UI, utilities)>
-- **Slice ordering:** <study → golden → migrate → delete sequence respected?>
-- **Migration plan:** <how all callers move to golden path>
-- **Deletion plan:** <old implementations slated for removal>
-- **Duplication:** <existing duplicates to eliminate; risk of new duplication>
-- **Structural decisions:** <folder/module boundaries; SSOT locations>
-</handoff-defragmentation>
+<handoff-frontend-design>
+## Frontend / user-centric design
 
-<handoff-notes>
-## Knowledge gaps
-<specific facts, files, or research to verify — name what to check and why>
-</handoff-notes>
+${getFrontendDesignUxPlanningPrinciplesBlock()}
 
-<handoff-action>
-## Risks & failure modes
-<specific risks tied to this plan — what fails, under what conditions, and how to mitigate>
+### Flow 1: <name>
+**Entry:** User visits \`<route/page>\` from \`<source>\`.
 
-## Recommendations
-<!-- SECOND-LAST — concrete, actionable suggestions tied to the check-in. Include tradeoffs and considerations. No code blocks here (use Suggested edits for snippets). -->
+| Step | User action | System response | UI state |
+|------|-------------|-----------------|----------|
+| 1 | User clicks \`<element label>\` | \`<navigation / modal / fetch>\` | \`<loading → success/error>\` |
 
-## Suggested edits (remove or change only)
-<!-- LAST — proposed edits to grounding and builder-handoff. File paths and code snippets required when recommending changes. Omit entirely if none. -->
-When you recommend removing or changing specific content in the planner's check-in, list each change here with file-level detail and code examples.
-${getFileReferenceGuidanceComment()}
+${getFrontendDesignUxFlowChecklistBlock()}
+
+**Expected interactions per element:**
+- \`<ElementName>\` (\`apps/webapp/src/...\`): click → \`<handler>\`; keyboard: \`<tab order>\`; disabled when \`<condition>\`
+
+### Element, style, and layout specification
 
-### <section or claim to remove or change>
-**File:** \`apps/webapp/src/path/to/file.ts\`
-**Change:** <what to remove, replace, or correct and why>
+#### \`<ComponentName>\` — \`apps/webapp/src/path/to/Component.tsx\`
+**Change:** <create | modify>
+
+**Layout:** \`<div className="...">\` — flex/grid, gaps, breakpoints
+
+**States:** loading | empty | error | success
+
+\`\`\`tsx
+export function ComponentName({ ... }: Props) {
+  // target structure — props, classNames, branches
+}
+\`\`\`
+
+<!-- Repeat per component; write exactly "Not Applicable." for the entire section if no UI -->
+</handoff-frontend-design>
+
+<handoff-data-design>
+## Persistent state and query pattern design
+
+**Goal:** Small updates must not cause large cache invalidations. High-frequency writes use projections to smaller tables.
+
+### 1. Sources of concern
+| Source | Write frequency | Read pattern | Risk |
+|--------|---------------|--------------|------|
+| \`<table/mutation>\` | \`<frequency>\` | \`<pattern>\` | \`<scan / hot partition>\` |
+
+### 2. Schema design
+**Hot path:** \`<table>\` — fields, projection from \`<source>\`
+**Cold path:** \`<table>\` — …
+
+\`\`\`typescript
+// target schema shape
+\`\`\`
+
+### 3. Index design (within limits)
+| Table | Index | Serves query | Budget |
+|-------|-------|--------------|--------|
+
+### 4. Query design (within limits)
+| Query | Index | Rows scanned | Timeout | Invalidation scope |
+|-------|-------|--------------|---------|-------------------|
 
 \`\`\`typescript
-// Code snippet: what should change, be removed, or what the planner got wrong
+// target query signature
 \`\`\`
 
-(Add one ### block per distinct removal or change. Use repo-relative paths with file extensions.)
+<!-- Write exactly "Not Applicable." for the entire section if no persistence changes -->
+</handoff-data-design>
+
+<handoff-notes>
+## Open questions for user
+<decisions only the user can make, or write "Not Applicable.">
+</handoff-notes>
+
+<handoff-action>
+## Recommended implementation sequence
+<!-- Ordered slices for the planner — references files from design sections. For large or multi-surface revisions, activate the defragmentation skill before delegating. -->
+
+1. …
+2. …
+
+## Files touched (index)
+- \`apps/webapp/src/...\` — …
+- \`services/backend/convex/...\` — …
 </handoff-action>`;
 }
-var init_enhancer_feedback_template_body = () => {};
+var init_enhancer_feedback_template_body = __esm(() => {
+  init_handoff_quality_principles();
+});
 
-// ../../services/backend/prompts/teams/duo/handoff-templates/enhancer-to-planner.ts
-function getEnhancerToPlannerHandoffTemplate() {
-  return `${getHandoffRecipientVisibilityCallout("planner")}
+// ../../services/backend/prompts/enhancer/handoff-templates.ts
+function roleLabel(role) {
+  return role.charAt(0).toUpperCase() + role.slice(1).toLowerCase();
+}
+function getEntryPointToEnhancerHandoffTemplate(entryPointRole) {
+  const label = roleLabel(entryPointRole);
+  return `**Planning Request (${label} → Enhancer)** — after reading the user message and any pinned chatroom context, fill only <additional-context> below. The system injects the user message automatically — do not copy it.
 
-${getHandoffReportTemplateIntro("Planning Feedback (Enhancer → Planner)")}
+\`\`\`markdown
+<user-message>
+<!-- Injected automatically from the originating user message — do not edit or copy the user message here -->
+${ENHANCER_USER_MESSAGE_PLACEHOLDER}
+</user-message>
 
-The planner sent you three XML sections. Your job is **advisory adversarial review** — raise risks, challenge assumptions, align with user intent. Be **specific and targeted**: cite concrete claims, files, UX choices, and gaps from the check-in so the planner can improve the plan without re-synthesizing vague feedback.
+<additional-context>
+## Goal
+<what the user wants in plain language — one short paragraph>
+</additional-context>
+\`\`\`
 
-Give **concrete, actionable recommendations** in every section. End with **Recommendations** (second-last: summarized suggestions, tradeoffs, and considerations) then **Suggested edits** (last: proposed edits to grounding and the builder-handoff with file paths and code snippets). For UI work, complete the optional **UX** section using the reference below. For large or multi-surface revision work, complete the optional **Defragmentation** section using its reference below. **Do not rewrite their full builder brief.** The planner makes the final call.
+After handoff succeeds, **end your turn immediately**. The enhancer independently downloads the originating message history and returns design input as your next ${entryPointRole.toLowerCase()} task.`;
+}
+function getEnhancerToEntryPointHandoffTemplate(entryPointRole) {
+  const normalizedRole = entryPointRole.toLowerCase();
+  const label = roleLabel(entryPointRole);
+  return `**Design Input (Enhancer → ${label})**
 
-${renderWebappUxHandoffReference()}
+You are the design authority for this request. Recover conversation history, inspect the repository, and return **one** complete design — not options. The ${normalizedRole} agent verifies your design and delegates implementation.
 
-${renderDefragmentationHandoffReference()}
+**Rules:**
+- Design first — complete frontend and data/query sections before implementation sequencing.
+- **No alternative approaches** — one \`Recommended design\` only.
+- Frontend and data sections: code granularity (component names, props, classes, file paths, schema, indexes, queries).
+- Complete per-flow **UX quality** checklist in frontend design — states, layout stability, patterns, safeguards.
+- For large or multi-surface revisions, note in implementation sequence that the entry point should activate the \`defragmentation\` skill.
+- In \`<handoff-proofs>\`, complete **Proof of Principles** for how this design satisfies each quality principle (or "Not Applicable.").
+- Write "Not Applicable." only when a major design section truly does not apply.
 
 \`\`\`markdown
 ${getEnhancerFeedbackTemplateBody()}
 \`\`\`
 
-Return only the feedback markdown — no preamble. Follow this structure; omit sections that truly do not apply.`;
+Return only the design input markdown — no preamble. Follow this structure; use "Not Applicable." where a major section does not apply.`;
 }
-var init_enhancer_to_planner = __esm(() => {
+var init_handoff_templates = __esm(() => {
   init_enhancer_feedback_template_body();
 });
 
+// ../../services/backend/prompts/teams/duo/handoff-templates/enhancer-to-planner.ts
+function getEnhancerToPlannerHandoffTemplate() {
+  return getEnhancerToEntryPointHandoffTemplate("planner");
+}
+var init_enhancer_to_planner = __esm(() => {
+  init_handoff_templates();
+});
+
 // ../../services/backend/prompts/teams/duo/handoff-templates/planner-to-builder.ts
 function getPlannerToBuilderHandoffTemplate() {
   return `${getHandoffRecipientVisibilityCallout("builder")}
@@ -79322,40 +79354,11 @@ var init_planner_to_builder = () => {};
 
 // ../../services/backend/prompts/teams/duo/handoff-templates/planner-to-enhancer.ts
 function getPlannerToEnhancerHandoffTemplate() {
-  return `${getHandoffRecipientVisibilityCallout("enhancer")}
-
-**Mandatory Planning Check-in (Planner → Enhancer)** — paste into the handoff message. **Do not skip this check-in** when the enhancer is enabled.
-
-The enhancer starts from this check-in — it may read files in the repo to verify your grounding. Use the three XML sections below **exactly** — they delimit what the enhancer will review.
-
-\`\`\`markdown
-<user-message>
-<verbatim or faithful quote of the user's request — include constraints, priorities, and classification context if relevant>
-</user-message>
-
-<grounding>
-<fully detailed research — include file paths and snippets the enhancer should verify; it may read the codebase to validate your proposal>
-
-Include:
-- **Existing code examples** — relevant snippets, patterns, and conventions already in the codebase
-- **File references** — paths to every file you investigated or plan to change
-- **Technology choices** — libraries, frameworks, APIs, and why they apply here
-- **Observations** — what you learned, edge cases, risks, and open questions from investigation
-${getFileReferenceGuidanceComment()}
-</grounding>
-
-<builder-handoff>
-<your complete, filled-in Delegation Brief for builder review — every section with real content, not placeholders>
-
-Follow the **Handoff to \`builder\`** template structure (Summary, Goal, approach, Requirements, etc.). The enhancer reviews **approach and scope** — not line-by-line file edits. Keep file references for context, but expect advisory feedback on risks and gaps, not a rewritten brief.
-</builder-handoff>
-\`\`\`
-
-After handoff succeeds, **end your turn immediately** — do not monitor the enhancer or wait in this session. When review completes, enhancer → planner handoff delivers feedback as your next planner task.
-
-After you receive that feedback, you make the **final call** — incorporate valid critiques, ignore what doesn't apply, then proceed to \`builder\` or \`user\`. Do not re-check with the enhancer for this slice; one round only.`;
+  return getEntryPointToEnhancerHandoffTemplate("planner");
 }
-var init_planner_to_enhancer = () => {};
+var init_planner_to_enhancer = __esm(() => {
+  init_handoff_templates();
+});
 
 // ../../services/backend/prompts/utils/context-disclosure.ts
 function getContextReadDisclosureComment(params = {}) {
@@ -79533,7 +79536,7 @@ function getDuoHandoffTemplate(query) {
   return getter?.(query) ?? null;
 }
 var DUO_HANDOFF_TEMPLATES;
-var init_handoff_templates = __esm(() => {
+var init_handoff_templates2 = __esm(() => {
   init_builder_to_planner();
   init_enhancer_to_planner();
   init_planner_to_builder();
@@ -79576,9 +79579,12 @@ function getSoloHandoffTemplate(query) {
   return getter?.(query) ?? null;
 }
 var SOLO_HANDOFF_TEMPLATES;
-var init_handoff_templates2 = __esm(() => {
+var init_handoff_templates3 = __esm(() => {
   init_solo_to_user();
+  init_handoff_templates();
   SOLO_HANDOFF_TEMPLATES = {
+    "solo:enhancer": () => getEntryPointToEnhancerHandoffTemplate("solo"),
+    "enhancer:solo": () => getEnhancerToEntryPointHandoffTemplate("solo"),
     "solo:user": (query) => getSoloToUserReportTemplate({
       chatroomId: query.chatroomId,
       role: query.role,
@@ -79596,9 +79602,9 @@ function getHandoffTemplate(query) {
     return getSoloHandoffTemplate(query);
   return null;
 }
-var init_handoff_templates3 = __esm(() => {
-  init_handoff_templates();
+var init_handoff_templates4 = __esm(() => {
   init_handoff_templates2();
+  init_handoff_templates3();
 });
 
 // ../../services/backend/prompts/cli/handoff/view-template.ts
@@ -79615,7 +79621,7 @@ function viewHandoffTemplate(params) {
   return template;
 }
 var init_view_template2 = __esm(() => {
-  init_handoff_templates3();
+  init_handoff_templates4();
 });
 
 // src/commands/handoff/view-template.ts
@@ -79780,9 +79786,12 @@ function formatDecodeError(error) {
 
 // ../../services/backend/prompts/native/session-continuity.ts
 function getNativeHandoffTurnEndGuidance(nextRole) {
+  return getHandoffTurnEndGuidance(nextRole);
+}
+function getHandoffTurnEndGuidance(nextRole) {
   const lines = [
     "",
-    "**Handoff must be your last action this turn.** After running handoff, **End your turn now** — stop tool calls. Your session stays active."
+    "**Handoff complete. End your turn now — stop tool calls. The system will send you a message when further action is required.**"
   ];
   if (nextRole.toLowerCase() === "user") {
     lines.push("The system delivers the next chatroom task when the user sends one.");
@@ -79792,11 +79801,11 @@ function getNativeHandoffTurnEndGuidance(nextRole) {
   return lines.join(`
 `);
 }
-function getNativeEnhancerCheckInTurnEndGuidance() {
+function getNativeEnhancerRequestTurnEndGuidance() {
   return [
     "",
-    "**Handoff must be your last action this turn.** After running handoff, **End your turn now** — stop tool calls. Your session stays active.",
-    "Do **not** wait for enhancer feedback, poll, or monitor the enhancer job in this turn. The system delivers enhancer feedback as your next planner task when review completes."
+    "**Handoff complete. End your turn now — stop tool calls. The system will send you a message when further action is required.**",
+    "Do **not** wait for enhancer input, poll, or monitor the enhancer job in this turn. The system delivers independent planning input as your next task when analysis completes."
   ].join(`
 `);
 }
@@ -79826,10 +79835,14 @@ var init_backlog = __esm(() => {
 // ../../services/backend/src/domain/usecase/skills/modules/code-review/index.ts
 var init_code_review = () => {};
 
+// ../../services/backend/src/domain/usecase/skills/modules/defragmentation/index.ts
+var init_defragmentation = () => {};
+
 // ../../services/backend/src/domain/usecase/skills/registry.ts
 var init_registry4 = __esm(() => {
   init_backlog();
   init_code_review();
+  init_defragmentation();
 });
 
 // ../../services/backend/prompts/sections/glossary.ts
@@ -79866,7 +79879,8 @@ var init_glossary = __esm(() => {
     },
     {
       term: "structural-decisions",
-      definition: "Meta-level architectural choices that persist in the codebase and influence consistency: " + "folder structure, file naming, interface definitions, and key abstraction names/locations " + "(e.g., Repository/Service layers)."
+      definition: "Meta-level architectural choices that persist in the codebase and influence consistency: " + "folder structure, file naming, interface definitions, and key abstraction names/locations " + "(e.g., Repository/Service layers).",
+      linkedSkillId: "defragmentation"
     }
   ];
   NATIVE_GLOSSARY_TERMS = [
@@ -80225,15 +80239,15 @@ var init_types = __esm(() => {
 // ../../services/backend/prompts/review-guidelines/index.ts
 var init_review_guidelines = () => {};
 // ../../services/backend/prompts/generator.ts
-function isEnhancerCheckInQueuedHandoff(params) {
-  return params.enhancerCheckInQueued === true && params.role.toLowerCase() === "planner" && params.nextRole.toLowerCase() === "enhancer";
+function isEnhancerRequestQueuedHandoff(params) {
+  return params.enhancerRequestQueued === true && params.nextRole.toLowerCase() === "enhancer";
 }
-function getEnhancerCheckInQueuedConfirmationLines(nativeIntegration) {
-  const turnEndRule = nativeIntegration ? "**End your turn now** — do not wait for feedback, poll, monitor the enhancer, or re-submit the handoff. The system delivers enhancer feedback as your next planner task when review completes." : "**Run get-next-task now and end your turn** — do not wait for feedback, poll, monitor the enhancer, or re-submit the handoff.";
+function getEnhancerRequestQueuedConfirmationLines(nativeIntegration) {
+  const turnEndRule = nativeIntegration ? "**Handoff complete. End your turn now — stop tool calls. The system will send you a message when further action is required.** Do **not** wait for enhancer input, poll, monitor the enhancer, or re-submit the handoff. The system delivers independent planning input as your next task when analysis completes." : "**Run get-next-task now and end your turn — stop tool calls. The system will send you a message when further action is required.** Do **not** wait for enhancer input, poll, monitor the enhancer, or re-submit the handoff.";
   return [
-    "✅ Planning check-in queued for handoff enhancer",
+    "✅ User request queued for handoff enhancer",
     "",
-    "Your check-in was sent to the handoff enhancer (async). You will receive planning feedback back as a planner task when review completes.",
+    "The user request was sent to the handoff enhancer (async). You will receive independent planning input as your next task when analysis completes.",
     turnEndRule
   ];
 }
@@ -80244,24 +80258,28 @@ function generateHandoffOutput(params) {
     chatroomId,
     convexUrl,
     supportsNativeIntegration,
-    enhancerCheckInQueued
+    enhancerRequestQueued
   } = params;
   const cliEnvPrefix = getCliEnvPrefix(convexUrl);
-  const enhancerCheckIn = isEnhancerCheckInQueuedHandoff({ role, nextRole, enhancerCheckInQueued });
+  const enhancerRequest = isEnhancerRequestQueuedHandoff({
+    nextRole,
+    enhancerRequestQueued
+  });
   const lines = [];
-  if (enhancerCheckIn) {
-    lines.push(...getEnhancerCheckInQueuedConfirmationLines(supportsNativeIntegration));
+  if (enhancerRequest) {
+    lines.push(...getEnhancerRequestQueuedConfirmationLines(supportsNativeIntegration));
   } else {
     lines.push(`✅ Chatroom task completed and handed off to ${nextRole}`);
   }
   if (supportsNativeIntegration) {
-    lines.push(enhancerCheckIn ? getNativeEnhancerCheckInTurnEndGuidance() : getNativeHandoffTurnEndGuidance(nextRole));
+    lines.push(enhancerRequest ? getNativeEnhancerRequestTurnEndGuidance() : getNativeHandoffTurnEndGuidance(nextRole));
   } else {
     lines.push("");
     lines.push("✅ Level B complete (chatroom task handed off).");
     lines.push("⏳ Level A continues (session is still active) — run get-next-task to stay connected:");
     lines.push("");
     lines.push(`\`${getNextTaskCommand({ chatroomId, role, cliEnvPrefix })}\``);
+    lines.push(getHandoffTurnEndGuidance(nextRole));
   }
   return lines.join(`
 `);
@@ -80419,7 +80437,7 @@ var handoffEffect = (chatroomId, options) => exports_Effect.gen(function* () {
       chatroomId,
       convexUrl,
       supportsNativeIntegration: result.supportsNativeIntegration,
-      enhancerCheckInQueued: result.enhancerJobId != null
+      enhancerRequestQueued: result.enhancerJobId != null
     }));
   });
 });
@@ -134297,4 +134315,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=D5DF842800E395EE64756E2164756E21
+//# debugId=6F8892900A69B55764756E2164756E21