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

package/src/resources/extensions/gsd/auto-start.ts

@@ -60,12 +60,13 @@ import { getAutoWorktreePath, isInAutoWorktree, checkoutBranchWithStashGuard } f
 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";
@@ -100,6 +101,7 @@ import {
 } from "./preferences-models.js";
 import type { WorktreeLifecycle } from "./worktree-lifecycle.js";
 import { getSessionModelOverride } from "./session-model-override.js";
+import { setAutoActiveStatus } from "./auto-dashboard.js";
 
 export interface BootstrapDeps {
   shouldUseWorktreeIsolation: (basePath?: string) => boolean;
@@ -187,6 +189,40 @@ export function reconcileProjectMilestonesFromDisk(basePath: string): number {
   }
 }
 
+export function reconcileMergedMilestonesFromJournal(basePath: string): number {
+  if (!isDbAvailable()) return 0;
+
+  const mergedAtByMilestone = new Map<string, string>();
+  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;
+}
+
 /**
  * Audit for orphaned milestone branches at bootstrap.
  *
@@ -258,6 +294,7 @@ export interface OrphanAuditAction {
   message: string;
   severity: "info" | "warning";
   branch?: string;
+  mainBranch?: string;
   commitsAhead?: number;
   dirtyWorktree?: boolean;
   worktreeDirExists?: boolean;
@@ -276,6 +313,27 @@ function isBlockingStrandedWorkAction(action: OrphanAuditAction): boolean {
   return action.kind === "in-progress-stranded-work" && action.blocksAuto;
 }
 
+function strandedWorkEvidence(args: {
+  branch?: string;
+  commitsAhead: number;
+  mainBranch: string;
+  dirtyWorktree: boolean;
+}): string[] {
+  const evidence: string[] = [];
+  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: string,
   milestoneId: string,
@@ -307,18 +365,7 @@ function strandedWorkMessage(args: {
   worktreeDirExists: boolean;
   recoveryMode: StrandedWorkRecoveryMode;
 }): string {
-  const evidence: string[] = [];
-  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.`
@@ -334,6 +381,45 @@ function strandedWorkMessage(args: {
   );
 }
 
+function formatStrandedWorkRecoveryMessage(action: OrphanAuditAction): string {
+  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: OrphanAuditAction,
+  activeMilestoneId: string | null,
+): string {
+  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: string,
   _isolationMode: "worktree" | "branch" | "none",
@@ -435,6 +521,7 @@ export function auditOrphanedMilestoneBranches(
         kind: "in-progress-stranded-work",
         milestoneId,
         branch,
+        mainBranch,
         commitsAhead,
         dirtyWorktree: worktreeEvidence.dirty,
         worktreeDirExists: worktreeEvidence.dirExists,
@@ -589,6 +676,7 @@ export function auditOrphanedMilestoneBranches(
       pushAction({
         kind: "in-progress-stranded-work",
         milestoneId: m.id,
+        mainBranch,
         commitsAhead: 0,
         dirtyWorktree: true,
         worktreeDirExists: worktreeEvidence.dirExists,
@@ -1066,6 +1154,7 @@ export async function bootstrapAutoSession(
     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
@@ -1103,7 +1192,13 @@ export async function bootstrapAutoSession(
       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");
       }
@@ -1177,21 +1272,21 @@ export async function bootstrapAutoSession(
     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.`,
+          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.`,
+          formatStrandedWorkBlockerMessage(blockingStrandedRecoveryAction, state.activeMilestone.id),
           "error",
         );
         return releaseLockAndReturn();
       }
       strandedRecoveryAction = blockingStrandedRecoveryAction;
       ctx.ui.notify(
-        `Recovering stranded work for ${strandedRecoveryAction.milestoneId} before dispatching new units.`,
+        formatStrandedWorkRecoveryMessage(strandedRecoveryAction),
         "info",
       );
     }
@@ -1663,7 +1758,7 @@ export async function bootstrapAutoSession(
       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(

package/src/resources/extensions/gsd/auto-tool-tracking.ts

@@ -94,7 +94,7 @@ export function clearInFlightTools(): void {
  * 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;
 
 /**

package/src/resources/extensions/gsd/auto-unit-tool-scope.ts

@@ -1,58 +1,13 @@
 import { parseUnitId } from "./unit-id.js";
+import {
+  AUTO_UNIT_SCOPED_TOOLS,
+  getForbiddenGsdToolReason,
+} from "./unit-tool-contracts.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",
-] as const;
-
-export const AUTO_UNIT_SCOPED_TOOLS: Record<string, readonly string[]> = {
-  "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"],
-};
+export {
+  AUTO_UNIT_SCOPED_TOOLS,
+  RUN_UAT_BROWSER_TOOL_NAMES,
+} from "./unit-tool-contracts.js";
 
 const WORKFLOW_TOOL_ALIASES: Record<string, string> = {
   gsd_save_decision: "gsd_decision_save",
@@ -96,6 +51,14 @@ const SCOPED_GSD_LIFECYCLE_TOOLS = new Set(
     .map(canonicalWorkflowToolName),
 );
 
+export const GSD_PHASE_SCOPE_DISPLAY_REASON = "This GSD phase only allows its scoped workflow tools.";
+
+type AutoUnitToolScopeResult = {
+  block: boolean;
+  reason?: string;
+  displayReason?: string;
+};
+
 function stripMcpToolPrefix(toolName: string): string {
   if (!toolName.startsWith("mcp__")) return toolName;
   const toolSeparator = toolName.indexOf("__", "mcp__".length);
@@ -113,12 +76,20 @@ export function isWorkflowAliasTool(toolName: string): boolean {
 
 function hardBlockReason(unitType: string, what: string): string {
   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: string, what: string): AutoUnitToolScopeResult {
+  return {
+    block: true,
+    reason: hardBlockReason(unitType, what),
+    displayReason: GSD_PHASE_SCOPE_DISPLAY_REASON,
+  };
+}
+
 function allowedGsdToolsForUnit(unitType: string): string[] {
   return [...new Set(
     (AUTO_UNIT_SCOPED_TOOLS[unitType] ?? [])
@@ -143,7 +114,7 @@ function shouldBlockTaskCompletionScope(
   unitId: string | undefined,
   toolName: string,
   input: unknown,
-): { block: boolean; reason?: string } {
+): AutoUnitToolScopeResult {
   if (!EXECUTE_TASK_UNIT_TYPES.has(unitType)) return { block: false };
   if (canonicalWorkflowToolName(toolName) !== "gsd_task_complete") return { block: false };
   if (!unitId) return { block: false };
@@ -164,13 +135,10 @@ function shouldBlockTaskCompletionScope(
     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(
@@ -178,15 +146,12 @@ export function shouldBlockAutoUnitToolCall(
   toolName: string,
   input?: unknown,
   unitId?: string,
-): { block: boolean; reason?: string } {
+): AutoUnitToolScopeResult {
   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);
@@ -198,11 +163,16 @@ export function shouldBlockAutoUnitToolCall(
   const allowedTools = allowedGsdToolsForUnit(unitType);
   if (allowedTools.includes(canonicalTool)) return { block: false };
 
-  return {
-    block: true,
-    reason: hardBlockReason(
+  const forbiddenReason = getForbiddenGsdToolReason(unitType, canonicalTool);
+  if (forbiddenReason) {
+    return hardBlock(
       unitType,
-      `GSD lifecycle tool "${canonicalTool}" is not permitted; allowed GSD tools: ${allowedTools.length > 0 ? allowedTools.join(", ") : "(none)"}`,
-    ),
-  };
+      `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/src/resources/extensions/gsd/auto-worktree.ts

@@ -83,6 +83,11 @@ import {
   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 { type MilestoneScope, type GsdWorkspace, createWorkspace } from "./workspace.js";
 import {
@@ -1771,16 +1776,29 @@ export function mergeMilestoneToMain(
   // 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));
     }
   }
 

package/src/resources/extensions/gsd/auto.ts

@@ -205,6 +205,7 @@ import {
   updateProgressWidget as _updateProgressWidget,
   setCompletionProgressWidget,
   setAutoOutcomeWidget,
+  setAutoActiveStatus,
   updateSliceProgressCache,
   clearSliceProgressCache,
   describeNextUnit as _describeNextUnit,
@@ -254,7 +255,12 @@ import {
   postUnitPreVerification,
   postUnitPostVerification,
 } from "./auto-post-unit.js";
-import { bootstrapAutoSession, openProjectDbIfPresent, type BootstrapDeps } from "./auto-start.js";
+import {
+  bootstrapAutoSession,
+  openProjectDbIfPresent,
+  reconcileMergedMilestonesFromJournal,
+  type BootstrapDeps,
+} 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";
@@ -2102,6 +2108,28 @@ export function createWiredDispatchAdapter(
     return null;
   }
 
+  function shouldAdoptActiveMilestone(
+    state: GSDState,
+    activeSession: AutoSession | undefined,
+    activeDispatchBasePath: string,
+  ): boolean {
+    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;
@@ -2110,6 +2138,9 @@ export function createWiredDispatchAdapter(
 
       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
@@ -2280,10 +2311,20 @@ export function createWiredAutoOrchestrationModule(
       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,
           };
         }
@@ -2955,6 +2996,7 @@ export async function startAuto(
     if (!getLedger()) initMetrics(base);
     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
@@ -2991,7 +3033,7 @@ export async function startAuto(
     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.",
@@ -3320,7 +3362,7 @@ export async function dispatchHookUnit(
     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", {