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

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

@@ -11,9 +11,21 @@ import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { getUnitWorkflowDispatchReadinessError } from "./tool-contract.js";
-export async function dispatchDirectPhase(ctx, pi, phase, base) {
+export function parseDirectDispatchPhase(raw) {
+    const tokens = raw.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return { phase: "" };
+    const phase = tokens[0].toLowerCase();
+    const milestoneToken = tokens.find((token, index) => index > 0 && /^M\d/i.test(token));
+    return {
+        phase,
+        milestoneId: milestoneToken?.replace(/[.,;:!?]+$/, ""),
+    };
+}
+export async function dispatchDirectPhase(ctx, pi, phase, base, opts = {}) {
+    const parsed = parseDirectDispatchPhase(phase);
     const state = await deriveState(base);
-    const mid = state.activeMilestone?.id;
+    const mid = opts.milestoneId ?? parsed.milestoneId ?? state.activeMilestone?.id;
     const midTitle = state.activeMilestone?.title ?? "";
     if (!mid) {
         ctx.ui.notify("Cannot dispatch: no active milestone.", "warning");
@@ -25,7 +37,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
     // build prompts and create a session anchored to the project root even
     // though the milestone's actual code lives in the worktree.
     const dispatchBase = resolveCanonicalMilestoneRoot(base, mid);
-    const normalized = phase.toLowerCase();
+    const normalized = parsed.phase;
     let unitType;
     let unitId;
     let prompt;

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

@@ -5,11 +5,11 @@ import { getUatBrowserToolSupportError } from "./uat-policy.js";
 import { isDbAvailable, getMilestoneSlices, getMilestoneSliceSummaries, getClosedSliceIds, getPendingGatesForTurn, markPendingGatesOmittedForTurn, getMilestone, insertArtifact, insertAssessment, setSliceSketchFlag, transaction, getAssessment, } 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";
@@ -48,6 +48,22 @@ function resolveExistingExpectedArtifact(unitType, unitId, basePath) {
 }
 let reassessmentChecker = checkNeedsReassessment;
 let researchProjectPromptBuilder = buildResearchProjectPrompt;
+/**
+ * Optional override for the reactive graph derivation step inside the
+ * "executing → reactive-execute" rule. Production leaves this null so the rule
+ * uses the real loadSliceTaskIO + deriveTaskGraph; tests inject a throwing
+ * function to deterministically exercise the best-effort failure path
+ * (auto-dispatch.ts:1494). The catch is otherwise unreachable because every
+ * operation it wraps (loadSliceTaskIO, deriveTaskGraph, saveReactiveState) is
+ * internally defensive.
+ * @internal
+ */
+let _reactiveGraphDeriveFn = null;
+export function setReactiveGraphDeriveFnForTest(fn) {
+    const previous = _reactiveGraphDeriveFn;
+    _reactiveGraphDeriveFn = fn;
+    return () => { _reactiveGraphDeriveFn = previous; };
+}
 function shouldBypassMilestoneDepthGateInAuto(prefs) {
     return isAutoActive() && prefs?.planning_depth !== "deep";
 }
@@ -303,9 +319,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");
@@ -1155,7 +1170,9 @@ export const DISPATCH_RULES = [
                 return null;
             try {
                 const { loadSliceTaskIO, deriveTaskGraph, isGraphAmbiguous, getReadyTasks, chooseNonConflictingSubset, graphMetrics, } = await import("./reactive-graph.js");
-                const taskIO = await loadSliceTaskIO(basePath, mid, sid);
+                const taskIO = _reactiveGraphDeriveFn
+                    ? await _reactiveGraphDeriveFn(basePath, mid, sid)
+                    : await loadSliceTaskIO(basePath, mid, sid);
                 if (taskIO.length < 2)
                     return null; // single task, no point
                 const graph = deriveTaskGraph(taskIO);
@@ -1225,10 +1242,26 @@ export const DISPATCH_RULES = [
             // missing, the planner created S##-PLAN.md with task entries but never
             // wrote the tasks/ directory files. Dispatch plan-slice to regenerate
             // them rather than hard-stopping — fixes the infinite-loop described in
-            // issue #909.
+            // issue #909. Flat-phase layout embeds tasks in the slice plan file, so
+            // skip recovery when tasks are embedded (<tasks> block or task checkboxes in phases/ plan).
             const taskPlanPath = resolveTaskFile(artifactBasePath, mid, sid, tid, "PLAN");
+            const slicePlanPath = resolveSliceFile(artifactBasePath, mid, sid, "PLAN");
+            const phasesRoot = join(gsdProjectionRoot(artifactBasePath), "phases");
+            const slicePlanContent = slicePlanPath && existsSync(slicePlanPath)
+                ? readFileSync(slicePlanPath, "utf-8")
+                : "";
+            const isPhasesSlicePlan = slicePlanPath !== null &&
+                (slicePlanPath === phasesRoot || slicePlanPath.startsWith(`${phasesRoot}${sep}`));
+            const hasTaskCheckboxes = /^-\s+\[[ xX]\]\s+\*\*[\w.]+/m.test(slicePlanContent);
+            const tasksEmbeddedInSlicePlan = Boolean(slicePlanPath &&
+                existsSync(slicePlanPath) &&
+                (slicePlanContent.includes("<tasks>") || (isPhasesSlicePlan && hasTaskCheckboxes)));
+            // tasksEmbeddedInSlicePlan is true when tasks live inside the slice plan
+            // (flat-phase phases/ layout with task checkboxes or renderPlanFromDb <tasks> block).
             const projectionTaskPlanPath = join(gsdProjectionRoot(artifactBasePath), "milestones", mid, "slices", sid, "tasks", buildTaskFileName(tid, "PLAN"));
-            if ((!taskPlanPath || !existsSync(taskPlanPath)) && !existsSync(projectionTaskPlanPath)) {
+            if ((!taskPlanPath || !existsSync(taskPlanPath)) &&
+                !existsSync(projectionTaskPlanPath) &&
+                !tasksEmbeddedInSlicePlan) {
                 if (isDebugEnabled()) {
                     const expectedTaskPlanPath = join(artifactBasePath, relTaskFile(artifactBasePath, mid, sid, tid, "PLAN"));
                     const originalProjectRoot = session?.originalBasePath || basePath;
@@ -1334,7 +1367,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

@@ -12,6 +12,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";
@@ -324,8 +325,8 @@ export function floorThinkingLevelForUnit(unitType, level) {
     }
     return EXECUTE_TASK_MIN_THINKING_LEVEL;
 }
-export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true) {
-    const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
+export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true, basePath, availableModelIds, preferredModelId) {
+    const explicitConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId);
     if (explicitConfig) {
         return {
             ...explicitConfig,
@@ -380,7 +381,9 @@ autoModeStartThinkingLevel) {
     // With no explicit level, fall back to the auto-start session level and raise
     // the code-writing floor — preserving prior behavior exactly. Recomputed per
     // dispatch so neither the floor nor a phase override leaks to other units.
-    const explicitThinkingLevel = resolveThinkingLevelForUnit(unitType);
+    const anchorProvider = resolveProfileAnchorProvider(ctx.model?.provider, autoModeStartModel?.provider);
+    const profileResolutionIds = modelIdsForProfileResolution(ctx.modelRegistry, anchorProvider, resolveDisabledModelProvidersFromPreferences());
+    const explicitThinkingLevel = resolveThinkingLevelForUnit(unitType, basePath, profileResolutionIds);
     const desiredThinkingLevel = explicitThinkingLevel
         ?? floorThinkingLevelForUnit(unitType, autoModeStartThinkingLevel);
     if (explicitThinkingLevel) {
@@ -413,9 +416,12 @@ autoModeStartThinkingLevel) {
             flatRateCtx: buildFlatRateContext(autoModeStartModel.provider, ctx, prefs),
         };
     }
+    const preferredModelId = autoModeStartModel
+        ? `${autoModeStartModel.provider}/${autoModeStartModel.id}`
+        : ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
     const modelConfig = effectiveSessionModelOverride
         ? undefined
-        : resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode);
+        : resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode, basePath, profileResolutionIds, preferredModelId);
     let routing = null;
     let appliedModel = null;
     // ── Restore active-tool baseline before policy evaluation (#4959, #4681, #4850) ──
@@ -575,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,
@@ -611,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 = {
@@ -860,16 +866,16 @@ export function resolveModelId(modelId, availableModels, currentProvider) {
  *
  * 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",
 ];
 /**
  * Flat-rate providers charge the same per request regardless of model.

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;
@@ -1766,11 +1775,11 @@ export async function postUnitPreVerification(pctx, opts) {
                         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, s.currentUnit.type, s.currentUnit.id, 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,
@@ -1782,11 +1791,15 @@ export async function postUnitPreVerification(pctx, opts) {
                             return "continue";
                         }
                         const parallelBlocker = maybeWriteParallelResearchCostSpikeBlocker(s.currentUnit.type, s.currentUnit.id, verificationBasePath, unitCostUsd, rollingAvgUsd);
-                        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");
-                        await pauseAuto(ctx, pi);
-                        return "dispatched";
+                        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(`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");
                     }
                     const attempt = (s.verificationRetryCount.get(retryKey) ?? 0) + 1;
                     const failureDetails = describeArtifactVerificationFailure(s.currentUnit.type, s.currentUnit.id, verificationBasePath, s.lastUnitAgentEndMessages);
@@ -1948,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)
@@ -2085,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;

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

@@ -1167,19 +1167,29 @@ export function extractSliceExecutionExcerpt(content, relPath) {
     return parts.join("\n");
 }
 // ─── Prior Task Summaries ──────────────────────────────────────────────────
-export async function getPriorTaskSummaryPaths(mid, sid, currentTid, base) {
+/** Resolve where task SUMMARY files live (legacy tasks/ subdir or flat-phase phase dir). */
+function resolveTaskSummariesLocation(base, mid, sid) {
+    const slicePath = resolveSlicePath(base, mid, sid);
+    if (!slicePath)
+        return null;
     const tDir = resolveTasksDir(base, mid, sid);
-    if (!tDir)
+    const sRel = relSlicePath(base, mid, sid);
+    if (tDir)
+        return { dir: tDir, relPrefix: `${sRel}/tasks` };
+    return { dir: slicePath, relPrefix: sRel };
+}
+export async function getPriorTaskSummaryPaths(mid, sid, currentTid, base) {
+    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}`);
 }
 /**
  * Get carry-forward summary paths scoped to a task's derived dependencies.
@@ -1196,11 +1206,10 @@ export async function getDependencyTaskSummaryPaths(mid, sid, currentTid, depend
     if (dependsOn.length === 0) {
         return getPriorTaskSummaryPaths(mid, sid, currentTid, base);
     }
-    const tDir = resolveTasksDir(base, mid, sid);
-    if (!tDir)
+    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
         .filter((f) => {
@@ -1208,7 +1217,7 @@ export async function getDependencyTaskSummaryPaths(mid, sid, currentTid, depend
         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 ────────────────────────────────────────────
 /**
@@ -1696,7 +1705,7 @@ export async function buildResearchMilestonePrompt(mid, midTitle, base) {
     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,
@@ -1844,7 +1853,7 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
     return loadPrompt("plan-milestone", {
         workingDirectory: base,
         milestoneId: mid, milestoneTitle: midTitle,
-        milestonePath: relMilestonePath(base, mid),
+        milestonePath: relMilestonePath(base, mid, midTitle),
         contextPath: contextRel,
         researchPath: researchRel,
         researchOutputPath,
@@ -2474,17 +2483,16 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
                     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 = [];
                 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));
                 }
@@ -2734,8 +2742,10 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
     trackPromptContext(contextTelemetry, "cap", cappedInlinedContext.length < rawInlinedContext.length ? "skipped" : "inline", null, cappedInlinedContext.length < rawInlinedContext.length ? `dropped ${rawInlinedContext.length - cappedInlinedContext.length} chars` : "within budget");
     const inlinedContext = prependContextModeToBlock("complete-milestone", base, cappedInlinedContext);
     emitPromptContextTelemetry("complete-milestone", contextTelemetry, inlinedContext);
-    const milestoneSummaryPath = join(base, `${relMilestonePath(base, mid)}/${mid}-SUMMARY.md`);
-    const learningsRelPath = join(relMilestonePath(base, mid), `${mid}-LEARNINGS.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 = relMilestoneFile(base, mid, "LEARNINGS");
     const learningsAbsPath = join(base, learningsRelPath);
     const extractLearningsSteps = buildExtractionStepsBlock({
         milestoneId: mid,
@@ -2965,8 +2975,9 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     trackPromptContext(contextTelemetry, "cap", cappedInlinedContext.length < rawInlinedContext.length ? "skipped" : "inline", null, cappedInlinedContext.length < rawInlinedContext.length ? `dropped ${rawInlinedContext.length - cappedInlinedContext.length} chars` : "within budget");
     const inlinedContext = prependContextModeToBlock("validate-milestone", base, cappedInlinedContext);
     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
     // address, and the block below is what the template renders so the
@@ -3009,17 +3020,16 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
     inlined.push(await inlineFile(slicePlanPath, slicePlanRel, "Current Slice Plan"));
     // 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 }));
@@ -3035,7 +3045,7 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
     if (replanOverridesInline)
         inlined.unshift(replanOverridesInline);
     const inlinedContext = prependContextModeToBlock("replan-slice", base, 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)";
     try {
@@ -3372,7 +3382,11 @@ opts) {
         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.",
             "",