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

package/src/resources/extensions/gsd/auto-direct-dispatch.ts

@@ -33,14 +33,27 @@ import { pauseAuto } from "./auto.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { getUnitWorkflowDispatchReadinessError } from "./tool-contract.js";
 
+export function parseDirectDispatchPhase(raw: string): { phase: string; milestoneId?: string } {
+  const tokens = raw.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) return { phase: "" };
+  const phase = tokens[0].toLowerCase();
+  const milestoneToken = tokens.find((token, index) => index > 0 && /^M\d/i.test(token));
+  return {
+    phase,
+    milestoneId: milestoneToken?.replace(/[.,;:!?]+$/, ""),
+  };
+}
+
 export async function dispatchDirectPhase(
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI,
   phase: string,
   base: string,
+  opts: { milestoneId?: string } = {},
 ): Promise<void> {
+  const parsed = parseDirectDispatchPhase(phase);
   const state = await deriveState(base);
-  const mid = state.activeMilestone?.id;
+  const mid = opts.milestoneId ?? parsed.milestoneId ?? state.activeMilestone?.id;
   const midTitle = state.activeMilestone?.title ?? "";
 
   if (!mid) {
@@ -56,7 +69,7 @@ export async function dispatchDirectPhase(
   // though the milestone's actual code lives in the worktree.
   const dispatchBase = resolveCanonicalMilestoneRoot(base, mid);
 
-  const normalized = phase.toLowerCase();
+  const normalized = parsed.phase;
   let unitType: string;
   let unitId: string;
   let prompt: string;

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -12,7 +12,7 @@
  * without modifying orchestration code.
  */
 
-import type { GSDState } from "./types.js";
+import type { GSDState, TaskIO } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
 import type { MinimalModelRegistry } from "./context-budget.js";
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
@@ -44,15 +44,15 @@ import {
   resolveTaskFile,
   relTaskFile,
   relSliceFile,
+  relMilestoneFile,
   buildMilestoneFileName,
-  buildSliceFileName,
   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,
@@ -179,6 +179,26 @@ type ResearchProjectPromptBuilder = typeof buildResearchProjectPrompt;
 let reassessmentChecker: ReassessmentChecker = checkNeedsReassessment;
 let researchProjectPromptBuilder: ResearchProjectPromptBuilder = buildResearchProjectPrompt;
 
+/**
+ * Optional override for the reactive graph derivation step inside the
+ * "executing → reactive-execute" rule. Production leaves this null so the rule
+ * uses the real loadSliceTaskIO + deriveTaskGraph; tests inject a throwing
+ * function to deterministically exercise the best-effort failure path
+ * (auto-dispatch.ts:1494). The catch is otherwise unreachable because every
+ * operation it wraps (loadSliceTaskIO, deriveTaskGraph, saveReactiveState) is
+ * internally defensive.
+ * @internal
+ */
+let _reactiveGraphDeriveFn: ((basePath: string, mid: string, sid: string) => Promise<TaskIO[]>) | null = null;
+
+export function setReactiveGraphDeriveFnForTest(
+  fn: ((basePath: string, mid: string, sid: string) => Promise<TaskIO[]>) | null,
+): () => void {
+  const previous = _reactiveGraphDeriveFn;
+  _reactiveGraphDeriveFn = fn;
+  return () => { _reactiveGraphDeriveFn = previous; };
+}
+
 function shouldBypassMilestoneDepthGateInAuto(prefs: GSDPreferences | undefined): boolean {
   return isAutoActive() && prefs?.planning_depth !== "deep";
 }
@@ -502,9 +522,8 @@ function backfillMissingAssessmentsFromSummaries(basePath: string, mid: string):
     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");
@@ -1421,7 +1440,9 @@ export const DISPATCH_RULES: DispatchRule[] = [
           graphMetrics,
         } = await import("./reactive-graph.js");
 
-        const taskIO = await loadSliceTaskIO(basePath, mid, sid);
+        const taskIO = _reactiveGraphDeriveFn
+          ? await _reactiveGraphDeriveFn(basePath, mid, sid)
+          : await loadSliceTaskIO(basePath, mid, sid);
         if (taskIO.length < 2) return null; // single task, no point
 
         const graph = deriveTaskGraph(taskIO);
@@ -1510,8 +1531,25 @@ export const DISPATCH_RULES: DispatchRule[] = [
       // 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",
@@ -1521,7 +1559,11 @@ export const DISPATCH_RULES: DispatchRule[] = [
         "tasks",
         buildTaskFileName(tid, "PLAN"),
       );
-      if ((!taskPlanPath || !existsSync(taskPlanPath)) && !existsSync(projectionTaskPlanPath)) {
+      if (
+        (!taskPlanPath || !existsSync(taskPlanPath)) &&
+        !existsSync(projectionTaskPlanPath) &&
+        !tasksEmbeddedInSlicePlan
+      ) {
         if (isDebugEnabled()) {
           const expectedTaskPlanPath = join(artifactBasePath, relTaskFile(artifactBasePath, mid, sid, tid, "PLAN"));
           const originalProjectRoot = session?.originalBasePath || basePath;
@@ -1653,10 +1695,13 @@ export const DISPATCH_RULES: DispatchRule[] = [
           };
         }
         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/src/resources/extensions/gsd/auto-model-selection.ts

@@ -17,6 +17,7 @@ import { unitPhaseLabel } from "./auto-dashboard.js";
 import { getSessionModelOverride } from "./session-model-override.js";
 import { logWarning } from "./workflow-logger.js";
 import { resolveUokFlags } from "./uok/flags.js";
+import { modelIdsForProfileResolution, resolveProfileAnchorProvider, resolveDisabledModelProvidersFromPreferences } from "./preferences.js";
 import { applyModelPolicyFilter } from "./uok/model-policy.js";
 import { isModelBlocked, isModelTemporarilyUnavailable } from "./blocked-models.js";
 import { getRequiredWorkflowToolsForAutoUnit, isWorkflowMcpSurfaceTool } from "./workflow-mcp.js";
@@ -404,8 +405,11 @@ export function resolvePreferredModelConfig(
   unitType: string,
   autoModeStartModel: { provider: string; id: string; flatRateCtx?: FlatRateContext } | null,
   isAutoMode = true,
+  basePath?: string,
+  availableModelIds?: string[],
+  preferredModelId?: string,
 ): PreferredModelConfig | undefined {
-  const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
+  const explicitConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId);
   if (explicitConfig) {
     return {
       ...explicitConfig,
@@ -475,8 +479,14 @@ export async function selectAndApplyModel(
   // With no explicit level, fall back to the auto-start session level and raise
   // the code-writing floor — preserving prior behavior exactly. Recomputed per
   // dispatch so neither the floor nor a phase override leaks to other units.
+  const anchorProvider = resolveProfileAnchorProvider(ctx.model?.provider, autoModeStartModel?.provider);
+  const profileResolutionIds = modelIdsForProfileResolution(
+    ctx.modelRegistry,
+    anchorProvider,
+    resolveDisabledModelProvidersFromPreferences(),
+  );
   const explicitThinkingLevel =
-    resolveThinkingLevelForUnit(unitType) as ReturnType<ExtensionAPI["getThinkingLevel"]> | undefined;
+    resolveThinkingLevelForUnit(unitType, basePath, profileResolutionIds) as ReturnType<ExtensionAPI["getThinkingLevel"]> | undefined;
   const desiredThinkingLevel = explicitThinkingLevel
     ?? floorThinkingLevelForUnit(unitType, autoModeStartThinkingLevel);
   if (explicitThinkingLevel) {
@@ -518,9 +528,19 @@ export async function selectAndApplyModel(
       flatRateCtx: buildFlatRateContext(autoModeStartModel.provider, ctx, prefs),
     };
   }
+  const preferredModelId = autoModeStartModel
+    ? `${autoModeStartModel.provider}/${autoModeStartModel.id}`
+    : ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
   const modelConfig = effectiveSessionModelOverride
     ? undefined
-    : resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode);
+    : resolvePreferredModelConfig(
+      unitType,
+      autoModeStartModel,
+      isAutoMode,
+      basePath,
+      profileResolutionIds,
+      preferredModelId,
+    );
   let routing: { tier: string; modelDowngraded: boolean } | null = null;
   let appliedModel: Model<Api> | null = null;
 
@@ -722,6 +742,7 @@ export async function selectAndApplyModel(
             classification.tier,
             availableModelIds,
             routingConfig,
+            preferredModelId,
           );
           const hookResult = await pi.emitBeforeModelSelect({
             unitType,
@@ -766,6 +787,7 @@ export async function selectAndApplyModel(
             unitType,
             classification.taskMetadata,
             capabilityOverrides,
+            preferredModelId,
           );
         }
 
@@ -1068,16 +1090,16 @@ export function resolveModelId<T extends { id: string; provider: string }>(
  *
  * Order rationale:
  * - openai-codex before github-copilot: ChatGPT-native for shared GPT IDs
- * - google-gemini-cli before github-copilot: first-party Gemini CLI
+ * - google-antigravity before google-gemini-cli: Antigravity replaced Gemini CLI for individuals
  * - anthropic before github-copilot: first-party Claude API/OAuth over Copilot
  * - github-copilot before openai/google: Copilot OAuth over platform API keys
  */
 export const BARE_ID_SUBSCRIPTION_PROVIDER_PRECEDENCE = [
   "openai-codex",
+  "google-antigravity",
   "google-gemini-cli",
   "anthropic",
   "github-copilot",
-  "google-antigravity",
 ] as const;
 
 /**

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -20,13 +20,16 @@ import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { isAwaitingUserInput } from "./consent-question.js";
 import {
-  resolveMilestonePath,
   resolveSliceFile,
   resolveSlicePath,
+  relSlicePath,
   resolveTaskFile,
   resolveMilestoneFile,
   resolveTasksDir,
-  buildTaskFileName,
+  resolveFile,
+  relMilestoneFile,
+  relSliceFile,
+  relTaskFile,
 } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { rebuildState } from "./doctor.js";
@@ -233,7 +236,6 @@ function completeSliceReopenReplanHandoffDetected(
   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")
   );
@@ -247,7 +249,6 @@ function completeSliceReplanSignalDetected(
   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")
   );
@@ -441,6 +442,22 @@ function getPlannedKeyFiles(tasks: Array<
 export const _parseReactiveBatchTaskIdsForTest = parseReactiveBatchTaskIds;
 export const _getPlannedKeyFilesForTest = getPlannedKeyFiles;
 
+function resolveTaskArtifactPath(
+  basePath: string,
+  mid: string,
+  sid: string,
+  tid: string,
+  suffix: string,
+): string | null {
+  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: string,
   unitId: string,
@@ -451,20 +468,17 @@ function resolveVerificationFailureMarkerPath(
     case "complete-milestone": {
       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;
@@ -483,7 +497,7 @@ async function buildTaskCommitContextForUnit(
   const task = isDbAvailable() ? getTask(mid, sid, tid) : null;
   let summary: ReturnType<typeof parseSummary> | null = 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);
@@ -696,7 +710,7 @@ export function detectRogueFileWrites(
   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);
@@ -762,7 +776,7 @@ export function detectRogueFileWrites(
   } 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);
@@ -2041,7 +2055,10 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
             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}.`,
@@ -2100,9 +2117,6 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
             return "dispatched";
           }
           if (getUnitCostSpikeAction(unitCostUsd, rollingAvgUsd, resolveUnitCostSpikeMultiplier(prefs)) === "pause") {
-            s.pendingVerificationRetry = null;
-            s.verificationRetryCount.delete(retryKey);
-            s.verificationRetryFailureHashes.delete(retryKey);
             const advancedPastUnit = await hasArtifactCostGuardAdvancedPastUnit(
               s,
               ctx,
@@ -2111,6 +2125,9 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
               prefs,
             );
             if (advancedPastUnit) {
+              s.pendingVerificationRetry = null;
+              s.verificationRetryCount.delete(retryKey);
+              s.verificationRetryFailureHashes.delete(retryKey);
               debugLog("postUnit", {
                 phase: "artifact-cost-spike-continue-after-advance",
                 unitType: s.currentUnit.type,
@@ -2131,14 +2148,21 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
               unitCostUsd,
               rollingAvgUsd,
             );
+            if (parallelBlocker) {
+              s.pendingVerificationRetry = null;
+              s.verificationRetryCount.delete(retryKey);
+              s.verificationRetryFailureHashes.delete(retryKey);
+              ctx.ui.notify(
+                `Unit ${s.currentUnit.id} cost spike detected (${unitCostUsd.toFixed(2)} vs avg ${rollingAvgUsd.toFixed(2)}) — wrote parallel blocker and pausing auto-mode.`,
+                "error",
+              );
+              await pauseAuto(ctx, pi);
+              return "dispatched";
+            }
             ctx.ui.notify(
-              parallelBlocker
-                ? `Unit ${s.currentUnit.id} cost spike detected (${unitCostUsd.toFixed(2)} vs avg ${rollingAvgUsd.toFixed(2)}) — wrote parallel blocker and pausing auto-mode.`
-                : `Unit ${s.currentUnit.id} cost spike detected (${unitCostUsd.toFixed(2)} vs avg ${rollingAvgUsd.toFixed(2)}) — pausing auto-mode.`,
-              "error",
+              `Unit ${s.currentUnit.id} cost spike detected (${unitCostUsd.toFixed(2)} vs avg ${rollingAvgUsd.toFixed(2)}) during artifact verification retry; keeping verification failure as the authoritative blocker.`,
+              "warning",
             );
-            await pauseAuto(ctx, pi);
-            return "dispatched";
           }
           const attempt = (s.verificationRetryCount.get(retryKey) ?? 0) + 1;
           const failureDetails = describeArtifactVerificationFailure(
@@ -2344,12 +2368,9 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
           // 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);
             }
           }
 
@@ -2508,7 +2529,7 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
         // 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;

package/src/resources/extensions/gsd/auto-prompts.ts

@@ -1343,22 +1343,33 @@ export function extractSliceExecutionExcerpt(content: string | null, relPath: st
 
 // ─── Prior Task Summaries ──────────────────────────────────────────────────
 
+/** Resolve where task SUMMARY files live (legacy tasks/ subdir or flat-phase phase dir). */
+function resolveTaskSummariesLocation(
+  base: string, mid: string, sid: string,
+): { dir: string; relPrefix: string } | null {
+  const slicePath = resolveSlicePath(base, mid, sid);
+  if (!slicePath) return null;
+  const tDir = resolveTasksDir(base, mid, sid);
+  const sRel = relSlicePath(base, mid, sid);
+  if (tDir) return { dir: tDir, relPrefix: `${sRel}/tasks` };
+  return { dir: slicePath, relPrefix: sRel };
+}
+
 export async function getPriorTaskSummaryPaths(
   mid: string, sid: string, currentTid: string, base: string,
 ): Promise<string[]> {
-  const tDir = resolveTasksDir(base, mid, sid);
-  if (!tDir) return [];
+  const loc = resolveTaskSummariesLocation(base, mid, sid);
+  if (!loc) return [];
 
-  const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
+  const summaryFiles = resolveTaskFiles(loc.dir, "SUMMARY");
   const currentNum = parseInt(currentTid.replace(/^T/, ""), 10);
-  const sRel = relSlicePath(base, mid, sid);
 
   return summaryFiles
     .filter(f => {
       const num = parseInt(f.replace(/^T/, ""), 10);
       return num < currentNum;
     })
-    .map(f => `${sRel}/tasks/${f}`);
+    .map(f => `${loc.relPrefix}/${f}`);
 }
 
 /**
@@ -1380,11 +1391,10 @@ export async function getDependencyTaskSummaryPaths(
     return getPriorTaskSummaryPaths(mid, sid, currentTid, base);
   }
 
-  const tDir = resolveTasksDir(base, mid, sid);
-  if (!tDir) return [];
+  const loc = resolveTaskSummariesLocation(base, mid, sid);
+  if (!loc) return [];
 
-  const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
-  const sRel = relSlicePath(base, mid, sid);
+  const summaryFiles = resolveTaskFiles(loc.dir, "SUMMARY");
   const depSet = new Set(dependsOn.map((d) => d.toUpperCase()));
 
   return summaryFiles
@@ -1393,7 +1403,7 @@ export async function getDependencyTaskSummaryPaths(
       const tid = f.replace(/-SUMMARY\.md$/i, "").toUpperCase();
       return depSet.has(tid);
     })
-    .map((f) => `${sRel}/tasks/${f}`);
+    .map((f) => `${loc.relPrefix}/${f}`);
 }
 
 // ─── Adaptive Replanning Checks ────────────────────────────────────────────
@@ -1960,7 +1970,7 @@ export async function buildResearchMilestonePrompt(mid: string, midTitle: string
   return loadPrompt("research-milestone", {
     workingDirectory: base,
     milestoneId: mid, milestoneTitle: midTitle,
-    milestonePath: relMilestonePath(base, mid),
+    milestonePath: relMilestonePath(base, mid, midTitle),
     contextPath: relMilestoneFile(base, mid, "CONTEXT"),
     outputPath: join(base, outputRelPath),
     inlinedContext,
@@ -2117,7 +2127,7 @@ export async function buildPlanMilestonePrompt(mid: string, midTitle: string, ba
   return loadPrompt("plan-milestone", {
     workingDirectory: base,
     milestoneId: mid, milestoneTitle: midTitle,
-    milestonePath: relMilestonePath(base, mid),
+    milestonePath: relMilestonePath(base, mid, midTitle),
     contextPath: contextRel,
     researchPath: researchRel,
     researchOutputPath,
@@ -2886,17 +2896,16 @@ export async function buildCompleteSlicePrompt(
           return body;
         }
       case "prior-task-summaries": {
-        const tDir = resolveTasksDir(base, mid, sid);
-        if (!tDir) {
+        const loc = resolveTaskSummariesLocation(base, mid, sid);
+        if (!loc) {
           trackPromptContext(contextTelemetry, "prior-task-summaries", "skipped", null, "missing tasks dir");
           return null;
         }
-        const summaryFiles = resolveTaskFiles(tDir, "SUMMARY").sort();
-        const sRel = relSlicePath(base, mid, sid);
+        const summaryFiles = resolveTaskFiles(loc.dir, "SUMMARY").sort();
         const blocks: string[] = [];
         for (const file of summaryFiles) {
-          const absPath = join(tDir, file);
-          const relPath = `${sRel}/tasks/${file}`;
+          const absPath = join(loc.dir, file);
+          const relPath = `${loc.relPrefix}/${file}`;
           const taskId = file.replace(/-SUMMARY\.md$/i, "");
           blocks.push(await buildTaskSummaryExcerpt(absPath, relPath, taskId));
         }
@@ -3178,9 +3187,11 @@ export async function buildCompleteMilestonePrompt(
   );
   emitPromptContextTelemetry("complete-milestone", contextTelemetry, inlinedContext);
 
-  const milestoneSummaryPath = join(base, `${relMilestonePath(base, mid)}/${mid}-SUMMARY.md`);
+  // Use relMilestoneFile to get the layout-aware filename (NN-SUFFIX.md for flat-phase,
+  // M001-SUFFIX.md for legacy) rather than manually appending the raw milestone id.
+  const milestoneSummaryPath = join(base, relMilestoneFile(base, mid, "SUMMARY"));
 
-  const learningsRelPath = join(relMilestonePath(base, mid), `${mid}-LEARNINGS.md`);
+  const learningsRelPath = relMilestoneFile(base, mid, "LEARNINGS");
   const learningsAbsPath = join(base, learningsRelPath);
   const extractLearningsSteps = buildExtractionStepsBlock({
     milestoneId: mid,
@@ -3417,8 +3428,9 @@ export async function buildValidateMilestonePrompt(
   );
   emitPromptContextTelemetry("validate-milestone", contextTelemetry, inlinedContext);
 
-  const validationOutputPath = join(base, `${relMilestonePath(base, mid)}/${mid}-VALIDATION.md`);
-  const roadmapOutputPath = `${relMilestonePath(base, mid)}/${mid}-ROADMAP.md`;
+  // Use relMilestoneFile for layout-aware filenames (NN-SUFFIX.md flat-phase, M001-SUFFIX.md legacy).
+  const validationOutputPath = join(base, relMilestoneFile(base, mid, "VALIDATION"));
+  const roadmapOutputPath = relMilestoneFile(base, mid, "ROADMAP");
 
   // Every milestone validation turn owns MV01–MV04 unconditionally: the
   // registry is the source of truth for which gates the validator must
@@ -3467,16 +3479,15 @@ export async function buildReplanSlicePrompt(
 
   // Find the blocker task summary — the completed task with blocker_discovered: true
   let blockerTaskId = "";
-  const tDir = resolveTasksDir(base, mid, sid);
-  if (tDir) {
-    const summaryFiles = resolveTaskFiles(tDir, "SUMMARY").sort();
+  const summaryLoc = resolveTaskSummariesLocation(base, mid, sid);
+  if (summaryLoc) {
+    const summaryFiles = resolveTaskFiles(summaryLoc.dir, "SUMMARY").sort();
     for (const file of summaryFiles) {
-      const absPath = join(tDir, file);
+      const absPath = join(summaryLoc.dir, file);
       const content = await loadFile(absPath);
       if (!content) continue;
       const summary = parseSummary(content);
-      const sRel = relSlicePath(base, mid, sid);
-      const relPath = `${sRel}/tasks/${file}`;
+      const relPath = `${summaryLoc.relPrefix}/${file}`;
       if (summary.frontmatter.blocker_discovered) {
         blockerTaskId = summary.frontmatter.id || file.replace(/-SUMMARY\.md$/i, "");
         inlined.push(await buildTaskSummaryExcerpt(absPath, relPath, blockerTaskId, { blocker: true }));
@@ -3497,7 +3508,7 @@ export async function buildReplanSlicePrompt(
     capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`),
   );
 
-  const replanPath = join(base, `${relSlicePath(base, mid, sid)}/${sid}-REPLAN.md`);
+  const replanPath = join(base, relSliceFile(base, mid, sid, "REPLAN"));
 
   // Build capture context for replan prompt (captures that triggered this replan)
   let captureContext = "(none)";
@@ -3891,7 +3902,11 @@ export async function buildReactiveExecutePrompt(
     const taskPrompt = [
       `## UNIT: Execute Task ${tid} ("${tTitle}")`,
       "",
-      "Work only in the repository root.",
+      "## Working Directory",
+      "",
+      `Your working directory is \`${base}\`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT \`cd\` to any other directory.`,
+      `If any inlined plan names an absolute path outside \`${base}\`, treat it as stale — use the equivalent path under \`${base}\` before reading, writing, or executing.`,
+      "",
       "Implement from the inlined task plan below. Verify changes, then call `gsd_task_complete`.",
       "Do not run git commands.",
       "",