@opengsd/gsd-pi 1.5.0-dev.4fb2d460 → 1.5.0-dev.c4c8885f

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

@@ -1 +1 @@
-dc6f7673892b74e1
+d89940a8e727f2ea

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

@@ -4,8 +4,6 @@ import { Type } from "@sinclair/typebox";
 import { BROWSER_CONTRACT_TOOL_NAMES } from "../../shared/browser-contract.js";
 import { resolveGsdBrowserMcpLaunchConfig } from "../../shared/gsd-browser-cli.js";
 import { buildMcpChildEnv } from "../../mcp-client/manager.js";
-const connections = new Map();
-const pendingConnections = new Map();
 const DEFAULT_MAX_LINES = 2_000;
 const DEFAULT_MAX_BYTES = 50 * 1024;
 const MCP_CALL_TIMEOUT_MS = 60_000;
@@ -297,6 +295,103 @@ function buildConnectionKey(launch) {
         env: launch.env ?? {},
     });
 }
+function combineAbortSignals(poolSignal, callerSignal) {
+    if (!callerSignal)
+        return poolSignal;
+    if (typeof AbortSignal.any === "function") {
+        return AbortSignal.any([poolSignal, callerSignal]);
+    }
+    const controller = new AbortController();
+    const abort = () => {
+        if (!controller.signal.aborted)
+            controller.abort();
+    };
+    if (poolSignal.aborted || callerSignal.aborted) {
+        abort();
+    }
+    else {
+        poolSignal.addEventListener("abort", abort, { once: true });
+        callerSignal.addEventListener("abort", abort, { once: true });
+    }
+    return controller.signal;
+}
+export class ManagedGsdBrowserConnectionPool {
+    connections = new Map();
+    pendingConnections = new Map();
+    connect;
+    closeConnection;
+    generation = 0;
+    closing = false;
+    constructor(connect, closeConnection) {
+        this.connect = connect;
+        this.closeConnection = closeConnection;
+    }
+    get activeCount() {
+        return this.connections.size;
+    }
+    get pendingCount() {
+        return this.pendingConnections.size;
+    }
+    getOrConnect(launch, signal) {
+        if (this.closing) {
+            return Promise.reject(new Error("gsd-browser connection pool is closing"));
+        }
+        const key = buildConnectionKey(launch);
+        const existing = this.connections.get(key);
+        if (existing)
+            return Promise.resolve(existing);
+        const pending = this.pendingConnections.get(key);
+        if (pending)
+            return pending.promise;
+        const generation = this.generation;
+        const abortController = new AbortController();
+        const connectionSignal = combineAbortSignals(abortController.signal, signal);
+        const connectionPromise = this.connect(launch, connectionSignal)
+            .then(async (connection) => {
+            if (this.closing || this.generation !== generation) {
+                await this.closeConnection(connection);
+                throw new Error("gsd-browser connection closed during startup");
+            }
+            this.connections.set(key, connection);
+            return connection;
+        })
+            .finally(() => {
+            if (this.pendingConnections.get(key)?.promise === connectionPromise) {
+                this.pendingConnections.delete(key);
+            }
+        });
+        this.pendingConnections.set(key, { promise: connectionPromise, abortController });
+        return connectionPromise;
+    }
+    async closeAll() {
+        this.closing = true;
+        this.generation += 1;
+        const activeConnections = Array.from(this.connections.values());
+        const pendingConnections = Array.from(this.pendingConnections.values());
+        this.connections.clear();
+        this.pendingConnections.clear();
+        for (const pending of pendingConnections) {
+            pending.abortController.abort();
+        }
+        const closingActive = activeConnections.map((connection) => this.closeConnection(connection));
+        const closingPending = pendingConnections.map(async (pending) => {
+            try {
+                const connection = await pending.promise;
+                await this.closeConnection(connection);
+            }
+            catch {
+                // Failed or invalidated connection attempts have already cleaned up.
+            }
+        });
+        try {
+            await Promise.allSettled([...closingActive, ...closingPending]);
+        }
+        finally {
+            this.closing = false;
+            this.generation += 1;
+        }
+    }
+}
 async function connectManagedGsdBrowser(launch, signal) {
     const client = new Client({ name: "gsd-pi-browser-tools", version: "1.0.0" });
     const transport = new StdioClientTransport({
@@ -326,27 +421,26 @@ async function connectManagedGsdBrowser(launch, signal) {
         throw error;
     }
 }
+async function closeManagedGsdBrowserConnection(connection) {
+    try {
+        await connection.client.close();
+    }
+    catch {
+        // Best-effort cleanup.
+    }
+    try {
+        await connection.transport.close();
+    }
+    catch {
+        // Best-effort cleanup.
+    }
+}
+const connectionPool = new ManagedGsdBrowserConnectionPool(connectManagedGsdBrowser, closeManagedGsdBrowserConnection);
 async function getOrConnectManagedGsdBrowser(ctx, signal) {
     const launch = resolveGsdBrowserMcpLaunchConfig(resolveProjectRoot(ctx), process.env, {
         sessionSuffix: resolveManagedSessionSuffix(ctx),
     });
-    const key = buildConnectionKey(launch);
-    const existing = connections.get(key);
-    if (existing)
-        return existing;
-    const pending = pendingConnections.get(key);
-    if (pending)
-        return pending;
-    const connectionPromise = connectManagedGsdBrowser(launch, signal);
-    pendingConnections.set(key, connectionPromise);
-    try {
-        const connection = await connectionPromise;
-        connections.set(key, connection);
-        return connection;
-    }
-    finally {
-        pendingConnections.delete(key);
-    }
+    return connectionPool.getOrConnect(launch, signal);
 }
 function isUnknownMcpToolError(error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -609,23 +703,7 @@ export function registerManagedGsdBrowserTools(pi) {
     }
 }
 export async function closeManagedGsdBrowser() {
-    const closing = Array.from(connections.entries()).map(async ([key, connection]) => {
-        try {
-            await connection.client.close();
-        }
-        catch {
-            // Best-effort cleanup.
-        }
-        try {
-            await connection.transport.close();
-        }
-        catch {
-            // Best-effort cleanup.
-        }
-        connections.delete(key);
-    });
-    await Promise.allSettled(closing);
-    pendingConnections.clear();
+    await connectionPool.closeAll();
 }
 export async function _resetManagedGsdBrowserForTest() {
     await closeManagedGsdBrowser();

package/dist/resources/extensions/gsd/activity-log.js

@@ -115,7 +115,7 @@ export function saveActivityLog(ctx, basePath, unitType, unitId) {
         }
         state.nextSeq += 1;
         state.lastSnapshotKeyByUnit.set(unitKey, key);
-        if (isUnifiedAuditEnabled()) {
+        if (isUnifiedAuditEnabled(basePath)) {
             emitUokAuditEvent(basePath, buildAuditEnvelope({
                 traceId: `activity:${unitType}:${unitId}`,
                 turnId: unitId,

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

@@ -999,16 +999,22 @@ export class AutoOrchestrator {
                 this.postAdvanceRecord(skipped);
                 return skipped;
             }
-            // Stuck-loop detection: when the window is saturated with copies of
-            // `nextKey` (count >= STUCK_WINDOW_SIZE), consult the Dispatch History
-            // module's full detect-stuck rule set for the verdict instead of the old
-            // bare saturation count. This keeps the saturation threshold (the window
-            // deliberately records benign idempotent repeats, so earlier-firing
-            // rules would false-positive on pause/resume re-advances) while gaining
-            // retry-budget suppression and diagnosable rule reasons. A saturated
-            // window with no verdict means the dispatch ledger says we are inside
-            // the unit's retry-backoff budget — let the retry proceed.
-            const stuckVerdict = matchingCount >= STUCK_WINDOW_SIZE ? this.dispatchHistory.detectStuck() : null;
+            // Stuck-loop detection: consult the Dispatch History module's full
+            // detect-stuck rule set once the window is *full* — not only when a
+            // single key saturates it. Gating on a single key's saturation count
+            // (matchingCount >= STUCK_WINDOW_SIZE) let two-unit oscillations slip
+            // through forever: an execute-task ↔ complete-slice loop (a slice gate
+            // that keeps reopening the same task, #1225) fills the window with two
+            // alternating keys, so neither key ever reaches the saturation count and
+            // detect-stuck's oscillation/repeat rules were never even invoked. Firing
+            // on window saturation instead covers both shapes. Consecutive same-key
+            // re-advances (the benign pause/resume churn the old count gate guarded
+            // against) are already short-circuited above by the idempotency skip, and
+            // legitimate retry backoff is still suppressed inside detect-stuck via the
+            // dispatch ledger — a saturated window with no verdict means we are inside
+            // the unit's retry-backoff budget, so let the retry proceed.
+            const windowSaturated = this.dispatchHistory.getRecentWindow().length >= STUCK_WINDOW_SIZE;
+            const stuckVerdict = windowSaturated ? this.dispatchHistory.detectStuck() : null;
             if (stuckVerdict) {
                 // #442: before declaring a stuck loop, verify the unit didn't actually
                 // complete on disk (stale DB) and recover if so — legacy graduated

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -5,7 +5,7 @@
 // resolveExpectedArtifactPath and diagnoseExpectedArtifact moved here from
 // auto-recovery.ts (Phase 5 dead-code cleanup). The artifact verification
 // function was removed entirely — callers now query WorkflowEngine directly.
-import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, } from "./paths.js";
+import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, normalizeRealPath, } from "./paths.js";
 import { milestoneIdToPhaseNum } from "./layout-policy.js";
 import { parseUnitId } from "./unit-id.js";
 import { basename, dirname, join, relative } from "node:path";
@@ -308,7 +308,7 @@ export function resolveSliceResearchLocation(basePath, mid, sid) {
     if (canonicalPath && existsSync(canonicalPath)) {
         return {
             absolutePath: canonicalPath,
-            relativePath: relative(basePath, canonicalPath),
+            relativePath: relative(normalizeRealPath(basePath), canonicalPath),
         };
     }
     return { absolutePath: null, relativePath: null };

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

@@ -12,8 +12,9 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdir
 import { logWarning, logError } from "./workflow-logger.js";
 import { dirname, join, sep } 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, resolveThinkingLevelForUnit } from "./preferences-models.js";
+import { buildDiscussMilestonePrompt, buildDiscussProjectPrompt, buildDiscussRequirementsPrompt, buildResearchDecisionPrompt, buildResearchProjectPrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildRefineSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, loadRoadmapCompletedSliceCandidates, } from "./auto-prompts.js";
+import { checkNeedsRunUat } from "./uat-dispatch.js";
+import { normalizeModelFieldConfig, 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";
@@ -142,12 +143,21 @@ export async function readUatGateVerdict(basePath, mid, sliceId) {
         if (assessmentScope === "roadmap") {
             return null;
         }
-        const assessmentVerdict = extractVerdict(assessmentContent);
-        if (assessmentVerdict) {
-            return {
-                verdict: assessmentVerdict,
-                uatType: uatType ?? extractUatType(assessmentContent),
-            };
+        // Backfilled assessments (#1258) are placeholders created during milestone
+        // validation for completed slices that never produced a real UAT ASSESSMENT
+        // (e.g. artifact-driven UAT that was never dispatched). Their fabricated
+        // verdict must not be treated as a genuine UAT sign-off — otherwise "never
+        // checked" is silently read as "passed". Skip the placeholder and fall
+        // through to the authoritative run-uat DB row (which stays null unless a
+        // real UAT was actually recorded).
+        if (assessmentScope !== BACKFILL_ASSESSMENT_SCOPE) {
+            const assessmentVerdict = extractVerdict(assessmentContent);
+            if (assessmentVerdict) {
+                return {
+                    verdict: assessmentVerdict,
+                    uatType: uatType ?? extractUatType(assessmentContent),
+                };
+            }
         }
     }
     if (uatContent) {
@@ -291,11 +301,20 @@ function stringField(row, key) {
 function stripGsdPrefix(path) {
     return path.startsWith(".gsd/") ? path.slice(".gsd/".length) : path;
 }
-function persistSliceAssessmentBackfill(assessmentRelPath, mid, sliceId, content) {
+// Scope marker for assessments fabricated by the milestone-validation backfill
+// (#1258). It keeps these placeholders distinguishable from genuine `run-uat`
+// sign-offs so `readUatGateVerdict` never mistakes "never checked" for "passed".
+const BACKFILL_ASSESSMENT_SCOPE = "backfill";
+function persistSliceAssessmentBackfill(assessmentRelPath, mid, sliceId, content, fabricated) {
     const artifactPath = stripGsdPrefix(assessmentRelPath);
     const existingAssessment = getAssessment(assessmentRelPath) ??
         getAssessment(artifactPath);
-    const scope = stringField(existingAssessment, "scope") ?? "run-uat";
+    // A newly fabricated placeholder is filed under a distinct scope; a pre-existing
+    // on-disk ASSESSMENT keeps its real scope (default `run-uat`) so genuine
+    // sign-offs are still honored.
+    const scope = fabricated
+        ? BACKFILL_ASSESSMENT_SCOPE
+        : stringField(existingAssessment, "scope") ?? "run-uat";
     const status = stringField(existingAssessment, "status") ??
         extractVerdict(content)?.toLowerCase() ??
         "unknown";
@@ -343,18 +362,24 @@ function backfillMissingAssessmentsFromSummaries(basePath, mid) {
             "---",
             `sliceId: ${sliceId}`,
             "verdict: PASS",
+            // Distinguishing marker (#1258): this ASSESSMENT was fabricated to satisfy
+            // the per-slice artifact requirement, NOT produced by a real UAT run. It
+            // must not be read as a genuine UAT sign-off.
+            "backfilled: true",
+            "verified: false",
             `date: ${now}`,
             "---",
             "",
             `# Assessment — ${sliceId}`,
             "",
             "Auto-created during milestone validation because this completed slice had a SUMMARY but no ASSESSMENT artifact.",
+            "This is a placeholder: no UAT was executed for this slice, so its verdict is not an independent sign-off.",
             "No additional reassessment changes were detected in this backfill step.",
             "",
         ].join("\n") : readFileSync(assessmentPath, "utf-8");
         if (isDbAvailable()) {
             try {
-                persistSliceAssessmentBackfill(assessmentRelPath, mid, sliceId, content);
+                persistSliceAssessmentBackfill(assessmentRelPath, mid, sliceId, content, didCreateAssessment);
             }
             catch (err) {
                 logWarning("dispatch", `failed to backfill assessment DB rows for ${mid}/${sliceId}: ${err.message}`);
@@ -534,7 +559,7 @@ export const DISPATCH_RULES = [
     {
         name: "run-uat (post-completion)",
         match: async ({ state, mid, basePath, prefs, sessionProvider, sessionAuthMode, activeTools, registeredTools, sessionBaseUrl, }) => {
-            const needsRunUat = await checkNeedsRunUat(basePath, mid, state, prefs);
+            const needsRunUat = await checkNeedsRunUat(basePath, mid, prefs, await loadRoadmapCompletedSliceCandidates(basePath, mid));
             if (!needsRunUat)
                 return null;
             const { sliceId, uatType } = needsRunUat;
@@ -1168,8 +1193,15 @@ export const DISPATCH_RULES = [
             if (resolveSliceFile(basePath, mid, sid, "REACTIVE-BLOCKER"))
                 return null;
             const maxParallel = reactiveConfig?.max_parallel ?? 2;
-            const subagentModel = reactiveConfig?.subagent_model ?? resolveModelWithFallbacksForUnit("subagent")?.primary;
-            const subagentThinking = resolveThinkingLevelForUnit("subagent");
+            // `subagent_model` accepts the phase-bucket object form (#1229); honor the
+            // full primary→fallbacks chain in the dispatch prompt (the reactive
+            // subagent model is embedded there rather than set as the session model).
+            const subagentModelConfig = normalizeModelFieldConfig(reactiveConfig?.subagent_model)
+                ?? resolveModelWithFallbacksForUnit("subagent");
+            const subagentModel = subagentModelConfig?.primary;
+            // Prefer the per-field `thinking` carried on `reactive_execution.subagent_model`'s
+            // object form over the phase-bucket `subagent` level (#1269).
+            const subagentThinking = subagentModelConfig?.thinking ?? 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
@@ -1229,7 +1261,13 @@ 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, subagentThinking }),
+                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel, {
+                        sessionContextWindow,
+                        modelRegistry,
+                        sessionProvider,
+                        subagentThinking,
+                        subagentModelFallbacks: subagentModelConfig?.fallbacks,
+                    }),
                 };
             }
             catch (err) {

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -219,10 +219,37 @@ function buildModelPolicyBlockReasons(policyDenyReasons, availableModels, routin
             reason: `configured model(s) did not resolve against policy-eligible registry [${eligibleSummary}]`,
         }];
 }
-function isModelUnavailable(basePath, provider, id) {
+export function isModelUnavailable(basePath, provider, id) {
     return isModelBlocked(basePath, provider, id) ||
         isModelTemporarilyUnavailable(basePath, provider, id);
 }
+/** Apply `auto_supervisor.model`, walking configured fallbacks on unavailability (#1229). */
+export async function applySupervisorModelIfConfigured(ctx, pi, basePath) {
+    const modelConfig = resolveModelWithFallbacksForUnit("supervisor", basePath);
+    if (!modelConfig)
+        return;
+    const availableModels = ctx.modelRegistry.getAvailable();
+    for (const candidate of [modelConfig.primary, ...modelConfig.fallbacks]) {
+        const match = resolveModelId(candidate, availableModels, ctx.model?.provider);
+        if (!match)
+            continue;
+        if (isModelUnavailable(basePath, match.provider, match.id))
+            continue;
+        try {
+            if (await pi.setModel(match, { persist: false })) {
+                // Prefer the per-field `thinking` from `auto_supervisor.model`'s object
+                // form over the session level so a configured supervisor level actually
+                // applies (#1269).
+                applyThinkingLevelForModel(pi, modelConfig.thinking ?? pi.getThinkingLevel(), match, ctx);
+                return;
+            }
+        }
+        catch (err) {
+            // Non-fatal — try the next fallback.
+            logWarning("dispatch", `supervisor model set failed for ${candidate}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
 function restoreToolBaseline(pi) {
     const key = pi;
     const baseline = TOOL_BASELINE.get(key);

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -17,7 +17,7 @@ import { logWarning, logError } from "./workflow-logger.js";
 import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { isAwaitingUserInput } from "./consent-question.js";
-import { resolveSliceFile, resolveSlicePath, relSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, resolveFile, relMilestoneFile, relSliceFile, relTaskFile, } from "./paths.js";
+import { resolveSliceFile, resolveSlicePath, relSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, resolveFile, relMilestoneFile, relSliceFile, relTaskFile, normalizeRealPath, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
@@ -770,7 +770,7 @@ function describeArtifactVerificationFailure(unitType, unitId, basePath, agentEn
     if (!artifactPath) {
         return `Artifact verification failed: ${unitType} "${unitId}" has no resolvable artifact path.`;
     }
-    const relPath = relative(basePath, artifactPath);
+    const relPath = relative(normalizeRealPath(basePath), artifactPath);
     if (!existsSync(artifactPath)) {
         const completionToolHint = unitType === "execute-task" && !hasTaskCompletionToolCall(agentEndMessages)
             ? " No completion tool call detected (`gsd_task_complete`/alias)."
@@ -1987,7 +1987,8 @@ export async function postUnitPostVerification(pctx) {
             persistHookState(s.basePath);
             const verdict = gateBlock.verdict ? ` verdict=${gateBlock.verdict};` : "";
             const artifact = gateBlock.artifact ? ` artifact=${gateBlock.artifact};` : "";
-            const message = `Post-unit gate "${gateBlock.hookName}" blocked ${gateBlock.triggerUnitType} ${gateBlock.triggerUnitId}:` +
+            const message = `Post-unit gate "${gateBlock.hookName}" blocked ${gateBlock.triggerUnitType} ${gateBlock.triggerUnitId} ` +
+                `(detected on completion of ${s.currentUnit.type} ${s.currentUnit.id}):` +
                 `${verdict}${artifact} ${gateBlock.reason}. Run /gsd status to inspect, then /gsd auto after recovery.`;
             ctx.ui.notify(message, "warning");
             await pauseAuto(ctx, pi);

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

@@ -8,7 +8,7 @@
  * utility.
  */
 import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection } from "./files.js";
-import { hasVerdict, extractVerdict } from "./verdict-parser.js";
+import { extractVerdict } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, relTaskFile, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
 import { resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
@@ -35,7 +35,8 @@ import { debugLog } from "./debug-logger.js";
 import { buildSkillActivationBlock, buildSkillDiscoveryVars } from "./skill-activation.js";
 import { findMilestoneIds } from "./milestone-ids.js";
 import { buildRunUatPresentationForType, RUN_UAT_TOOL_PRESENTATION_PLAN_ID } from "./tool-presentation-plan.js";
-import { classifyUatContentForRun, shouldDispatchUatForContent, } from "./uat-policy.js";
+import { classifyUatContentForRun } from "./uat-policy.js";
+import { checkNeedsRunUat as resolveNeedsRunUat } from "./uat-dispatch.js";
 import { buildWebAppUatGuidanceBlock } from "./web-app-uat.js";
 export { buildSkillActivationBlock, buildSkillDiscoveryVars };
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
@@ -1320,120 +1321,26 @@ export async function checkNeedsReassessment(base, mid, state) {
         return null;
     return { sliceId: lastDone };
 }
+export function getRoadmapCompletedSliceCandidates(roadmapContent) {
+    return parseRoadmap(roadmapContent)
+        .slices.filter((slice) => slice.done)
+        .map((slice) => ({ sliceId: slice.id }))
+        .reverse();
+}
+export async function loadRoadmapCompletedSliceCandidates(base, mid) {
+    const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+    const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
+    return roadmapContent ? getRoadmapCompletedSliceCandidates(roadmapContent) : [];
+}
 /**
- * Check if the most recently completed slice needs a UAT run.
- * Returns { sliceId, uatType } if UAT should be dispatched, null otherwise.
- *
- * Skips when:
- * - No roadmap or no completed slices
- * - uat_dispatch is not enabled and the UAT spec does not require runtime/browser evidence
- * - No UAT file exists for the slice
- * - UAT result file already exists (idempotent — already ran)
- */
-/**
- * Resolve the effective UAT mode for the dispatch gate the same way
- * `buildRunUatPrompt` does: classify the UAT body with the slice's SUMMARY as
- * supplemental context, so a `browser-executable` UAT whose slice references a
- * self-contained harness (`npm run test:uat`, `search-uat.mjs`, `npx
- * playwright test`) is promoted to `runtime-executable` for the gate too.
- *
- * Without this, `checkNeedsRunUat` returns `browser-executable` while the
- * prompt instructs runtime-only execution, causing the dispatch gate to
- * require browser tools / warm up the browser daemon (or stop dispatch when
- * browser MCP is unavailable) for UAT runs that never touch the browser. See
- * cursor[bot] review on PR #696 for the M007/S01 regression.
+ * Back-compat wrapper for callers that import UAT dispatch checks from the
+ * prompt module. UAT dispatch architecture lives in `uat-dispatch.ts`; the
+ * `state` parameter is intentionally ignored because DB/roadmap artifacts are
+ * the source of truth for completed-slice discovery.
  */
-async function resolveRunUatEffectiveType(base, mid, sliceId, uatContent) {
-    let summaryContent = "";
-    try {
-        const summaryPath = resolveSliceFile(base, mid, sliceId, "SUMMARY");
-        if (summaryPath) {
-            summaryContent = (await loadFile(summaryPath)) ?? "";
-        }
-    }
-    catch (err) {
-        logWarning("prompt", `resolveRunUatEffectiveType SUMMARY load failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    return classifyUatContentForRun(uatContent, summaryContent).effectiveType;
-}
 export async function checkNeedsRunUat(base, mid, state, prefs) {
-    // DB primary path — fall through to file-based when DB has no data for this milestone
-    try {
-        const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
-        if (isDbAvailable()) {
-            const slices = getMilestoneSlices(mid);
-            if (slices.length > 0) {
-                const completedSlices = slices.filter(s => s.status === "complete");
-                if (completedSlices.length === 0)
-                    return null;
-                for (const completed of [...completedSlices].reverse()) {
-                    const sid = completed.id;
-                    const uatFile = resolveSliceFile(base, mid, sid, "UAT");
-                    if (!uatFile)
-                        continue;
-                    const uatContent = await loadFile(uatFile);
-                    if (!uatContent)
-                        continue;
-                    // If the UAT file already contains a verdict, UAT has been run — skip
-                    if (hasVerdict(uatContent))
-                        continue;
-                    // Also check the ASSESSMENT file — the run-uat prompt writes the verdict
-                    // there (via gsd_uat_result_save), not into the
-                    // UAT spec file. Without this check the unit re-dispatches indefinitely.
-                    const assessmentFile = resolveSliceFile(base, mid, sid, "ASSESSMENT");
-                    if (assessmentFile) {
-                        const assessmentContent = await loadFile(assessmentFile);
-                        if (assessmentContent && hasVerdict(assessmentContent))
-                            continue;
-                    }
-                    if (!shouldDispatchUatForContent(uatContent, prefs))
-                        continue;
-                    const uatType = await resolveRunUatEffectiveType(base, mid, sid, uatContent);
-                    return { sliceId: sid, uatType };
-                }
-                return null;
-            }
-        }
-    }
-    catch (err) {
-        logWarning("prompt", `checkNeedsRunUat DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    // File-based fallback using roadmap checkboxes
-    const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
-    if (!roadmapPath)
-        return null;
-    const roadmapContent = await loadFile(roadmapPath);
-    if (!roadmapContent)
-        return null;
-    const parsed = parseRoadmap(roadmapContent);
-    const completedFileSlices = parsed.slices.filter(s => s.done);
-    if (completedFileSlices.length === 0)
-        return null;
-    for (const completed of [...completedFileSlices].reverse()) {
-        const uatSid = completed.id;
-        const uatFileFb = resolveSliceFile(base, mid, uatSid, "UAT");
-        if (!uatFileFb)
-            continue;
-        const uatContentFb = await loadFile(uatFileFb);
-        if (!uatContentFb)
-            continue;
-        // If the UAT file already contains a verdict, UAT has been run — skip
-        if (hasVerdict(uatContentFb))
-            continue;
-        // Also check the ASSESSMENT file for the file-based fallback path (same
-        // reason as the DB path above — verdict lives in ASSESSMENT, not UAT).
-        const assessmentFileFb = resolveSliceFile(base, mid, uatSid, "ASSESSMENT");
-        if (assessmentFileFb) {
-            const assessmentContentFb = await loadFile(assessmentFileFb);
-            if (assessmentContentFb && hasVerdict(assessmentContentFb))
-                continue;
-        }
-        if (!shouldDispatchUatForContent(uatContentFb, prefs))
-            continue;
-        const uatType = await resolveRunUatEffectiveType(base, mid, uatSid, uatContentFb);
-        return { sliceId: uatSid, uatType };
-    }
-    return null;
+    void state;
+    return resolveNeedsRunUat(base, mid, prefs, await loadRoadmapCompletedSliceCandidates(base, mid));
 }
 export async function buildDiscussMilestoneInlinedContext(mid, base) {
     const inlined = [];
@@ -3401,10 +3308,15 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
  * that instructs the coordinator how to dispatch a `subagent` call. Either or
  * both may be absent (ADR-026 / #508).
  */
-function subagentCallSuffix(model, thinking) {
+function subagentCallSuffix(model, thinking, fallbacks) {
     const parts = [];
-    if (model)
-        parts.push(`model: "${model}"`);
+    if (model) {
+        let modelHint = `model: "${model}"`;
+        if (fallbacks && fallbacks.length > 0) {
+            modelHint += ` (fallbacks, in order: ${fallbacks.map((f) => `"${f}"`).join(", ")})`;
+        }
+        parts.push(modelHint);
+    }
     if (thinking)
         parts.push(`thinking: "${thinking}"`);
     return parts.length > 0 ? ` with ${parts.join(" and ")}` : "";
@@ -3490,7 +3402,7 @@ opts) {
             "",
             `When done, say: "Task ${tid} complete."`,
         ].join("\n");
-        const modelSuffix = subagentCallSuffix(subagentModel, opts?.subagentThinking);
+        const modelSuffix = subagentCallSuffix(subagentModel, opts?.subagentThinking, opts?.subagentModelFallbacks);
         subagentSections.push([
             `### ${tid}: ${tTitle}`,
             "",