gsd-pi 2.76.0 → 2.77.0-dev.538325aea

package/src/resources/extensions/gsd/compaction-snapshot.ts

@@ -0,0 +1,165 @@
+// 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, type Memory } from "./memory-store.js";
+import { listExecHistory, type ExecHistoryEntry } from "./exec-history.js";
+
+export const DEFAULT_SNAPSHOT_BYTES = 2048;
+export const SNAPSHOT_FILENAME = "last-snapshot.md";
+
+export interface SnapshotSources {
+  memories: Memory[];
+  execHistory: ExecHistoryEntry[];
+  generatedAt: Date;
+  /** Optional free-form context string (e.g. active unit id). */
+  activeContext?: string | null;
+}
+
+export interface BuildSnapshotOptions {
+  /** Hard cap in bytes (UTF-8). Default 2048. */
+  maxBytes?: number;
+  /** Memory count cap before truncation (default 6). */
+  maxMemories?: number;
+  /** Exec history cap (default 5). */
+  maxExec?: number;
+}
+
+/**
+ * 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: SnapshotSources, opts: BuildSnapshotOptions = {}): string {
+  const maxBytes = opts.maxBytes ?? DEFAULT_SNAPSHOT_BYTES;
+  const maxMemories = opts.maxMemories ?? 6;
+  const maxExec = opts.maxExec ?? 5;
+
+  const lines: string[] = [];
+  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: string, maxBytes: number): string {
+  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 interface WriteSnapshotOptions extends BuildSnapshotOptions {
+  activeContext?: string | null;
+  now?: () => Date;
+}
+
+export interface WriteSnapshotResult {
+  path: string;
+  bytes: number;
+  memories: number;
+  execRuns: number;
+}
+
+export function writeCompactionSnapshot(
+  baseDir: string,
+  opts: WriteSnapshotOptions = {},
+): WriteSnapshotResult {
+  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: string): string | null {
+  const path = resolve(baseDir, ".gsd", SNAPSHOT_FILENAME);
+  if (!existsSync(path)) return null;
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+function safeGetMemories(): Memory[] {
+  try {
+    return getActiveMemoriesRanked(12);
+  } catch {
+    return [];
+  }
+}
+
+function safeListExec(baseDir: string): ExecHistoryEntry[] {
+  try {
+    return listExecHistory(baseDir);
+  } catch {
+    return [];
+  }
+}

package/src/resources/extensions/gsd/complexity-classifier.ts

@@ -32,11 +32,13 @@ export interface TaskMetadata {
 // ─── Unit Type → Default Tier Mapping ────────────────────────────────────────
 
 const UNIT_TYPE_TIERS: Record<string, ComplexityTier> = {
-  // 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/src/resources/extensions/gsd/db-writer.ts

@@ -227,6 +227,18 @@ export async function nextDecisionId(): Promise<string> {
   }
 }
 
+/** Synchronous variant for use inside db.transaction(). */
+function nextDecisionIdSync(adapter: ReturnType<typeof import('./gsd-db.js')._getAdapter>): string {
+  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'] as number | null) : null;
+  if (maxNum == null || isNaN(maxNum)) return 'D001';
+  const next = maxNum + 1;
+  return `D${String(next).padStart(3, '0')}`;
+}
+
 // ─── Next Requirement ID ─────────────────────────────────────────────────
 
 /**
@@ -363,6 +375,18 @@ export async function saveRequirementToDb(
   }
 }
 
+// ─── 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<unknown> = Promise.resolve();
+
+/** Reset the mutex — only for tests. */
+export function _resetDecisionSaveLock(): void {
+  _decisionSaveLock = Promise.resolve();
+}
+
 // ─── Save Decision to DB + Regenerate Markdown ────────────────────────────
 
 export interface SaveDecisionFields {
@@ -381,9 +405,10 @@ export interface SaveDecisionFields {
  * 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.
  */
@@ -391,23 +416,25 @@ export async function saveDecisionToDb(
   fields: SaveDecisionFields,
   basePath: string,
 ): Promise<{ id: string }> {
+  // Serialize via async mutex: each call waits for the previous one to
+  // complete before starting, preventing interleaved DB + file writes.
+  let release: () => void;
+  const prev = _decisionSaveLock;
+  _decisionSaveLock = new Promise<void>(r => { release = r; });
+
   try {
-    const db = await import('./gsd-db.js');
+    await prev;
+  } catch {
+    // Previous call failed — proceed regardless; the lock chain must continue.
+  }
 
-    // Atomic ID assignment + insert inside a transaction to prevent
-    // parallel calls from racing on the same MAX(id) value.
-    const id = db.transaction(() => {
-      const adapter = db._getAdapter();
-      if (!adapter) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  try {
+    const db = await import('./gsd-db.js');
 
-      const row = adapter
-        .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM decisions')
-        .get();
-      const maxNum = row ? (row['max_num'] as number | null) : null;
-      const nextId = (maxNum == null || isNaN(maxNum))
-        ? 'D001'
-        : `D${String(maxNum + 1).padStart(3, '0')}`;
+    const adapter = db._getAdapter();
 
+    const id = db.transaction(() => {
+      const nextId = nextDecisionIdSync(adapter);
       db.upsertDecision({
         id: nextId,
         when_context: fields.when_context ?? '',
@@ -421,11 +448,11 @@ export async function saveDecisionToDb(
         superseded_by: null,
       });
 
+
       return nextId;
     });
 
     // Fetch all decisions (including superseded for the full register)
-    const adapter = db._getAdapter();
     let allDecisions: Decision[] = [];
     if (adapter) {
       const rows = adapter.prepare('SELECT * FROM decisions ORDER BY seq').all();
@@ -502,10 +529,54 @@ export async function saveDecisionToDb(
     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: string[] = [];
+      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 as Error).message),
+      });
+    }
+
     return { id };
   } catch (err) {
     logError('manifest', 'saveDecisionToDb failed', { fn: 'saveDecisionToDb', error: String((err as Error).message) });
     throw err;
+  } finally {
+    release!();
   }
 }
 

package/src/resources/extensions/gsd/dispatch-guard.ts

@@ -3,11 +3,30 @@
 import { resolveMilestoneFile } from "./paths.js";
 import { findMilestoneIds } from "./guided-flow.js";
 import { parseUnitId } from "./unit-id.js";
-import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getMilestone } from "./gsd-db.js";
 import { parseRoadmap } from "./parsers-legacy.js";
 import { isClosedStatus } from "./status-guards.js";
 import { readFileSync } from "node:fs";
 
+/**
+ * Detect failure-path milestone SUMMARY content (#4663 sibling to #4658).
+ * A failure SUMMARY must not let the dispatch guard treat an active
+ * milestone as complete. The markers mirror those produced by
+ * writeBlockerPlaceholder and the "verification FAILED" retry path.
+ *
+ * This is intentionally a minimal local detector so this fix does not
+ * depend on PR #4660's `classifyMilestoneSummaryContent`. It can migrate
+ * to the shared classifier once that lands.
+ */
+function isFailureMilestoneSummary(content: string): boolean {
+  return (
+    /(?:^|\n)\s*#\s*BLOCKER\b/i.test(content) ||
+    /auto-mode recovery failed/i.test(content) ||
+    /verification\s+failed/i.test(content) ||
+    /\bnot complete\b/i.test(content)
+  );
+}
+
 const SLICE_DISPATCH_TYPES = new Set([
   "research-slice",
   "plan-slice",
@@ -47,7 +66,30 @@ export function getPriorSliceCompletionBlocker(
 
   for (const mid of milestoneIds) {
     if (resolveMilestoneFile(base, mid, "PARKED")) continue;
-    if (resolveMilestoneFile(base, mid, "SUMMARY")) continue;
+
+    // DB/SUMMARY completion check (#4663 sibling to #4658).
+    // Prior behavior treated any SUMMARY file on disk as proof of milestone
+    // completion, which is wrong when the SUMMARY is a failure-path report
+    // (verification FAILED, blocker placeholder, etc.). Resolve as follows:
+    //   1. When DB is available and status is closed → skip (authoritative).
+    //   2. When SUMMARY exists but looks like a failure/blocker report →
+    //      do not short-circuit; fall through to the slice-level check so
+    //      the guard can still block dependents of an active milestone.
+    //   3. Otherwise (SUMMARY without failure markers) → skip. Preserves
+    //      the #1716 contract where a completed milestone with unchecked
+    //      remediation slices is still treated as done.
+    const summaryPath = resolveMilestoneFile(base, mid, "SUMMARY");
+    if (isDbAvailable()) {
+      const milestoneRow = getMilestone(mid);
+      if (milestoneRow && isClosedStatus(milestoneRow.status)) continue;
+    }
+    if (summaryPath) {
+      let summaryContent: string | null = null;
+      try { summaryContent = readFileSync(summaryPath, "utf-8"); } catch { /* ignore */ }
+      if (!summaryContent || !isFailureMilestoneSummary(summaryContent)) {
+        continue;
+      }
+    }
 
     // Normalised slice list from DB or file fallback
     type NormSlice = { id: string; done: boolean; depends: string[] };

package/src/resources/extensions/gsd/doctor-git-checks.ts

@@ -4,7 +4,7 @@ import { join, sep } from "node:path";
 import type { DoctorIssue, DoctorIssueCode } from "./doctor-types.js";
 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";
@@ -52,6 +52,22 @@ function isSameOrNestedPath(candidate: string, container: string): boolean {
     normalizedCandidate.startsWith(`${normalizedContainer}/`);
 }
 
+async function isCompletedMilestoneTerminal(basePath: string, milestoneId: string): Promise<boolean> {
+  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: string,
   issues: DoctorIssue[],
@@ -81,23 +97,9 @@ export async function checkGitHealth(
       // 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({
@@ -151,15 +153,9 @@ export async function checkGitHealth(
           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/src/resources/extensions/gsd/doctor-providers.ts

@@ -11,8 +11,8 @@
  *   - 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";
@@ -72,7 +72,8 @@ function modelToProviderId(model: string): string | 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: Record<string, string> = {
       "anthropic-vertex": "anthropic-vertex",
@@ -86,6 +87,7 @@ function modelToProviderId(model: string): string | null {
       "github-copilot": "github-copilot",
     };
     if (prefixMap[prefix]) return prefixMap[prefix];
+    return rawPrefix;
   }
 
   const lower = model.toLowerCase();
@@ -145,7 +147,7 @@ function collectConfiguredModelProviders(): Set<string> {
 
 interface KeyLookup {
   found: boolean;
-  source: "auth.json" | "env" | "none";
+  source: "auth.json" | "env" | "models.json" | "none";
   backedOff: boolean;
 }
 
@@ -167,8 +169,55 @@ const CLI_BINARY_MAP: Record<string, string> = {
 function isCliBinaryInPath(providerId: string): boolean {
   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: string[] = [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(): string[] {
+  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: string): boolean {
+  for (const path of modelsJsonPaths()) {
+    if (!existsSync(path)) continue;
+    try {
+      const parsed = JSON.parse(readFileSync(path, "utf-8")) as {
+        providers?: Record<string, { apiKey?: unknown }>;
+      };
+      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: string): KeyLookup {
@@ -221,6 +270,10 @@ function resolveKey(providerId: string): KeyLookup {
     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 };
 }
 

package/src/resources/extensions/gsd/ecosystem/gsd-extension-api.ts

@@ -160,6 +160,8 @@ export function createGSDExtensionAPI(
       pi.emitBeforeModelSelect(...args),
     emitAdjustToolSet: (...args: Parameters<ExtensionAPI["emitAdjustToolSet"]>) =>
       pi.emitAdjustToolSet(...args),
+    emitExtensionEvent: (...args: Parameters<ExtensionAPI["emitExtensionEvent"]>) =>
+      pi.emitExtensionEvent(...args),
 
     // ── Tool / command / shortcut / flag registration ──────────────────
     registerTool: ((tool: any) => pi.registerTool(tool)) as ExtensionAPI["registerTool"],

package/src/resources/extensions/gsd/error-classifier.ts

@@ -19,6 +19,7 @@ export type ErrorClass =
   | { kind: "stream";       retryAfterMs: number }
   | { kind: "connection";   retryAfterMs: number }
   | { kind: "model-error" }
+  | { kind: "unsupported-model" }
   | { kind: "permanent" }
   | { kind: "unknown" };
 
@@ -46,12 +47,19 @@ 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+".
@@ -59,6 +67,18 @@ const CONNECTION_RE = /terminated|connection.?(?:refused|error)|other side close
 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.
  *
@@ -74,6 +94,19 @@ const RESET_DELAY_RE = /reset in (\d+)s/i;
 export function classifyError(errorMsg: string, retryAfterMs?: number): ErrorClass {
   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) {