@opengsd/gsd-pi 1.3.0 → 1.4.0

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");
@@ -920,18 +931,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 +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;
@@ -972,16 +980,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 +1238,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 +1298,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 +1381,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);
     if (explicitConfig) {
         return {
             ...explicitConfig,
@@ -416,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, 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) ──
@@ -578,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,
@@ -614,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 = {

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

@@ -17,7 +17,7 @@ import { logWarning, logError } from "./workflow-logger.js";
 import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { isAwaitingUserInput } from "./consent-question.js";
-import { resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
+import { resolveSliceFile, resolveSlicePath, relSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, resolveFile, relMilestoneFile, relSliceFile, relTaskFile, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
@@ -187,7 +187,6 @@ function completeSliceReopenReplanHandoffDetected(s, agentEndMessages) {
     const unitId = s.currentUnit.id;
     return (agentEndMessagesIncludeSuccessfulToolResult(agentEndMessages, "gsd_task_reopen") ||
         agentEndMessagesIncludeToolCall(agentEndMessages, "gsd_task_reopen") ||
-        agentEndMessagesMentionTool(agentEndMessages, "gsd_task_reopen") ||
         unitActivityMentionsTool(s.basePath, unitType, unitId, "gsd_task_reopen") ||
         unitActivityMentionsTool(s.canonicalProjectRoot, unitType, unitId, "gsd_task_reopen"));
 }
@@ -196,7 +195,6 @@ function completeSliceReplanSignalDetected(s, agentEndMessages) {
         return false;
     return (agentEndMessagesIncludeSuccessfulToolResult(agentEndMessages, "gsd_replan_slice") ||
         agentEndMessagesIncludeToolCall(agentEndMessages, "gsd_replan_slice") ||
-        agentEndMessagesMentionTool(agentEndMessages, "gsd_replan_slice") ||
         unitActivityMentionsTool(s.basePath, s.currentUnit.type, s.currentUnit.id, "gsd_replan_slice") ||
         unitActivityMentionsTool(s.canonicalProjectRoot, s.currentUnit.type, s.currentUnit.id, "gsd_replan_slice"));
 }
@@ -359,6 +357,17 @@ function getPlannedKeyFiles(tasks) {
 }
 export const _parseReactiveBatchTaskIdsForTest = parseReactiveBatchTaskIds;
 export const _getPlannedKeyFilesForTest = getPlannedKeyFiles;
+function resolveTaskArtifactPath(basePath, mid, sid, tid, suffix) {
+    const legacy = resolveTaskFile(basePath, mid, sid, tid, suffix);
+    if (legacy)
+        return legacy;
+    const slicePath = resolveSlicePath(basePath, mid, sid);
+    if (!slicePath)
+        return null;
+    const taskDir = resolveTasksDir(basePath, mid, sid) ?? slicePath;
+    const file = resolveFile(taskDir, tid, suffix);
+    return file ? join(taskDir, file) : null;
+}
 function resolveVerificationFailureMarkerPath(unitType, unitId, basePath) {
     const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
@@ -366,22 +375,19 @@ function resolveVerificationFailureMarkerPath(unitType, unitId, basePath) {
             const existing = resolveMilestoneFile(basePath, mid, "VERIFICATION-FAILED");
             if (existing)
                 return existing;
-            const milestoneDir = resolveMilestonePath(basePath, mid);
-            return milestoneDir ? join(milestoneDir, `${mid}-VERIFICATION-FAILED.md`) : null;
+            return join(basePath, relMilestoneFile(basePath, mid, "VERIFICATION-FAILED"));
         }
         case "complete-slice": {
             const existing = resolveSliceFile(basePath, mid, sid, "VERIFICATION-FAILED");
             if (existing)
                 return existing;
-            const sliceDir = resolveSlicePath(basePath, mid, sid);
-            return sliceDir ? join(sliceDir, `${sid}-VERIFICATION-FAILED.md`) : null;
+            return join(basePath, relSliceFile(basePath, mid, sid, "VERIFICATION-FAILED"));
         }
         case "execute-task": {
-            const existing = resolveTaskFile(basePath, mid, sid, tid, "VERIFICATION-FAILED");
+            const existing = resolveTaskArtifactPath(basePath, mid, sid, tid, "VERIFICATION-FAILED");
             if (existing)
                 return existing;
-            const tasksDir = resolveTasksDir(basePath, mid, sid);
-            return tasksDir ? join(tasksDir, buildTaskFileName(tid, "VERIFICATION-FAILED")) : null;
+            return join(basePath, relTaskFile(basePath, mid, sid, tid, "VERIFICATION-FAILED"));
         }
         default:
             return null;
@@ -395,7 +401,7 @@ async function buildTaskCommitContextForUnit(basePath, unitId) {
     const slice = isDbAvailable() ? getSlice(mid, sid) : null;
     const task = isDbAvailable() ? getTask(mid, sid, tid) : null;
     let summary = null;
-    const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+    const summaryPath = resolveTaskArtifactPath(basePath, mid, sid, tid, "SUMMARY");
     if (summaryPath) {
         try {
             const summaryContent = await loadFile(summaryPath);
@@ -563,7 +569,7 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
     if (unitType === "execute-task") {
         if (!mid || !sid || !tid)
             return [];
-        const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+        const summaryPath = resolveTaskArtifactPath(basePath, mid, sid, tid, "SUMMARY");
         if (!summaryPath || !existsSync(summaryPath))
             return [];
         const dbRow = getTask(mid, sid, tid);
@@ -629,7 +635,7 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
     else if (unitType === "plan-task") {
         if (!mid || !sid || !tid)
             return [];
-        const taskPlanPath = resolveTaskFile(basePath, mid, sid, tid, "PLAN");
+        const taskPlanPath = resolveTaskArtifactPath(basePath, mid, sid, tid, "PLAN");
         if (!taskPlanPath || !existsSync(taskPlanPath))
             return [];
         const dbRow = getTask(mid, sid, tid);
@@ -1717,7 +1723,10 @@ export async function postUnitPreVerification(pctx, opts) {
                         return "dispatched";
                     }
                     s.toolUnavailableRetries++;
-                    const delayMs = s.toolUnavailableRetries * 1000;
+                    // Exponential backoff starting at 10s (10s, 20s, 40s capped at 45s). MCP server
+                    // startup can take tens of seconds; a 1s/2s/3s linear delay re-dispatches before
+                    // the server finishes connecting, causing a stuck loop. See #817.
+                    const delayMs = Math.min(10_000 * Math.pow(2, s.toolUnavailableRetries - 1), 45_000);
                     debugLog("postUnit", { phase: "tool-unavailable-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, error: s.lastToolInvocationError, attempt: s.toolUnavailableRetries, delayMs });
                     ctx.ui.notify(`Tool unavailable for ${s.currentUnit.type}: ${s.lastToolInvocationError}. Waiting ${delayMs}ms for MCP server — retry ${s.toolUnavailableRetries}/${MAX_TOOL_UNAVAIL_RETRIES}.`, "warning");
                     s.lastToolInvocationError = null;
@@ -1825,7 +1834,7 @@ export async function postUnitPreVerification(pctx, opts) {
                     saveCustomVerifyRetryCounts(s, { logFailure: err => debugLog("postUnit", { phase: "save-verify-retries-failed", error: err instanceof Error ? err.message : String(err) }) });
                     s.pendingVerificationRetry = {
                         unitId: s.currentUnit.id,
-                        failureContext: `${failureDetails} (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`,
+                        failureContext: failureDetails,
                         attempt,
                     };
                     debugLog("postUnit", { phase: "artifact-verify-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
@@ -1952,12 +1961,9 @@ export async function postUnitPostVerification(pctx) {
                     // 2. Delete SUMMARY.md for the task
                     if (mid && sid && tid) {
                         // Phase C: read+delete via canonical project root.
-                        const tasksDir = resolveTasksDir(s.canonicalProjectRoot, mid, sid);
-                        if (tasksDir) {
-                            const summaryFile = join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
-                            if (existsSync(summaryFile)) {
-                                unlinkSync(summaryFile);
-                            }
+                        const summaryPath = resolveTaskArtifactPath(s.canonicalProjectRoot, mid, sid, tid, "SUMMARY");
+                        if (summaryPath && existsSync(summaryPath)) {
+                            unlinkSync(summaryPath);
                         }
                     }
                     // 3. Delete the retry_on artifact (e.g. NEEDS-REWORK.md)
@@ -2089,7 +2095,7 @@ export async function postUnitPostVerification(pctx) {
                 // Write evidence JSON to slice artifacts directory
                 const slicePath = resolveSlicePath(s.canonicalProjectRoot, mid, sid);
                 const evidenceFileName = `${sid}-PRE-EXEC-VERIFY.json`;
-                let evidencePath = join(".gsd", "milestones", mid, "slices", sid, evidenceFileName);
+                let evidencePath = join(relSlicePath(s.canonicalProjectRoot, mid, sid), evidenceFileName);
                 if (slicePath) {
                     writePreExecutionEvidence(result, slicePath, mid, sid);
                     evidencePath = relative(s.canonicalProjectRoot, join(slicePath, evidenceFileName)) || evidenceFileName;