@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

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

@@ -20,10 +20,11 @@ import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
-import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
+import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
 import { execFileSync } from "node:child_process";
-import { dirname, join } from "node:path";
+import { LAYOUT_SEGMENTS } from "./layout-policy.js";
+import { dirname, join, resolve } from "node:path";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { hasVerdict } from "./verdict-parser.js";
@@ -31,6 +32,7 @@ import { validateArtifact } from "./schemas/validate.js";
 import { getProjectResearchStatus } from "./project-research-policy.js";
 import { isGsdWorktreePath } from "./worktree-root.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
+import { resolveWorktreeProjectRoot } from "./worktree-root.js";
 import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
 import { loadAllCaptures, loadPendingCaptures } from "./captures.js";
 import { proveMilestoneCloseout, } from "./milestone-closeout-proof.js";
@@ -38,6 +40,45 @@ import { proveMilestoneCloseout, } from "./milestone-closeout-proof.js";
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
 export { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
+/**
+ * Optional override for the legacy roadmap parser used by verifyExpectedArtifact.
+ * Production leaves this null so the real parseLegacyRoadmap runs; tests inject
+ * a throwing function to deterministically exercise the parse-failure catches
+ * (auto-recovery.ts:515 plan-milestone and :622 complete-slice). Those catches
+ * are otherwise unreachable because parseLegacyRoadmap is internally defensive
+ * against every malformed input.
+ * @internal
+ */
+let _roadmapParserFn = null;
+/**
+ * Inject an override for the legacy roadmap parser, returning a function that
+ * restores the default (real parser) behavior. No production caller.
+ * @internal
+ */
+export function _setRoadmapParserFnForTests(fn) {
+    const previous = _roadmapParserFn;
+    _roadmapParserFn = fn;
+    return () => { _roadmapParserFn = previous; };
+}
+function parseRoadmapForRecovery(content) {
+    if (_roadmapParserFn)
+        return _roadmapParserFn(content);
+    return parseLegacyRoadmap(content);
+}
+/**
+ * Optional override for the detached GitHub milestone finalize invoked after DB
+ * closeout in refreshRecoveryDbForArtifact. Production leaves this null so the
+ * real finalizeMilestoneGitHubSync runs; tests inject a throwing function to
+ * deterministically exercise the best-effort catch (auto-recovery.ts:232),
+ * which otherwise needs a real GitHub remote + network failure.
+ * @internal
+ */
+let _githubFinalizeFn = null;
+export function _setGithubFinalizeFnForTests(fn) {
+    const previous = _githubFinalizeFn;
+    _githubFinalizeFn = fn;
+    return () => { _githubFinalizeFn = previous; };
+}
 // ─── Artifact Resolution & Verification ───────────────────────────────────────
 export function diagnoseWorktreeIntegrityFailure(basePath) {
     if (!isGsdWorktreePath(basePath))
@@ -139,9 +180,16 @@ export function refreshRecoveryDbForArtifact(unitType, unitId, basePath) {
             };
         }
         updateMilestoneStatus(mid, "complete", new Date().toISOString());
-        void import("../github-sync/sync.js")
-            .then(({ finalizeMilestoneGitHubSync }) => finalizeMilestoneGitHubSync(basePath, mid))
-            .catch((err) => {
+        // Detached GitHub sync — best-effort. Test seam: when
+        // _githubFinalizeFn is injected, route through it so the catch
+        // (:232) is deterministically reachable (otherwise it needs a real
+        // GitHub remote + network failure). Production leaves it null. The
+        // seam is wrapped so a synchronous throw becomes a rejected promise,
+        // matching the real import-then-call deferred semantics.
+        const finalizePromise = _githubFinalizeFn
+            ? new Promise((resolve) => { resolve(_githubFinalizeFn(basePath, mid)); })
+            : import("../github-sync/sync.js").then(({ finalizeMilestoneGitHubSync }) => finalizeMilestoneGitHubSync(basePath, mid));
+        void finalizePromise.catch((err) => {
             logWarning("recovery", `GitHub milestone finalize failed after DB closeout: ${getErrorMessage(err)}`);
         });
         return { ok: true };
@@ -203,16 +251,15 @@ function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function hasCheckedTaskCompletionOnDisk(base, mid, sid, tid) {
-    const tasksDir = resolveTasksDir(base, mid, sid);
-    if (!tasksDir)
-        return false;
-    if (!existsSync(join(tasksDir, `${tid}-SUMMARY.md`)))
+    const slicePath = resolveSlicePath(base, mid, sid);
+    if (!slicePath)
         return false;
     const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
     if (!planAbs || !existsSync(planAbs))
         return false;
     const planContent = readFileSync(planAbs, "utf-8");
-    const cbRe = new RegExp(`^\\s*-\\s+\\[[xX]\\]\\s+\\*\\*${escapeRegExp(tid)}:`, "m");
+    // Match legacy (`**T01: Title**`) and flat-phase (`**T01**: Title`) checkbox lines.
+    const cbRe = new RegExp(`^\\s*-\\s+\\[[xX]\\]\\s+\\*\\*${escapeRegExp(tid)}(?:\\*\\*)?:`, "m");
     return cbRe.test(planContent);
 }
 /**
@@ -285,21 +332,20 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         if (blockerPath && existsSync(blockerPath)) {
             return true;
         }
+        const slicePath = resolveSlicePath(base, mid, sid);
+        if (!slicePath)
+            return false;
         const plusIdx = batchPart.indexOf("+");
         if (plusIdx === -1) {
             // Legacy format "reactive" without batch IDs — fall back to "any summary"
-            const tDir = resolveTasksDir(base, mid, sid);
-            if (!tDir)
-                return false;
+            const tDir = resolveTasksDir(base, mid, sid) ?? slicePath;
             const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
             return summaryFiles.length > 0;
         }
         const batchIds = batchPart.slice(plusIdx + 1).split(",").filter(Boolean);
         if (batchIds.length === 0)
             return false;
-        const tDir = resolveTasksDir(base, mid, sid);
-        if (!tDir)
-            return false;
+        const tDir = resolveTasksDir(base, mid, sid) ?? slicePath;
         const existingSummaries = new Set(resolveTaskFiles(tDir, "SUMMARY").map((f) => f.replace(/-SUMMARY\.md$/i, "").toUpperCase()));
         // Every dispatched task must have a summary file
         for (const tid of batchIds) {
@@ -369,7 +415,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             return false;
         }
         try {
-            const roadmap = parseLegacyRoadmap(readFileSync(roadmapFile, "utf-8"));
+            const roadmap = parseRoadmapForRecovery(readFileSync(roadmapFile, "utf-8"));
             const milestoneResearchFile = resolveExpectedArtifactPath("research-milestone", mid, base);
             const hasMilestoneResearch = !!milestoneResearchFile && existsSync(milestoneResearchFile);
             for (const slice of roadmap.slices) {
@@ -397,7 +443,26 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         }
     }
     const artifactBase = resolveArtifactVerificationBase(unitId, base);
-    const absPath = resolveExpectedArtifactPath(unitType, unitId, artifactBase);
+    let absPath = resolveExpectedArtifactPath(unitType, unitId, artifactBase);
+    // Worktree→project-root fallback: a milestone running in a worktree may not
+    // have its CONTEXT/ROADMAP/SUMMARY projected into the worktree yet (the
+    // worktree only has the META dir until planning writes its projections).
+    // When the worktree base yields null or a non-existent path, fall back to the
+    // project root — where the artifact genuinely lives. Without this, a
+    // discuss-milestone unit with CONTEXT at phases/NN-slug/ in the project root
+    // but not in the worktree resolves to null → "resolveExpectedArtifactPath
+    // returned null" → finalize-retry loop (#852).
+    if (artifactBase !== base) {
+        const projectRoot = resolve(resolveWorktreeProjectRoot(artifactBase));
+        if (projectRoot && projectRoot !== artifactBase) {
+            if (!absPath || !existsSync(absPath)) {
+                const projectPath = resolveExpectedArtifactPath(unitType, unitId, projectRoot);
+                if (projectPath && existsSync(projectPath)) {
+                    absPath = projectPath;
+                }
+            }
+        }
+    }
     // For unit types with no registered artifact contract (null path), treat the
     // completion state as stale so the key gets evicted (#313).
     if (!absPath) {
@@ -429,7 +494,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     }
     if (unitType === "plan-milestone") {
         try {
-            const roadmap = parseLegacyRoadmap(readFileSync(absPath, "utf-8"));
+            const roadmap = parseRoadmapForRecovery(readFileSync(absPath, "utf-8"));
             if (roadmap.slices.length === 0) {
                 logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap has zero slices at ${absPath}`);
                 return false;
@@ -448,19 +513,22 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         if (mid && sid) {
             try {
                 let taskIds = null;
+                let dbPrimary = false;
                 if (isDbAvailable()) {
                     const refreshed = refreshWorkflowDatabaseFromDisk();
                     if (refreshed) {
                         const tasks = getSliceTasks(mid, sid);
-                        if (tasks.length > 0)
+                        if (tasks.length > 0) {
                             taskIds = tasks.map(t => t.id);
+                            dbPrimary = true;
+                        }
                     }
                 }
                 if (!taskIds) {
                     // LEGACY: DB unavailable or no tasks in DB. Require actual task
                     // entries so an empty scaffold cannot advance the pipeline (#699).
                     const planContent = readFileSync(absPath, "utf-8");
-                    const hasCheckboxTask = /^\s*- \[[xX ]\] \*\*T\d+:/m.test(planContent);
+                    const hasCheckboxTask = /^\s*- \[[xX ]\] \*\*T\d+/m.test(planContent);
                     const hasHeadingTask = /^\s*#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
                     if (!hasCheckboxTask && !hasHeadingTask) {
                         logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
@@ -470,19 +538,27 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
                     if (plan.tasks.length > 0)
                         taskIds = plan.tasks.map((t) => t.id);
                 }
+                // Per-task plan file check: applies when a tasks/ directory is present on
+                // disk (legacy layout), regardless of whether DB is primary. Flat-phase
+                // projects have no tasks/ dir, so the check is naturally skipped there.
+                // When DB is NOT primary and there is no tasks/ dir either, the missing
+                // dir itself is evidence of an incomplete plan (non-flat-phase projects must
+                // have a tasks/ dir).
                 if (taskIds && taskIds.length > 0) {
                     const tasksDir = join(dirname(absPath), "tasks");
-                    if (!existsSync(tasksDir)) {
+                    if (existsSync(tasksDir)) {
+                        for (const tid of taskIds) {
+                            const taskPlanFile = join(tasksDir, `${tid}-PLAN.md`);
+                            if (!existsSync(taskPlanFile)) {
+                                logWarning("recovery", `verify-fail ${unitType} ${unitId}: task plan missing ${taskPlanFile}`);
+                                return false;
+                            }
+                        }
+                    }
+                    else if (!dbPrimary && !absPath.replace(/\\/g, "/").includes(`.gsd/${LAYOUT_SEGMENTS.level1}`)) {
                         logWarning("recovery", `verify-fail ${unitType} ${unitId}: tasks dir missing at ${tasksDir}`);
                         return false;
                     }
-                    for (const tid of taskIds) {
-                        const taskPlanFile = join(tasksDir, `${tid}-PLAN.md`);
-                        if (!existsSync(taskPlanFile)) {
-                            logWarning("recovery", `verify-fail ${unitType} ${unitId}: task plan missing ${taskPlanFile}`);
-                            return false;
-                        }
-                    }
                 }
             }
             catch (err) {
@@ -523,12 +599,13 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     if (unitType === "complete-slice") {
         const { milestone: mid, slice: sid } = parseUnitId(unitId);
         if (mid && sid) {
-            const dir = resolveSlicePath(base, mid, sid);
-            if (dir) {
-                const uatPath = join(dir, buildSliceFileName(sid, "UAT"));
-                if (!existsSync(uatPath))
-                    return false;
-            }
+            // resolveSliceFile only finds existing files; UAT may not exist yet.
+            // Fall back to the canonical expected location so a missing UAT always
+            // returns false (not a silent pass when resolveSliceFile returns null).
+            const uatPath = resolveSliceFile(base, mid, sid, "UAT")
+                ?? join(base, relSliceFile(base, mid, sid, "UAT"));
+            if (!existsSync(uatPath))
+                return false;
             const dbSlice = getSlice(mid, sid);
             if (dbSlice) {
                 // DB available — trust it
@@ -542,7 +619,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
                 if (roadmapFile && existsSync(roadmapFile)) {
                     try {
                         const roadmapContent = readFileSync(roadmapFile, "utf-8");
-                        const roadmap = parseLegacyRoadmap(roadmapContent);
+                        const roadmap = parseRoadmapForRecovery(roadmapContent);
                         const slice = roadmap.slices.find((s) => s.id === sid);
                         if (slice && !slice.done)
                             return false;
@@ -604,10 +681,11 @@ export function writeReactiveExecuteBlocker(unitId, base, reason) {
     const blockerPath = resolveExpectedArtifactPath("reactive-execute", unitId, base);
     if (!blockerPath)
         return null;
-    const tasksDir = resolveTasksDir(base, mid, sid);
-    const existingSummaries = new Set(tasksDir
-        ? resolveTaskFiles(tasksDir, "SUMMARY").map((f) => f.replace(/-SUMMARY\.md$/i, "").toUpperCase())
-        : []);
+    const slicePath = resolveSlicePath(base, mid, sid);
+    if (!slicePath)
+        return null;
+    const tasksDir = resolveTasksDir(base, mid, sid) ?? slicePath;
+    const existingSummaries = new Set(resolveTaskFiles(tasksDir, "SUMMARY").map((f) => f.replace(/-SUMMARY\.md$/i, "").toUpperCase()));
     const summaryPresent = batchIds.filter((tid) => existingSummaries.has(tid.toUpperCase()));
     const summaryMissing = batchIds.filter((tid) => !existingSummaries.has(tid.toUpperCase()));
     const completedTaskIds = [];

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -31,6 +31,19 @@ export function clearAutoToolSurfaceSnapshot() {
 export function isAutoActive() {
     return autoSession.active;
 }
+/**
+ * The unit type of the unit auto-mode is currently dispatching, or undefined
+ * when auto is inactive or between units. This is the authoritative phase
+ * signal for auto-mode (set in auto/unit-phase.ts before each dispatch), so
+ * consumers never have to regex-infer the phase from prompt text. Can be a
+ * `hook/<name>` pseudo-type during hook dispatch — callers that need a real
+ * GSD phase should validate against their known phase set.
+ */
+export function getActiveAutoUnitType() {
+    if (!autoSession.active)
+        return undefined;
+    return autoSession.currentUnit?.type ?? undefined;
+}
 export function isAutoPaused() {
     return autoSession.paused;
 }

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

@@ -13,11 +13,12 @@
 import { deriveState } from "./state.js";
 import { findWorktreeSegment, isGsdWorktreePath } from "./worktree-root.js";
 import { loadFile, getManifestStatus } from "./files.js";
-import { loadEffectiveGSDPreferences, resolveSkillDiscoveryMode, getIsolationMode, } from "./preferences.js";
+import { loadEffectiveGSDPreferences, loadEffectiveGSDPreferencesWithRegistry, modelIdsForProfileResolution, resolveProfileAnchorProvider, resolveDisabledModelProvidersFromPreferences, resolveSkillDiscoveryMode, getIsolationMode, } from "./preferences.js";
 import { ensureGsdSymlink, isInheritedRepo, validateProjectId } from "./repo-identity.js";
 import { migrateToExternalState, recoverFailedMigration } from "./migrate-external.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
 import { gsdRoot, resolveMilestoneFile } from "./paths.js";
+import { findMilestoneIds } from "./milestone-ids.js";
 import { milestoneEntryBlockedGuidance } from "./guidance.js";
 import { invalidateAllCaches } from "./cache.js";
 import { writeLock, clearLock, readCrashLock, isLockProcessAlive } from "./crash-recovery.js";
@@ -46,7 +47,7 @@ import { auditOrphanedPreflightStashes } from "./orphan-stash-audit.js";
 import { parseProject } from "./schemas/parsers.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, } from "node:fs";
 import { join } from "node:path";
 import { validateDirectory } from "./validate-directory.js";
 import { isCustomProvider, resolveDefaultSessionModel, resolveDynamicRoutingConfig, } from "./preferences-models.js";
@@ -239,7 +240,7 @@ function formatStrandedWorkBlockerMessage(action, activeMilestoneId) {
         `3. Abandon it: run \`/gsd rethink\` and explicitly discard ${target}.`,
     ].join("\n");
 }
-export function auditOrphanedMilestoneBranches(basePath, _isolationMode, gitDeps = {}) {
+export function auditOrphanedMilestoneBranches(basePath, isolationMode, gitDeps = {}) {
     const recovered = [];
     const warnings = [];
     const actions = [];
@@ -286,6 +287,17 @@ export function auditOrphanedMilestoneBranches(basePath, _isolationMode, gitDeps
     catch {
         mergedBranches = new Set();
     }
+    // Detect the branch currently checked out at the project root once — it
+    // does not change across loop iterations and is used below to avoid
+    // requesting a worktree creation for a branch that git already considers
+    // "in use" by the main worktree.
+    let currentRootBranch = null;
+    try {
+        currentRootBranch = nativeGetCurrentBranch(basePath) || null;
+    }
+    catch {
+        currentRootBranch = null;
+    }
     for (const branch of milestoneBranches) {
         const milestoneId = branch.replace(/^milestone\//, "");
         const milestone = getMilestone(milestoneId);
@@ -313,7 +325,26 @@ export function auditOrphanedMilestoneBranches(basePath, _isolationMode, gitDeps
             }
             if ((isMerged || commitsAhead === 0) && !worktreeEvidence.dirty)
                 continue;
-            const recoveryMode = worktreeEvidence.path
+            // #812 — the worktree directory being absent on disk does NOT mean the
+            // project is branch-mode. getAutoWorktreePath() returns null whenever the
+            // directory is merely missing (transient/permanent loss after an
+            // interrupted session), which previously collapsed to recoveryMode:
+            // "branch" — silently checking out milestone/<id> in the project root with
+            // no worktree. When the project is *configured* for worktree isolation,
+            // recover as "worktree" so adoptStrandedMilestone re-materializes the
+            // worktree from the existing branch (createAutoWorktree with
+            // reuseExistingBranch) instead of degrading to branch-mode-in-root.
+            //
+            // Exception (#812-followup): if the milestone branch is already checked
+            // out at the project root (e.g. a leftover from the pre-fix #812 recovery
+            // that ran `git checkout milestone/<id>` in the root), git considers that
+            // branch "in use by another worktree" and will refuse `git worktree add`,
+            // causing bootstrap to abort. Degrade to "branch" in that case — the
+            // session resumes on the already-checked-out branch without worktree
+            // creation, same as pre-fix behavior, and the configured isolation is
+            // restored for subsequent milestones after merge/teardown.
+            const isBranchCheckedOutAtRoot = currentRootBranch === branch;
+            const recoveryMode = worktreeEvidence.path || (isolationMode === "worktree" && !isBranchCheckedOutAtRoot)
                 ? "worktree"
                 : "branch";
             const message = strandedWorkMessage({
@@ -759,9 +790,10 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
     // run /login" before pausing and resetting to claude-code/claude-sonnet-4-6.
     const manualSessionOverride = getSessionModelOverride(ctx.sessionManager.getSessionId());
     const sessionProviderIsCustom = isCustomProvider(ctx.model?.provider);
+    const profileModelIds = modelIdsForProfileResolution(ctx.modelRegistry, resolveProfileAnchorProvider(ctx.model?.provider), resolveDisabledModelProvidersFromPreferences());
     const preferredModel = sessionProviderIsCustom
         ? null
-        : resolveDefaultSessionModel(ctx.model?.provider, base);
+        : resolveDefaultSessionModel(ctx.model?.provider, base, profileModelIds, ctx.model?.id);
     // Validate the preferred model against the live registry + provider auth so
     // an unconfigured PREFERENCES.md entry (no API key / OAuth) can't become the
     // start-model snapshot. Without this, every subsequent unit would try to
@@ -1124,7 +1156,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 state = await deriveState(base);
             }
         }
-        const effectivePrefs = loadEffectiveGSDPreferences(base)?.preferences;
+        const effectivePrefs = loadEffectiveGSDPreferencesWithRegistry(ctx.modelRegistry, base, resolveProfileAnchorProvider(ctx.model?.provider, startModelSnapshot?.provider), startModelSnapshot ? `${startModelSnapshot.provider}/${startModelSnapshot.id}` : undefined)?.preferences;
         const { shouldRunDeepProjectSetup } = await import("./auto-dispatch.js");
         const deepProjectStagePending = shouldRunDeepProjectSetup(state, effectivePrefs, base, { hasSurvivorBranch });
         if (deepProjectStagePending && !strandedRecoveryAction) {
@@ -1408,7 +1440,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // FlatRateContext used by selectAndApplyModel so user-declared
         // flat-rate providers and externalCli auto-detection are respected.
         const { isFlatRateProvider, buildFlatRateContext } = await import("./auto-model-selection.js");
-        const bannerPrefs = loadEffectiveGSDPreferences(base)?.preferences;
+        const bannerPrefs = loadEffectiveGSDPreferencesWithRegistry(ctx.modelRegistry, base, resolveProfileAnchorProvider(ctx.model?.provider, s.autoModeStartModel?.provider), s.autoModeStartModel ? `${s.autoModeStartModel.provider}/${s.autoModeStartModel.id}` : undefined)?.preferences;
         const effectiveProvider = s.autoModeStartModel?.provider ?? ctx.model?.provider;
         const effectivelyEnabled = routingConfig.enabled
             && (routingConfig.allow_flat_rate_providers
@@ -1449,31 +1481,26 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         }
         // Pre-flight: validate milestone queue
         try {
-            const msDir = join(base, ".gsd", "milestones");
-            if (existsSync(msDir)) {
-                const milestoneIds = readdirSync(msDir, { withFileTypes: true })
-                    .filter((d) => d.isDirectory() && /^M\d{3}/.test(d.name))
-                    .map((d) => d.name.match(/^(M\d{3})/)?.[1] ?? d.name);
-                if (milestoneIds.length > 1) {
-                    const issues = [];
-                    for (const id of milestoneIds) {
-                        // Skip completed/parked milestones — a leftover CONTEXT-DRAFT.md
-                        // on a finished milestone is harmless residue, not an actionable warning.
-                        if (isDbAvailable()) {
-                            const ms = getMilestone(id);
-                            if (ms?.status === "complete" || ms?.status === "parked")
-                                continue;
-                        }
-                        const draft = resolveMilestoneFile(base, id, "CONTEXT-DRAFT");
-                        if (draft)
-                            issues.push(`${id}: has CONTEXT-DRAFT.md (will pause for discussion)`);
-                    }
-                    if (issues.length > 0) {
-                        ctx.ui.notify(`Pre-flight: ${milestoneIds.length} milestones queued.\n${issues.map((i) => `  ⚠ ${i}`).join("\n")}`, "warning");
-                    }
-                    else {
-                        ctx.ui.notify(`Pre-flight: ${milestoneIds.length} milestones queued. All have full context.`, "info");
+            const milestoneIds = findMilestoneIds(base);
+            if (milestoneIds.length > 1) {
+                const issues = [];
+                for (const id of milestoneIds) {
+                    // Skip completed/parked milestones — a leftover CONTEXT-DRAFT.md
+                    // on a finished milestone is harmless residue, not an actionable warning.
+                    if (isDbAvailable()) {
+                        const ms = getMilestone(id);
+                        if (ms?.status === "complete" || ms?.status === "parked")
+                            continue;
                     }
+                    const draft = resolveMilestoneFile(base, id, "CONTEXT-DRAFT");
+                    if (draft)
+                        issues.push(`${id}: has CONTEXT-DRAFT.md (will pause for discussion)`);
+                }
+                if (issues.length > 0) {
+                    ctx.ui.notify(`Pre-flight: ${milestoneIds.length} milestones queued.\n${issues.map((i) => `  ⚠ ${i}`).join("\n")}`, "warning");
+                }
+                else {
+                    ctx.ui.notify(`Pre-flight: ${milestoneIds.length} milestones queued. All have full context.`, "info");
                 }
             }
         }

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

@@ -1,7 +1,7 @@
 // Project/App: gsd-pi
 // File Purpose: Post-unit verification gate for GSD auto-mode units.
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { gsdProjectionRoot, resolveSlicePath } from "./paths.js";
+import { relMilestoneFile, resolveSlicePath } from "./paths.js";
 import { resolveMilestoneValidationVerdict } from "./milestone-validation-verdict.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { parseUnitId } from "./unit-id.js";
@@ -212,7 +212,10 @@ async function runValidateMilestonePostCheck(vctx, pauseAuto) {
         return incompleteSliceCount > 0 || hasAssessmentArtifact;
     };
     const validationBasePath = resolveCanonicalMilestoneRoot(s.basePath, mid);
-    const validationFile = join(gsdProjectionRoot(validationBasePath), "milestones", mid, `${mid}-VALIDATION.md`);
+    // Layout-aware: matches the writer at tools/validate-milestone.ts:167.
+    // Flat-phase resolves to phases/NN-slug/NN-VALIDATION.md; legacy resolves
+    // to milestones/MID/MID-VALIDATION.md. See open-gsd/gsd-pi#876.
+    const validationFile = join(validationBasePath, relMilestoneFile(validationBasePath, mid, "VALIDATION"));
     const validationContent = await loadFile(validationFile);
     if (validationContent !== null && validationContent.trim() === "") {
         if (await reassessmentInvalidatedValidation()) {