@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.5c1a3ff2

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

@@ -393,7 +393,8 @@ function resolveArtifactBasePath(
 ): string {
   if (
     session?.basePath &&
-    session.currentMilestoneId === mid &&
+    session.currentMilestoneId &&
+    milestoneIdsDispatchCompatible(session.currentMilestoneId, mid) &&
     existsSync(session.basePath)
   ) {
     return session.basePath;
@@ -422,6 +423,28 @@ function normalizeMilestoneScope(value: string | null | undefined): string | nul
   return trimmed;
 }
 
+function dispatchMilestoneIdentity(value: string | null | undefined): { baseId: string; hasSuffix: boolean } | null {
+  const normalized = normalizeMilestoneScope(value);
+  const match = normalized?.match(/^(M\d{3})(?:-[a-z0-9]{6})?$/);
+  if (!match) return null;
+  return { baseId: match[1]!, hasSuffix: normalized !== match[1] };
+}
+
+function isBareSuffixedMilestoneAlias(left: string, right: string): boolean {
+  const leftId = dispatchMilestoneIdentity(left);
+  const rightId = dispatchMilestoneIdentity(right);
+  return Boolean(
+    leftId &&
+      rightId &&
+      leftId.baseId === rightId.baseId &&
+      leftId.hasSuffix !== rightId.hasSuffix,
+  );
+}
+
+function milestoneIdsDispatchCompatible(left: string, right: string): boolean {
+  return left === right || isBareSuffixedMilestoneAlias(left, right);
+}
+
 function resolveDispatchMilestoneScope(
   ctx: DispatchContext,
 ): { id: string; source: string } | null {
@@ -439,6 +462,37 @@ function resolveDispatchMilestoneScope(
   return null;
 }
 
+function resolveEffectiveDispatchMilestoneId(
+  ctx: DispatchContext,
+  scopedMilestone: { id: string; source: string } | null,
+): string {
+  if (scopedMilestone && isBareSuffixedMilestoneAlias(ctx.mid, scopedMilestone.id)) {
+    return dispatchMilestoneIdentity(scopedMilestone.id)?.hasSuffix ? scopedMilestone.id : ctx.mid;
+  }
+
+  const activeMid = ctx.state.activeMilestone?.id;
+  if (activeMid && isBareSuffixedMilestoneAlias(ctx.mid, activeMid)) {
+    return dispatchMilestoneIdentity(activeMid)?.hasSuffix ? activeMid : ctx.mid;
+  }
+
+  return ctx.mid;
+}
+
+function withEffectiveDispatchMilestone(ctx: DispatchContext, effectiveMid: string): DispatchContext {
+  if (effectiveMid === ctx.mid) return ctx;
+  const activeMilestone = ctx.state.activeMilestone;
+  const state = activeMilestone && milestoneIdsDispatchCompatible(activeMilestone.id, effectiveMid)
+    ? {
+        ...ctx.state,
+        activeMilestone: {
+          ...activeMilestone,
+          id: effectiveMid,
+        },
+      }
+    : ctx.state;
+  return { ...ctx, mid: effectiveMid, state };
+}
+
 function hasMilestonePassedDiscuss(basePath: string, mid: string): boolean {
   if (isDbAvailable()) {
     try {
@@ -732,14 +786,21 @@ export const DISPATCH_RULES: DispatchRule[] = [
     // Fire BEFORE the execution-entry phase rules so we redispatch to
     // `discuss-milestone` instead of hitting the plan-v2 gate.
     name: "execution-entry phase (no context) → discuss-milestone",
-    match: async ({ state, mid, midTitle, basePath, prefs, structuredQuestionsAvailable }) => {
+    match: async ({ state, mid, midTitle, basePath, session, prefs, structuredQuestionsAvailable }) => {
       if (!EXECUTION_ENTRY_PHASES.has(state.phase)) return null;
       if (!MILESTONE_ID_RE.test(mid)) return null;
       if (isRegistryMilestoneComplete(state, mid)) return null;
-      if (hasMilestonePassedDiscuss(basePath, mid)) return null;
+      // Resolve discuss/context artifacts against the active session worktree,
+      // mirroring the executing rules below. For a suffixed-worktree milestone
+      // the CONTEXT and slice plans live under the worktree, not the project
+      // root; checking the raw project-root basePath misreads the milestone as
+      // "never discussed" and re-dispatches discuss-milestone after task
+      // closeout instead of continuing execution (#1317).
+      const artifactBasePath = resolveArtifactBasePath(basePath, mid, session);
+      if (hasMilestonePassedDiscuss(artifactBasePath, mid)) return null;
       // Align with the plan-v2 gate's lookup semantics: whitespace-only counts
       // as missing, and an auto worktree may fall back to GSD_PROJECT_ROOT.
-      if (hasFinalizedMilestoneContext(basePath, mid)) return null;
+      if (hasFinalizedMilestoneContext(artifactBasePath, mid)) return null;
       // H6 fix (#4973): non-deep auto-mode has no human to answer the
       // depth-verification question, so pre-marking avoids a write-gate
       // deadlock. Deep planning is still user-driven even inside auto-mode,
@@ -1095,10 +1156,13 @@ export const DISPATCH_RULES: DispatchRule[] = [
   },
   {
     name: "pre-planning (no context) → discuss-milestone",
-    match: async ({ state, mid, midTitle, basePath, prefs, structuredQuestionsAvailable }) => {
+    match: async ({ state, mid, midTitle, basePath, prefs, session, structuredQuestionsAvailable }) => {
       if (state.phase !== "pre-planning") return null;
       if (isRegistryMilestoneComplete(state, mid)) return null;
-      const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
+      const contextBasePath = resolveWorktreeProjectRoot(basePath, session?.originalBasePath);
+      const contextFile =
+        resolveMilestoneFile(basePath, mid, "CONTEXT") ??
+        (contextBasePath !== basePath ? resolveMilestoneFile(contextBasePath, mid, "CONTEXT") : null);
       const hasContext = !!(contextFile && (await loadFile(contextFile)));
       if (hasContext) return null; // fall through to next rule
       if (prefs?.planning_depth === "deep") return null;
@@ -1908,36 +1972,39 @@ function applyLanguageDirectiveToDispatch(
 export async function resolveDispatch(
   ctx: DispatchContext,
 ): Promise<DispatchAction> {
-  if (ctx.mid && isDbAvailable()) {
-    const milestone = getMilestone(ctx.mid);
+  const scopedMilestone = resolveDispatchMilestoneScope(ctx);
+  const effectiveMid = resolveEffectiveDispatchMilestoneId(ctx, scopedMilestone);
+  const dispatchCtx = withEffectiveDispatchMilestone(ctx, effectiveMid);
+
+  if (dispatchCtx.mid && isDbAvailable()) {
+    const milestone = getMilestone(dispatchCtx.mid);
     if (milestone && isClosedStatus(milestone.status)) {
       return {
         action: "stop",
         reason:
-          `Milestone ${ctx.mid} is closed (status: ${milestone.status}); auto-mode will not reopen or recover it implicitly. ` +
+          `Milestone ${dispatchCtx.mid} is closed (status: ${milestone.status}); auto-mode will not reopen or recover it implicitly. ` +
           "Use an explicit reopen command before planning or executing more work for this milestone.",
         level: "warning",
       };
     }
   }
 
-  const activeMid = ctx.state.activeMilestone?.id;
-  if (activeMid && ctx.mid !== activeMid) {
+  const activeMid = dispatchCtx.state.activeMilestone?.id;
+  if (activeMid && !milestoneIdsDispatchCompatible(dispatchCtx.mid, activeMid)) {
     return {
       action: "stop",
       reason:
-        `Dispatch milestone mismatch: context mid "${ctx.mid}" does not match active milestone "${activeMid}". ` +
+        `Dispatch milestone mismatch: context mid "${dispatchCtx.mid}" does not match active milestone "${activeMid}". ` +
         "This usually means a project-level deep setup pseudo-id leaked into milestone dispatch; rerun /gsd auto after setup state is reconciled.",
       level: "warning",
     };
   }
 
-  const scopedMilestone = resolveDispatchMilestoneScope(ctx);
-  if (scopedMilestone && ctx.mid !== scopedMilestone.id) {
+  if (scopedMilestone && !milestoneIdsDispatchCompatible(dispatchCtx.mid, scopedMilestone.id)) {
     return {
       action: "stop",
       reason:
-        `Dispatch milestone mismatch: context mid "${ctx.mid}" does not match ${scopedMilestone.source} "${scopedMilestone.id}". ` +
+        `Dispatch milestone mismatch: context mid "${dispatchCtx.mid}" does not match ${scopedMilestone.source} "${scopedMilestone.id}". ` +
         "The active worktree/session and derived project state disagree; recover, park, or discard the stranded milestone before continuing.",
       level: "warning",
     };
@@ -1946,10 +2013,10 @@ export async function resolveDispatch(
   // Delegate to registry when available
   try {
     const registry = getRegistry();
-    const action = annotateBackgroundable(await registry.evaluateDispatch(ctx));
+    const action = annotateBackgroundable(await registry.evaluateDispatch(dispatchCtx));
     if (
       action.action === "dispatch" &&
-      ctx.session?.exhaustedVerificationUnits?.has(`${action.unitType}:${action.unitId}`)
+      dispatchCtx.session?.exhaustedVerificationUnits?.has(`${action.unitType}:${action.unitId}`)
     ) {
       return {
         action: "stop",
@@ -1964,13 +2031,13 @@ export async function resolveDispatch(
   }
 
   for (const rule of DISPATCH_RULES) {
-    const result = await rule.match(ctx);
+    const result = await rule.match(dispatchCtx);
     if (result) {
       if (result.action !== "skip") result.matchedRule = rule.name;
       const action = annotateBackgroundable(result);
       if (
         action.action === "dispatch" &&
-        ctx.session?.exhaustedVerificationUnits?.has(`${action.unitType}:${action.unitId}`)
+        dispatchCtx.session?.exhaustedVerificationUnits?.has(`${action.unitType}:${action.unitId}`)
       ) {
         return {
           action: "stop",

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

@@ -1698,6 +1698,10 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
                     `Safety: task ${sTid} claimed passing verification that failed in recorded execution`,
                     "error",
                   );
+                  const gitActionResult = await runCloseoutGitAction(pctx, s.currentUnit);
+                  if (gitActionResult === "dispatched") {
+                    return "dispatched";
+                  }
                   await pauseAuto(ctx, pi);
                   return "dispatched";
                 }

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

@@ -16,6 +16,7 @@ import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import {
   resolveMilestoneFile, resolveSliceFile, resolveSlicePath,
   resolveTasksDir, resolveTaskFiles, resolveTaskFile,
+  taskIdFromTaskFileName,
   relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath,
   relTaskFile, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile,
 } from "./paths.js";
@@ -28,7 +29,8 @@ import type { GSDPreferences } from "./preferences.js";
 import { join, basename, relative, sep } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary, type MinimalModelRegistry } from "./context-budget.js";
-import { getGateResults, getPendingGates, getPendingGatesForTurn } from "./gsd-db.js";
+import type { TokenProvider } from "./token-counter.js";
+import { getBlockingReworkFindingsForTask, getGateResults, getPendingGates, getPendingGatesForTurn } from "./gsd-db.js";
 import {
   GATE_REGISTRY,
   assertGateCoverage,
@@ -91,13 +93,29 @@ function resolvePromptBudgets(): ReturnType<typeof computeBudgets> {
     const prefs = loadEffectiveGSDPreferences();
     const sessionWindow = prefs?.preferences.context_window_override;
     const windowTokens = resolveExecutorContextWindow(undefined, prefs?.preferences, sessionWindow);
-    return computeBudgets(windowTokens);
+    return computeBudgets(windowTokens, resolveExecutionProvider(prefs?.preferences));
   } catch (e) {
     logWarning("prompt", `resolvePromptBudgets failed: ${(e as Error).message}`);
     return computeBudgets(200_000);
   }
 }
 
+/**
+ * Best-effort provider for the chars/token ratio: the executor's configured
+ * model profile is the only provider source reachable here (the runtime
+ * `sessionProvider` that reaches `formatExecutorConstraints` isn't threaded to
+ * `capPreamble`/summary callers). Undefined when no explicit provider is set —
+ * `computeBudgets` then uses the 4.0 default, i.e. today's behavior.
+ */
+function resolveExecutionProvider(prefs?: { models?: { execution?: unknown } }): TokenProvider | undefined {
+  const exec = prefs?.models?.execution;
+  if (exec && typeof exec === "object" && "provider" in exec) {
+    const provider = (exec as { provider?: unknown }).provider;
+    if (typeof provider === "string" && provider) return provider as TokenProvider;
+  }
+  return undefined;
+}
+
 /**
  * Character budget for dependency/prior slice summaries injected into dispatch
  * prompts. Scales with the executor's configured context window (issue #4435).
@@ -106,6 +124,34 @@ function resolveSummaryBudgetChars(): number {
   return resolvePromptBudgets().summaryBudgetChars;
 }
 
+
+function renderBlockingReworkFindingsBlock(mid: string, sid: string, tid: string): string {
+  const findings = getBlockingReworkFindingsForTask(mid, sid, tid)
+    .filter((finding) => finding.status === "pending");
+  if (findings.length === 0) return "";
+
+  const lines = [
+    "## Blocking Rework Findings (non-optional)",
+    "",
+    "This task has structured blocking rework findings. Address every finding before calling `gsd_task_complete`. Include `reworkResolution` entries with each `findingId`, `status: \"resolved\"`, and concrete evidence. If deferring a finding, use `status: \"deferred-with-override\"` with concrete evidence and `decisionRef`.",
+    "",
+  ];
+  for (const finding of findings) {
+    lines.push(`### ${finding.finding_id} (${finding.severity})`);
+    lines.push(`- Status: ${finding.status}`);
+    lines.push(`- Finding: ${finding.description}`);
+    lines.push(`- Required fix: ${finding.required_fix}`);
+    if (finding.verification_commands.length > 0) {
+      lines.push("- Required verification:");
+      for (const command of finding.verification_commands) {
+        lines.push(`  - \`${command}\``);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+
 function formatProjectClassificationForPlanning(classification: ProjectClassification): string {
   const sampleFiles = classification.contentFiles.slice(0, 8);
   const sample = sampleFiles.length > 0 ? sampleFiles.map((file) => `\`${file}\``).join(", ") : "(none)";
@@ -208,7 +254,7 @@ function formatCloseoutReviewInstructions(validationContent: string | null, vali
   ].join("\n");
 }
 
-function capPreamble(preamble: string): string {
+export function capPreamble(preamble: string): string {
   // Cap inlined context at min(static ceiling, scaled inline budget).
   // The ceiling bounds repeated auto prompt payloads; the scaled
   // budget tightens the cap for small-window users whose true safe limit is
@@ -218,6 +264,41 @@ function capPreamble(preamble: string): string {
   return truncateAtSectionBoundary(preamble, budget).content;
 }
 
+/**
+ * Cap the execute-task inline blocks against one shared budget in priority
+ * order. Unlike `capPreamble` (single concatenated preamble), execute-task
+ * feeds these blocks into separate, non-contiguous template placeholders, so
+ * they can't be joined and re-split — the budget is spent block-by-block.
+ *
+ * The task plan is the authoritative execution contract: it is never truncated
+ * here (it consumes budget first, whole). Remaining budget flows to the slice
+ * excerpt, then templates, each truncated at section boundaries so the lowest-
+ * priority context drops whole trailing sections first. When the task plan
+ * alone meets or exceeds the budget, the trailing blocks are dropped rather
+ * than the task plan being cut.
+ */
+function capExecuteTaskInlineBlocks(
+  taskPlan: string,
+  slicePlan: string,
+  templates: string,
+  budgetChars: number,
+): { taskPlan: string; slicePlan: string; templates: string } {
+  let remaining = budgetChars - taskPlan.length;
+  if (remaining <= 0) {
+    return { taskPlan, slicePlan: "", templates: "" };
+  }
+  const cappedSlice = slicePlan.length <= remaining
+    ? slicePlan
+    : truncateAtSectionBoundary(slicePlan, remaining).content;
+  remaining -= cappedSlice.length;
+  const cappedTemplates = remaining <= 0
+    ? ""
+    : templates.length <= remaining
+      ? templates
+      : truncateAtSectionBoundary(templates, remaining).content;
+  return { taskPlan, slicePlan: cappedSlice, templates: cappedTemplates };
+}
+
 type PromptContextMode = "inline" | "excerpt" | "on-demand" | "skipped";
 
 interface PromptContextTelemetryEntry {
@@ -296,7 +377,7 @@ function prependContextModeToBlock(
   block: string,
   renderMode: ContextModeRenderMode = "standalone",
 ): string {
-  const toolSurface = composeToolSurfaceInstructions(unitType, { renderMode });
+  const toolSurface = composeToolSurfaceInstructions(unitType, { renderMode, basePath: base });
   const contextMode = renderContextModeBlockForPrompt(unitType, base, renderMode);
   const guidance = [toolSurface, contextMode].filter(Boolean).join("\n\n");
   if (!guidance) return block;
@@ -377,7 +458,7 @@ function formatExecutorConstraints(
     // so DEFAULT_CONTEXT_WINDOW stays the single source of truth.
     windowTokens = resolveExecutorContextWindow(undefined, undefined, sessionContextWindow, sessionProvider);
   }
-  const budgets = computeBudgets(windowTokens);
+  const budgets = computeBudgets(windowTokens, sessionProvider as TokenProvider | undefined);
   const { min, max } = budgets.taskCountRange;
   const execWindowK = Math.round(windowTokens / 1000);
   const perTaskBudgetK = Math.round(budgets.inlineContextBudgetChars / 1000);
@@ -1403,6 +1484,18 @@ function resolveTaskSummariesLocation(
   return { dir: slicePath, relPrefix: sRel };
 }
 
+function summaryFileBelongsToSlice(
+  fileName: string,
+  base: string,
+  mid: string,
+  sid: string,
+): boolean {
+  const tid = taskIdFromTaskFileName(fileName, "SUMMARY");
+  if (!tid) return false;
+  const resolved = resolveTaskFile(base, mid, sid, tid, "SUMMARY");
+  return resolved !== null && basename(resolved) === fileName;
+}
+
 export async function getPriorTaskSummaryPaths(
   mid: string, sid: string, currentTid: string, base: string,
 ): Promise<string[]> {
@@ -1414,7 +1507,10 @@ export async function getPriorTaskSummaryPaths(
 
   return summaryFiles
     .filter(f => {
-      const num = parseInt(f.replace(/^T/, ""), 10);
+      if (!summaryFileBelongsToSlice(f, base, mid, sid)) return false;
+      const tid = taskIdFromTaskFileName(f, "SUMMARY");
+      if (!tid) return false;
+      const num = parseInt(tid.replace(/^T/, ""), 10);
       return num < currentNum;
     })
     .map(f => `${loc.relPrefix}/${f}`);
@@ -1447,8 +1543,9 @@ export async function getDependencyTaskSummaryPaths(
 
   return summaryFiles
     .filter((f) => {
-      // Extract task ID from filename: "T02-SUMMARY.md" → "T02"
-      const tid = f.replace(/-SUMMARY\.md$/i, "").toUpperCase();
+      if (!summaryFileBelongsToSlice(f, base, mid, sid)) return false;
+      const tid = taskIdFromTaskFileName(f, "SUMMARY");
+      if (!tid) return false;
       return depSet.has(tid);
     })
     .map((f) => `${loc.relPrefix}/${f}`);
@@ -2697,7 +2794,7 @@ export async function buildExecuteTaskPrompt(
   // Compute verification budget for the executor's context window (issue #707)
   const prefs = loadEffectiveGSDPreferences();
   const contextWindow = resolveExecutorContextWindow(opts.modelRegistry, prefs?.preferences, opts.sessionContextWindow, opts.sessionProvider);
-  const budgets = computeBudgets(contextWindow);
+  const budgets = computeBudgets(contextWindow, opts.sessionProvider as TokenProvider | undefined);
   const verificationBudget = `~${Math.round(budgets.verificationBudgetChars / 1000)}K chars`;
 
   // Truncate carry-forward section when it exceeds 40% of inline context budget.
@@ -2745,6 +2842,15 @@ export async function buildExecuteTaskPrompt(
     logWarning("prompt", `reopen reason injection failed: ${(reopenErr as Error).message}`);
   }
 
+  const reworkFindingsBlock = renderBlockingReworkFindingsBlock(mid, sid, tid);
+  if (reworkFindingsBlock) {
+    const block = reworkFindingsBlock + "\n\n---\n\n";
+    phaseAnchorSection = phaseAnchorSection
+      ? `${block}${phaseAnchorSection}`
+      : block;
+    trackPromptContext(contextTelemetry, "rework-findings", "inline", reworkFindingsBlock);
+  }
+
   // ADR-011 Phase 2: inject any resolved-but-unapplied escalation override
   // into this task's prompt. Claim is atomic via DB UPDATE WHERE IS NULL, so
   // if a parallel build already injected it, we skip. Feature-gated by
@@ -2805,10 +2911,26 @@ export async function buildExecuteTaskPrompt(
       }
     },
   });
-  const taskPlanInline = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "task-plan");
-  const slicePlanExcerpt = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "slice-plan");
+  const rawTaskPlanInline = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "task-plan");
+  const rawSlicePlanExcerpt = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "slice-plan");
   const contractedCarryForward = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "prior-task-summaries");
-  const contractedTemplates = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "templates");
+  const rawContractedTemplates = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "templates");
+  // Cap the static inline blocks against one shared budget so a small-window
+  // executor can't overflow (the sibling builders cap via `capPreamble`;
+  // execute-task's blocks feed separate template slots, so they share a budget
+  // block-by-block). Carry-forward already has its own truncation above.
+  const inlineBudget = Math.min(MAX_PREAMBLE_CHARS, budgets.inlineContextBudgetChars);
+  const { taskPlan: taskPlanInline, slicePlan: slicePlanExcerpt, templates: contractedTemplates } =
+    capExecuteTaskInlineBlocks(rawTaskPlanInline, rawSlicePlanExcerpt, rawContractedTemplates, inlineBudget);
+  const inlineDropped = (rawTaskPlanInline.length + rawSlicePlanExcerpt.length + rawContractedTemplates.length)
+    - (taskPlanInline.length + slicePlanExcerpt.length + contractedTemplates.length);
+  trackPromptContext(
+    contextTelemetry,
+    "inline-cap",
+    inlineDropped > 0 ? "excerpt" : "skipped",
+    null,
+    inlineDropped > 0 ? `dropped ${inlineDropped} chars (budget ${inlineBudget})` : "within budget",
+  );
   const onDemandResult = renderExecuteTaskOnDemandContext(base, mid, sid, contractedContext.onDemand);
   const onDemandContext = onDemandResult.text;
   trackPromptContext(
@@ -2904,12 +3026,14 @@ export async function buildCompleteSlicePrompt(
           trackPromptContext(contextTelemetry, "prior-task-summaries", "skipped", null, "missing tasks dir");
           return null;
         }
-        const summaryFiles = resolveTaskFiles(loc.dir, "SUMMARY").sort();
+        const summaryFiles = resolveTaskFiles(loc.dir, "SUMMARY")
+          .filter((file) => summaryFileBelongsToSlice(file, base, mid, sid))
+          .sort();
         const blocks: string[] = [];
         for (const file of summaryFiles) {
           const absPath = join(loc.dir, file);
           const relPath = `${loc.relPrefix}/${file}`;
-          const taskId = file.replace(/-SUMMARY\.md$/i, "");
+          const taskId = taskIdFromTaskFileName(file, "SUMMARY") ?? file.replace(/-SUMMARY\.md$/i, "");
           blocks.push(await buildTaskSummaryExcerpt(absPath, relPath, taskId));
         }
         const body = blocks.length > 0 ? blocks.join("\n\n---\n\n") : null;
@@ -3522,7 +3646,9 @@ export async function buildReplanSlicePrompt(
   let blockerTaskId = "";
   const summaryLoc = resolveTaskSummariesLocation(base, mid, sid);
   if (summaryLoc) {
-    const summaryFiles = resolveTaskFiles(summaryLoc.dir, "SUMMARY").sort();
+    const summaryFiles = resolveTaskFiles(summaryLoc.dir, "SUMMARY")
+      .filter((file) => summaryFileBelongsToSlice(file, base, mid, sid))
+      .sort();
     for (const file of summaryFiles) {
       const absPath = join(summaryLoc.dir, file);
       const content = await loadFile(absPath);
@@ -3530,7 +3656,7 @@ export async function buildReplanSlicePrompt(
       const summary = parseSummary(content);
       const relPath = `${summaryLoc.relPrefix}/${file}`;
       if (summary.frontmatter.blocker_discovered) {
-        blockerTaskId = summary.frontmatter.id || file.replace(/-SUMMARY\.md$/i, "");
+        blockerTaskId = summary.frontmatter.id || taskIdFromTaskFileName(file, "SUMMARY") || file.replace(/-SUMMARY\.md$/i, "");
         inlined.push(await buildTaskSummaryExcerpt(absPath, relPath, blockerTaskId, { blocker: true }));
       }
     }

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

@@ -39,8 +39,7 @@ import { isClosedStatus, isInactiveStatus } from "./status-guards.js";
 import {
   resolveSlicePath,
   resolveSliceFile,
-  resolveTasksDir,
-  resolveTaskFiles,
+  resolveTaskFile,
   relMilestoneFile,
   relSliceFile,
   buildSliceFileName,
@@ -324,13 +323,16 @@ export function writeReactiveExecuteBlocker(
   const slicePath = resolveSlicePath(base, mid, sid);
   if (!slicePath) return null;
 
-  const tasksDir = resolveTasksDir(base, mid, sid) ?? slicePath;
-  const existingSummaries = new Set(
-    resolveTaskFiles(tasksDir, "SUMMARY").map((f) => f.replace(/-SUMMARY\.md$/i, "").toUpperCase()),
-  );
+  // Resolve each batch task's SUMMARY with slice-qualified paths so flat-phase
+  // slices that reuse a task id (e.g. two T03s in one phase) don't collide: a
+  // sibling slice's summary must never make this slice's task look complete.
+  const hasSummary = (tid: string): boolean => {
+    const summaryPath = resolveTaskFile(base, mid, sid, tid, "SUMMARY");
+    return summaryPath !== null && existsSync(summaryPath);
+  };
 
-  const summaryPresent = batchIds.filter((tid) => existingSummaries.has(tid.toUpperCase()));
-  const summaryMissing = batchIds.filter((tid) => !existingSummaries.has(tid.toUpperCase()));
+  const summaryPresent = batchIds.filter((tid) => hasSummary(tid));
+  const summaryMissing = batchIds.filter((tid) => !hasSummary(tid));
   const completedTaskIds: string[] = [];
   const skippedTaskIds: string[] = [];
   const unchangedTaskIds: string[] = [];

package/src/resources/extensions/gsd/auto-worktree-cleanup.ts

@@ -10,6 +10,7 @@ import { existsSync, realpathSync, unlinkSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
 
 import { gsdRoot } from "./paths.js";
+import { milestoneMetaPath } from "./git-service.js";
 import { logWarning } from "./workflow-logger.js";
 
 function isSamePath(a: string, b: string): boolean {
@@ -93,6 +94,9 @@ export function clearProjectRootStateFiles(
   // worth removing on teardown.
   const transientFiles = [
     join(gsdDir, "STATE.md"),
+    // Integration-branch META now lives flat at .gsd/<MID>-META.json (ADR-045).
+    milestoneMetaPath(basePath, milestoneId),
+    // Legacy location — still cleaned for pre-migration trees.
     join(gsdDir, "milestones", milestoneId, `${milestoneId}-META.json`),
   ];
 

package/src/resources/extensions/gsd/auto-worktree-teardown.ts

@@ -65,7 +65,7 @@ export function teardownAutoWorktree(
 
     // Mirror cleanup steps from mergeMilestoneToMain abort path:
 
-    // 1. Remove transient state files (STATE.md, auto.lock, {MID}-META.json).
+    // 1. Remove transient state files (STATE.md, auto.lock, .gsd/{MID}-META.json).
     //    Non-fatal — must not block teardown.
     try {
       clearProjectRootStateFiles(originalBasePath, milestoneId);

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

@@ -19,7 +19,7 @@ import type {
   SessionMessageEntry,
 } from "@gsd/pi-coding-agent";
 
-import { deriveState } from "./state.js";
+import { deriveState, invalidateStateCache } from "./state.js";
 import {
   buildRequirementsBacklogSummaryLines,
   countUnmappedActiveRequirements,
@@ -443,6 +443,9 @@ function captureMilestoneLockEnv(milestoneId: string | null): void {
   } else {
     delete process.env.GSD_MILESTONE_LOCK;
   }
+  // The derive cache is keyed on basePath only; GSD_MILESTONE_LOCK changes
+  // what deriveState computes, so a lock flip must not serve a cached result.
+  invalidateStateCache();
 }
 
 function restoreMilestoneLockEnv(): void {
@@ -457,6 +460,7 @@ function restoreMilestoneLockEnv(): void {
   s.previousMilestoneLockEnv = null;
   s.hadMilestoneLockEnv = false;
   s.milestoneLockEnvCaptured = false;
+  invalidateStateCache();
 }
 
 /**