@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

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

@@ -2,14 +2,14 @@
 // File Purpose: Declarative auto-mode dispatch rules and dispatch resolver.
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
 import { getUatBrowserToolSupportError } from "./uat-policy.js";
-import { isDbAvailable, getMilestoneSlices, getMilestoneSliceSummaries, getClosedSliceIds, getPendingGatesForTurn, markPendingGatesOmittedForTurn, getMilestone, insertArtifact, insertAssessment, setSliceSketchFlag, transaction, getAssessment, } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getMilestoneSliceSummaries, getClosedSliceIds, getPendingGatesForTurn, markPendingGatesOmittedForTurn, getMilestone, insertArtifact, insertAssessment, setSliceSketchFlag, transaction, getAssessment, getSliceRunUatAssessment, } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
-import { gsdRoot, resolveGsdPathContract, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, relTaskFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, gsdProjectionRoot, } from "./paths.js";
+import { gsdRoot, resolveGsdPathContract, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relTaskFile, relSliceFile, relMilestoneFile, buildTaskFileName, gsdProjectionRoot, } from "./paths.js";
 import { validateArtifact } from "./schemas/validate.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
-import { dirname, join } from "node:path";
+import { dirname, join, sep } from "node:path";
 import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
 import { buildDiscussMilestonePrompt, buildDiscussProjectPrompt, buildDiscussRequirementsPrompt, buildResearchDecisionPrompt, buildResearchProjectPrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildRefineSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
 import { resolveModelWithFallbacksForUnit, resolveThinkingLevelForUnit } from "./preferences-models.js";
@@ -40,7 +40,7 @@ import { detectWorktreeName } from "./worktree.js";
 import { probeGitConflictState } from "./git-conflict-state.js";
 import { runTurnGitAction } from "./git-service.js";
 import { parseUnitId } from "./unit-id.js";
-import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
+import { resolveExpectedArtifactPath, resolveExistingSliceResearchPath } from "./auto-artifact-paths.js";
 import { formatCloseoutProofBlock, proveMilestoneCloseout, } from "./milestone-closeout-proof.js";
 function resolveExistingExpectedArtifact(unitType, unitId, basePath) {
     const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
@@ -155,6 +155,18 @@ export async function readUatGateVerdict(basePath, mid, sliceId) {
             return { verdict: legacyUatVerdict, uatType };
         }
     }
+    // ADR-017 DB fallback: when the ASSESSMENT markdown is missing or orphaned
+    // from its canonical path (e.g. after a milestone artifact-layout migration
+    // moves slice artifacts from `phases/…` to `milestones/…`), consult the
+    // authoritative assessments table by (mid, slice) identity instead of path.
+    // `gsd_uat_result_save` always writes this row, so it is the source of truth.
+    const runUatAssessment = getSliceRunUatAssessment(mid, sliceId);
+    if (runUatAssessment?.status) {
+        return {
+            verdict: runUatAssessment.status,
+            uatType: uatType ?? extractUatType(runUatAssessment.fullContent),
+        };
+    }
     return null;
 }
 /**
@@ -319,9 +331,8 @@ function backfillMissingAssessmentsFromSummaries(basePath, mid) {
         const summaryPath = resolveSliceFile(basePath, mid, sliceId, "SUMMARY");
         if (!summaryPath || !existsSync(summaryPath))
             continue;
-        const slicePath = resolveSlicePath(basePath, mid, sliceId);
         const assessmentPath = resolveSliceFile(basePath, mid, sliceId, "ASSESSMENT")
-            ?? (slicePath ? join(slicePath, buildSliceFileName(sliceId, "ASSESSMENT")) : null);
+            ?? join(basePath, relSliceFile(basePath, mid, sliceId, "ASSESSMENT"));
         if (!assessmentPath)
             continue;
         const assessmentRelPath = relSliceFile(basePath, mid, sliceId, "ASSESSMENT");
@@ -585,7 +596,7 @@ export const DISPATCH_RULES = [
         },
     },
     {
-        name: "uat-verdict-gate (non-PASS blocks progression)",
+        name: "uat-verdict-gate (non-PASS observed; closeout enforces)",
         match: async ({ mid, basePath, prefs }) => {
             // Only applies when UAT dispatch is enabled
             if (!prefs?.uat_dispatch)
@@ -600,9 +611,9 @@ export const DISPATCH_RULES = [
                     continue;
                 const { verdict, uatType } = result;
                 if (!isAcceptableUatVerdict(verdict, uatType)) {
-                    // Do not hard-stop auto-mode on non-PASS verdicts. Allow progression
-                    // so follow-up slices can remediate, while complete-milestone still
-                    // enforces manual UAT PASS sign-off before closure.
+                    // Observe non-PASS verdicts without hard-stopping auto-mode. Allow
+                    // progression so follow-up slices can remediate, while
+                    // complete-milestone still enforces manual UAT PASS sign-off before closure.
                     continue;
                 }
             }
@@ -891,9 +902,19 @@ export const DISPATCH_RULES = [
             const sliceContextFile = resolveSliceFile(basePath, mid, state.activeSlice.id, "CONTEXT");
             if (sliceContextFile && existsSync(sliceContextFile))
                 return null; // discussion already done, proceed
+            const closedSliceIds = getClosedSliceIds(mid);
+            const justClosedSliceId = closedSliceIds[closedSliceIds.length - 1];
+            let priorVerdictWarning = "";
+            if (justClosedSliceId) {
+                const prior = await readUatGateVerdict(basePath, mid, justClosedSliceId);
+                if (prior && !isAcceptableUatVerdict(prior.verdict, prior.uatType)) {
+                    priorVerdictWarning =
+                        ` Note: the slice just closed (${justClosedSliceId}) recorded a non-PASS UAT verdict (${prior.verdict.toUpperCase()}); review before continuing.`;
+                }
+            }
             return {
                 action: "stop",
-                reason: `Slice ${state.activeSlice.id} requires discussion before planning (require_slice_discussion is enabled). Run /gsd discuss to discuss this slice, then /gsd auto to resume.`,
+                reason: `Slice ${state.activeSlice.id} requires discussion before planning (require_slice_discussion is enabled). Run /gsd discuss to discuss this slice, then /gsd auto to resume.${priorVerdictWarning}`,
                 level: "warning",
             };
         },
@@ -920,18 +941,15 @@ export const DISPATCH_RULES = [
             const dbSlices = getMilestoneSliceSummaries(mid);
             if (dbSlices.length === 0)
                 return null;
-            // Find slices that need research (no RESEARCH file, dependencies done)
-            const milestoneResearchFile = resolveExistingExpectedArtifact("research-milestone", mid, basePath) ??
-                resolveMilestoneFile(basePath, mid, "RESEARCH");
+            // Find slices that need research (no RESEARCH file, dependencies done).
+            // Milestone research informs slice research; it does not satisfy the
+            // per-slice RESEARCH artifact contract.
             const researchReadySlices = [];
             for (const slice of dbSlices) {
                 if (slice.done)
                     continue;
-                // Skip S01 when milestone research exists
-                if (milestoneResearchFile && slice.id === "S01")
-                    continue;
                 // Skip if already has research
-                if (resolveExistingExpectedArtifact("research-slice", `${mid}/${slice.id}`, basePath))
+                if (resolveExistingSliceResearchPath(basePath, mid, slice.id))
                     continue;
                 // Skip if dependencies aren't done (check for SUMMARY files)
                 const depsComplete = slice.depends.every((depId) => !!resolveExistingExpectedArtifact("complete-slice", `${mid}/${depId}`, basePath));
@@ -958,7 +976,7 @@ export const DISPATCH_RULES = [
         },
     },
     {
-        name: "planning (no research, not S01) → research-slice",
+        name: "planning (no research) → research-slice",
         match: async ({ state, mid, midTitle, basePath, prefs }) => {
             if (state.phase !== "planning")
                 return null;
@@ -972,16 +990,8 @@ export const DISPATCH_RULES = [
                 return missingSliceStop(mid, state.phase);
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
-            const researchFile = resolveExistingExpectedArtifact("research-slice", `${mid}/${sid}`, basePath) ??
-                resolveSliceFile(basePath, mid, sid, "RESEARCH");
-            if (researchFile)
+            if (resolveExistingSliceResearchPath(basePath, mid, sid))
                 return null; // has research, fall through
-            // Skip slice research for S01 when milestone research already exists —
-            // the milestone research already covers the same ground for the first slice.
-            const milestoneResearchFile = resolveExistingExpectedArtifact("research-milestone", mid, basePath) ??
-                resolveMilestoneFile(basePath, mid, "RESEARCH");
-            if (milestoneResearchFile && sid === "S01")
-                return null; // fall through to plan-slice
             return {
                 action: "dispatch",
                 unitType: "research-slice",
@@ -1238,15 +1248,43 @@ export const DISPATCH_RULES = [
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
             const tid = state.activeTask.id;
+            const unitId = `${mid}/${sid}`;
             const artifactBasePath = resolveArtifactBasePath(basePath, mid, session);
             // Guard: if the slice plan exists but the individual task plan files are
             // missing, the planner created S##-PLAN.md with task entries but never
             // wrote the tasks/ directory files. Dispatch plan-slice to regenerate
             // them rather than hard-stopping — fixes the infinite-loop described in
-            // issue #909.
+            // issue #909. Flat-phase layout embeds tasks in the slice plan file, so
+            // skip recovery when tasks are embedded (<tasks> block or task checkboxes in phases/ plan).
             const taskPlanPath = resolveTaskFile(artifactBasePath, mid, sid, tid, "PLAN");
+            const slicePlanPath = resolveSliceFile(artifactBasePath, mid, sid, "PLAN");
+            const phasesRoot = join(gsdProjectionRoot(artifactBasePath), "phases");
+            const slicePlanContent = slicePlanPath && existsSync(slicePlanPath)
+                ? readFileSync(slicePlanPath, "utf-8")
+                : "";
+            const isPhasesSlicePlan = slicePlanPath !== null &&
+                (slicePlanPath === phasesRoot || slicePlanPath.startsWith(`${phasesRoot}${sep}`));
+            const hasTaskCheckboxes = /^-\s+\[[ xX]\]\s+\*\*[\w.]+/m.test(slicePlanContent);
+            const tasksEmbeddedInSlicePlan = Boolean(slicePlanPath &&
+                existsSync(slicePlanPath) &&
+                (slicePlanContent.includes("<tasks>") || (isPhasesSlicePlan && hasTaskCheckboxes)));
+            // tasksEmbeddedInSlicePlan is true when tasks live inside the slice plan
+            // (flat-phase phases/ layout with task checkboxes or renderPlanFromDb <tasks> block).
             const projectionTaskPlanPath = join(gsdProjectionRoot(artifactBasePath), "milestones", mid, "slices", sid, "tasks", buildTaskFileName(tid, "PLAN"));
-            if ((!taskPlanPath || !existsSync(taskPlanPath)) && !existsSync(projectionTaskPlanPath)) {
+            if ((!taskPlanPath || !existsSync(taskPlanPath)) &&
+                !existsSync(projectionTaskPlanPath) &&
+                !tasksEmbeddedInSlicePlan) {
+                const MAX_MISSING_TASK_PLAN_RETRIES = 2;
+                const retryCount = session?.missingTaskPlanRetryCount?.get(unitId) ?? 0;
+                if (retryCount >= MAX_MISSING_TASK_PLAN_RETRIES) {
+                    session?.missingTaskPlanRetryCount?.delete(unitId);
+                    return {
+                        action: "stop",
+                        reason: `Missing task-plan recovery failed ${retryCount} times for ${unitId} - manual intervention required. Task plan ${tid} is still missing after regenerating the slice plan. Fix the task-plan files manually, then run /gsd auto to resume.`,
+                        level: "error",
+                    };
+                }
+                session?.missingTaskPlanRetryCount?.set(unitId, retryCount + 1);
                 if (isDebugEnabled()) {
                     const expectedTaskPlanPath = join(artifactBasePath, relTaskFile(artifactBasePath, mid, sid, tid, "PLAN"));
                     const originalProjectRoot = session?.originalBasePath || basePath;
@@ -1270,10 +1308,11 @@ export const DISPATCH_RULES = [
                 return {
                     action: "dispatch",
                     unitType: "plan-slice",
-                    unitId: `${mid}/${sid}`,
+                    unitId,
                     prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry, sessionProvider }),
                 };
             }
+            session?.missingTaskPlanRetryCount?.delete(unitId);
             return null;
         },
     },
@@ -1352,7 +1391,13 @@ export const DISPATCH_RULES = [
                 }
                 if (!existsSync(mDir))
                     mkdirSync(mDir, { recursive: true });
-                const validationPath = join(mDir, buildMilestoneFileName(mid, "VALIDATION"));
+                // Use relMilestoneFile for the layout-aware filename:
+                //   legacy   → milestones/M001/M001-VALIDATION.md
+                //   flat-phase → phases/01-slug/01-VALIDATION.md
+                // When the milestone dir is only in the project root (worktree has none),
+                // write to the project root so the artifact lands in the canonical location.
+                const writeBase = resolveMilestonePath(artifactBasePath, mid) != null ? artifactBasePath : projectRoot;
+                const validationPath = join(writeBase, relMilestoneFile(writeBase, mid, "VALIDATION"));
                 const skipSource = trivialVariant
                     ? "trivial-scope pipeline variant"
                     : "`skip_milestone_validation` preference";

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

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

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;