@opengsd/gsd-pi 1.1.1-dev.9f86580 → 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 @@
-f692671bcb7f8bc4
+fc4ebdcd3723ade9

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

@@ -2,6 +2,7 @@
 import { importExtensionModule } from "@gsd/pi-coding-agent";
 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;
@@ -84,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;
@@ -113,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")

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/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

@@ -49,7 +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 } from "../auto-model-selection.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";
@@ -393,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);
 }
@@ -581,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 };
@@ -1029,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: {
@@ -1712,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");
             }
@@ -1783,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;
@@ -1869,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" };
     }
@@ -2204,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;
     };
@@ -2439,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 };
 }

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

@@ -17,6 +17,7 @@
  * auto-session-encapsulation.test.ts enforce that auto.ts has no module-level
  * `let` or `var` declarations.
  */
+import { SourceObservationStore, supportsSourceObservationsForUnit } from "../source-observations.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { normalizeRealPath } from "../paths.js";
 // ─── Constants ───────────────────────────────────────────────────────────────
@@ -76,6 +77,7 @@ export class AutoSession {
     currentTurnId = null;
     currentUnitRouting = null;
     currentMilestoneId = null;
+    sourceObservations = new SourceObservationStore();
     // ── Model state ──────────────────────────────────────────────────────────
     autoModeStartModel = null;
     /** Explicit /gsd model pin captured at bootstrap (session-scoped policy override). */
@@ -196,6 +198,23 @@ export class AutoSession {
         this.unitDispatchCount.clear();
         this.unitLifetimeDispatches.clear();
     }
+    setCurrentUnit(unit) {
+        this.currentUnit = unit;
+        if (!supportsSourceObservationsForUnit(unit.type)) {
+            this.sourceObservations.clear();
+            return;
+        }
+        this.sourceObservations.beginUnit({
+            unitType: unit.type,
+            unitId: unit.id,
+            startedAt: unit.startedAt,
+            basePath: unit.workspaceRoot ?? this.basePath,
+        });
+    }
+    clearCurrentUnit() {
+        this.currentUnit = null;
+        this.sourceObservations.clear();
+    }
     get lockBasePath() {
         return resolveWorktreeProjectRoot(this.basePath, this.originalBasePath);
     }
@@ -246,7 +265,7 @@ export class AutoSession {
         this.unitLifetimeDispatches.clear();
         this.unitRecoveryCount.clear();
         // Unit
-        this.currentUnit = null;
+        this.clearCurrentUnit();
         this.currentTraceId = null;
         this.currentTurnId = null;
         this.currentUnitRouting = null;

package/dist/resources/extensions/gsd/auto/workflow-kernel.js

@@ -71,6 +71,7 @@ const COMPLETE_AND_BREAK_REASONS = [
     "verification-pause",
     "finalize-pre-timeout",
     "finalize-post-timeout",
+    "milestone-complete",
 ];
 function isCompleteAndBreakReason(reason) {
     return COMPLETE_AND_BREAK_REASONS.includes(reason);

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

@@ -1,7 +1,8 @@
 // Project/App: gsd-pi
 // File Purpose: Declarative auto-mode dispatch rules and dispatch resolver.
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
-import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone, insertAssessment, setSliceSketchFlag, transaction, getAssessment, } from "./gsd-db.js";
+import { getUatBrowserToolSupportError } from "./uat-policy.js";
+import { isDbAvailable, getMilestoneSlices, getPendingGatesForTurn, markPendingGatesOmittedForTurn, getMilestone, insertArtifact, insertAssessment, setSliceSketchFlag, transaction, getAssessment, } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
 import { gsdRoot, resolveGsdPathContract, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, relTaskFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, gsdProjectionRoot, } from "./paths.js";
@@ -12,7 +13,7 @@ import { logWarning, logError } from "./workflow-logger.js";
 import { dirname, join } from "node:path";
 import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
 import { buildDiscussMilestonePrompt, buildDiscussProjectPrompt, buildDiscussRequirementsPrompt, buildResearchDecisionPrompt, buildResearchProjectPrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildRefineSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
-import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
+import { resolveModelWithFallbacksForUnit, resolveThinkingLevelForUnit } from "./preferences-models.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { selectReactiveDispatchBatch } from "./uok/execution-graph.js";
 import { getMilestonePipelineVariant } from "./milestone-scope-classifier.js";
@@ -250,6 +251,43 @@ export function findMissingSummaries(basePath, mid) {
     })
         .map(s => s.id);
 }
+function stringField(row, key) {
+    const value = row?.[key];
+    return typeof value === "string" ? value : null;
+}
+function stripGsdPrefix(path) {
+    return path.startsWith(".gsd/") ? path.slice(".gsd/".length) : path;
+}
+function persistSliceAssessmentBackfill(assessmentRelPath, mid, sliceId, content) {
+    const artifactPath = stripGsdPrefix(assessmentRelPath);
+    const existingAssessment = getAssessment(assessmentRelPath) ??
+        getAssessment(artifactPath);
+    const scope = stringField(existingAssessment, "scope") ?? "run-uat";
+    const status = stringField(existingAssessment, "status") ??
+        extractVerdict(content)?.toLowerCase() ??
+        "unknown";
+    transaction(() => {
+        insertArtifact({
+            path: artifactPath,
+            artifact_type: "ASSESSMENT",
+            milestone_id: mid,
+            slice_id: sliceId,
+            task_id: null,
+            full_content: content,
+        });
+        if (!getAssessment(assessmentRelPath)) {
+            insertAssessment({
+                path: assessmentRelPath,
+                milestoneId: mid,
+                sliceId,
+                taskId: null,
+                status,
+                scope,
+                fullContent: content,
+            });
+        }
+    });
+}
 function backfillMissingAssessmentsFromSummaries(basePath, mid) {
     const completedSliceIds = new Set();
     if (isDbAvailable()) {
@@ -281,11 +319,12 @@ function backfillMissingAssessmentsFromSummaries(basePath, mid) {
         const slicePath = resolveSlicePath(basePath, mid, sliceId);
         const assessmentPath = resolveSliceFile(basePath, mid, sliceId, "ASSESSMENT")
             ?? (slicePath ? join(slicePath, buildSliceFileName(sliceId, "ASSESSMENT")) : null);
-        if (!assessmentPath || existsSync(assessmentPath))
+        if (!assessmentPath)
             continue;
-        mkdirSync(dirname(assessmentPath), { recursive: true });
+        const assessmentRelPath = relSliceFile(basePath, mid, sliceId, "ASSESSMENT");
         const now = new Date().toISOString();
-        const content = [
+        const didCreateAssessment = !existsSync(assessmentPath);
+        const content = didCreateAssessment ? [
             "---",
             `sliceId: ${sliceId}`,
             "verdict: PASS",
@@ -297,8 +336,19 @@ function backfillMissingAssessmentsFromSummaries(basePath, mid) {
             "Auto-created during milestone validation because this completed slice had a SUMMARY but no ASSESSMENT artifact.",
             "No additional reassessment changes were detected in this backfill step.",
             "",
-        ].join("\n");
-        writeFileSync(assessmentPath, content, "utf-8");
+        ].join("\n") : readFileSync(assessmentPath, "utf-8");
+        if (isDbAvailable()) {
+            try {
+                persistSliceAssessmentBackfill(assessmentRelPath, mid, sliceId, content);
+            }
+            catch (err) {
+                logWarning("dispatch", `failed to backfill assessment DB rows for ${mid}/${sliceId}: ${err.message}`);
+            }
+        }
+        if (didCreateAssessment) {
+            mkdirSync(dirname(assessmentPath), { recursive: true });
+            writeFileSync(assessmentPath, content, "utf-8");
+        }
     }
 }
 // ─── Rewrite Circuit Breaker ──────────────────────────────────────────────
@@ -480,6 +530,15 @@ export const DISPATCH_RULES = [
             if (transportError) {
                 return { action: "stop", reason: transportError, level: "warning" };
             }
+            const browserToolError = getUatBrowserToolSupportError({
+                uatType,
+                activeTools,
+                milestoneId: mid,
+                sliceId,
+            });
+            if (browserToolError) {
+                return { action: "stop", reason: browserToolError, level: "warning" };
+            }
             // Cap run-uat dispatch attempts to prevent infinite replay (#3624).
             // Check before incrementing so an exhausted counter cannot create a
             // no-progress skip loop that starves later dispatch rules.
@@ -885,7 +944,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "research-slice",
                 unitId: `${mid}/parallel-research`,
-                prompt: await buildParallelResearchSlicesPrompt(mid, midTitle, researchReadySlices, basePath, resolveModelWithFallbacksForUnit("subagent")?.primary),
+                prompt: await buildParallelResearchSlicesPrompt(mid, midTitle, researchReadySlices, basePath, resolveModelWithFallbacksForUnit("subagent")?.primary, resolveThinkingLevelForUnit("subagent")),
             };
         },
     },
@@ -1037,17 +1096,17 @@ export const DISPATCH_RULES = [
             // Gate evaluation is opt-in via preferences
             const gateConfig = prefs?.gate_evaluation;
             if (!gateConfig?.enabled) {
-                markAllGatesOmitted(mid, sid);
+                markPendingGatesOmittedForTurn(mid, sid, "gate-evaluate");
                 return { action: "skip" };
             }
-            const pending = getPendingGates(mid, sid, "slice");
+            const pending = getPendingGatesForTurn(mid, sid, "gate-evaluate");
             if (pending.length === 0)
                 return { action: "skip" };
             return {
                 action: "dispatch",
                 unitType: "gate-evaluate",
                 unitId: `${mid}/${sid}/gates+${pending.map(g => g.gate_id).join(",")}`,
-                prompt: await buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, basePath, resolveModelWithFallbacksForUnit("subagent")?.primary),
+                prompt: await buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, basePath, resolveModelWithFallbacksForUnit("subagent")?.primary, resolveThinkingLevelForUnit("subagent")),
             };
         },
     },
@@ -1090,6 +1149,7 @@ export const DISPATCH_RULES = [
                 return null;
             const maxParallel = reactiveConfig?.max_parallel ?? 2;
             const subagentModel = reactiveConfig?.subagent_model ?? resolveModelWithFallbacksForUnit("subagent")?.primary;
+            const subagentThinking = resolveThinkingLevelForUnit("subagent");
             // Default-on safety threshold: only activate reactive dispatch when at
             // least N tasks are ready. Users who explicitly enabled reactive_execution
             // keep the legacy threshold of 2 (matches the prior "any parallelism is
@@ -1147,7 +1207,7 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "reactive-execute",
                     unitId: `${mid}/${sid}/reactive+${batchSuffix}`,
-                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel, { sessionContextWindow, modelRegistry, sessionProvider }),
+                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel, { sessionContextWindow, modelRegistry, sessionProvider, subagentThinking }),
                 };
             }
             catch (err) {