@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.9bb7453

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -32,7 +32,7 @@ import { isDbAvailable, getDbPath, refreshOpenDatabaseFromDisk, getTask, getSlic
 import { renderPlanCheckboxes, renderRoadmapFromDb } from "./markdown-renderer.js";
 import { parseRoadmap as parseLegacyRoadmap } from "./parsers-legacy.js";
 import { consumeSignal } from "./session-status-io.js";
-import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
+import { checkPostUnitHooks, consumeHookFailure, isRetryPending, consumeRetryTrigger, consumeGateBlock, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
 import { hasPendingCaptures, loadPendingCaptures, revertExecutorResolvedCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 import { runSafely } from "./auto-utils.js";
@@ -323,6 +323,41 @@ function stripKnownIdPrefix(value, id) {
         return raw.slice(id.length + 1).trim() || undefined;
     return raw;
 }
+function parseReactiveBatchTaskIds(unitId) {
+    const { task: batchPart } = parseUnitId(unitId);
+    if (!batchPart?.startsWith("reactive+"))
+        return [];
+    const rawIds = batchPart
+        .slice("reactive+".length)
+        .split(",")
+        .map((taskId) => taskId.trim().toUpperCase())
+        .filter(Boolean);
+    const unique = new Set();
+    for (const taskId of rawIds) {
+        unique.add(taskId);
+    }
+    return [...unique];
+}
+function dedupePaths(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (!seen.has(value)) {
+            seen.add(value);
+            result.push(value);
+        }
+    }
+    return result;
+}
+function getPlannedKeyFiles(tasks) {
+    return dedupePaths(tasks.flatMap((taskRow) => [
+        ...(taskRow.expected_output ?? []),
+        ...(taskRow.files ?? []),
+        ...(taskRow.key_files ?? []),
+    ]));
+}
+export const _parseReactiveBatchTaskIdsForTest = parseReactiveBatchTaskIds;
+export const _getPlannedKeyFilesForTest = getPlannedKeyFiles;
 function resolveVerificationFailureMarkerPath(unitType, unitId, basePath) {
     const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
@@ -402,6 +437,34 @@ async function buildTaskCommitContextForUnit(basePath, unitId) {
         issueNumber: ghIssueNumber,
     };
 }
+async function buildReactiveTaskCommitContext(_basePath, unitId) {
+    const { milestone: mid, slice: sid } = parseUnitId(unitId);
+    if (!mid || !sid || !isDbAvailable())
+        return undefined;
+    const batchTaskIds = parseReactiveBatchTaskIds(unitId);
+    if (batchTaskIds.length === 0)
+        return undefined;
+    const milestone = getMilestone(mid);
+    const slice = getSlice(mid, sid);
+    const taskRows = batchTaskIds
+        .map((tid) => getTask(mid, sid, tid))
+        .filter((taskRow) => taskRow !== null);
+    const keyFiles = getPlannedKeyFiles(taskRows);
+    if (taskRows.length === 0 || keyFiles.length === 0)
+        return undefined;
+    const taskLabel = taskRows.map((row) => row.id).join(",");
+    return {
+        taskId: `${sid}/${taskLabel}`,
+        taskDisplayId: "reactive-batch",
+        taskTitle: `Reactive batch: ${taskLabel}`,
+        milestoneId: mid,
+        milestoneTitle: stripKnownIdPrefix(milestone?.title, mid),
+        sliceId: sid,
+        sliceTitle: stripKnownIdPrefix(slice?.title, sid),
+        oneLiner: `Reactive execute for ${taskLabel}`,
+        keyFiles,
+    };
+}
 async function runPostUnitGitHubSyncIfNeeded(basePath, unit) {
     if (unit.type === "complete-milestone")
         return;
@@ -761,6 +824,9 @@ export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
         if (unitType === "execute-task") {
             taskContext = await buildTaskCommitContextForUnit(basePath, unitId);
         }
+        else if (unitType === "reactive-execute") {
+            taskContext = await buildReactiveTaskCommitContext(basePath, unitId);
+        }
         _resetHasChangesCache();
         if (LIFECYCLE_ONLY_UNITS.has(unitType)) {
             return null;
@@ -812,6 +878,22 @@ async function runCloseoutGitAction(pctx, unit, opts) {
                 targetRepositories = getTask(mid, sid, tid)?.target_repositories;
             }
         }
+        else if (turnAction === "commit" && unit.type === "reactive-execute") {
+            taskContext = await buildReactiveTaskCommitContext(s.basePath, unit.id);
+            const { milestone: mid, slice: sid } = parseUnitId(unit.id);
+            if (mid && sid && isDbAvailable()) {
+                const repositories = new Set();
+                for (const tid of parseReactiveBatchTaskIds(unit.id)) {
+                    const taskRow = getTask(mid, sid, tid);
+                    for (const repoId of taskRow?.target_repositories ?? []) {
+                        repositories.add(repoId);
+                    }
+                }
+                if (repositories.size > 0) {
+                    targetRepositories = [...repositories];
+                }
+            }
+        }
         // Invalidate the nativeHasChanges cache before auto-commit (#1853).
         // The cache has a 10-second TTL and is keyed by basePath. A stale
         // `false` result causes autoCommit to skip staging entirely.
@@ -1206,12 +1288,19 @@ export async function postUnitPreVerification(pctx, opts) {
             if (safetyConfig.enabled) {
                 const { milestone: sMid, slice: sSid, task: sTid } = parseUnitId(s.currentUnit.id);
                 // File change validation (execute-task only, after unit execution)
-                if (safetyConfig.file_change_validation && s.currentUnit.type === "execute-task" && sMid && sSid && sTid && isDbAvailable()) {
+                if (safetyConfig.file_change_validation && s.currentUnit.type === "execute-task" && sMid && sSid && sTid) {
                     try {
-                        const taskRow = getTask(sMid, sSid, sTid);
-                        if (taskRow) {
-                            const expectedOutput = taskRow.expected_output ?? [];
-                            const plannedFiles = taskRow.files ?? [];
+                        const sliceTaskRows = isDbAvailable()
+                            ? getSliceTasks(sMid, sSid).filter((t) => isClosedStatus(t.status) || t.id === sTid)
+                            : [];
+                        if (sliceTaskRows.length > 0) {
+                            const expectedOutput = getPlannedKeyFiles(sliceTaskRows.map((taskRow) => ({
+                                expected_output: taskRow.expected_output,
+                                files: taskRow.files,
+                            })));
+                            const plannedFiles = getPlannedKeyFiles(sliceTaskRows.map((taskRow) => ({
+                                files: taskRow.files,
+                            })));
                             const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles, safetyConfig.file_change_allowlist);
                             if (audit && audit.violations.length > 0) {
                                 const warnings = audit.violations.filter(v => v.severity === "warning");
@@ -1223,6 +1312,23 @@ export async function postUnitPreVerification(pctx, opts) {
                                 }
                             }
                         }
+                        else {
+                            const taskRow = getTask(sMid, sSid, sTid);
+                            if (taskRow) {
+                                const expectedOutput = taskRow.expected_output ?? [];
+                                const plannedFiles = taskRow.files ?? [];
+                                const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles, safetyConfig.file_change_allowlist);
+                                if (audit && audit.violations.length > 0) {
+                                    const warnings = audit.violations.filter(v => v.severity === "warning");
+                                    for (const v of warnings) {
+                                        logWarning("safety", `file-change: ${v.file} — ${v.reason}`);
+                                    }
+                                    if (warnings.length > 0) {
+                                        ctx.ui.notify(`Safety: ${warnings.length} unexpected file change(s) outside task plan`, "warning");
+                                    }
+                                }
+                            }
+                        }
                     }
                     catch (e) {
                         debugLog("postUnit", { phase: "safety-file-change", error: String(e) });
@@ -1754,18 +1860,25 @@ export async function postUnitPostVerification(pctx) {
     // ── Post-unit hooks ──
     if (s.currentUnit && !s.stepMode) {
         const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);
+        persistHookState(s.basePath);
         if (hookUnit) {
             if (s.currentUnit) {
                 await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
             }
-            persistHookState(s.basePath);
             return enqueueSidecar(s, ctx, { kind: "hook", unitType: hookUnit.unitType, unitId: hookUnit.unitId, prompt: hookUnit.prompt, model: hookUnit.model }, { hookName: hookUnit.hookName });
         }
+        const hookFailure = consumeHookFailure();
+        if (hookFailure) {
+            ctx.ui.notify(`Post-unit hook ${hookFailure.hookName} failed for ${hookFailure.unitId}: ${hookFailure.reason}. Pausing auto-mode.`, "warning");
+            await pauseAuto(ctx, pi);
+            return "stopped";
+        }
         // Check if a hook requested a retry of the trigger unit
         if (isRetryPending()) {
             const trigger = consumeRetryTrigger();
             if (trigger) {
-                ctx.ui.notify(`Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting task state.`, "info");
+                persistHookState(s.basePath);
+                ctx.ui.notify(`Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting trigger unit state.`, "info");
                 await s.orchestration?.retryActiveUnit({
                     unitType: trigger.unitType,
                     unitId: trigger.unitId,
@@ -1781,8 +1894,8 @@ export async function postUnitPostVerification(pctx) {
                         }
                         catch (dbErr) {
                             // DB unavailable — fail explicitly rather than silently reverting to markdown mutation.
-                            // Use 'gsd recover' to rebuild DB state from disk if needed.
-                            logError("engine", `retry state-reset failed (DB unavailable): ${dbErr.message}. Run 'gsd recover' to reconcile.`);
+                            // Use 'gsd recover --confirm' to import markdown into the DB if needed.
+                            logError("engine", `retry state-reset failed (DB unavailable): ${dbErr.message}. Run 'gsd recover --confirm' to import markdown into the DB.`);
                         }
                     }
                     // 2. Delete SUMMARY.md for the task
@@ -1812,6 +1925,17 @@ export async function postUnitPostVerification(pctx) {
                 // Fall through to normal dispatch — deriveState will re-derive the unit
             }
         }
+        const gateBlock = consumeGateBlock();
+        if (gateBlock) {
+            persistHookState(s.basePath);
+            const verdict = gateBlock.verdict ? ` verdict=${gateBlock.verdict};` : "";
+            const artifact = gateBlock.artifact ? ` artifact=${gateBlock.artifact};` : "";
+            const message = `Post-unit gate "${gateBlock.hookName}" blocked ${gateBlock.triggerUnitType} ${gateBlock.triggerUnitId}:` +
+                `${verdict}${artifact} ${gateBlock.reason}. Run /gsd status to inspect, then /gsd auto after recovery.`;
+            ctx.ui.notify(message, "warning");
+            await pauseAuto(ctx, pi);
+            return "stopped";
+        }
     }
     // ── Fast-path stop detection (#3487) ──
     // Before waiting for triage, check if any PENDING captures contain explicit

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -30,6 +30,7 @@ import { classifyProject } from "./detection.js";
 import { hasBrowserRequiredText } from "./browser-evidence.js";
 import { debugLog } from "./debug-logger.js";
 import { buildSkillActivationBlock, buildSkillDiscoveryVars } from "./skill-activation.js";
+import { findMilestoneIds } from "./milestone-ids.js";
 export { buildSkillActivationBlock, buildSkillDiscoveryVars };
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 /**
@@ -1270,7 +1271,7 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
                     if (hasVerdict(uatContent))
                         continue;
                     // Also check the ASSESSMENT file — the run-uat prompt writes the verdict
-                    // there (via gsd_summary_save artifact_type:"ASSESSMENT"), not into the
+                    // there (via gsd_uat_result_save), not into the
                     // UAT spec file. Without this check the unit re-dispatches indefinitely.
                     const assessmentFile = resolveSliceFile(base, mid, sid, "ASSESSMENT");
                     if (assessmentFile) {
@@ -1325,21 +1326,44 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
     }
     return null;
 }
-// ─── Prompt Builders ──────────────────────────────────────────────────────
-/**
- * Build a prompt for the discuss-milestone unit type.
- * Loads the guided-discuss-milestone template and inlines the CONTEXT-DRAFT
- * as a seed when present. The discussion agent interviews the user, writes
- * a full CONTEXT.md, and the phase transitions to pre-planning automatically.
- */
-export async function buildDiscussMilestonePrompt(mid, midTitle, base, structuredQuestionsAvailable = "false", { headless = false } = {}) {
-    const discussTemplates = inlineTemplate("context", "Context");
+export async function buildDiscussMilestoneInlinedContext(mid, base) {
+    const inlined = [];
+    const roadmapInline = await inlineFileOptional(resolveMilestoneFile(base, mid, "ROADMAP"), relMilestoneFile(base, mid, "ROADMAP"), "Milestone Roadmap");
+    if (roadmapInline)
+        inlined.push(roadmapInline);
+    const contextInline = await inlineFileOptional(resolveMilestoneFile(base, mid, "CONTEXT"), relMilestoneFile(base, mid, "CONTEXT"), "Milestone Context");
+    if (contextInline)
+        inlined.push(contextInline);
+    const researchInline = await inlineFileOptional(resolveMilestoneFile(base, mid, "RESEARCH"), relMilestoneFile(base, mid, "RESEARCH"), "Milestone Research");
+    if (researchInline)
+        inlined.push(researchInline);
+    const decisionsPath = resolveGsdRootFile(base, "DECISIONS");
+    if (existsSync(decisionsPath)) {
+        const decisionsContent = await loadFile(decisionsPath);
+        if (decisionsContent) {
+            inlined.push(`### Decisions Register\nSource: \`${relGsdRootFile("DECISIONS")}\`\n\n${decisionsContent.trim()}`);
+        }
+    }
+    const milestoneIds = findMilestoneIds(base);
+    const currentIndex = milestoneIds.indexOf(mid);
+    const priorMilestoneIds = currentIndex >= 0 ? milestoneIds.slice(0, currentIndex) : milestoneIds;
+    for (const priorMid of priorMilestoneIds) {
+        const summaryInline = await inlineFileOptional(resolveMilestoneFile(base, priorMid, "SUMMARY"), relMilestoneFile(base, priorMid, "SUMMARY"), `${priorMid} Prior Milestone Summary`);
+        if (summaryInline)
+            inlined.push(summaryInline);
+    }
+    return inlined.length > 0
+        ? `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`
+        : "## Inlined Context\n\n_(no milestone context files found yet — go in blind and ask broad questions)_";
+}
+export async function buildDiscussMilestonePrompt(mid, midTitle, base, structuredQuestionsAvailable = "false", { headless = false, commitInstruction = "Do not commit planning artifacts — .gsd/ is managed externally.", fastPathInstruction = "", includeDraftSeed = true, includeContextMode = true, } = {}) {
+    const contextTemplate = inlineTemplate("context", "Context");
     if (headless) {
         const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
         const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
         return loadPrompt("discuss-headless", {
             seedContext: roadmapContent ?? "",
-            inlinedTemplates: discussTemplates,
+            inlinedTemplates: contextTemplate,
             workingDirectory: base,
             milestoneId: mid,
             contextPath: relMilestoneFile(base, mid, "CONTEXT"),
@@ -1347,24 +1371,28 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
             multiMilestoneCommitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
         });
     }
-    const contextModeInstructions = renderContextModeForPrompt("discuss-milestone", base);
+    const rawInlinedContext = await buildDiscussMilestoneInlinedContext(mid, base);
+    const cappedInlinedContext = capPreamble(rawInlinedContext);
+    const discussTemplates = [cappedInlinedContext, contextTemplate].join("\n\n---\n\n");
     const basePrompt = loadPrompt("guided-discuss-milestone", {
         workingDirectory: base,
         milestoneId: mid,
         milestoneTitle: midTitle,
         inlinedTemplates: discussTemplates,
         structuredQuestionsAvailable,
-        commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
-        fastPathInstruction: "",
+        commitInstruction,
+        fastPathInstruction,
     });
-    const promptWithContextMode = prependContextModeToBlock("discuss-milestone", base, basePrompt);
+    const promptWithContextMode = includeContextMode
+        ? prependContextModeToBlock("discuss-milestone", base, basePrompt)
+        : basePrompt;
     // If a CONTEXT-DRAFT.md exists, append it as seed material
     const draftPath = resolveMilestoneFile(base, mid, "CONTEXT-DRAFT");
     const draftContent = draftPath ? await loadFile(draftPath) : null;
-    if (draftContent) {
+    if (includeDraftSeed && draftContent) {
         return `${promptWithContextMode}\n\n## Prior Discussion (Draft Seed)\n\nThe following draft was captured from a prior multi-milestone discussion. Use it as seed material — the user has already provided this context. Start with a brief reflection on what the draft covers, then probe for any gaps or open questions before writing the full CONTEXT.md.\n\n${draftContent}`;
     }
-    return contextModeInstructions ? promptWithContextMode : basePrompt;
+    return promptWithContextMode;
 }
 /**
  * Build a prompt for the workflow-preferences unit type (deep mode).
@@ -2351,6 +2379,15 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
         sliceSummaryPath,
         sliceUatPath,
         gatesToClose,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            milestoneTitle: midTitle,
+            sliceId: sid,
+            sliceTitle: sTitle,
+            extraContext: [inlinedContext],
+            unitType: "complete-slice",
+        }),
     });
 }
 export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
@@ -2531,17 +2568,26 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         if (isDbAvailable()) {
             const milestone = getMilestone(mid);
             if (milestone) {
+                const escapeCell = (value) => value.replace(/[\\|]/g, (char) => `\\${char}`).replace(/\r?\n/g, " ");
                 const classes = [];
                 if (milestone.verification_contract)
-                    classes.push(`- **Contract:** ${milestone.verification_contract}`);
+                    classes.push(`| Contract | ${escapeCell(milestone.verification_contract)} |`);
                 if (milestone.verification_integration)
-                    classes.push(`- **Integration:** ${milestone.verification_integration}`);
+                    classes.push(`| Integration | ${escapeCell(milestone.verification_integration)} |`);
                 if (milestone.verification_operational)
-                    classes.push(`- **Operational:** ${milestone.verification_operational}`);
+                    classes.push(`| Operational | ${escapeCell(milestone.verification_operational)} |`);
                 if (milestone.verification_uat)
-                    classes.push(`- **UAT:** ${milestone.verification_uat}`);
+                    classes.push(`| UAT | ${escapeCell(milestone.verification_uat)} |`);
                 if (classes.length > 0) {
-                    const verificationClasses = `### Verification Classes (from planning)\n\nThese verification tiers were defined during milestone planning. Each non-empty class must be checked for evidence during validation.\n\n${classes.join("\n")}`;
+                    const verificationClasses = [
+                        "### Verification Classes (from planning)",
+                        "",
+                        "These verification tiers were defined during milestone planning. Every row in this table must appear in `verificationClasses` with the same canonical class name.",
+                        "",
+                        "| Class | Planned Check |",
+                        "| --- | --- |",
+                        ...classes,
+                    ].join("\n");
                     inlined.push(verificationClasses);
                     trackPromptContext(contextTelemetry, "verification-classes", "inline", verificationClasses);
                 }

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -802,7 +802,7 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
             return [
                 `   1. Run \`gsd undo-task ${mid}/${sid}/${tid}\` to reset the task state`,
                 `   2. Resume auto-mode — it will re-execute the task`,
-                `   3. If the task keeps failing, run \`gsd recover\` to rebuild DB state from disk`,
+                `   3. If the task keeps failing and markdown should repopulate the DB, run \`gsd recover --confirm\``,
             ].join("\n");
         }
         case "plan-slice":
@@ -814,7 +814,7 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
                 : relSliceFile(base, mid, sid, "RESEARCH");
             return [
                 `   1. Write ${artifactRel} manually (or with the LLM in interactive mode)`,
-                `   2. Run \`gsd recover\` to rebuild DB state from disk`,
+                `   2. Run \`gsd recover --confirm\` to import the markdown into the DB`,
                 `   3. Resume auto-mode`,
             ].join("\n");
         }
@@ -824,7 +824,7 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
             return [
                 `   1. Run \`gsd reset-slice ${mid}/${sid}\` to reset the slice and all its tasks`,
                 `   2. Resume auto-mode — it will re-execute incomplete tasks and re-complete the slice`,
-                `   3. If the slice keeps failing, run \`gsd recover\` to rebuild DB state from disk`,
+                `   3. If the slice keeps failing and markdown should repopulate the DB, run \`gsd recover --confirm\``,
             ].join("\n");
         }
         case "validate-milestone": {
@@ -833,7 +833,7 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
             const artifactRel = relMilestoneFile(base, mid, "VALIDATION");
             return [
                 `   1. Write ${artifactRel} with verdict: pass`,
-                `   2. Run \`gsd recover\` to rebuild DB state from disk`,
+                `   2. Run \`gsd recover --confirm\` to import the markdown into the DB`,
                 `   3. Resume auto-mode`,
             ].join("\n");
         }

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -20,6 +20,9 @@ export function isAutoActive() {
 export function isAutoPaused() {
     return autoSession.paused;
 }
+export function isAutoCompletionStopInProgress() {
+    return autoSession.completionStopInProgress;
+}
 export function markToolStart(toolCallId, toolName) {
     markTrackedToolStart(toolCallId, autoSession.active, toolName);
 }

package/dist/resources/extensions/gsd/auto-start.js

@@ -28,12 +28,13 @@ import { getAutoWorktreePath, checkoutBranchWithStashGuard } from "./auto-worktr
 import { readResourceVersion, cleanStaleRuntimeUnits } from "./auto-worktree.js";
 import { worktreePath as getWorktreeDir, isInsideWorktreesDir } from "./worktree-manager.js";
 import { emitWorktreeOrphaned } from "./worktree-telemetry.js";
+import { queryJournal } from "./journal.js";
 import { initMetrics } from "./metrics.js";
 import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable, getMilestone, getAllMilestones, insertMilestone, openDatabase, getDbStatus } from "./gsd-db.js";
+import { isDbAvailable, getMilestone, getAllMilestones, insertMilestone, openDatabase, getDbStatus, updateMilestoneStatus } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { extractVerdict } from "./verdict-parser.js";
@@ -48,6 +49,7 @@ import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
 import { validateDirectory } from "./validate-directory.js";
 import { isCustomProvider, resolveDefaultSessionModel, resolveDynamicRoutingConfig, } from "./preferences-models.js";
 import { getSessionModelOverride } from "./session-model-override.js";
+import { setAutoActiveStatus } from "./auto-dashboard.js";
 export function resolveIsolationNoneBranchCheckout(currentBranch, integrationBranch, isolationMode, isRepo) {
     if (!isRepo || isolationMode !== "none")
         return null;
@@ -112,6 +114,40 @@ export function reconcileProjectMilestonesFromDisk(basePath) {
         return 0;
     }
 }
+export function reconcileMergedMilestonesFromJournal(basePath) {
+    if (!isDbAvailable())
+        return 0;
+    const mergedAtByMilestone = new Map();
+    for (const entry of queryJournal(basePath, { eventType: "worktree-merged" })) {
+        const data = entry.data ?? {};
+        const milestoneId = typeof data.milestoneId === "string" ? data.milestoneId : null;
+        if (!milestoneId)
+            continue;
+        if (data.conflict === true)
+            continue;
+        const endedAt = typeof data.endedAt === "string" ? data.endedAt : entry.ts;
+        const previous = mergedAtByMilestone.get(milestoneId);
+        if (!previous || endedAt > previous)
+            mergedAtByMilestone.set(milestoneId, endedAt);
+    }
+    let closed = 0;
+    for (const [milestoneId, completedAt] of mergedAtByMilestone) {
+        const existing = getMilestone(milestoneId);
+        if (!existing) {
+            insertMilestone({ id: milestoneId, title: milestoneId, status: "complete" });
+            updateMilestoneStatus(milestoneId, "complete", completedAt);
+            closed++;
+            continue;
+        }
+        if (!isClosedStatus(existing.status)) {
+            updateMilestoneStatus(milestoneId, "complete", completedAt);
+            closed++;
+        }
+    }
+    if (closed > 0)
+        invalidateAllCaches();
+    return closed;
+}
 export function decideSurvivorAction(hasSurvivorBranch, phase) {
     if (!hasSurvivorBranch)
         return "none";
@@ -129,6 +165,19 @@ export function resolveSurvivorRecoveryIsolationMode(isolationMode, phase) {
 function isBlockingStrandedWorkAction(action) {
     return action.kind === "in-progress-stranded-work" && action.blocksAuto;
 }
+function strandedWorkEvidence(args) {
+    const evidence = [];
+    if (args.branch && args.commitsAhead > 0) {
+        evidence.push(`branch ${args.branch} has ${args.commitsAhead} commit(s) ahead of ${args.mainBranch}`);
+    }
+    if (args.dirtyWorktree) {
+        evidence.push("the worktree has uncommitted changes");
+    }
+    if (evidence.length === 0) {
+        evidence.push("physical git evidence exists");
+    }
+    return evidence;
+}
 function detectWorktreeEvidence(basePath, milestoneId, hasChanges) {
     const wtDir = getWorktreeDir(basePath, milestoneId);
     const wtPath = getAutoWorktreePath(basePath, milestoneId);
@@ -148,16 +197,7 @@ function detectWorktreeEvidence(basePath, milestoneId, hasChanges) {
     };
 }
 function strandedWorkMessage(args) {
-    const evidence = [];
-    if (args.branch && args.commitsAhead > 0) {
-        evidence.push(`branch ${args.branch} has ${args.commitsAhead} commit(s) ahead of ${args.mainBranch}`);
-    }
-    if (args.dirtyWorktree) {
-        evidence.push("the worktree has uncommitted changes");
-    }
-    if (evidence.length === 0) {
-        evidence.push("physical git evidence exists");
-    }
+    const evidence = strandedWorkEvidence(args);
     const wtSuffix = args.worktreeDirExists
         ? ` Worktree directory at .gsd/worktrees/${args.milestoneId}/ holds live work.`
         : "";
@@ -168,6 +208,37 @@ function strandedWorkMessage(args) {
         wtSuffix +
         ` ${recovery} Park or discard explicitly if abandoning.`);
 }
+function formatStrandedWorkRecoveryMessage(action) {
+    const recoveryMode = action.recoveryMode === "worktree"
+        ? "existing worktree"
+        : "milestone branch";
+    const evidence = strandedWorkEvidence({
+        branch: action.branch,
+        commitsAhead: action.commitsAhead ?? 0,
+        mainBranch: action.mainBranch ?? "main",
+        dirtyWorktree: action.dirtyWorktree ?? false,
+    });
+    const wtSuffix = action.worktreeDirExists
+        ? ` Worktree directory at .gsd/worktrees/${action.milestoneId}/ holds live work.`
+        : "";
+    return (`Resuming saved milestone work for ${action.milestoneId}: ${evidence.join("; ")}.` +
+        wtSuffix +
+        ` Adopting the ${recoveryMode} before dispatching new units. Park or discard explicitly if abandoning.`);
+}
+function formatStrandedWorkBlockerMessage(action, activeMilestoneId) {
+    const target = action.milestoneId;
+    const mode = action.recoveryMode === "worktree" ? "existing worktree" : "milestone branch";
+    const intro = activeMilestoneId
+        ? `Stranded work for ${target} blocks auto-mode before ${activeMilestoneId}.`
+        : `Stranded work for ${target} blocks auto-mode, but that milestone is not active in project state.`;
+    return [
+        intro,
+        "Choose one explicit next step:",
+        `1. Recover it: run \`/gsd auto ${target}\` to adopt the ${mode}.`,
+        `2. Defer it: run \`/gsd park ${target} "reason"\`, then rerun \`/gsd auto\`.`,
+        `3. Abandon it: run \`/gsd rethink\` and explicitly discard ${target}.`,
+    ].join("\n");
+}
 export function auditOrphanedMilestoneBranches(basePath, _isolationMode, gitDeps = {}) {
     const recovered = [];
     const warnings = [];
@@ -258,6 +329,7 @@ export function auditOrphanedMilestoneBranches(basePath, _isolationMode, gitDeps
                 kind: "in-progress-stranded-work",
                 milestoneId,
                 branch,
+                mainBranch,
                 commitsAhead,
                 dirtyWorktree: worktreeEvidence.dirty,
                 worktreeDirExists: worktreeEvidence.dirExists,
@@ -413,6 +485,7 @@ export function auditOrphanedMilestoneBranches(basePath, _isolationMode, gitDeps
             pushAction({
                 kind: "in-progress-stranded-work",
                 milestoneId: m.id,
+                mainBranch,
                 commitsAhead: 0,
                 dirtyWorktree: true,
                 worktreeDirExists: worktreeEvidence.dirExists,
@@ -806,6 +879,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         await openProjectDbIfPresent(base);
         registerAutoWorkerForSession(base);
         reconcileProjectMilestonesFromDisk(base);
+        reconcileMergedMilestonesFromJournal(base);
         // Clean stale runtime unit files for completed milestones (#887).
         // DB-authoritative: when DB is available, require DB status to be closed
         // before clearing runtime units. A SUMMARY file alone is no longer
@@ -840,7 +914,12 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             for (const msg of auditResult.recovered) {
                 ctx.ui.notify(`Orphan audit: ${msg}`, "info");
             }
+            const deferredStrandedMessages = new Set(auditResult.actions
+                .filter(isBlockingStrandedWorkAction)
+                .map((action) => action.message));
             for (const msg of auditResult.warnings) {
+                if (deferredStrandedMessages.has(msg))
+                    continue;
                 const prefix = msg.startsWith("Stranded work") ? "" : "Orphan audit: ";
                 ctx.ui.notify(`${prefix}${msg}`, "warning");
             }
@@ -900,15 +979,15 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             : strandedRecoveryAction;
         if (blockingStrandedRecoveryAction) {
             if (!state.activeMilestone) {
-                ctx.ui.notify(`Stranded work for ${blockingStrandedRecoveryAction.milestoneId} blocks auto-mode, but that milestone is not active in project state. Park or discard it explicitly before continuing.`, "error");
+                ctx.ui.notify(formatStrandedWorkBlockerMessage(blockingStrandedRecoveryAction, null), "error");
                 return releaseLockAndReturn();
             }
             if (state.activeMilestone.id !== blockingStrandedRecoveryAction.milestoneId) {
-                ctx.ui.notify(`Stranded work for ${blockingStrandedRecoveryAction.milestoneId} blocks auto-mode before ${state.activeMilestone.id}. Recover, park, or discard ${blockingStrandedRecoveryAction.milestoneId} explicitly before continuing.`, "error");
+                ctx.ui.notify(formatStrandedWorkBlockerMessage(blockingStrandedRecoveryAction, state.activeMilestone.id), "error");
                 return releaseLockAndReturn();
             }
             strandedRecoveryAction = blockingStrandedRecoveryAction;
-            ctx.ui.notify(`Recovering stranded work for ${strandedRecoveryAction.milestoneId} before dispatching new units.`, "info");
+            ctx.ui.notify(formatStrandedWorkRecoveryMessage(strandedRecoveryAction), "info");
         }
         if (process.env.GSD_HEADLESS === "1" &&
             orphanAuditRecovered &&
@@ -1293,7 +1372,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         if (resolveSkillDiscoveryMode(base) !== "off") {
             snapshotSkills();
         }
-        ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
+        setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
         ctx.ui.setWidget("gsd-health", undefined);
         const modeLabel = s.stepMode ? "Step-mode" : "Auto-mode";
         const pendingCount = (state.registry ?? []).filter((m) => m.status !== "complete" && m.status !== "parked").length;

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -83,7 +83,7 @@ export function clearInFlightTools() {
  * from the tool handler. When these errors occur, retrying the same unit will
  * produce the same failure, so the retry loop must be broken.
  */
-const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Expected ',' or '\}'(?: after property value)?(?: in JSON)?|Unexpected end of JSON|Unexpected token.*in JSON|does not provide an export named|Named export .* not found|Cannot find module|ERR_MODULE_NOT_FOUND|ERR_MODULE_NOT_EXPORTED|ERR_PACKAGE_PATH_NOT_EXPORTED/i;
+const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Input validation error|Invalid arguments for tool|MCP error -32602|No such tool available|Expected ',' or '\}'(?: after property value)?(?: in JSON)?|Unexpected end of JSON|Unexpected token.*in JSON|does not provide an export named|Named export .* not found|Cannot find module|ERR_MODULE_NOT_FOUND|ERR_MODULE_NOT_EXPORTED|ERR_PACKAGE_PATH_NOT_EXPORTED/i;
 const DETERMINISTIC_POLICY_ERROR_RE = /(?:^|\b)(?:HARD BLOCK:|Blocked: \/gsd queue is a planning tool|Direct writes to \.gsd\/STATE\.md and \.gsd\/gsd\.db are blocked|This is a mechanical gate)/i;
 /**
  * Returns true if the error message indicates a deterministic invocation or