@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/src/resources/extensions/gsd/tests/tool-call-loop-guard.test.ts

@@ -7,9 +7,11 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
   checkToolCallLoop,
+  recordToolCallLoopMutation,
   resetToolCallLoopGuard,
   disableToolCallLoopGuard,
   getToolCallLoopCount,
+  getToolCallCountForTool,
 } from '../bootstrap/tool-call-loop-guard.ts';
 
 
@@ -177,3 +179,272 @@ console.log('\n── Loop guard: nested key order is normalized ──');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
+// Per-tool-name cap (#783 Brief C) — catches improvisation loops with varied args
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: per-tool cap blocks varied-args improvisation (#783) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  // A one-shot workflow tool called with DIFFERENT args each time (the reported
+  // improvisation pattern). The identical-signature streak alone would reset
+  // every call; the per-tool cap must catch it.
+  for (let i = 1; i <= 6; i++) {
+    const result = checkToolCallLoop('gsd_complete_milestone', { milestone: `M${i}` });
+    assert.ok(result.block === false, `one-shot call ${i} (varied args) should be allowed`);
+    assert.deepStrictEqual(getToolCallCountForTool('gsd_complete_milestone'), i, `per-tool count should be ${i}`);
+  }
+  // 7th call (cap 6 + 1) must be blocked by the per-tool guard.
+  const blocked = checkToolCallLoop('gsd_complete_milestone', { milestone: 'M7' });
+  assert.ok(blocked.block === true, '7th one-shot call (varied args) should be blocked by per-tool cap');
+  assert.ok(blocked.reason!.includes('repeated tool'), 'reason should identify the per-tool guard');
+  assert.ok(blocked.reason!.includes('gsd_complete_milestone'), 'reason should name the tool');
+  assert.ok(blocked.reason!.includes('7'), 'reason should mention the count');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Repeatable tools get the higher cap
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: repeatable tools get the higher cap (#783) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  // bash is repeatable: varied commands are legitimate up to the higher cap.
+  for (let i = 1; i <= 15; i++) {
+    const result = checkToolCallLoop('bash', { command: `echo ${i}` });
+    assert.ok(result.block === false, `bash call ${i} (varied args) should be allowed`);
+  }
+  // 16th call (cap 15 + 1) is blocked by the per-tool guard — this is the
+  // improvisation-through-bash case from the forensics (~51 calls).
+  const blocked = checkToolCallLoop('bash', { command: 'echo 16' });
+  assert.ok(blocked.block === true, '16th bash call (varied args) should be blocked by per-tool cap');
+  assert.ok(blocked.reason!.includes('cap 15'), 'reason should mention the repeatable cap');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Mutation progress decays per-tool counts (#1092)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: mutation progress decays per-tool counts (#1092) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  // bash is called more than the repeatable cap, but each count is separated
+  // by a successful file mutation. Guard 2 should treat that as progress and
+  // avoid blocking the progressing unit.
+  for (let i = 1; i <= 20; i++) {
+    const result = checkToolCallLoop('bash', { command: `echo ${i}` });
+    assert.ok(result.block === false, `bash call ${i} after mutation progress should be allowed`);
+    assert.deepStrictEqual(getToolCallCountForTool('bash'), 1, `bash count should decay before call ${i}`);
+
+    const mutationTool = i % 2 === 0 ? 'write' : 'edit';
+    const mutation = checkToolCallLoop(mutationTool, {
+      path: `file-${i}.ts`,
+      content: `content ${i}`,
+    });
+    assert.ok(mutation.block === false, `${mutationTool} mutation ${i} should be allowed`);
+    recordToolCallLoopMutation(mutationTool);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Distinct read-only navigation calls are context gathering, not repeated-tool loops.
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: distinct read-only navigation calls are not capped by per-tool count ──');
+
+{
+  const exemptTools = ['find', 'glob', 'grep', 'ls', 'read', 'search_and_read'];
+
+  for (const toolName of exemptTools) {
+    resetToolCallLoopGuard();
+
+    for (let i = 1; i <= 20; i++) {
+      const result = checkToolCallLoop(toolName, { path: `file-${i}.ts` });
+      assert.ok(result.block === false, `distinct ${toolName} call ${i} should be allowed`);
+    }
+
+    resetToolCallLoopGuard();
+    for (let i = 1; i <= 4; i++) {
+      const result = checkToolCallLoop(toolName, { path: 'same-file.ts' });
+      assert.ok(result.block === false, `identical ${toolName} call ${i} should be allowed`);
+    }
+
+    const blocked = checkToolCallLoop(toolName, { path: 'same-file.ts' });
+    assert.ok(blocked.block === true, `5th identical ${toolName} call should still be blocked`);
+    assert.ok(blocked.reason?.includes('identical args'), `${toolName} loops should be caught by Guard 1`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Per-tool counts are independent per tool and reset together
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: per-tool counts are independent and reset together (#783) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  // Two different tools tracked separately.
+  for (let i = 0; i < 3; i++) checkToolCallLoop('read', { path: `f${i}` });
+  for (let i = 0; i < 3; i++) checkToolCallLoop('write', { path: `g${i}` });
+  assert.deepStrictEqual(getToolCallCountForTool('read'), 3, 'read tracked separately');
+  assert.deepStrictEqual(getToolCallCountForTool('write'), 3, 'write tracked separately');
+  assert.deepStrictEqual(getToolCallCountForTool('edit'), 0, 'uncalled tool reports 0');
+
+  resetToolCallLoopGuard();
+  assert.deepStrictEqual(getToolCallCountForTool('read'), 0, 'per-tool counts cleared on reset');
+  assert.deepStrictEqual(getToolCallCountForTool('write'), 0, 'per-tool counts cleared on reset');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Non-exempt repeatable tools from core-session-tools.ts get the higher cap.
+// Read-only navigation tools are exempted earlier; mutating/execution repeatable
+// tools (e.g. gsd_exec) must still trip the per-tool cap.
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: non-exempt repeatable tools get high cap ──');
+
+{
+  for (const toolName of ['bg_shell', 'gsd_exec', 'write']) {
+    resetToolCallLoopGuard();
+
+    // Should allow up to 15 varied calls without blocking.
+    for (let i = 1; i <= 15; i++) {
+      const result = checkToolCallLoop(toolName, { arg: `v${i}` });
+      assert.ok(result.block === false, `${toolName} call ${i} (varied args) should be allowed`);
+    }
+    // 16th call with varied args must be blocked by the per-tool repeatable cap.
+    const blocked = checkToolCallLoop(toolName, { arg: 'v16' });
+    assert.ok(blocked.block === true, `${toolName}: 16th call must be blocked by repeatable cap`);
+    assert.ok(blocked.reason?.includes('cap 15'), `${toolName}: reason must mention cap 15`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Non-repeatable tools excluded from INHERENTLY_REPEATABLE_TOOL_SET use the
+// default cap (6), not the repeatable cap (15).
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: ToolSearch (excluded from repeatable set) hits default cap ──');
+
+{
+  // ToolSearch is in MINIMAL_AUTO_BASE but explicitly excluded from repeatable.
+  // It should hit the default cap of 6, not 15.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 6; i++) {
+    const result = checkToolCallLoop('ToolSearch', { query: `q${i}` });
+    assert.ok(result.block === false, `ToolSearch call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('ToolSearch', { query: 'q7' });
+  assert.ok(blocked.block === true, 'ToolSearch: 7th varied call must be blocked by default cap');
+  assert.ok(!blocked.reason?.includes('cap 15'), 'ToolSearch must NOT use the repeatable cap');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Block reasons instruct the model to stop tooling this turn
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: block reasons tell model to respond in text ──');
+
+{
+  resetToolCallLoopGuard();
+
+  for (let i = 0; i < 4; i++) {
+    checkToolCallLoop('web_search', { query: 'same query' });
+  }
+  const identicalBlocked = checkToolCallLoop('web_search', { query: 'same query' });
+  assert.ok(identicalBlocked.block === true, 'identical-args guard should block');
+  assert.ok(
+    identicalBlocked.reason!.includes('respond to the user in text'),
+    'identical-args reason should tell the model to stop tooling',
+  );
+  assert.ok(
+    !identicalBlocked.reason!.includes('Try a different approach'),
+    'identical-args reason should not suggest retrying another tool',
+  );
+
+  resetToolCallLoopGuard();
+  for (let i = 0; i < 6; i++) {
+    checkToolCallLoop('gsd_complete_milestone', { milestone: `M${i}` });
+  }
+  const perToolBlocked = checkToolCallLoop('gsd_complete_milestone', { milestone: 'M7' });
+  assert.ok(perToolBlocked.block === true, 'per-tool guard should block');
+  assert.ok(
+    perToolBlocked.reason!.includes('respond to the user in text'),
+    'per-tool reason should tell the model to stop tooling',
+  );
+  assert.ok(
+    perToolBlocked.reason!.includes('Do not retry this tool'),
+    'per-tool reason should forbid retrying the blocked tool',
+  );
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Distinct-arg browser-automation calls are a legitimate UAT, not a loop (#1120)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: distinct-arg browser automation calls are not capped by per-tool count (#1120) ──');
+
+{
+  // A browser-backed UAT legitimately calls one browser verb many times with
+  // DIFFERENT arguments (read a validation message, count staged edits, inspect
+  // a control card, …). Guard 1's identical-signature streak never trips because
+  // the args vary; Guard 2's arg-independent per-tool cap must NOT block it.
+  for (const toolName of ['browser_evaluate', 'browser_act', 'browser_find']) {
+    resetToolCallLoopGuard();
+    for (let i = 1; i <= 12; i++) {
+      const result = checkToolCallLoop(toolName, { script: `step ${i}` });
+      assert.ok(result.block === false, `distinct ${toolName} call ${i} should be allowed`);
+    }
+  }
+
+  // MCP-prefixed browser tools canonicalize to `browser_*` and are exempt too.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 12; i++) {
+    const result = checkToolCallLoop('mcp__agent-browser__browser_evaluate', { script: `step ${i}` });
+    assert.ok(result.block === false, `distinct MCP-prefixed browser_evaluate call ${i} should be allowed`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Identical-arg browser loops are STILL caught by Guard 1 (#1120)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: identical-arg browser loops are still caught by Guard 1 (#1120) ──');
+
+{
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 4; i++) {
+    const result = checkToolCallLoop('browser_evaluate', { script: 'document.title' });
+    assert.ok(result.block === false, `identical browser_evaluate call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('browser_evaluate', { script: 'document.title' });
+  assert.ok(blocked.block === true, '5th identical browser_evaluate call should be blocked by Guard 1');
+  assert.ok(blocked.reason?.includes('identical args'), 'identical browser loops should be caught by Guard 1, not Guard 2');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// The browser exemption must NOT widen to other non-exempt tools (#1120)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: browser exemption does not widen to other tools (#1120) ──');
+
+{
+  // Negative invariant: an arbitrary non-exempt, non-browser tool called past
+  // the default cap with varied args must still be blocked by Guard 2.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 6; i++) {
+    const result = checkToolCallLoop('some_workflow_tool', { arg: `v${i}` });
+    assert.ok(result.block === false, `non-exempt tool call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('some_workflow_tool', { arg: 'v7' });
+  assert.ok(blocked.block === true, '7th varied-arg non-exempt call must still trip Guard 2');
+  assert.ok(blocked.reason?.includes('repeated tool'), 'non-exempt overflow should be caught by Guard 2');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════

package/src/resources/extensions/gsd/tests/tool-param-optionality.test.ts

@@ -13,6 +13,7 @@
 
 import { test } from "node:test";
 import assert from "node:assert/strict";
+import { SUMMARY_SAVE_CONTENT_MAX_LENGTH } from "@opengsd/contracts";
 import { registerDbTools } from "../bootstrap/db-tools.ts";
 import AjvModule from "ajv";
 
@@ -86,6 +87,31 @@ test("gsd_summary_save — validates UAT assessment params", () => {
   assert.strictEqual(valid, true, `UAT assessment params should validate but got errors: ${JSON.stringify(validate.errors)}`);
 });
 
+test("gsd_summary_save — content has a provider-safe maxLength", () => {
+  const tool = getTool("gsd_summary_save");
+  assert.ok(tool, "gsd_summary_save must be registered");
+
+  const contentSchema = tool.parameters.properties.content;
+  assert.strictEqual(contentSchema.maxLength, SUMMARY_SAVE_CONTENT_MAX_LENGTH);
+
+  const validAtLimit = validateSchema(tool, {
+    milestone_id: "M001",
+    artifact_type: "CONTEXT-DRAFT",
+    content: "x".repeat(SUMMARY_SAVE_CONTENT_MAX_LENGTH),
+  });
+  assert.deepEqual(validAtLimit, []);
+
+  const overLimit = validateSchema(tool, {
+    milestone_id: "M001",
+    artifact_type: "CONTEXT-DRAFT",
+    content: "x".repeat(SUMMARY_SAVE_CONTENT_MAX_LENGTH + 1),
+  });
+  assert.ok(
+    overLimit.some((error) => error.includes(`must NOT have more than ${SUMMARY_SAVE_CONTENT_MAX_LENGTH} characters`)),
+    `expected maxLength validation error, got: ${overLimit.join("; ")}`,
+  );
+});
+
 // ─── gsd_slice_complete: enrichment arrays must be optional ──────────────────
 
 test("gsd_slice_complete — enrichment arrays are optional", () => {
@@ -359,14 +385,17 @@ test("gsd_plan_slice — enrichment fields are optional", () => {
 
   const required = new Set(getRequiredProps(tool));
 
-  // Core fields
-  const coreRequired = ["milestoneId", "sliceId", "goal", "tasks"];
+  // Core fields. `tasks` is intentionally NOT here: incremental planning
+  // (#1027) lets gsd_plan_slice persist slice metadata only, then add tasks
+  // one at a time via gsd_plan_task, so tasks must be optional.
+  const coreRequired = ["milestoneId", "sliceId", "goal"];
   for (const field of coreRequired) {
     assert.ok(required.has(field), `core field "${field}" must be required`);
   }
 
-  // Enrichment fields
+  // Enrichment fields (plus tasks, optional for incremental planning).
   const enrichmentFields = [
+    "tasks",
     "successCriteria",
     "proofLevel",
     "integrationClosure",

package/src/resources/extensions/gsd/tests/tool-schema-model-fallback.test.ts

@@ -0,0 +1,64 @@
+/**
+ * tool-schema-model-fallback.test.ts — Regression test for #813.
+ *
+ * Auto mode aborted with "Schema overload: consecutive tool validation
+ * failures exceeded cap" instead of recovering. The tool-schema handler now
+ * attempts the unit's configured fallbacks and the auto-mode start model (the
+ * model the user actually selected) before hard-pausing, mirroring the
+ * model-error path.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { classifyError } from "../error-classifier.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const RECOVERY_PATH = join(__dirname, "..", "bootstrap", "agent-end-recovery.ts");
+
+function getRecoverySource(): string {
+  return readFileSync(RECOVERY_PATH, "utf-8");
+}
+
+test("schema overload classifies as tool-schema (#813)", () => {
+  const cls = classifyError(
+    "Schema overload: consecutive tool validation failures exceeded cap",
+  );
+  assert.equal(cls.kind, "tool-schema");
+});
+
+test("tool-schema handler attempts model fallback before pausing (#813)", () => {
+  const src = getRecoverySource();
+
+  // Isolate the tool-schema branch body.
+  const branchStart = src.indexOf('if (cls.kind === "tool-schema")');
+  assert.ok(branchStart !== -1, "tool-schema branch must exist");
+  const branch = src.slice(branchStart, branchStart + 1200);
+
+  assert.ok(
+    branch.includes("tryProviderModelFallback"),
+    "tool-schema branch must attempt tryProviderModelFallback before pausing (#813)",
+  );
+  // Fallback success must short-circuit the pause so auto-mode continues.
+  assert.ok(
+    /if\s*\(switched\)\s*return;/.test(branch),
+    "tool-schema branch must return early when a fallback model is switched in (#813)",
+  );
+});
+
+test("tool-schema handler still pauses when no fallback succeeds (#813)", () => {
+  const src = getRecoverySource();
+
+  const branchStart = src.indexOf('if (cls.kind === "tool-schema")');
+  const branch = src.slice(branchStart, branchStart + 1200);
+
+  // The terminal pause must still classify as a tool-schema pause, not a
+  // generic provider pause.
+  assert.ok(
+    /category:\s*"tool-schema"/.test(branch),
+    "tool-schema branch must retain its tool-schema pause category when fallback fails (#813)",
+  );
+});

package/src/resources/extensions/gsd/tests/tool-search-shim.test.ts

@@ -2,6 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import { parseToolSearchSelectQuery } from "@gsd/pi-ai";
+import { registerToolSearchShim } from "../bootstrap/tool-search-shim.ts";
 
 test("parseToolSearchSelectQuery extracts MCP tool name", () => {
   assert.equal(
@@ -18,3 +19,73 @@ test("parseToolSearchSelectQuery returns null for non-select queries", () => {
   assert.equal(parseToolSearchSelectQuery("gsd_save_gate_result"), null);
   assert.equal(parseToolSearchSelectQuery(""), null);
 });
+
+// ── #852 follow-up: registerToolSearchShim tolerates the pre-bind runtime ──
+//
+// During extension loading, getActiveTools()/setActiveTools() are throwing
+// stubs ("Extension runtime not initialized"). The old shim called them
+// unconditionally, the throw propagated to register-extension.ts's catch,
+// and the whole "Extension setup partially failed" warning fired — which
+// under Claude Code CLI could leave workflow tools missing and trap
+// plan-milestone in a finalize-retry loop. The shim must register the tool
+// regardless and tolerate the pre-bind throw.
+
+function makeFakePi(opts: {
+  getActiveToolsThrows?: boolean;
+  setActiveToolsThrows?: boolean;
+  activeTools?: string[];
+}): {
+  registerTool(tool: { name: string }): void;
+  getActiveTools(): string[];
+  setActiveTools(tools: string[]): void;
+  registered: string[];
+  setCalls: string[][];
+} {
+  const registered: string[] = [];
+  const setCalls: string[][] = [];
+  const active = opts.activeTools ?? [];
+  return {
+    registerTool(tool) {
+      registered.push(tool.name);
+    },
+    getActiveTools() {
+      if (opts.getActiveToolsThrows) {
+        throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
+      }
+      return [...active];
+    },
+    setActiveTools(tools) {
+      if (opts.setActiveToolsThrows) {
+        throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
+      }
+      setCalls.push(tools);
+      active.length = 0;
+      active.push(...tools);
+    },
+    registered,
+    setCalls,
+  };
+}
+
+test("registerToolSearchShim registers the tool even when getActiveTools throws (pre-bind runtime)", () => {
+  const pi = makeFakePi({ getActiveToolsThrows: true, setActiveToolsThrows: true });
+  // Must not throw — the old code let this propagate.
+  assert.doesNotThrow(() => registerToolSearchShim(pi as any));
+  assert.ok(pi.registered.includes("ToolSearch"), "tool must be registered despite the pre-bind stubs");
+});
+
+test("registerToolSearchShim activates ToolSearch when the runtime is bound (no throw)", () => {
+  const pi = makeFakePi({ activeTools: ["bash", "read"] });
+  registerToolSearchShim(pi as any);
+  assert.ok(pi.registered.includes("ToolSearch"));
+  assert.equal(pi.setCalls.length, 1, "setActiveTools called once to add ToolSearch");
+  assert.ok(pi.setCalls[0]!.includes("ToolSearch"), "ToolSearch added to the active set");
+});
+
+test("registerToolSearchShim does not re-add ToolSearch if already active", () => {
+  const pi = makeFakePi({ activeTools: ["ToolSearch", "bash"] });
+  registerToolSearchShim(pi as any);
+  assert.ok(pi.registered.includes("ToolSearch"));
+  assert.equal(pi.setCalls.length, 0, "setActiveTools not called when ToolSearch is already active");
+});
+

package/src/resources/extensions/gsd/tests/tool-surface-readiness.test.ts

@@ -305,23 +305,42 @@ describe("awaitWorkflowMcpToolRegistration", () => {
 });
 
 describe("readiness error classification contract", () => {
-  const readinessError = getToolSurfaceReadinessError({
+  const terminalReadinessError = getToolSurfaceReadinessError({
     unitType: "run-uat",
     workflowServerName: SERVER,
     observation: { tools: [], mcpServers: [{ name: SERVER, status: "failed" }] },
   })!;
+  const transientReadinessError = getToolSurfaceReadinessError({
+    unitType: "run-uat",
+    workflowServerName: SERVER,
+    observation: { tools: [], mcpServers: [{ name: SERVER, status: "pending" }] },
+  })!;
 
-  test("auto-tool-tracking treats the readiness error as tool-unavailable", () => {
-    assert.equal(isToolUnavailableError(readinessError), true);
+  test("auto-tool-tracking treats both readiness error variants as tool-unavailable", () => {
+    assert.equal(isToolUnavailableError(terminalReadinessError), true);
+    assert.equal(isToolUnavailableError(transientReadinessError), true);
   });
 
-  test("error-classifier treats the readiness error as transient", () => {
-    const cls = classifyError(`Claude Code error: ${readinessError}`);
+  test("error-classifier treats a TERMINAL readiness error as non-transient (#783)", () => {
+    const cls = classifyError(`Claude Code error: ${terminalReadinessError}`);
+    assert.equal(isTransient(cls), false);
+    assert.equal(cls.kind, "permanent");
+  });
+
+  test("error-classifier still treats a TRANSIENT readiness error as transient", () => {
+    const cls = classifyError(`Claude Code error: ${transientReadinessError}`);
     assert.equal(isTransient(cls), true);
+    assert.equal(cls.kind, "network");
+  });
+
+  test("Recovery Classification escalates a TERMINAL readiness error instead of retrying (#783)", () => {
+    const recovery = classifyFailure({ error: new Error(terminalReadinessError), unitType: "run-uat", unitId: "M001" });
+    assert.equal(recovery.action, "escalate");
+    assert.notEqual(recovery.failureKind, "tool-unavailable");
   });
 
-  test("Recovery Classification maps the readiness error to tool-unavailable → retry", () => {
-    const recovery = classifyFailure({ error: new Error(readinessError), unitType: "run-uat", unitId: "M001" });
+  test("Recovery Classification still retries a TRANSIENT readiness error", () => {
+    const recovery = classifyFailure({ error: new Error(transientReadinessError), unitType: "run-uat", unitId: "M001" });
     assert.equal(recovery.failureKind, "tool-unavailable");
     assert.equal(recovery.action, "retry");
     assert.equal(recovery.exitReason, "tool-unavailable");

package/src/resources/extensions/gsd/tests/tool-unavailable-retry.test.ts

@@ -31,3 +31,26 @@ describe("toolUnavailableRetries on AutoSession", () => {
     assert.equal(s.toolUnavailableRetries, 3);
   });
 });
+
+describe("tool-unavailable retry backoff (#817)", () => {
+  // Mirrors the delay formula in auto-post-unit.ts. The MCP workflow server can
+  // take tens of seconds to finish connecting, so the backoff must start high
+  // enough that re-dispatch does not land before the server is ready.
+  const backoffMs = (retry: number) =>
+    Math.min(10_000 * Math.pow(2, retry - 1), 45_000);
+
+  test("starts at 10s, doubles, and caps at 45s", () => {
+    assert.equal(backoffMs(1), 10_000);
+    assert.equal(backoffMs(2), 20_000);
+    assert.equal(backoffMs(3), 40_000);
+  });
+
+  test("never exceeds the 45s cap", () => {
+    assert.equal(backoffMs(4), 45_000);
+    assert.equal(backoffMs(10), 45_000);
+  });
+
+  test("first retry survives a multi-second MCP startup (regression for 1s delay)", () => {
+    assert.ok(backoffMs(1) >= 10_000, "first retry must wait at least 10s");
+  });
+});