gsd-pi 2.76.0-dev.b072ebb73 → 2.76.0-dev.fe143342a

package/dist/resources/extensions/gsd/blocked-models.js

@@ -0,0 +1,68 @@
+// GSD — Persistent per-project blocklist of provider/model pairs that the
+// provider has rejected at request time for account entitlement reasons.
+//
+// Lives at `.gsd/runtime/blocked-models.json` so the block survives /gsd auto
+// restarts.  Auto-mode model selection skips blocked entries; agent-end
+// recovery adds entries when a runtime rejection is classified as
+// `unsupported-model`.  See issue #4513.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { gsdRoot } from "./paths.js";
+import { withFileLockSync } from "./file-lock.js";
+function blockedModelsPath(basePath) {
+    return join(gsdRoot(basePath), "runtime", "blocked-models.json");
+}
+function modelKey(provider, id) {
+    return `${provider.toLowerCase()}/${id.toLowerCase()}`;
+}
+function readFileSafe(path) {
+    if (!existsSync(path))
+        return { version: 1, blocked: [] };
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.blocked)) {
+            return { version: 1, blocked: [] };
+        }
+        const blocked = parsed.blocked.filter((e) => !!e && typeof e.provider === "string" && typeof e.id === "string");
+        return { version: 1, blocked };
+    }
+    catch {
+        // Corrupted JSON: treat as empty so a bad file never blocks dispatch.
+        return { version: 1, blocked: [] };
+    }
+}
+export function loadBlockedModels(basePath) {
+    return readFileSafe(blockedModelsPath(basePath)).blocked;
+}
+export function isModelBlocked(basePath, provider, id) {
+    if (!provider || !id)
+        return false;
+    const target = modelKey(provider, id);
+    return loadBlockedModels(basePath).some((e) => modelKey(e.provider, e.id) === target);
+}
+export function blockModel(basePath, provider, id, reason) {
+    const path = blockedModelsPath(basePath);
+    mkdirSync(dirname(path), { recursive: true });
+    // Ensure the file exists before we try to lock it — proper-lockfile requires
+    // the target path to exist (file-lock.ts falls through to an unlocked call
+    // otherwise).
+    if (!existsSync(path)) {
+        writeFileSync(path, JSON.stringify({ version: 1, blocked: [] }, null, 2) + "\n", "utf-8");
+    }
+    withFileLockSync(path, () => {
+        const current = readFileSafe(path);
+        const target = modelKey(provider, id);
+        if (current.blocked.some((e) => modelKey(e.provider, e.id) === target)) {
+            return;
+        }
+        const next = {
+            version: 1,
+            blocked: [
+                ...current.blocked,
+                { provider, id, reason, blockedAt: Date.now() },
+            ],
+        };
+        writeFileSync(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
+    });
+}

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -8,6 +8,7 @@ import { resolveModelId } from "../auto-model-selection.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
 import { resumeAutoAfterProviderDelay } from "./provider-error-resume.js";
 import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
+import { blockModel, isModelBlocked } from "../blocked-models.js";
 const retryState = createRetryState();
 const MAX_NETWORK_RETRIES = 2;
 const MAX_TRANSIENT_AUTO_RESUMES = 8;
@@ -106,6 +107,81 @@ export async function handleAgentEnd(pi, event, ctx) {
         const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
         // ── 1. Classify using rawErrorMsg to avoid prose false-positives ────
         const cls = classifyError(rawErrorMsg, explicitRetryAfterMs);
+        // ── 1a. Unsupported-model: provider rejected this model for the current
+        //        account/plan at request time (#4513).  Persist a block so the
+        //        same dead model isn't reselected on the next /gsd auto restart,
+        //        then try a fallback before pausing.
+        if (cls.kind === "unsupported-model") {
+            const dash = getAutoDashboardData();
+            const rejectedProvider = ctx.model?.provider;
+            const rejectedId = ctx.model?.id;
+            if (dash.basePath && rejectedProvider && rejectedId) {
+                try {
+                    blockModel(dash.basePath, rejectedProvider, rejectedId, rawErrorMsg || "unsupported for account");
+                    ctx.ui.notify(`Blocked ${rejectedProvider}/${rejectedId} for this project — provider rejected it for the current account.`, "warning");
+                }
+                catch (err) {
+                    const m = err instanceof Error ? err.message : String(err);
+                    logWarning("bootstrap", `Failed to persist blocked model: ${m}`);
+                }
+            }
+            // Try configured fallback chain, skipping anything already blocked.
+            if (dash.currentUnit && dash.basePath) {
+                const modelConfig = resolveModelWithFallbacksForUnit(dash.currentUnit.type);
+                if (modelConfig && modelConfig.fallbacks.length > 0) {
+                    const availableModels = ctx.modelRegistry.getAvailable();
+                    let cursorModelId = ctx.model?.id;
+                    while (true) {
+                        const nextModelId = getNextFallbackModel(cursorModelId, modelConfig);
+                        if (!nextModelId)
+                            break;
+                        const candidate = resolveModelId(nextModelId, availableModels, ctx.model?.provider);
+                        if (candidate && !isModelBlocked(dash.basePath, candidate.provider, candidate.id)) {
+                            const ok = await pi.setModel(candidate, { persist: false });
+                            if (ok) {
+                                setCurrentDispatchedModelId({ provider: candidate.provider, id: candidate.id });
+                                ctx.ui.notify(`Switched to fallback ${candidate.provider}/${candidate.id} after account entitlement rejection.`, "warning");
+                                pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
+                                return;
+                            }
+                        }
+                        cursorModelId = nextModelId;
+                    }
+                }
+                // Fallback chain exhausted — try the auto-mode start model if it isn't
+                // the same one we just blocked and isn't itself blocked.
+                const sessionModel = getAutoModeStartModel();
+                if (sessionModel &&
+                    !(sessionModel.provider === rejectedProvider && sessionModel.id === rejectedId) &&
+                    !isModelBlocked(dash.basePath, sessionModel.provider, sessionModel.id)) {
+                    const startModel = ctx.modelRegistry
+                        .getAvailable()
+                        .find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
+                    if (startModel) {
+                        const ok = await pi.setModel(startModel, { persist: false });
+                        if (ok) {
+                            setCurrentDispatchedModelId({ provider: startModel.provider, id: startModel.id });
+                            ctx.ui.notify(`Restored auto-mode start model ${startModel.provider}/${startModel.id} after entitlement rejection.`, "warning");
+                            pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
+                            return;
+                        }
+                    }
+                }
+            }
+            // No usable fallback — pause with a clearly named message.
+            const blockedLabel = rejectedProvider && rejectedId ? `${rejectedProvider}/${rejectedId}` : "current model";
+            const pauseDetail = `Model ${blockedLabel} blocked for this account${errorDetail}. Configure a different model and restart /gsd auto.`;
+            await pauseAutoForProviderError(ctx.ui, pauseDetail, () => pauseAuto(ctx, pi, {
+                message: pauseDetail,
+                category: "provider",
+                isTransient: false,
+            }), {
+                isRateLimit: false,
+                isTransient: false,
+                retryAfterMs: 0,
+            });
+            return;
+        }
         // ── 1b. Defer to Core RetryHandler for most transient errors ────────
         // Core retries transient failures in-session after this handler.
         // Keep that behavior for non-rate-limit classes to avoid pause/retry races,

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -19,6 +19,18 @@ function registerAlias(pi, toolDef, aliasName, canonicalName) {
         promptGuidelines: [`Alias for ${canonicalName} — prefer the canonical name.`],
     });
 }
+/**
+ * Read a tool result's structured payload, accommodating MCP's `details` →
+ * `structuredContent` rename (#4472, #4477). In-process executions still
+ * deliver the payload on `result.details`; MCP-routed executions deliver it
+ * on `result.structuredContent` (post `adaptExecutorResult` transform). All
+ * `renderResult` callbacks in this file route through this helper so a future
+ * field rename only needs to be applied in one place.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- result shape varies by tool
+function readDetails(result) {
+    return result?.details ?? result?.structuredContent;
+}
 export function registerDbTools(pi) {
     // ─── gsd_decision_save (formerly gsd_save_decision) ─────────────────────
     const decisionSaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
@@ -92,7 +104,7 @@ export function registerDbTools(pi) {
             return new Text(text, 0, 0);
         },
         renderResult(result, _options, theme) {
-            const d = result.details;
+            const d = readDetails(result);
             if (result.isError || d?.error) {
                 return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
             }
@@ -175,7 +187,7 @@ export function registerDbTools(pi) {
             return new Text(text, 0, 0);
         },
         renderResult(result, _options, theme) {
-            const d = result.details;
+            const d = readDetails(result);
             if (result.isError || d?.error) {
                 return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
             }
@@ -255,7 +267,7 @@ export function registerDbTools(pi) {
             return new Text(text, 0, 0);
         },
         renderResult(result, _options, theme) {
-            const d = result.details;
+            const d = readDetails(result);
             if (result.isError || d?.error) {
                 return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
             }
@@ -301,7 +313,7 @@ export function registerDbTools(pi) {
             return new Text(text, 0, 0);
         },
         renderResult(result, _options, theme) {
-            const d = result.details;
+            const d = readDetails(result);
             if (result.isError || d?.error) {
                 return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
             }
@@ -382,7 +394,7 @@ export function registerDbTools(pi) {
             return new Text(theme.fg("toolTitle", theme.bold("milestone_generate_id")), 0, 0);
         },
         renderResult(result, _options, theme) {
-            const d = result.details;
+            const d = readDetails(result);
             if (result.isError || d?.error) {
                 return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
             }
@@ -967,13 +979,31 @@ export function registerDbTools(pi) {
             text += theme.fg("dim", ` → ${args.verdict ?? ""}`);
             return new Text(text, 0, 0);
         },
+        /**
+         * Render the save_gate_result tool output for the TUI.
+         *
+         * Prefers structured fields, but falls back to `content[0].text` when the
+         * structured payload is empty. Defensive: the structural fix on this
+         * branch plumbs `details` through MCP via `structuredContent`, but older
+         * hosts, a future handler that forgets `structuredContent`, or any drop
+         * of non-standard return fields would otherwise render as
+         * "undefined: undefined". Same fallback applies to error rendering, and
+         * we strip a leading `Error:` from the fallback text to avoid producing
+         * `Error: Error: ...`.
+         */
         renderResult(result, _options, theme) {
-            const d = result.details;
+            const d = readDetails(result);
             if (result.isError || d?.error) {
-                return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
+                const rawMsg = d?.error ?? result.content?.[0]?.text ?? "unknown";
+                const msg = rawMsg.replace(/^\s*Error:\s*/i, "");
+                return new Text(theme.fg("error", `Error: ${msg}`), 0, 0);
+            }
+            if (!d?.gateId || !d?.verdict) {
+                const text = result.content?.[0]?.text ?? "Gate result saved";
+                return new Text(theme.fg("success", text), 0, 0);
             }
-            const color = d?.verdict === "flag" ? "warning" : "success";
-            return new Text(theme.fg(color, `${d?.gateId}: ${d?.verdict}`), 0, 0);
+            const color = d.verdict === "flag" ? "warning" : "success";
+            return new Text(theme.fg(color, `${d.gateId}: ${d.verdict}`), 0, 0);
         },
     };
     pi.registerTool(saveGateResultTool);

package/dist/resources/extensions/gsd/bootstrap/exec-tools.js

@@ -0,0 +1,93 @@
+// GSD2 — Exec (context-mode) tool registration.
+//
+// Exposes the `gsd_exec` tool over MCP. Opt-in: disabled unless
+// `context_mode.enabled: true` is set in preferences.
+import { Type } from "@sinclair/typebox";
+import { executeGsdExec } from "../tools/exec-tool.js";
+import { executeExecSearch } from "../tools/exec-search-tool.js";
+import { executeResume } from "../tools/resume-tool.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { logWarning } from "../workflow-logger.js";
+export function registerExecTools(pi) {
+    pi.registerTool({
+        name: "gsd_exec",
+        label: "Exec (Sandboxed)",
+        description: "Run a short script (bash/node/python) in a subprocess. Full stdout/stderr persist to " +
+            ".gsd/exec/<id>.{stdout,stderr,meta.json}; only a short digest returns in context. Use " +
+            "this instead of reading many files or emitting large tool outputs — e.g. have the script " +
+            "count/grep/summarize and log the finding. Enabled by default; opt out via " +
+            "preferences.context_mode.enabled=false.",
+        promptSnippet: "Run a bash/node/python script in a sandbox; full output is saved to disk and only a digest returns",
+        promptGuidelines: [
+            "Prefer gsd_exec for analyses that would otherwise read >3 files or produce large tool output.",
+            "Write scripts that log the finding (counts, matches, summaries) rather than raw dumps.",
+            "The digest is the last ~300 chars of stdout — size your log output accordingly.",
+            "Need the full output? Read the stdout_path returned in details (file on local disk).",
+        ],
+        parameters: Type.Object({
+            runtime: Type.Union([Type.Literal("bash"), Type.Literal("node"), Type.Literal("python")], { description: "Interpreter: bash (-c), node (-e), or python3 (-c)." }),
+            script: Type.String({ description: "Script body. Keep output small (log the finding, not the data)." }),
+            purpose: Type.Optional(Type.String({ description: "Short label recorded in meta.json for later review." })),
+            timeout_ms: Type.Optional(Type.Number({
+                description: "Per-invocation timeout (ms). Capped at 600000. Default from preferences.",
+                minimum: 1_000,
+                maximum: 600_000,
+            })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            let prefs = null;
+            try {
+                prefs = loadEffectiveGSDPreferences();
+            }
+            catch (err) {
+                logWarning("tool", `gsd_exec could not load preferences: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return executeGsdExec(params, {
+                baseDir: process.cwd(),
+                preferences: prefs?.preferences ?? null,
+            });
+        },
+    });
+    pi.registerTool({
+        name: "gsd_exec_search",
+        label: "Search gsd_exec History",
+        description: "List prior gsd_exec runs (most recent first) from .gsd/exec/*.meta.json. Useful for " +
+            "rediscovering the stdout_path of an earlier run without re-executing it. Read-only.",
+        promptSnippet: "Search prior gsd_exec runs by substring, runtime, or failing-only filter",
+        promptGuidelines: [
+            "Use this before re-running an expensive analysis — the prior run's stdout file may still answer.",
+            "The preview shows the trailing ~300 chars of stdout; read stdout_path for the full transcript.",
+        ],
+        parameters: Type.Object({
+            query: Type.Optional(Type.String({ description: "Substring matched against id and purpose (case-insensitive)." })),
+            runtime: Type.Optional(Type.Union([Type.Literal("bash"), Type.Literal("node"), Type.Literal("python")], {
+                description: "Restrict to one runtime.",
+            })),
+            failing_only: Type.Optional(Type.Boolean({ description: "Only non-zero exit codes and timeouts." })),
+            limit: Type.Optional(Type.Number({ description: "Max results (default 20, cap 200)", minimum: 1, maximum: 200 })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            return executeExecSearch(params, {
+                baseDir: process.cwd(),
+            });
+        },
+    });
+    pi.registerTool({
+        name: "gsd_resume",
+        label: "Resume (Read Snapshot)",
+        description: "Return the contents of .gsd/last-snapshot.md — a ≤2 KB digest of top memories, recent " +
+            "gsd_exec runs, and active context, written automatically on session_before_compact. Use " +
+            "this after compaction or session resume to re-orient quickly.",
+        promptSnippet: "Read the pre-compaction snapshot to re-orient after context loss",
+        promptGuidelines: [
+            "Call this right after a session resumes if you feel you've lost durable context.",
+            "The snapshot is a summary — use memory_query or gsd_exec_search for detail.",
+        ],
+        parameters: Type.Object({}),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            return executeResume(params, {
+                baseDir: process.cwd(),
+            });
+        },
+    });
+}

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -4,6 +4,7 @@ import { registerWorktreeCommand } from "../worktree-command.js";
 import { loadEcosystemExtensions } from "../ecosystem/loader.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
+import { registerExecTools } from "./exec-tools.js";
 import { registerJournalTools } from "./journal-tools.js";
 import { registerMemoryTools } from "./memory-tools.js";
 import { registerQueryTools } from "./query-tools.js";
@@ -86,6 +87,7 @@ export function registerGsdExtension(pi) {
         ["journal-tools", () => registerJournalTools(pi)],
         ["query-tools", () => registerQueryTools(pi)],
         ["memory-tools", () => registerMemoryTools(pi)],
+        ["exec-tools", () => registerExecTools(pi)],
         ["shortcuts", () => registerShortcuts(pi)],
         ["hooks", () => registerHooks(pi, ecosystemHandlers)],
         ["ecosystem", () => {

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -204,6 +204,41 @@ export function registerHooks(pi, ecosystemHandlers) {
             nextAction: `Resume task ${state.activeTask.id}: ${state.activeTask.title}.`,
         }));
     });
+    // Context-mode snapshot: write .gsd/last-snapshot.md before compaction so
+    // agents can call gsd_resume (or Read the file) to re-orient. Opt-in via
+    // preferences.context_mode.enabled. Runs after the auto-cancel handler
+    // above — if that one returned cancel:true, pi still fires us but the
+    // compaction won't actually happen; the snapshot is still useful then,
+    // since auto may pause and resume later.
+    pi.on("session_before_compact", async () => {
+        try {
+            const { loadEffectiveGSDPreferences } = await import("../preferences.js");
+            const { isContextModeEnabled } = await import("../preferences-types.js");
+            const prefs = loadEffectiveGSDPreferences();
+            if (!isContextModeEnabled(prefs?.preferences))
+                return;
+            const { writeCompactionSnapshot } = await import("../compaction-snapshot.js");
+            const { ensureDbOpen } = await import("./dynamic-tools.js");
+            await ensureDbOpen();
+            const basePath = process.cwd();
+            let activeContext = null;
+            try {
+                const state = await deriveState(basePath);
+                if (state.activeMilestone && state.activeSlice && state.activeTask) {
+                    activeContext =
+                        `Active: ${state.activeMilestone.id} / ${state.activeSlice.id} / ${state.activeTask.id}` +
+                            (state.activeTask.title ? ` — ${state.activeTask.title}` : "");
+                }
+            }
+            catch {
+                /* non-fatal */
+            }
+            writeCompactionSnapshot(basePath, { activeContext });
+        }
+        catch (err) {
+            safetyLogWarning("context-mode", `failed to write compaction snapshot: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
     pi.on("session_shutdown", async (_event, ctx) => {
         if (isParallelActive()) {
             try {

package/dist/resources/extensions/gsd/compaction-snapshot.js

@@ -0,0 +1,121 @@
+// GSD Compaction Snapshot — writes a ≤2 KB markdown digest of durable
+// project state before the session context is compacted. On resume, an
+// agent can `gsd_resume` (or Read .gsd/last-snapshot.md) to re-orient
+// without re-deriving the same memories.
+//
+// Inspired by mksglu/context-mode. Independent implementation.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { getActiveMemoriesRanked } from "./memory-store.js";
+import { listExecHistory } from "./exec-history.js";
+export const DEFAULT_SNAPSHOT_BYTES = 2048;
+export const SNAPSHOT_FILENAME = "last-snapshot.md";
+/**
+ * Build a priority-tiered markdown snapshot. Pure — no I/O. Tiers:
+ *   1. Active context (if any)
+ *   2. Top memories by rank
+ *   3. Recent exec runs (failures highlighted)
+ * The result is guaranteed to be <= opts.maxBytes (truncated with an
+ * ellipsis marker if necessary).
+ */
+export function buildSnapshot(sources, opts = {}) {
+    const maxBytes = opts.maxBytes ?? DEFAULT_SNAPSHOT_BYTES;
+    const maxMemories = opts.maxMemories ?? 6;
+    const maxExec = opts.maxExec ?? 5;
+    const lines = [];
+    lines.push(`# GSD context snapshot (${sources.generatedAt.toISOString()})`);
+    lines.push("");
+    if (sources.activeContext && sources.activeContext.trim().length > 0) {
+        lines.push("## Active context");
+        lines.push(sources.activeContext.trim());
+        lines.push("");
+    }
+    const memories = sources.memories.slice(0, maxMemories);
+    if (memories.length > 0) {
+        lines.push("## Top project memories");
+        for (const memory of memories) {
+            lines.push(`- [${memory.id}] (${memory.category}) ${memory.content.trim()}`);
+        }
+        lines.push("");
+    }
+    const exec = sources.execHistory.slice(0, maxExec);
+    if (exec.length > 0) {
+        lines.push("## Recent gsd_exec runs");
+        for (const entry of exec) {
+            const status = entry.timed_out
+                ? "timeout"
+                : entry.exit_code === null
+                    ? "exit:null"
+                    : `exit:${entry.exit_code}`;
+            const purpose = entry.purpose ? ` — ${entry.purpose}` : "";
+            lines.push(`- [${entry.id}] ${entry.runtime} ${status}${purpose}`);
+        }
+        lines.push("");
+    }
+    if (memories.length === 0 && exec.length === 0 && !sources.activeContext) {
+        lines.push("_No durable memories, active context, or exec history to surface._");
+    }
+    return enforceByteCap(lines.join("\n").trimEnd(), maxBytes);
+}
+function enforceByteCap(input, maxBytes) {
+    if (Buffer.byteLength(input, "utf-8") <= maxBytes)
+        return input;
+    const marker = "\n…[truncated]";
+    const markerBytes = Buffer.byteLength(marker, "utf-8");
+    const budget = Math.max(0, maxBytes - markerBytes);
+    // Walk backwards until the trimmed string fits. utf-8 is variable-width;
+    // naive char slicing is safe for ASCII but may split a multi-byte char.
+    // Guard by decoding the trimmed Buffer and relying on the replacement-char
+    // fallback in TextDecoder (implicit via toString).
+    const buf = Buffer.from(input, "utf-8").subarray(0, budget);
+    return `${buf.toString("utf-8")}${marker}`;
+}
+export function writeCompactionSnapshot(baseDir, opts = {}) {
+    const memories = safeGetMemories();
+    const execHistory = safeListExec(baseDir);
+    const content = buildSnapshot({
+        memories,
+        execHistory,
+        generatedAt: (opts.now ?? (() => new Date()))(),
+        activeContext: opts.activeContext ?? null,
+    }, opts);
+    const gsdDir = resolve(baseDir, ".gsd");
+    if (!existsSync(gsdDir))
+        mkdirSync(gsdDir, { recursive: true });
+    const path = resolve(gsdDir, SNAPSHOT_FILENAME);
+    const finalContent = `${content}\n`;
+    writeFileSync(path, finalContent, "utf-8");
+    return {
+        path,
+        bytes: Buffer.byteLength(finalContent, "utf-8"),
+        memories: memories.length,
+        execRuns: execHistory.length,
+    };
+}
+export function readCompactionSnapshot(baseDir) {
+    const path = resolve(baseDir, ".gsd", SNAPSHOT_FILENAME);
+    if (!existsSync(path))
+        return null;
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function safeGetMemories() {
+    try {
+        return getActiveMemoriesRanked(12);
+    }
+    catch {
+        return [];
+    }
+}
+function safeListExec(baseDir) {
+    try {
+        return listExecHistory(baseDir);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/resources/extensions/gsd/complexity-classifier.js

@@ -8,10 +8,12 @@ import { getAdaptiveTierAdjustment } from "./routing-history.js";
 import { parseUnitId } from "./unit-id.js";
 // ─── Unit Type → Default Tier Mapping ────────────────────────────────────────
 const UNIT_TYPE_TIERS = {
-    // Tier 1 — Light: structured summaries, completion, UAT
-    "complete-slice": "light",
+    // Tier 1 — Light: compact verification turns
     "run-uat": "light",
-    // Tier 2 — Standard: research, routine discussion
+    // Tier 2 — Standard: research, routine discussion, slice completion
+    // complete-slice can carry large inlined context; avoid routing it to the
+    // cheapest "light" model by default (#4520).
+    "complete-slice": "standard",
     "discuss-milestone": "standard",
     "discuss-slice": "standard",
     "research-milestone": "standard",

package/dist/resources/extensions/gsd/error-classifier.js

@@ -22,18 +22,35 @@ const PERMANENT_RE = /auth|unauthorized|forbidden|invalid.*key|invalid.*api|bill
 // Include provider-specific quota-window phrasing like:
 // - "You've hit your limit"
 // - "usage limit" / "quota reached"
-const RATE_LIMIT_RE = /rate.?limit|too many requests|429|hit your limit|usage limit|quota (?:reached|hit)|limit.*resets?/i;
+// - "out of extra usage"
+const RATE_LIMIT_RE = /rate.?limit|too many requests|429|hit your limit|usage limit|out of extra usage|quota (?:reached|hit)|limit.*resets?/i;
 // OpenRouter affordability-style quota errors should be treated as transient
 // so core retry logic can lower maxTokens and continue in-session.
 const AFFORDABILITY_RE = /requires more credits|can only afford|insufficient credits|not enough credits|fewer max_tokens/i;
-const NETWORK_RE = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns|unexpected eof/i;
-const SERVER_RE = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i;
+// "Stream idle timeout" and "partial response received" are emitted by the SDK/harness
+// for mid-stream disconnects. Both indicate a transient network-level interruption.
+// See: https://github.com/gsd-build/gsd-2/issues/4558
+const NETWORK_RE = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns|unexpected eof|stream idle timeout|partial response received/i;
+// Context overflow errors (context window/length exceeded) should be treated as server-class
+// transient errors so auto-mode can retry with reduced budget or fall back to a larger-context model.
+// See: https://github.com/gsd-build/gsd-2/issues/4528
+const SERVER_RE = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable|context (?:window|length) exceed|context window exceed/i;
 // ECONNRESET/ECONNREFUSED are in NETWORK_RE (same-model retry first).
 const CONNECTION_RE = /terminated|connection.?(?:refused|error)|other side closed|EPIPE|network.?(?:is\s+)?unavailable|stream_exhausted(?:_without_result)?/i;
 // Catch-all for V8 JSON.parse errors: all modern variants end with "in JSON at position \d+".
 // This eliminates the need to enumerate every error message variant individually.
 const STREAM_RE = /in JSON at position \d+|Unexpected end of JSON|SyntaxError.*JSON/i;
 const RESET_DELAY_RE = /reset in (\d+)s/i;
+// Provider-side model entitlement rejection: the SDK accepted the model switch,
+// but the provider refused at request time because the current account/plan/tier
+// cannot use that model.  Must match all three of: a model/deployment token,
+// a negative-entitlement indicator, and an account/plan/tier/subscription token.
+// Requiring all three keeps generic "account suspended" errors in `permanent`
+// (no model token) while catching the phrasings providers actually use.
+// See issue #4513.
+const UNSUPPORTED_MODEL_MODEL_RE = /\b(?:model|deployment)\b/i;
+const UNSUPPORTED_MODEL_INDICATOR_RE = /\bnot support(?:ed|s)?\b|\bunsupported\b|\bnot available\b|\bunavailable\b|\bno access\b|\bdoes(?:n['’]t| not) (?:have access|support)\b|\bnot authori[sz]ed\b/i;
+const UNSUPPORTED_MODEL_SCOPE_RE = /\b(?:account|plan|tier|subscription)\b/i;
 /**
  * Classify an error message into one of the ErrorClass kinds.
  *
@@ -49,6 +66,17 @@ const RESET_DELAY_RE = /reset in (\d+)s/i;
 export function classifyError(errorMsg, retryAfterMs) {
     const isPermanent = PERMANENT_RE.test(errorMsg);
     const isRateLimit = RATE_LIMIT_RE.test(errorMsg) || AFFORDABILITY_RE.test(errorMsg);
+    const isUnsupportedModel = UNSUPPORTED_MODEL_MODEL_RE.test(errorMsg) &&
+        UNSUPPORTED_MODEL_INDICATOR_RE.test(errorMsg) &&
+        UNSUPPORTED_MODEL_SCOPE_RE.test(errorMsg);
+    // 0. Unsupported model (account/plan entitlement rejection) — checked before
+    //    `permanent` because PERMANENT_RE also matches /account/i and would
+    //    otherwise swallow these errors, blocking the blocklist-driven fallback.
+    //    Rate limit still wins when both patterns appear (a throttled account is
+    //    not an entitlement failure).
+    if (isUnsupportedModel && !isRateLimit) {
+        return { kind: "unsupported-model" };
+    }
     // 1. Permanent — but rate limit takes precedence
     if (isPermanent && !isRateLimit) {
         return { kind: "permanent" };