@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.eed73bea

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

@@ -4,17 +4,28 @@
  */
 import { deriveState } from "./state.js";
 import { loadFile } from "./files.js";
-import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
-import { parseRoadmap } from "./parsers-legacy.js";
-import { resolveMilestoneFile, resolveSliceFile, relSliceFile, } from "./paths.js";
+import { isDbAvailable, getClosedSliceIds } from "./gsd-db.js";
+import { resolveSliceFile, relSliceFile, } from "./paths.js";
 import { buildResearchSlicePrompt, buildResearchMilestonePrompt, buildPlanSlicePrompt, buildPlanMilestonePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReassessRoadmapPrompt, buildRunUatPrompt, buildReplanSlicePrompt, } from "./auto-prompts.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
-import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "./workflow-mcp.js";
-export async function dispatchDirectPhase(ctx, pi, phase, base) {
+import { getUnitWorkflowDispatchReadinessError } from "./tool-contract.js";
+export function parseDirectDispatchPhase(raw) {
+    const tokens = raw.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return { phase: "" };
+    const phase = tokens[0].toLowerCase();
+    const milestoneToken = tokens.find((token, index) => index > 0 && /^M\d/i.test(token));
+    return {
+        phase,
+        milestoneId: milestoneToken?.replace(/[.,;:!?]+$/, ""),
+    };
+}
+export async function dispatchDirectPhase(ctx, pi, phase, base, opts = {}) {
+    const parsed = parseDirectDispatchPhase(phase);
     const state = await deriveState(base);
-    const mid = state.activeMilestone?.id;
+    const mid = opts.milestoneId ?? parsed.milestoneId ?? state.activeMilestone?.id;
     const midTitle = state.activeMilestone?.title ?? "";
     if (!mid) {
         ctx.ui.notify("Cannot dispatch: no active milestone.", "warning");
@@ -26,7 +37,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
     // build prompts and create a session anchored to the project root even
     // though the milestone's actual code lives in the worktree.
     const dispatchBase = resolveCanonicalMilestoneRoot(base, mid);
-    const normalized = phase.toLowerCase();
+    const normalized = parsed.phase;
     let unitType;
     let unitId;
     let prompt;
@@ -135,21 +146,9 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
         }
         case "reassess":
         case "reassess-roadmap": {
-            // DB primary path — get completed slices, fall back to file parsing when DB has no data
-            let completedSliceIds = [];
-            if (isDbAvailable()) {
-                completedSliceIds = getMilestoneSlices(mid).filter(s => s.status === "complete").map(s => s.id);
-            }
-            if (completedSliceIds.length === 0) {
-                // File-based fallback: parse roadmap checkboxes
-                const roadmapPath = resolveMilestoneFile(dispatchBase, mid, "ROADMAP");
-                if (roadmapPath) {
-                    const roadmapContent = await loadFile(roadmapPath);
-                    if (roadmapContent) {
-                        completedSliceIds = parseRoadmap(roadmapContent).slices.filter(s => s.done).map(s => s.id);
-                    }
-                }
-            }
+            // DB-authoritative read (ADR-017) — markdown projections are never
+            // consulted for dispatch decisions. No DB rows means no completed slices.
+            const completedSliceIds = isDbAvailable() ? getClosedSliceIds(mid) : [];
             if (completedSliceIds.length === 0) {
                 ctx.ui.notify("Cannot dispatch reassess-roadmap: no completed slices.", "warning");
                 return;
@@ -173,20 +172,9 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             // incomplete) slice. After slice completion, state.activeSlice advances
             // to the next incomplete slice, so we find the last done slice from the
             // roadmap instead (#1693).
-            let uatCompletedSliceIds = [];
-            if (isDbAvailable()) {
-                uatCompletedSliceIds = getMilestoneSlices(mid).filter(s => s.status === "complete").map(s => s.id);
-            }
-            if (uatCompletedSliceIds.length === 0) {
-                // File-based fallback: parse roadmap checkboxes
-                const roadmapPath = resolveMilestoneFile(dispatchBase, mid, "ROADMAP");
-                if (roadmapPath) {
-                    const roadmapContent = await loadFile(roadmapPath);
-                    if (roadmapContent) {
-                        uatCompletedSliceIds = parseRoadmap(roadmapContent).slices.filter(s => s.done).map(s => s.id);
-                    }
-                }
-            }
+            // DB-authoritative read (ADR-017) — no markdown fallback for dispatch
+            // decisions.
+            const uatCompletedSliceIds = isDbAvailable() ? getClosedSliceIds(mid) : [];
             if (uatCompletedSliceIds.length === 0) {
                 ctx.ui.notify("Cannot dispatch run-uat: no completed slices.", "warning");
                 return;
@@ -225,7 +213,8 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             ctx.ui.notify(`Unknown phase "${phase}". Valid phases: research, plan, execute, complete, validate, reassess, uat, replan.`, "warning");
             return;
     }
-    const compatibilityError = getWorkflowTransportSupportError(ctx.model?.provider, getRequiredWorkflowToolsForAutoUnit(unitType), {
+    const compatibilityError = getUnitWorkflowDispatchReadinessError({
+        provider: ctx.model?.provider,
         projectRoot,
         surface: "direct phase dispatch",
         unitType,

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

@@ -2,15 +2,14 @@
 // File Purpose: Declarative auto-mode dispatch rules and dispatch resolver.
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
 import { getUatBrowserToolSupportError } from "./uat-policy.js";
-import { isDbAvailable, getMilestoneSlices, getPendingGatesForTurn, markPendingGatesOmittedForTurn, getMilestone, insertArtifact, insertAssessment, setSliceSketchFlag, transaction, getAssessment, } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getMilestoneSliceSummaries, getClosedSliceIds, getPendingGatesForTurn, markPendingGatesOmittedForTurn, getMilestone, insertArtifact, insertAssessment, setSliceSketchFlag, transaction, getAssessment, getSliceRunUatAssessment, } 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";
-import { parseRoadmap } from "./parsers-legacy.js";
+import { gsdRoot, resolveGsdPathContract, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relTaskFile, relSliceFile, relMilestoneFile, buildTaskFileName, gsdProjectionRoot, } from "./paths.js";
 import { validateArtifact } from "./schemas/validate.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
-import { dirname, join } from "node:path";
+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";
@@ -19,10 +18,15 @@ import { selectReactiveDispatchBatch } from "./uok/execution-graph.js";
 import { getMilestonePipelineVariant } from "./milestone-scope-classifier.js";
 import { EXECUTION_ENTRY_PHASES, hasFinalizedMilestoneContext } from "./uok/plan-v2.js";
 import { isAutoActive } from "./auto.js";
-import { markDepthVerified } from "./bootstrap/write-gate.js";
+// Host adapter explicitly: auto-dispatch runs in the extension host, and the
+// ambient write-gate exports env-sniff the adapter per call (they are reserved
+// for the workflow MCP child's dynamic-import surface).
+import { hostWriteGateAdapter } from "./bootstrap/write-gate.js";
 import { ensureWorkflowPreferencesCaptured } from "./planning-depth.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
-import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "./workflow-mcp.js";
+import { resolveWorkflowMcpProjectRoot } from "./workflow-mcp.js";
+import { getUnitWorkflowDispatchReadinessError } from "./tool-contract.js";
+import { prepareBrowserDaemonForUat } from "./browser-daemon-auto-prep.js";
 import { PROJECT_RESEARCH_INFLIGHT_MARKER, } from "./project-research-policy.js";
 import { isWorkflowPrefsCaptured, resolveDeepProjectSetupState, } from "./deep-project-setup-policy.js";
 import { annotateBackgroundable } from "./delegation-policy.js";
@@ -37,13 +41,29 @@ import { probeGitConflictState } from "./git-conflict-state.js";
 import { runTurnGitAction } from "./git-service.js";
 import { parseUnitId } from "./unit-id.js";
 import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
-import { checkCloseoutConsistencyGate, formatCloseoutConsistencyBlock, } from "./closeout-consistency-gate.js";
+import { formatCloseoutProofBlock, proveMilestoneCloseout, } from "./milestone-closeout-proof.js";
 function resolveExistingExpectedArtifact(unitType, unitId, basePath) {
     const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
     return artifactPath && existsSync(artifactPath) ? artifactPath : null;
 }
 let reassessmentChecker = checkNeedsReassessment;
 let researchProjectPromptBuilder = buildResearchProjectPrompt;
+/**
+ * Optional override for the reactive graph derivation step inside the
+ * "executing → reactive-execute" rule. Production leaves this null so the rule
+ * uses the real loadSliceTaskIO + deriveTaskGraph; tests inject a throwing
+ * function to deterministically exercise the best-effort failure path
+ * (auto-dispatch.ts:1494). The catch is otherwise unreachable because every
+ * operation it wraps (loadSliceTaskIO, deriveTaskGraph, saveReactiveState) is
+ * internally defensive.
+ * @internal
+ */
+let _reactiveGraphDeriveFn = null;
+export function setReactiveGraphDeriveFnForTest(fn) {
+    const previous = _reactiveGraphDeriveFn;
+    _reactiveGraphDeriveFn = fn;
+    return () => { _reactiveGraphDeriveFn = previous; };
+}
 function shouldBypassMilestoneDepthGateInAuto(prefs) {
     return isAutoActive() && prefs?.planning_depth !== "deep";
 }
@@ -135,6 +155,18 @@ export async function readUatGateVerdict(basePath, mid, sliceId) {
             return { verdict: legacyUatVerdict, uatType };
         }
     }
+    // ADR-017 DB fallback: when the ASSESSMENT markdown is missing or orphaned
+    // from its canonical path (e.g. after a milestone artifact-layout migration
+    // moves slice artifacts from `phases/…` to `milestones/…`), consult the
+    // authoritative assessments table by (mid, slice) identity instead of path.
+    // `gsd_uat_result_save` always writes this row, so it is the source of truth.
+    const runUatAssessment = getSliceRunUatAssessment(mid, sliceId);
+    if (runUatAssessment?.status) {
+        return {
+            verdict: runUatAssessment.status,
+            uatType: uatType ?? extractUatType(runUatAssessment.fullContent),
+        };
+    }
     return null;
 }
 /**
@@ -289,36 +321,18 @@ function persistSliceAssessmentBackfill(assessmentRelPath, mid, sliceId, content
     });
 }
 function backfillMissingAssessmentsFromSummaries(basePath, mid) {
-    const completedSliceIds = new Set();
-    if (isDbAvailable()) {
-        for (const slice of getMilestoneSlices(mid)) {
-            if (slice.status === "complete" || slice.status === "done") {
-                completedSliceIds.add(slice.id);
-            }
-        }
-    }
-    else {
-        const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-        if (!roadmapFile)
-            return;
-        try {
-            const roadmap = parseRoadmap(readFileSync(roadmapFile, "utf-8"));
-            for (const slice of roadmap.slices) {
-                if (slice.done)
-                    completedSliceIds.add(slice.id);
-            }
-        }
-        catch {
-            return;
-        }
-    }
-    for (const sliceId of completedSliceIds) {
+    // DB-authoritative (ADR-017): no markdown fallback. Without DB rows there
+    // is nothing to backfill.
+    if (!isDbAvailable())
+        return;
+    // Canonical closed vocabulary (complete/done/skipped/closed) — a skipped or
+    // closed slice with a SUMMARY gets the same assessment backfill treatment.
+    for (const sliceId of getClosedSliceIds(mid)) {
         const summaryPath = resolveSliceFile(basePath, mid, sliceId, "SUMMARY");
         if (!summaryPath || !existsSync(summaryPath))
             continue;
-        const slicePath = resolveSlicePath(basePath, mid, sliceId);
         const assessmentPath = resolveSliceFile(basePath, mid, sliceId, "ASSESSMENT")
-            ?? (slicePath ? join(slicePath, buildSliceFileName(sliceId, "ASSESSMENT")) : null);
+            ?? join(basePath, relSliceFile(basePath, mid, sliceId, "ASSESSMENT"));
         if (!assessmentPath)
             continue;
         const assessmentRelPath = relSliceFile(basePath, mid, sliceId, "ASSESSMENT");
@@ -488,7 +502,7 @@ export const DISPATCH_RULES = [
             // deadlock. Deep planning is still user-driven even inside auto-mode,
             // so it must wait for explicit approval instead of taking this bypass.
             if (shouldBypassMilestoneDepthGateInAuto(prefs)) {
-                markDepthVerified(mid, basePath);
+                hostWriteGateAdapter.markDepthVerified(mid, basePath);
             }
             return {
                 action: "dispatch",
@@ -518,7 +532,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "run-uat (post-completion)",
-        match: async ({ state, mid, basePath, prefs, sessionProvider, sessionAuthMode, activeTools, sessionBaseUrl }) => {
+        match: async ({ state, mid, basePath, prefs, sessionProvider, sessionAuthMode, activeTools, registeredTools, sessionBaseUrl, }) => {
             const needsRunUat = await checkNeedsRunUat(basePath, mid, state, prefs);
             if (!needsRunUat)
                 return null;
@@ -526,19 +540,38 @@ export const DISPATCH_RULES = [
             // Transport preflight: verify required MCP tools are actually connected
             // before consuming a retry attempt. Fixes tool-starved sessions burning
             // all MAX_UAT_ATTEMPTS before stopping (#477).
-            const transportError = getWorkflowTransportSupportError(sessionProvider, getRequiredWorkflowToolsForAutoUnit("run-uat"), { projectRoot: basePath, surface: "auto-mode", unitType: "run-uat", authMode: sessionAuthMode, baseUrl: sessionBaseUrl, activeTools });
+            const transportError = getUnitWorkflowDispatchReadinessError({
+                provider: sessionProvider,
+                projectRoot: basePath,
+                surface: "auto-mode",
+                unitType: "run-uat",
+                authMode: sessionAuthMode,
+                baseUrl: sessionBaseUrl,
+                activeTools,
+            });
             if (transportError) {
                 return { action: "stop", reason: transportError, level: "warning" };
             }
             const browserToolError = getUatBrowserToolSupportError({
                 uatType,
                 activeTools,
+                registeredTools,
                 milestoneId: mid,
                 sliceId,
             });
             if (browserToolError) {
                 return { action: "stop", reason: browserToolError, level: "warning" };
             }
+            const browserDaemonError = prepareBrowserDaemonForUat({
+                uatType,
+                sessionProvider,
+                sessionAuthMode,
+                sessionBaseUrl,
+                projectRoot: resolveWorkflowMcpProjectRoot(basePath),
+            });
+            if (browserDaemonError) {
+                return { action: "stop", reason: browserDaemonError, 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.
@@ -568,24 +601,11 @@ export const DISPATCH_RULES = [
             // Only applies when UAT dispatch is enabled
             if (!prefs?.uat_dispatch)
                 return null;
-            // DB-first: prefer closed slices from DB; fall back to ROADMAP on disk.
-            let closedSliceIds;
-            if (isDbAvailable()) {
-                closedSliceIds = getMilestoneSlices(mid)
-                    .filter(s => isClosedStatus(s.status))
-                    .map(s => s.id);
-            }
-            else {
-                // Filesystem fallback for degraded / unmigrated projects.
-                // `slice.done` in the parsed ROADMAP is the disk-level closed signal.
-                const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-                const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-                if (!roadmapContent)
-                    return null;
-                const roadmap = parseRoadmap(roadmapContent);
-                closedSliceIds = roadmap.slices.filter(s => s.done).map(s => s.id);
-            }
-            for (const sliceId of closedSliceIds) {
+            // DB-authoritative (ADR-017): closed slices come from the DB only; the
+            // ROADMAP projection is never parsed for gate decisions.
+            if (!isDbAvailable())
+                return null;
+            for (const sliceId of getClosedSliceIds(mid)) {
                 const result = await readUatGateVerdict(basePath, mid, sliceId);
                 if (!result)
                     continue;
@@ -640,7 +660,7 @@ export const DISPATCH_RULES = [
             // H6 fix (#4973): keep the non-deep auto-mode bypass, but do not
             // pre-verify deep planning's user-facing milestone approval gate.
             if (shouldBypassMilestoneDepthGateInAuto(prefs)) {
-                markDepthVerified(mid, basePath);
+                hostWriteGateAdapter.markDepthVerified(mid, basePath);
             }
             return {
                 action: "dispatch",
@@ -822,7 +842,7 @@ export const DISPATCH_RULES = [
             // H6 fix (#4973): keep the non-deep auto-mode bypass, but do not
             // pre-verify deep planning's user-facing milestone approval gate.
             if (shouldBypassMilestoneDepthGateInAuto(prefs)) {
-                markDepthVerified(mid, basePath);
+                hostWriteGateAdapter.markDepthVerified(mid, basePath);
             }
             return {
                 action: "dispatch",
@@ -904,28 +924,25 @@ export const DISPATCH_RULES = [
             // behavior.
             if (await getMilestonePipelineVariant(mid) === "trivial")
                 return null;
-            // Load roadmap to find all slices
-            const roadmapFile = resolveExistingExpectedArtifact("plan-milestone", mid, basePath) ??
-                resolveMilestoneFile(basePath, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (!roadmapContent)
+            // DB-authoritative slice list (ADR-017): the ROADMAP projection is
+            // never parsed for dispatch decisions. No DB / no rows → skip this rule.
+            if (!isDbAvailable())
+                return null;
+            const dbSlices = getMilestoneSliceSummaries(mid);
+            if (dbSlices.length === 0)
                 return null;
-            const roadmap = parseRoadmap(roadmapContent);
-            // Find slices that need research (no RESEARCH file, dependencies done)
-            const milestoneResearchFile = resolveExistingExpectedArtifact("research-milestone", mid, basePath) ??
-                resolveMilestoneFile(basePath, mid, "RESEARCH");
+            // Find slices that need research (no RESEARCH file, dependencies done).
+            // Milestone research informs slice research; it does not satisfy the
+            // per-slice RESEARCH artifact contract.
             const researchReadySlices = [];
-            for (const slice of roadmap.slices) {
+            for (const slice of dbSlices) {
                 if (slice.done)
                     continue;
-                // Skip S01 when milestone research exists
-                if (milestoneResearchFile && slice.id === "S01")
-                    continue;
                 // Skip if already has research
                 if (resolveExistingExpectedArtifact("research-slice", `${mid}/${slice.id}`, basePath))
                     continue;
                 // Skip if dependencies aren't done (check for SUMMARY files)
-                const depsComplete = (slice.depends ?? []).every((depId) => !!resolveExistingExpectedArtifact("complete-slice", `${mid}/${depId}`, basePath));
+                const depsComplete = slice.depends.every((depId) => !!resolveExistingExpectedArtifact("complete-slice", `${mid}/${depId}`, basePath));
                 if (!depsComplete)
                     continue;
                 researchReadySlices.push({ id: slice.id, title: slice.title });
@@ -949,7 +966,7 @@ export const DISPATCH_RULES = [
         },
     },
     {
-        name: "planning (no research, not S01) → research-slice",
+        name: "planning (no research) → research-slice",
         match: async ({ state, mid, midTitle, basePath, prefs }) => {
             if (state.phase !== "planning")
                 return null;
@@ -967,12 +984,6 @@ export const DISPATCH_RULES = [
                 resolveSliceFile(basePath, mid, sid, "RESEARCH");
             if (researchFile)
                 return null; // has research, fall through
-            // Skip slice research for S01 when milestone research already exists —
-            // the milestone research already covers the same ground for the first slice.
-            const milestoneResearchFile = resolveExistingExpectedArtifact("research-milestone", mid, basePath) ??
-                resolveMilestoneFile(basePath, mid, "RESEARCH");
-            if (milestoneResearchFile && sid === "S01")
-                return null; // fall through to plan-slice
             return {
                 action: "dispatch",
                 unitType: "research-slice",
@@ -1162,7 +1173,9 @@ export const DISPATCH_RULES = [
                 return null;
             try {
                 const { loadSliceTaskIO, deriveTaskGraph, isGraphAmbiguous, getReadyTasks, chooseNonConflictingSubset, graphMetrics, } = await import("./reactive-graph.js");
-                const taskIO = await loadSliceTaskIO(basePath, mid, sid);
+                const taskIO = _reactiveGraphDeriveFn
+                    ? await _reactiveGraphDeriveFn(basePath, mid, sid)
+                    : await loadSliceTaskIO(basePath, mid, sid);
                 if (taskIO.length < 2)
                     return null; // single task, no point
                 const graph = deriveTaskGraph(taskIO);
@@ -1232,10 +1245,26 @@ export const DISPATCH_RULES = [
             // missing, the planner created S##-PLAN.md with task entries but never
             // wrote the tasks/ directory files. Dispatch plan-slice to regenerate
             // them rather than hard-stopping — fixes the infinite-loop described in
-            // issue #909.
+            // issue #909. Flat-phase layout embeds tasks in the slice plan file, so
+            // skip recovery when tasks are embedded (<tasks> block or task checkboxes in phases/ plan).
             const taskPlanPath = resolveTaskFile(artifactBasePath, mid, sid, tid, "PLAN");
+            const slicePlanPath = resolveSliceFile(artifactBasePath, mid, sid, "PLAN");
+            const phasesRoot = join(gsdProjectionRoot(artifactBasePath), "phases");
+            const slicePlanContent = slicePlanPath && existsSync(slicePlanPath)
+                ? readFileSync(slicePlanPath, "utf-8")
+                : "";
+            const isPhasesSlicePlan = slicePlanPath !== null &&
+                (slicePlanPath === phasesRoot || slicePlanPath.startsWith(`${phasesRoot}${sep}`));
+            const hasTaskCheckboxes = /^-\s+\[[ xX]\]\s+\*\*[\w.]+/m.test(slicePlanContent);
+            const tasksEmbeddedInSlicePlan = Boolean(slicePlanPath &&
+                existsSync(slicePlanPath) &&
+                (slicePlanContent.includes("<tasks>") || (isPhasesSlicePlan && hasTaskCheckboxes)));
+            // tasksEmbeddedInSlicePlan is true when tasks live inside the slice plan
+            // (flat-phase phases/ layout with task checkboxes or renderPlanFromDb <tasks> block).
             const projectionTaskPlanPath = join(gsdProjectionRoot(artifactBasePath), "milestones", mid, "slices", sid, "tasks", buildTaskFileName(tid, "PLAN"));
-            if ((!taskPlanPath || !existsSync(taskPlanPath)) && !existsSync(projectionTaskPlanPath)) {
+            if ((!taskPlanPath || !existsSync(taskPlanPath)) &&
+                !existsSync(projectionTaskPlanPath) &&
+                !tasksEmbeddedInSlicePlan) {
                 if (isDebugEnabled()) {
                     const expectedTaskPlanPath = join(artifactBasePath, relTaskFile(artifactBasePath, mid, sid, tid, "PLAN"));
                     const originalProjectRoot = session?.originalBasePath || basePath;
@@ -1341,7 +1370,13 @@ export const DISPATCH_RULES = [
                 }
                 if (!existsSync(mDir))
                     mkdirSync(mDir, { recursive: true });
-                const validationPath = join(mDir, buildMilestoneFileName(mid, "VALIDATION"));
+                // Use relMilestoneFile for the layout-aware filename:
+                //   legacy   → milestones/M001/M001-VALIDATION.md
+                //   flat-phase → phases/01-slug/01-VALIDATION.md
+                // When the milestone dir is only in the project root (worktree has none),
+                // write to the project root so the artifact lands in the canonical location.
+                const writeBase = resolveMilestonePath(artifactBasePath, mid) != null ? artifactBasePath : projectRoot;
+                const validationPath = join(writeBase, relMilestoneFile(writeBase, mid, "VALIDATION"));
                 const skipSource = trivialVariant
                     ? "trivial-scope pipeline variant"
                     : "`skip_milestone_validation` preference";
@@ -1425,11 +1460,11 @@ export const DISPATCH_RULES = [
                     };
                 }
                 if (milestone) {
-                    const closeoutGate = checkCloseoutConsistencyGate(mid, { refreshFromDisk: true });
-                    if (!closeoutGate.ok) {
+                    const closeoutProof = proveMilestoneCloseout(mid, { refreshFromDisk: true });
+                    if (!closeoutProof.ok) {
                         return {
                             action: "stop",
-                            reason: formatCloseoutConsistencyBlock(closeoutGate),
+                            reason: formatCloseoutProofBlock(closeoutProof),
                             level: "warning",
                         };
                     }

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

@@ -12,8 +12,9 @@ import { unitPhaseLabel } from "./auto-dashboard.js";
 import { getSessionModelOverride } from "./session-model-override.js";
 import { logWarning } from "./workflow-logger.js";
 import { resolveUokFlags } from "./uok/flags.js";
+import { modelIdsForProfileResolution, resolveProfileAnchorProvider, resolveDisabledModelProvidersFromPreferences } from "./preferences.js";
 import { applyModelPolicyFilter } from "./uok/model-policy.js";
-import { isModelBlocked } from "./blocked-models.js";
+import { isModelBlocked, isModelTemporarilyUnavailable } from "./blocked-models.js";
 import { getRequiredWorkflowToolsForAutoUnit, isWorkflowMcpSurfaceTool } from "./workflow-mcp.js";
 /**
  * Thrown when the model-policy gate rejects every candidate model for a unit
@@ -90,6 +91,14 @@ export function getToolBaselineSnapshot(pi) {
         return live;
     return [...new Set([...baseline, ...live])];
 }
+export function getRegisteredToolSnapshot(pi) {
+    if (typeof pi.getAllTools !== "function")
+        return getToolBaselineSnapshot(pi);
+    const names = pi.getAllTools()
+        .map((tool) => tool.name)
+        .filter((name) => typeof name === "string" && name.length > 0);
+    return [...new Set(names)];
+}
 /**
  * Models eligible for the pre-dispatch policy gate. Prefer registry-available
  * models; when that list is empty (common after worktree resume before registry
@@ -210,6 +219,10 @@ function buildModelPolicyBlockReasons(policyDenyReasons, availableModels, routin
             reason: `configured model(s) did not resolve against policy-eligible registry [${eligibleSummary}]`,
         }];
 }
+function isModelUnavailable(basePath, provider, id) {
+    return isModelBlocked(basePath, provider, id) ||
+        isModelTemporarilyUnavailable(basePath, provider, id);
+}
 function restoreToolBaseline(pi) {
     const key = pi;
     const baseline = TOOL_BASELINE.get(key);
@@ -312,8 +325,8 @@ export function floorThinkingLevelForUnit(unitType, level) {
     }
     return EXECUTE_TASK_MIN_THINKING_LEVEL;
 }
-export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true) {
-    const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
+export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true, basePath, availableModelIds, preferredModelId) {
+    const explicitConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId);
     if (explicitConfig) {
         return {
             ...explicitConfig,
@@ -368,7 +381,9 @@ autoModeStartThinkingLevel) {
     // With no explicit level, fall back to the auto-start session level and raise
     // the code-writing floor — preserving prior behavior exactly. Recomputed per
     // dispatch so neither the floor nor a phase override leaks to other units.
-    const explicitThinkingLevel = resolveThinkingLevelForUnit(unitType);
+    const anchorProvider = resolveProfileAnchorProvider(ctx.model?.provider, autoModeStartModel?.provider);
+    const profileResolutionIds = modelIdsForProfileResolution(ctx.modelRegistry, anchorProvider, resolveDisabledModelProvidersFromPreferences());
+    const explicitThinkingLevel = resolveThinkingLevelForUnit(unitType, basePath, profileResolutionIds);
     const desiredThinkingLevel = explicitThinkingLevel
         ?? floorThinkingLevelForUnit(unitType, autoModeStartThinkingLevel);
     if (explicitThinkingLevel) {
@@ -401,9 +416,12 @@ autoModeStartThinkingLevel) {
             flatRateCtx: buildFlatRateContext(autoModeStartModel.provider, ctx, prefs),
         };
     }
+    const preferredModelId = autoModeStartModel
+        ? `${autoModeStartModel.provider}/${autoModeStartModel.id}`
+        : ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
     const modelConfig = effectiveSessionModelOverride
         ? undefined
-        : resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode);
+        : resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode, basePath, profileResolutionIds, preferredModelId);
     let routing = null;
     let appliedModel = null;
     // ── Restore active-tool baseline before policy evaluation (#4959, #4681, #4850) ──
@@ -563,7 +581,7 @@ autoModeStartThinkingLevel) {
                 // Hook can override model selection entirely by returning { modelId }
                 let hookOverride;
                 if (routingConfig.hooks !== false) {
-                    const eligible = getEligibleModels(classification.tier, availableModelIds, routingConfig);
+                    const eligible = getEligibleModels(classification.tier, availableModelIds, routingConfig, preferredModelId);
                     const hookResult = await pi.emitBeforeModelSelect({
                         unitType,
                         unitId,
@@ -599,7 +617,7 @@ autoModeStartThinkingLevel) {
                     };
                 }
                 else {
-                    routingResult = resolveModelForComplexity(classification, modelConfig, routingConfig, availableModelIds, unitType, classification.taskMetadata, capabilityOverrides);
+                    routingResult = resolveModelForComplexity(classification, modelConfig, routingConfig, availableModelIds, unitType, classification.taskMetadata, capabilityOverrides, preferredModelId);
                 }
                 if (routingResult.wasDowngraded) {
                     effectiveModelConfig = {
@@ -649,8 +667,8 @@ autoModeStartThinkingLevel) {
             // (issue #4513).  The block is persisted in .gsd/runtime/blocked-models.json
             // so it survives /gsd auto restarts — without this, the same dead model
             // gets reselected after every restart.
-            if (isModelBlocked(basePath, model.provider, model.id)) {
-                ctx.ui.notify(`Skipping blocked model ${model.provider}/${model.id} (provider rejected it for this account).`, "warning");
+            if (isModelUnavailable(basePath, model.provider, model.id)) {
+                ctx.ui.notify(`Skipping unavailable model ${model.provider}/${model.id}.`, "warning");
                 continue;
             }
             // Warn if the ID is ambiguous across providers
@@ -716,7 +734,7 @@ autoModeStartThinkingLevel) {
                 const key = `${model.provider.toLowerCase()}/${model.id.toLowerCase()}`;
                 if (!policyAllowedModelKeys.has(key))
                     continue;
-                if (isModelBlocked(basePath, model.provider, model.id))
+                if (isModelUnavailable(basePath, model.provider, model.id))
                     continue;
                 const ok = await pi.setModel(model, { persist: false });
                 if (!ok)
@@ -738,16 +756,16 @@ autoModeStartThinkingLevel) {
         // No model preference for this unit type — re-apply the model captured
         // at auto-mode start to prevent bleed from shared global settings.json (#650).
         const availableModels = buildModelPolicyCandidates(ctx, autoModeStartModel, effectiveSessionModelOverride);
-        const startBlocked = isModelBlocked(basePath, autoModeStartModel.provider, autoModeStartModel.id);
+        const startBlocked = isModelUnavailable(basePath, autoModeStartModel.provider, autoModeStartModel.id);
         if (startBlocked) {
-            ctx.ui.notify(`Auto-mode start model ${autoModeStartModel.provider}/${autoModeStartModel.id} is blocked for this account. Using current session model instead.`, "warning");
+            ctx.ui.notify(`Auto-mode start model ${autoModeStartModel.provider}/${autoModeStartModel.id} is unavailable. Using current session model instead.`, "warning");
         }
         else {
             const startModel = availableModels.find(m => m.provider === autoModeStartModel.provider && m.id === autoModeStartModel.id);
             if (startModel) {
                 const ok = await pi.setModel(startModel, { persist: false });
                 if (!ok) {
-                    const byId = availableModels.find(m => m.id === autoModeStartModel.id && !isModelBlocked(basePath, m.provider, m.id));
+                    const byId = availableModels.find(m => m.id === autoModeStartModel.id && !isModelUnavailable(basePath, m.provider, m.id));
                     if (byId) {
                         const fallbackOk = await pi.setModel(byId, { persist: false });
                         if (fallbackOk) {
@@ -831,15 +849,34 @@ export function resolveModelId(modelId, availableModels, currentProvider) {
         if (providerMatch)
             return providerMatch;
     }
-    // Prefer "anthropic" as the canonical provider for Anthropic models.
-    // Transport-specific tiebreaker (ADR-012): intentionally keys on provider,
-    // not api — we want the plain Anthropic transport when multiple are available.
-    const anthropicMatch = candidates.find(m => m.provider === "anthropic");
-    if (anthropicMatch)
-        return anthropicMatch;
+    // Subscription/OAuth routes beat pay-per-token API when the same model ID
+    // exists on multiple providers. Order matters — first match wins.
+    for (const provider of BARE_ID_SUBSCRIPTION_PROVIDER_PRECEDENCE) {
+        const match = candidates.find(m => m.provider === provider);
+        if (match)
+            return match;
+    }
     // Fall back to first non-extension candidate, or any candidate
     return candidates.find(m => !EXTENSION_PROVIDERS.has(m.provider)) ?? candidates[0];
 }
+/**
+ * When a bare model ID exists on multiple providers, prefer subscription/OAuth
+ * routes over pay-per-token API keys. Matches PROVIDER_ROUTES in doctor-providers
+ * but applies when *both* sides are authenticated.
+ *
+ * Order rationale:
+ * - openai-codex before github-copilot: ChatGPT-native for shared GPT IDs
+ * - google-antigravity before google-gemini-cli: Antigravity replaced Gemini CLI for individuals
+ * - anthropic before github-copilot: first-party Claude API/OAuth over Copilot
+ * - github-copilot before openai/google: Copilot OAuth over platform API keys
+ */
+export const BARE_ID_SUBSCRIPTION_PROVIDER_PRECEDENCE = [
+    "openai-codex",
+    "google-antigravity",
+    "google-gemini-cli",
+    "anthropic",
+    "github-copilot",
+];
 /**
  * Flat-rate providers charge the same per request regardless of model.
  * Dynamic routing provides no cost benefit — it only degrades quality (#3453).