chatroom-cli 1.98.7 → 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
+
+#### \`<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.
 
-### <section or claim to remove or change>
-**File:** \`apps/webapp/src/path/to/file.ts\`
-**Change:** <what to remove, replace, or correct and why>
+### 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
     }));
   });
 });
@@ -83515,6 +83533,321 @@ function harnessCapabilitiesFingerprint(harnesses, versions) {
   return `${h}::${v3}`;
 }
 
+// src/daemon/infrastructure/outbox/lib/durable-fifo-queue-schema.ts
+var DURABLE_FIFO_QUEUE_MIGRATIONS;
+var init_durable_fifo_queue_schema = __esm(() => {
+  DURABLE_FIFO_QUEUE_MIGRATIONS = [
+    `CREATE TABLE IF NOT EXISTS schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,
+    `CREATE TABLE IF NOT EXISTS fifo_outbox_entries (id INTEGER PRIMARY KEY AUTOINCREMENT, delivery_key TEXT NOT NULL, payload_json TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'pending', attempts INTEGER NOT NULL DEFAULT 0, last_error TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL)`,
+    `CREATE INDEX IF NOT EXISTS idx_fifo_outbox_pending ON fifo_outbox_entries(delivery_key, status, id)`
+  ];
+});
+
+// src/daemon/infrastructure/outbox/lib/durable-fifo-queue-store.ts
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync as mkdirSync4 } from "node:fs";
+import { dirname as dirname9 } from "node:path";
+function openDurableFifoQueueStore(dbPath) {
+  mkdirSync4(dirname9(dbPath), { recursive: true });
+  const db = new DatabaseSync(dbPath);
+  for (const sql of DURABLE_FIFO_QUEUE_MIGRATIONS)
+    db.exec(sql);
+  db.prepare("UPDATE fifo_outbox_entries SET status='pending', updated_at=? WHERE status='in_flight'").run(Date.now());
+  return {
+    enqueue: (key, payloadJson) => {
+      const now = Date.now();
+      return Number(db.prepare("INSERT INTO fifo_outbox_entries(delivery_key,payload_json,created_at,updated_at) VALUES(?,?,?,?) RETURNING id").get(key, payloadJson, now, now).id);
+    },
+    claimNextBatch: (key, limit) => db.prepare("UPDATE fifo_outbox_entries SET status='in_flight', attempts=attempts+1, updated_at=? WHERE id IN (SELECT id FROM fifo_outbox_entries WHERE delivery_key=? AND status='pending' ORDER BY id LIMIT ?) RETURNING id, delivery_key as deliveryKey, payload_json as payloadJson, attempts").all(Date.now(), key, limit),
+    markDone: (id3) => {
+      db.prepare("DELETE FROM fifo_outbox_entries WHERE id=?").run(id3);
+    },
+    markPending: (id3) => {
+      db.prepare("UPDATE fifo_outbox_entries SET status='pending', last_error=NULL, updated_at=? WHERE id=?").run(Date.now(), id3);
+    },
+    updatePayload: (id3, payloadJson) => {
+      db.prepare("UPDATE fifo_outbox_entries SET payload_json=?, updated_at=? WHERE id=?").run(payloadJson, Date.now(), id3);
+    },
+    markPendingRetry: (id3, error) => {
+      db.prepare("UPDATE fifo_outbox_entries SET status='pending', last_error=?, updated_at=? WHERE id=?").run(String(error), Date.now(), id3);
+    },
+    listPendingForRecovery: (key) => db.prepare("SELECT id, delivery_key as deliveryKey, payload_json as payloadJson, attempts FROM fifo_outbox_entries WHERE delivery_key=? AND status IN ('pending','in_flight') ORDER BY id").all(key),
+    close: () => db.close()
+  };
+}
+var init_durable_fifo_queue_store = __esm(() => {
+  init_durable_fifo_queue_schema();
+});
+
+// src/daemon/infrastructure/outbox/lib/outbox-retry-backoff.ts
+function computeExponentialRetryDelayMs(attempt, retryDelayMs, maxRetryDelayMs) {
+  const exponent = Math.min(Math.max(0, attempt), MAX_RETRY_EXPONENT);
+  return Math.min(retryDelayMs * 2 ** exponent, maxRetryDelayMs);
+}
+var MAX_RETRY_EXPONENT = 20;
+
+// src/daemon/infrastructure/outbox/lib/fifo-batched-outbox.ts
+function createFifoBatchedOutbox(o) {
+  const waiters = new Map;
+  let running3;
+  let stopped = false;
+  let retryTimer;
+  let retryAttempt = 0;
+  const retryDelay = () => computeExponentialRetryDelayMs(retryAttempt++, o.retryDelayMs ?? 500, o.maxRetryDelayMs ?? 5000);
+  const scheduleRetry = () => {
+    if (!stopped && !retryTimer) {
+      retryTimer = setTimeout(() => {
+        retryTimer = undefined;
+        drain().catch(() => {
+          return;
+        });
+      }, retryDelay());
+      retryTimer.unref?.();
+    }
+  };
+  const drain = async () => {
+    if (running3)
+      return running3;
+    running3 = (async () => {
+      while (true) {
+        const rows = o.store.claimNextBatch(o.deliveryKey, o.batchSize);
+        if (!rows.length)
+          break;
+        try {
+          const results = await o.send(rows.map((r) => o.deserialize(r.payloadJson)));
+          let hasRetry = false;
+          for (let i2 = 0;i2 < results.length; i2++) {
+            const item = o.deserialize(rows[i2].payloadJson);
+            const outcome = o.classifyOutcome?.(results[i2], item) ?? { kind: "success" };
+            if (outcome.kind === "retry") {
+              o.store.updatePayload(rows[i2].id, o.serialize(outcome.item));
+              o.store.markPending(rows[i2].id);
+              hasRetry = true;
+              continue;
+            }
+            o.store.markDone(rows[i2].id);
+            waiters.get(rows[i2].id)?.resolve(results[i2]);
+            waiters.delete(rows[i2].id);
+          }
+          for (let i2 = results.length;i2 < rows.length; i2++)
+            o.store.markPending(rows[i2].id);
+          if (hasRetry) {
+            scheduleRetry();
+            break;
+          }
+          retryAttempt = 0;
+        } catch (e) {
+          o.onError?.(e);
+          for (const r of rows)
+            o.store.markPendingRetry(r.id, e);
+          scheduleRetry();
+          break;
+        }
+      }
+    })().finally(() => {
+      running3 = undefined;
+    });
+    return running3;
+  };
+  const enqueue = (item) => {
+    if (stopped)
+      return Promise.reject(new Error("Outbox is stopped"));
+    const id3 = o.store.enqueue(o.deliveryKey, o.serialize(item));
+    const p = new Promise((resolve4, reject) => waiters.set(id3, { resolve: resolve4, reject }));
+    drain().catch(() => {
+      return;
+    });
+    return p;
+  };
+  const flushNow = async () => {
+    while (o.store.listPendingForRecovery(o.deliveryKey).length) {
+      await drain();
+    }
+  };
+  const stop4 = async () => {
+    if (stopped)
+      return;
+    if (retryTimer)
+      clearTimeout(retryTimer);
+    retryTimer = undefined;
+    await flushNow();
+    stopped = true;
+  };
+  return { enqueue, flushNow, stop: stop4 };
+}
+var init_fifo_batched_outbox = () => {};
+
+// src/daemon/infrastructure/outbox/lib/keyed-fifo-batched-outbox-registry.ts
+function createKeyedFifoBatchedOutboxRegistry(o) {
+  const boxes = new Map;
+  const get13 = (key) => {
+    let b = boxes.get(key);
+    if (!b) {
+      b = createFifoBatchedOutbox({
+        batchSize: o.batchSize,
+        send: o.createSend(key),
+        store: o.store,
+        deliveryKey: key,
+        serialize: o.serialize,
+        deserialize: o.deserialize,
+        retryDelayMs: o.retryDelayMs,
+        maxRetryDelayMs: o.maxRetryDelayMs,
+        onError: (e) => o.onError?.(key, e),
+        classifyOutcome: o.classifyOutcome
+      });
+      boxes.set(key, b);
+    }
+    return b;
+  };
+  const stop4 = async (k) => {
+    const b = boxes.get(k);
+    if (b) {
+      await b.stop();
+      boxes.delete(k);
+    }
+  };
+  return {
+    enqueue: (k, i2) => get13(k).enqueue(i2),
+    flushNow: async (k) => {
+      if (k)
+        await get13(k).flushNow();
+      else
+        for (const b of boxes.values())
+          await b.flushNow();
+    },
+    stop: stop4,
+    stopAll: async () => {
+      for (const k of [...boxes.keys()])
+        await stop4(k);
+      o.store.close();
+    }
+  };
+}
+var init_keyed_fifo_batched_outbox_registry = __esm(() => {
+  init_fifo_batched_outbox();
+});
+
+// src/daemon/infrastructure/outbox/outbox-db-path.ts
+import { homedir as homedir5 } from "node:os";
+import { join as join17 } from "node:path";
+function resolveOutboxDbPath(machineId, kind) {
+  return join17(homedir5(), ".chatroom", "daemon", machineId, `outbox-${kind}.sqlite`);
+}
+var init_outbox_db_path = () => {};
+
+// src/daemon/domain/entities/agent-lifecycle-fact.ts
+function buildExitedLifecycleFact(auditArgs, emittedAt) {
+  const { sessionId: _sessionId, machineId: _machineId, ...fields } = auditArgs;
+  return {
+    kind: "exited",
+    ...fields,
+    revisionKey: buildAgentLifecycleRevisionKey("exited", {
+      chatroomId: auditArgs.chatroomId,
+      role: auditArgs.role,
+      pid: auditArgs.pid,
+      emittedAt
+    }),
+    emittedAt
+  };
+}
+function normalizeAgentLifecycleFact(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error("Invalid agent lifecycle fact");
+  }
+  const value = raw;
+  const { sessionId: _sessionId, machineId: _machineId, ...rest } = value;
+  const kind = rest.kind;
+  if (kind === "cleared_all_pids") {
+    return {
+      kind: "cleared_all_pids",
+      revisionKey: String(rest.revisionKey),
+      emittedAt: Number(rest.emittedAt)
+    };
+  }
+  if (kind === "spawned" || kind === "exited") {
+    return rest;
+  }
+  throw new Error(`Unknown agent lifecycle fact kind: ${String(kind)}`);
+}
+function agentLifecycleDeliveryKey(machineId, fact) {
+  if (fact.kind === "cleared_all_pids")
+    return `${machineId}:__machine__`;
+  return `${machineId}:${fact.chatroomId}:${fact.role.toLowerCase()}`;
+}
+function buildAgentLifecycleRevisionKey(prefix, parts2) {
+  return `${prefix}:${Object.entries(parts2).filter(([, v3]) => v3 !== undefined).map(([k, v3]) => `${k}=${v3}`).join(":")}`;
+}
+
+// src/daemon/infrastructure/outbox/agent-lifecycle-outbox.ts
+function createAgentLifecycleOutboxRegistry(machineId, createSend, options) {
+  const store = openDurableFifoQueueStore(resolveOutboxDbPath(machineId, "agent-lifecycle"));
+  return createKeyedFifoBatchedOutboxRegistry({
+    store,
+    batchSize: AGENT_LIFECYCLE_OUTBOX_BATCH_SIZE,
+    createSend: (key) => async (facts) => {
+      const results = [];
+      for (const fact of facts)
+        results.push(await createSend(key)(fact));
+      return results;
+    },
+    serialize: JSON.stringify,
+    deserialize: (serialized) => normalizeAgentLifecycleFact(JSON.parse(serialized)),
+    retryDelayMs: 500,
+    maxRetryDelayMs: 5 * 60000,
+    onError: options?.onError,
+    classifyOutcome: () => ({ kind: "success" })
+  });
+}
+function agentLifecycleKey(machineId, fact) {
+  return agentLifecycleDeliveryKey(machineId, fact);
+}
+var AGENT_LIFECYCLE_OUTBOX_BATCH_SIZE = 1;
+var init_agent_lifecycle_outbox = __esm(() => {
+  init_durable_fifo_queue_store();
+  init_keyed_fifo_batched_outbox_registry();
+  init_outbox_db_path();
+});
+
+// src/daemon/infrastructure/outbox/agent-lifecycle-send.ts
+function toConvexLifecycleFact(fact) {
+  const normalized = normalizeAgentLifecycleFact(fact);
+  if (normalized.kind === "cleared_all_pids")
+    return normalized;
+  return {
+    ...normalized,
+    chatroomId: normalized.chatroomId
+  };
+}
+function createAgentLifecycleSend(session2) {
+  return async (fact) => {
+    const args2 = {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId,
+      fact: toConvexLifecycleFact(fact)
+    };
+    return await session2.backend.mutation(api.machines.projectAgentLifecycleFact, args2);
+  };
+}
+var init_agent_lifecycle_send = __esm(() => {
+  init_api3();
+});
+
+// src/daemon/entry/agent-lifecycle-outbox-runtime.ts
+function createAgentLifecycleOutboxForSession(args2) {
+  return createAgentLifecycleOutboxRegistry(args2.machineId, () => createAgentLifecycleSend({
+    sessionId: args2.sessionId,
+    machineId: args2.machineId,
+    backend: args2.backend
+  }));
+}
+function enqueueAgentLifecycleFact(registry2, machineId, fact) {
+  return registry2.enqueue(agentLifecycleKey(machineId, fact), fact);
+}
+var init_agent_lifecycle_outbox_runtime = __esm(() => {
+  init_agent_lifecycle_outbox();
+  init_agent_lifecycle_send();
+});
+
 // src/daemon/entry/daemon-services.ts
 function DaemonMutableStateServiceLive(init2) {
   return exports_Layer.effect(DaemonMutableStateService, exports_Effect.gen(function* () {
@@ -83526,7 +83859,10 @@ function DaemonMutableStateServiceLive(init2) {
     };
   }));
 }
-var DaemonMachineService, DaemonMachineServiceLive = (ops) => exports_Layer.succeed(DaemonMachineService, {
+var AgentLifecycleOutboxService, AgentLifecycleOutboxServiceLive = (registry2, machineId) => exports_Layer.succeed(AgentLifecycleOutboxService, {
+  enqueue: (fact) => exports_Effect.promise(() => enqueueAgentLifecycleFact(registry2, machineId, fact)),
+  stopAll: () => exports_Effect.promise(() => registry2.stopAll())
+}), DaemonMachineService, DaemonMachineServiceLive = (ops) => exports_Layer.succeed(DaemonMachineService, {
   clearAgentPid: (machineId, chatroomId, role) => exports_Effect.promise(() => ops.clearAgentPid(machineId, chatroomId, role)),
   persistAgentPid: (machineId, chatroomId, role, pid, harness) => exports_Effect.promise(() => ops.persistAgentPid(machineId, chatroomId, role, pid, harness)),
   listAgentEntries: (machineId) => exports_Effect.promise(() => ops.listAgentEntries(machineId)),
@@ -83550,6 +83886,9 @@ var DaemonMachineService, DaemonMachineServiceLive = (ops) => exports_Layer.succ
 }), DaemonSessionService, DaemonMutableStateService;
 var init_daemon_services = __esm(() => {
   init_esm();
+  init_agent_lifecycle_outbox_runtime();
+  AgentLifecycleOutboxService = class AgentLifecycleOutboxService extends exports_Context.Tag("AgentLifecycleOutboxService")() {
+  };
   DaemonMachineService = class DaemonMachineService extends exports_Context.Tag("DaemonMachineService")() {
   };
   DaemonSpawningService = class DaemonSpawningService extends exports_Context.Tag("DaemonSpawningService")() {
@@ -83572,7 +83911,7 @@ function daemonSessionToLayers(init2) {
   return exports_Layer.mergeAll(BackendServiceLive({
     mutation: (e, a) => init2.backend.mutation(e, a),
     query: (e, a) => init2.backend.query(e, a)
-  }), ProcessServiceLive, ClockServiceLive, FsServiceLive, DaemonMachineServiceLive(init2.machine), DaemonSpawningServiceLive(init2.spawning), DaemonAgentProcessManagerServiceLive(init2.agentProcessManager), DaemonMutableStateServiceLive({
+  }), ProcessServiceLive, ClockServiceLive, FsServiceLive, DaemonMachineServiceLive(init2.machine), AgentLifecycleOutboxServiceLive(init2.agentLifecycleOutbox, init2.machineId), DaemonSpawningServiceLive(init2.spawning), DaemonAgentProcessManagerServiceLive(init2.agentProcessManager), DaemonMutableStateServiceLive({
     lastPushedGitState: init2.lastPushedGitState,
     lastPushedModels: init2.lastPushedModels,
     lastPushedHarnessFingerprint: init2.lastPushedHarnessFingerprint,
@@ -83696,10 +84035,18 @@ var init_register_listeners = __esm(() => {
 
 // src/daemon/entry/handlers/daemon-restart-cleanup.ts
 var clearStaleSpawnedPidsEffect = () => exports_Effect.gen(function* () {
-  const backend2 = yield* BackendService;
+  const outbox = yield* AgentLifecycleOutboxService;
   const session2 = yield* DaemonSessionService;
-  const result = yield* backend2.mutation(api.machines.clearAllSpawnedPids, { sessionId: session2.sessionId, machineId: session2.machineId });
-  return result.clearedCount;
+  const emittedAt = Date.now();
+  const result = yield* outbox.enqueue({
+    kind: "cleared_all_pids",
+    revisionKey: buildAgentLifecycleRevisionKey("cleared_all", {
+      machineId: session2.machineId,
+      emittedAt
+    }),
+    emittedAt
+  });
+  return result.clearedCount ?? 0;
 }), reapOrphanCommandRunsEffect = () => exports_Effect.gen(function* () {
   const backend2 = yield* BackendService;
   const session2 = yield* DaemonSessionService;
@@ -83737,26 +84084,26 @@ import { createHash as createHash2 } from "node:crypto";
 import {
   appendFileSync,
   existsSync as existsSync6,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   readFileSync as readFileSync8,
   renameSync,
   unlinkSync,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join17 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { join as join18 } from "node:path";
 function getUrlHash() {
   const url2 = getConvexUrl();
   return createHash2("sha256").update(url2).digest("hex").substring(0, 8);
 }
 function getChildPidsFilePath() {
-  const dir = join17(homedir5(), ".chatroom");
-  return join17(dir, `daemon-children-${getUrlHash()}.pids`);
+  const dir = join18(homedir6(), ".chatroom");
+  return join18(dir, `daemon-children-${getUrlHash()}.pids`);
 }
 function ensureChatroomDir2() {
-  const dir = join17(homedir5(), ".chatroom");
+  const dir = join18(homedir6(), ".chatroom");
   if (!existsSync6(dir)) {
-    mkdirSync4(dir, { recursive: true, mode: 448 });
+    mkdirSync5(dir, { recursive: true, mode: 448 });
   }
 }
 function readPids() {
@@ -83869,7 +84216,7 @@ var init_orphan_tracker = __esm(() => {
 // src/daemon/entry/handlers/process/output-store.ts
 import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile6, rm as rm2 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 
 class TempFileOutputStore {
   state;
@@ -83932,7 +84279,7 @@ function createOutputStore(runId) {
   if (!RUN_ID_RE.test(runId)) {
     throw new Error(`Invalid runId: ${runId}`);
   }
-  const filePath = join18(TEMP_DIR, `${runId}.log`);
+  const filePath = join19(TEMP_DIR, `${runId}.log`);
   return new TempFileOutputStore(filePath);
 }
 async function ensureTempDir() {
@@ -83946,7 +84293,7 @@ async function cleanOrphanTempFiles() {
 var TAIL_WINDOW_BYTES, TEMP_DIR, RUN_ID_RE, MAX_TAIL_LINES_V2 = 50;
 var init_output_store = __esm(() => {
   TAIL_WINDOW_BYTES = 32 * 1024;
-  TEMP_DIR = join18(tmpdir(), "chatroom-cli", "runs");
+  TEMP_DIR = join19(tmpdir(), "chatroom-cli", "runs");
   RUN_ID_RE = /^[a-z0-9]+$/i;
 });
 
@@ -84014,74 +84361,6 @@ async function logDaemonAuditEvent(logEvent, event) {
   });
 }
 
-// src/daemon/infrastructure/inbox/task-snapshot-state.ts
-function snapshotKey(taskId, role) {
-  return `${taskId}:${role.toLowerCase()}`;
-}
-
-class MachineTaskSnapshotState {
-  snapshots = new Map;
-  replace(snapshots) {
-    this.snapshots.clear();
-    this.upsert(snapshots);
-  }
-  applySignalPage(signals, snapshots) {
-    const snapshotsByKey = new Map(snapshots.map((snapshot) => [
-      snapshotKey(snapshot.taskId, snapshot.agentConfig.role),
-      snapshot
-    ]));
-    for (const signal of signals) {
-      const key = snapshotKey(signal.taskId, signal.targetRole);
-      const snapshot = snapshotsByKey.get(key);
-      if (snapshot) {
-        this.snapshots.set(key, snapshot);
-      } else {
-        this.snapshots.delete(key);
-      }
-    }
-  }
-  listForRole(chatroomId, role) {
-    const roleLower = role.toLowerCase();
-    return [...this.snapshots.values()].filter((snapshot) => snapshot.chatroomId === chatroomId && snapshot.agentConfig.role.toLowerCase() === roleLower);
-  }
-  listAll() {
-    return [...this.snapshots.values()];
-  }
-  setDesiredState(chatroomId, role, desiredState) {
-    const roleLower = role.toLowerCase();
-    for (const [key, snapshot] of this.snapshots) {
-      if (snapshot.chatroomId !== chatroomId || snapshot.agentConfig.role.toLowerCase() !== roleLower) {
-        continue;
-      }
-      this.snapshots.set(key, {
-        ...snapshot,
-        agentConfig: { ...snapshot.agentConfig, desiredState }
-      });
-    }
-  }
-  upsert(snapshots) {
-    for (const snapshot of snapshots) {
-      this.snapshots.set(snapshotKey(snapshot.taskId, snapshot.agentConfig.role), snapshot);
-    }
-  }
-}
-
-// src/daemon/entry/native-delivery/native-delivery-session-registry.ts
-function registerNativeDeliverySession(ctx) {
-  registered = {
-    ...ctx,
-    taskSnapshotState: ctx.taskSnapshotState ?? new MachineTaskSnapshotState
-  };
-}
-function unregisterNativeDeliverySession() {
-  registered = null;
-}
-function getNativeDeliverySession() {
-  return registered;
-}
-var registered = null;
-var init_native_delivery_session_registry = () => {};
-
 // ../../services/backend/config/reliability.ts
 var HARNESS_SESSION_READY_TIMEOUT_MS = 5000, DAEMON_HEARTBEAT_INTERVAL_MS, DAEMON_HEARTBEAT_TTL_MS, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVED_FULL_PUSH_INTERVAL_MS, OBSERVED_SYNC_RECONCILE_MS, WORKSPACE_RECENCY_WINDOW_MS, WORKSPACE_LIST_RECONCILE_MS, CONNECTION_CLOSE_REQUEST_TTL_MS, ENHANCER_TERMINAL_JOB_RETENTION_MS;
 var init_reliability = __esm(() => {
@@ -98811,8 +99090,6 @@ var init_assigned_task_snapshot_contract = __esm(() => {
     assignedTo: exports_external.string().optional(),
     lastSeenAction: exports_external.string().nullable().optional(),
     lastStatus: exports_external.string().nullable().optional(),
-    spawnedAgentPid: exports_external.number().optional(),
-    desiredState: agentDesiredStateSchema.optional(),
     sessionAugmentation: sessionAugmentationSchema.optional()
   };
   assignedTaskSignalSchema = exports_external.object(assignedTaskSignalBootstrapFields);
@@ -98889,13 +99166,99 @@ function getNativeDeliveryLedger() {
 }
 var sharedLedger;
 
+// src/daemon/infrastructure/agent-operational/agent-operational-read-model.ts
+function isOperationalDesiredRunning(row) {
+  return row?.operationalState === "running" || row?.operationalState === "starting";
+}
+
+class AgentOperationalReadModel {
+  rows = new Map;
+  replace(rows) {
+    const changed = [];
+    const nextKeys = new Set;
+    for (const row of rows) {
+      const key = roleKey(row.chatroomId, row.role);
+      nextKeys.add(key);
+      const prev = this.rows.get(key);
+      if (!prev || prev.revisionKey !== row.revisionKey)
+        changed.push({ chatroomId: row.chatroomId, role: row.role });
+      this.rows.set(key, row);
+    }
+    for (const [key, prev] of this.rows) {
+      if (!nextKeys.has(key)) {
+        changed.push({ chatroomId: prev.chatroomId, role: prev.role });
+        this.rows.delete(key);
+      }
+    }
+    return changed;
+  }
+  get(chatroomId, role) {
+    return this.rows.get(roleKey(chatroomId, role));
+  }
+}
+var roleKey = (chatroomId, role) => `${chatroomId}:${role.toLowerCase()}`;
+
+// src/daemon/infrastructure/inbox/task-snapshot-state.ts
+function snapshotKey(taskId, role) {
+  return `${taskId}:${role.toLowerCase()}`;
+}
+
+class MachineTaskSnapshotState {
+  snapshots = new Map;
+  replace(snapshots) {
+    this.snapshots.clear();
+    this.upsert(snapshots);
+  }
+  applySignalPage(signals, snapshots) {
+    const snapshotsByKey = new Map(snapshots.map((snapshot) => [
+      snapshotKey(snapshot.taskId, snapshot.agentConfig.role),
+      snapshot
+    ]));
+    for (const signal of signals) {
+      const key = snapshotKey(signal.taskId, signal.targetRole);
+      const snapshot = snapshotsByKey.get(key);
+      if (snapshot) {
+        this.snapshots.set(key, snapshot);
+      } else {
+        this.snapshots.delete(key);
+      }
+    }
+  }
+  listForRole(chatroomId, role) {
+    const roleLower = role.toLowerCase();
+    return [...this.snapshots.values()].filter((snapshot) => snapshot.chatroomId === chatroomId && snapshot.agentConfig.role.toLowerCase() === roleLower);
+  }
+  listAll() {
+    return [...this.snapshots.values()];
+  }
+  upsert(snapshots) {
+    for (const snapshot of snapshots) {
+      this.snapshots.set(snapshotKey(snapshot.taskId, snapshot.agentConfig.role), snapshot);
+    }
+  }
+}
+
+// src/daemon/entry/native-delivery/native-delivery-session-registry.ts
+function registerNativeDeliverySession(ctx) {
+  registered = {
+    ...ctx,
+    taskSnapshotState: ctx.taskSnapshotState ?? new MachineTaskSnapshotState,
+    agentOperationalReadModel: ctx.agentOperationalReadModel ?? new AgentOperationalReadModel
+  };
+}
+function unregisterNativeDeliverySession() {
+  registered = null;
+}
+function getNativeDeliverySession() {
+  return registered;
+}
+var registered = null;
+var init_native_delivery_session_registry = () => {};
+
 // src/daemon/domain/entities/assigned-task.ts
 function isDeliverableTaskStatus(status3) {
   return status3 === "pending" || status3 === "acknowledged";
 }
-function isAgentDesiredRunning(desiredState) {
-  return desiredState === "running";
-}
 var init_assigned_task = () => {};
 
 // src/daemon/domain/usecase/check-agent-slot.ts
@@ -98925,8 +99288,9 @@ function explainAgentReadyForNativeDeliveryBlock(task, slot) {
   if (!isNativeHarness(agentConfig.agentHarness)) {
     return `not_native_harness (harness=${agentConfig.agentHarness})`;
   }
-  if (!isAgentDesiredRunning(agentConfig.desiredState)) {
-    return `desired_state_not_running (desiredState=${agentConfig.desiredState})`;
+  const operational = getNativeDeliverySession()?.agentOperationalReadModel?.get(task.chatroomId, agentConfig.role);
+  if (!isOperationalDesiredRunning(operational)) {
+    return `operational_state_not_running (state=${operational?.operationalState ?? "missing"})`;
   }
   if (!slot) {
     return agentConfig.spawnedAgentPid == null ? "spawned_pid_missing" : `slot_missing (expectedPid=${agentConfig.spawnedAgentPid})`;
@@ -98954,6 +99318,7 @@ function isDeliverableNativeTaskStatus(status3) {
 }
 var init_native_ready_invariant = __esm(() => {
   init_types();
+  init_native_delivery_session_registry();
   init_assigned_task();
   init_check_agent_slot();
 });
@@ -99466,20 +99831,20 @@ function mapAssignedTaskSnapshotList(rows) {
 }
 
 // src/daemon/entry/restart-orchestrator-in-flight.ts
-function roleKey(chatroomId, role) {
+function roleKey2(chatroomId, role) {
   return `${chatroomId}:${role.toLowerCase()}`;
 }
 function markRestartOrchestratorInFlight(chatroomId, role, correlationId) {
-  inFlight.set(roleKey(chatroomId, role), correlationId);
+  inFlight.set(roleKey2(chatroomId, role), correlationId);
 }
 function clearRestartOrchestratorInFlight(chatroomId, role, correlationId) {
-  const key = roleKey(chatroomId, role);
+  const key = roleKey2(chatroomId, role);
   if (correlationId !== undefined && inFlight.get(key) !== correlationId)
     return;
   inFlight.delete(key);
 }
 function isRestartOrchestratorInFlight(chatroomId, role) {
-  return inFlight.has(roleKey(chatroomId, role));
+  return inFlight.has(roleKey2(chatroomId, role));
 }
 function filterSnapshotsExcludingRestartInFlight(snapshots) {
   return snapshots.filter((row) => !isRestartOrchestratorInFlight(row.chatroomId, row.agentConfig.role));
@@ -99490,7 +99855,7 @@ var init_restart_orchestrator_in_flight = __esm(() => {
 });
 
 // src/daemon/entry/role-delivery-state.ts
-function roleKey2(chatroomId, role) {
+function roleKey3(chatroomId, role) {
   return `${chatroomId}:${role.toLowerCase()}`;
 }
 
@@ -99499,10 +99864,10 @@ class RoleDeliveryState {
   inFlight = new Set;
   nativeNudgeFailures = new Map;
   getGeneration(chatroomId, role) {
-    return this.generation.get(roleKey2(chatroomId, role)) ?? 0;
+    return this.generation.get(roleKey3(chatroomId, role)) ?? 0;
   }
   resetDeliveryState(chatroomId, role) {
-    const key = roleKey2(chatroomId, role);
+    const key = roleKey3(chatroomId, role);
     const next4 = (this.generation.get(key) ?? 0) + 1;
     this.generation.set(key, next4);
     this.inFlight.delete(key);
@@ -99510,26 +99875,26 @@ class RoleDeliveryState {
     return next4;
   }
   tryAcquireDelivery(chatroomId, role) {
-    const key = roleKey2(chatroomId, role);
+    const key = roleKey3(chatroomId, role);
     if (this.inFlight.has(key))
       return false;
     this.inFlight.add(key);
     return true;
   }
   releaseDelivery(chatroomId, role) {
-    this.inFlight.delete(roleKey2(chatroomId, role));
+    this.inFlight.delete(roleKey3(chatroomId, role));
   }
   recordNativeNudgeFailure(chatroomId, role) {
-    const key = roleKey2(chatroomId, role);
+    const key = roleKey3(chatroomId, role);
     const count3 = (this.nativeNudgeFailures.get(key) ?? 0) + 1;
     this.nativeNudgeFailures.set(key, count3);
     return count3;
   }
   clearNativeNudgeFailures(chatroomId, role) {
-    this.nativeNudgeFailures.delete(roleKey2(chatroomId, role));
+    this.nativeNudgeFailures.delete(roleKey3(chatroomId, role));
   }
   getNativeNudgeFailures(chatroomId, role) {
-    return this.nativeNudgeFailures.get(roleKey2(chatroomId, role)) ?? 0;
+    return this.nativeNudgeFailures.get(roleKey3(chatroomId, role)) ?? 0;
   }
 }
 function getRoleDeliveryState() {
@@ -99916,8 +100281,6 @@ function createStartAgentDeps(agentMgr, session2) {
   return {
     agentProcessManager: {
       ensureRunning: async (args2) => {
-        const taskSnapshotState = getNativeDeliverySession()?.taskSnapshotState;
-        taskSnapshotState?.setDesiredState(args2.chatroomId, args2.role, "running");
         const result = await exports_Effect.runPromise(agentMgr.ensureRunning({
           chatroomId: args2.chatroomId,
           role: args2.role,
@@ -99927,9 +100290,7 @@ function createStartAgentDeps(agentMgr, session2) {
           reason: args2.reason,
           wantResume: args2.wantResume
         }));
-        if (!result.success) {
-          taskSnapshotState?.setDesiredState(args2.chatroomId, args2.role, "stopped");
-        }
+        if (!result.success) {}
         return result;
       }
     },
@@ -100052,7 +100413,6 @@ function createRecoverAgentStateDeps(agentMgr, session2) {
 var init_agent_control_bridge = __esm(() => {
   init_esm();
   init_api3();
-  init_native_delivery_session_registry();
   init_restart_orchestrator();
 });
 
@@ -100188,9 +100548,9 @@ var init_daemon_process_scan = __esm(() => {
 
 // src/commands/machine/pid.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync5 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync6 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join20 } from "node:path";
 function getUrlHash2() {
   const url3 = getConvexUrl();
   return createHash3("sha256").update(url3).digest("hex").substring(0, 8);
@@ -100200,11 +100560,11 @@ function getPidFileName() {
 }
 function ensureChatroomDir3() {
   if (!existsSync8(CHATROOM_DIR4)) {
-    mkdirSync5(CHATROOM_DIR4, { recursive: true, mode: 448 });
+    mkdirSync6(CHATROOM_DIR4, { recursive: true, mode: 448 });
   }
 }
 function getPidFilePath() {
-  return join19(CHATROOM_DIR4, getPidFileName());
+  return join20(CHATROOM_DIR4, getPidFileName());
 }
 function isProcessRunning(pid) {
   try {
@@ -100350,7 +100710,7 @@ var CHATROOM_DIR4, LOCK_RETRY_INTERVAL_MS = 500, LOCK_RETRY_MAX_WAIT_MS = 15000,
 var init_pid = __esm(() => {
   init_daemon_process_scan();
   init_client2();
-  CHATROOM_DIR4 = join19(homedir6(), ".chatroom");
+  CHATROOM_DIR4 = join20(homedir7(), ".chatroom");
 });
 
 // src/infrastructure/machine/crash-loop-tracker.ts
@@ -102096,9 +102456,8 @@ class AgentProcessManager {
       console.log(`   ⚠️  ${failureLog}: ${err.message}`);
       this.queueExitRetry({ role, args: exitArgs });
     });
-    this.deps.backend.mutation(api.daemon.agentEvents.agentExited, exitArgs).catch((err) => {
-      console.log(`   ⚠️  Failed to apply agent exit state: ${err.message}`);
-    });
+    const emittedAt = this.deps.clock.now();
+    this.deps.lifecycleOutbox.enqueue(buildExitedLifecycleFact(exitArgs, emittedAt)).catch((err) => console.log(`   ⚠️  Failed to enqueue agent exited lifecycle fact: ${err.message}`));
   }
   async clearAgentPidQuietly(chatroomId, role) {
     try {
@@ -102502,28 +102861,23 @@ class AgentProcessManager {
     }).catch((err) => {
       console.log(`   ⚠️  Failed to record agent.started event: ${err.message}`);
     });
-    this.deps.backend.mutation(api.daemon.agentEvents.agentStarted, {
-      sessionId: this.deps.sessionId,
-      machineId: this.deps.machineId,
+    const emittedAt = this.deps.clock.now();
+    this.deps.lifecycleOutbox.enqueue({
+      kind: "spawned",
       chatroomId: opts.chatroomId,
       role: opts.role,
       pid,
       model: opts.model,
       reason: opts.reason,
-      ...spawnResult.harnessSessionId ? { harnessSessionId: spawnResult.harnessSessionId } : {}
-    }).catch((err) => {
-      console.log(`   ⚠️  Failed to apply agent.started state: ${err.message}`);
-    });
-    this.deps.backend.mutation(api.machines.updateSpawnedAgent, {
-      sessionId: this.deps.sessionId,
-      machineId: this.deps.machineId,
-      chatroomId: opts.chatroomId,
-      role: opts.role,
-      pid,
-      model: opts.model
-    }).catch((err) => {
-      console.log(`   ⚠️  Failed to update PID in backend: ${err.message}`);
-    });
+      ...spawnResult.harnessSessionId ? { harnessSessionId: spawnResult.harnessSessionId } : {},
+      revisionKey: buildAgentLifecycleRevisionKey("spawned", {
+        chatroomId: opts.chatroomId,
+        role: opts.role,
+        pid,
+        emittedAt
+      }),
+      emittedAt
+    }).catch((err) => console.log(`   ⚠️  Failed to enqueue agent spawned lifecycle fact: ${err.message}`));
   }
   registerSpawnCallbacks(slot, opts, spawnResult, pid) {
     if (spawnResult.onLogLine) {
@@ -102878,6 +103232,11 @@ function assembleDaemonSessionInit(args2) {
   } = args2;
   deps.backend.mutation = (endpoint, args3) => client4.mutation(endpoint, args3);
   deps.backend.query = (endpoint, args3) => client4.query(endpoint, args3);
+  const agentLifecycleOutbox = createAgentLifecycleOutboxForSession({
+    sessionId: typedSessionId,
+    machineId,
+    backend: deps.backend
+  });
   deps.agentProcessManager = new AgentProcessManager({
     logEvent: activeLogEvent ?? (async () => {
       return;
@@ -102893,7 +103252,8 @@ function assembleDaemonSessionInit(args2) {
     persistence: deps.machine,
     spawning: deps.spawning,
     crashLoop: new CrashLoopTracker,
-    convexUrl
+    convexUrl,
+    lifecycleOutbox: { enqueue: (fact) => enqueueAgentLifecycleFact(agentLifecycleOutbox, machineId, fact) }
   });
   return {
     client: client4,
@@ -102906,6 +103266,7 @@ function assembleDaemonSessionInit(args2) {
     machine: deps.machine,
     spawning: deps.spawning,
     agentProcessManager: deps.agentProcessManager,
+    agentLifecycleOutbox,
     events: new DaemonEventBus,
     agentServices,
     lastPushedGitState: new Map,
@@ -103138,6 +103499,8 @@ var init_init_daemon = __esm(() => {
   init_daemon_startup_log();
   init_orphan_tracker();
   init_output_store();
+  init_agent_lifecycle_outbox_runtime();
+  init_agent_lifecycle_outbox_runtime();
   init_state_recovery();
   init_pid();
   init_storage();
@@ -105768,6 +106131,14 @@ var init_workspace_cache = __esm(() => {
 
 // src/daemon/infrastructure/git/run-command.ts
 import { spawn as spawn4 } from "node:child_process";
+function enqueueGit(cwd, task) {
+  const tail = gitQueues.get(cwd) ?? Promise.resolve();
+  const run3 = tail.then(task, task);
+  gitQueues.set(cwd, run3.catch(() => {
+    return;
+  }));
+  return run3;
+}
 function runCommandSpawn(command, args2, cwd, options) {
   const successExitCodes = options?.successExitCodes ?? [0];
   return new Promise((resolve4) => {
@@ -105813,7 +106184,7 @@ function runCommandSpawn(command, args2, cwd, options) {
   });
 }
 function runGit(args2, cwd, options) {
-  return runCommandSpawn("git", args2, cwd, options);
+  return enqueueGit(cwd, () => runCommandSpawn("git", options?.readOnly ? ["--no-optional-locks", ...args2] : args2, cwd, options));
 }
 function runGh(args2, cwd, options) {
   return runCommandSpawn("gh", args2, cwd, {
@@ -105821,7 +106192,7 @@ function runGh(args2, cwd, options) {
     env: { ...process.env, NO_COLOR: "1" }
   });
 }
-var DEFAULT_GIT_ENV;
+var DEFAULT_GIT_ENV, gitQueues;
 var init_run_command = __esm(() => {
   DEFAULT_GIT_ENV = {
     ...process.env,
@@ -105829,6 +106200,7 @@ var init_run_command = __esm(() => {
     GIT_PAGER: "cat",
     NO_COLOR: "1"
   };
+  gitQueues = new Map;
 });
 
 // src/daemon/infrastructure/git/types.ts
@@ -105838,6 +106210,9 @@ function makeGitStateKey(machineId, workingDir) {
 var FULL_DIFF_MAX_BYTES = 500000, COMMITS_PER_PAGE = 20;
 
 // src/daemon/infrastructure/git/git-reader.ts
+function runGit2(args2, cwd, options) {
+  return runGit(cwd ? args2 : args2, cwd, { ...options, readOnly: true });
+}
 function repoArgs(repoSlug) {
   return repoSlug ? ["--repo", repoSlug] : [];
 }
@@ -105854,14 +106229,14 @@ function isEmptyRepo(stderr) {
   return stderr.includes("does not have any commits yet") || stderr.includes("no commits yet") || stderr.includes("ambiguous argument 'HEAD'") || stderr.includes("unknown revision or path");
 }
 async function listUntrackedFiles(workingDir) {
-  const result = await runGit(["ls-files", "--others", "--exclude-standard"], workingDir);
+  const result = await runGit2(["ls-files", "--others", "--exclude-standard"], workingDir);
   if ("error" in result)
     return [];
   return result.stdout.split(`
 `).map((line) => line.trim()).filter(Boolean);
 }
 async function getUntrackedFileDiff(workingDir, filePath) {
-  const result = await runGit(["diff", "--no-index", "--", NULL_DEVICE, filePath], workingDir, {
+  const result = await runGit2(["diff", "--no-index", "--", NULL_DEVICE, filePath], workingDir, {
     successExitCodes: [0, 1]
   });
   if ("error" in result)
@@ -105922,7 +106297,7 @@ function truncateDiffContent(raw) {
   return { status: "available", content: raw, truncated: false };
 }
 async function runTrackedHeadDiff(workingDir, args2, options) {
-  const result = await runGit(args2, workingDir, options);
+  const result = await runGit2(args2, workingDir, options);
   if ("error" in result) {
     const errMsg = result.error.message;
     if (isEmptyRepo(errMsg))
@@ -105951,13 +106326,13 @@ function classifyError(errMessage) {
   return { status: "error", message: errMessage.trim() };
 }
 async function isGitRepo(workingDir) {
-  const result = await runGit(["rev-parse", "--git-dir"], workingDir);
+  const result = await runGit2(["rev-parse", "--git-dir"], workingDir);
   if ("error" in result)
     return false;
   return result.stdout.trim().length > 0;
 }
 async function getBranch(workingDir) {
-  const result = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], workingDir);
+  const result = await runGit2(["rev-parse", "--abbrev-ref", "HEAD"], workingDir);
   if ("error" in result) {
     const errMsg = result.error.message;
     if (errMsg.includes("unknown revision") || errMsg.includes("No such file or directory") || errMsg.includes("does not have any commits")) {
@@ -105972,7 +106347,7 @@ async function getBranch(workingDir) {
   return { status: "available", branch };
 }
 async function isDirty(workingDir) {
-  const result = await runGit(["status", "--porcelain"], workingDir);
+  const result = await runGit2(["status", "--porcelain"], workingDir);
   if ("error" in result)
     return false;
   return result.stdout.trim().length > 0;
@@ -106042,7 +106417,7 @@ async function getRecentCommits(workingDir, count3 = 20, skip = 0) {
   if (skip > 0)
     logArgs.push(`--skip=${skip}`);
   logArgs.push(`--format=${format4}`);
-  const result = await runGit(logArgs, workingDir);
+  const result = await runGit2(logArgs, workingDir);
   if ("error" in result) {
     return [];
   }
@@ -106064,7 +106439,7 @@ async function getRecentCommits(workingDir, count3 = 20, skip = 0) {
   return commits;
 }
 async function getCommitDetail(workingDir, sha) {
-  const result = await runGit(["show", sha, "--format=", "--stat", "-p"], workingDir);
+  const result = await runGit2(["show", sha, "--format=", "--stat", "-p"], workingDir);
   if ("error" in result) {
     const errMsg = result.error.message;
     const classified = classifyError(errMsg);
@@ -106085,7 +106460,7 @@ async function getCommitDetail(workingDir, sha) {
 }
 async function getCommitMetadata(workingDir, sha) {
   const format4 = "%s%x1f%b%x1f%an%x1f%aI";
-  const result = await runGit(["log", "-1", `--format=${format4}`, sha], workingDir);
+  const result = await runGit2(["log", "-1", `--format=${format4}`, sha], workingDir);
   if ("error" in result)
     return null;
   const output = result.stdout.trim();
@@ -106111,7 +106486,7 @@ function parseRepoSlug(remoteUrl) {
   return null;
 }
 async function getOriginRepoSlug(cwd) {
-  const result = await runGit(["remote", "get-url", "origin"], cwd);
+  const result = await runGit2(["remote", "get-url", "origin"], cwd);
   if ("error" in result)
     return null;
   const url3 = result.stdout.trim();
@@ -106248,7 +106623,7 @@ async function getPRCommits(cwd, prNumber) {
   }
 }
 async function getRemotes(cwd) {
-  const result = await runGit(["remote", "-v"], cwd);
+  const result = await runGit2(["remote", "-v"], cwd);
   if ("error" in result)
     return [];
   if (!result.stdout.trim())
@@ -106272,14 +106647,14 @@ async function getRemotes(cwd) {
   return remotes;
 }
 async function getCommitsAhead(workingDir) {
-  const result = await runGit(["rev-list", "--count", "@{upstream}..HEAD"], workingDir);
+  const result = await runGit2(["rev-list", "--count", "@{upstream}..HEAD"], workingDir);
   if ("error" in result)
     return 0;
   const count3 = parseInt(result.stdout.trim(), 10);
   return Number.isNaN(count3) ? 0 : count3;
 }
 async function getCommitsBehind(workingDir) {
-  const result = await runGit(["rev-list", "--count", "HEAD..@{upstream}"], workingDir);
+  const result = await runGit2(["rev-list", "--count", "HEAD..@{upstream}"], workingDir);
   if ("error" in result)
     return 0;
   const count3 = parseInt(result.stdout.trim(), 10);
@@ -106373,16 +106748,12 @@ class GitStatePipeline {
     const results = new Map(preCollected);
     if (this.fields.length === 0)
       return results;
-    const entries2 = await Promise.all(this.fields.filter((f) => !results.has(f.key)).map(async (field) => {
+    for (const field of this.fields.filter((f) => !results.has(f.key))) {
       try {
-        const raw = await field.collect(workingDir);
-        return { key: field.key, raw };
+        results.set(field.key, await field.collect(workingDir));
       } catch {
-        return { key: field.key, raw: field.defaultValue };
+        results.set(field.key, field.defaultValue);
       }
-    }));
-    for (const { key, raw } of entries2) {
-      results.set(key, raw);
     }
     return results;
   }
@@ -107547,16 +107918,16 @@ var init_jsonc = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-resolver.ts
 import { readFile as readFile7, readdir, stat as stat3 } from "node:fs/promises";
-import { join as join20, basename, resolve as resolve4 } from "node:path";
+import { join as join21, basename, resolve as resolve4 } from "node:path";
 async function resolveGlobPatternStar(rootDir, cleaned) {
-  const parentDir = join20(rootDir, cleaned.slice(0, -2));
+  const parentDir = join21(rootDir, cleaned.slice(0, -2));
   try {
     const entries2 = await readdir(parentDir, { withFileTypes: true });
     const dirs = [];
     for (const entry of entries2) {
       if (!entry.isDirectory())
         continue;
-      const dirPath = join20(parentDir, entry.name);
+      const dirPath = join21(parentDir, entry.name);
       if (resolve4(dirPath).startsWith(resolve4(rootDir))) {
         dirs.push(dirPath);
       }
@@ -107567,7 +107938,7 @@ async function resolveGlobPatternStar(rootDir, cleaned) {
   }
 }
 async function resolveLiteralPath(rootDir, cleaned) {
-  const dir = join20(rootDir, cleaned);
+  const dir = join21(rootDir, cleaned);
   try {
     if (!resolve4(dir).startsWith(resolve4(rootDir)))
       return [];
@@ -107587,7 +107958,7 @@ async function resolveGlobPattern(rootDir, pattern) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile7(join20(dir, "package.json"), "utf-8");
+    const content = await readFile7(join21(dir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return {
       name: pkg.name || basename(dir),
@@ -107599,7 +107970,7 @@ async function readPackageJson(dir) {
 }
 async function readPnpmWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile7(join20(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    const content = await readFile7(join21(rootDir, "pnpm-workspace.yaml"), "utf-8");
     const patterns = [];
     let inPackages = false;
     for (const line of content.split(`
@@ -107626,7 +107997,7 @@ async function readPnpmWorkspacePatterns(rootDir) {
 }
 async function readPackageJsonWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile7(join20(rootDir, "package.json"), "utf-8");
+    const content = await readFile7(join21(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.workspaces)
       return [];
@@ -107707,11 +108078,11 @@ var MAX_NAME_LENGTH = 256;
 
 // src/infrastructure/services/workspace/command-discovery.ts
 import { access as access2, readFile as readFile8 } from "node:fs/promises";
-import { join as join21, relative, basename as basename2 } from "node:path";
+import { join as join22, relative, basename as basename2 } from "node:path";
 async function detectPackageManager(workingDir) {
   for (const { file: file2, manager } of LOCKFILE_MAP) {
     try {
-      await access2(join21(workingDir, file2));
+      await access2(join22(workingDir, file2));
       return manager;
     } catch {}
   }
@@ -107780,7 +108151,7 @@ function collectRootScriptCommands(scripts, pm, scriptPrefix, rootSw) {
 }
 async function readRootPackageJson(workingDir, pm, scriptPrefix) {
   let rootPackageName = basename2(workingDir);
-  const pkg = await readJsonFile(join21(workingDir, "package.json"), "root package.json");
+  const pkg = await readJsonFile(join22(workingDir, "package.json"), "root package.json");
   if (!pkg)
     return { commands: [], rootPackageName };
   if (pkg.name)
@@ -107796,7 +108167,7 @@ async function readRootPackageJson(workingDir, pm, scriptPrefix) {
 }
 async function readTurboJson(workingDir, _turboPrefix, _rootSubWorkspace) {
   const turboTaskNames = [];
-  const turbo = await readJsonFile(join21(workingDir, "turbo.json"), "turbo.json");
+  const turbo = await readJsonFile(join22(workingDir, "turbo.json"), "turbo.json");
   if (!turbo?.tasks || typeof turbo.tasks !== "object")
     return turboTaskNames;
   for (const taskName of Object.keys(turbo.tasks)) {
@@ -107809,7 +108180,7 @@ async function readTurboJson(workingDir, _turboPrefix, _rootSubWorkspace) {
 async function readDenoJson(workingDir) {
   const commands = [];
   for (const fileName of ["deno.json", "deno.jsonc"]) {
-    const deno = await readJsonFile(join21(workingDir, fileName), fileName);
+    const deno = await readJsonFile(join22(workingDir, fileName), fileName);
     if (!deno?.tasks || typeof deno.tasks !== "object")
       continue;
     const pkgName = deno.name ?? basename2(workingDir);
@@ -107832,7 +108203,7 @@ async function readMakefile(workingDir) {
   const commands = [];
   for (const fileName of ["Makefile", "makefile"]) {
     try {
-      const content = await readFile8(join21(workingDir, fileName), "utf-8");
+      const content = await readFile8(join22(workingDir, fileName), "utf-8");
       const targets = parseMakefileTargets(content);
       if (targets.length === 0)
         continue;
@@ -110038,7 +110409,7 @@ var init_assert_registered_working_dir = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-path-security.ts
 import { realpath } from "node:fs/promises";
-import { dirname as dirname9, isAbsolute, relative as relative2, resolve as resolve5, sep } from "node:path";
+import { dirname as dirname10, isAbsolute, relative as relative2, resolve as resolve5, sep } from "node:path";
 import { gunzipSync } from "node:zlib";
 function validateRelativePathSegments(filePath) {
   if (filePath.includes("\x00"))
@@ -110066,7 +110437,7 @@ function assertContained(workspaceRoot, targetPath) {
   return { ok: true };
 }
 async function resolveNonExistentTarget(workspaceRoot, candidate) {
-  let current = dirname9(candidate);
+  let current = dirname10(candidate);
   for (;; ) {
     try {
       const ancestorReal = await realpath(current);
@@ -110084,7 +110455,7 @@ async function resolveNonExistentTarget(workspaceRoot, candidate) {
       if (code2 !== "ENOENT") {
         return { ok: false, error: "Invalid file path" };
       }
-      const parent = dirname9(current);
+      const parent = dirname10(current);
       if (parent === current) {
         return { ok: false, error: "Path escapes workspace" };
       }
@@ -110895,16 +111266,16 @@ var require_ignore = __commonJS((exports, module) => {
 // src/infrastructure/services/workspace/workspace-ignore.ts
 import { promises as fsPromises } from "node:fs";
 import { readFile as readFile10 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir8 } from "node:os";
 import path3 from "node:path";
 function normalizeRelativePath(relativePath) {
   return relativePath.replace(/\\/g, "/").replace(/^\.?\//, "").replace(/\/+$/, "");
 }
 function expandUserPath(filePath) {
   if (filePath === "~")
-    return homedir7();
+    return homedir8();
   if (filePath.startsWith("~/"))
-    return path3.join(homedir7(), filePath.slice(2));
+    return path3.join(homedir8(), filePath.slice(2));
   return filePath;
 }
 function readExcludesFileFromGitconfig(content) {
@@ -110935,11 +111306,11 @@ async function readGitconfigExcludesFilePath(configPath) {
   return path3.isAbsolute(raw) ? expandUserPath(raw) : path3.resolve(path3.dirname(configPath), raw);
 }
 async function resolveGitExtraExcludeFilePaths(rootDir) {
-  const globalConfig2 = process.env.GIT_CONFIG_GLOBAL?.length ? process.env.GIT_CONFIG_GLOBAL : path3.join(homedir7(), ".gitconfig");
+  const globalConfig2 = process.env.GIT_CONFIG_GLOBAL?.length ? process.env.GIT_CONFIG_GLOBAL : path3.join(homedir8(), ".gitconfig");
   const localConfig = path3.join(rootDir, ".git", "config");
   let excludesFile = await readGitconfigExcludesFilePath(localConfig) ?? await readGitconfigExcludesFilePath(globalConfig2);
   if (!excludesFile) {
-    excludesFile = path3.join(process.env.XDG_CONFIG_HOME?.length ? process.env.XDG_CONFIG_HOME : path3.join(homedir7(), ".config"), "git", "ignore");
+    excludesFile = path3.join(process.env.XDG_CONFIG_HOME?.length ? process.env.XDG_CONFIG_HOME : path3.join(homedir8(), ".config"), "git", "ignore");
   }
   const candidates = [excludesFile, path3.join(rootDir, ".git", "info", "exclude")];
   const existing = [];
@@ -111391,7 +111762,8 @@ function porcelainUntrackedDeletedEvents(args2) {
 }
 async function readGitHead(workTree) {
   const result = await runGit(["rev-parse", "HEAD"], workTree, {
-    timeout: GIT_POLL_TIMEOUT_MS
+    timeout: GIT_POLL_TIMEOUT_MS,
+    readOnly: true
   });
   if ("error" in result) {
     if (isEmptyRepoHeadError(result.error))
@@ -111415,7 +111787,10 @@ async function readGitPorcelainStatus(node) {
   const args2 = ["status", "--porcelain=v1", "-z", "-uall", "--"];
   if (node.pathspec.length > 0)
     args2.push(...node.pathspec);
-  const result = await runGit(args2, node.workTree, { timeout: GIT_POLL_TIMEOUT_MS });
+  const result = await runGit(args2, node.workTree, {
+    timeout: GIT_POLL_TIMEOUT_MS,
+    readOnly: true
+  });
   if ("error" in result) {
     throw new GitWorkspaceCommandError({
       operation: "readGitPorcelainStatus",
@@ -111553,35 +111928,31 @@ function createGitWorkspaceChangeSource(options) {
     let needsReconcile = false;
     let tickHadFailure = false;
     let maxNodeFailures = 0;
-    const results = await Promise.allSettled(nodes.map(async (node) => {
-      const prev = state.get(node.workTree) ?? {
-        prevEntries: [],
-        prevHead: { head: null },
-        baselineEstablished: false
-      };
-      const result = await pollGitWorkspaceNode({
-        options,
-        node,
-        prev
-      });
-      allEvents.push(...result.events);
-      if (result.needsReconcile)
-        needsReconcile = true;
-      state.set(node.workTree, result.nextState);
-      nodeFailureCounts.set(node.workTree, 0);
-      return node;
-    }));
-    for (let i2 = 0;i2 < results.length; i2++) {
-      const result = results[i2];
-      const node = nodes[i2];
-      if (!node || result.status === "fulfilled")
-        continue;
-      tickHadFailure = true;
-      options.onError?.(result.reason);
-      const prevFailures = nodeFailureCounts.get(node.workTree) ?? 0;
-      const nextFailures = prevFailures + 1;
-      nodeFailureCounts.set(node.workTree, nextFailures);
-      maxNodeFailures = Math.max(maxNodeFailures, nextFailures);
+    for (const node of nodes) {
+      try {
+        const prev = state.get(node.workTree) ?? {
+          prevEntries: [],
+          prevHead: { head: null },
+          baselineEstablished: false
+        };
+        const result = await pollGitWorkspaceNode({
+          options,
+          node,
+          prev
+        });
+        allEvents.push(...result.events);
+        if (result.needsReconcile)
+          needsReconcile = true;
+        state.set(node.workTree, result.nextState);
+        nodeFailureCounts.set(node.workTree, 0);
+      } catch (reason) {
+        tickHadFailure = true;
+        options.onError?.(reason);
+        const prevFailures = nodeFailureCounts.get(node.workTree) ?? 0;
+        const nextFailures = prevFailures + 1;
+        nodeFailureCounts.set(node.workTree, nextFailures);
+        maxNodeFailures = Math.max(maxNodeFailures, nextFailures);
+      }
     }
     if (tickHadFailure) {
       consecutiveFailureTicks += 1;
@@ -111639,7 +112010,7 @@ function createGitWorkspaceChangeSource(options) {
     }
   };
 }
-var DEFAULT_POLL_INTERVAL_MS = 1000, MAX_BACKOFF_MS = 30000, PERSISTENT_FAILURE_THRESHOLD = 3;
+var DEFAULT_POLL_INTERVAL_MS = 3000, MAX_BACKOFF_MS = 30000, PERSISTENT_FAILURE_THRESHOLD = 3;
 var init_git_workspace_change_source = __esm(() => {
   init_git_workspace_porcelain();
 });
@@ -112068,9 +112439,9 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname11 = sp.dirname(file2);
+    const dirname12 = sp.dirname(file2);
     const basename4 = sp.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname11);
+    const parent = this.fsw._getWatchedDir(dirname12);
     let prevStats = stats;
     if (parent.has(basename4))
       return;
@@ -112097,7 +112468,7 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error51) {
-          this.fsw._remove(dirname11, basename4);
+          this.fsw._remove(dirname12, basename4);
         }
       } else if (parent.has(basename4)) {
         const at = newStats.atimeMs;
@@ -113486,8 +113857,8 @@ function diffPathIndexes(previous, next4) {
 // src/infrastructure/services/workspace/workspace-sync-state.ts
 import { createHash as createHash7, randomUUID as randomUUID9 } from "node:crypto";
 import * as fs11 from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import { join as join24 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { join as join25 } from "node:path";
 function workspaceKeyFor(workingDir) {
   const normalized = normalizeWorkingDirForLookup(workingDir);
   return createHash7("sha256").update(normalized).digest("hex").slice(0, 16);
@@ -113501,10 +113872,10 @@ function buildPathIndex(entries2) {
 }
 function manifestPath(machineId, workingDir) {
   const key = workspaceKeyFor(workingDir);
-  return join24(SYNC_STATE_DIR, machineId, key, "manifest.json");
+  return join25(SYNC_STATE_DIR, machineId, key, "manifest.json");
 }
 async function ensureDir(filePath) {
-  await fs11.mkdir(join24(filePath, ".."), { recursive: true, mode: 448 });
+  await fs11.mkdir(join25(filePath, ".."), { recursive: true, mode: 448 });
 }
 async function loadWorkspaceSyncManifest(machineId, workingDir) {
   try {
@@ -113564,7 +113935,7 @@ function entriesFromPathIndex(paths) {
 }
 var SYNC_STATE_VERSION = "2", SYNC_STATE_DIR;
 var init_workspace_sync_state = __esm(() => {
-  SYNC_STATE_DIR = join24(homedir8(), ".chatroom", "sync-state");
+  SYNC_STATE_DIR = join25(homedir9(), ".chatroom", "sync-state");
 });
 
 // src/infrastructure/services/workspace/workspace-file-tree-coordinator.ts
@@ -113941,12 +114312,12 @@ var init_durable_coalescing_state_schema = __esm(() => {
 });
 
 // src/daemon/infrastructure/outbox/lib/durable-coalescing-state-store.ts
-import { mkdirSync as mkdirSync6 } from "node:fs";
-import { dirname as dirname12 } from "node:path";
-import { DatabaseSync } from "node:sqlite";
+import { mkdirSync as mkdirSync7 } from "node:fs";
+import { dirname as dirname13 } from "node:path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 function openDurableCoalescingStateStore(path8) {
-  mkdirSync6(dirname12(path8), { recursive: true });
-  const db = new DatabaseSync(path8);
+  mkdirSync7(dirname13(path8), { recursive: true });
+  const db = new DatabaseSync2(path8);
   for (const sql of DURABLE_COALESCING_STATE_MIGRATIONS)
     db.exec(sql);
   db.prepare("UPDATE coalescing_outbox_entries SET status='pending' WHERE status='in_flight'").run();
@@ -113963,13 +114334,6 @@ var init_durable_coalescing_state_store = __esm(() => {
   init_durable_coalescing_state_schema();
 });
 
-// src/daemon/infrastructure/outbox/lib/outbox-retry-backoff.ts
-function computeExponentialRetryDelayMs(attempt, retryDelayMs, maxRetryDelayMs) {
-  const exponent = Math.min(Math.max(0, attempt), MAX_RETRY_EXPONENT);
-  return Math.min(retryDelayMs * 2 ** exponent, maxRetryDelayMs);
-}
-var MAX_RETRY_EXPONENT = 20;
-
 // src/daemon/infrastructure/outbox/lib/coalescing-state-outbox.ts
 function createCoalescingStateOutbox(options) {
   const durable = [options.store, options.deliveryKey, options.serialize, options.deserialize];
@@ -114146,14 +114510,6 @@ var init_keyed_coalescing_state_outbox_registry = __esm(() => {
   init_coalescing_state_outbox();
 });
 
-// src/daemon/infrastructure/outbox/outbox-db-path.ts
-import { homedir as homedir9 } from "node:os";
-import { join as join25 } from "node:path";
-function resolveOutboxDbPath(machineId, kind) {
-  return join25(homedir9(), ".chatroom", "daemon", machineId, `outbox-${kind}.sqlite`);
-}
-var init_outbox_db_path = () => {};
-
 // src/daemon/infrastructure/outbox/workspace-file-tree-checkpoint-outbox.ts
 function createWorkspaceFileTreeCheckpointOutboxRegistry(machineId, createSend, options) {
   return createKeyedCoalescingStateOutboxRegistry({
@@ -114175,193 +114531,6 @@ var init_workspace_file_tree_checkpoint_outbox = __esm(() => {
   WORKSPACE_FILE_TREE_CHECKPOINT_OUTBOX_MAX_RETRY_DELAY_MS = 5 * 60000;
 });
 
-// src/daemon/infrastructure/outbox/lib/durable-fifo-queue-schema.ts
-var DURABLE_FIFO_QUEUE_MIGRATIONS;
-var init_durable_fifo_queue_schema = __esm(() => {
-  DURABLE_FIFO_QUEUE_MIGRATIONS = [
-    `CREATE TABLE IF NOT EXISTS schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,
-    `CREATE TABLE IF NOT EXISTS fifo_outbox_entries (id INTEGER PRIMARY KEY AUTOINCREMENT, delivery_key TEXT NOT NULL, payload_json TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'pending', attempts INTEGER NOT NULL DEFAULT 0, last_error TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL)`,
-    `CREATE INDEX IF NOT EXISTS idx_fifo_outbox_pending ON fifo_outbox_entries(delivery_key, status, id)`
-  ];
-});
-
-// src/daemon/infrastructure/outbox/lib/durable-fifo-queue-store.ts
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
-import { mkdirSync as mkdirSync7 } from "node:fs";
-import { dirname as dirname13 } from "node:path";
-function openDurableFifoQueueStore(dbPath) {
-  mkdirSync7(dirname13(dbPath), { recursive: true });
-  const db = new DatabaseSync2(dbPath);
-  for (const sql of DURABLE_FIFO_QUEUE_MIGRATIONS)
-    db.exec(sql);
-  db.prepare("UPDATE fifo_outbox_entries SET status='pending', updated_at=? WHERE status='in_flight'").run(Date.now());
-  return {
-    enqueue: (key, payloadJson) => {
-      const now = Date.now();
-      return Number(db.prepare("INSERT INTO fifo_outbox_entries(delivery_key,payload_json,created_at,updated_at) VALUES(?,?,?,?) RETURNING id").get(key, payloadJson, now, now).id);
-    },
-    claimNextBatch: (key, limit) => db.prepare("UPDATE fifo_outbox_entries SET status='in_flight', attempts=attempts+1, updated_at=? WHERE id IN (SELECT id FROM fifo_outbox_entries WHERE delivery_key=? AND status='pending' ORDER BY id LIMIT ?) RETURNING id, delivery_key as deliveryKey, payload_json as payloadJson, attempts").all(Date.now(), key, limit),
-    markDone: (id3) => {
-      db.prepare("DELETE FROM fifo_outbox_entries WHERE id=?").run(id3);
-    },
-    markPending: (id3) => {
-      db.prepare("UPDATE fifo_outbox_entries SET status='pending', last_error=NULL, updated_at=? WHERE id=?").run(Date.now(), id3);
-    },
-    updatePayload: (id3, payloadJson) => {
-      db.prepare("UPDATE fifo_outbox_entries SET payload_json=?, updated_at=? WHERE id=?").run(payloadJson, Date.now(), id3);
-    },
-    markPendingRetry: (id3, error51) => {
-      db.prepare("UPDATE fifo_outbox_entries SET status='pending', last_error=?, updated_at=? WHERE id=?").run(String(error51), Date.now(), id3);
-    },
-    listPendingForRecovery: (key) => db.prepare("SELECT id, delivery_key as deliveryKey, payload_json as payloadJson, attempts FROM fifo_outbox_entries WHERE delivery_key=? AND status IN ('pending','in_flight') ORDER BY id").all(key),
-    close: () => db.close()
-  };
-}
-var init_durable_fifo_queue_store = __esm(() => {
-  init_durable_fifo_queue_schema();
-});
-
-// src/daemon/infrastructure/outbox/lib/fifo-batched-outbox.ts
-function createFifoBatchedOutbox(o) {
-  const waiters = new Map;
-  let running3;
-  let stopped = false;
-  let retryTimer;
-  let retryAttempt = 0;
-  const retryDelay = () => computeExponentialRetryDelayMs(retryAttempt++, o.retryDelayMs ?? 500, o.maxRetryDelayMs ?? 5000);
-  const scheduleRetry = () => {
-    if (!stopped && !retryTimer) {
-      retryTimer = setTimeout(() => {
-        retryTimer = undefined;
-        drain2().catch(() => {
-          return;
-        });
-      }, retryDelay());
-      retryTimer.unref?.();
-    }
-  };
-  const drain2 = async () => {
-    if (running3)
-      return running3;
-    running3 = (async () => {
-      while (true) {
-        const rows = o.store.claimNextBatch(o.deliveryKey, o.batchSize);
-        if (!rows.length)
-          break;
-        try {
-          const results = await o.send(rows.map((r) => o.deserialize(r.payloadJson)));
-          let hasRetry = false;
-          for (let i2 = 0;i2 < results.length; i2++) {
-            const item = o.deserialize(rows[i2].payloadJson);
-            const outcome = o.classifyOutcome?.(results[i2], item) ?? { kind: "success" };
-            if (outcome.kind === "retry") {
-              o.store.updatePayload(rows[i2].id, o.serialize(outcome.item));
-              o.store.markPending(rows[i2].id);
-              hasRetry = true;
-              continue;
-            }
-            o.store.markDone(rows[i2].id);
-            waiters.get(rows[i2].id)?.resolve(results[i2]);
-            waiters.delete(rows[i2].id);
-          }
-          for (let i2 = results.length;i2 < rows.length; i2++)
-            o.store.markPending(rows[i2].id);
-          if (hasRetry) {
-            scheduleRetry();
-            break;
-          }
-          retryAttempt = 0;
-        } catch (e) {
-          o.onError?.(e);
-          for (const r of rows)
-            o.store.markPendingRetry(r.id, e);
-          scheduleRetry();
-          break;
-        }
-      }
-    })().finally(() => {
-      running3 = undefined;
-    });
-    return running3;
-  };
-  const enqueue = (item) => {
-    if (stopped)
-      return Promise.reject(new Error("Outbox is stopped"));
-    const id3 = o.store.enqueue(o.deliveryKey, o.serialize(item));
-    const p = new Promise((resolve8, reject) => waiters.set(id3, { resolve: resolve8, reject }));
-    drain2().catch(() => {
-      return;
-    });
-    return p;
-  };
-  const flushNow = async () => {
-    while (o.store.listPendingForRecovery(o.deliveryKey).length) {
-      await drain2();
-    }
-  };
-  const stop4 = async () => {
-    if (stopped)
-      return;
-    if (retryTimer)
-      clearTimeout(retryTimer);
-    retryTimer = undefined;
-    await flushNow();
-    stopped = true;
-  };
-  return { enqueue, flushNow, stop: stop4 };
-}
-var init_fifo_batched_outbox = () => {};
-
-// src/daemon/infrastructure/outbox/lib/keyed-fifo-batched-outbox-registry.ts
-function createKeyedFifoBatchedOutboxRegistry(o) {
-  const boxes = new Map;
-  const get13 = (key) => {
-    let b = boxes.get(key);
-    if (!b) {
-      b = createFifoBatchedOutbox({
-        batchSize: o.batchSize,
-        send: o.createSend(key),
-        store: o.store,
-        deliveryKey: key,
-        serialize: o.serialize,
-        deserialize: o.deserialize,
-        retryDelayMs: o.retryDelayMs,
-        maxRetryDelayMs: o.maxRetryDelayMs,
-        onError: (e) => o.onError?.(key, e),
-        classifyOutcome: o.classifyOutcome
-      });
-      boxes.set(key, b);
-    }
-    return b;
-  };
-  const stop4 = async (k) => {
-    const b = boxes.get(k);
-    if (b) {
-      await b.stop();
-      boxes.delete(k);
-    }
-  };
-  return {
-    enqueue: (k, i2) => get13(k).enqueue(i2),
-    flushNow: async (k) => {
-      if (k)
-        await get13(k).flushNow();
-      else
-        for (const b of boxes.values())
-          await b.flushNow();
-    },
-    stop: stop4,
-    stopAll: async () => {
-      for (const k of [...boxes.keys()])
-        await stop4(k);
-      o.store.close();
-    }
-  };
-}
-var init_keyed_fifo_batched_outbox_registry = __esm(() => {
-  init_fifo_batched_outbox();
-});
-
 // src/daemon/infrastructure/outbox/workspace-file-tree-delta-outbox.ts
 function createWorkspaceFileTreeDeltaOutboxRegistry(machineId, createSend, options) {
   const store = openDurableFifoQueueStore(resolveOutboxDbPath(machineId, "file-tree-delta"));
@@ -114396,6 +114565,8 @@ var init_workspace_file_tree_delta_outbox = __esm(() => {
 var init_outbox = __esm(() => {
   init_workspace_file_tree_checkpoint_outbox();
   init_workspace_file_tree_delta_outbox();
+  init_agent_lifecycle_outbox();
+  init_agent_lifecycle_send();
 });
 
 // ../../services/backend/src/domain/workspace-file-tree/types.ts
@@ -115804,7 +115975,8 @@ var init_command_run_subscription = __esm(() => {
 // src/daemon/entry/task-delivery/task-delivery-logic.ts
 function isPendingAliveRunningTask(task) {
   const { agentConfig, status: status3 } = task;
-  return status3 === "pending" && agentConfig.spawnedAgentPid != null && isAgentDesiredRunning(agentConfig.desiredState);
+  const op = getNativeDeliverySession()?.agentOperationalReadModel?.get(task.chatroomId, agentConfig.role);
+  return status3 === "pending" && (agentConfig.spawnedAgentPid != null || op?.isAlive === true) && isOperationalDesiredRunning(op);
 }
 function isSlotUnavailableForPid(slot, pid, isPidAlive, now = Date.now()) {
   if (!slot) {
@@ -115847,7 +116019,8 @@ function isNativeAgentSlotDown(task, health, now = Date.now()) {
 function isNativeActiveTaskAgentDown(task, health, now) {
   if (!isNativeHarness(task.agentConfig.agentHarness))
     return false;
-  if (!isAgentDesiredRunning(task.agentConfig.desiredState))
+  const op = getNativeDeliverySession()?.agentOperationalReadModel?.get(task.chatroomId, task.agentConfig.role);
+  if (!isOperationalDesiredRunning(op))
     return false;
   if (!isNativeRevivableTaskStatus(task))
     return false;
@@ -115871,7 +116044,8 @@ function isNativePendingTaskNeedingWake(task) {
     return false;
   if (task.status !== "pending")
     return false;
-  if (isAgentDesiredRunning(task.agentConfig.desiredState))
+  const op = getNativeDeliverySession()?.agentOperationalReadModel?.get(task.chatroomId, task.agentConfig.role);
+  if (isOperationalDesiredRunning(op))
     return false;
   return Boolean(task.agentConfig.workingDir);
 }
@@ -115947,10 +116121,10 @@ function listTasksReadyForNudge(tasks, now, cooldown, getSlot) {
 }
 var PENDING_IDLE_NUDGE_MS = 15000, NUDGE_COOLDOWN_MS = 60000;
 var init_task_delivery_logic = __esm(() => {
-  init_assigned_task();
   init_check_agent_slot();
   init_predicates();
   init_agent_process_manager();
+  init_native_delivery_session_registry();
   init_native_ready_invariant();
   init_native_task_injector_logic();
 });
@@ -116050,7 +116224,7 @@ function runNativeWakeEffect(task, runtime4, effectContext2, agentMgr) {
   if (!ctx)
     return;
   const { chatroomId, agentConfig, role, workingDir, wantResume } = ctx;
-  console.log(`[TaskMonitor] native wake ${role}@${chatroomId} — desiredState=stopped with pending task ${task.taskId}`);
+  console.log(`[TaskMonitor] native wake ${role}@${chatroomId} — operational_state=stopped with pending task ${task.taskId}`);
   exports_Runtime.runFork(runtime4)(exports_Effect.gen(function* () {
     yield* agentMgr.ensureRunning({
       chatroomId,
@@ -116152,6 +116326,31 @@ var init_task_delivery_processor = __esm(() => {
   init_task_delivery_logic();
 });
 
+// src/daemon/infrastructure/agent-operational/enrich-snapshot-with-operational.ts
+function enrichSnapshotWithOperational(snapshot) {
+  const op = getNativeDeliverySession()?.agentOperationalReadModel?.get(snapshot.chatroomId, snapshot.agentConfig.role);
+  if (!op)
+    return snapshot;
+  return { ...snapshot, agentConfig: { ...snapshot.agentConfig, desiredState: isOperationalDesiredRunning(op) ? "running" : "stopped" } };
+}
+function enrichSnapshotsWithOperational(snapshots) {
+  return snapshots.map(enrichSnapshotWithOperational);
+}
+var init_enrich_snapshot_with_operational = __esm(() => {
+  init_native_delivery_session_registry();
+});
+
+// src/daemon/infrastructure/agent-operational/subscribe-machine-agent-operational-status.ts
+function subscribeMachineAgentOperationalStatus(client4, options, onRows) {
+  return client4.onUpdate(api.machines.subscribeMachineAgentOperationalStatus, { sessionId: options.sessionId, machineId: options.machineId }, (result) => {
+    if (Array.isArray(result))
+      onRows(result);
+  });
+}
+var init_subscribe_machine_agent_operational_status = __esm(() => {
+  init_api3();
+});
+
 // src/daemon/infrastructure/inbox/fetch-machine-assigned-task-snapshots.ts
 async function fetchMachineAssignedTaskSnapshots(sessionDeps, machineId) {
   const result = await sessionDeps.backend.query(api.machines.listMachineAssignedTaskSnapshots, {
@@ -116321,11 +116520,12 @@ async function handleTaskInboxUpdate(update6, deps) {
   taskSnapshotState?.applySignalPage(update6.signals, update6.snapshots);
   if (update6.snapshots.length === 0)
     return;
-  await processTasksUpdate(deps.runtime, deps.effectContext, deps.cooldown, deps.agentMgr, deps.sessionDeps, deps.machineId, "inbox-signal", { snapshots: update6.snapshots });
+  await processTasksUpdate(deps.runtime, deps.effectContext, deps.cooldown, deps.agentMgr, deps.sessionDeps, deps.machineId, "inbox-signal", { snapshots: enrichSnapshotsWithOperational(update6.snapshots) });
 }
 var init_task_inbox_delivery = __esm(() => {
   init_native_delivery_session_registry();
   init_task_delivery_processor();
+  init_enrich_snapshot_with_operational();
 });
 
 // src/daemon/infrastructure/inbox/task.ts
@@ -116435,6 +116635,10 @@ var init_task = __esm(() => {
 
 // src/daemon/entry/task-inbox-runtime.ts
 async function bootstrapMachineAssignedTaskSnapshots(deps) {
+  await deps.sessionDeps.backend.mutation(api.machines.backfillAgentOperationalStatusForMachine, {
+    sessionId: deps.sessionDeps.sessionId,
+    machineId: deps.machineId
+  });
   await deps.sessionDeps.backend.mutation(api.machines.syncMachineAssignedTaskSnapshotsMutation, {
     sessionId: deps.sessionDeps.sessionId,
     machineId: deps.machineId
@@ -116443,7 +116647,7 @@ async function bootstrapMachineAssignedTaskSnapshots(deps) {
   deps.taskSnapshotState?.replace(tasks);
   if (!tasks.length)
     return;
-  await processTasksUpdate(deps.runtime, deps.effectContext, deps.cooldown, deps.agentMgr, deps.sessionDeps, deps.machineId, "bootstrap", { snapshots: tasks });
+  await processTasksUpdate(deps.runtime, deps.effectContext, deps.cooldown, deps.agentMgr, deps.sessionDeps, deps.machineId, "bootstrap", { snapshots: enrichSnapshotsWithOperational(tasks) });
 }
 function isAbortError(error51) {
   return error51 instanceof Error && error51.name === "AbortError";
@@ -116487,13 +116691,15 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
   const abort = new AbortController;
   let stopped = false;
   const taskSnapshotState = new MachineTaskSnapshotState;
+  const agentOperationalReadModel = new AgentOperationalReadModel;
   registerNativeDeliverySession({
     runtime: runtime4,
     effectContext: effectContext2,
     agentMgr,
     sessionDeps,
     machineId: session2.machineId,
-    taskSnapshotState
+    taskSnapshotState,
+    agentOperationalReadModel
   });
   const cooldown = new RecoveryCooldown;
   let inboxUpdateInFlight = false;
@@ -116535,11 +116741,24 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
     console.warn("[TaskInbox] bootstrap failed:", error51);
     return exports_Effect.void;
   }));
+  const unsubscribeOperational = subscribeMachineAgentOperationalStatus(wsClient2, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    signal: abort.signal
+  }, (rows) => {
+    if (stopped)
+      return;
+    const changed = agentOperationalReadModel.replace(rows);
+    const snapshots = changed.flatMap(({ chatroomId, role }) => taskSnapshotState.listForRole(chatroomId, role));
+    if (snapshots.length === 0)
+      return;
+    processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, "operational-status", { snapshots: enrichSnapshotsWithOperational(snapshots) }).catch((error51) => console.warn("[TaskInbox] operational-status reconcile failed:", error51));
+  }) ?? (() => {});
   const reconcileTimer = setInterval(() => {
     if (stopped || inboxUpdateInFlight || reconcileInFlight)
       return;
     reconcileInFlight = true;
-    processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, "periodic-reconcile", { snapshots: taskSnapshotState.listAll() }).catch((error51) => {
+    processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, "periodic-reconcile", { snapshots: enrichSnapshotsWithOperational(taskSnapshotState.listAll()) }).catch((error51) => {
       console.warn("[TaskInbox] local delivery reconciliation failed:", error51);
     }).finally(() => {
       reconcileInFlight = false;
@@ -116549,6 +116768,7 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
   return {
     stop() {
       stopped = true;
+      unsubscribeOperational();
       abort.abort();
       clearInterval(reconcileTimer);
       unregisterNativeDeliverySession();
@@ -116563,6 +116783,8 @@ var init_task_inbox_runtime = __esm(() => {
   init_native_delivery_session_registry();
   init_task_delivery_processor();
   init_task_delivery_logic();
+  init_enrich_snapshot_with_operational();
+  init_subscribe_machine_agent_operational_status();
   init_fetch_machine_assigned_task_snapshots();
   init_inbox();
   init_task_inbox_delivery();
@@ -117020,6 +117242,9 @@ function createDaemonRuntime(deps) {
     shutdownWatchdog.unref?.();
     if (heartbeatTimer)
       clearInterval(heartbeatTimer);
+    await deps.agentLifecycleOutbox?.stopAll().catch(() => {
+      return;
+    });
     stopWorkers();
     await withTimeout2(exports_Effect.runPromise(exports_Effect.gen(function* () {
       const effectContext2 = yield* exports_Effect.context();
@@ -132841,7 +133066,11 @@ async function startDaemon() {
   console.log(`[daemon] Local web UI: http://127.0.0.1:${localWeb.port}/`);
   const layers = daemonSessionToLayers(init2);
   startBackgroundMachineCapabilitiesDiscovery(createStartBackgroundCapabilitiesDiscoveryDeps(layers));
-  const runtime4 = createDaemonRuntime({ wsClient: wsClient2, layers });
+  const runtime4 = createDaemonRuntime({
+    wsClient: wsClient2,
+    layers,
+    agentLifecycleOutbox: init2.agentLifecycleOutbox
+  });
   try {
     await runtime4.run();
   } finally {
@@ -134086,4 +134315,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=D3E73C85EB221DCE64756E2164756E21
+//# debugId=6F8892900A69B55764756E2164756E21