@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.97ef11e3

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,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,
@@ -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).
@@ -106,6 +132,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 +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
@@ -218,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 {
@@ -296,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;
@@ -377,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);
@@ -1403,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[]> {
@@ -1414,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}`);
@@ -1447,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}`);
@@ -1633,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,
@@ -1642,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);
@@ -1672,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);
 }
 
 /**
@@ -2697,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.
@@ -2745,6 +2852,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 +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(
@@ -2904,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;
@@ -3522,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);
@@ -3530,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,
@@ -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).

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-sync.ts

@@ -16,7 +16,7 @@ import {
   _isSamePath as isSamePath,
   _shouldReconcileWorktreeDb,
 } from "./auto-worktree-cleanup.js";
-import { resolveGsdPathContract } from "./paths.js";
+import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
 import type { MilestoneScope } from "./workspace.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { logWarning } from "./workflow-logger.js";
@@ -211,10 +211,17 @@ function syncMilestoneLayout(
   if (!existsSync(mainMilestonesDir)) return;
 
   try {
-    mkdirSync(wtMilestonesDir, { recursive: true });
     const mainMilestones = readdirSync(mainMilestonesDir, { withFileTypes: true })
       .filter((entry) => entry.isDirectory())
-      .map((entry) => entry.name);
+      .map((entry) => entry.name)
+      .filter((name) =>
+        layoutSegment !== "milestones" ||
+        dirIsContentBearingLegacyMilestone(join(mainMilestonesDir, name)),
+      );
+
+    if (mainMilestones.length === 0) return;
+
+    mkdirSync(wtMilestonesDir, { recursive: true });
 
     for (const milestoneId of mainMilestones) {
       syncMilestoneDirectory(

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);