@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.75048e7

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

package/dist/resources/extensions/gsd/auto-unit-tool-scope.js

@@ -1,56 +1,6 @@
 import { parseUnitId } from "./unit-id.js";
-export const RUN_UAT_BROWSER_TOOL_NAMES = [
-    "browser_navigate",
-    "browser_click",
-    "browser_type",
-    "browser_fill_form",
-    "browser_click_ref",
-    "browser_fill_ref",
-    "browser_wait_for",
-    "browser_assert",
-    "browser_verify",
-    "browser_screenshot",
-    "browser_snapshot_refs",
-    "browser_find",
-    "browser_get_console_logs",
-    "browser_get_network_logs",
-    "browser_evaluate",
-    "browser_reload",
-    "browser_batch",
-    "browser_act",
-];
-export const AUTO_UNIT_SCOPED_TOOLS = {
-    "research-milestone": ["gsd_summary_save", "gsd_decision_save"],
-    "plan-milestone": ["gsd_plan_milestone", "gsd_decision_save", "gsd_requirement_update"],
-    "discuss-milestone": [
-        "gsd_summary_save",
-        "gsd_decision_save",
-        "gsd_requirement_save",
-        "gsd_requirement_update",
-        "gsd_plan_milestone",
-        "gsd_milestone_generate_id",
-    ],
-    "discuss-slice": ["gsd_summary_save", "gsd_decision_save"],
-    "validate-milestone": ["gsd_validate_milestone", "gsd_reassess_roadmap", "subagent"],
-    "complete-milestone": ["gsd_complete_milestone", "subagent"],
-    "research-slice": ["gsd_summary_save", "gsd_decision_save"],
-    "plan-slice": ["gsd_plan_slice", "gsd_plan_task", "gsd_decision_save"],
-    "refine-slice": ["gsd_plan_slice", "gsd_plan_task", "gsd_decision_save"],
-    "replan-slice": ["gsd_replan_slice", "gsd_plan_task", "gsd_decision_save"],
-    "complete-slice": ["gsd_slice_complete", "gsd_task_reopen", "gsd_replan_slice", "gsd_decision_save", "gsd_requirement_update", "subagent"],
-    "reassess-roadmap": ["gsd_reassess_roadmap"],
-    "execute-task": ["gsd_task_complete", "gsd_decision_save"],
-    "execute-task-simple": ["gsd_task_complete", "gsd_decision_save"],
-    "reactive-execute": ["gsd_task_complete", "gsd_decision_save"],
-    "run-uat": ["gsd_summary_save", ...RUN_UAT_BROWSER_TOOL_NAMES],
-    "gate-evaluate": ["gsd_save_gate_result"],
-    "rewrite-docs": ["gsd_summary_save", "gsd_decision_save"],
-    "workflow-preferences": ["gsd_summary_save"],
-    "discuss-project": ["gsd_summary_save", "gsd_decision_save", "gsd_requirement_save"],
-    "discuss-requirements": ["gsd_requirement_save", "gsd_summary_save"],
-    "research-decision": ["gsd_summary_save"],
-    "research-project": ["gsd_summary_save", "gsd_decision_save"],
-};
+import { AUTO_UNIT_SCOPED_TOOLS, getForbiddenGsdToolReason, } from "./unit-tool-contracts.js";
+export { AUTO_UNIT_SCOPED_TOOLS, RUN_UAT_BROWSER_TOOL_NAMES, } from "./unit-tool-contracts.js";
 const WORKFLOW_TOOL_ALIASES = {
     gsd_save_decision: "gsd_decision_save",
     gsd_update_requirement: "gsd_requirement_update",
@@ -87,6 +37,7 @@ const SCOPED_GSD_LIFECYCLE_TOOLS = new Set([
 ]
     .filter((tool) => tool.startsWith("gsd_"))
     .map(canonicalWorkflowToolName));
+export const GSD_PHASE_SCOPE_DISPLAY_REASON = "This GSD phase only allows its scoped workflow tools.";
 function stripMcpToolPrefix(toolName) {
     if (!toolName.startsWith("mcp__"))
         return toolName;
@@ -102,11 +53,18 @@ export function isWorkflowAliasTool(toolName) {
 }
 function hardBlockReason(unitType, what) {
     return [
-        `HARD BLOCK: unit "${unitType}" is constrained by auto-unit tool scope — ${what}.`,
+        `HARD BLOCK: Tool Contract failure for unit "${unitType}" — ${what}.`,
         "This is a mechanical phase-boundary gate. You MUST NOT proceed, retry the same call,",
         "or route around this block; the orchestrator owns phase transitions.",
     ].join(" ");
 }
+function hardBlock(unitType, what) {
+    return {
+        block: true,
+        reason: hardBlockReason(unitType, what),
+        displayReason: GSD_PHASE_SCOPE_DISPLAY_REASON,
+    };
+}
 function allowedGsdToolsForUnit(unitType) {
     return [...new Set((AUTO_UNIT_SCOPED_TOOLS[unitType] ?? [])
             .filter((tool) => tool.startsWith("gsd_"))
@@ -142,20 +100,14 @@ function shouldBlockTaskCompletionScope(unitType, unitId, toolName, input) {
         actualTask === expected.task) {
         return { block: false };
     }
-    return {
-        block: true,
-        reason: hardBlockReason(unitType, `gsd_task_complete may only complete the active task ${expected.milestone}/${expected.slice}/${expected.task}; requested ${actualMilestone}/${actualSlice}/${actualTask}`),
-    };
+    return hardBlock(unitType, `gsd_task_complete may only complete the active task ${expected.milestone}/${expected.slice}/${expected.task}; requested ${actualMilestone}/${actualSlice}/${actualTask}`);
 }
 export function shouldBlockAutoUnitToolCall(unitType, toolName, input, unitId) {
     const scopedTools = AUTO_UNIT_SCOPED_TOOLS[unitType];
     if (!scopedTools)
         return { block: false };
     if (isNativeWorkflowTool(toolName)) {
-        return {
-            block: true,
-            reason: hardBlockReason(unitType, "native Workflow is not permitted inside a dispatched GSD auto-mode unit"),
-        };
+        return hardBlock(unitType, "native Workflow is not permitted inside a dispatched GSD auto-mode unit");
     }
     const taskScope = shouldBlockTaskCompletionScope(unitType, unitId, toolName, input);
     if (taskScope.block)
@@ -166,8 +118,9 @@ export function shouldBlockAutoUnitToolCall(unitType, toolName, input, unitId) {
     const allowedTools = allowedGsdToolsForUnit(unitType);
     if (allowedTools.includes(canonicalTool))
         return { block: false };
-    return {
-        block: true,
-        reason: hardBlockReason(unitType, `GSD lifecycle tool "${canonicalTool}" is not permitted; allowed GSD tools: ${allowedTools.length > 0 ? allowedTools.join(", ") : "(none)"}`),
-    };
+    const forbiddenReason = getForbiddenGsdToolReason(unitType, canonicalTool);
+    if (forbiddenReason) {
+        return hardBlock(unitType, `GSD lifecycle tool "${canonicalTool}" is not permitted; ${forbiddenReason} Fix unit-tool-contracts.ts or the ${unitType} prompt.`);
+    }
+    return hardBlock(unitType, `GSD lifecycle tool "${canonicalTool}" is not permitted; allowed GSD tools: ${allowedTools.length > 0 ? allowedTools.join(", ") : "(none)"}`);
 }

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

@@ -26,6 +26,7 @@ import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { classifyProject } from "./detection.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchForceReset, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, nativeMergeAbort, nativeWorktreeList, nativeLsFiles, } from "./native-git-bridge.js";
+import { CLOSEOUT_CONSISTENCY_BLOCKED_REASON, checkCloseoutConsistencyGate, formatCloseoutConsistencyBlock, } from "./closeout-consistency-gate.js";
 import { gsdHome } from "./gsd-home.js";
 import { createWorkspace } from "./workspace.js";
 import { _finalizeProjectionForMergeImpl, _projectRootToWorktreeImpl, _projectWorktreeToRootImpl, } from "./worktree-state-projection.js";
@@ -1513,17 +1514,29 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     // symlink layout) — ATTACHing a WAL-mode file to itself corrupts the
     // database (#2823).
     if (isDbAvailable()) {
+        const contract = resolveGsdPathContract(worktreeCwd, originalBasePath_);
+        const worktreeDbPath = join(contract.worktreeGsd ?? join(worktreeCwd, ".gsd"), "gsd.db");
+        const mainDbPath = contract.projectDb;
         try {
-            const contract = resolveGsdPathContract(worktreeCwd, originalBasePath_);
-            const worktreeDbPath = join(contract.worktreeGsd ?? join(worktreeCwd, ".gsd"), "gsd.db");
-            const mainDbPath = contract.projectDb;
+            const activeDbPath = getDbPath();
+            if (activeDbPath && _shouldReconcileWorktreeDb(activeDbPath, mainDbPath)) {
+                closeDatabase();
+                if (!openDatabase(mainDbPath)) {
+                    throw new Error(`cannot open project DB at ${mainDbPath}`);
+                }
+            }
             if (_shouldReconcileWorktreeDb(worktreeDbPath, mainDbPath)) {
                 reconcileWorktreeDb(mainDbPath, worktreeDbPath);
             }
         }
         catch (err) {
-            /* non-fatal */
-            logError("worktree", `DB reconciliation failed: ${err instanceof Error ? err.message : String(err)}`);
+            const message = `DB reconciliation failed before milestone ${milestoneId} merge: ${err instanceof Error ? err.message : String(err)}`;
+            logError("worktree", message);
+            throw new GSDError(GSD_GIT_ERROR, `${message}. Recovery reason: ${CLOSEOUT_CONSISTENCY_BLOCKED_REASON}.`);
+        }
+        const closeoutGate = checkCloseoutConsistencyGate(milestoneId);
+        if (!closeoutGate.ok) {
+            throw new GSDError(GSD_GIT_ERROR, formatCloseoutConsistencyBlock(closeoutGate));
         }
     }
     // 2. Get completed slices for commit message

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

@@ -64,7 +64,7 @@ import { initRegistry, convertDispatchRules } from "./rule-registry.js";
 import { emitJournalEvent as _emitJournalEvent } from "./journal.js";
 import { isClosedStatus } from "./status-guards.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
-import { updateProgressWidget as _updateProgressWidget, setCompletionProgressWidget, setAutoOutcomeWidget, updateSliceProgressCache, clearSliceProgressCache, unitVerb, } from "./auto-dashboard.js";
+import { updateProgressWidget as _updateProgressWidget, setCompletionProgressWidget, setAutoOutcomeWidget, setAutoActiveStatus, updateSliceProgressCache, clearSliceProgressCache, unitVerb, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
 import { isDbAvailable, getMilestone, getMilestoneSlices, getSlice, getTask, refreshOpenDatabaseFromDisk, } from "./gsd-db.js";
 import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
@@ -86,7 +86,7 @@ function makeCmuxEmitters(pi) {
 import { startUnitSupervision } from "./auto-timers.js";
 import { runPostUnitVerification } from "./auto-verification.js";
 import { autoCommitUnit, postUnitPreVerification, postUnitPostVerification, } from "./auto-post-unit.js";
-import { bootstrapAutoSession, openProjectDbIfPresent } from "./auto-start.js";
+import { bootstrapAutoSession, openProjectDbIfPresent, reconcileMergedMilestonesFromJournal, } from "./auto-start.js";
 import { initHealthWidget } from "./health-widget.js";
 import { runLegacyAutoLoop, runUokKernelLoop } from "./auto/loop.js";
 import { resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight } from "./auto/resolve.js";
@@ -1601,6 +1601,20 @@ export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath, session) {
         }
         return null;
     }
+    function shouldAdoptActiveMilestone(state, activeSession, activeDispatchBasePath) {
+        const activeMilestoneId = state.activeMilestone?.id;
+        const currentMilestoneId = activeSession?.currentMilestoneId;
+        if (!activeSession || !activeMilestoneId || !currentMilestoneId || activeMilestoneId === currentMilestoneId) {
+            return false;
+        }
+        const scopedWorktreeMilestone = (activeSession.basePath ? detectWorktreeName(activeSession.basePath) : null) ??
+            detectWorktreeName(activeDispatchBasePath);
+        if (scopedWorktreeMilestone && scopedWorktreeMilestone !== activeMilestoneId) {
+            return false;
+        }
+        const currentMilestone = state.registry.find((milestone) => milestone.id === currentMilestoneId);
+        return !!currentMilestone && isClosedStatus(currentMilestone.status);
+    }
     return {
         async decideNextUnit(input) {
             const state = input.stateSnapshot;
@@ -1609,6 +1623,9 @@ export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath, session) {
                 return null;
             const activeSession = input.session ?? session;
             const activeDispatchBasePath = activeSession?.basePath || dispatchBasePath;
+            if (activeSession && shouldAdoptActiveMilestone(state, activeSession, activeDispatchBasePath)) {
+                activeSession.currentMilestoneId = active.id;
+            }
             const prefs = loadEffectiveGSDPreferences(activeDispatchBasePath)?.preferences;
             // Derive session-derived dispatch inputs the same way phases.ts:runDispatch does
             // (#5789). Prefer caller-supplied values when present so test harnesses and
@@ -1757,10 +1774,17 @@ export function createWiredAutoOrchestrationModule(ctx, pi, dispatchBasePath, ru
             async reconcileBeforeDispatch() {
                 const activeBasePath = getLiveDispatchBasePath();
                 const result = await reconcileBeforeDispatch(activeBasePath);
-                if (result.blockers.length > 0) {
+                // Failure-path summaries written by gsd_summary_save create
+                // artifact-db-status-divergence blockers for tasks that are still
+                // pending (gsd_task_complete never ran). These tasks can still be
+                // dispatched and the drift self-heals once they complete successfully.
+                const hardBlockers = result.blockers.filter((b) => !b.includes("has SUMMARY artifact while DB status is") &&
+                    !b.includes("has SUMMARY on disk while DB status is") &&
+                    !b.includes("has task SUMMARY artifacts but no DB tasks"));
+                if (hardBlockers.length > 0) {
                     return {
                         ok: false,
-                        reason: result.blockers[0],
+                        reason: hardBlockers[0],
                         stateSnapshot: result.stateSnapshot,
                     };
                 }
@@ -2369,6 +2393,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         if (s.currentMilestoneId)
             setActiveMilestoneId(base, s.currentMilestoneId);
         await openProjectDbIfPresent(base);
+        reconcileMergedMilestonesFromJournal(base);
         registerAutoWorkerForSession(s, base);
         // Re-register health level notification callback lost across process restart
         setLevelChangeCallback((_from, to, summary) => {
@@ -2396,7 +2421,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         const loopDeps = buildLoopDeps(pi);
         ensureOrchestrationModule(ctx, pi, s.basePath || base);
         registerSigtermHandler(lockBase());
-        ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
+        setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
         ctx.ui.setWidget("gsd-health", undefined);
         ctx.ui.notify(s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "info");
         restoreHookState(s.basePath);
@@ -2641,7 +2666,7 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         resetHookState();
         await pauseAuto(ctx, pi);
     }, hookHardTimeoutMs);
-    ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
+    setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
     ctx.ui.notify(`Running post-unit hook: ${hookName}`, "info");
     debugLog("dispatchHookUnit", {
         phase: "send-message",

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -65,6 +65,9 @@ function readDetails(result) {
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- result shape varies by tool
 function formatToolErrorText(result, details) {
+    if (typeof details?.displayReason === "string" && details.displayReason) {
+        return details.displayReason;
+    }
     const message = details?.error
         ?? result?.content?.find((entry) => entry.type === "text")?.text
         ?? "unknown";
@@ -396,6 +399,88 @@ export function registerDbTools(pi) {
     };
     pi.registerTool(summarySaveTool);
     registerAlias(pi, summarySaveTool, "gsd_save_summary", "gsd_summary_save");
+    // ─── gsd_uat_result_save ─────────────────────────────────────────────────
+    const uatResultSaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executeUatResultSave } = await loadWorkflowExecutors();
+        return executeUatResultSave(params, resolveWorkflowToolBasePath(_ctx, params));
+    };
+    const uatEvidenceRef = Type.Object({
+        kind: StringEnum(["gsd_uat_exec", "gsd_exec", "screenshot", "log", "url", "browser"], { description: "Evidence kind" }),
+        ref: Type.String({ description: "Evidence ID, approved .gsd path, or URL" }),
+        note: Type.Optional(Type.String({ description: "Short evidence note" })),
+        unitType: Type.Optional(Type.String({ description: "Unit that produced the evidence" })),
+        tool: Type.Optional(Type.String({ description: "Tool that produced the evidence" })),
+        executionId: Type.Optional(Type.String({ description: "Stable execution or artifact id" })),
+    });
+    const uatCheck = Type.Object({
+        id: Type.String({ description: "Stable check ID from the UAT spec" }),
+        description: Type.String({ description: "Check description" }),
+        mode: StringEnum(["artifact", "runtime", "browser", "human-follow-up"], { description: "Evidence mode" }),
+        result: StringEnum(["PASS", "FAIL", "NEEDS-HUMAN"], { description: "Check result" }),
+        evidence: Type.Optional(Type.Array(uatEvidenceRef, { description: "Objective evidence references" })),
+        notes: Type.Optional(Type.String({ description: "Observed result, failure notes, or human instruction" })),
+        nonAutomatable: Type.Optional(Type.Boolean({ description: "True when the check is explicitly non-automatable" })),
+    });
+    const toolPresentationBlock = Type.Object({
+        surface: Type.Optional(StringEnum(["provider-tools", "claude-code-sdk", "mcp", "hybrid"], { description: "Tool presentation surface" })),
+        model: Type.Optional(Type.Object({
+            provider: Type.Optional(Type.String()),
+            api: Type.Optional(Type.String()),
+            id: Type.Optional(Type.String()),
+        })),
+        presentedTools: Type.Optional(Type.Array(Type.String(), { description: "Tool names actually presented to the model" })),
+        blockedTools: Type.Optional(Type.Array(Type.Object({
+            name: Type.String(),
+            reason: Type.String(),
+        }), { description: "Tool names blocked from the model with reasons" })),
+        aliases: Type.Optional(Type.Array(Type.Object({
+            requested: Type.String(),
+            canonical: Type.String(),
+        }))),
+        fallbackToolsUsed: Type.Optional(Type.Array(Type.String())),
+        toolPresentationPlanId: Type.Optional(Type.String()),
+        notes: Type.Optional(Type.String()),
+    });
+    const uatResultSaveTool = {
+        name: "gsd_uat_result_save",
+        label: "Save UAT Result",
+        description: "Save a structured UAT result for a slice. Validates evidence, writes the ASSESSMENT artifact, " +
+            "records attempt history, and saves the aggregate UAT gate result.",
+        promptSnippet: "Save structured UAT checks, evidence, verdict, and tool-presentation proof",
+        promptGuidelines: [
+            "Call gsd_uat_result_save once after all UAT checks have been executed.",
+            "Every PASS or FAIL check must cite objective evidence, preferably a gsd_uat_exec evidence ID.",
+            "Include the presented and blocked tool set in presentation so tool timing is auditable.",
+            "Do not use raw gsd_summary_save as a substitute for UAT results.",
+        ],
+        parameters: Type.Object({
+            milestoneId: Type.Optional(Type.String({ description: "Milestone ID (e.g. M001)" })),
+            sliceId: Type.Optional(Type.String({ description: "Slice ID (e.g. S01)" })),
+            uatType: Type.Optional(Type.String({ description: "Declared UAT mode" })),
+            verdict: Type.Optional(Type.String({ description: "Overall UAT verdict: PASS, FAIL, or PARTIAL" })),
+            checks: Type.Optional(Type.Array(uatCheck, { description: "Structured check results" })),
+            presentation: Type.Optional(toolPresentationBlock),
+            notes: Type.Optional(Type.String({ description: "Overall verdict rationale" })),
+            attempt: Type.Optional(Type.String({ description: "Attempt number or auto" })),
+            previousAttemptId: Type.Optional(Type.String({ description: "Prior attempt ID, when retrying" })),
+        }),
+        execute: uatResultSaveExecute,
+        renderCall(args, theme) {
+            let text = theme.fg("toolTitle", theme.bold("uat_result_save "));
+            text += theme.fg("accent", `${args.milestoneId ?? "?"}/${args.sliceId ?? "?"}`);
+            if (args.verdict)
+                text += theme.fg("dim", ` → ${args.verdict}`);
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, _options, theme) {
+            const d = readDetails(result);
+            if (result.isError || d?.error) {
+                return new Text(theme.fg("error", formatToolErrorText(result, d)), 0, 0);
+            }
+            return new Text(theme.fg("success", `UAT ${d?.sliceId ?? ""}: ${d?.verdict ?? "saved"}`), 0, 0);
+        },
+    };
+    pi.registerTool(uatResultSaveTool);
     // ─── gsd_milestone_generate_id (formerly gsd_generate_milestone_id) ────
     const milestoneGenerateIdExecute = async (_toolCallId, _params, _signal, _onUpdate, _ctx) => {
         try {
@@ -709,7 +794,7 @@ export function registerDbTools(pi) {
                 recommendation: Type.String({ description: "Option id the executor recommends." }),
                 recommendationRationale: Type.String({ description: "Why the recommendation — 1–2 sentences." }),
                 continueWithDefault: Type.Boolean({
-                    description: "When true, loop continues (artifact logged for later review). When false, auto-mode pauses until the user resolves via /gsd escalate resolve.",
+                    description: "When true, the recommendation is recorded as the default, but auto-mode still pauses until the user resolves via /gsd escalate resolve.",
                 }),
             }, { description: "ADR-011 Phase 2: optional escalation payload. Only honored when phases.mid_execution_escalation is true." })),
             verificationEvidence: Type.Optional(Type.Array(Type.Object({
@@ -750,7 +835,7 @@ export function registerDbTools(pi) {
             sliceTitle: Type.String({ description: "Title of the slice" }),
             oneLiner: Type.String({ description: "One-line summary of what the slice accomplished" }),
             narrative: Type.String({ description: "Detailed narrative of what happened across all tasks" }),
-            verification: Type.String({ description: "What was verified across all tasks" }),
+            verification: Type.Optional(Type.String({ description: "What was verified across all tasks — if omitted, summary records verification as passed without detail." })),
             uatContent: Type.String({ description: "UAT test content (markdown body)" }),
             // ── Enrichment metadata (optional — defaults to empty) ────────────
             deviations: Type.Optional(Type.String({ description: "Deviations from the slice plan, or 'None.'" })),
@@ -931,7 +1016,7 @@ export function registerDbTools(pi) {
         promptGuidelines: [
             "Use gsd_validate_milestone when all slices are done and the milestone needs validation before completion.",
             "Parameters: milestoneId, verdict, remediationRound, successCriteriaChecklist, sliceDeliveryAudit, crossSliceIntegration, requirementCoverage, verificationClasses (optional), verdictRationale, remediationPlan (optional).",
-            "If verification classes were planned, verificationClasses must include canonical class rows using the exact class names Contract, Integration, Operational, and UAT when present in planning.",
+            "If verification classes were planned, verificationClasses must be a complete canonical table with one row for every applicable planned class using the exact class names Contract, Integration, Operational, and UAT. Do not submit a partial table.",
             "Planned verification text marked as none/not required/not applicable/N/A (including suffixed variants such as 'not required - backend-only') is treated as not applicable and does not require a class row.",
             "If verdict is 'needs-remediation', also provide remediationPlan and use gsd_reassess_roadmap to add remediation slices to the roadmap.",
             "On success, returns validationPath where VALIDATION.md was written.",
@@ -944,7 +1029,7 @@ export function registerDbTools(pi) {
             sliceDeliveryAudit: Type.String({ description: "Markdown table auditing each slice's claimed vs delivered output" }),
             crossSliceIntegration: Type.String({ description: "Markdown describing any cross-slice boundary mismatches" }),
             requirementCoverage: Type.String({ description: "Markdown describing any unaddressed requirements" }),
-            verificationClasses: Type.Optional(Type.String({ description: "Markdown describing verification class compliance and gaps using canonical class names (Contract, Integration, Operational, UAT) for each applicable planned class" })),
+            verificationClasses: Type.Optional(Type.String({ description: "Complete markdown table describing verification class compliance and gaps; include one canonical row for every applicable planned class (Contract, Integration, Operational, UAT)" })),
             verdictRationale: Type.String({ description: "Why this verdict was chosen" }),
             remediationPlan: Type.Optional(Type.String({ description: "Remediation plan (required if verdict is needs-remediation)" })),
         }),