gsd-pi 2.76.0 → 2.77.0

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/db-writer.js

@@ -205,6 +205,19 @@ export async function nextDecisionId() {
         return 'D001';
     }
 }
+/** Synchronous variant for use inside db.transaction(). */
+function nextDecisionIdSync(adapter) {
+    if (!adapter)
+        return 'D001';
+    const row = adapter
+        .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM decisions')
+        .get();
+    const maxNum = row ? row['max_num'] : null;
+    if (maxNum == null || isNaN(maxNum))
+        return 'D001';
+    const next = maxNum + 1;
+    return `D${String(next).padStart(3, '0')}`;
+}
 // ─── Next Requirement ID ─────────────────────────────────────────────────
 /**
  * Compute the next requirement ID from the current DB state.
@@ -318,32 +331,44 @@ export async function saveRequirementToDb(fields, basePath) {
         throw err;
     }
 }
+// ─── Async Mutex for Decision Saves ───────────────────────────────────────
+//
+// Serializes the entire saveDecisionToDb operation (ID generation + DB upsert
+// + file read + markdown regeneration + file write) so that parallel callers
+// cannot interleave and produce a last-writer-wins race on DECISIONS.md.
+let _decisionSaveLock = Promise.resolve();
+/** Reset the mutex — only for tests. */
+export function _resetDecisionSaveLock() {
+    _decisionSaveLock = Promise.resolve();
+}
 /**
  * Save a new decision to DB and regenerate DECISIONS.md.
  * Auto-assigns the next ID via nextDecisionId().
  *
- * The ID computation (SELECT MAX) and insert are wrapped in a single
- * transaction to prevent parallel tool calls from computing the same ID
- * and silently overwriting each other (#3326, #3339, #3459).
+ * Concurrency: uses an async mutex (promise chain) to serialize the entire
+ * operation — ID generation, DB upsert, file read, markdown regeneration,
+ * and file write — preventing parallel callers from overwriting each other's
+ * output (last-writer-wins race condition).
  *
  * Returns the assigned ID.
  */
 export async function saveDecisionToDb(fields, basePath) {
+    // Serialize via async mutex: each call waits for the previous one to
+    // complete before starting, preventing interleaved DB + file writes.
+    let release;
+    const prev = _decisionSaveLock;
+    _decisionSaveLock = new Promise(r => { release = r; });
+    try {
+        await prev;
+    }
+    catch {
+        // Previous call failed — proceed regardless; the lock chain must continue.
+    }
     try {
         const db = await import('./gsd-db.js');
-        // Atomic ID assignment + insert inside a transaction to prevent
-        // parallel calls from racing on the same MAX(id) value.
+        const adapter = db._getAdapter();
         const id = db.transaction(() => {
-            const adapter = db._getAdapter();
-            if (!adapter)
-                throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-            const row = adapter
-                .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM decisions')
-                .get();
-            const maxNum = row ? row['max_num'] : null;
-            const nextId = (maxNum == null || isNaN(maxNum))
-                ? 'D001'
-                : `D${String(maxNum + 1).padStart(3, '0')}`;
+            const nextId = nextDecisionIdSync(adapter);
             db.upsertDecision({
                 id: nextId,
                 when_context: fields.when_context ?? '',
@@ -359,7 +384,6 @@ export async function saveDecisionToDb(fields, basePath) {
             return nextId;
         });
         // Fetch all decisions (including superseded for the full register)
-        const adapter = db._getAdapter();
         let allDecisions = [];
         if (adapter) {
             const rows = adapter.prepare('SELECT * FROM decisions ORDER BY seq').all();
@@ -434,12 +458,60 @@ export async function saveDecisionToDb(fields, basePath) {
         invalidateStateCache();
         clearPathCache();
         clearParseCache();
+        // ADR-013 dual-write: keep the memory store in sync with every decision
+        // persisted via the legacy gsd_save_decision path. Without this, prompts
+        // that still call gsd_save_decision (discuss.md, plan-milestone.md,
+        // guided-plan-slice.md, et al. during the deprecation window) would
+        // create decisions rows invisible to memory_query and loadMemoryBlock.
+        // Best-effort — never throw, never roll back the decision on failure.
+        try {
+            const { createMemory } = await import('./memory-store.js');
+            const decisionText = (fields.decision ?? '').trim();
+            const choiceText = (fields.choice ?? '').trim();
+            const rationaleText = (fields.rationale ?? '').trim();
+            const contentParts = [];
+            if (decisionText)
+                contentParts.push(decisionText);
+            if (choiceText)
+                contentParts.push(`Chose: ${choiceText}.`);
+            if (rationaleText)
+                contentParts.push(`Rationale: ${rationaleText}.`);
+            const content = contentParts.join(' ').slice(0, 600);
+            if (content) {
+                createMemory({
+                    category: 'architecture',
+                    content,
+                    scope: fields.scope || 'project',
+                    confidence: 0.85,
+                    structuredFields: {
+                        sourceDecisionId: id,
+                        when_context: fields.when_context ?? '',
+                        scope: fields.scope,
+                        decision: fields.decision,
+                        choice: fields.choice,
+                        rationale: fields.rationale,
+                        made_by: fields.made_by ?? 'agent',
+                        revisable: fields.revisable ?? '',
+                    },
+                });
+            }
+        }
+        catch (mirrorErr) {
+            logError('manifest', 'memory-store mirror write failed (non-fatal)', {
+                fn: 'saveDecisionToDb',
+                decisionId: id,
+                error: String(mirrorErr.message),
+            });
+        }
         return { id };
     }
     catch (err) {
         logError('manifest', 'saveDecisionToDb failed', { fn: 'saveDecisionToDb', error: String(err.message) });
         throw err;
     }
+    finally {
+        release();
+    }
 }
 /**
  * Extract a milestone/slice reference from a deferral decision.

package/dist/resources/extensions/gsd/doctor-git-checks.js

@@ -2,7 +2,7 @@ import { existsSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs
 import { join, sep } from "node:path";
 import { loadFile } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap } from "./parsers-legacy.js";
-import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
+import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { resolveMilestoneFile } from "./paths.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
 import { listWorktrees, resolveGitDir, worktreesDir } from "./worktree-manager.js";
@@ -48,6 +48,21 @@ function isSameOrNestedPath(candidate, container) {
     return normalizedCandidate === normalizedContainer ||
         normalizedCandidate.startsWith(`${normalizedContainer}/`);
 }
+async function isCompletedMilestoneTerminal(basePath, milestoneId) {
+    const summaryPath = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
+    if (!summaryPath)
+        return false;
+    if (isDbAvailable()) {
+        const milestone = getMilestone(milestoneId);
+        return !!milestone && milestone.status === "complete";
+    }
+    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+    const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
+    if (!roadmapContent)
+        return false;
+    const roadmap = parseLegacyRoadmap(roadmapContent);
+    return isMilestoneComplete(roadmap);
+}
 export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode = "none") {
     // Degrade gracefully if not a git repo
     if (!nativeIsRepo(basePath)) {
@@ -67,23 +82,9 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                 // Extract milestone ID from branch name "milestone/M001" → "M001"
                 const milestoneId = wt.branch.replace(/^milestone\//, "");
                 const milestoneEntry = state.registry.find(m => m.id === milestoneId);
-                // Check if milestone is complete via roadmap
-                let isComplete = false;
-                if (milestoneEntry) {
-                    if (isDbAvailable()) {
-                        const dbSlices = getMilestoneSlices(milestoneId);
-                        isComplete = dbSlices.length > 0 && dbSlices.every(s => s.status === "complete");
-                    }
-                    else {
-                        const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
-                        const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-                        if (roadmapContent) {
-                            const roadmap = parseLegacyRoadmap(roadmapContent);
-                            isComplete = isMilestoneComplete(roadmap);
-                        }
-                    }
-                    // When DB unavailable and no roadmap, isComplete stays false
-                }
+                const isComplete = milestoneEntry
+                    ? await isCompletedMilestoneTerminal(basePath, milestoneId)
+                    : false;
                 if (isComplete) {
                     issues.push({
                         severity: "warning",
@@ -136,17 +137,10 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                         const milestoneId = branch.replace(/^milestone\//, "");
                         const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
                         let branchMilestoneComplete = false;
-                        if (isDbAvailable()) {
-                            const dbSlices = getMilestoneSlices(milestoneId);
-                            branchMilestoneComplete = dbSlices.length > 0 && dbSlices.every(s => s.status === "complete");
-                        }
-                        else {
-                            const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-                            if (!roadmapContent)
-                                continue;
-                            const roadmap = parseLegacyRoadmap(roadmapContent);
-                            branchMilestoneComplete = isMilestoneComplete(roadmap);
-                        }
+                        const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
+                        if (!roadmapContent)
+                            continue;
+                        branchMilestoneComplete = await isCompletedMilestoneTerminal(basePath, milestoneId);
                         if (branchMilestoneComplete) {
                             issues.push({
                                 severity: "info",

package/dist/resources/extensions/gsd/doctor-providers.js

@@ -10,8 +10,8 @@
  *   - Remote questions channel if configured (Slack/Discord/Telegram token)
  *   - Optional search/tool integrations (Brave, Tavily, Jina, Context7)
  */
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { delimiter, join } from "node:path";
 import { AuthStorage } from "@gsd/pi-coding-agent";
 import { getEnvApiKey } from "@gsd/pi-ai";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
@@ -47,7 +47,8 @@ function modelToProviderId(model) {
         return null;
     // Explicit provider prefix (e.g. "openrouter/deepseek-r1")
     if (model.includes("/")) {
-        const prefix = model.split("/")[0].toLowerCase();
+        const rawPrefix = model.split("/")[0];
+        const prefix = rawPrefix.toLowerCase();
         // Map known prefixes to registry IDs
         const prefixMap = {
             "anthropic-vertex": "anthropic-vertex",
@@ -62,6 +63,7 @@ function modelToProviderId(model) {
         };
         if (prefixMap[prefix])
             return prefixMap[prefix];
+        return rawPrefix;
     }
     const lower = model.toLowerCase();
     if (lower.startsWith("claude"))
@@ -136,8 +138,49 @@ function isCliBinaryInPath(providerId) {
     const binary = CLI_BINARY_MAP[providerId];
     if (!binary)
         return false;
-    const pathDirs = (process.env.PATH ?? "").split(":");
-    return pathDirs.some(dir => dir && existsSync(join(dir, binary)));
+    const pathDirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+    // On Windows, command shims are commonly installed as .cmd/.exe/.bat/.com.
+    // Scan PATHEXT candidates in addition to the bare binary name.
+    const executableNames = [binary];
+    if (process.platform === "win32") {
+        const rawPathExt = process.env.PATHEXT
+            ?.split(";")
+            .map(ext => ext.trim())
+            .filter(Boolean) ?? [];
+        const normalizedPathExt = rawPathExt.map(ext => ext.startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`);
+        const defaultExt = [".exe", ".cmd", ".bat", ".com"];
+        for (const ext of [...normalizedPathExt, ...defaultExt]) {
+            const candidate = `${binary}${ext}`;
+            if (!executableNames.includes(candidate))
+                executableNames.push(candidate);
+        }
+    }
+    return pathDirs.some(dir => executableNames.some(name => existsSync(join(dir, name))));
+}
+function modelsJsonPaths() {
+    const home = process.env.HOME ?? "~";
+    return [
+        join(home, ".gsd", "agent", "models.json"),
+        // Keep parity with custom-provider discovery during auto bootstrap.
+        join(home, ".pi", "agent", "models.json"),
+    ];
+}
+function hasModelsJsonApiKey(providerId) {
+    for (const path of modelsJsonPaths()) {
+        if (!existsSync(path))
+            continue;
+        try {
+            const parsed = JSON.parse(readFileSync(path, "utf-8"));
+            const apiKey = parsed.providers?.[providerId]?.apiKey;
+            if (typeof apiKey === "string" && apiKey.trim().length > 0) {
+                return true;
+            }
+        }
+        catch {
+            // Malformed models.json should not break the dashboard health check.
+        }
+    }
+    return false;
 }
 function resolveKey(providerId) {
     const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
@@ -182,6 +225,9 @@ function resolveKey(providerId) {
     if (info?.envVar && process.env[info.envVar]) {
         return { found: true, source: "env", backedOff: false };
     }
+    if (hasModelsJsonApiKey(providerId)) {
+        return { found: true, source: "models.json", backedOff: false };
+    }
     return { found: false, source: "none", backedOff: false };
 }
 // ── Individual check groups ────────────────────────────────────────────────────

package/dist/resources/extensions/gsd/ecosystem/gsd-extension-api.js

@@ -101,6 +101,7 @@ export function createGSDExtensionAPI(pi, sharedHandlers) {
         // ── Event emission ─────────────────────────────────────────────────
         emitBeforeModelSelect: (...args) => pi.emitBeforeModelSelect(...args),
         emitAdjustToolSet: (...args) => pi.emitAdjustToolSet(...args),
+        emitExtensionEvent: (...args) => pi.emitExtensionEvent(...args),
         // ── Tool / command / shortcut / flag registration ──────────────────
         registerTool: ((tool) => pi.registerTool(tool)),
         registerCommand: (...args) => pi.registerCommand(...args),

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" };

package/dist/resources/extensions/gsd/exec-history.js

@@ -0,0 +1,120 @@
+// GSD Exec History — read-side helpers for the exec sandbox.
+//
+// Pure I/O: scans `.gsd/exec/*.meta.json` under a base directory and
+// returns lightweight records. Used by the gsd_exec_search tool and
+// any future compaction-snapshot enrichment.
+import { closeSync, openSync, readdirSync, readFileSync, readSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+function listMetaFiles(baseDir) {
+    const dir = resolve(baseDir, ".gsd", "exec");
+    try {
+        return readdirSync(dir)
+            .filter((name) => name.endsWith(".meta.json"))
+            .map((name) => join(dir, name));
+    }
+    catch {
+        return [];
+    }
+}
+function safeReadMeta(path) {
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.id !== "string" || typeof parsed.runtime !== "string")
+            return null;
+        return {
+            id: parsed.id,
+            runtime: parsed.runtime,
+            purpose: typeof parsed.purpose === "string" ? parsed.purpose : null,
+            started_at: typeof parsed.started_at === "string" ? parsed.started_at : "",
+            finished_at: typeof parsed.finished_at === "string" ? parsed.finished_at : "",
+            duration_ms: typeof parsed.duration_ms === "number" ? parsed.duration_ms : 0,
+            exit_code: typeof parsed.exit_code === "number" ? parsed.exit_code : null,
+            signal: typeof parsed.signal === "string" ? parsed.signal : null,
+            timed_out: parsed.timed_out === true,
+            stdout_bytes: typeof parsed.stdout_bytes === "number" ? parsed.stdout_bytes : 0,
+            stderr_bytes: typeof parsed.stderr_bytes === "number" ? parsed.stderr_bytes : 0,
+            stdout_truncated: parsed.stdout_truncated === true,
+            stderr_truncated: parsed.stderr_truncated === true,
+            stdout_path: path.replace(/\.meta\.json$/, ".stdout"),
+            stderr_path: path.replace(/\.meta\.json$/, ".stderr"),
+            meta_path: path,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function listExecHistory(baseDir) {
+    const metas = listMetaFiles(baseDir)
+        .map((path) => {
+        let mtime = 0;
+        try {
+            mtime = statSync(path).mtimeMs;
+        }
+        catch {
+            /* ignore */
+        }
+        const entry = safeReadMeta(path);
+        return entry ? { entry, mtime } : null;
+    })
+        .filter((value) => value !== null);
+    metas.sort((a, b) => b.mtime - a.mtime);
+    return metas.map((m) => m.entry);
+}
+function matchesFilters(entry, opts) {
+    if (opts.runtime && entry.runtime !== opts.runtime)
+        return false;
+    if (opts.failing_only) {
+        const failed = entry.timed_out || (entry.exit_code !== 0 && entry.exit_code !== null);
+        if (!failed)
+            return false;
+    }
+    const query = (opts.query ?? "").trim().toLowerCase();
+    if (!query)
+        return true;
+    const haystack = `${entry.id} ${entry.purpose ?? ""}`.toLowerCase();
+    return haystack.includes(query);
+}
+function readDigestPreview(entry, maxChars) {
+    if (!entry.stdout_path || maxChars <= 0)
+        return undefined;
+    try {
+        const size = statSync(entry.stdout_path).size;
+        if (size === 0)
+            return undefined;
+        const readBytes = Math.min(size, maxChars * 4); // 4 bytes/char upper bound for UTF-8
+        const buf = Buffer.allocUnsafe(readBytes);
+        const fd = openSync(entry.stdout_path, "r");
+        try {
+            const bytesRead = readSync(fd, buf, 0, readBytes, Math.max(0, size - readBytes));
+            const text = buf.subarray(0, bytesRead).toString("utf-8");
+            const trimmed = text.trimEnd();
+            return trimmed.length <= maxChars ? trimmed : trimmed.slice(trimmed.length - maxChars);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+export function searchExecHistory(baseDir, opts = {}) {
+    const limit = clampLimit(opts.limit, 20, 200);
+    const entries = listExecHistory(baseDir);
+    const filtered = entries.filter((entry) => matchesFilters(entry, opts));
+    return filtered.slice(0, limit).map((entry) => ({
+        entry,
+        digest_preview: readDigestPreview(entry, 300),
+    }));
+}
+function clampLimit(value, fallback, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    if (value < 1)
+        return 1;
+    if (value > max)
+        return max;
+    return Math.floor(value);
+}