@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.5fc22c6f

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

@@ -30,6 +30,7 @@ import {
   setSliceSketchFlag,
   transaction,
   getAssessment,
+  getSliceRunUatAssessment,
 } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
@@ -44,15 +45,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,
@@ -113,7 +114,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,
@@ -322,6 +323,19 @@ export async function readUatGateVerdict(
     }
   }
 
+  // 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;
 }
 
@@ -522,9 +536,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");
@@ -825,7 +838,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
     },
   },
   {
-    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) return null;
@@ -839,9 +852,9 @@ export const DISPATCH_RULES: DispatchRule[] = [
         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;
         }
       }
@@ -1117,9 +1130,21 @@ export const DISPATCH_RULES: DispatchRule[] = [
       // call site.
       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" as const,
-        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" as const,
       };
     },
@@ -1143,18 +1168,15 @@ export const DISPATCH_RULES: DispatchRule[] = [
       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: Array<{ id: string; title: string }> = [];
 
       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)) continue;
+        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),
@@ -1191,7 +1213,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
     },
   },
   {
-    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;
       // Phase skip: skip research when preference or profile says so
@@ -1202,20 +1224,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
       if (!state.activeSlice) 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) 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
+      if (resolveExistingSliceResearchPath(basePath, mid, sid)) return null; // has research, fall through
       return {
         action: "dispatch",
         unitType: "research-slice",
@@ -1526,14 +1535,32 @@ export const DISPATCH_RULES: DispatchRule[] = [
       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",
@@ -1543,7 +1570,22 @@ export const DISPATCH_RULES: DispatchRule[] = [
         "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;
@@ -1567,7 +1609,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
         return {
           action: "dispatch",
           unitType: "plan-slice",
-          unitId: `${mid}/${sid}`,
+          unitId,
           prompt: await buildPlanSlicePrompt(
             mid,
             midTitle,
@@ -1580,6 +1622,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
         };
       }
 
+      session?.missingTaskPlanRetryCount?.delete(unitId);
       return null;
     },
   },
@@ -1675,10 +1718,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

@@ -407,8 +407,15 @@ export function resolvePreferredModelConfig(
   isAutoMode = true,
   basePath?: string,
   availableModelIds?: string[],
+  preferredModelId?: string,
 ): PreferredModelConfig | undefined {
-  const explicitConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds);
+  const explicitConfig = resolveModelWithFallbacksForUnit(
+    unitType,
+    basePath,
+    availableModelIds,
+    preferredModelId,
+    true,
+  );
   if (explicitConfig) {
     return {
       ...explicitConfig,
@@ -421,26 +428,55 @@ export function resolvePreferredModelConfig(
   if (!isAutoMode) return undefined;
 
   const routingConfig = resolveDynamicRoutingConfig();
-  if (!routingConfig.enabled || !routingConfig.tier_models) return undefined;
+  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).
+  // 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 &&
+    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) return undefined;
+  // 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",
   };
 }
@@ -527,6 +563,9 @@ 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(
@@ -535,6 +574,7 @@ export async function selectAndApplyModel(
       isAutoMode,
       basePath,
       profileResolutionIds,
+      preferredModelId,
     );
   let routing: { tier: string; modelDowngraded: boolean } | null = null;
   let appliedModel: Model<Api> | null = null;
@@ -642,15 +682,11 @@ export async function selectAndApplyModel(
       }
     }
 
-    // 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);
@@ -737,6 +773,7 @@ export async function selectAndApplyModel(
             classification.tier,
             availableModelIds,
             routingConfig,
+            preferredModelId,
           );
           const hookResult = await pi.emitBeforeModelSelect({
             unitType,
@@ -781,6 +818,7 @@ export async function selectAndApplyModel(
             unitType,
             classification.taskMetadata,
             capabilityOverrides,
+            preferredModelId,
           );
         }
 

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}.`,
@@ -2195,7 +2212,7 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
           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 });
@@ -2351,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);
             }
           }
 
@@ -2515,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;