gsd-pi 2.50.0-dev.d210a87 → 2.51.0-dev.7d435fe

package/src/resources/extensions/gsd/tests/interactive-tool-idle-exemption.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Tests for #2676: idle watchdog must exempt user-interactive tools
+ * (ask_user_questions, secure_env_collect) from stall detection.
+ */
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  markToolStart,
+  markToolEnd,
+  hasInteractiveToolInFlight,
+  getInFlightToolCount,
+  getOldestInFlightToolStart,
+  getOldestInFlightToolAgeMs,
+  clearInFlightTools,
+} from "../auto-tool-tracking.ts";
+
+// These tests call the tracking module directly (bypassing the auto.ts
+// wrapper which guards on s.active) so we always pass isActive=true.
+
+beforeEach(() => {
+  clearInFlightTools();
+});
+
+describe("hasInteractiveToolInFlight", () => {
+  test("returns false when no tools are in-flight", () => {
+    assert.equal(hasInteractiveToolInFlight(), false);
+  });
+
+  test("returns false when only non-interactive tools are in-flight", () => {
+    markToolStart("call-1", true, "bash");
+    markToolStart("call-2", true, "read");
+    assert.equal(hasInteractiveToolInFlight(), false);
+  });
+
+  test("returns true when ask_user_questions is in-flight", () => {
+    markToolStart("call-1", true, "bash");
+    markToolStart("call-2", true, "ask_user_questions");
+    assert.equal(hasInteractiveToolInFlight(), true);
+  });
+
+  test("returns true when secure_env_collect is in-flight", () => {
+    markToolStart("call-1", true, "secure_env_collect");
+    assert.equal(hasInteractiveToolInFlight(), true);
+  });
+
+  test("returns false after interactive tool completes", () => {
+    markToolStart("call-1", true, "ask_user_questions");
+    assert.equal(hasInteractiveToolInFlight(), true);
+    markToolEnd("call-1");
+    assert.equal(hasInteractiveToolInFlight(), false);
+  });
+
+  test("returns true if one of multiple tools is interactive", () => {
+    markToolStart("call-1", true, "bash");
+    markToolStart("call-2", true, "edit");
+    markToolStart("call-3", true, "ask_user_questions");
+    markToolStart("call-4", true, "write");
+    assert.equal(hasInteractiveToolInFlight(), true);
+  });
+});
+
+describe("toolName tracking in markToolStart", () => {
+  test("defaults toolName to 'unknown' when not provided", () => {
+    markToolStart("call-1", true);
+    // unknown tool should not be treated as interactive
+    assert.equal(hasInteractiveToolInFlight(), false);
+    assert.equal(getInFlightToolCount(), 1);
+  });
+
+  test("no-ops when isActive is false", () => {
+    markToolStart("call-1", false, "ask_user_questions");
+    assert.equal(getInFlightToolCount(), 0);
+    assert.equal(hasInteractiveToolInFlight(), false);
+  });
+});
+
+describe("existing tracking behavior preserved with toolName", () => {
+  test("getInFlightToolCount tracks correctly", () => {
+    assert.equal(getInFlightToolCount(), 0);
+    markToolStart("call-1", true, "bash");
+    assert.equal(getInFlightToolCount(), 1);
+    markToolStart("call-2", true, "ask_user_questions");
+    assert.equal(getInFlightToolCount(), 2);
+    markToolEnd("call-1");
+    assert.equal(getInFlightToolCount(), 1);
+    markToolEnd("call-2");
+    assert.equal(getInFlightToolCount(), 0);
+  });
+
+  test("getOldestInFlightToolStart returns correct timestamp", () => {
+    assert.equal(getOldestInFlightToolStart(), undefined);
+    const before = Date.now();
+    markToolStart("call-1", true, "bash");
+    const after = Date.now();
+    const oldest = getOldestInFlightToolStart();
+    assert.ok(oldest !== undefined);
+    assert.ok(oldest! >= before && oldest! <= after);
+  });
+
+  test("getOldestInFlightToolAgeMs returns 0 with no tools", () => {
+    assert.equal(getOldestInFlightToolAgeMs(), 0);
+  });
+
+  test("getOldestInFlightToolAgeMs returns positive value with tools", () => {
+    markToolStart("call-1", true, "read");
+    const age = getOldestInFlightToolAgeMs();
+    assert.ok(age >= 0, `age should be non-negative, got ${age}`);
+  });
+
+  test("clearInFlightTools resets all state", () => {
+    markToolStart("call-1", true, "ask_user_questions");
+    markToolStart("call-2", true, "bash");
+    assert.equal(getInFlightToolCount(), 2);
+    assert.equal(hasInteractiveToolInFlight(), true);
+    clearInFlightTools();
+    assert.equal(getInFlightToolCount(), 0);
+    assert.equal(hasInteractiveToolInFlight(), false);
+  });
+});

package/src/resources/extensions/gsd/tests/key-manager.test.ts

@@ -189,7 +189,22 @@ test("getAllKeyStatuses detects empty keys as not configured", () => {
   const statuses = getAllKeyStatuses(auth);
   const groq = statuses.find((s) => s.provider.id === "groq");
   assert.equal(groq?.configured, false);
-  assert.ok(groq?.description.includes("empty"));
+  // Empty-key entries are filtered out, so provider appears unconfigured
+  assert.equal(groq?.source, "none");
+});
+
+test("getAllKeyStatuses finds valid keys even when empty-key entry exists at index 0", () => {
+  const auth = makeAuth({
+    groq: [
+      { type: "api_key", key: "" },
+      { type: "api_key", key: "gsk-real-key" },
+    ],
+  });
+  const statuses = getAllKeyStatuses(auth);
+  const groq = statuses.find((s) => s.provider.id === "groq");
+  assert.equal(groq?.configured, true);
+  assert.equal(groq?.source, "auth.json");
+  assert.equal(groq?.credentialCount, 1); // only the valid key counts
 });
 
 test("getAllKeyStatuses detects env var keys", () => {

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -363,7 +363,7 @@ test('md-importer: schema v1→v2 migration', () => {
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.v, 12, 'new DB should be at schema version 12');
+  assert.deepStrictEqual(version?.v, 14, 'new DB should be at schema version 14');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();

package/src/resources/extensions/gsd/tests/memory-store.test.ts

@@ -323,9 +323,9 @@ test('memory-store: schema includes memories table', () => {
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 12 (after quality gates table)
+  // Verify schema version is 14 (after indexes + slice_dependencies)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.['v'], 12, 'schema version should be 12');
+  assert.deepStrictEqual(version?.['v'], 14, 'schema version should be 14');
 
   closeDatabase();
 });

package/src/resources/extensions/gsd/tests/none-mode-gates.test.ts

@@ -8,7 +8,7 @@
  * Uses the writeRunnerPreferences pattern from doctor-git.test.ts:
  * PROJECT_PREFERENCES_PATH is a module-level constant frozen at import
  * time, so process.chdir() won't redirect preference loading. We write
- * prefs to the runner's cwd .gsd/preferences.md and clean up in finally.
+ * prefs to the runner's cwd .gsd/PREFERENCES.md and clean up in finally.
  */
 
 import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
@@ -24,7 +24,7 @@ import assert from 'node:assert/strict';
 
 // --- Preferences helpers (same pattern as doctor-git.test.ts K001) ---
 
-const RUNNER_PREFS_PATH = join(process.cwd(), ".gsd", "preferences.md");
+const RUNNER_PREFS_PATH = join(process.cwd(), ".gsd", "PREFERENCES.md");
 
 function writeRunnerPreferences(isolation: "none" | "worktree" | "branch"): void {
   mkdirSync(join(process.cwd(), ".gsd"), { recursive: true });
@@ -72,12 +72,12 @@ try {
 
 // Test 4: shouldUseWorktreeIsolation returns false for no prefs (default: none)
 // Worktree isolation requires explicit opt-in — default is "none" so GSD
-// works out of the box without preferences.md (#2480).
+// works out of the box without PREFERENCES.md (#2480).
 // Skip if global prefs exist — they override the default and this test
-// cannot control ~/.gsd/preferences.md.
+// cannot control ~/.gsd/PREFERENCES.md.
 
 test('shouldUseWorktreeIsolation returns false for no prefs (default: none)', () => {
-  const globalPrefsExist = existsSync(join(homedir(), ".gsd", "preferences.md"))
+  const globalPrefsExist = existsSync(join(homedir(), ".gsd", "PREFERENCES.md"))
     || existsSync(join(homedir(), ".gsd", "PREFERENCES.md"));
   if (!globalPrefsExist) {
     try {
@@ -91,9 +91,9 @@ test('shouldUseWorktreeIsolation returns false for no prefs (default: none)', ()
   }
 });
 
-// Test 5: getIsolationMode returns "none" when no preferences.md exists (#2480)
+// Test 5: getIsolationMode returns "none" when no PREFERENCES.md exists (#2480)
 test('getIsolationMode returns "none" with no prefs (default)', () => {
-  const globalPrefsExist = existsSync(join(homedir(), ".gsd", "preferences.md"))
+  const globalPrefsExist = existsSync(join(homedir(), ".gsd", "PREFERENCES.md"))
     || existsSync(join(homedir(), ".gsd", "PREFERENCES.md"));
   if (!globalPrefsExist) {
     try {

package/src/resources/extensions/gsd/tests/park-db-sync.test.ts

@@ -0,0 +1,85 @@
+/**
+ * Regression test for #2694: parkMilestone and unparkMilestone must
+ * update the DB milestone status alongside the filesystem marker.
+ *
+ * Without this, deriveStateFromDb skips unparked milestones because
+ * the DB still has status='parked', causing "All milestones complete".
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { parkMilestone, unparkMilestone } from "../milestone-actions.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  getMilestone,
+} from "../gsd-db.ts";
+
+function createBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-park-db-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001\n\nContext.",
+  );
+  return base;
+}
+
+test("parkMilestone updates DB status to 'parked' (#2694)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    assert.equal(getMilestone("M001")!.status, "active", "starts active");
+
+    parkMilestone(base, "M001", "deprioritized");
+
+    assert.equal(getMilestone("M001")!.status, "parked", "DB status should be parked");
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("unparkMilestone updates DB status to 'active' (#2694)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    // Park first
+    parkMilestone(base, "M001", "deprioritized");
+    assert.equal(getMilestone("M001")!.status, "parked");
+
+    // Unpark
+    unparkMilestone(base, "M001");
+    assert.equal(getMilestone("M001")!.status, "active", "DB status should be active after unpark");
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("park/unpark are safe when DB is not available (#2694 guard)", () => {
+  const base = createBase();
+  try {
+    // No openDatabase — DB not available
+    // park/unpark should still work (filesystem-only, no throw)
+    const parked = parkMilestone(base, "M001", "test");
+    assert.ok(parked, "parkMilestone succeeds without DB");
+
+    const unparked = unparkMilestone(base, "M001");
+    assert.ok(unparked, "unparkMilestone succeeds without DB");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/preferences-worktree-sync.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Regression tests for #2684: preferences.md must be included in both
+ * ROOT_STATE_FILES (sync) and copyPlanningArtifacts (initial seed).
+ *
+ * Without this, post_unit_hooks and all preference-driven config silently
+ * stop working inside auto-mode worktrees.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+test("#2684: preferences.md is NOT in ROOT_STATE_FILES (forward-only sync)", () => {
+  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
+  const src = readFileSync(srcPath, "utf-8");
+
+  const constIdx = src.indexOf("ROOT_STATE_FILES");
+  assert.ok(constIdx !== -1, "ROOT_STATE_FILES constant exists");
+
+  const arrayStart = src.indexOf("[", constIdx);
+  const arrayEnd = src.indexOf("] as const", arrayStart);
+  const block = src.slice(arrayStart, arrayEnd);
+
+  // preferences.md must NOT be in ROOT_STATE_FILES — it is handled separately
+  // in syncGsdStateToWorktree() (forward-only, additive). Including it in
+  // ROOT_STATE_FILES would cause syncWorktreeStateBack() to overwrite the
+  // authoritative project root copy (#2684).
+  const entries = block.split("\n")
+    .map(l => l.trim())
+    .filter(l => l.startsWith('"') && l.includes(".md"));
+  const hasPrefs = entries.some(l => l.includes("preferences.md"));
+  assert.ok(
+    !hasPrefs,
+    "preferences.md must NOT be in ROOT_STATE_FILES (back-sync would overwrite root)",
+  );
+});
+
+test("#2684: copyPlanningArtifacts file list includes preferences.md", () => {
+  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
+  const src = readFileSync(srcPath, "utf-8");
+
+  // Find the copyPlanningArtifacts function body
+  const fnIdx = src.indexOf("function copyPlanningArtifacts");
+  assert.ok(fnIdx !== -1, "copyPlanningArtifacts function exists");
+
+  // Extract function body (up to the next top-level function)
+  const fnBody = src.slice(fnIdx, fnIdx + 1500);
+
+  assert.ok(
+    fnBody.includes('"preferences.md"'),
+    "preferences.md should be in copyPlanningArtifacts file list",
+  );
+});
+
+test("#2684: syncGsdStateToWorktree copies preferences.md", async () => {
+  // Functional test: create a mock source and destination, call the sync
+  const srcBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-src-"));
+  const dstBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-dst-"));
+  const srcGsd = join(srcBase, ".gsd");
+  const dstGsd = join(dstBase, ".gsd");
+  mkdirSync(srcGsd, { recursive: true });
+  mkdirSync(dstGsd, { recursive: true });
+
+  try {
+    // Write a preferences.md in source
+    writeFileSync(
+      join(srcGsd, "preferences.md"),
+      "---\nversion: 1\n---\n\npost_unit_hooks:\n  - name: notify\n    command: echo done\n",
+    );
+
+    // Import and call syncGsdStateToWorktree
+    const { syncGsdStateToWorktree } = await import("../auto-worktree.ts");
+    syncGsdStateToWorktree(srcBase, dstBase);
+
+    // Verify preferences.md was copied
+    assert.ok(
+      existsSync(join(dstGsd, "preferences.md")),
+      "preferences.md should be copied to worktree",
+    );
+
+    const content = readFileSync(join(dstGsd, "preferences.md"), "utf-8");
+    assert.ok(
+      content.includes("post_unit_hooks"),
+      "copied preferences.md should contain the hooks config",
+    );
+  } finally {
+    rmSync(srcBase, { recursive: true, force: true });
+    rmSync(dstBase, { recursive: true, force: true });
+  }
+});

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

@@ -45,7 +45,7 @@ test("getIsolationMode defaults to none when preferences have no isolation setti
   // Validate the default via validatePreferences: when no isolation is set,
   // preferences.git.isolation is undefined, and getIsolationMode returns "none".
   // Default changed from "worktree" to "none" so GSD works out of the box
-  // without preferences.md (#2480).
+  // without PREFERENCES.md (#2480).
   const { preferences } = validatePreferences({});
   assert.equal(preferences.git?.isolation, undefined, "no isolation in empty prefs");
   const isolation = preferences.git?.isolation;

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

@@ -1,6 +1,6 @@
 /**
  * Provider error handling tests — consolidated from:
- *   - provider-error-classify.test.ts (classifyProviderError)
+ *   - provider-error-classify.test.ts (classifyError)
  *   - network-error-fallback.test.ts (isTransientNetworkError, getNextFallbackModel)
  *   - agent-end-provider-error.test.ts (pauseAutoForProviderError)
  */
@@ -10,102 +10,111 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { classifyProviderError, pauseAutoForProviderError } from "../provider-error-pause.ts";
-import { getNextFallbackModel, isTransientNetworkError } from "../preferences.ts";
+import { classifyError, isTransient, isTransientNetworkError } from "../error-classifier.ts";
+import { pauseAutoForProviderError } from "../provider-error-pause.ts";
+import { getNextFallbackModel } from "../preferences.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-// ── classifyProviderError ────────────────────────────────────────────────────
+// ── classifyError ────────────────────────────────────────────────────────────
 
-test("classifyProviderError detects rate limit from 429", () => {
-  const result = classifyProviderError("HTTP 429 Too Many Requests");
-  assert.ok(result.isTransient);
-  assert.ok(result.isRateLimit);
-  assert.ok(result.suggestedDelayMs > 0);
+test("classifyError detects rate limit from 429", () => {
+  const result = classifyError("HTTP 429 Too Many Requests");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs > 0);
 });
 
-test("classifyProviderError detects rate limit from message", () => {
-  const result = classifyProviderError("rate limit exceeded");
-  assert.ok(result.isTransient);
-  assert.ok(result.isRateLimit);
+test("classifyError detects rate limit from message", () => {
+  const result = classifyError("rate limit exceeded");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
 });
 
-test("classifyProviderError extracts reset delay from message", () => {
-  const result = classifyProviderError("rate limit exceeded, reset in 45s");
-  assert.ok(result.isRateLimit);
-  assert.equal(result.suggestedDelayMs, 45000);
+test("classifyError extracts reset delay from message", () => {
+  const result = classifyError("rate limit exceeded, reset in 45s");
+  assert.equal(result.kind, "rate-limit");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 45000);
 });
 
-test("classifyProviderError defaults to 60s for rate limit without reset", () => {
-  const result = classifyProviderError("429 too many requests");
-  assert.ok(result.isRateLimit);
-  assert.equal(result.suggestedDelayMs, 60_000);
+test("classifyError defaults to 60s for rate limit without reset", () => {
+  const result = classifyError("429 too many requests");
+  assert.equal(result.kind, "rate-limit");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 60_000);
 });
 
-test("classifyProviderError detects Anthropic internal server error", () => {
+test("classifyError treats stream_exhausted_without_result as transient connection failure", () => {
+  const result = classifyError("stream_exhausted_without_result");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "connection");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 15_000);
+});
+
+test("classifyError detects Anthropic internal server error", () => {
   const msg = '{"type":"error","error":{"details":null,"type":"api_error","message":"Internal server error"}}';
-  const result = classifyProviderError(msg);
-  assert.ok(result.isTransient);
-  assert.ok(!result.isRateLimit);
-  assert.equal(result.suggestedDelayMs, 30_000);
+  const result = classifyError(msg);
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "server");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 30_000);
 });
 
-test("classifyProviderError detects Codex server_error from extracted message", () => {
+test("classifyError detects Codex server_error from extracted message", () => {
   // After fix, mapCodexEvents extracts the nested error type and produces
   // "Codex server_error: <message>" instead of raw JSON.
   const msg = "Codex server_error: An error occurred while processing your request.";
-  const result = classifyProviderError(msg);
-  assert.ok(result.isTransient);
-  assert.ok(!result.isRateLimit);
-  assert.equal(result.suggestedDelayMs, 30_000);
+  const result = classifyError(msg);
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "server");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 30_000);
 });
 
-test("classifyProviderError detects overloaded error", () => {
-  const result = classifyProviderError("overloaded_error: Overloaded");
-  assert.ok(result.isTransient);
-  assert.equal(result.suggestedDelayMs, 30_000);
+test("classifyError detects overloaded error", () => {
+  const result = classifyError("overloaded_error: Overloaded");
+  assert.ok(isTransient(result));
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 30_000);
 });
 
-test("classifyProviderError detects 503 service unavailable", () => {
-  const result = classifyProviderError("HTTP 503 Service Unavailable");
-  assert.ok(result.isTransient);
+test("classifyError detects 503 service unavailable", () => {
+  const result = classifyError("HTTP 503 Service Unavailable");
+  assert.ok(isTransient(result));
 });
 
-test("classifyProviderError detects 502 bad gateway", () => {
-  const result = classifyProviderError("HTTP 502 Bad Gateway");
-  assert.ok(result.isTransient);
+test("classifyError detects 502 bad gateway", () => {
+  const result = classifyError("HTTP 502 Bad Gateway");
+  assert.ok(isTransient(result));
 });
 
-test("classifyProviderError detects auth error as permanent", () => {
-  const result = classifyProviderError("unauthorized: invalid API key");
-  assert.ok(!result.isTransient);
-  assert.ok(!result.isRateLimit);
+test("classifyError detects auth error as permanent", () => {
+  const result = classifyError("unauthorized: invalid API key");
+  assert.ok(!isTransient(result));
+  assert.equal(result.kind, "permanent");
 });
 
-test("classifyProviderError detects billing error as permanent", () => {
-  const result = classifyProviderError("billing issue: payment required");
-  assert.ok(!result.isTransient);
+test("classifyError detects billing error as permanent", () => {
+  const result = classifyError("billing issue: payment required");
+  assert.ok(!isTransient(result));
 });
 
-test("classifyProviderError detects quota exceeded as permanent", () => {
-  const result = classifyProviderError("quota exceeded for this month");
-  assert.ok(!result.isTransient);
+test("classifyError detects quota exceeded as permanent", () => {
+  const result = classifyError("quota exceeded for this month");
+  assert.ok(!isTransient(result));
 });
 
-test("classifyProviderError treats unknown error as permanent", () => {
-  const result = classifyProviderError("something went wrong");
-  assert.ok(!result.isTransient);
+test("classifyError treats unknown error as not transient", () => {
+  const result = classifyError("something went wrong");
+  assert.ok(!isTransient(result));
+  assert.equal(result.kind, "unknown");
 });
 
-test("classifyProviderError treats empty string as permanent", () => {
-  const result = classifyProviderError("");
-  assert.ok(!result.isTransient);
+test("classifyError treats empty string as not transient", () => {
+  const result = classifyError("");
+  assert.ok(!isTransient(result));
 });
 
-test("classifyProviderError: rate limit takes precedence over auth keywords", () => {
-  const result = classifyProviderError("429 unauthorized rate limit");
-  assert.ok(result.isRateLimit);
-  assert.ok(result.isTransient);
+test("classifyError: rate limit takes precedence over auth keywords", () => {
+  const result = classifyError("429 unauthorized rate limit");
+  assert.equal(result.kind, "rate-limit");
+  assert.ok(isTransient(result));
 });
 
 // ── isTransientNetworkError ──────────────────────────────────────────────────
@@ -265,8 +274,8 @@ test("agent-end-recovery.ts tracks consecutive transient errors for escalating b
   const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
 
   assert.ok(
-    src.includes("consecutiveTransientErrors"),
-    "agent-end-recovery.ts must track consecutiveTransientErrors for escalating backoff (#1166)",
+    src.includes("consecutiveTransientCount"),
+    "agent-end-recovery.ts must track consecutiveTransientCount for escalating backoff (#1166)",
   );
   assert.ok(
     src.includes("MAX_TRANSIENT_AUTO_RESUMES"),
@@ -274,15 +283,13 @@ test("agent-end-recovery.ts tracks consecutive transient errors for escalating b
   );
 });
 
-test("agent-end-recovery.ts resets consecutive transient error counter on success", () => {
+test("agent-end-recovery.ts resets retry state before resolveAgentEnd on success", () => {
   const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
 
-  // After successful agent_end (before resolveAgentEnd), the counter must be reset.
-  // Use a regex across the success block so CRLF checkouts on Windows do not
-  // push the reset line outside a fixed substring window.
+  // After successful agent_end, resetRetryState must be called before resolveAgentEnd.
   assert.ok(
-    /consecutiveTransientErrors\s*=\s*0\s*;[\s\S]{0,250}resolveAgentEnd/.test(src),
-    "consecutive transient error counter must be reset before resolveAgentEnd on the success path (#1166)",
+    /resetRetryState[\s\S]{0,250}resolveAgentEnd/.test(src),
+    "resetRetryState must be called before resolveAgentEnd on the success path (#1166)",
   );
 });
 
@@ -291,7 +298,7 @@ test("agent-end-recovery.ts applies escalating delay for repeated transient erro
 
   // Must contain the exponential backoff formula (may span multiple lines)
   assert.ok(
-    src.includes("2 ** Math.max(0, consecutiveTransientErrors"),
+    src.includes("2 ** Math.max(0, retryState.consecutiveTransientCount"),
     "agent-end-recovery.ts must escalate retryAfterMs exponentially for consecutive transient errors (#1166)",
   );
 });