@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.0b870afa

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts

@@ -10,6 +10,7 @@ import { DISCUSS_TOOLS_ALLOWLIST } from "../constants.ts";
 import { buildMinimalAutoGsdToolSet, buildMinimalGsdToolSet, buildMinimalGsdWorkflowToolSet, buildRequestScopedGsdToolSet, MINIMAL_AUTO_BASE_TOOL_NAMES, MINIMAL_GSD_TOOL_NAMES, requestHasGsdCustomType, restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch } from "../bootstrap/register-hooks.ts";
 import { filterToolsForProvider } from "../model-router.ts";
 import { applyUnitSkillVisibility } from "../skill-scope.ts";
+import { drainLogs } from "../workflow-logger.ts";
 
 test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surface", () => {
   const result = buildMinimalGsdToolSet([
@@ -17,6 +18,7 @@ test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surf
     "read",
     "browser_open",
     "gsd_plan_milestone",
+    "gsd_plan_slice",
     "gsd_task_complete",
     "gsd_exec",
     "gsd_exec_search",
@@ -24,7 +26,9 @@ test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surf
     "gsd_milestone_status",
     "gsd_checkpoint_db",
     "memory_query",
+    "gsd_memory_query",
     "capture_thought",
+    "gsd_capture_thought",
     "gsd_graph",
   ]);
 
@@ -101,6 +105,40 @@ test("buildMinimalAutoGsdToolSet keeps unit-specific completion tools without al
   assert.ok(!result.includes("gsd_complete_slice"));
 });
 
+test("buildMinimalAutoGsdToolSet warns when plan-milestone required tools are unresolved", () => {
+  drainLogs();
+  const result = buildMinimalAutoGsdToolSet(
+    [
+      "ask_user_questions",
+      "bash",
+      "read",
+      "gsd_milestone_status",
+      "gsd_plan_milestone",
+    ],
+    "plan-milestone",
+    [
+      "ask_user_questions",
+      "bash",
+      "read",
+      "gsd_milestone_status",
+      "gsd_plan_milestone",
+    ],
+  );
+
+  assert.ok(result.includes("gsd_plan_milestone"));
+  assert.ok(!result.includes("gsd_plan_slice"));
+
+  const logs = drainLogs();
+  assert.ok(
+    logs.some((entry) =>
+      entry.component === "bootstrap" &&
+      entry.message.includes("buildMinimalAutoGsdToolSet(plan-milestone)") &&
+      entry.message.includes("gsd_plan_slice")
+    ),
+    `expected missing gsd_plan_slice bootstrap warning, got ${JSON.stringify(logs)}`,
+  );
+});
+
 test("buildMinimalAutoGsdToolSet scopes run-uat to UAT-specific and read-only tools", () => {
   const active = ["ask_user_questions", "bash", "read", "edit", "write", "gsd_summary_save"];
   const registered = [
@@ -575,6 +613,82 @@ test("scopeGsdWorkflowToolsForDispatch applies and restores per-unit skill visib
   assert.equal(calls.filter((call) => call.kind === "skills").length, 2);
 });
 
+// ── Regression #534: auto-mode subprocess cannot call gsd_memory_query / gsd_capture_thought ──
+// MCP-workflow subprocesses register the gsd_-prefixed variants, not the pi-native names.
+// MINIMAL_GSD_TOOL_NAMES must include both so resolveScopedToolNames exposes them.
+
+test("MINIMAL_GSD_TOOL_NAMES includes gsd_memory_query and gsd_capture_thought (regression #534)", () => {
+  assert.ok(
+    (MINIMAL_GSD_TOOL_NAMES as readonly string[]).includes("gsd_memory_query"),
+    "MINIMAL_GSD_TOOL_NAMES must include gsd_memory_query for MCP-workflow surface parity",
+  );
+  assert.ok(
+    (MINIMAL_GSD_TOOL_NAMES as readonly string[]).includes("gsd_capture_thought"),
+    "MINIMAL_GSD_TOOL_NAMES must include gsd_capture_thought for MCP-workflow surface parity",
+  );
+});
+
+test("buildMinimalAutoGsdToolSet resolves MCP-scoped gsd_memory_query and gsd_capture_thought when subprocess only registers gsd_-prefixed variants (regression #534)", () => {
+  // Simulate a subprocess that only exposes gsd_-prefixed MCP tool names,
+  // not the pi-native memory_query / capture_thought variants.
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "mcp__gsd-workflow__gsd_exec",
+    "mcp__gsd-workflow__gsd_memory_query",
+    "mcp__gsd-workflow__gsd_capture_thought",
+  ], "execute-task");
+
+  assert.ok(
+    result.includes("mcp__gsd-workflow__gsd_memory_query"),
+    "mcp__gsd-workflow__gsd_memory_query must be included when only the gsd_-prefixed variant is available",
+  );
+  assert.ok(
+    result.includes("mcp__gsd-workflow__gsd_capture_thought"),
+    "mcp__gsd-workflow__gsd_capture_thought must be included when only the gsd_-prefixed variant is available",
+  );
+});
+
+// ── Regression #627: auto-mode cannot run plan-milestone because gsd_plan_slice is missing ──
+// gsd_plan_slice is in AUTO_UNIT_SCOPED_TOOLS["plan-milestone"] (via unit-tool-contracts).
+// buildMinimalAutoGsdToolSet must expose it when unitType is "plan-milestone".
+
+test("buildMinimalAutoGsdToolSet includes gsd_plan_slice for plan-milestone (regression #627)", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "gsd_plan_milestone",
+    "gsd_plan_slice",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "memory_query",
+    "capture_thought",
+  ], "plan-milestone");
+
+  assert.ok(
+    result.includes("gsd_plan_slice"),
+    "gsd_plan_slice must be included in plan-milestone auto-mode tool set",
+  );
+});
+
+test("buildMinimalAutoGsdToolSet resolves MCP-scoped gsd_plan_slice for plan-milestone when subprocess only registers prefixed variant (regression #627)", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "mcp__gsd-workflow__gsd_plan_milestone",
+    "mcp__gsd-workflow__gsd_plan_slice",
+    "mcp__gsd-workflow__gsd_milestone_status",
+    "mcp__gsd-workflow__gsd_checkpoint_db",
+    "mcp__gsd-workflow__memory_query",
+    "mcp__gsd-workflow__capture_thought",
+  ], "plan-milestone");
+
+  assert.ok(
+    result.includes("mcp__gsd-workflow__gsd_plan_slice"),
+    "mcp__gsd-workflow__gsd_plan_slice must be included when only the MCP-scoped variant is available",
+  );
+});
+
 test("applyUnitSkillVisibility sets manifest or clears for wildcard", () => {
   const calls: Array<string[] | undefined> = [];
   applyUnitSkillVisibility({

package/src/resources/extensions/gsd/tests/tool-availability-audit.test.ts

@@ -141,6 +141,41 @@ for (const customType of ["gsd-discuss", "gsd-run"] as const) {
   });
 }
 
+for (const unitType of ["execute-task", "execute-task-simple", "reactive-execute"] as const) {
+  test(`${unitType}: resolves gsd_task_complete via alias gsd_complete_task when only alias is registered`, () => {
+    // Simulates the MCP transport registering gsd_complete_task (alias) instead of gsd_task_complete.
+    // adjust_tool_set strips aliases from providerCompatible, so gsd_complete_task is only present
+    // in registeredToolNames. resolveScopedToolNames must still surface it so the agent can complete tasks.
+    const base: string[] = [...FULL_REGISTERED_TOOLS];
+    const aliasOnlyRegistered = base
+      .filter((name) => name !== "gsd_task_complete")
+      .concat("gsd_complete_task");
+    const aliasStrippedActive = aliasOnlyRegistered.filter((name) => name !== "gsd_complete_task");
+
+    const result = buildMinimalAutoGsdToolSet(aliasStrippedActive, unitType, aliasOnlyRegistered);
+
+    assert.ok(
+      result.includes("gsd_task_complete") || result.includes("gsd_complete_task"),
+      `${unitType} missing gsd_task_complete / gsd_complete_task — agent cannot complete tasks`,
+    );
+  });
+
+  test(`${unitType}: alias does not duplicate canonical when both are in the active set`, () => {
+    // When both canonical and alias are registered/active, only the canonical should be surfaced.
+    const bothPresent: string[] = [...FULL_REGISTERED_TOOLS, "gsd_complete_task"];
+
+    const result = buildMinimalAutoGsdToolSet(bothPresent, unitType, bothPresent);
+
+    const hasCanonical = result.includes("gsd_task_complete");
+    const hasAlias = result.includes("gsd_complete_task");
+    assert.ok(hasCanonical || hasAlias, `${unitType} missing completion tool`);
+    assert.ok(
+      !(hasCanonical && hasAlias),
+      `${unitType} surfaces both gsd_task_complete and gsd_complete_task — alias should not duplicate canonical`,
+    );
+  });
+}
+
 test("discuss-milestone two-stage scoping matches adjust_tool_set request scope", () => {
   const activeTools = simulateDiscussAllowlistFilter(FULL_REGISTERED_TOOLS);
   const dispatchScoped = buildMinimalAutoGsdToolSet(

package/src/resources/extensions/gsd/tests/tool-invocation-error-loop-break.test.ts

@@ -48,6 +48,7 @@ import {
   isDeterministicPolicyError,
   isPendingUserApprovalGateError,
   isToolInvocationError,
+  isToolUnavailableError,
   isQueuedUserMessageSkip,
 } from "../auto-tool-tracking.ts";
 import {
@@ -121,6 +122,13 @@ describe("#2883: isToolInvocationError classification", () => {
     assert.equal(isToolInvocationError("No such tool available: mcp__gsd-workflow__memory_query"), true);
   });
 
+  test("isToolUnavailableError singles out the startup-race error as transient", () => {
+    assert.equal(isToolUnavailableError("No such tool available: mcp__gsd-workflow__gsd_uat_exec"), true);
+    assert.equal(isToolUnavailableError("Validation failed for tool gsd_complete_slice"), false);
+    assert.equal(isToolUnavailableError("Unexpected end of JSON input"), false);
+    assert.equal(isToolUnavailableError(""), false);
+  });
+
   test("detects ESM export-link errors", () => {
     assert.equal(
       isToolInvocationError("The requested module '../paths.js' does not provide an export named 'gsdProjectionRoot'"),

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

@@ -5,6 +5,10 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { registerDbTools } from '../bootstrap/db-tools.ts';
 import { getLegacyTelemetry, resetLegacyTelemetry } from '../legacy-telemetry.ts';
+import {
+  WORKFLOW_TOOL_ALIAS_PAIRS,
+  WORKFLOW_TOOL_CONTRACTS,
+} from '../workflow-tool-surface.ts';
 
 
 // ─── Mock PI ──────────────────────────────────────────────────────────────────
@@ -17,49 +21,38 @@ function makeMockPi() {
   } as any;
 }
 
-// ─── Rename map ───────────────────────────────────────────────────────────────
-
-const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
-  { canonical: "gsd_decision_save", alias: "gsd_save_decision" },
-  { canonical: "gsd_requirement_update", alias: "gsd_update_requirement" },
-  { canonical: "gsd_requirement_save", alias: "gsd_save_requirement" },
-  { canonical: "gsd_summary_save", alias: "gsd_save_summary" },
-  { canonical: "gsd_milestone_generate_id", alias: "gsd_generate_milestone_id" },
-  { canonical: "gsd_task_complete", alias: "gsd_complete_task" },
-  { canonical: "gsd_slice_complete", alias: "gsd_complete_slice" },
-  { canonical: "gsd_plan_milestone", alias: "gsd_milestone_plan" },
-  { canonical: "gsd_plan_slice", alias: "gsd_slice_plan" },
-  { canonical: "gsd_plan_task", alias: "gsd_task_plan" },
-  { canonical: "gsd_replan_slice", alias: "gsd_slice_replan" },
-  { canonical: "gsd_reassess_roadmap", alias: "gsd_roadmap_reassess" },
-  { canonical: "gsd_complete_milestone", alias: "gsd_milestone_complete" },
-  { canonical: "gsd_validate_milestone", alias: "gsd_milestone_validate" },
-  { canonical: "gsd_task_reopen", alias: "gsd_reopen_task" },
-  { canonical: "gsd_slice_reopen", alias: "gsd_reopen_slice" },
-  { canonical: "gsd_milestone_reopen", alias: "gsd_reopen_milestone" },
-];
-
-const STANDALONE_TOOLS = [
-  "gsd_save_gate_result",
-  "gsd_skip_slice",
-  "gsd_uat_result_save",
-];
-
 // ─── Registration count ──────────────────────────────────────────────────────
 
 console.log('\n── Tool naming: registration count ──');
 
 const pi = makeMockPi();
 registerDbTools(pi);
-
+const toolByName = new Map<string, any>(pi.tools.map((tool: any) => [tool.name, tool]));
+const registeredCanonicalNames = new Set<string>(
+  WORKFLOW_TOOL_CONTRACTS
+    .map((tool) => tool.canonicalName)
+    .filter((name) => toolByName.has(name)),
+);
+const RENAME_MAP = WORKFLOW_TOOL_ALIAS_PAIRS.filter(({ canonical }) =>
+  registeredCanonicalNames.has(canonical),
+);
+const STANDALONE_TOOLS = WORKFLOW_TOOL_CONTRACTS
+  .filter((tool) => registeredCanonicalNames.has(tool.canonicalName) && tool.aliases.length === 0)
+  .map((tool) => tool.canonicalName);
+const expectedRegisteredNames = [
+  ...STANDALONE_TOOLS,
+  ...RENAME_MAP.flatMap(({ canonical, alias }) => [canonical, alias]),
+].sort();
+
+assert.equal(pi.tools.length, toolByName.size, 'Tool registration should not produce duplicate names');
 assert.deepStrictEqual(
-  pi.tools.length,
-  RENAME_MAP.length * 2 + STANDALONE_TOOLS.length,
-  'Should register canonical/alias tool pairs plus standalone DB tools',
+  [...toolByName.keys()].sort(),
+  expectedRegisteredNames,
+  'Should register only workflow surface tools and their declared aliases',
 );
 
 for (const name of STANDALONE_TOOLS) {
-  assert.ok(pi.tools.some((t: any) => t.name === name), `Standalone tool "${name}" should be registered`);
+  assert.ok(toolByName.has(name), `Standalone tool "${name}" should be registered`);
 }
 
 // ─── Both names exist for each pair ──────────────────────────────────────────
@@ -67,8 +60,8 @@ for (const name of STANDALONE_TOOLS) {
 console.log('\n── Tool naming: canonical and alias names exist ──');
 
 for (const { canonical, alias } of RENAME_MAP) {
-  const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
-  const aliasTool = pi.tools.find((t: any) => t.name === alias);
+  const canonicalTool = toolByName.get(canonical);
+  const aliasTool = toolByName.get(alias);
 
   assert.ok(canonicalTool !== undefined, `Canonical tool "${canonical}" should be registered`);
   assert.ok(aliasTool !== undefined, `Alias tool "${alias}" should be registered`);
@@ -79,8 +72,8 @@ for (const { canonical, alias } of RENAME_MAP) {
 console.log('\n── Tool naming: alias execute wrapper ──');
 
 for (const { canonical, alias } of RENAME_MAP) {
-  const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
-  const aliasTool = pi.tools.find((t: any) => t.name === alias);
+  const canonicalTool = toolByName.get(canonical);
+  const aliasTool = toolByName.get(alias);
 
   if (canonicalTool && aliasTool) {
     assert.ok(
@@ -91,8 +84,8 @@ for (const { canonical, alias } of RENAME_MAP) {
 }
 
 test("alias execute increments legacy MCP alias telemetry before delegating", async () => {
-  const canonicalTool = pi.tools.find((t: any) => t.name === "gsd_decision_save");
-  const aliasTool = pi.tools.find((t: any) => t.name === "gsd_save_decision");
+  const canonicalTool = toolByName.get("gsd_decision_save");
+  const aliasTool = toolByName.get("gsd_save_decision");
   assert.ok(canonicalTool);
   assert.ok(aliasTool);
 
@@ -120,7 +113,7 @@ test("alias execute increments legacy MCP alias telemetry before delegating", as
 console.log('\n── Tool naming: alias descriptions ──');
 
 for (const { canonical, alias } of RENAME_MAP) {
-  const aliasTool = pi.tools.find((t: any) => t.name === alias);
+  const aliasTool = toolByName.get(alias);
 
   if (aliasTool) {
     assert.ok(
@@ -135,7 +128,7 @@ for (const { canonical, alias } of RENAME_MAP) {
 console.log('\n── Tool naming: canonical promptGuidelines use canonical name ──');
 
 for (const { canonical } of RENAME_MAP) {
-  const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
+  const canonicalTool = toolByName.get(canonical);
 
   if (canonicalTool) {
     const guidelinesText = canonicalTool.promptGuidelines.join(' ');
@@ -151,7 +144,7 @@ for (const { canonical } of RENAME_MAP) {
 console.log('\n── Tool naming: alias promptGuidelines redirect to canonical ──');
 
 for (const { canonical, alias } of RENAME_MAP) {
-  const aliasTool = pi.tools.find((t: any) => t.name === alias);
+  const aliasTool = toolByName.get(alias);
 
   if (aliasTool) {
     const guidelinesText = aliasTool.promptGuidelines.join(' ');

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

@@ -0,0 +1,155 @@
+// Project/App: gsd-pi
+// File Purpose: Contract coverage for the Tool Surface Readiness gate and its recovery classification.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { getToolSurfaceReadinessError } from "../tool-surface-readiness.ts";
+import { isToolUnavailableError } from "../auto-tool-tracking.ts";
+import { classifyError, isTransient } from "../error-classifier.ts";
+import { toMcpToolName } from "../mcp-tool-name.ts";
+import { classifyFailure } from "../recovery-classification.ts";
+
+const SERVER = "gsd-workflow";
+
+function prefixed(tool: string): string {
+  return toMcpToolName(SERVER, tool);
+}
+
+const RUN_UAT_TOOLS = [
+  "gsd_uat_exec",
+  "gsd_uat_result_save",
+  "gsd_resume",
+  "gsd_milestone_status",
+  "gsd_journal_query",
+];
+
+describe("getToolSurfaceReadinessError", () => {
+  test("returns null when no unit type or no workflow server is in play", () => {
+    const observation = { tools: [], mcpServers: [] };
+    assert.equal(
+      getToolSurfaceReadinessError({ unitType: undefined, workflowServerName: SERVER, observation }),
+      null,
+    );
+    assert.equal(
+      getToolSurfaceReadinessError({ unitType: "run-uat", workflowServerName: undefined, observation }),
+      null,
+    );
+  });
+
+  test("returns null for units with no required workflow tools", () => {
+    const error = getToolSurfaceReadinessError({
+      unitType: "rewrite-docs",
+      workflowServerName: SERVER,
+      observation: { tools: [], mcpServers: [{ name: SERVER, status: "failed" }] },
+    });
+    assert.equal(error, null);
+  });
+
+  test("returns an error when the expected workflow server is absent from the init surface", () => {
+    const error = getToolSurfaceReadinessError({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      observation: { tools: ["read", "bash"], mcpServers: [{ name: "other-server", status: "connected" }] },
+    });
+    assert.ok(error, "expected a readiness error when the workflow server is absent");
+    assert.match(error, /workflow tool surface not ready for run-uat/);
+    assert.match(error, /absent from the init surface/);
+    assert.match(error, /gsd_uat_exec/);
+  });
+
+  test("passes a still-connecting (pending) server through instead of aborting", () => {
+    // The SDK reports still-connecting servers as "pending" at init — the
+    // common healthy session. A genuine miss after pass-through is caught
+    // in-session ("No such tool available" → tool-unavailable → retry).
+    const error = getToolSurfaceReadinessError({
+      unitType: "plan-slice",
+      workflowServerName: SERVER,
+      observation: { tools: ["read", "bash"], mcpServers: [{ name: SERVER, status: "pending" }] },
+    });
+    assert.equal(error, null);
+  });
+
+  test("returns null when all required tools are registered under the MCP prefix", () => {
+    const error = getToolSurfaceReadinessError({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      observation: {
+        tools: ["read", ...RUN_UAT_TOOLS.map(prefixed)],
+        mcpServers: [{ name: SERVER, status: "connected" }],
+      },
+    });
+    assert.equal(error, null);
+  });
+
+  test("reports the failed server and the missing tools when the surface never registered", () => {
+    const error = getToolSurfaceReadinessError({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      observation: { tools: ["read", "bash"], mcpServers: [{ name: SERVER, status: "failed" }] },
+    });
+    assert.ok(error, "expected a readiness error");
+    assert.match(error, /workflow tool surface not ready for run-uat/);
+    assert.match(error, /status is "failed"/);
+    assert.match(error, /gsd_uat_exec/);
+  });
+
+  test("aborts on needs-auth (terminal — cannot self-heal)", () => {
+    const error = getToolSurfaceReadinessError({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      observation: { tools: ["read", "bash"], mcpServers: [{ name: SERVER, status: "needs-auth" }] },
+    });
+    assert.ok(error, "expected a readiness error for needs-auth");
+    assert.match(error, /status is "needs-auth"/);
+  });
+
+  test("aborts on disabled (terminal — cannot self-heal)", () => {
+    const error = getToolSurfaceReadinessError({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      observation: { tools: ["read", "bash"], mcpServers: [{ name: SERVER, status: "disabled" }] },
+    });
+    assert.ok(error, "expected a readiness error for disabled");
+    assert.match(error, /status is "disabled"/);
+  });
+
+  test("reports partially-registered surfaces even when the server says connected", () => {
+    const error = getToolSurfaceReadinessError({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      observation: {
+        tools: [prefixed("gsd_uat_exec")],
+        mcpServers: [{ name: SERVER, status: "connected" }],
+      },
+    });
+    assert.ok(error, "expected a readiness error");
+    assert.match(error, /connected but has not registered/);
+    assert.match(error, /gsd_uat_result_save/);
+    assert.doesNotMatch(error, /gsd_uat_exec,/);
+  });
+});
+
+describe("readiness error classification contract", () => {
+  const readinessError = getToolSurfaceReadinessError({
+    unitType: "run-uat",
+    workflowServerName: SERVER,
+    observation: { tools: [], mcpServers: [{ name: SERVER, status: "failed" }] },
+  })!;
+
+  test("auto-tool-tracking treats the readiness error as tool-unavailable", () => {
+    assert.equal(isToolUnavailableError(readinessError), true);
+  });
+
+  test("error-classifier treats the readiness error as transient", () => {
+    const cls = classifyError(`Claude Code error: ${readinessError}`);
+    assert.equal(isTransient(cls), true);
+  });
+
+  test("Recovery Classification maps the readiness error to tool-unavailable → retry", () => {
+    const recovery = classifyFailure({ error: new Error(readinessError), 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

@@ -0,0 +1,33 @@
+/**
+ * Regression test for MCP tool-availability race.
+ *
+ * When the MCP workflow server is still connecting, tool calls fail with
+ * "No such tool available". The bounded retry counter on AutoSession
+ * (toolUnavailableRetries) prevents infinite re-dispatch loops by capping
+ * retries at 3 with escalating delay, then pausing auto-mode.
+ */
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { AutoSession } from "../auto/session.ts";
+
+describe("toolUnavailableRetries on AutoSession", () => {
+  test("defaults to 0", () => {
+    const s = new AutoSession();
+    assert.equal(s.toolUnavailableRetries, 0);
+  });
+
+  test("is cleared on reset()", () => {
+    const s = new AutoSession();
+    s.toolUnavailableRetries = 2;
+    s.reset();
+    assert.equal(s.toolUnavailableRetries, 0);
+  });
+
+  test("accumulates across assignments (simulates retry increments)", () => {
+    const s = new AutoSession();
+    s.toolUnavailableRetries = 1;
+    s.toolUnavailableRetries = 2;
+    s.toolUnavailableRetries = 3;
+    assert.equal(s.toolUnavailableRetries, 3);
+  });
+});