@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.b1abb545

package/src/resources/extensions/gsd/auto/loop-deps.ts

@@ -7,6 +7,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 
 import type { AutoSession } from "./session.js";
+import type { AutoTerminalOutcome } from "./contracts.js";
 import type { ErrorContext } from "./types.js";
 import type { GSDPreferences } from "../preferences.js";
 import type { GSDState } from "../types.js";
@@ -33,6 +34,7 @@ export interface StopAutoOptions {
     milestoneTitle?: string | null;
     allMilestonesComplete?: boolean;
   };
+  terminalOutcome?: AutoTerminalOutcome;
   /**
    * Foreground closeout-boundary stops already have the useful final surface in
    * the transcript. Preserve it instead of installing a replacement widget.

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

@@ -3,7 +3,7 @@
 /**
  * auto/loop.ts — Main auto-mode execution loop.
  *
- * Iterates: derive → dispatch → guards → runUnit → finalize → repeat.
+ * Iterates: orchestration.advance → guards → runUnit → finalize → repeat.
  * Exits when s.active becomes false or a terminal condition is reached.
  *
  * Imports from: auto/types, auto/resolve, auto/phases
@@ -15,6 +15,7 @@ import { randomUUID } from "node:crypto";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { AutoSession } from "./session.js";
+import type { AutoTerminalOutcome } from "./contracts.js";
 import type { LoopDeps, StopAutoOptions } from "./loop-deps.js";
 import type { GSDState } from "../types.js";
 import {
@@ -24,13 +25,7 @@ import {
   type IterationData,
 } from "./types.js";
 import { _clearCurrentResolve } from "./resolve.js";
-import {
-  runPreDispatch,
-  runDispatch,
-  runGuards,
-  runFinalize,
-  STUCK_WINDOW_SIZE,
-} from "./phases.js";
+import { runGuards, runFinalize, STUCK_WINDOW_SIZE } from "./phases.js";
 import { debugLog } from "../debug-logger.js";
 import { isInfrastructureError, isTransientCooldownError, getCooldownRetryAfterMs, COOLDOWN_FALLBACK_WAIT_MS, MAX_COOLDOWN_RETRIES } from "./infra-errors.js";
 import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
@@ -146,6 +141,25 @@ function resolveCompletionStopFromState(
   };
 }
 
+function resolveCompletionStopFromOutcome(
+  outcome: AutoTerminalOutcome | undefined,
+  stateSnapshot: GSDState | undefined,
+): { reason: string; options: StopAutoOptions } | null {
+  if (outcome?.code !== "all-complete") return null;
+  const completedMilestone = stateSnapshot?.lastCompletedMilestone ?? stateSnapshot?.activeMilestone;
+  return {
+    reason: outcome.displayReason,
+    options: {
+      completionWidget: {
+        milestoneId: completedMilestone?.id ?? null,
+        milestoneTitle: completedMilestone?.title ?? null,
+        allMilestonesComplete: true,
+      },
+      terminalOutcome: outcome,
+    },
+  };
+}
+
 // ── Stuck detection persistence (#3704) ──────────────────────────────────
 // Phase C migration: stuck-state.json deleted in favor of DB-backed
 // equivalents. recentUnits is rebuilt from unit_dispatches (Phase B
@@ -158,6 +172,8 @@ function resolveCompletionStopFromState(
 // tolerates — same behavior as a fresh session.
 const STUCK_RECOVERY_ATTEMPTS_KEY = "stuck_recovery_attempts";
 const MAX_CONSECUTIVE_ALREADY_ACTIVE_SKIPS = 3;
+const ORCHESTRATION_MISSING_REASON =
+  "Auto Orchestration Module is not wired; cannot dispatch built-in GSD Unit.";
 
 function stableStuckStateScopeId(s: AutoSession): string {
   return normalizeRealPath(s.scope?.workspace.projectRoot ?? (s.originalBasePath || s.basePath));
@@ -353,9 +369,9 @@ function closeOutCrashedUnit(s: AutoSession, iterData: IterationData, err: unkno
 }
 
 /**
- * Main auto-mode execution loop. Iterates: derive → dispatch → guards →
- * runUnit → finalize → repeat. Exits when s.active becomes false or a
- * terminal condition is reached.
+ * Main auto-mode execution loop. Iterates: orchestration.advance → guards →
+ * runUnit → finalize → repeat. Exits when s.active becomes false or a terminal
+ * condition is reached.
  *
  * This is the linear replacement for the recursive
  * dispatchNextUnit → resolveAgentEnd → dispatchNextUnit chain.
@@ -572,10 +588,9 @@ export async function autoLoop(
       let iterData: IterationData;
 
       // ── Custom engine path ──────────────────────────────────────────────
-      // When activeEngineId is a non-dev value, bypass runPreDispatch and
-      // runDispatch entirely — the custom engine drives its own state via
-      // GRAPH.yaml. Shares runGuards and runUnitPhase with the dev path.
-      // After unit execution, verifies then reconciles via the engine layer.
+      // When activeEngineId is a non-dev value, the custom engine drives its own
+      // state via GRAPH.yaml. It shares guards and Unit execution with the dev
+      // path, then verifies and reconciles via the engine layer.
       //
       // GSD_ENGINE_BYPASS=1 skips the engine layer entirely — falls through
       // to the dev path below.
@@ -656,7 +671,7 @@ export async function autoLoop(
         observedUnitType = iterData.unitType;
         observedUnitId = iterData.unitId;
 
-        // ── Progress widget (mirrors dev path in runDispatch) ──
+        // ── Progress widget (mirrors the dev path) ──
         deps.updateProgressWidget(ctx, iterData.unitType, iterData.unitId, iterData.state);
 
         // ── Guards (shared with dev path) ──
@@ -876,14 +891,22 @@ export async function autoLoop(
 
           if (orchestrationResult.kind === "blocked") {
             s.pendingOrchestrationDispatch = null;
+            const blockMessage = orchestrationResult.terminalOutcome?.code === "settlement-blocked"
+              ? [
+                  orchestrationResult.terminalOutcome.displayReason,
+                  `Next: ${orchestrationResult.terminalOutcome.nextAction}`,
+                ].join("\n")
+              : orchestrationResult.reason;
             if (orchestrationResult.action === "pause") {
               await deps.pauseAuto(ctx, pi, {
-                message: orchestrationResult.reason,
+                message: blockMessage,
                 category: "unknown",
+              }, {
+                expectedCurrentUnit: null,
               });
               finishTurn("paused", "manual-attention", "orchestration-blocked");
             } else {
-              await deps.stopAuto(ctx, pi, orchestrationResult.reason);
+              await deps.stopAuto(ctx, pi, blockMessage);
               finishTurn("stopped", "manual-attention", "orchestration-blocked");
             }
             finishIncompleteIteration({
@@ -894,8 +917,20 @@ export async function autoLoop(
             break;
           }
 
+          if (orchestrationResult.kind === "skipped") {
+            s.pendingOrchestrationDispatch = null;
+            emitIterationEnd({ skipped: true });
+            completeIteration();
+            finishTurn("skipped");
+            continue;
+          }
+
           if (orchestrationResult.kind === "paused") {
             s.pendingOrchestrationDispatch = null;
+            finishIncompleteIteration({
+              status: "paused",
+              reason: orchestrationResult.reason,
+            });
             finishTurn("skipped");
             continue;
           }
@@ -917,7 +952,11 @@ export async function autoLoop(
 
           if (orchestrationResult.kind === "stopped") {
             s.pendingOrchestrationDispatch = null;
-            const completionStop = resolveCompletionStopFromState(orchestrationResult.stateSnapshot);
+            let completionStop = resolveCompletionStopFromOutcome(
+              orchestrationResult.terminalOutcome,
+              orchestrationResult.stateSnapshot,
+            );
+            completionStop ??= resolveCompletionStopFromState(orchestrationResult.stateSnapshot);
             if (completionStop) {
               await deps.stopAuto(ctx, pi, completionStop.reason, completionStop.options);
             } else {
@@ -998,54 +1037,37 @@ export async function autoLoop(
           });
           observedUnitType = iterData.unitType;
           observedUnitId = iterData.unitId;
-        } else {
-          const preDispatchResult = await runPreDispatch(ic, loopState);
-          phaseReporter.report("pre-dispatch", preDispatchResult.action);
-          if (preDispatchResult.action === "break") {
-            finishTurn("stopped", "manual-attention", "pre-dispatch-break");
+
+          const guardMilestoneId = iterData.mid ?? s.currentMilestoneId ?? "workflow";
+          const guardsResult = await runGuards(ic, guardMilestoneId);
+          phaseReporter.report("guard", guardsResult.action, {
+            unitType: iterData.unitType,
+            unitId: iterData.unitId,
+          });
+          if (guardsResult.action === "break") {
+            finishTurn("stopped", "manual-attention", "guard-break");
             finishIncompleteIteration({
               status: "stopped",
-              reason: "pre-dispatch-break",
+              reason: "guard-break",
+              unitType: iterData.unitType,
+              unitId: iterData.unitId,
               failureClass: "manual-attention",
             });
             break;
           }
-          if (preDispatchResult.action === "continue") {
-            emitIterationEnd({ skipped: true });
-            completeIteration();
-            finishTurn("skipped");
-            continue;
-          }
-          if (preDispatchResult.action === "retry") {
-            finishTurn("retry", "execution", preDispatchResult.reason);
-            continue;
-          }
-          const preData = preDispatchResult.data;
-          const guardsResult = await runGuards(ic, preData.mid);
-          phaseReporter.report("guard", guardsResult.action);
-          if (guardsResult.action === "break") {
-            finishTurn("stopped", "manual-attention", "guard-break");
-            break;
-          }
-          const dispatchResult = await runDispatch(ic, preData, loopState);
-          phaseReporter.report("dispatch", dispatchResult.action);
-          if (dispatchResult.action === "break") {
-            finishTurn("stopped", "manual-attention", "dispatch-break");
-            break;
-          }
-          if (dispatchResult.action === "continue") {
-            emitIterationEnd({ skipped: true });
-            completeIteration();
-            finishTurn("skipped");
-            continue;
-          }
-          if (dispatchResult.action === "retry") {
-            finishTurn("retry", "execution", dispatchResult.reason);
-            continue;
-          }
-          iterData = dispatchResult.data;
-          observedUnitType = iterData.unitType;
-          observedUnitId = iterData.unitId;
+        } else {
+          s.pendingOrchestrationDispatch = null;
+          await deps.pauseAuto(ctx, pi, {
+            message: ORCHESTRATION_MISSING_REASON,
+            category: "unknown",
+          });
+          finishTurn("paused", "manual-attention", "orchestration-missing");
+          finishIncompleteIteration({
+            status: "paused",
+            reason: ORCHESTRATION_MISSING_REASON,
+            failureClass: "manual-attention",
+          });
+          break;
         }
       } else {
         iterData = await buildSidecarIterationData({

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

@@ -12,11 +12,13 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 
-import type { AutoAdvanceResult, AutoOrchestrationModule, AutoSessionContext, AutoStatus } from "./contracts.js";
+import type { AutoAdvanceResult, AutoOrchestrationModule, AutoSessionContext, AutoStatus, AutoTerminalOutcome } from "./contracts.js";
 import type { AutoSession, PendingOrchestrationDispatch } from "./session.js";
 import type { GSDState } from "../types.js";
 import type { MinimalModelRegistry } from "../context-budget.js";
 
+type BlockedAdvanceResult = Extract<AutoAdvanceResult, { kind: "blocked" }>;
+
 import { debugCount, debugTime } from "../debug-logger.js";
 import { reconcileBeforeDispatch } from "../state-reconciliation.js";
 import { resolveDispatch } from "../auto-dispatch.js";
@@ -36,13 +38,20 @@ import { getSessionLockStatus } from "../session-lock.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { emitJournalEvent as _emitJournalEvent } from "../journal.js";
 import { loadEffectiveGSDPreferences, getIsolationMode } from "../preferences.js";
-import { detectWorktreeName, resolveProjectRoot } from "../worktree.js";
+import {
+  detectWorktreeName,
+  getMainBranch,
+  resolveProjectRoot,
+  resolveWorktreeProjectRoot,
+} from "../worktree.js";
+import { getPriorSliceCompletionBlocker } from "../dispatch-guard.js";
 import { GitServiceImpl } from "../git-service.js";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import { WorktreeLifecycle } from "../worktree-lifecycle.js";
+import { createMilestoneMergeTransaction } from "../milestone-merge-transaction.js";
 import { createWorkspace, scopeMilestone } from "../workspace.js";
 import { supportsStructuredQuestions } from "../workflow-mcp.js";
-import { getToolBaselineSnapshot } from "../auto-model-selection.js";
+import { getRegisteredToolSnapshot, getToolBaselineSnapshot } from "../auto-model-selection.js";
 import { deriveState } from "../state.js";
 import { parseUnitId } from "../unit-id.js";
 import { isClosedStatus } from "../status-guards.js";
@@ -50,12 +59,13 @@ import {
   isDbAvailable,
   getSlice,
   getTask,
-  refreshOpenDatabaseFromDisk,
 } from "../gsd-db.js";
+import { refreshWorkflowDatabaseFromDisk } from "../db-workspace.js";
 import { getErrorMessage } from "../error-utils.js";
 import { logWarning } from "../workflow-logger.js";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { evaluateAllCompleteSettlement } from "../milestone-settlement.js";
 
 function now(): number {
   return Date.now();
@@ -71,11 +81,19 @@ function now(): number {
  */
 export const STUCK_WINDOW_SIZE = 6;
 
-function noRemainingUnitsReason(stateSnapshot: GSDState): string {
+function noRemainingUnitsOutcome(stateSnapshot: GSDState): AutoTerminalOutcome {
   if (stateSnapshot.phase === "complete") {
-    return "all milestones complete";
+    return {
+      code: "all-complete",
+      displayReason: "All milestones complete",
+      allMilestonesComplete: true,
+    };
   }
-  return "no remaining units";
+  return {
+    code: "no-remaining-units",
+    displayReason: "No remaining units",
+    allMilestonesComplete: false,
+  };
 }
 
 /**
@@ -118,7 +136,7 @@ export interface DispatchDecisionInput {
 
 function getAlreadyClosedDispatchReason(unitType: string, unitId: string): string | null {
   if (!isDbAvailable()) return null;
-  refreshOpenDatabaseFromDisk();
+  refreshWorkflowDatabaseFromDisk();
   const { milestone, slice, task } = parseUnitId(unitId);
   if (unitType === "execute-task" && milestone && slice && task) {
     const row = getTask(milestone, slice, task);
@@ -201,6 +219,7 @@ export async function decideOrchestratorDispatch(
   // active set may be narrowed by the prior unit before selectAndApplyModel
   // restores it, causing false transport-preflight failures (#477 follow-up).
   const activeTools = getToolBaselineSnapshot(pi);
+  const registeredTools = getRegisteredToolSnapshot(pi);
   // Mirrors runDispatch: deep-planning keeps approval gates in plain chat
   // because structured questions can be cancelled outside the chat turn on
   // some transports.
@@ -248,6 +267,7 @@ export async function decideOrchestratorDispatch(
     sessionProvider,
     modelRegistry,
     activeTools,
+    registeredTools,
     sessionAuthMode: authMode,
     sessionBaseUrl: ctx.model?.baseUrl,
   });
@@ -532,6 +552,55 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
     return decideOrchestratorDispatch(this.ctx, this.pi, this.dispatchBasePath, this.s, input);
   }
 
+  private evaluateNoRemainingUnitsSettlement(stateSnapshot: GSDState): BlockedAdvanceResult | null {
+    const settlement = evaluateAllCompleteSettlement({
+      milestoneId: this.s.currentMilestoneId ?? stateSnapshot.activeMilestone?.id,
+      statePhase: stateSnapshot.phase,
+      basePath: this.s.basePath || this.getLiveDispatchBasePath(),
+      originalBasePath: this.s.originalBasePath || this.runtimeBasePath,
+      milestoneMerged: this.s.milestoneMergedInPhases,
+    });
+    this.s.milestoneSettlement = settlement;
+    if (settlement.ok) return null;
+    return {
+      kind: "blocked",
+      reason: settlement.message,
+      action: settlement.action,
+      stateSnapshot,
+      terminalOutcome: {
+        code: "settlement-blocked",
+        displayReason: settlement.message,
+        nextAction: settlement.nextAction,
+        milestoneId: settlement.milestoneId,
+        allMilestonesComplete: false,
+      },
+    };
+  }
+
+  private clearPendingDispatch(): void {
+    this.s.pendingOrchestrationDispatch = null;
+  }
+
+  private findPriorSliceCompletionBlocker(unitType: string, unitId: string): string | null {
+    const guardBasePath = resolveWorktreeProjectRoot(
+      this.getLiveDispatchBasePath(),
+      this.s.originalBasePath,
+    );
+    let mainBranch = "main";
+    try {
+      mainBranch = getMainBranch(guardBasePath);
+    } catch (err) {
+      // Preserve legacy dispatch behavior: fall back to main when branch
+      // discovery fails, then let the guard make the progression decision.
+      logWarning(
+        "engine",
+        `branch discovery failed, falling back to main: ${getErrorMessage(err)}`,
+        { file: "orchestrator.ts" },
+      );
+    }
+    return getPriorSliceCompletionBlocker(guardBasePath, mainBranch, unitType, unitId);
+  }
+
   // ── ToolContractAdapter (folded) ─────────────────────────────────────────
 
   private compileUnitToolContract(unitType: string): { ok: true; reason: string } | { ok: false; reason: string } {
@@ -554,7 +623,7 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
         return new GitServiceImpl(basePath, gitConfig);
       },
       worktreeProjection: new WorktreeStateProjection(),
-      mergeMilestoneToMain,
+      mergeMilestoneToMain: createMilestoneMergeTransaction(mergeMilestoneToMain),
     });
   }
 
@@ -809,10 +878,23 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
 
       const decision = await this.decideNextUnit({ stateSnapshot: reconciliation.stateSnapshot });
       if (!decision) {
+        const settlementBlock = this.evaluateNoRemainingUnitsSettlement(reconciliation.stateSnapshot);
+        if (settlementBlock) {
+          this.status.phase = "paused";
+          this.status.activeUnit = undefined;
+          this.lastAdvanceKey = null;
+          this.dispatchKeyWindow = [];
+          this.bumpTransition();
+          this.journalTransition({ name: "advance-blocked", reason: settlementBlock.reason });
+          this.postAdvanceRecord(settlementBlock);
+          return settlementBlock;
+        }
+        const terminalOutcome = noRemainingUnitsOutcome(reconciliation.stateSnapshot);
         const stopped: AutoAdvanceResult = {
           kind: "stopped",
-          reason: noRemainingUnitsReason(reconciliation.stateSnapshot),
+          reason: terminalOutcome.displayReason,
           stateSnapshot: reconciliation.stateSnapshot,
+          terminalOutcome,
         };
         this.status.phase = "stopped";
         this.status.activeUnit = undefined;
@@ -848,6 +930,25 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
         return blocked;
       }
 
+      const priorSliceBlocker = this.findPriorSliceCompletionBlocker(decision.unitType, decision.unitId);
+      if (priorSliceBlocker) {
+        this.clearPendingDispatch();
+        const blocked: AutoAdvanceResult = {
+          kind: "blocked",
+          reason: priorSliceBlocker,
+          action: "stop",
+          stateSnapshot: reconciliation.stateSnapshot,
+        };
+        this.journalTransition({
+          name: "advance-blocked",
+          reason: blocked.reason,
+          unitType: decision.unitType,
+          unitId: decision.unitId,
+        });
+        this.postAdvanceRecord(blocked);
+        return blocked;
+      }
+
       const nextKey = `${decision.unitType}:${decision.unitId}`;
 
       // Record every dispatch decision in the ring buffer before pre-flight
@@ -865,8 +966,10 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
         // actually completed on disk with a stale DB. Verify + recover before
         // hard-stopping (legacy graduated stuck-recovery parity).
         if (this.tryStuckArtifactRecovery(decision.unitType, decision.unitId)) {
+          this.clearPendingDispatch();
           return this.stuckRecovered(decision, reconciliation.stateSnapshot);
         }
+        this.clearPendingDispatch();
         const blocked: AutoAdvanceResult = {
           kind: "blocked",
           reason: `state did not advance after finalized ${decision.unitType} ${decision.unitId}`,
@@ -890,6 +993,7 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
       // checks coexist: idempotency for the common immediate-repeat case,
       // stuck-loop for the saturated-window case.
       if (this.lastAdvanceKey === nextKey && matchingCount < STUCK_WINDOW_SIZE) {
+        this.clearPendingDispatch();
         const blocked: AutoAdvanceResult = { kind: "blocked", reason: "idempotent advance: unit already active", action: "pause" };
         this.journalTransition({
           name: "advance-blocked",
@@ -910,8 +1014,10 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
         // complete on disk (stale DB) and recover if so — legacy graduated
         // stuck-recovery parity. Otherwise hard-stop with a diagnosable reason.
         if (this.tryStuckArtifactRecovery(decision.unitType, decision.unitId)) {
+          this.clearPendingDispatch();
           return this.stuckRecovered(decision, reconciliation.stateSnapshot);
         }
+        this.clearPendingDispatch();
         const blocked: AutoAdvanceResult = {
           kind: "blocked",
           reason: `stuck-loop: ${nextKey} picked ${matchingCount} times`,
@@ -929,6 +1035,7 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
 
       const contract = this.compileUnitToolContract(decision.unitType);
       if (!contract.ok) {
+        this.clearPendingDispatch();
         const blocked: AutoAdvanceResult = {
           kind: "blocked",
           reason: contract.reason,
@@ -947,6 +1054,7 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
 
       const worktree = await this.prepareWorktreeForUnit(decision.unitType, decision.unitId);
       if (!worktree.ok) {
+        this.clearPendingDispatch();
         const blocked: AutoAdvanceResult = {
           kind: "blocked",
           reason: worktree.reason,
@@ -1035,7 +1143,8 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
   public async resume(): Promise<AutoAdvanceResult> {
     this.lastAdvanceKey = null;
     this.lastFinalizedUnitKey = null;
-    this.dispatchKeyWindow = [];
+    // Preserve dispatchKeyWindow across resume so stuck-loop detection
+    // accumulates across pause/resume cycles rather than resetting each time.
     this.lastStuckRecoveryKey = null;
     this.status.phase = "running";
     this.bumpTransition();
@@ -1053,7 +1162,11 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
     this.status.activeUnit = undefined;
     this.lastAdvanceKey = null;
     this.lastFinalizedUnitKey = null;
-    this.dispatchKeyWindow = [];
+    // Preserve dispatchKeyWindow on pause so stuck-loop detection accumulates
+    // across pause/resume cycles. Only clear on a hard stop.
+    if (reason !== "pause") {
+      this.dispatchKeyWindow = [];
+    }
     this.lastStuckRecoveryKey = null;
     this.bumpTransition();
     this.journalTransition({ name: "stop", reason });

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

@@ -60,7 +60,8 @@ import { writeUnitRuntimeRecord } from "../unit-runtime.js";
 import { withTimeout, FINALIZE_PRE_TIMEOUT_MS, FINALIZE_POST_TIMEOUT_MS } from "./finalize-timeout.js";
 import { getEligibleSlices } from "../slice-parallel-eligibility.js";
 import { isSliceParallelActive, startSliceParallel } from "../slice-parallel-orchestrator.js";
-import { isDbAvailable, getMilestoneSlices, getSlice, getTask, refreshOpenDatabaseFromDisk } from "../gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getSlice, getTask } from "../gsd-db.js";
+import { refreshWorkflowDatabaseFromDisk } from "../db-workspace.js";
 import { isClosedStatus } from "../status-guards.js";
 import { setRuntimeKv } from "../db/runtime-kv.js";
 import { getLatestForUnit } from "../db/unit-dispatches.js";
@@ -85,7 +86,12 @@ import {
   supportsStructuredQuestions,
 } from "../workflow-mcp.js";
 import { prepareWorkflowMcpForProject } from "../workflow-mcp-auto-prep.js";
-import { getToolBaselineSnapshot, applyThinkingLevelForModel, floorThinkingLevelForUnit } from "../auto-model-selection.js";
+import {
+  applyThinkingLevelForModel,
+  floorThinkingLevelForUnit,
+  getRegisteredToolSnapshot,
+  getToolBaselineSnapshot,
+} from "../auto-model-selection.js";
 import type { DispatchAction } from "../auto-dispatch.js";
 import { resolveManifest } from "../unit-context-manifest.js";
 import { createWorktreeSafetyModule, type WorktreeSafetyResult } from "../worktree-safety.js";
@@ -225,7 +231,7 @@ function rememberRetryDispatch(
 
 function getAlreadyClosedDispatchReason(unitType: string, unitId: string): string | null {
   if (!isDbAvailable()) return null;
-  refreshOpenDatabaseFromDisk();
+  refreshWorkflowDatabaseFromDisk();
   const { milestone, slice, task } = parseUnitId(unitId);
   if (unitType === "execute-task" && milestone && slice && task) {
     const row = getTask(milestone, slice, task);
@@ -624,6 +630,16 @@ export async function _runMilestoneMergeWithStashRestore(
   );
   if (exitResult.ok) {
     s.milestoneMergedInPhases = true;
+    try {
+      const projectRoot = s.originalBasePath || s.canonicalProjectRoot || s.basePath;
+      const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.js");
+      await rebuildMarkdownProjectionsFromDb(projectRoot);
+    } catch (err) {
+      logWarning(
+        "engine",
+        `markdown projection rebuild after milestone merge failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
   } else {
     mergeError = exitResult.cause ?? new Error(`exit ${exitResult.reason}`);
   }
@@ -1232,6 +1248,19 @@ export async function runPreDispatch(
     } catch (e) {
       logWarning("engine", "STATE.md rebuild failed after milestone transition", { error: String(e) });
     }
+
+    // Re-project ROADMAP/PLAN markdown from the authoritative DB. Worktree DB
+    // reconciliation during merge can leave main-branch markdown stale relative
+    // to gsd.db (the 3M/3S/10T vs 3M/5S/16T drift class at /gsd startup).
+    try {
+      const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.js");
+      await rebuildMarkdownProjectionsFromDb(s.canonicalProjectRoot);
+      if (s.basePath !== s.canonicalProjectRoot) {
+        await rebuildMarkdownProjectionsFromDb(s.basePath);
+      }
+    } catch (e) {
+      logWarning("engine", "markdown projection rebuild failed after milestone transition", { error: String(e) });
+    }
   }
 
   if (mid) {
@@ -1458,6 +1487,7 @@ export async function runDispatch(
   // Checking a stale-narrowed set causes false transport-preflight warnings
   // that repeat on every /gsd auto resume (#477 follow-up).
   const activeTools = getToolBaselineSnapshot(pi);
+  const registeredTools = getRegisteredToolSnapshot(pi);
   // Deep planning intentionally keeps human checkpoints in plain chat. In
   // Claude Code/local MCP transports, structured question requests can be
   // cancelled outside the normal chat flow, which made approval gates easy to
@@ -1482,6 +1512,7 @@ export async function runDispatch(
     sessionProvider: ctx.model?.provider,
     modelRegistry: ctx.modelRegistry as MinimalModelRegistry | undefined,
     activeTools,
+    registeredTools,
     sessionBaseUrl: ctx.model?.baseUrl,
     sessionAuthMode: authMode,
   });
@@ -1508,6 +1539,7 @@ export async function runDispatch(
       sessionProvider: ctx.model?.provider,
       modelRegistry: ctx.modelRegistry as MinimalModelRegistry | undefined,
       activeTools,
+      registeredTools,
       sessionBaseUrl: ctx.model?.baseUrl,
       sessionAuthMode: authMode,
     });

package/src/resources/extensions/gsd/auto/run-unit.ts

@@ -130,7 +130,8 @@ export async function runUnit(
       unitId,
       error: msg,
     });
-    return { status: "cancelled", errorContext: { message: `Session creation failed: ${msg}`, category: "session-failed", isTransient: true } };
+    const isStructural = sessionErr instanceof TypeError || /is not a function/i.test(msg);
+    return { status: "cancelled", errorContext: { message: `Session creation failed: ${msg}`, category: "session-failed", isTransient: !isStructural } };
   }
   if (sessionTimeoutHandle) clearTimeout(sessionTimeoutHandle);
 

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

@@ -29,6 +29,7 @@ import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { normalizeRealPath } from "../paths.js";
 import type { MilestoneScope } from "../workspace.js";
 import type { RootDirtySnapshot } from "../root-write-leak-guard.js";
+import type { MilestoneSettlementOutcome } from "../milestone-settlement.js";
 
 // ─── Exported Types ──────────────────────────────────────────────────────────
 
@@ -230,6 +231,8 @@ export class AutoSession {
   /** Set to true after phases.ts successfully calls mergeAndExit, so that
    *  stopAuto does not attempt the same merge a second time (#2645). */
   milestoneMergedInPhases = false;
+  /** Last milestone settlement result observed by Auto Orchestration. */
+  milestoneSettlement: MilestoneSettlementOutcome | null = null;
 
   // #4765 — slice-cadence collapse: main-branch SHAs at the moment each
   // milestone's first slice merge began. Used by resquashMilestoneOnMain at
@@ -410,6 +413,7 @@ export class AutoSession {
     this.strandedRecoveryIsolationMode = null;
     this.rootWriteBaseline = null;
     this.milestoneMergedInPhases = false;
+    this.milestoneSettlement = null;
     this.milestoneStartShas = new Map();
     this.checkpointSha = null;