gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.1b44e695b

package/dist/resources/extensions/gsd/verification-verdict.js

@@ -0,0 +1,26 @@
+// Project/App: GSD-2
+// File Purpose: Host-owned verification verdict policy for auto-mode units.
+export function decideVerificationVerdict(unitType, result) {
+    if (unitType === "execute-task" && result.discoverySource === "none" && result.checks.length === 0) {
+        return {
+            passed: false,
+            reason: "no-host-checks",
+            retryable: false,
+            failureContext: "No runnable host-owned verification command was discovered. Add project verification_commands or a runnable task-plan Verify command before completing this execute-task.",
+        };
+    }
+    if (!result.passed) {
+        return {
+            passed: false,
+            reason: "checks-failed",
+            retryable: true,
+            failureContext: "",
+        };
+    }
+    return {
+        passed: true,
+        reason: "passed",
+        retryable: false,
+        failureContext: "",
+    };
+}

package/dist/resources/extensions/gsd/workflow-manifest.js

@@ -83,6 +83,7 @@ export function snapshotState() {
             proof_level: r["proof_level"] ?? "",
             integration_closure: r["integration_closure"] ?? "",
             observability_impact: r["observability_impact"] ?? "",
+            target_repositories: JSON.parse(r["target_repositories"] || "[]"),
             sequence: toNumeric(r["sequence"], 0),
             replan_triggered_at: r["replan_triggered_at"] ?? null,
             is_sketch: toNumeric(r["is_sketch"], 0),
@@ -114,6 +115,7 @@ export function snapshotState() {
             expected_output: JSON.parse(r["expected_output"] || "[]"),
             observability_impact: r["observability_impact"] ?? "",
             full_plan_md: r["full_plan_md"] ?? "",
+            target_repositories: JSON.parse(r["target_repositories"] || "[]"),
             sequence: toNumeric(r["sequence"], 0),
             blocker_source: r["blocker_source"] ?? "",
             escalation_pending: toNumeric(r["escalation_pending"], 0),

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -322,6 +322,16 @@ function hasAskUserQuestionsTool(activeTools) {
         return toolSeparator >= 0 && toolName.slice(toolSeparator + 2) === "ask_user_questions";
     });
 }
+function hasRequiredTool(requiredTool, activeTools) {
+    return activeTools.some((toolName) => {
+        if (toolName === requiredTool)
+            return true;
+        if (!toolName.startsWith("mcp__"))
+            return false;
+        const toolSeparator = toolName.indexOf("__", "mcp__".length);
+        return toolSeparator >= 0 && toolName.slice(toolSeparator + 2) === requiredTool;
+    });
+}
 function workflowMcpStructuredQuestionsOptIn(env = process.env) {
     const value = env.GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS;
     return value === "1" || value === "true";
@@ -352,8 +362,14 @@ export function getWorkflowTransportSupportError(provider, requiredTools, option
     if (!launch) {
         return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: the GSD workflow MCP server is not configured or discoverable. Detected Claude Code model but no workflow MCP. Please run /gsd mcp init . from your project root. You can also configure GSD_WORKFLOW_MCP_COMMAND, build packages/mcp-server/dist/cli.js, or install gsd-mcp-server on PATH.`;
     }
-    const missing = [...new Set(requiredTools)].filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
+    const uniqueRequired = [...new Set(requiredTools)];
+    const missing = (options.activeTools && options.activeTools.length > 0)
+        ? uniqueRequired.filter((tool) => !hasRequiredTool(tool, options.activeTools))
+        : uniqueRequired.filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
     if (missing.length === 0)
         return null;
+    if (options.activeTools && options.activeTools.length > 0) {
+        return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: this unit requires ${missing.join(", ")}, but the active runtime toolset currently exposes only ${options.activeTools.slice().sort().join(", ")}.`;
+    }
     return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: this unit requires ${missing.join(", ")}, but the workflow MCP transport currently exposes only ${Array.from(MCP_WORKFLOW_TOOL_SURFACE).sort().join(", ")}.`;
 }

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -150,11 +150,11 @@ export function renderSummaryContent(taskRow, sliceId, milestoneId, evidence) {
     }
     // ── Frontmatter (YAML list format, matches parseSummary() expectations) ──
     const keyFilesYaml = taskRow.key_files && taskRow.key_files.length > 0
-        ? taskRow.key_files.map(f => `  - ${f}`).join("\n")
-        : "  - (none)";
+        ? `\n${taskRow.key_files.map(f => `  - ${f}`).join("\n")}`
+        : " []";
     const keyDecisionsYaml = taskRow.key_decisions && taskRow.key_decisions.length > 0
-        ? taskRow.key_decisions.map(d => `  - ${d}`).join("\n")
-        : "  - (none)";
+        ? `\n${taskRow.key_decisions.map(d => `  - ${d}`).join("\n")}`
+        : " []";
     // Derive verification_result from evidence if available
     const evidenceList = evidence ?? [];
     const allPassed = evidenceList.length > 0 &&
@@ -182,10 +182,8 @@ export function renderSummaryContent(taskRow, sliceId, milestoneId, evidence) {
 id: ${taskRow.id}
 parent: ${sliceId}
 milestone: ${milestoneId}
-key_files:
-${keyFilesYaml}
-key_decisions:
-${keyDecisionsYaml}
+key_files:${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
 duration: ${taskRow.duration || ""}
 verification_result: ${verificationResult}
 completed_at: ${taskRow.completed_at || ""}

package/dist/resources/extensions/gsd/worktree-lifecycle.js

@@ -20,6 +20,7 @@ import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { debugLog } from "./debug-logger.js";
+import { logWarning } from "./workflow-logger.js";
 import { emitJournalEvent } from "./journal.js";
 import { emitWorktreeCreated, emitWorktreeMerged } from "./worktree-telemetry.js";
 import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare, } from "./worktree-root.js";
@@ -48,6 +49,11 @@ import { nativeCheckoutBranch } from "./native-git-bridge.js";
 // is the only Module that calls them, and they live alongside the Module's
 // other primitives in `auto-worktree.ts`.
 import { autoWorktreeBranch, createAutoWorktree, enterAutoWorktree, enterBranchModeForMilestone, getAutoWorktreePath, isInAutoWorktree, teardownAutoWorktree, } from "./auto-worktree.js";
+const recentWorktreeMergeFailures = new Map();
+const MERGE_FAILURE_DEDUPE_MS = 60_000;
+export function resetRecentWorktreeMergeFailuresForTest() {
+    recentWorktreeMergeFailures.clear();
+}
 /**
  * Internal sentinel — thrown by `_mergeBranchMode` when it has already
  * emitted a user-visible error. The outer `mergeAndExit` catches the type
@@ -197,18 +203,9 @@ export function _enterMilestoneCore(s, deps, milestoneId, ctx) {
             cause: invalidMilestoneIdError(milestoneId),
         };
     }
-    if (s.isolationDegraded) {
-        debugLog("WorktreeLifecycle", {
-            action: "enterMilestone",
-            milestoneId,
-            skipped: true,
-            reason: "isolation-degraded",
-        });
-        return { ok: false, reason: "isolation-degraded" };
-    }
     // Phase B: claim a milestone lease before any worktree mutation. Two
     // workers cannot enter the same milestone concurrently. Best-effort:
-    // skip if no worker registered (single-worker fallback) or DB
+    // warn if no worker registered (single-worker fallback) or skip if DB
     // unavailable; reuse existing lease if we already hold it on this
     // milestone (re-entry within the same session).
     if (s.workerId) {
@@ -288,11 +285,43 @@ export function _enterMilestoneCore(s, deps, milestoneId, ctx) {
             }
         }
     }
+    else {
+        logWarning("worktree", `enterMilestone(${milestoneId}) ran before auto worker registration; milestone lease was not claimed.`);
+    }
     // Resolve the project root for worktree operations via shared helper.
     // Handles the case where originalBasePath is falsy and basePath is itself
     // a worktree path — prevents double-nested worktree paths (#3729).
     const basePath = resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
     const mode = getIsolationMode(basePath);
+    if (s.isolationDegraded) {
+        if (mode === "worktree") {
+            try {
+                lifecycleEnterBranchMode(deps, basePath, milestoneId);
+                s.basePath = basePath;
+                rebuildGitService(s, deps);
+                invalidateAllCaches();
+                ctx.notify(`Worktree isolation is degraded. Fell back to branch milestone/${milestoneId}.`, "warning");
+                return { ok: true, mode: "branch", path: basePath };
+            }
+            catch (err) {
+                debugLog("WorktreeLifecycle", {
+                    action: "enterMilestone",
+                    milestoneId,
+                    skipped: true,
+                    reason: "isolation-degraded",
+                    fallback: "branch-failed",
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        debugLog("WorktreeLifecycle", {
+            action: "enterMilestone",
+            milestoneId,
+            skipped: true,
+            reason: "isolation-degraded",
+        });
+        return { ok: false, reason: "isolation-degraded" };
+    }
     if (mode === "none") {
         debugLog("WorktreeLifecycle", {
             action: "enterMilestone",
@@ -477,6 +506,28 @@ function rebuildGitService(s, deps) {
     // GitService cast.
     s.gitService = deps.gitServiceFactory(s.basePath);
 }
+function emitWorktreeMergeFailedOnce(basePath, milestoneId, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const errorCategory = err instanceof Error ? err.name : "Error";
+    const now = Date.now();
+    const key = `${basePath}\0${milestoneId}\0${errorCategory}`;
+    const previous = recentWorktreeMergeFailures.get(key);
+    if (previous && now - previous < MERGE_FAILURE_DEDUPE_MS)
+        return;
+    for (const [candidate, ts] of recentWorktreeMergeFailures) {
+        if (now - ts >= MERGE_FAILURE_DEDUPE_MS) {
+            recentWorktreeMergeFailures.delete(candidate);
+        }
+    }
+    emitJournalEvent(basePath, {
+        ts: new Date().toISOString(),
+        flowId: randomUUID(),
+        seq: 0,
+        eventType: "worktree-merge-failed",
+        data: { milestoneId, error: msg },
+    });
+    recentWorktreeMergeFailures.set(key, now);
+}
 // ─── Session-less merge entry (ADR-016 phase 2 / A1) ─────────────────────
 /**
  * Worktree-mode merge body. Session-less — operates on a `MergeContext`.
@@ -590,13 +641,7 @@ function _mergeWorktreeModeImpl(deps, mctx) {
             error: msg,
             fallback: "chdir-to-project-root",
         });
-        emitJournalEvent(originalBasePath || worktreeBasePath, {
-            ts: new Date().toISOString(),
-            flowId: randomUUID(),
-            seq: 0,
-            eventType: "worktree-merge-failed",
-            data: { milestoneId, error: msg },
-        });
+        emitWorktreeMergeFailedOnce(originalBasePath || worktreeBasePath, milestoneId, err);
         // Surface a clear, actionable error. Worktree and milestone branch
         // are intentionally preserved — nothing has been deleted. User can
         // retry /gsd dispatch complete-milestone or merge manually once the
@@ -752,6 +797,9 @@ function _mergeBranchModeImpl(deps, mctx) {
 export function mergeMilestoneStandalone(deps, mctx) {
     const { originalBasePath, worktreeBasePath, milestoneId, notify } = mctx;
     validateMilestoneId(milestoneId);
+    if (!originalBasePath && !worktreeBasePath) {
+        throw new Error(`Internal error: mergeMilestoneStandalone(${milestoneId}) requires originalBasePath or worktreeBasePath.`);
+    }
     if (mctx.isolationDegraded) {
         if (originalBasePath) {
             try {
@@ -1198,17 +1246,36 @@ export class WorktreeLifecycle {
         }
     }
     /**
-     * Restore `s.basePath` to `s.originalBasePath` and rebuild `s.gitService`.
-     * No-op when `originalBasePath` is empty (fresh sessions).
+     * Restore `s.basePath` to `s.originalBasePath`, chdir process cwd, and
+     * rebuild `s.gitService`. No-op when `originalBasePath` is empty (fresh
+     * sessions).
      *
      * Used by error/cleanup paths that need the session to behave as if the
      * worktree was never entered. Does NOT teardown the worktree directory —
      * callers that need teardown go through `exitMilestone({ merge: false })`.
+     *
+     * ADR-016 phase 3 (#5693): chdir lives inside the verb so callers do not
+     * pair `restoreToProjectRoot()` with a redundant `process.chdir`. The
+     * chdir runs BEFORE the throwable work (`rebuildGitService`, cache
+     * invalidation) so that cleanup-path cwd is restored even if the
+     * downstream rebuild throws. The chdir itself is best-effort; failure is
+     * logged via debugLog and swallowed.
      */
     restoreToProjectRoot() {
         if (!this.s.originalBasePath)
             return;
         this.s.basePath = this.s.originalBasePath;
+        try {
+            process.chdir(this.s.basePath);
+        }
+        catch (err) {
+            debugLog("WorktreeLifecycle", {
+                action: "restoreToProjectRoot",
+                result: "chdir-failed",
+                basePath: this.s.basePath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
         rebuildGitService(this.s, this.deps);
         invalidateAllCaches();
     }

package/dist/resources/extensions/gsd/worktree-manager.js

@@ -177,7 +177,16 @@ export function createWorktree(basePath, name, opts = {}) {
         const gitFilePath = join(wtPath, ".git");
         if (!existsSync(gitFilePath)) {
             logWarning("reconcile", `Removing stale worktree directory (no .git file): ${wtPath}`, { worktree: name });
-            rmSync(wtPath, { recursive: true, force: true });
+            try {
+                rmSync(wtPath, { recursive: true, force: true });
+            }
+            catch (error) {
+                const code = error?.code;
+                if (code === "EPERM" || code === "EBUSY") {
+                    throw new GSDError(GSD_GIT_ERROR, `Cannot remove stale worktree directory at ${wtPath} (${code}: directory may be locked by another process). Close editors/antivirus/git tools using this path and retry.`, { cause: error });
+                }
+                throw error;
+            }
         }
         else {
             throw new GSDError(GSD_STALE_STATE, `Worktree "${name}" already exists at ${wtPath}`);
@@ -491,7 +500,7 @@ export function removeWorktree(basePath, name, opts = {}) {
             const nestedGitPath = join(nestedDir, ".git");
             try {
                 rmSync(nestedGitPath, { recursive: true, force: true });
-                logWarning("reconcile", `Removed nested .git directory from scaffolded project to prevent data loss (#2616)`, { worktree: name, nestedRepo: nestedDir });
+                logWarning("reconcile", `Removed nested .git directory from scaffolded project to prevent data loss`, { worktree: name, nestedRepo: nestedDir });
             }
             catch {
                 logWarning("reconcile", `Failed to remove nested .git directory — files may be lost as orphaned gitlink`, { worktree: name, nestedRepo: nestedDir });

package/dist/resources/extensions/gsd/worktree-safety.js

@@ -1,6 +1,7 @@
 // Project/App: GSD-2
 // File Purpose: Worktree Safety module contract for validating source-writing Unit roots.
 import { existsSync, lstatSync } from "node:fs";
+import { execFileSync } from "node:child_process";
 import { join, resolve } from "node:path";
 import { normalizeWorktreePathForCompare } from "./worktree-root.js";
 import { listWorktrees } from "./worktree-manager.js";
@@ -17,6 +18,12 @@ const defaultDeps = {
             branch: worktree.branch,
         }));
     },
+    pruneRegisteredWorktrees(projectRoot) {
+        execFileSync("git", ["worktree", "prune"], {
+            cwd: projectRoot,
+            stdio: "pipe",
+        });
+    },
     getCurrentBranch,
 };
 function isValidMilestoneId(milestoneId) {
@@ -32,6 +39,7 @@ function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 export function createWorktreeSafetyModule(deps = defaultDeps) {
+    const unregisteredRecoveryFailed = new Set();
     return {
         validateUnitRoot(input) {
             if (input.writeScope === "planning-only") {
@@ -50,9 +58,16 @@ export function createWorktreeSafetyModule(deps = defaultDeps) {
             }
             const projectRoot = resolve(input.projectRoot);
             const unitRoot = resolve(input.unitRoot);
-            const expectedRoot = join(projectRoot, ".gsd", "worktrees", milestoneId);
+            const isolationMode = input.isolationMode ?? "worktree";
+            const expectedRoot = isolationMode === "worktree"
+                ? join(projectRoot, ".gsd", "worktrees", milestoneId)
+                : projectRoot;
             if (!samePath(unitRoot, expectedRoot)) {
-                return failure("invalid-root", `Unit root ${unitRoot} is not the expected worktree root for ${milestoneId}.`, "Prepare the Unit in its canonical milestone worktree before allowing source writes.", { expectedRoot, unitRoot });
+                return failure("invalid-root", isolationMode === "worktree"
+                    ? `Unit root ${unitRoot} is not the expected worktree root for ${milestoneId}.`
+                    : `Unit root ${unitRoot} is not the project root while isolation mode is ${isolationMode}.`, isolationMode === "worktree"
+                    ? "Prepare the Unit in its canonical milestone worktree before allowing source writes."
+                    : "Run the Unit from the project root when worktree isolation is disabled.", { expectedRoot, unitRoot });
             }
             if (!deps.existsSync(unitRoot)) {
                 return failure("worktree-missing", `Worktree root ${unitRoot} does not exist.`, "Create or recover the milestone worktree before dispatching the source-writing Unit.", { unitRoot });
@@ -68,7 +83,7 @@ export function createWorktreeSafetyModule(deps = defaultDeps) {
             catch (error) {
                 return failure("worktree-git-probe-failed", `Unable to inspect .git marker for worktree root ${unitRoot}.`, "Recover or recreate the milestone worktree before dispatching the source-writing Unit.", { gitMarker, error: errorMessage(error) });
             }
-            if (!gitMarkerStat.isFile()) {
+            if (isolationMode === "worktree" && !gitMarkerStat.isFile()) {
                 return failure("worktree-git-marker-not-file", `Worktree root ${unitRoot} has a .git directory, not a registered worktree .git file.`, "Use a registered GSD worktree instead of a copied or nested repository.", { gitMarker });
             }
             let registered;
@@ -79,7 +94,31 @@ export function createWorktreeSafetyModule(deps = defaultDeps) {
                 return failure("worktree-git-probe-failed", `Unable to list registered worktrees for project root ${projectRoot}.`, "Recover or recreate the milestone worktree before dispatching the source-writing Unit.", { projectRoot, error: errorMessage(error) });
             }
             if (registered && !registered.some((worktree) => samePath(worktree.path, unitRoot))) {
-                return failure("worktree-unregistered", `Worktree root ${unitRoot} is not registered with git worktree list.`, "Recreate or re-register the milestone worktree before dispatching the source-writing Unit.", { unitRoot });
+                const wasPreviouslyTracked = unregisteredRecoveryFailed.has(unitRoot);
+                let attemptedPrune = false;
+                if (!wasPreviouslyTracked && deps.pruneRegisteredWorktrees) {
+                    attemptedPrune = true;
+                    try {
+                        deps.pruneRegisteredWorktrees(projectRoot);
+                        const rechecked = deps.listRegisteredWorktrees?.(projectRoot);
+                        if (rechecked?.some((worktree) => samePath(worktree.path, unitRoot))) {
+                            unregisteredRecoveryFailed.delete(unitRoot);
+                            registered = rechecked;
+                        }
+                        else {
+                            unregisteredRecoveryFailed.add(unitRoot);
+                        }
+                    }
+                    catch (error) {
+                        unregisteredRecoveryFailed.add(unitRoot);
+                        return failure("worktree-git-probe-failed", `Unable to recover unregistered worktree root ${unitRoot}.`, "Run 'git worktree prune', then recreate the milestone worktree before dispatching the source-writing Unit.", { projectRoot, unitRoot, error: errorMessage(error) });
+                    }
+                }
+                if (!registered?.some((worktree) => samePath(worktree.path, unitRoot))) {
+                    return failure("worktree-unregistered", `Worktree root ${unitRoot} is not registered with git worktree list.`, attemptedPrune || wasPreviouslyTracked
+                        ? "Worktree recovery was attempted but the root is still unregistered. Recreate or re-register the milestone worktree before dispatching the source-writing Unit."
+                        : "Run 'git worktree prune'. If still unregistered, recreate or re-register the milestone worktree before dispatching the source-writing Unit.", { unitRoot, attemptedPrune, trackedAsFailed: unregisteredRecoveryFailed.has(unitRoot) });
+                }
             }
             if (input.emptyWorktreeWithProjectContent) {
                 return failure("empty-worktree-with-project-content", `Worktree root ${unitRoot} has no project content, but the project root does.`, "Resolve untracked project-root content or recreate the worktree so source writes stay isolated.", { unitRoot, projectRoot });

package/dist/resources/extensions/gsd/worktree-state-projection.js

@@ -100,6 +100,34 @@ function forceOverwriteAssessmentsWithVerdict(srcMilestoneDir, dstMilestoneDir)
         logWarning("worktree", `assessment sync failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+function syncTopLevelMilestoneArtifacts(srcMilestonesDir, dstMilestonesDir) {
+    if (!existsSync(srcMilestonesDir))
+        return;
+    try {
+        for (const milestoneEntry of readdirSync(srcMilestonesDir, { withFileTypes: true })) {
+            if (!milestoneEntry.isDirectory())
+                continue;
+            const srcMilestoneDir = join(srcMilestonesDir, milestoneEntry.name);
+            const dstMilestoneDir = join(dstMilestonesDir, milestoneEntry.name);
+            try {
+                mkdirSync(dstMilestoneDir, { recursive: true });
+                for (const fileEntry of readdirSync(srcMilestoneDir, { withFileTypes: true })) {
+                    if (!fileEntry.isFile())
+                        continue;
+                    if (!fileEntry.name.endsWith(".md") && !fileEntry.name.endsWith(".json"))
+                        continue;
+                    safeCopy(join(srcMilestoneDir, fileEntry.name), join(dstMilestoneDir, fileEntry.name), { force: false });
+                }
+            }
+            catch (err) {
+                logWarning("worktree", `milestone top-level artifact sync failed (${milestoneEntry.name}): ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    catch (err) {
+        logWarning("worktree", `milestone artifact scan failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 /**
  * Root-level .gsd/ files copied from worktree back to project root for
  * post-merge diagnostics. Markdown projections are NOT in this list — DB
@@ -142,6 +170,9 @@ export function _projectRootToWorktreeImpl(projectRoot, worktreePath_, milestone
     // by validate-milestone) get clobbered by stale project root copies,
     // causing an infinite re-validation loop (#1886).
     safeCopyRecursive(join(prGsd, "milestones", milestoneId), join(wtGsd, "milestones", milestoneId), { force: false });
+    // Additively project missing top-level milestone files for all milestones
+    // so worktree-bound units can verify future-milestone context artifacts.
+    syncTopLevelMilestoneArtifacts(join(prGsd, "milestones"), join(wtGsd, "milestones"));
     // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
     // The additive-only copy above preserves worktree-local files, but
     // ASSESSMENT files are special: after run-uat writes a verdict and post-unit

package/dist/resources/extensions/gsd/worktree-telemetry.js

@@ -32,6 +32,37 @@ function baseEntry(eventType, data) {
         data,
     };
 }
+export function normalizeAutoExitReason(rawReason) {
+    const reason = rawReason ?? "stop";
+    const reasonLc = reason.toLowerCase();
+    return reasonLc.startsWith("blocked:")
+        ? "blocked"
+        : reasonLc.startsWith("merge conflict")
+            ? "merge-conflict"
+            : reasonLc.startsWith("merge error") || reasonLc.startsWith("merge failed")
+                ? "merge-failed"
+                : reasonLc.startsWith("slice-parallel dispatched")
+                    ? "stop"
+                    : reasonLc.startsWith("slice-merge-conflict")
+                        ? "slice-merge-conflict"
+                        : reasonLc.startsWith("provider error")
+                            ? "provider-error"
+                            : reasonLc.startsWith("session creation")
+                                ? "session-failed"
+                                : reasonLc.startsWith("operation aborted") || reasonLc.includes("stream aborted")
+                                    ? "stream-aborted"
+                                    : reasonLc.startsWith("auto-mode stopped")
+                                        ? "unit-aborted"
+                                        : reasonLc.includes("pausing auto-mode after") && reasonLc.includes("retries")
+                                            ? "verification-exhausted"
+                                            : reasonLc === "all milestones complete"
+                                                ? "all-complete"
+                                                : reasonLc === "no active milestone"
+                                                    ? "no-active-milestone"
+                                                    : reasonLc === "stop" || reasonLc === "pause"
+                                                        ? reasonLc
+                                                        : "other";
+}
 // ─── Emitters ────────────────────────────────────────────────────────────
 export function emitWorktreeCreated(projectRoot, milestoneId, meta = {}) {
     emitJournalEvent(projectRoot, baseEntry("worktree-created", {
@@ -68,6 +99,7 @@ export function emitWorktreeOrphaned(projectRoot, milestoneId, meta) {
 export function emitAutoExit(projectRoot, meta) {
     emitJournalEvent(projectRoot, baseEntry("auto-exit", {
         reason: meta.reason,
+        rawReason: meta.rawReason,
         flowId: meta.flowId,
         milestoneId: meta.milestoneId,
         milestoneMerged: meta.milestoneMerged,