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

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

@@ -209,7 +209,8 @@ export function shouldRunDeepProjectSetup(state, prefs, basePath, options = {})
 }
 function resolveArtifactBasePath(basePath, mid, session) {
     if (session?.basePath &&
-        session.currentMilestoneId === mid &&
+        session.currentMilestoneId &&
+        milestoneIdsDispatchCompatible(session.currentMilestoneId, mid) &&
         existsSync(session.basePath)) {
         return session.basePath;
     }
@@ -231,6 +232,24 @@ function normalizeMilestoneScope(value) {
         return null;
     return trimmed;
 }
+function dispatchMilestoneIdentity(value) {
+    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, right) {
+    const leftId = dispatchMilestoneIdentity(left);
+    const rightId = dispatchMilestoneIdentity(right);
+    return Boolean(leftId &&
+        rightId &&
+        leftId.baseId === rightId.baseId &&
+        leftId.hasSuffix !== rightId.hasSuffix);
+}
+function milestoneIdsDispatchCompatible(left, right) {
+    return left === right || isBareSuffixedMilestoneAlias(left, right);
+}
 function resolveDispatchMilestoneScope(ctx) {
     const sessionMilestone = normalizeMilestoneScope(ctx.session?.currentMilestoneId);
     if (sessionMilestone)
@@ -243,6 +262,31 @@ function resolveDispatchMilestoneScope(ctx) {
         return { id: baseWorktree, source: "basePath worktree" };
     return null;
 }
+function resolveEffectiveDispatchMilestoneId(ctx, scopedMilestone) {
+    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, effectiveMid) {
+    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, mid) {
     if (isDbAvailable()) {
         try {
@@ -510,18 +554,25 @@ export const DISPATCH_RULES = [
         // 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))
+            // 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))
+            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
@@ -854,12 +905,14 @@ export const DISPATCH_RULES = [
     },
     {
         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
@@ -1550,6 +1603,8 @@ function applyLanguageDirectiveToDispatch(action, prefs) {
     const directive = renderLanguageDirectiveForPrompt(prefs);
     if (!directive)
         return action;
+    if (action.prompt.startsWith(directive))
+        return action;
     return { ...action, prompt: `${directive}\n\n${action.prompt}` };
 }
 // ─── Resolver ─────────────────────────────────────────────────────────────
@@ -1562,31 +1617,33 @@ function applyLanguageDirectiveToDispatch(action, prefs) {
  * resolveDispatch directly without registry initialization).
  */
 export async function resolveDispatch(ctx) {
-    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. ` +
+                reason: `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}". ` +
+            reason: `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}". ` +
+            reason: `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",
         };
@@ -1594,9 +1651,9 @@ export async function resolveDispatch(ctx) {
     // 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",
                 reason: `Unit ${action.unitId} exhausted verification retries this session.`,
@@ -1610,13 +1667,13 @@ export async function resolveDispatch(ctx) {
         logWarning("dispatch", `registry dispatch failed, falling back to inline rules: ${err instanceof Error ? err.message : String(err)}`);
     }
     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",
                     reason: `Unit ${action.unitId} exhausted verification retries this session.`,

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -1411,6 +1411,10 @@ export async function postUnitPreVerification(pctx, opts) {
                                 const blockingMismatch = mismatches.find((mismatch) => mismatch.severity === "error");
                                 if (blockingMismatch) {
                                     ctx.ui.notify(`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/dist/resources/extensions/gsd/auto-prompts.js

@@ -10,15 +10,15 @@
 import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection } from "./files.js";
 import { extractVerdict } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
-import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, relTaskFile, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
-import { resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
+import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, taskIdFromTaskFileName, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, relTaskFile, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.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";
-import { join, relative, sep } from "node:path";
+import { join, basename, relative, sep } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
-import { getGateResults, getPendingGatesForTurn } from "./gsd-db.js";
+import { getBlockingReworkFindingsForTask, getGateResults, getPendingGatesForTurn } from "./gsd-db.js";
 import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
@@ -47,6 +47,12 @@ export { buildSkillActivationBlock, buildSkillDiscoveryVars };
  * from their configured executor window.
  */
 const MAX_PREAMBLE_CHARS = 20_000;
+function prependLanguageDirectiveForBase(base, prompt) {
+    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.
  *
@@ -62,13 +68,29 @@ function resolvePromptBudgets() {
         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.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) {
+    const exec = prefs?.models?.execution;
+    if (exec && typeof exec === "object" && "provider" in exec) {
+        const provider = exec.provider;
+        if (typeof provider === "string" && provider)
+            return provider;
+    }
+    return undefined;
+}
 /**
  * Character budget for dependency/prior slice summaries injected into dispatch
  * prompts. Scales with the executor's configured context window (issue #4435).
@@ -76,6 +98,32 @@ function resolvePromptBudgets() {
 function resolveSummaryBudgetChars() {
     return resolvePromptBudgets().summaryBudgetChars;
 }
+function renderBlockingReworkFindingsBlock(mid, sid, tid) {
+    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) {
     const sampleFiles = classification.contentFiles.slice(0, 8);
     const sample = sampleFiles.length > 0 ? sampleFiles.map((file) => `\`${file}\``).join(", ") : "(none)";
@@ -174,7 +222,7 @@ function formatCloseoutReviewInstructions(validationContent, validationRel, curr
         `No passing validation artifact was found at \`${validationRel}\`. Use the full closeout review path before completion.`,
     ].join("\n");
 }
-function capPreamble(preamble) {
+export function capPreamble(preamble) {
     // 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
@@ -184,6 +232,35 @@ function capPreamble(preamble) {
         return preamble;
     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, slicePlan, templates, budgetChars) {
+    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 };
+}
 function trackPromptContext(entries, key, mode, body, reason) {
     entries.push({
         key,
@@ -227,7 +304,7 @@ function renderContextModeBlockForPrompt(unitType, base, renderMode = "standalon
     return `${contextMode}\n\n## Context Snapshot\nSource: \`.gsd/last-snapshot.md\`\n\n${snapshot.trimEnd()}`;
 }
 function prependContextModeToBlock(unitType, base, block, renderMode = "standalone") {
-    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)
@@ -284,7 +361,7 @@ function formatExecutorConstraints(sessionContextWindow, modelRegistry, sessionP
         // 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);
     const { min, max } = budgets.taskCountRange;
     const execWindowK = Math.round(windowTokens / 1000);
     const perTaskBudgetK = Math.round(budgets.inlineContextBudgetChars / 1000);
@@ -1219,6 +1296,13 @@ function resolveTaskSummariesLocation(base, mid, sid) {
         return { dir: tDir, relPrefix: `${sRel}/tasks` };
     return { dir: slicePath, relPrefix: sRel };
 }
+function summaryFileBelongsToSlice(fileName, base, mid, sid) {
+    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, sid, currentTid, base) {
     const loc = resolveTaskSummariesLocation(base, mid, sid);
     if (!loc)
@@ -1227,7 +1311,12 @@ export async function getPriorTaskSummaryPaths(mid, sid, currentTid, base) {
     const currentNum = parseInt(currentTid.replace(/^T/, ""), 10);
     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}`);
@@ -1254,8 +1343,11 @@ export async function getDependencyTaskSummaryPaths(mid, sid, currentTid, depend
     const depSet = new Set(dependsOn.map((d) => d.toUpperCase()));
     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}`);
@@ -1377,7 +1469,7 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
     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,
@@ -1386,6 +1478,7 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
             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);
     const cappedInlinedContext = capPreamble(rawInlinedContext);
@@ -1412,9 +1505,10 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
         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);
 }
 /**
  * Build a prompt for the workflow-preferences unit type (deep mode).
@@ -2281,7 +2375,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     // 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);
     const verificationBudget = `~${Math.round(budgets.verificationBudgetChars / 1000)}K chars`;
     // Truncate carry-forward section when it exceeds 40% of inline context budget.
     const carryForwardBudget = Math.floor(budgets.inlineContextBudgetChars * 0.4);
@@ -2319,6 +2413,14 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     catch (reopenErr) {
         logWarning("prompt", `reopen reason injection failed: ${reopenErr.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
@@ -2375,10 +2477,19 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
             }
         },
     });
-    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(contextTelemetry, "slice-research", onDemandContext ? "on-demand" : "skipped", onDemandContext, onDemandContext ? undefined : onDemandResult.skipReason ?? undefined);
@@ -2463,12 +2574,14 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
                     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 = [];
                 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;
@@ -3038,7 +3151,9 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
     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);
@@ -3047,7 +3162,7 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
             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/dist/resources/extensions/gsd/auto-recovery.js

@@ -17,7 +17,7 @@ import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus, isInactiveStatus } from "./status-guards.js";
-import { resolveSlicePath, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, clearPathCache, } from "./paths.js";
+import { resolveSlicePath, resolveTaskFile, relMilestoneFile, relSliceFile, clearPathCache, } from "./paths.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
 import { dirname } from "node:path";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
@@ -227,10 +227,15 @@ export function writeReactiveExecuteBlocker(unitId, base, reason) {
     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()));
-    const summaryPresent = batchIds.filter((tid) => existingSummaries.has(tid.toUpperCase()));
-    const summaryMissing = batchIds.filter((tid) => !existingSummaries.has(tid.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) => {
+        const summaryPath = resolveTaskFile(base, mid, sid, tid, "SUMMARY");
+        return summaryPath !== null && existsSync(summaryPath);
+    };
+    const summaryPresent = batchIds.filter((tid) => hasSummary(tid));
+    const summaryMissing = batchIds.filter((tid) => !hasSummary(tid));
     const completedTaskIds = [];
     const skippedTaskIds = [];
     const unchangedTaskIds = [];

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -1,6 +1,6 @@
 // GSD auto-mode runtime state
 import { AutoSession } from "./auto/session.js";
-import { isDeterministicPolicyError, isQueuedUserMessageSkip, isToolInvocationError, markToolEnd as markTrackedToolEnd, markToolStart as markTrackedToolStart, } from "./auto-tool-tracking.js";
+import { 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
 // foreground where the foreground approval-gate pause consults it.
@@ -61,13 +61,13 @@ export function markToolEnd(toolCallId) {
 export function recordToolInvocationError(toolName, errorMsg) {
     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() {
+export function clearToolInvocationError(successfulToolName) {
     if (!autoSession.active)
         return;
+    if (!shouldClearToolInvocationErrorAfterSuccess(autoSession.lastToolInvocationError, successfulToolName))
+        return;
     autoSession.lastToolInvocationError = null;
 }
 export function getSourceObservationStore() {

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

@@ -46,9 +46,10 @@ 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, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
-import { existsSync, mkdirSync, readFileSync, rmSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, } from "node:fs";
 import { join } from "node:path";
 import { validateDirectory } from "./validate-directory.js";
 import { isCustomProvider, resolveDefaultSessionModel, resolveDynamicRoutingConfig, } from "./preferences-models.js";
@@ -73,6 +74,30 @@ const MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS = 2;
 export function hasGitIndexLockForTest(basePath) {
     return existsSync(join(basePath, ".git", "index.lock"));
 }
+function isEmptyDirectory(dirPath) {
+    try {
+        return existsSync(dirPath) && readdirSync(dirPath).length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function reconcileFlatPhaseBootstrapLayout(basePath) {
+    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, dbAvailable, pathExists = existsSync) {
     return pathExists(gsdDbPath) && !dbAvailable;
 }
@@ -868,20 +893,15 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         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)}`);
             }
         }
         {