@opengsd/gsd-pi 1.9.0 → 1.10.0

package/README.md

@@ -28,16 +28,16 @@ See [CHANGELOG.md](./CHANGELOG.md) for release-by-release fixes and [Legacy Rele
 ## Latest Release Highlights
 
 <!-- release-highlights:start -->
-Latest release: **v1.9.0**
-
-- **gsd:** Add task rework briefs.
-- **web:** Delete unused chart.tsx and recharts.
-- **deps:** Move ajv to devDependencies.
-- **daemon:** Dedupe @anthropic-ai/sdk to ^0.91.1.
-- **deps:** Override hono to >=4.12.25.
-- **gsd:** Batch plan-v2 task queries and skip unchanged graph writes.
-- **gsd:** Open the worker DB once per parallel-monitor tick.
-- **gsd:** Batch parallel-eligibility task queries.
+Latest release: **v1.10.0**
+
+- **pi-ai:** Add Meta Muse Spark 1.1 to the model catalog.
+- **gsd:** Surface cacheRetention as a settable prompt-cache TTL preference.
+- **models:** Add GPT-5.6 as a first-class model.
+- **models:** Add Grok 4.5 as a first-class xAI model.
+- **agent-core:** Pin compaction summarization reasoning to low, bound degenerate-chunk retry.
+- **gsd:** Filter superseded context injections from provider payload.
+- **gsd:** Stop advertising alias tool schemas on model-facing surfaces.
+- **gsd:** Cap execute-task and discuss-slice inlined context; provider-aware budgets.
 
 <!-- release-highlights:end -->
 

package/dist/headless.js

@@ -29,7 +29,8 @@ export function buildHeadlessSlashCommand(options) {
     if (options.command === 'new-milestone' && options.auto && !commandArgs.includes(HEADLESS_CHAIN_AUTO_FLAG)) {
         commandArgs.push(HEADLESS_CHAIN_AUTO_FLAG);
     }
-    return `/gsd ${options.command}${commandArgs.length > 0 ? ' ' + commandArgs.join(' ') : ''}`;
+    const serializedArgs = commandArgs.map(arg => /\s/.test(arg) ? JSON.stringify(arg) : arg);
+    return `/gsd ${options.command}${serializedArgs.length > 0 ? ' ' + serializedArgs.join(' ') : ''}`;
 }
 /**
  * Commands classified as multi-turn in headless mode: they involve multiple

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-4c3ea176cf8f5545
+5f0f1c788a126951

package/dist/resources/GSD-WORKFLOW.md

@@ -367,7 +367,7 @@ When verification finds gaps, include a **Gaps** section with what's missing, im
 ### Phase 6: Summarize
 
 **Purpose:** Record what happened for downstream tasks.
-**Produces:** `T##-SUMMARY.md`, and when slice completes, `S##-SUMMARY.md`.
+**Produces:** `S##-T##-SUMMARY.md` in flat-phase projects, and when slice completes, `S##-SUMMARY.md`. Legacy flat `T##-SUMMARY.md` task summaries are still readable.
 
 **Task summary format:**
 ```markdown
@@ -494,7 +494,7 @@ It is NOT the source of truth. It's a convenience dashboard.
 **Sources of truth:**
 - `ROADMAP.md` → which slices exist and which are done
 - `<NN>-<MM>-PLAN.md` → which tasks exist within a slice and what each task must do
-- `T##-SUMMARY.md` → what happened during a task
+- `S##-T##-SUMMARY.md` → what happened during a task in flat-phase projects (legacy `T##-SUMMARY.md` is still readable)
 - `S##-SUMMARY.md` and `M###-SUMMARY.md` → compressed slice and milestone outcomes
 
 **Update `STATE.md`** after every significant action:

package/dist/resources/extensions/gsd/artifact-verification.js

@@ -9,7 +9,7 @@ import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
-import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relSliceFile, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
+import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relSliceFile, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
 import { existsSync, readFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { LAYOUT_SEGMENTS } from "./layout-policy.js";
@@ -185,10 +185,9 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         const batchIds = batchPart.slice(plusIdx + 1).split(",").filter(Boolean);
         if (batchIds.length === 0)
             return false;
-        const tDir = resolveTasksDir(base, mid, sid) ?? slicePath;
-        const existingSummaries = new Set(resolveTaskFiles(tDir, "SUMMARY").map((f) => f.replace(/-SUMMARY\.md$/i, "").toUpperCase()));
         for (const tid of batchIds) {
-            if (!existingSummaries.has(tid.toUpperCase()))
+            const summaryPath = resolveTaskFile(base, mid, sid, tid, "SUMMARY");
+            if (!summaryPath || !existsSync(summaryPath))
                 return false;
         }
         return true;

package/dist/resources/extensions/gsd/auto/loop.js

@@ -261,7 +261,22 @@ async function enforceMinRequestInterval(s, prefs) {
         await new Promise(r => setTimeout(r, decision.waitMs));
     }
 }
-function closeOutCrashedUnit(s, iterData, err) {
+async function snapshotCrashedUnitWork(ctx, s, deps, iterData) {
+    try {
+        const commitMsg = await deps.autoCommitUnit?.(s.basePath, iterData.unitType, iterData.unitId, ctx);
+        if (commitMsg) {
+            debugLog("autoLoop", {
+                phase: "crash-snapshot-commit",
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+            });
+        }
+    }
+    catch (snapshotErr) {
+        logWarning("dispatch", `unit crash snapshot failed: ${snapshotErr instanceof Error ? snapshotErr.message : String(snapshotErr)}`);
+    }
+}
+async function closeOutCrashedUnit(ctx, s, deps, iterData, err) {
     const summary = formatDispatchExceptionSummary({ error: err });
     try {
         emitOpenUnitEndForUnit(s.basePath, iterData.unitType, iterData.unitId, "cancelled", {
@@ -278,6 +293,7 @@ function closeOutCrashedUnit(s, iterData, err) {
     catch (closeoutErr) {
         logWarning("dispatch", `unit crash closeout failed: ${closeoutErr instanceof Error ? closeoutErr.message : String(closeoutErr)}`);
     }
+    await snapshotCrashedUnitWork(ctx, s, deps, iterData);
 }
 /**
  * Main auto-mode execution loop. Iterates: orchestration.advance → guards →
@@ -400,11 +416,15 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             active: s.active,
             iteration,
             maxIterations: MAX_LOOP_ITERATIONS,
-            hasCommandContext: Boolean(s.cmdCtx),
+            hasCommandContext: typeof s.cmdCtx?.newSession === "function",
             sessionLockValid: true,
         });
         if (commandContextDecision.action === "stop" && commandContextDecision.reason === "missing-command-context") {
             debugLog("autoLoop", { phase: "exit", reason: "no-cmdCtx" });
+            if (s.currentUnit) {
+                await deps.autoCommitUnit?.(s.basePath, s.currentUnit.type, s.currentUnit.id, ctx);
+            }
+            await deps.stopAuto(ctx, pi, commandContextDecision.message, { preserveWorktree: true });
             finishTurn("stopped", "manual-attention", commandContextDecision.reason);
             break;
         }
@@ -586,7 +606,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     if (err instanceof ModelPolicyDispatchBlockedError) {
                         throw err;
                     }
-                    closeOutCrashedUnit(s, iterData, err);
+                    await closeOutCrashedUnit(ctx, s, deps, iterData, err);
                     throw err;
                 }
                 if (unitPhaseResult.action === "next") {
@@ -1109,7 +1129,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 if (err instanceof ModelPolicyDispatchBlockedError) {
                     throw err;
                 }
-                closeOutCrashedUnit(s, iterData, err);
+                await closeOutCrashedUnit(ctx, s, deps, iterData, err);
                 dispatchSettled = settleDispatchFailed(dispatchId, formatDispatchExceptionSummary({ error: err }), {
                     markFailed: markDispatchFailed,
                     logWriteFailure: logDispatchLedgerWriteFailure,

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

@@ -58,6 +58,24 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     debugLog("runUnit", { phase: "start", unitType, unitId });
     // ── Session creation with timeout ──
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
+    const cmdCtx = s.cmdCtx;
+    if (typeof cmdCtx?.newSession !== "function") {
+        const msg = "command context is missing newSession";
+        debugLog("runUnit", {
+            phase: "session-error",
+            unitType,
+            unitId,
+            error: msg,
+        });
+        return {
+            status: "cancelled",
+            errorContext: {
+                message: `Session creation failed: ${msg}`,
+                category: "session-failed",
+                isTransient: false,
+            },
+        };
+    }
     let sessionResult;
     let sessionTimeoutHandle;
     const mySessionSwitchGeneration = ++sessionSwitchGeneration;
@@ -67,7 +85,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const sessionAbortController = new AbortController();
     _setSessionSwitchInFlight(true);
     try {
-        const sessionPromise = s.cmdCtx.newSession({
+        const sessionPromise = cmdCtx.newSession({
             abortSignal: sessionAbortController.signal,
             workspaceRoot: s.basePath,
         }).finally(() => {

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

@@ -30,6 +30,25 @@ import { isIsolatedWorktreeSession, _resolveCurrentUnitStartedAtForTest, emitCan
 import { MAX_RECOVERY_CHARS } from "./types.js";
 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) {
+    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) {
+    if (!ZERO_TOOL_PSEUDO_TOOL_CALL_RE.test(message))
+        return null;
+    return zeroToolMessageSnippet(message);
+}
 function classifyZeroToolProviderMessage(message) {
     const firstLine = message.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
     if (!firstLine ||
@@ -39,6 +58,7 @@ function classifyZeroToolProviderMessage(message) {
     return classifyError(firstLine);
 }
 export const _classifyZeroToolProviderMessageForTest = classifyZeroToolProviderMessage;
+export const _zeroToolPseudoToolCallSnippetForTest = zeroToolPseudoToolCallSnippet;
 export function resolveDispatchRecoveryAttempts(unitRecoveryCount, unitType, unitId) {
     return (unitRecoveryCount.get(`${unitType}/${unitId}`) ?? 0) > 0
         ? 0
@@ -572,11 +592,23 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             const lastUnit = [...currentLedger.units].reverse().find((u) => u.type === unitType && u.id === unitId && u.startedAt === _resolveCurrentUnitStartedAtForTest(s.currentUnit));
             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: () => {
@@ -593,7 +625,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                     });
                     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/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -5,7 +5,7 @@
 // resolveExpectedArtifactPath and diagnoseExpectedArtifact moved here from
 // auto-recovery.ts (Phase 5 dead-code cleanup). The artifact verification
 // function was removed entirely — callers now query WorkflowEngine directly.
-import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, normalizeRealPath, } from "./paths.js";
+import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildFlatTaskFileName, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, normalizeRealPath, } from "./paths.js";
 import { milestoneIdToPhaseNum } from "./layout-policy.js";
 import { parseUnitId } from "./unit-id.js";
 import { basename, dirname, join, relative } from "node:path";
@@ -79,12 +79,15 @@ function resolveProjectMilestonePath(base, mid) {
     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
@@ -203,7 +206,10 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             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/dist/resources/extensions/gsd/auto-dispatch.js

@@ -1603,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 ─────────────────────────────────────────────────────────────

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

@@ -10,12 +10,12 @@
 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 { getBlockingReworkFindingsForTask, getGateResults, getPendingGatesForTurn } from "./gsd-db.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).
@@ -200,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
@@ -210,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,
@@ -253,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)
@@ -310,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);
@@ -1245,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)
@@ -1253,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}`);
@@ -1280,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}`);
@@ -1403,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,
@@ -1412,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);
@@ -1438,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).
@@ -2307,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);
@@ -2409,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);
@@ -2497,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;
@@ -3072,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);
@@ -3081,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() {