@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.5fc22c6f

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

@@ -78,6 +78,8 @@ export class AutoSession {
     currentUnitRouting = null;
     currentMilestoneId = null;
     sourceObservations = new SourceObservationStore();
+    /** Live tool-surface snapshot for dashboard / runtime telemetry while auto is active. */
+    toolSurfaceSnapshot = null;
     // ── Model state ──────────────────────────────────────────────────────────
     autoModeStartModel = null;
     /** Explicit /gsd model pin captured at bootstrap (session-scoped policy override). */
@@ -122,6 +124,13 @@ export class AutoSession {
      * the issues after MAX_PRE_EXEC_RETRIES re-attempts.
      */
     preExecRetryCount = new Map();
+    /**
+     * Tracks how many times each slice unit has been re-dispatched to plan-slice
+     * because task plan files were missing. Keyed by unitId (e.g. "M001/S01").
+     * Separate from preExecRetryCount so pre-exec gate failures do not block or
+     * conflate with missing-task-plan recovery.
+     */
+    missingTaskPlanRetryCount = new Map();
     // ── Tool invocation errors (#2883) ──────────────────────────────────
     /** Set when a GSD tool execution ends with isError due to malformed/truncated
      *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
@@ -270,6 +279,7 @@ export class AutoSession {
         this.unitRecoveryCount.clear();
         // Unit
         this.clearCurrentUnit();
+        this.toolSurfaceSnapshot = null;
         this.currentTraceId = null;
         this.currentTurnId = null;
         this.currentUnitRouting = null;
@@ -307,6 +317,7 @@ export class AutoSession {
         this.consecutiveCompleteBootstraps = 0;
         this.lastPreExecFailure = null;
         this.preExecRetryCount.clear();
+        this.missingTaskPlanRetryCount.clear();
         this.lastToolInvocationError = null;
         this.toolUnavailableRetries = 0;
         this.lastUnitAgentEndMessages = null;

package/dist/resources/extensions/gsd/auto/verification-retry-policy.js

@@ -25,7 +25,7 @@ export function decideVerificationRetry(input) {
         return { action: "pause", reason: "missing-retry-context" };
     }
     const key = verificationRetryKey(unitType, retryInfo.unitId);
-    const failureHash = hashVerificationFailureContext(retryInfo.failureContext);
+    const failureHash = hashVerificationFailureContext(retryInfo.signature ?? retryInfo.failureContext);
     if (input.previousFailureHash === failureHash) {
         return {
             action: "pause",

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

@@ -76,6 +76,15 @@ const COMPLETE_AND_BREAK_REASONS = [
 function isCompleteAndBreakReason(reason) {
     return COMPLETE_AND_BREAK_REASONS.includes(reason);
 }
+/** Strip per-attempt counter suffixes so detect-stuck Rule 1 can match repeats. */
+const FAILURE_DETAIL_ATTEMPT_SUFFIX_RE = /\s*\(attempt\s+\d+(?:\/\d+)?\)\.?$/i;
+function failureDetailForLedger(detail) {
+    const trimmed = detail?.trim();
+    if (!trimmed)
+        return undefined;
+    const normalized = trimmed.replace(FAILURE_DETAIL_ATTEMPT_SUFFIX_RE, "").trim();
+    return normalized || undefined;
+}
 export function decideFinalizeResult(input) {
     if (input.action === "break") {
         const reason = input.reason ?? "unknown";
@@ -90,9 +99,14 @@ export function decideFinalizeResult(input) {
         };
     }
     if (input.action === "continue") {
+        // Carry the specific verification failure (e.g. "roadmap has zero slices",
+        // "15-SUMMARY.md was not found on disk") into the ledger summary so the
+        // stuck-loop kill message is actionable. The `finalize-retry` prefix is
+        // preserved so legacy ledger filters and dashboards still match (#852).
+        const detail = failureDetailForLedger(input.failureDetail);
         return {
             action: "retry",
-            ledgerErrorSummary: "finalize-retry",
+            ledgerErrorSummary: detail ? `finalize-retry: ${detail}` : "finalize-retry",
         };
     }
     return { action: "complete" };

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

@@ -5,27 +5,93 @@
 // 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, gsdProjectionRoot, resolveDir, resolveFile, relMilestoneFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, } from "./paths.js";
+import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, } from "./paths.js";
+import { milestoneIdToPhaseNum } from "./layout-policy.js";
 import { parseUnitId } from "./unit-id.js";
-import { join } from "node:path";
+import { dirname, join, relative } from "node:path";
+import { existsSync } from "node:fs";
 function resolveMilestoneArtifactPath(base, mid, suffix) {
     const existing = resolveProjectedMilestoneFile(base, mid, suffix) ?? resolveProjectMilestoneFile(base, mid, suffix);
     if (existing)
         return existing;
-    const dir = resolveProjectedMilestonePath(base, mid) ?? resolveProjectMilestonePath(base, mid);
-    return dir ? join(dir, buildMilestoneFileName(mid, suffix)) : null;
+    // Try projected (worktree) path, then project-root path. Both can return
+    // either a legacy (milestones/<MID>/) or flat-phase (phases/NN-slug/) dir.
+    const dir = resolveProjectedMilestonePath(base, mid) ?? resolveProjectMilestonePath(base, mid) ?? resolveMilestonePath(base, mid);
+    if (dir) {
+        // The filename depends on the LAYOUT of the resolved directory, not on
+        // which resolver found it. A flat-phase dir (phases/NN-slug/) uses the
+        // phase-number prefix (15-CONTEXT.md); a legacy dir (milestones/<MID>/)
+        // uses the milestone-id prefix (M015-CONTEXT.md). Building the wrong
+        // filename for the resolved dir produces existsSync-false paths that trap
+        // the unit in a finalize-retry loop (#852).
+        //
+        // Layout is determined structurally from the resolved directory's parent
+        // segment name, NOT by comparing against a root-anchored legacyMilestonesDir
+        // base path. On a canonical worktree (<project>/.gsd-worktrees/M001/),
+        // legacyMilestonesDir uses gsdProjectionRoot (the worktree .gsd) while
+        // resolveProjectMilestonePath uses gsdRoot (the project .gsd) — two
+        // different roots. A dir returned by resolveProjectMilestonePath would
+        // fail the startsWith check against the worktree root and incorrectly
+        // produce a flat-phase filename for a legacy directory (#bugbot c5ee8eba).
+        const parentDir = dirname(dir);
+        const isLegacy = parentDir.endsWith("/milestones") || parentDir.endsWith("\\milestones");
+        const phaseNum = milestoneIdToPhaseNum(mid);
+        const filename = isLegacy
+            ? `${mid}-${suffix}.md`
+            : `${String(phaseNum).padStart(2, "0")}-${suffix}.md`;
+        return join(dir, filename);
+    }
+    return null;
+}
+/**
+ * Build the layout-aware filename for a milestone artifact suffix.
+ * Exported so other callers (e.g. verification diagnostics) use the same
+ * naming policy: flat-phase dirs use the phase-number prefix (15-CONTEXT.md),
+ * legacy dirs use the milestone-id prefix (M015-CONTEXT.md).
+ *
+ * Layout is determined structurally: dirs whose immediate parent is named
+ * "milestones" are legacy; all others are flat-phase. This avoids the
+ * root-path ambiguity between gsdProjectionRoot (worktree .gsd) and gsdRoot
+ * (project .gsd) that caused wrong filenames on canonical worktrees.
+ */
+export function buildMilestoneArtifactFilename(mid, suffix, dir) {
+    const parentDir = dirname(dir);
+    const isLegacy = parentDir.endsWith("/milestones") || parentDir.endsWith("\\milestones");
+    const phaseNum = milestoneIdToPhaseNum(mid);
+    return isLegacy
+        ? `${mid}-${suffix}.md`
+        : `${String(phaseNum).padStart(2, "0")}-${suffix}.md`;
 }
 function resolveSliceArtifactPath(base, mid, sid, suffix) {
     const existing = resolveProjectedSliceFile(base, mid, sid, suffix) ?? resolveProjectSliceFile(base, mid, sid, suffix);
     if (existing)
         return existing;
-    const dir = resolveProjectedSlicePath(base, mid, sid) ?? resolveProjectSlicePath(base, mid, sid);
-    return dir ? join(dir, buildSliceFileName(sid, suffix)) : null;
+    // Flat-phase: plan files live at phases/NN-slug/NN-MM-SUFFIX.md — resolveSliceFile handles both layouts.
+    const flatPhase = resolveSliceFile(base, mid, sid, suffix);
+    if (flatPhase)
+        return flatPhase;
+    // File doesn't exist yet — use relSliceFile for the layout-aware canonical path.
+    // buildSliceFileName(sid) only has sliceId → MM-SUFFIX.md, wrong for both layouts.
+    return join(base, relSliceFile(base, mid, sid, suffix));
 }
 function resolveProjectMilestonePath(base, mid) {
     const milestonesDir = join(gsdRoot(base), "milestones");
     const dir = resolveDir(milestonesDir, mid);
-    return dir ? join(milestonesDir, dir) : null;
+    if (!dir)
+        return null;
+    // git-service.ts creates milestones/<MID>/ for integration-branch metadata
+    // (<MID>-META.json) even in flat-phase projects. A dir that holds ONLY
+    // *-META.json files must not be treated as a real legacy milestone dir —
+    // otherwise this early-return resolves CONTEXT/ROADMAP/SUMMARY to the legacy
+    // path (milestones/<MID>/<MID>-<SUFFIX>.md) before the flat-phase fallback
+    // can run, trapping the unit in a finalize-retry loop (#852 follow-up).
+    //
+    // We use dirIsMetaOnlyLegacyMilestone rather than !dirIsContentBearingLegacyMilestone
+    // so that an EMPTY dir (a new milestone before any content is written) is NOT
+    // blocked — it is a valid legacy target that write-paths should resolve to.
+    if (dirIsMetaOnlyLegacyMilestone(join(milestonesDir, dir)))
+        return null;
+    return join(milestonesDir, dir);
 }
 function resolveProjectMilestoneFile(base, mid, suffix) {
     const dir = resolveProjectMilestonePath(base, mid);
@@ -50,16 +116,10 @@ function resolveProjectSliceFile(base, mid, sid, suffix) {
     return file ? join(dir, file) : null;
 }
 function resolveProjectedMilestonePath(base, mid) {
-    const milestonesDir = join(gsdProjectionRoot(base), "milestones");
-    const dir = resolveDir(milestonesDir, mid);
-    return dir ? join(milestonesDir, dir) : null;
+    return resolveMilestonePath(base, mid);
 }
 function resolveProjectedMilestoneFile(base, mid, suffix) {
-    const dir = resolveProjectedMilestonePath(base, mid);
-    if (!dir)
-        return null;
-    const file = resolveFile(dir, mid, suffix);
-    return file ? join(dir, file) : null;
+    return resolveMilestoneFile(base, mid, suffix);
 }
 function resolveProjectedSlicePath(base, mid, sid) {
     const milestoneDir = resolveProjectedMilestonePath(base, mid);
@@ -128,10 +188,13 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             return resolveSliceArtifactPath(base, mid, sid, "ASSESSMENT");
         }
         case "execute-task": {
-            const dir = resolveProjectedSlicePath(base, mid, sid) ?? resolveProjectSlicePath(base, mid, sid);
-            return dir && tid
-                ? join(dir, "tasks", buildTaskFileName(tid, "SUMMARY"))
-                : null;
+            const slicePath = resolveProjectedSlicePath(base, mid, sid)
+                ?? resolveProjectSlicePath(base, mid, sid)
+                ?? resolveSlicePath(base, mid, sid);
+            if (!slicePath || !tid)
+                return null;
+            const tasksDir = resolveTasksDir(base, mid, sid) ?? slicePath;
+            return join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
         }
         case "complete-slice": {
             return resolveSliceArtifactPath(base, mid, sid, "SUMMARY");
@@ -219,3 +282,29 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
             return null;
     }
 }
+/**
+ * Resolve slice RESEARCH with worktree projection first, then canonical
+ * project-root path. Shared by dispatch rules, execute-task prompts, and
+ * artifact verification.
+ */
+export function resolveSliceResearchLocation(basePath, mid, sid) {
+    const projectedFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");
+    if (projectedFile) {
+        return {
+            absolutePath: projectedFile,
+            relativePath: relSliceFile(basePath, mid, sid, "RESEARCH"),
+        };
+    }
+    const canonicalPath = resolveExpectedArtifactPath("research-slice", `${mid}/${sid}`, basePath);
+    if (canonicalPath && existsSync(canonicalPath)) {
+        return {
+            absolutePath: canonicalPath,
+            relativePath: relative(basePath, canonicalPath),
+        };
+    }
+    return { absolutePath: null, relativePath: null };
+}
+/** Returns the absolute RESEARCH path when it exists, otherwise null. */
+export function resolveExistingSliceResearchPath(basePath, mid, sid) {
+    return resolveSliceResearchLocation(basePath, mid, sid).absolutePath;
+}

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

@@ -68,6 +68,10 @@ export function resolveCompactionThresholdPercent(raw) {
     const value = typeof raw === "number" && Number.isFinite(raw) && raw >= 0.5 && raw <= 0.95 ? raw : 0.6;
     return value <= 1 ? value * 100 : value;
 }
-export function shouldRerootStepSessionForContext(contextPercent, compactionThresholdPercent) {
+export const HARD_CONTEXT_REROOT_THRESHOLD_PERCENT = 90;
+export function shouldWarnStepSessionForContext(contextPercent, compactionThresholdPercent) {
     return getContextPauseAction(contextPercent, resolveCompactionThresholdPercent(compactionThresholdPercent)) === "pause";
 }
+export function shouldRerootStepSessionForContext(contextPercent) {
+    return getContextPauseAction(contextPercent, HARD_CONTEXT_REROOT_THRESHOLD_PERCENT) === "pause";
+}

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

@@ -2,14 +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, getMilestoneSliceSummaries, getClosedSliceIds, 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 { 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";
@@ -40,7 +40,7 @@ import { detectWorktreeName } from "./worktree.js";
 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 { resolveExpectedArtifactPath, resolveExistingSliceResearchPath } from "./auto-artifact-paths.js";
 import { formatCloseoutProofBlock, proveMilestoneCloseout, } from "./milestone-closeout-proof.js";
 function resolveExistingExpectedArtifact(unitType, unitId, basePath) {
     const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
@@ -155,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;
 }
 /**
@@ -319,9 +331,8 @@ function backfillMissingAssessmentsFromSummaries(basePath, 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");
@@ -585,7 +596,7 @@ export const DISPATCH_RULES = [
         },
     },
     {
-        name: "uat-verdict-gate (non-PASS blocks progression)",
+        name: "uat-verdict-gate (non-PASS observed; closeout enforces)",
         match: async ({ mid, basePath, prefs }) => {
             // Only applies when UAT dispatch is enabled
             if (!prefs?.uat_dispatch)
@@ -600,9 +611,9 @@ export const DISPATCH_RULES = [
                     continue;
                 const { verdict, uatType } = result;
                 if (!isAcceptableUatVerdict(verdict, uatType)) {
-                    // Do not hard-stop auto-mode on non-PASS verdicts. Allow progression
-                    // so follow-up slices can remediate, while complete-milestone still
-                    // enforces manual UAT PASS sign-off before closure.
+                    // Observe non-PASS verdicts without hard-stopping auto-mode. Allow
+                    // progression so follow-up slices can remediate, while
+                    // complete-milestone still enforces manual UAT PASS sign-off before closure.
                     continue;
                 }
             }
@@ -891,9 +902,19 @@ export const DISPATCH_RULES = [
             const sliceContextFile = resolveSliceFile(basePath, mid, state.activeSlice.id, "CONTEXT");
             if (sliceContextFile && existsSync(sliceContextFile))
                 return null; // discussion already done, proceed
+            const closedSliceIds = getClosedSliceIds(mid);
+            const justClosedSliceId = closedSliceIds[closedSliceIds.length - 1];
+            let priorVerdictWarning = "";
+            if (justClosedSliceId) {
+                const prior = await readUatGateVerdict(basePath, mid, justClosedSliceId);
+                if (prior && !isAcceptableUatVerdict(prior.verdict, prior.uatType)) {
+                    priorVerdictWarning =
+                        ` Note: the slice just closed (${justClosedSliceId}) recorded a non-PASS UAT verdict (${prior.verdict.toUpperCase()}); review before continuing.`;
+                }
+            }
             return {
                 action: "stop",
-                reason: `Slice ${state.activeSlice.id} requires discussion before planning (require_slice_discussion is enabled). Run /gsd discuss to discuss this slice, then /gsd auto to resume.`,
+                reason: `Slice ${state.activeSlice.id} requires discussion before planning (require_slice_discussion is enabled). Run /gsd discuss to discuss this slice, then /gsd auto to resume.${priorVerdictWarning}`,
                 level: "warning",
             };
         },
@@ -920,18 +941,15 @@ export const DISPATCH_RULES = [
             const dbSlices = getMilestoneSliceSummaries(mid);
             if (dbSlices.length === 0)
                 return null;
-            // 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 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))
+                if (resolveExistingSliceResearchPath(basePath, mid, slice.id))
                     continue;
                 // Skip if dependencies aren't done (check for SUMMARY files)
                 const depsComplete = slice.depends.every((depId) => !!resolveExistingExpectedArtifact("complete-slice", `${mid}/${depId}`, basePath));
@@ -958,7 +976,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;
@@ -972,16 +990,8 @@ export const DISPATCH_RULES = [
                 return missingSliceStop(mid, state.phase);
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
-            const researchFile = resolveExistingExpectedArtifact("research-slice", `${mid}/${sid}`, basePath) ??
-                resolveSliceFile(basePath, mid, sid, "RESEARCH");
-            if (researchFile)
+            if (resolveExistingSliceResearchPath(basePath, mid, sid))
                 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",
@@ -1238,15 +1248,43 @@ export const DISPATCH_RULES = [
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
             const tid = state.activeTask.id;
+            const unitId = `${mid}/${sid}`;
             const artifactBasePath = resolveArtifactBasePath(basePath, mid, session);
             // Guard: if the slice plan exists but the individual task plan files are
             // 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) {
+                const MAX_MISSING_TASK_PLAN_RETRIES = 2;
+                const retryCount = session?.missingTaskPlanRetryCount?.get(unitId) ?? 0;
+                if (retryCount >= MAX_MISSING_TASK_PLAN_RETRIES) {
+                    session?.missingTaskPlanRetryCount?.delete(unitId);
+                    return {
+                        action: "stop",
+                        reason: `Missing task-plan recovery failed ${retryCount} times for ${unitId} - manual intervention required. Task plan ${tid} is still missing after regenerating the slice plan. Fix the task-plan files manually, then run /gsd auto to resume.`,
+                        level: "error",
+                    };
+                }
+                session?.missingTaskPlanRetryCount?.set(unitId, retryCount + 1);
                 if (isDebugEnabled()) {
                     const expectedTaskPlanPath = join(artifactBasePath, relTaskFile(artifactBasePath, mid, sid, tid, "PLAN"));
                     const originalProjectRoot = session?.originalBasePath || basePath;
@@ -1270,10 +1308,11 @@ export const DISPATCH_RULES = [
                 return {
                     action: "dispatch",
                     unitType: "plan-slice",
-                    unitId: `${mid}/${sid}`,
+                    unitId,
                     prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry, sessionProvider }),
                 };
             }
+            session?.missingTaskPlanRetryCount?.delete(unitId);
             return null;
         },
     },
@@ -1352,7 +1391,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";

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

@@ -325,8 +325,8 @@ export function floorThinkingLevelForUnit(unitType, level) {
     }
     return EXECUTE_TASK_MIN_THINKING_LEVEL;
 }
-export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true, basePath, availableModelIds) {
-    const explicitConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds);
+export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true, basePath, availableModelIds, preferredModelId) {
+    const explicitConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId, true);
     if (explicitConfig) {
         return {
             ...explicitConfig,
@@ -338,23 +338,45 @@ export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAuto
     if (!isAutoMode)
         return undefined;
     const routingConfig = resolveDynamicRoutingConfig();
-    if (!routingConfig.enabled || !routingConfig.tier_models)
+    if (!routingConfig.enabled)
         return undefined;
-    // Don't synthesize a routing config for flat-rate providers (#3453).
-    // Users can opt into routing for flat-rate subscriptions (e.g. claude-code)
-    // via dynamic_routing.allow_flat_rate_providers (#4386).
-    if (!routingConfig.allow_flat_rate_providers &&
+    // Only an explicit flat-rate opt-out suppresses synthesized routing.
+    // `dynamic_routing.enabled: true` is user intent to run routing even when
+    // the start provider is a flat-rate subscription. Applied ahead of both the
+    // tier-pin and profile-derived synthesis paths so the opt-out is uniform.
+    if (routingConfig.allow_flat_rate_providers === false &&
         autoModeStartModel &&
         isFlatRateProvider(autoModeStartModel.provider, autoModeStartModel.flatRateCtx)) {
         return undefined;
     }
-    const ceilingModel = routingConfig.tier_models.heavy
-        ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
-    if (!ceilingModel)
+    // With explicit `tier_models` pins, synthesize a heavy-tier ceiling that
+    // dynamic routing downgrades from per unit.
+    if (routingConfig.tier_models) {
+        const ceilingModel = routingConfig.tier_models.heavy
+            ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
+        if (!ceilingModel)
+            return undefined;
+        return {
+            primary: ceilingModel,
+            fallbacks: [],
+            source: "synthesized",
+        };
+    }
+    // No `tier_models` pins: fall back to the token-profile's per-phase model so
+    // profile tier resolution survives. `skipProfileDefaults` is left false here
+    // (unlike the explicit-detection call above) precisely because we WANT the
+    // profile defaults this time — they are the routing ceiling, not a hard
+    // user selection. Labeling the result `synthesized` (not `explicit`) keeps
+    // dynamic routing and fallbacks enabled downstream. Without this branch,
+    // `resolvePreferredModelConfig` returns undefined for profile-only configs
+    // and auto dispatch bleeds the start model onto every unit, silently
+    // discarding the profile (#1115: routing/fallbacks disabled when a
+    // token_profile is set but no tier_models are pinned).
+    const profileConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId, false);
+    if (!profileConfig)
         return undefined;
     return {
-        primary: ceilingModel,
-        fallbacks: [],
+        ...profileConfig,
         source: "synthesized",
     };
 }
@@ -416,9 +438,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, basePath, profileResolutionIds);
+        : resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode, basePath, profileResolutionIds, preferredModelId);
     let routing = null;
     let appliedModel = null;
     // ── Restore active-tool baseline before policy evaluation (#4959, #4681, #4850) ──
@@ -507,15 +532,11 @@ autoModeStartThinkingLevel) {
                 ]));
             }
         }
-        // Disable routing for flat-rate providers like GitHub Copilot (#3453).
-        // All models cost the same per request, so downgrading to a cheaper
-        // model provides no cost benefit — it only degrades quality.
+        // Disable routing for flat-rate providers only when the user explicitly
+        // opts out with dynamic_routing.allow_flat_rate_providers: false.
         // Fail-closed: if primary model can't be resolved, fall back to
         // provider-level signals rather than allowing unwanted downgrades.
-        // Opt-in: dynamic_routing.allow_flat_rate_providers skips the bypass so
-        // claude-code subscribers can still get intelligent per-task selection
-        // across their subscription (#4386).
-        if (routingConfig.enabled && !routingConfig.allow_flat_rate_providers) {
+        if (routingConfig.enabled && routingConfig.allow_flat_rate_providers === false) {
             const primaryModel = resolveModelId(modelConfig.primary, routingEligibleModels, ctx.model?.provider);
             if (primaryModel) {
                 const primaryFlatRateCtx = buildFlatRateContext(primaryModel.provider, ctx, prefs);
@@ -578,7 +599,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,
@@ -614,7 +635,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 = {