@opengsd/gsd-pi 1.1.1-dev.a5a2de8 → 1.1.1-dev.b2556262

package/dist/headless-recover.js

@@ -46,13 +46,20 @@ async function loadExtensionModules() {
     const dbModule = await jiti.import(gsdExtensionPath('gsd-db.ts'), {});
     const importerModule = await jiti.import(gsdExtensionPath('md-importer.ts'), {});
     const dynamicToolsModule = await jiti.import(gsdExtensionPath('bootstrap/dynamic-tools.ts'), {});
+    const migrationCheckModule = await jiti.import(gsdExtensionPath('migration-auto-check.ts'), {});
+    const rendererModule = await jiti.import(gsdExtensionPath('markdown-renderer.ts'), {});
     return {
         ensureDbOpen: dynamicToolsModule.ensureDbOpen,
         isDbAvailable: dbModule.isDbAvailable,
         clearEngineHierarchy: dbModule.clearEngineHierarchy,
         transaction: dbModule.transaction,
+        backupDatabaseSnapshot: dbModule.backupDatabaseSnapshot,
         migrateHierarchyToDb: importerModule.migrateHierarchyToDb,
         invalidateStateCache: stateModule.invalidateStateCache,
+        countDbHierarchy: migrationCheckModule.countDbHierarchy,
+        countMarkdownHierarchy: migrationCheckModule.countMarkdownHierarchy,
+        recoverWouldDeleteDbRows: migrationCheckModule.recoverWouldDeleteDbRows,
+        renderAllFromDb: rendererModule.renderAllFromDb,
     };
 }
 export async function handleRecover(basePath) {
@@ -75,6 +82,24 @@ export async function handleRecover(basePath) {
         process.stderr.write(`[headless] recover: failed to open or create the GSD database at ${basePath}\n`);
         return { exitCode: 1 };
     }
+    // Refuse a destructive recover that would delete authoritative DB rows the
+    // markdown lacks, unless explicitly allowed. The DB is the source of truth;
+    // re-projecting via rebuild is almost always what's wanted instead. The
+    // check is identity-based, so it also catches equal-count divergence (DB S99
+    // vs markdown S01) that a cardinality-only comparison would miss.
+    const markdown = modules.countMarkdownHierarchy(basePath);
+    const beforeDb = modules.countDbHierarchy();
+    const dataLoss = modules.recoverWouldDeleteDbRows(basePath);
+    const allowDataLoss = process.env.GSD_RECOVER_ALLOW_DATA_LOSS === '1';
+    if (dataLoss && !allowDataLoss) {
+        process.stderr.write(`[headless] recover refused: the DB (${beforeDb.milestones}M/${beforeDb.slices}S/${beforeDb.tasks}T) ` +
+            `holds rows the markdown (${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T) lacks; ` +
+            `recover would delete them. Set GSD_RECOVER_ALLOW_DATA_LOSS=1 to override, ` +
+            `or run a DB-to-markdown rebuild instead.\n`);
+        return { exitCode: 1 };
+    }
+    // Snapshot the DB before the destructive clear so recover is reversible.
+    const backupPath = modules.backupDatabaseSnapshot('pre-recover');
     let counts;
     try {
         counts = modules.transaction(() => {
@@ -88,6 +113,36 @@ export async function handleRecover(basePath) {
         return { exitCode: 1 };
     }
     modules.invalidateStateCache();
-    process.stderr.write(`gsd-recover: recovered ${counts.milestones}M/${counts.slices}S/${counts.tasks}T hierarchy\n`);
+    // Re-project markdown from the freshly imported DB so disk and DB agree.
+    // renderAllFromDb resolves even when individual artifacts fail, so inspect
+    // its error list — a silent projection failure must surface, not pass as a
+    // clean recover.
+    let projectionErrors = 0;
+    try {
+        const renderResult = await modules.renderAllFromDb(basePath);
+        projectionErrors = renderResult.errors.length;
+        if (projectionErrors > 0) {
+            process.stderr.write(`[headless] recover: ${projectionErrors} markdown projection(s) failed to render — markdown may be stale:\n`);
+            for (const e of renderResult.errors.slice(0, 10)) {
+                process.stderr.write(`  - ${e}\n`);
+            }
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[headless] recover: re-render after import failed: ${msg}\n`);
+        projectionErrors = 1;
+    }
+    if (counts.milestones < markdown.milestones ||
+        counts.slices < markdown.slices ||
+        counts.tasks < markdown.tasks) {
+        process.stderr.write(`[headless] recover: imported fewer rows than markdown contained ` +
+            `(${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T on disk); some markdown may have failed to parse\n`);
+    }
+    if (backupPath) {
+        process.stderr.write(`[headless] recover: pre-recover snapshot saved to ${backupPath}\n`);
+    }
+    process.stderr.write(`gsd-recover: recovered ${counts.milestones}M/${counts.slices}S/${counts.tasks}T hierarchy` +
+        `${projectionErrors > 0 ? ` (${projectionErrors} projection error(s) — run rebuild markdown)` : ''}\n`);
     return { exitCode: 0 };
 }

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-fe5e2f79a21b7d4e
+fc4ebdcd3723ade9

package/dist/resources/extensions/browser-tools/engine/managed-gsd-browser.js

@@ -435,11 +435,27 @@ function formatManagedBrowserError(toolName, error) {
     return [
         `gsd-browser engine or tool unavailable for ${toolName}: ${message}`,
         "",
-        "GSD browser automation now uses the managed gsd-browser engine by default.",
+        "The managed gsd-browser engine is enabled for this session but is unavailable.",
         "Run /gsd doctor or reinstall dependencies so @opengsd/gsd-browser is available.",
-        "Set GSD_BROWSER_ENGINE=legacy only when you intentionally need the Playwright compatibility engine.",
+        "Unset GSD_BROWSER_ENGINE or set GSD_BROWSER_ENGINE=playwright to use the default Playwright engine.",
     ].join("\n");
 }
+/**
+ * Eagerly establish the managed gsd-browser connection so browser tools are
+ * ready before first use. Best-effort: returns the error instead of throwing so
+ * callers (e.g. session-start warm-up) can surface a warning without failing the
+ * session. Connecting only spawns the gsd-browser MCP daemon; it does not launch
+ * Chrome (that happens lazily on the first navigation).
+ */
+export async function warmUpManagedGsdBrowser(ctx, signal) {
+    try {
+        await getOrConnectManagedGsdBrowser(ctx, signal);
+        return { ok: true };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
 export function registerManagedGsdBrowserTools(pi) {
     for (const tool of MANAGED_BROWSER_TOOLS) {
         pi.registerTool({

package/dist/resources/extensions/browser-tools/engine/selection.js

@@ -1,4 +1,4 @@
-const DEFAULT_BROWSER_ENGINE = "gsd-browser";
+const DEFAULT_BROWSER_ENGINE = "legacy";
 export function resolveBrowserEngineMode(env = process.env) {
     const raw = env.GSD_BROWSER_ENGINE?.trim();
     if (!raw)

package/dist/resources/extensions/browser-tools/extension-manifest.json

@@ -2,7 +2,7 @@
   "id": "browser-tools",
   "name": "Browser Tools",
   "version": "1.0.0",
-  "description": "GSD browser automation contract adapter backed by the managed gsd-browser engine",
+  "description": "GSD browser automation contract adapter backed by Playwright with optional managed gsd-browser support",
   "tier": "bundled",
   "requires": { "platform": ">=2.29.0" },
   "provides": {

package/dist/resources/extensions/browser-tools/index.js

@@ -1,7 +1,9 @@
 /** browser-tools — Pi Browser Automation Contract adapter. */
 import { importExtensionModule } from "@gsd/pi-coding-agent";
-import { closeManagedGsdBrowser, registerManagedGsdBrowserTools } from "./engine/managed-gsd-browser.js";
+import { closeManagedGsdBrowser, registerManagedGsdBrowserTools, warmUpManagedGsdBrowser } from "./engine/managed-gsd-browser.js";
 import { resolveBrowserEngineMode } from "./engine/selection.js";
+import { setArtifactRootForCwd } from "./state.js";
+import { detectWebApp } from "./web-app-detect.js";
 let legacyRegistrationPromise = null;
 let managedRegistrationPromise = null;
 let registeredEngine = null;
@@ -83,28 +85,29 @@ async function registerLegacyBrowserTools(pi) {
                 sanitizeArtifactName: utils.sanitizeArtifactName,
                 formatArtifactTimestamp: utils.formatArtifactTimestamp,
             };
-            navigation.registerNavigationTools(pi, deps);
-            screenshot.registerScreenshotTools(pi, deps);
-            interaction.registerInteractionTools(pi, deps);
-            inspection.registerInspectionTools(pi, deps);
-            session.registerSessionTools(pi, deps);
-            assertions.registerAssertionTools(pi, deps);
-            refTools.registerRefTools(pi, deps);
-            wait.registerWaitTools(pi, deps);
-            pages.registerPageTools(pi, deps);
-            forms.registerFormTools(pi, deps);
-            intent.registerIntentTools(pi, deps);
-            pdf.registerPdfTools(pi, deps);
-            statePersistence.registerStatePersistenceTools(pi, deps);
-            networkMock.registerNetworkMockTools(pi, deps);
-            device.registerDeviceTools(pi, deps);
-            extract.registerExtractTools(pi, deps);
-            visualDiff.registerVisualDiffTools(pi, deps);
-            zoom.registerZoomTools(pi, deps);
-            codegen.registerCodegenTools(pi, deps);
-            actionCache.registerActionCacheTools(pi, deps);
-            injectionDetection.registerInjectionDetectionTools(pi, deps);
-            verify.registerVerifyTools(pi, deps);
+            const cwdScopedPi = withBrowserArtifactCwdScope(pi);
+            navigation.registerNavigationTools(cwdScopedPi, deps);
+            screenshot.registerScreenshotTools(cwdScopedPi, deps);
+            interaction.registerInteractionTools(cwdScopedPi, deps);
+            inspection.registerInspectionTools(cwdScopedPi, deps);
+            session.registerSessionTools(cwdScopedPi, deps);
+            assertions.registerAssertionTools(cwdScopedPi, deps);
+            refTools.registerRefTools(cwdScopedPi, deps);
+            wait.registerWaitTools(cwdScopedPi, deps);
+            pages.registerPageTools(cwdScopedPi, deps);
+            forms.registerFormTools(cwdScopedPi, deps);
+            intent.registerIntentTools(cwdScopedPi, deps);
+            pdf.registerPdfTools(cwdScopedPi, deps);
+            statePersistence.registerStatePersistenceTools(cwdScopedPi, deps);
+            networkMock.registerNetworkMockTools(cwdScopedPi, deps);
+            device.registerDeviceTools(cwdScopedPi, deps);
+            extract.registerExtractTools(cwdScopedPi, deps);
+            visualDiff.registerVisualDiffTools(cwdScopedPi, deps);
+            zoom.registerZoomTools(cwdScopedPi, deps);
+            codegen.registerCodegenTools(cwdScopedPi, deps);
+            actionCache.registerActionCacheTools(cwdScopedPi, deps);
+            injectionDetection.registerInjectionDetectionTools(cwdScopedPi, deps);
+            verify.registerVerifyTools(cwdScopedPi, deps);
         })().catch((error) => {
             legacyRegistrationPromise = null;
             throw error;
@@ -112,6 +115,21 @@ async function registerLegacyBrowserTools(pi) {
     }
     return legacyRegistrationPromise;
 }
+function withBrowserArtifactCwdScope(pi) {
+    return {
+        ...pi,
+        registerTool(definition) {
+            pi.registerTool({
+                ...definition,
+                async execute(toolCallId, params, signal, onUpdate, ctx) {
+                    if (ctx?.cwd)
+                        setArtifactRootForCwd(ctx.cwd);
+                    return definition.execute(toolCallId, params, signal, onUpdate, ctx);
+                },
+            });
+        },
+    };
+}
 async function registerBrowserTools(pi) {
     const engine = resolveBrowserEngineMode();
     if (engine === "off")
@@ -147,6 +165,29 @@ async function registerBrowserTools(pi) {
         throw error;
     }
 }
+function isWarmUpDisabled() {
+    const value = process.env.GSD_BROWSER_WARMUP?.trim().toLowerCase();
+    return value === "0" || value === "false" || value === "off";
+}
+/**
+ * Auto-initialize the managed gsd-browser engine only when explicitly selected
+ * for a web app. Best-effort and non-blocking: warm-up runs in the background
+ * and only surfaces a warning if it fails.
+ */
+function maybeWarmUpManagedEngine(pi, ctx) {
+    if (isWarmUpDisabled())
+        return;
+    if (resolveBrowserEngineMode() !== "gsd-browser")
+        return;
+    const projectRoot = ctx.cwd || process.cwd();
+    if (!detectWebApp(projectRoot))
+        return;
+    void warmUpManagedGsdBrowser(ctx).then((result) => {
+        if (!result.ok && ctx.hasUI) {
+            ctx.ui.notify(`gsd-browser auto-init failed: ${result.error}. Browser UAT tools will retry on first use; run /gsd doctor if this persists.`, "warning");
+        }
+    });
+}
 async function closeActiveBrowserEngines() {
     await closeManagedGsdBrowser();
     if (legacyRegistrationPromise) {
@@ -157,12 +198,15 @@ async function closeActiveBrowserEngines() {
 export default function (pi) {
     pi.on("session_start", async (_event, ctx) => {
         if (ctx.hasUI) {
-            void registerBrowserTools(pi).catch((error) => {
+            void registerBrowserTools(pi)
+                .then(() => maybeWarmUpManagedEngine(pi, ctx))
+                .catch((error) => {
                 ctx.ui.notify(`browser-tools failed to load: ${error instanceof Error ? error.message : String(error)}`, "warning");
             });
             return;
         }
         await registerBrowserTools(pi);
+        maybeWarmUpManagedEngine(pi, ctx);
     });
     pi.on("session_shutdown", async () => {
         await closeActiveBrowserEngines();

package/dist/resources/extensions/browser-tools/state.js

@@ -18,6 +18,17 @@ export const HAR_FILENAME = "session.har";
 // ---------------------------------------------------------------------------
 // Mutable state variables — accessed only via get/set functions
 // ---------------------------------------------------------------------------
+// 0. artifactRoot
+let _artifactRoot = ARTIFACT_ROOT;
+export function getArtifactRoot() { return _artifactRoot; }
+export function setArtifactRootForCwd(cwd) {
+    const newRoot = path.resolve(cwd, ".artifacts", "browser");
+    if (newRoot !== _artifactRoot) {
+        _artifactRoot = newRoot;
+        _sessionArtifactDir = null;
+    }
+    return _artifactRoot;
+}
 // 1. browser
 let _browser = null;
 export function getBrowser() { return _browser; }
@@ -102,6 +113,7 @@ export function setHarState(h) { _harState = h; }
 // resetAllState — mirrors closeBrowser()'s reset logic
 // ---------------------------------------------------------------------------
 export function resetAllState() {
+    _artifactRoot = ARTIFACT_ROOT;
     _browser = null;
     _context = null;
     pageRegistry.pages = [];

package/dist/resources/extensions/browser-tools/tools/session.js

@@ -2,7 +2,7 @@ import { Type } from "@sinclair/typebox";
 import { stat } from "node:fs/promises";
 import path from "node:path";
 import { formatTimelineEntries, buildFailureHypothesis, summarizeBrowserSession, } from "../core.js";
-import { ARTIFACT_ROOT, HAR_FILENAME, getPageRegistry, getConsoleLogs, getNetworkLogs, getDialogLogs, getActionTimeline, getActiveTraceSession, setActiveTraceSession, getHarState, setHarState, getSessionStartedAt, getSessionArtifactDir, } from "../state.js";
+import { HAR_FILENAME, getArtifactRoot, getPageRegistry, getConsoleLogs, getNetworkLogs, getDialogLogs, getActionTimeline, getActiveTraceSession, setActiveTraceSession, getHarState, setHarState, getSessionStartedAt, getSessionArtifactDir, } from "../state.js";
 import { getActiveFrameMetadata, ensureDir, } from "../utils.js";
 export function registerSessionTools(pi, deps) {
     // -------------------------------------------------------------------------
@@ -289,7 +289,8 @@ export function registerSessionTools(pi, deps) {
                 const { page: p } = await deps.ensureBrowser();
                 const startedAt = Date.now();
                 const sessionDir = await deps.ensureSessionArtifactDir();
-                const bundleDir = path.join(ARTIFACT_ROOT, `${deps.formatArtifactTimestamp(startedAt)}-${deps.sanitizeArtifactName(params.name ?? "debug-bundle", "debug-bundle")}`);
+                const bundleName = `${deps.formatArtifactTimestamp(startedAt)}-${deps.sanitizeArtifactName(params.name ?? "debug-bundle", "debug-bundle")}`;
+                const bundleDir = path.join(getArtifactRoot(), bundleName);
                 await ensureDir(bundleDir);
                 const pages = await deps.getLivePagesSnapshot();
                 const actionTimeline = getActionTimeline();

package/dist/resources/extensions/browser-tools/utils.js

@@ -8,7 +8,7 @@ import { mkdir, stat, writeFile, copyFile } from "node:fs/promises";
 import path from "node:path";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateHead, } from "@gsd/pi-coding-agent";
 import { beginAction, finishAction, findAction, toActionParamsSummary, registryListPages, } from "./core.js";
-import { ARTIFACT_ROOT, getActiveFrame, getActiveTraceSession, getConsoleLogs, getDialogLogs, getHarState, getNetworkLogs, getSessionArtifactDir, getSessionStartedAt, setSessionArtifactDir, setSessionStartedAt, pageRegistry, actionTimeline, getPendingCriticalRequestsByPage, } from "./state.js";
+import { getActiveFrame, getArtifactRoot, getActiveTraceSession, getConsoleLogs, getDialogLogs, getHarState, getNetworkLogs, getSessionArtifactDir, getSessionStartedAt, setSessionArtifactDir, setSessionStartedAt, pageRegistry, actionTimeline, getPendingCriticalRequestsByPage, } from "./state.js";
 // ---------------------------------------------------------------------------
 // Text truncation
 // ---------------------------------------------------------------------------
@@ -60,7 +60,7 @@ export async function ensureSessionArtifactDir() {
         return existing;
     }
     const startedAt = ensureSessionStartedAt();
-    const dir = path.join(ARTIFACT_ROOT, `${formatArtifactTimestamp(startedAt)}-session`);
+    const dir = path.join(getArtifactRoot(), `${formatArtifactTimestamp(startedAt)}-session`);
     setSessionArtifactDir(dir);
     await ensureDir(dir);
     return dir;
@@ -95,7 +95,7 @@ export function getActiveFrameMetadata() {
 }
 export function getSessionArtifactMetadata() {
     return {
-        artifactRoot: ARTIFACT_ROOT,
+        artifactRoot: getArtifactRoot(),
         sessionStartedAt: getSessionStartedAt(),
         sessionArtifactDir: getSessionArtifactDir(),
         activeTraceSession: getActiveTraceSession(),

package/dist/resources/extensions/browser-tools/web-app-detect.js

@@ -0,0 +1,52 @@
+/**
+ * web-app-detect — lightweight, synchronous heuristic for deciding whether the
+ * project under development is a web app. Used only when the optional managed
+ * gsd-browser engine is selected and can be warmed before first use.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+// Frontend frameworks / bundlers whose presence in dependencies indicates a
+// browser-facing web app worth warming the optional managed engine for.
+const WEB_DEPENDENCY_RE = /^(react|react-dom|next|nuxt|vue|@vue\/|svelte|@sveltejs\/|solid-js|astro|@remix-run\/|gatsby|preact|@angular\/core|vite|@vitejs\/|@builder\.io\/qwik|@web\/dev-server|@11ty\/eleventy)/;
+// package.json scripts that imply a dev server / browser-facing build.
+const WEB_SCRIPT_RE = /\b(vite|next|nuxt|astro|remix|webpack(-dev-server)?|parcel|ng serve|serve\b|http-server|live-server|gatsby)\b/;
+function readPackageJson(projectRoot) {
+    const packageJsonPath = resolve(projectRoot, "package.json");
+    if (!existsSync(packageJsonPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function dependencyNames(pkg) {
+    return [
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.devDependencies ?? {}),
+        ...Object.keys(pkg.peerDependencies ?? {}),
+    ];
+}
+/**
+ * Returns true when the project looks like a browser-facing web app. Conservative
+ * and dependency-free: a false negative just means lazy connection (the prior
+ * behavior); a false positive only warms an idle engine connection.
+ */
+export function detectWebApp(projectRoot) {
+    const pkg = readPackageJson(projectRoot);
+    if (pkg) {
+        if (dependencyNames(pkg).some((name) => WEB_DEPENDENCY_RE.test(name)))
+            return true;
+        const scriptValues = Object.values(pkg.scripts ?? {}).filter((value) => typeof value === "string");
+        if (scriptValues.some((script) => WEB_SCRIPT_RE.test(script)))
+            return true;
+    }
+    // No package.json signal — fall back to a top-level index.html (static sites).
+    if (existsSync(resolve(projectRoot, "index.html")))
+        return true;
+    if (existsSync(resolve(projectRoot, "public", "index.html")))
+        return true;
+    return false;
+}

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

@@ -1106,7 +1106,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 unitId: iterData.unitId,
             });
             const finalizeReason = finalizeResult.action === "break" ? finalizeResult.reason : undefined;
-            const finalizeStatus = finalizeReason === "step-wizard"
+            const finalizeStatus = (finalizeReason === "step-wizard" || finalizeReason === "milestone-complete")
                 ? "completed"
                 : finalizeResult.action === "next"
                     ? "completed"
@@ -1172,7 +1172,9 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             stuckStatePersistedThisIteration = true;
             finishTurn("completed");
             if (finalizeDecision.action === "complete-and-break") {
-                s.preserveStepSurfaceAfterLoopExit = true;
+                if (!s.completionStopInProgress) {
+                    s.preserveStepSurfaceAfterLoopExit = true;
+                }
                 break;
             }
         }

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

@@ -16,6 +16,8 @@ import { detectStuck } from "./detect-stuck.js";
 import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
 import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare } from "../worktree-root.js";
+import { buildManualValidationGuidance } from "../worktree-manager.js";
+import { relSliceFile } from "../paths.js";
 import { classifyProject } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
 import { setCurrentPhase, clearCurrentPhase } from "../../shared/gsd-phase-state.js";
@@ -47,6 +49,7 @@ import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
 import { getContextPauseAction } from "../auto-budget.js";
 import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, supportsStructuredQuestions, } from "../workflow-mcp.js";
 import { prepareWorkflowMcpForProject } from "../workflow-mcp-auto-prep.js";
+import { getToolBaselineSnapshot, applyThinkingLevelForModel, floorThinkingLevelForUnit } from "../auto-model-selection.js";
 import { resolveManifest } from "../unit-context-manifest.js";
 import { createWorktreeSafetyModule } from "../worktree-safety.js";
 import { isSuspiciousGhostCompletion } from "../auto-unit-closeout.js";
@@ -302,6 +305,8 @@ async function validateSourceWriteWorktreeSafety(ic, unitType, unitId, milestone
 // ─── Session timeout auto-resume state ────────────────────────────────────────
 let consecutiveSessionTimeouts = 0;
 const MAX_SESSION_TIMEOUT_AUTO_RESUMES = 3;
+/** Maximum zero-tool-call retries before pausing — context exhaustion is deterministic. */
+const MAX_ZERO_TOOL_RETRIES = 1;
 export function resetSessionTimeoutState() {
     consecutiveSessionTimeouts = 0;
 }
@@ -388,7 +393,7 @@ async function generateMilestoneReport(s, ctx, milestoneId) {
 async function closeoutAndStop(ctx, pi, s, deps, reason) {
     if (s.currentUnit) {
         await deps.closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, deps.buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
-        s.currentUnit = null;
+        s.clearCurrentUnit();
     }
     await deps.stopAuto(ctx, pi, reason);
 }
@@ -576,7 +581,7 @@ async function failClosedOnFinalizeTimeout(ic, iterData, loopState, stage, start
     });
     ctx.ui.notify(`${stage === "pre" ? "postUnitPreVerification" : "postUnitPostVerification"} timed out after ${timeoutMs / 1000}s for ${unitType} ${unitId} (${loopState.consecutiveFinalizeTimeouts}/${MAX_FINALIZE_TIMEOUTS}) — pausing auto-mode for recovery.`, "warning");
     await deps.pauseAuto(ctx, pi);
-    s.currentUnit = null;
+    s.clearCurrentUnit();
     clearCurrentPhase();
     drainLogs();
     return { action: "break", reason: progressKind };
@@ -1024,7 +1029,7 @@ export async function runPreDispatch(ic, loopState) {
         deps.logCmuxEvent(prefs, `Milestone ${mid} complete.`, "success");
         if (s.currentUnit) {
             await deps.closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, deps.buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
-            s.currentUnit = null;
+            s.clearCurrentUnit();
         }
         await deps.stopAuto(ctx, pi, `Milestone ${mid} complete`, {
             completionWidget: {
@@ -1070,7 +1075,13 @@ export async function runDispatch(ic, preData, loopState) {
     const authMode = provider && typeof ctx.modelRegistry?.getProviderAuthMode === "function"
         ? ctx.modelRegistry.getProviderAuthMode(provider)
         : undefined;
-    const activeTools = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
+    // Use the baseline snapshot rather than the live active-tool set: a prior
+    // unit's per-provider narrowing (hook overrides, Groq 128-tool cap, etc.)
+    // can strip required MCP tools from the live set even though
+    // selectAndApplyModel will restore them before the unit is dispatched.
+    // Checking a stale-narrowed set causes false transport-preflight warnings
+    // that repeat on every /gsd auto resume (#477 follow-up).
+    const activeTools = getToolBaselineSnapshot(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
@@ -1093,6 +1104,9 @@ export async function runDispatch(ic, preData, loopState) {
         sessionContextWindow: ctx.model?.contextWindow,
         sessionProvider: ctx.model?.provider,
         modelRegistry: ctx.modelRegistry,
+        activeTools,
+        sessionBaseUrl: ctx.model?.baseUrl,
+        sessionAuthMode: authMode,
     });
     if (isUnhandledPhaseWarning(dispatchResult)) {
         deps.invalidateAllCaches();
@@ -1116,6 +1130,9 @@ export async function runDispatch(ic, preData, loopState) {
             sessionContextWindow: ctx.model?.contextWindow,
             sessionProvider: ctx.model?.provider,
             modelRegistry: ctx.modelRegistry,
+            activeTools,
+            sessionBaseUrl: ctx.model?.baseUrl,
+            sessionAuthMode: authMode,
         });
     }
     if (dispatchResult.action === "stop") {
@@ -1695,9 +1712,16 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         if (match) {
             const ok = await pi.setModel(match, { persist: false });
             if (ok) {
-                if (s.autoModeStartThinkingLevel) {
-                    pi.setThinkingLevel(s.autoModeStartThinkingLevel);
-                }
+                // Apply the per-phase reasoning effort selectAndApplyModel resolved for
+                // this unit — not the auto-start session snapshot — but route it through
+                // the same floor + capability-clamp pipeline against the *hook* model
+                // (ADR-026). The hook override can pick a different model family than the
+                // one selectAndApplyModel clamped against, so re-clamping here prevents
+                // sending an unsupported level; the floor fills in when no phase level
+                // resolved so a hook-overridden execute-task still meets the floor.
+                const hookThinkingBase = modelResult.appliedThinkingLevel
+                    ?? floorThinkingLevelForUnit(unitType, s.autoModeStartThinkingLevel);
+                applyThinkingLevelForModel(pi, hookThinkingBase, match, ctx);
                 s.currentUnitModel = match;
                 ctx.ui.notify(`Hook model override: ${match.provider}/${match.id}`, "info");
             }
@@ -1766,7 +1790,21 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     _resetLogs();
     const unitStartedAt = Date.now();
     s.unitDispatchCount.set(dispatchKey, nextDispatchCount);
-    s.currentUnit = { type: unitType, id: unitId, startedAt: unitStartedAt, workspaceRoot: s.basePath };
+    s.setCurrentUnit({ type: unitType, id: unitId, startedAt: unitStartedAt, workspaceRoot: s.basePath });
+    if (unitType === "execute-task") {
+        const { milestone, slice, task } = parseUnitId(unitId);
+        if (milestone && slice && task && isDbAvailable()) {
+            try {
+                const taskRow = getTask(milestone, slice, task);
+                if (taskRow)
+                    s.sourceObservations.observePlanTask(taskRow);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                logWarning("prompt", `failed to preload source observations for ${unitId}: ${message}`);
+            }
+        }
+    }
     s.rootWriteBaseline = isIsolatedWorktreeSession(s)
         ? captureRootDirtySnapshot(s.originalBasePath)
         : null;
@@ -1852,7 +1890,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             category: "unknown",
             isTransient: true,
         });
-        s.currentUnit = null;
+        s.clearCurrentUnit();
         await deps.pauseAuto(ctx, pi);
         return { action: "break", reason: "ghost-completion" };
     }
@@ -2059,13 +2097,23 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                     });
                 }
                 else {
+                    const zeroToolKey = `${unitType}/${unitId}`;
+                    const attempt = (s.zeroToolRetryCount.get(zeroToolKey) ?? 0) + 1;
                     debugLog("runUnitPhase", {
                         phase: "zero-tool-calls",
                         unitType,
                         unitId,
+                        attempt,
                         warning: "Unit completed with 0 tool calls — likely context exhaustion, marking as failed",
                     });
-                    ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — context exhaustion, will retry`, "warning");
+                    if (attempt > MAX_ZERO_TOOL_RETRIES) {
+                        s.zeroToolRetryCount.delete(zeroToolKey);
+                        ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — context exhaustion, pausing auto-mode after ${MAX_ZERO_TOOL_RETRIES} retry.`, "error");
+                        await deps.pauseAuto(ctx, pi);
+                        return { action: "break", reason: "zero-tool-calls-exhausted" };
+                    }
+                    s.zeroToolRetryCount.set(zeroToolKey, attempt);
+                    ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — context exhaustion, will retry (attempt ${attempt}/${MAX_ZERO_TOOL_RETRIES})`, "warning");
                     return {
                         action: "retry",
                         reason: "zero-tool-calls",
@@ -2087,6 +2135,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     if (artifactVerified) {
         s.unitDispatchCount.delete(dispatchKey);
         s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
+        s.zeroToolRetryCount.delete(dispatchKey);
     }
     // Write phase handoff anchor after successful research/planning completion
     const anchorPhases = new Set(["research-milestone", "research-slice", "plan-milestone", "plan-slice"]);
@@ -2176,7 +2225,7 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
             s.currentUnit?.type === preUnitSnapshot.type &&
             s.currentUnit?.id === preUnitSnapshot.id &&
             s.currentUnit?.startedAt === preUnitSnapshot.startedAt) {
-            s.currentUnit = null;
+            s.clearCurrentUnit();
         }
         s.rootWriteBaseline = null;
     };
@@ -2232,7 +2281,21 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
         }
     }
     if (pauseAfterUatDispatch) {
-        ctx.ui.notify("UAT requires human execution. Auto-mode will pause after this unit writes the result file.", "info");
+        const pauseMid = iterData.mid;
+        const pauseSliceId = pauseMid && iterData.unitId.startsWith(`${pauseMid}/`)
+            ? iterData.unitId.slice(pauseMid.length + 1)
+            : undefined;
+        const guidance = pauseMid
+            ? buildManualValidationGuidance(s.basePath, pauseMid, {
+                uatPath: pauseSliceId
+                    ? relSliceFile(s.basePath, pauseMid, pauseSliceId, "UAT")
+                    : undefined,
+            })
+            : null;
+        const pauseMessage = guidance
+            ? `UAT requires human execution. Auto-mode will pause after this unit writes the result file.\n\n${guidance}`
+            : "UAT requires human execution. Auto-mode will pause after this unit writes the result file.";
+        ctx.ui.notify(pauseMessage, "info");
         await deps.pauseAuto(ctx, pi);
         debugLog("autoLoop", { phase: "exit", reason: "uat-pause" });
         clearFinalizingUnit();
@@ -2397,5 +2460,17 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
             ctx.ui.notify(formatForNotification(logs), severity);
         }
     }
+    if (preUnitSnapshot?.type === "complete-milestone" && s.currentMilestoneId) {
+        // cleanupAfterLoopExit skips gsd-progress when preserveCompletionSurface is true, so clear stale controls here.
+        ctx.ui.setStatus?.("gsd-step", undefined);
+        ctx.ui.setWidget?.("gsd-progress", undefined);
+        await deps.stopAuto(ctx, pi, `Milestone ${s.currentMilestoneId} complete`, {
+            completionWidget: {
+                milestoneId: s.currentMilestoneId,
+                milestoneTitle: iterData.midTitle,
+            },
+        });
+        return { action: "break", reason: "milestone-complete" };
+    }
     return { action: "next", data: undefined };
 }