@opengsd/gsd-pi 1.9.0 → 1.10.0-dev.a5e42e99

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

@@ -56,6 +56,26 @@ const ZERO_TOOL_PROVIDER_ERROR_PREFIX_RE =
   /^(?:api error(?::|$|\s*\()|provider error(?::|$|\s*\()|request failed\b|(?:http\s*)?(?:429|500|502|503)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|socket hang up\b|fetch failed\b|(?:network|connection|server) error(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|dns\b.*(?:fail|error|timeout)|unexpected eof\b|stream idle timeout\b|partial response received\b|stream_exhausted\b|terminated(?::|$)|(?:connection|stream|request)\b.{0,40}\bterminated\b|other side closed\b|rate.?limit(?:ed| exceeded| reached| error)|too many requests\b|you(?:'ve| have) (?:hit|reached) your (?:\w+ )?limit\b|.*\b(?:usage|session|weekly|daily|monthly|quota) limit\b|limit\b.{0,40}\bresets?\b|out of extra usage\b|service.?unavailable\b|internal(?: server)? error(?::|$)|internal(?:[_-]server)?[_-]error\b|server[_-]error\b|(?:provider|server|api|model|codex|claude|openai|anthropic|gemini)\b.{0,80}\boverloaded\b|overloaded\b.{0,80}\b(?:provider|server|api|model)\b|context (?:window|length) exceed|context window exceed)/i;
 const ZERO_TOOL_PROVIDER_ERROR_SIGNAL_RE =
   /(?:\b(?:http|status(?: code)?|code|error:)\s*(?:429|500|502|503)\b|\b(?:api|provider) error\s*[:(]?\s*(?:429|500|502|503)\b|\b(?:typeerror|error):\s*(?:fetch failed\b|socket hang up\b|terminated(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|(?:network|connection|server) error(?::|$)|stream idle timeout\b|partial response received\b|unexpected eof\b)|\b(?:server_error|api_error|stream_exhausted(?:_without_result)?)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|context (?:window|length) exceed|context window exceed)/i;
+const ZERO_TOOL_PSEUDO_TOOL_CALL_RE =
+  /<arg_key>[\s\S]*?<\/arg_key>\s*<arg_value>[\s\S]*?<\/arg_value>[\s\S]*?<\/tool_call>/i;
+const ZERO_TOOL_PSEUDO_TOOL_CALL_SNIPPET_CHARS = 200;
+
+function zeroToolMessageSnippet(message: string): string {
+  const compact = message.trim().replace(/\s+/g, " ");
+  if (compact.length <= ZERO_TOOL_PSEUDO_TOOL_CALL_SNIPPET_CHARS) return compact;
+  return `${compact.slice(0, ZERO_TOOL_PSEUDO_TOOL_CALL_SNIPPET_CHARS - 3)}...`;
+}
+
+// Provider serialization drift: the model emitted a tool call as plain assistant
+// text (`toolName<arg_key>…</arg_key><arg_value>…</arg_value></tool_call>`)
+// instead of a structured tool call. Returns an operator-visible snippet when
+// detected. Kept separate from error classification so a drift snippet is never
+// conflated with an ErrorClass (which would force a fragile union whose
+// narrowing the root and extensions tsconfigs disagree on).
+function zeroToolPseudoToolCallSnippet(message: string): string | null {
+  if (!ZERO_TOOL_PSEUDO_TOOL_CALL_RE.test(message)) return null;
+  return zeroToolMessageSnippet(message);
+}
 
 function classifyZeroToolProviderMessage(message: string): ReturnType<typeof classifyError> | null {
   const firstLine = message.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
@@ -68,6 +88,7 @@ function classifyZeroToolProviderMessage(message: string): ReturnType<typeof cla
 }
 
 export const _classifyZeroToolProviderMessageForTest = classifyZeroToolProviderMessage;
+export const _zeroToolPseudoToolCallSnippetForTest = zeroToolPseudoToolCallSnippet;
 
 export function resolveDispatchRecoveryAttempts(
   unitRecoveryCount: Map<string, number>,
@@ -767,15 +788,30 @@ export async function runUnitPhase(
       );
       if (lastUnit && lastUnit.toolCalls === 0) {
         const lastAssistantMessage = lastAssistantText(s.lastUnitAgentEndMessages);
-        const providerMessageClass = classifyZeroToolProviderMessage(lastAssistantMessage);
-        if (providerMessageClass && isTransient(providerMessageClass)) {
-          const retryAfterMs = "retryAfterMs" in providerMessageClass ? providerMessageClass.retryAfterMs : 15_000;
+        const pseudoToolCallSnippet = zeroToolPseudoToolCallSnippet(lastAssistantMessage);
+        if (pseudoToolCallSnippet) {
+          debugLog("runUnitPhase", {
+            phase: "zero-tool-serialization-drift",
+            unitType,
+            unitId,
+            snippet: pseudoToolCallSnippet,
+          });
+          ctx.ui.notify(
+            `${unitType} ${unitId} completed with 0 tool calls - provider serialization drift: model emitted pseudo-tool-call text. Snippet: ${pseudoToolCallSnippet}`,
+            "error",
+          );
+          await deps.pauseAuto(ctx, pi);
+          return { action: "break", reason: "zero-tool-serialization-drift" };
+        }
+        const providerErrorClass = classifyZeroToolProviderMessage(lastAssistantMessage);
+        if (providerErrorClass && isTransient(providerErrorClass)) {
+          const retryAfterMs = "retryAfterMs" in providerErrorClass ? providerErrorClass.retryAfterMs : 15_000;
           await pauseAutoForProviderError(
             ctx.ui,
             ` for ${unitType} ${unitId}`,
             () => deps.pauseAuto(ctx, pi),
             {
-              isRateLimit: providerMessageClass.kind === "rate-limit",
+              isRateLimit: providerErrorClass.kind === "rate-limit",
               isTransient: true,
               retryAfterMs,
               resume: () => {
@@ -793,7 +829,7 @@ export async function runUnitPhase(
           });
           return {
             action: "break",
-            reason: providerMessageClass.kind === "rate-limit" ? "rate-limit" : "api-timeout",
+            reason: providerErrorClass.kind === "rate-limit" ? "rate-limit" : "api-timeout",
           };
         }
         if (USER_DRIVEN_DEEP_UNITS.has(unitType) && isAwaitingUserInput(s.lastUnitAgentEndMessages ?? undefined)) {

package/src/resources/extensions/gsd/auto-artifact-paths.ts

@@ -15,6 +15,7 @@ import {
   resolveSliceFile,
   relMilestoneFile,
   relSliceFile,
+  buildFlatTaskFileName,
   buildTaskFileName,
   resolveSlicePath,
   resolveTasksDir,
@@ -103,12 +104,15 @@ function resolveProjectMilestonePath(base: string, mid: string): string | null {
   const milestonesDir = join(gsdRoot(base), "milestones");
   const dir = resolveDir(milestonesDir, mid);
   if (!dir) return null;
-  // git-service.ts creates milestones/<MID>/ for integration-branch metadata
-  // (<MID>-META.json) even in flat-phase projects. A dir that holds ONLY
-  // *-META.json files must not be treated as a real legacy milestone dir —
-  // otherwise this early-return resolves CONTEXT/ROADMAP/SUMMARY to the legacy
-  // path (milestones/<MID>/<MID>-<SUFFIX>.md) before the flat-phase fallback
-  // can run, trapping the unit in a finalize-retry loop (#852 follow-up).
+  // Historically git-service.ts wrote integration-branch metadata into
+  // milestones/<MID>/<MID>-META.json, which could create that dir in flat-phase
+  // projects and poison layout detection. As of ADR-045 that META lives flat at
+  // .gsd/<MID>-META.json and no longer poisons detection. A dir that holds ONLY
+  // *-META.json files (a pre-migration on-disk tree) must still not be treated
+  // as a real legacy milestone dir — otherwise this early-return resolves
+  // CONTEXT/ROADMAP/SUMMARY to the legacy path (milestones/<MID>/<MID>-<SUFFIX>.md)
+  // before the flat-phase fallback can run, trapping the unit in a
+  // finalize-retry loop (#852 follow-up).
   //
   // We use dirIsMetaOnlyLegacyMilestone rather than !dirIsContentBearingLegacyMilestone
   // so that an EMPTY dir (a new milestone before any content is written) is NOT
@@ -232,7 +236,10 @@ export function resolveExpectedArtifactPath(
       const summaryDir = isLegacySlice
         ? (resolveTasksDir(base, mid, sid!) ?? slicePath)
         : slicePath;
-      return join(summaryDir, buildTaskFileName(tid, "SUMMARY"));
+      const fileName = isLegacySlice
+        ? buildTaskFileName(tid, "SUMMARY")
+        : buildFlatTaskFileName(sid!, tid, "SUMMARY");
+      return join(summaryDir, fileName);
     }
     case "complete-slice": {
       return resolveSliceArtifactPath(base, mid, sid!, "SUMMARY");

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

@@ -1956,6 +1956,7 @@ function applyLanguageDirectiveToDispatch(
   if (action.action !== "dispatch" || !action.prompt) return action;
   const directive = renderLanguageDirectiveForPrompt(prefs);
   if (!directive) return action;
+  if (action.prompt.startsWith(directive)) return action;
   return { ...action, prompt: `${directive}\n\n${action.prompt}` };
 }
 

package/src/resources/extensions/gsd/auto-model-selection.ts

@@ -390,6 +390,7 @@ const THINKING_LEVEL_ORDER: readonly EffectiveThinkingLevel[] = [
   "medium",
   "high",
   "xhigh",
+  "max",
 ] as EffectiveThinkingLevel[];
 
 /**

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

@@ -16,10 +16,11 @@ 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";
-import { resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
+import { resolveInlineLevel, loadEffectiveGSDPreferences, renderLanguageDirectiveForPrompt } from "./preferences.js";
 import { createRepositoryRegistryFromPreferences } from "./repository-registry.js";
 import { isContextModeEnabled } from "./preferences-types.js";
 import { parseRoadmap } from "./parsers-legacy.js";
@@ -28,6 +29,7 @@ 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 type { TokenProvider } from "./token-counter.js";
 import { getBlockingReworkFindingsForTask, getGateResults, getPendingGates, getPendingGatesForTurn } from "./gsd-db.js";
 import {
   GATE_REGISTRY,
@@ -76,6 +78,14 @@ export { buildSkillActivationBlock, buildSkillDiscoveryVars };
  */
 const MAX_PREAMBLE_CHARS = 20_000;
 
+function prependLanguageDirectiveForBase(base: string, prompt: string): string {
+  const directive = renderLanguageDirectiveForPrompt(
+    loadEffectiveGSDPreferences(base)?.preferences,
+  );
+  if (!directive || prompt.startsWith(directive)) return prompt;
+  return `${directive}\n\n${prompt}`;
+}
+
 /**
  * Resolve prompt budgets from the configured executor context window.
  *
@@ -91,13 +101,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).
@@ -236,7 +262,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
@@ -246,6 +272,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 {
@@ -324,7 +385,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;
@@ -405,7 +466,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);
@@ -1431,6 +1492,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[]> {
@@ -1442,7 +1515,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}`);
@@ -1475,8 +1551,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}`);
@@ -1661,7 +1738,7 @@ export async function buildDiscussMilestonePrompt(
   if (headless) {
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
     const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-    return loadPrompt("discuss-headless", {
+    const prompt = loadPrompt("discuss-headless", {
       seedContext: roadmapContent ?? "",
       inlinedTemplates: contextTemplate,
       workingDirectory: base,
@@ -1670,6 +1747,7 @@ export async function buildDiscussMilestonePrompt(
       commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
       multiMilestoneCommitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
     });
+    return prependLanguageDirectiveForBase(base, prompt);
   }
 
   const rawInlinedContext = await buildDiscussMilestoneInlinedContext(mid, base);
@@ -1700,10 +1778,11 @@ export async function buildDiscussMilestonePrompt(
     const truncationNote = cappedDraftSeed !== draftSeed
       ? `\n\n_(Draft seed truncated; read the full draft at \`${draftRelPath}\` if needed.)_`
       : "";
-    return `${promptWithContextMode}\n\n## Prior Discussion (Draft Seed)\n\nThe following draft was captured from a prior multi-milestone discussion. Use it as seed material — the user has already provided this context. Start with a brief reflection on what the draft covers, then probe for any gaps or open questions before writing the full CONTEXT.md.\n\n${cappedDraftSeed}${truncationNote}`;
+    const promptWithDraftSeed = `${promptWithContextMode}\n\n## Prior Discussion (Draft Seed)\n\nThe following draft was captured from a prior multi-milestone discussion. Use it as seed material — the user has already provided this context. Start with a brief reflection on what the draft covers, then probe for any gaps or open questions before writing the full CONTEXT.md.\n\n${cappedDraftSeed}${truncationNote}`;
+    return prependLanguageDirectiveForBase(base, promptWithDraftSeed);
   }
 
-  return promptWithContextMode;
+  return prependLanguageDirectiveForBase(base, promptWithContextMode);
 }
 
 /**
@@ -2725,7 +2804,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.
@@ -2842,10 +2921,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(
@@ -2941,12 +3036,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;
@@ -3559,7 +3656,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);
@@ -3567,7 +3666,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-runtime-state.ts

@@ -3,11 +3,10 @@ import { AutoSession } from "./auto/session.js";
 import type { CurrentUnit } from "./auto/session.js";
 import type { SourceObservationStore } from "./source-observations.js";
 import {
-  isDeterministicPolicyError,
-  isQueuedUserMessageSkip,
-  isToolInvocationError,
   markToolEnd as markTrackedToolEnd,
   markToolStart as markTrackedToolStart,
+  shouldClearToolInvocationErrorAfterSuccess,
+  updateToolInvocationError,
 } from "./auto-tool-tracking.js";
 // Re-exported as a pure pass-through. Must stay UNGATED (no autoSession.active
 // argument, unlike markToolStart at the bottom of this file) so it is true in
@@ -99,13 +98,19 @@ export function markToolEnd(toolCallId: string): void {
 
 export function recordToolInvocationError(toolName: string, errorMsg: string): void {
   if (!autoSession.active) return;
-  if (isToolInvocationError(errorMsg) || isQueuedUserMessageSkip(errorMsg) || isDeterministicPolicyError(errorMsg)) {
-    autoSession.lastToolInvocationError = `${toolName}: ${errorMsg}`;
-  }
+  autoSession.lastToolInvocationError = updateToolInvocationError(
+    autoSession.lastToolInvocationError,
+    toolName,
+    errorMsg,
+  );
 }
 
-export function clearToolInvocationError(): void {
+export function clearToolInvocationError(successfulToolName?: string): void {
   if (!autoSession.active) return;
+  if (!shouldClearToolInvocationErrorAfterSuccess(
+    autoSession.lastToolInvocationError,
+    successfulToolName,
+  )) return;
   autoSession.lastToolInvocationError = null;
 }
 

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

@@ -88,6 +88,7 @@ import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.
 import { extractVerdict } from "./verdict-parser.js";
 import { auditOrphanedPreflightStashes } from "./orphan-stash-audit.js";
 import { parseProject } from "./schemas/parsers.js";
+import { LAYOUT_SEGMENTS } from "./layout-policy.js";
 
 import {
   debugLog,
@@ -152,6 +153,33 @@ export function hasGitIndexLockForTest(basePath: string): boolean {
   return existsSync(join(basePath, ".git", "index.lock"));
 }
 
+function isEmptyDirectory(dirPath: string): boolean {
+  try {
+    return existsSync(dirPath) && readdirSync(dirPath).length === 0;
+  } catch {
+    return false;
+  }
+}
+
+export function reconcileFlatPhaseBootstrapLayout(basePath: string): boolean {
+  const gsdDir = join(basePath, ".gsd");
+  const phasesPath = join(gsdDir, LAYOUT_SEGMENTS.level1);
+  const milestonesPath = join(gsdDir, "milestones");
+
+  if (isEmptyDirectory(milestonesPath)) {
+    if (!existsSync(phasesPath)) mkdirSync(phasesPath, { recursive: true });
+    rmSync(milestonesPath, { recursive: true, force: true });
+    return true;
+  }
+
+  if (!existsSync(phasesPath) && !existsSync(milestonesPath)) {
+    mkdirSync(phasesPath, { recursive: true });
+    return true;
+  }
+
+  return false;
+}
+
 export function _shouldAbortBootstrapForUnavailableDbForTest(
   gsdDbPath: string,
   dbAvailable: boolean,
@@ -1057,7 +1085,7 @@ export async function bootstrapAutoSession(
   // provider the user is not logged into and surface as "Not logged in · Please
   // run /login" before pausing and resetting to claude-code/claude-sonnet-4-6.
   const manualSessionOverride = getSessionModelOverride(ctx.sessionManager.getSessionId());
-  const sessionProviderIsCustom = isCustomProvider(ctx.model?.provider);
+  const sessionProviderIsCustom = isCustomProvider(ctx.model?.provider, ctx.modelRegistry);
   const profileModelIds = modelIdsForProfileResolution(
     ctx.modelRegistry,
     resolveProfileAnchorProvider(ctx.model?.provider),
@@ -1152,19 +1180,14 @@ export async function bootstrapAutoSession(
     ensureGitignore(base, { manageGitignore });
     if (manageGitignore !== false) untrackRuntimeFiles(base);
 
-    // Bootstrap milestones/ if it doesn't exist.
-    // Check milestones/ directly — ensureGsdSymlink above already created .gsd/,
-    // so checking .gsd/ existence would be dead code (#2942).
-    const gsdDir = join(base, ".gsd");
-    const milestonesPath = join(gsdDir, "milestones");
-    if (!existsSync(milestonesPath)) {
-      mkdirSync(milestonesPath, { recursive: true });
+    // Bootstrap the flat-phase projection root and clean empty legacy scaffolds.
+    if (reconcileFlatPhaseBootstrapLayout(base)) {
       try {
         nativeAddAll(base);
         nativeCommit(base, "chore: init gsd");
       } catch (err) {
         /* nothing to commit */
-        logWarning("engine", `mkdir failed: ${err instanceof Error ? err.message : String(err)}`);
+        logWarning("engine", `layout bootstrap commit failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
 

package/src/resources/extensions/gsd/auto-tool-tracking.ts

@@ -132,6 +132,8 @@ export function clearInFlightTools(): void {
  */
 const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Input validation error|Invalid arguments for tool|MCP error -32602|No such tool available|Expected ',' or '\}'(?: after property value)?(?: in JSON)?|Unexpected end of JSON|Unexpected token.*in JSON|does not provide an export named|Named export .* not found|Cannot find module|ERR_MODULE_NOT_FOUND|ERR_MODULE_NOT_EXPORTED|ERR_PACKAGE_PATH_NOT_EXPORTED/i;
 const DETERMINISTIC_POLICY_ERROR_RE = /(?:^|\b)(?:HARD BLOCK:|Blocked: \/gsd queue is a planning tool|Direct writes to \.gsd\/STATE\.md and \.gsd\/gsd\.db are blocked|This is a mechanical gate)/i;
+const SCHEDULE_WAKEUP_TOOL_NAME = "ScheduleWakeup";
+const SCHEDULE_WAKEUP_CONTINUATION_ERROR = "`prompt` is required when `stop` is not true";
 
 /**
  * Matches the runtime's "tool not registered" error. Unlike the deterministic
@@ -151,6 +153,60 @@ export function isToolInvocationError(errorMsg: string): boolean {
   return TOOL_INVOCATION_ERROR_RE.test(errorMsg) || isDeterministicPolicyError(errorMsg);
 }
 
+/**
+ * Claude Code validates its native ScheduleWakeup tool outside GSD's schema.
+ * Keep this exact and tool-scoped so similarly worded business validation from
+ * unrelated tools does not pause auto-mode.
+ */
+export function isScheduleWakeupContinuationError(toolName: string, errorMsg: string): boolean {
+  return stripMcpToolPrefix(toolName) === SCHEDULE_WAKEUP_TOOL_NAME
+    && errorMsg.trim() === SCHEDULE_WAKEUP_CONTINUATION_ERROR;
+}
+
+function shouldRecordToolInvocationError(toolName: string, errorMsg: string): boolean {
+  return isScheduleWakeupContinuationError(toolName, errorMsg)
+    || isToolInvocationError(errorMsg)
+    || isQueuedUserMessageSkip(errorMsg);
+}
+
+function isRecordedScheduleWakeupContinuationError(recordedError: string | null): boolean {
+  if (!recordedError) return false;
+
+  const separator = recordedError.indexOf(": ");
+  return separator >= 0 && isScheduleWakeupContinuationError(
+    recordedError.slice(0, separator),
+    recordedError.slice(separator + 2),
+  );
+}
+
+export function updateToolInvocationError(
+  recordedError: string | null,
+  toolName: string,
+  errorMsg: string,
+): string | null {
+  if (!shouldRecordToolInvocationError(toolName, errorMsg)) return recordedError;
+  if (
+    isRecordedScheduleWakeupContinuationError(recordedError)
+    && !isScheduleWakeupContinuationError(toolName, errorMsg)
+  ) return recordedError;
+
+  return `${toolName}: ${errorMsg}`;
+}
+
+/**
+ * A failed continuation must survive successful diagnostic/read calls in the
+ * same turn. Only a later successful ScheduleWakeup proves the continuation
+ * was armed; all other invocation errors retain their existing clear-on-success
+ * behavior.
+ */
+export function shouldClearToolInvocationErrorAfterSuccess(
+  recordedError: string | null,
+  successfulToolName?: string,
+): boolean {
+  return !isRecordedScheduleWakeupContinuationError(recordedError)
+    || stripMcpToolPrefix(successfulToolName ?? "") === SCHEDULE_WAKEUP_TOOL_NAME;
+}
+
 /**
  * Returns true if the error message indicates the called tool was not on the
  * session's tool surface (MCP startup race — see TOOL_UNAVAILABLE_ERROR_RE).