gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -186,6 +186,45 @@ test("flat_rate_providers is a recognized preference key (no warning)", () => {
   );
 });
 
+test("slice_parallel preferences validate and pass through", () => {
+  const { preferences, errors, warnings } = validatePreferences({
+    slice_parallel: { enabled: true, max_workers: 8 },
+  });
+
+  assert.equal(errors.length, 0);
+  assert.equal(warnings.filter(w => w.includes("slice_parallel")).length, 0);
+  assert.deepEqual(preferences.slice_parallel, { enabled: true, max_workers: 8 });
+});
+
+test("slice_parallel rejects invalid values and warns on unknown keys", () => {
+  const { preferences, errors, warnings } = validatePreferences({
+    slice_parallel: {
+      enabled: "yes",
+      max_workers: 9,
+      future_mode: true,
+    },
+  } as any);
+
+  assert.ok(errors.some(e => e.includes("slice_parallel.enabled")), "should reject non-boolean enabled");
+  assert.ok(errors.some(e => e.includes("slice_parallel.max_workers")), "should reject max_workers outside 1..8");
+  assert.ok(warnings.some(w => w.includes('unknown slice_parallel key "future_mode"')));
+  assert.equal(preferences.slice_parallel, undefined);
+});
+
+test("slice_parallel numeric max_workers is bounded to 1..8", () => {
+  const low = validatePreferences({ slice_parallel: { max_workers: 1 } });
+  const high = validatePreferences({ slice_parallel: { max_workers: 8 } });
+  const tooLow = validatePreferences({ slice_parallel: { max_workers: 0 } });
+  const tooHigh = validatePreferences({ slice_parallel: { max_workers: 9 } });
+
+  assert.equal(low.errors.length, 0);
+  assert.equal(low.preferences.slice_parallel?.max_workers, 1);
+  assert.equal(high.errors.length, 0);
+  assert.equal(high.preferences.slice_parallel?.max_workers, 8);
+  assert.ok(tooLow.errors.some(e => e.includes("slice_parallel.max_workers")));
+  assert.ok(tooHigh.errors.some(e => e.includes("slice_parallel.max_workers")));
+});
+
 test("valid values pass through correctly", () => {
   const { preferences: p1 } = validatePreferences({ budget_enforcement: "halt" });
   assert.equal(p1.budget_enforcement, "halt");
@@ -606,6 +645,44 @@ test("loadEffectiveGSDPreferences preserves experimental prefs across global+pro
   }
 });
 
+test("loadEffectiveGSDPreferences exposes slice_parallel prefs to runtime callers", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-slice-parallel-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-slice-parallel-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "slice_parallel:",
+        "  enabled: true",
+        "  max_workers: 3",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const loaded = loadEffectiveGSDPreferences();
+    assert.notEqual(loaded, null);
+    assert.equal(loaded!.preferences.slice_parallel?.enabled, true);
+    assert.equal(loaded!.preferences.slice_parallel?.max_workers, 3);
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("preferences paths use canonical uppercase filenames", () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;
@@ -632,6 +709,39 @@ test("preferences paths use canonical uppercase filenames", () => {
   }
 });
 
+test("explicit base path preference loading survives a deleted cwd (#4498)", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-base-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-base-home-"));
+  const deletedCwd = mkdtempSync(join(tmpdir(), "gsd-prefs-deleted-cwd-"));
+
+  t.after(() => {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+    rmSync(deletedCwd, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    "---\nversion: 1\nlanguage: Swedish\ngit:\n  isolation: worktree\n---\n",
+    "utf-8",
+  );
+
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(deletedCwd);
+  rmSync(deletedCwd, { recursive: true, force: true });
+
+  const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.notEqual(loaded, null);
+  assert.equal(loaded!.preferences.language, "Swedish");
+  assert.equal(getIsolationMode(tempProject), "worktree");
+});
+
 test("uppercase PREFERENCES.md wins over legacy lowercase preferences.md", () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;

package/src/resources/extensions/gsd/tests/prefs-wizard-coverage.test.ts

@@ -0,0 +1,44 @@
+// Guard test — every key in KNOWN_PREFERENCE_KEYS must be reachable from the
+// /gsd prefs wizard.  Without this guard, a new preference can be added to the
+// schema without anyone wiring it into the TUI, silently re-creating the gap
+// this test exists to prevent.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+
+import { KNOWN_PREFERENCE_KEYS } from "../preferences-types.ts";
+
+// Keys exposed via a dedicated command rather than the wizard.  They're still
+// reachable by the user, just not inside the category menu flow.  If you add a
+// new key here, add a comment explaining where it lives.
+const EXPOSED_OUTSIDE_WIZARD = new Set<string>([
+  "version",          // auto-managed by writePreferencesFile
+  "modelOverrides",   // advanced routing — edit PREFERENCES.md directly (not in KNOWN_PREFERENCE_KEYS)
+  "context_mode",     // advanced sandbox config (gsd_exec + compaction) — enabled by default; edit PREFERENCES.md directly to tune timeouts/caps. Wizard coverage tracked separately.
+]);
+
+test("every KNOWN_PREFERENCE_KEYS entry is reachable from the wizard source", () => {
+  const src = readFileSync(
+    new URL("../commands-prefs-wizard.ts", import.meta.url),
+    "utf-8",
+  );
+
+  const missing: string[] = [];
+  for (const key of KNOWN_PREFERENCE_KEYS) {
+    if (EXPOSED_OUTSIDE_WIZARD.has(key)) continue;
+    // The key must appear somewhere in the wizard — either as a direct
+    // prefs[...] / pref reference, or in the orderedKeys serialization list.
+    // A plain substring match is enough because all prefs-wizard references
+    // use the exact key name.
+    if (!src.includes(`"${key}"`) && !src.includes(`.${key}`)) {
+      missing.push(key);
+    }
+  }
+
+  assert.deepEqual(
+    missing,
+    [],
+    `These preference keys are in KNOWN_PREFERENCE_KEYS but are not referenced anywhere in the /gsd prefs wizard — they cannot be configured through the UI. Either add wizard coverage or add them to EXPOSED_OUTSIDE_WIZARD with an explanatory comment:\n${missing.join("\n")}`,
+  );
+});

package/src/resources/extensions/gsd/tests/prompt-cache-optimizer.test.ts

@@ -64,6 +64,18 @@ describe("prompt-cache-optimizer: classifySection", () => {
     assert.equal(classifySection("overrides"), "semi-static");
   });
 
+  // Regression: issue #4719 — KNOWLEDGE falls through to dynamic default.
+  // Knowledge content is reused across all tasks within a milestone, so it
+  // must be classified as semi-static to qualify for prefix caching when the
+  // cache optimizer is wired into the prompt path.
+  it("classifies knowledge as semi-static (issue #4719)", () => {
+    assert.equal(classifySection("knowledge"), "semi-static");
+  });
+
+  it("classifies project-knowledge as semi-static (issue #4719)", () => {
+    assert.equal(classifySection("project-knowledge"), "semi-static");
+  });
+
   it("classifies task-plan as dynamic", () => {
     assert.equal(classifySection("task-plan"), "dynamic");
   });

package/src/resources/extensions/gsd/tests/prompt-loader-extension-dir.test.ts

@@ -0,0 +1,49 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { join } from "node:path";
+
+import { resolveExtensionDirFromCandidates } from "../prompt-loader.ts";
+
+function makeExists(paths: Set<string>): (path: string) => boolean {
+  return (path: string) => paths.has(path);
+}
+
+test("resolveExtensionDirFromCandidates prefers user-local dir when both trees are valid", () => {
+  const moduleDir = "/npm/global/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    join(moduleDir, "templates", "task-summary.md"),
+    join(agentDir, "prompts"),
+    join(agentDir, "templates", "task-summary.md"),
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, agentDir);
+});
+
+test("resolveExtensionDirFromCandidates rejects module dir missing task-summary template", () => {
+  const moduleDir = "/npm/global/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    // Missing module templates/task-summary.md on purpose.
+    join(agentDir, "prompts"),
+    join(agentDir, "templates", "task-summary.md"),
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, agentDir);
+});
+
+test("resolveExtensionDirFromCandidates falls back to prompts-only dir when neither tree is fully valid", () => {
+  const moduleDir = "/npm/global/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    // Neither side has templates/task-summary.md.
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, moduleDir);
+});

package/src/resources/extensions/gsd/tests/prompt-step-ordering.test.ts

@@ -13,6 +13,7 @@ import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -69,11 +70,21 @@ describe('register-extension _gsdEpipeGuard (#3696)', () => {
 
 describe('register-hooks session_before_compact (#3696)', () => {
   test('session_before_compact only checks isAutoActive', () => {
-    // Extract the session_before_compact handler
-    const compactIdx = registerHooksSrc.indexOf('session_before_compact');
+    // Anchor on the full registration token rather than the bare event name —
+    // prevents matching unrelated substring occurrences.
+    const compactIdx = registerHooksSrc.indexOf('pi.on("session_before_compact"');
     assert.ok(compactIdx > -1, 'session_before_compact hook should exist');
-    // The first check in the handler should be isAutoActive(), not isAutoPaused()
-    const afterCompact = registerHooksSrc.slice(compactIdx, compactIdx + 300);
+    // The first check in the handler should be isAutoActive(), not isAutoPaused().
+    // Bound the region to this single handler — register-hooks.ts contains
+    // multiple pi.on("session_before_compact") handlers and a later handler
+    // legitimately references isAutoPaused.
+    const afterCompact = extractSourceRegion(
+      registerHooksSrc,
+      'pi.on("session_before_compact"',
+      'pi.on("',
+      // NB: endAnchor search starts AFTER the startAnchor, so the next
+      // pi.on("... matches the subsequent handler rather than this one.
+    );
     assert.match(afterCompact, /isAutoActive\(\)/,
       'session_before_compact should check isAutoActive()');
     // Should NOT block compaction when paused

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -13,7 +13,12 @@ import { fileURLToPath } from "node:url";
 import { classifyError, isTransient, isTransientNetworkError } from "../error-classifier.ts";
 import { pauseAutoForProviderError } from "../provider-error-pause.ts";
 import { resumeAutoAfterProviderDelay } from "../bootstrap/provider-error-resume.ts";
+import { MAX_TRANSIENT_AUTO_RESUMES } from "../bootstrap/agent-end-recovery.ts";
 import { getNextFallbackModel } from "../preferences.ts";
+// Zero-import module — imported by path rather than through the package
+// barrel to avoid pulling the full AgentSession / @gsd/pi-ai dep graph into
+// this unit test (see #4837).
+import { RETRYABLE_ERROR_RE } from "../../../../../packages/pi-coding-agent/src/core/retryable-error-regex.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -45,6 +50,13 @@ test("classifyError treats usage-limit phrasing as transient rate-limit (#4373)"
   assert.equal(result.kind, "rate-limit");
 });
 
+test("classifyError treats extra-usage phrasing as transient rate-limit (#4397)", () => {
+  const result = classifyError("You are out of extra usage. Please wait before retrying.");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 60_000);
+});
+
 test("classifyError treats OpenRouter affordability errors as transient rate-limit class", () => {
   const result = classifyError(
     "402 This request requires more credits, or fewer max_tokens. You requested up to 32000 tokens, but can only afford 329.",
@@ -147,6 +159,49 @@ test("classifyError: rate limit takes precedence over auth keywords", () => {
   assert.ok(isTransient(result));
 });
 
+// ── unsupported-model: account/plan entitlement rejection (#4513) ──────────
+
+test("classifyError: Codex ChatGPT-account entitlement rejection is unsupported-model", () => {
+  const result = classifyError(
+    "The 'gpt-5.1-codex-max' model is not supported when using Codex with a ChatGPT account.",
+  );
+  assert.equal(result.kind, "unsupported-model");
+  assert.ok(!isTransient(result));
+});
+
+test("classifyError: 'model not available for this plan' is unsupported-model", () => {
+  const result = classifyError("This model is not available for your current plan.");
+  assert.equal(result.kind, "unsupported-model");
+});
+
+test("classifyError: 'account does not have access to model' is unsupported-model", () => {
+  const result = classifyError("Your account does not have access to the gpt-5 model.");
+  assert.equal(result.kind, "unsupported-model");
+});
+
+test("classifyError: 'tier does not support deployment' is unsupported-model", () => {
+  const result = classifyError("The free tier does not support this deployment.");
+  assert.equal(result.kind, "unsupported-model");
+});
+
+test("classifyError: 'account suspended' stays permanent (not unsupported-model)", () => {
+  const result = classifyError("Your account has been suspended. Contact support.");
+  assert.equal(result.kind, "permanent");
+});
+
+test("classifyError: 'invalid account' stays permanent", () => {
+  const result = classifyError("invalid account credentials");
+  assert.equal(result.kind, "permanent");
+});
+
+test("classifyError: rate limit on unsupported-model phrasing stays rate-limit", () => {
+  // A throttled account is not an entitlement failure.
+  const result = classifyError(
+    "429 rate limit — model not supported when using your account right now",
+  );
+  assert.equal(result.kind, "rate-limit");
+});
+
 // ── STREAM_RE: V8 JSON parse error variants (#2916) ────────────────────────
 
 test("classifyError: 'Expected comma/brace after property value in JSON' is transient stream", () => {
@@ -354,6 +409,8 @@ test("resumeAutoAfterProviderDelay restarts paused auto-mode from the recorded b
         stepMode: true,
         basePath: "/tmp/project",
       }),
+      resetTransientRetryState: () => {},
+      resetSessionTimeoutState: () => {},
       startAuto: async (_ctx, _pi, base, verboseMode, options) => {
         startCalls.push({ base, verboseMode, step: options?.step });
       },
@@ -378,6 +435,8 @@ test("resumeAutoAfterProviderDelay does not double-start when auto-mode is alrea
         stepMode: false,
         basePath: "/tmp/project",
       }),
+      resetTransientRetryState: () => {},
+      resetSessionTimeoutState: () => {},
       startAuto: async () => {
         startCalls += 1;
       },
@@ -408,6 +467,8 @@ test("resumeAutoAfterProviderDelay leaves auto paused when no base path is avail
         stepMode: false,
         basePath: "",
       }),
+      resetTransientRetryState: () => {},
+      resetSessionTimeoutState: () => {},
       startAuto: async () => {
         startCalls += 1;
       },
@@ -424,6 +485,39 @@ test("resumeAutoAfterProviderDelay leaves auto paused when no base path is avail
   ]);
 });
 
+test("resumeAutoAfterProviderDelay resets provider retry state before restarting auto-mode", async () => {
+  const calls: string[] = [];
+
+  const result = await resumeAutoAfterProviderDelay(
+    {} as any,
+    { ui: { notify() {} } } as any,
+    {
+      getSnapshot: () => ({
+        active: false,
+        paused: true,
+        stepMode: false,
+        basePath: "/tmp/project",
+      }),
+      resetTransientRetryState: () => {
+        calls.push("reset-transient");
+      },
+      resetSessionTimeoutState: () => {
+        calls.push("reset-session-timeout");
+      },
+      startAuto: async () => {
+        calls.push("start-auto");
+      },
+    },
+  );
+
+  assert.equal(result, "resumed");
+  assert.deepEqual(calls, [
+    "reset-transient",
+    "reset-session-timeout",
+    "start-auto",
+  ]);
+});
+
 // ── Escalating backoff for transient errors (#1166) ─────────────────────────
 
 test("agent-end-recovery.ts tracks consecutive transient errors for escalating backoff", () => {
@@ -517,46 +611,29 @@ test("resetTransientRetryState is exported from agent-end-recovery.ts", () => {
   );
 });
 
-test("provider-error-resume.ts calls resetTransientRetryState before startAuto", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "provider-error-resume.ts"), "utf-8");
-  assert.ok(
-    src.includes("resetTransientRetryState"),
-    "provider-error-resume.ts must import and call resetTransientRetryState",
-  );
-  // Ensure reset is called BEFORE startAuto — order matters
-  const resetIdx = src.indexOf("resetTransientRetryState()");
-  const startIdx = src.indexOf("await deps.startAuto(");
-  assert.ok(
-    resetIdx !== -1 && startIdx !== -1 && resetIdx < startIdx,
-    "resetTransientRetryState() must be called before deps.startAuto()",
-  );
-  // Session timeout counter must also be reset before startAuto
-  assert.ok(
-    src.includes("resetSessionTimeoutState"),
-    "provider-error-resume.ts must import and call resetSessionTimeoutState",
-  );
-  const sessionResetIdx = src.indexOf("resetSessionTimeoutState()");
-  assert.ok(
-    sessionResetIdx !== -1 && startIdx !== -1 && sessionResetIdx < startIdx,
-    "resetSessionTimeoutState() must be called before deps.startAuto()",
-  );
-});
-
 // ── Fix 2: Session creation timeout treated as transient in phases.ts ───────
 
 test("phases.ts handles timeout session-creation failures with pause instead of stopAuto", () => {
   const src = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
 
-  // The cancelled + isTransient + category=timeout path must pause, not hard-stop
+  // The cancelled + isTransient session-start path must pause, not hard-stop
   assert.ok(
-    src.includes('category === "timeout"'),
-    "phases.ts must check category === 'timeout' on transient cancelled unitResults",
+    src.includes('errorCategory === "timeout"'),
+    "phases.ts must check errorCategory === 'timeout' on transient cancelled unitResults",
+  );
+  assert.ok(
+    src.includes('errorCategory === "session-failed"'),
+    "phases.ts must also check errorCategory === 'session-failed' on transient cancelled unitResults",
   );
   // Must call pauseAuto or pauseAutoForProviderError (not stopAuto) for timeout cancellations
   assert.ok(
-    /category === "timeout"[\s\S]{0,1200}pauseAuto/.test(src),
+    /errorCategory === "timeout"[\s\S]{0,1800}pauseAuto/.test(src),
     "phases.ts must call pauseAuto for session-timeout failures (not stopAuto or continue)",
   );
+  assert.ok(
+    /errorCategory === "session-failed"[\s\S]{0,700}pauseAuto/.test(src),
+    "phases.ts must call pauseAuto for transient session-start failures (not stopAuto or continue)",
+  );
   // Must NOT use action: "continue" for transient cancellations (causes infinite loops)
   assert.ok(
     !/isTransient[\s\S]{0,500}action:\s*"continue"/.test(src),
@@ -612,33 +689,75 @@ test("phases.ts resets session timeout counter on successful unit completion", (
 // ── Fix 3: MAX_TRANSIENT_AUTO_RESUMES raised to 8 ───────────────────────────
 
 test("MAX_TRANSIENT_AUTO_RESUMES is at least 8 for sustained overload resilience", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-  const match = src.match(/MAX_TRANSIENT_AUTO_RESUMES\s*=\s*(\d+)/);
-  assert.ok(match, "MAX_TRANSIENT_AUTO_RESUMES must be defined");
-  const value = Number(match![1]);
+  // Import the real constant rather than regex-scraping the source literal —
+  // this way the assertion cannot silently drift if the symbol is renamed or
+  // the value is moved. See #4837.
   assert.ok(
-    value >= 8,
-    `MAX_TRANSIENT_AUTO_RESUMES must be >= 8 for sustained overload resilience, got ${value}`,
+    MAX_TRANSIENT_AUTO_RESUMES >= 8,
+    `MAX_TRANSIENT_AUTO_RESUMES must be >= 8 for sustained overload resilience, got ${MAX_TRANSIENT_AUTO_RESUMES}`,
   );
 });
 
+// ── Stream idle timeout / partial response (#4558) ──────────────────────────
+
+test("classifyError: 'Stream idle timeout - partial response received' is transient network", () => {
+  const result = classifyError("API Error: Stream idle timeout - partial response received");
+  assert.ok(isTransient(result), "stream idle timeout must be transient");
+  assert.equal(result.kind, "network");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs > 0);
+});
+
+test("classifyError: 'stream idle timeout' (lowercase) is transient network", () => {
+  const result = classifyError("stream idle timeout");
+  assert.ok(isTransient(result), "lowercase stream idle timeout must be transient");
+  assert.equal(result.kind, "network");
+});
+
+test("classifyError: 'partial response received' alone is transient network", () => {
+  const result = classifyError("partial response received");
+  assert.ok(isTransient(result), "partial response received must be transient");
+  assert.equal(result.kind, "network");
+});
+
+// ── Context overflow / context window exceeded (#4528) ───────────────────────
+
+test("classifyError: MiniMax context window error is transient server", () => {
+  const result = classifyError("400 invalid params, context window exceeds limit (2013)");
+  assert.ok(isTransient(result), "context window exceeded must be transient");
+  assert.equal(result.kind, "server");
+});
+
+test("classifyError: 'context length exceeded' is transient server", () => {
+  const result = classifyError("context length exceeded: max 128000 tokens");
+  assert.ok(isTransient(result), "context length exceeded must be transient");
+  assert.equal(result.kind, "server");
+});
+
+test("classifyError: 'context window' with 'exceed' is transient server", () => {
+  const result = classifyError("context window exceeded for this model");
+  assert.ok(isTransient(result), "context window exceeded must be transient");
+  assert.equal(result.kind, "server");
+});
+
 // ── agent-session retryable regex handles server_error (#1166) ──────────────
 
 test("agent-session retryable error regex matches server_error (underscore)", () => {
-  // This regex is extracted from _isRetryableError in agent-session.ts.
-  // It must match both "server error" (space) and "server_error" (underscore)
-  // to properly classify Codex streaming errors as retryable.
-  // "temporarily backed off" intentionally excluded — see #3429
-  const retryableRegex = /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|network.?(?:is\s+)?unavailable|credentials.*expired|extra usage is required/i;
+  // Import the real regex from the retry-handler so this test can never
+  // silently drift from runtime behaviour. The regex must match both
+  // "server error" (space) and "server_error" (underscore) to properly
+  // classify Codex streaming errors as retryable.
+  // "temporarily backed off" is intentionally excluded — see #3429 / #4837.
 
   // server_error (with underscore — Codex streaming error format)
-  assert.ok(retryableRegex.test("Codex server_error: An error occurred"));
+  assert.ok(RETRYABLE_ERROR_RE.test("Codex server_error: An error occurred"));
   // server error (with space — traditional HTTP error format)
-  assert.ok(retryableRegex.test("server error occurred"));
+  assert.ok(RETRYABLE_ERROR_RE.test("server error occurred"));
   // internal_error (with underscore)
-  assert.ok(retryableRegex.test("internal_error: something went wrong"));
+  assert.ok(RETRYABLE_ERROR_RE.test("internal_error: something went wrong"));
   // internal error (with space)
-  assert.ok(retryableRegex.test("internal error"));
+  assert.ok(RETRYABLE_ERROR_RE.test("internal error"));
   // non-retryable errors must not match
-  assert.ok(!retryableRegex.test("model not found"));
+  assert.ok(!RETRYABLE_ERROR_RE.test("model not found"));
+  // "temporarily backed off" must NOT be matched (intentional exclusion #3429)
+  assert.ok(!RETRYABLE_ERROR_RE.test("temporarily backed off"));
 });