gsd-pi 2.77.0-dev.58d3d4d6c → 2.77.0-dev.cfd69e714

package/src/resources/extensions/gsd/tests/pipeline-variant-dispatch.test.ts

@@ -0,0 +1,301 @@
+// GSD-2 — #4781 phase 2: dispatch-rule gates read pipeline variant from DB.
+// Behavior tests (not source-grep) — construct a real tmpdir DB, insert a
+// milestone whose planning fields classify to the target variant, exercise
+// DISPATCH_RULES.match(), assert the gate result.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  upsertMilestonePlanning,
+  insertSlice,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import type { GSDState } from "../types.ts";
+
+const PARALLEL_RESEARCH_RULE = "planning (multiple slices need research) → parallel-research-slices";
+const SINGLE_RESEARCH_RULE = "planning (no research, not S01) → research-slice";
+const VALIDATE_RULE = "validating-milestone → validate-milestone";
+
+// ─── Fixture helpers ──────────────────────────────────────────────────────
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-pipeline-variant-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "tasks"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  invalidateAllCaches();
+  rmSync(base, { recursive: true, force: true });
+}
+
+interface SeedOpts {
+  title: string;
+  vision: string;
+  successCriteria: string[];
+}
+
+function seedMilestone(base: string, mid: string, opts: SeedOpts): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({
+    id: mid,
+    title: opts.title,
+    status: "active",
+    depends_on: [],
+  });
+  upsertMilestonePlanning(mid, {
+    title: opts.title,
+    status: "active",
+    vision: opts.vision,
+    successCriteria: opts.successCriteria,
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
+  });
+  insertSlice({
+    id: "S01",
+    milestoneId: mid,
+    title: "First",
+    status: "pending",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+  insertSlice({
+    id: "S02",
+    milestoneId: mid,
+    title: "Second",
+    status: "pending",
+    risk: "low",
+    depends: ["S01"],
+    demo: "",
+    sequence: 2,
+  });
+}
+
+function findRule(name: string) {
+  const rule = DISPATCH_RULES.find(r => r.name === name);
+  assert.ok(rule, `rule "${name}" must exist`);
+  return rule!;
+}
+
+function makeCtx(params: {
+  base: string;
+  mid: string;
+  phase: GSDState["phase"];
+  activeSlice?: { id: string; title: string };
+}): DispatchContext {
+  const state: GSDState = {
+    phase: params.phase,
+    activeMilestone: { id: params.mid, title: "Test" },
+    activeSlice: params.activeSlice ?? null,
+    activeTask: null,
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [{ id: params.mid, title: "Test", status: "active" }],
+  };
+  return {
+    basePath: params.base,
+    mid: params.mid,
+    midTitle: "Test",
+    state,
+    prefs: undefined,
+  };
+}
+
+// Inputs that consistently classify.
+const TRIVIAL_INPUT: SeedOpts = {
+  title: "Static To-Do App",
+  vision: "A minimal, clean browser-based to-do app. Pure HTML/CSS/JS, no build step, no backend. Tasks persist in localStorage.",
+  successCriteria: [
+    "Open index.html in any browser without a server",
+    "Tasks survive a page reload via localStorage",
+  ],
+};
+
+const STANDARD_INPUT: SeedOpts = {
+  title: "Billing API extension",
+  vision: "Extend the billing API to charge usage-tier overages. Touch the invoice service, the entitlements cache, and the webhook handler.",
+  successCriteria: [
+    "Overage charges generate correct invoices",
+    "Integration tests cover tier rollovers",
+    "API endpoint returns structured error on webhook failure",
+  ],
+};
+
+// ─── Research-slice gate (single) ─────────────────────────────────────────
+
+test("#4781 phase 2: single research-slice rule skips dispatch for trivial variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", TRIVIAL_INPUT);
+  const ctx = makeCtx({
+    base,
+    mid: "M001",
+    phase: "planning",
+    activeSlice: { id: "S02", title: "Second" },
+  });
+
+  const result = await findRule(SINGLE_RESEARCH_RULE).match(ctx);
+  assert.strictEqual(result, null, "trivial variant must skip research-slice dispatch");
+});
+
+test("#4781 phase 2: single research-slice rule proceeds normally for standard variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", STANDARD_INPUT);
+  const ctx = makeCtx({
+    base,
+    mid: "M001",
+    phase: "planning",
+    activeSlice: { id: "S02", title: "Second" },
+  });
+
+  // No RESEARCH file exists → rule should reach the dispatch branch.
+  // We don't assert "dispatch" because the prompt builder may error with
+  // minimal fixture data; we assert "not null AND not a trivial-skip
+  // shortcut" by checking that if null was returned, it's for a known
+  // reason (research file exists). For this fixture none exists, so the
+  // result should be an action object.
+  const result = await findRule(SINGLE_RESEARCH_RULE).match(ctx);
+  assert.notStrictEqual(result, null, "standard variant must not short-circuit the research-slice gate");
+});
+
+// ─── Parallel research-slice gate ─────────────────────────────────────────
+
+test("#4781 phase 2: parallel-research-slices rule skips dispatch for trivial variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", TRIVIAL_INPUT);
+  // Roadmap needs to be readable for the parallel rule to enter its slice
+  // analysis. Write a minimal one.
+  const { writeFileSync } = await import("node:fs");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "## Slices",
+      "- [ ] **S01: First** `risk:low` `depends:[]`",
+      "- [ ] **S02: Second** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+
+  const ctx = makeCtx({ base, mid: "M001", phase: "planning" });
+  const result = await findRule(PARALLEL_RESEARCH_RULE).match(ctx);
+  assert.strictEqual(result, null, "trivial variant must skip parallel-research dispatch");
+});
+
+// ─── Validate-milestone gate ──────────────────────────────────────────────
+
+test("#4781 phase 2: validate-milestone rule writes pass-through VALIDATION for trivial variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", TRIVIAL_INPUT);
+  // findMissingSummaries checks slice SUMMARY files — write empty ones so
+  // the safety guard doesn't stop first.
+  const { writeFileSync } = await import("node:fs");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"), "# S01\n");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-SUMMARY.md"), "# S02\n");
+  // Write a roadmap so findMissingSummaries can enumerate slice IDs.
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "## Slices",
+      "- [x] **S01: First** `risk:low` `depends:[]`",
+      "- [x] **S02: Second** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+
+  const ctx = makeCtx({ base, mid: "M001", phase: "validating-milestone" });
+  const result = await findRule(VALIDATE_RULE).match(ctx);
+
+  assert.ok(result, "rule must return a result, not null");
+  assert.strictEqual(result!.action, "skip", "trivial variant must return skip action");
+
+  const validationPath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+  assert.ok(existsSync(validationPath), "pass-through VALIDATION.md must be written");
+
+  const { readFileSync } = await import("node:fs");
+  const content = readFileSync(validationPath, "utf-8");
+  assert.match(content, /verdict: pass/);
+  assert.match(content, /trivial-scope pipeline variant \(#4781\)/);
+});
+
+test("#4781 phase 2: validate-milestone rule dispatches normally for standard variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", STANDARD_INPUT);
+  const { writeFileSync } = await import("node:fs");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"), "# S01\n");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-SUMMARY.md"), "# S02\n");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "## Slices",
+      "- [x] **S01: First** `risk:low` `depends:[]`",
+      "- [x] **S02: Second** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+
+  const ctx = makeCtx({ base, mid: "M001", phase: "validating-milestone" });
+  const result = await findRule(VALIDATE_RULE).match(ctx);
+
+  assert.ok(result, "standard variant must produce a result");
+  assert.strictEqual(result!.action, "dispatch", "standard variant must dispatch validate-milestone");
+  if (result!.action === "dispatch") {
+    assert.strictEqual(result!.unitType, "validate-milestone");
+  }
+});
+
+// ─── Fallback safety: no DB, missing milestone ────────────────────────────
+
+test("#4781 phase 2: null variant (no milestone row) does NOT gate dispatch — safe fallback", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  // Open DB but do NOT seed any milestone — getMilestone returns null,
+  // which makes getMilestonePipelineVariant return null. Rules must NOT
+  // short-circuit on null (silent downshift is the hazard we're guarding
+  // against).
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const ctx = makeCtx({
+    base,
+    mid: "M999",
+    phase: "planning",
+    activeSlice: { id: "S02", title: "Second" },
+  });
+
+  // Rule should NOT return null from the variant gate. It may still return
+  // null for other reasons (e.g. missing active slice), but our assertion
+  // is specifically about the variant-gate not short-circuiting.
+  const result = await findRule(SINGLE_RESEARCH_RULE).match(ctx);
+  // Rule reaches its normal logic; with an active slice and no RESEARCH file,
+  // it should produce a dispatch action, not null from the variant gate.
+  assert.notStrictEqual(result, null, "null variant must not cause the research-slice gate to short-circuit");
+});

package/src/resources/extensions/gsd/tests/pre-execution-pause-wiring.test.ts

@@ -191,7 +191,12 @@ function createFailingTasks(): void {
       estimate: "1h",
       files: [],
       verify: "npm test",
-      inputs: ["nonexistent-file-that-does-not-exist.ts"],
+      inputs: [
+        "nonexistent-file-that-does-not-exist.ts",
+        "missing-second-file.ts",
+        "missing-third-file.ts",
+        "missing-fourth-file.ts",
+      ],
       expectedOutput: [],
       observabilityImpact: "",
     },
@@ -308,6 +313,32 @@ describe("Pre-execution checks → pauseAuto wiring", () => {
         String(call.arguments[0]).includes("Pre-execution checks failed")
     );
     assert.ok(errorNotify, "Should show error notification about pre-execution check failure");
+    const errorMessage = String(errorNotify.arguments[0]);
+    assert.match(
+      errorMessage,
+      /Pre-execution checks failed: \d+ blocking issue/,
+      "failure notification should include the blocking issue count",
+    );
+    assert.ok(
+      errorMessage.includes("[file] nonexistent-file-that-does-not-exist.ts: Task T01 references"),
+      "failure notification should include category, target, and message details",
+    );
+    assert.ok(
+      errorMessage.includes("[file] missing-third-file.ts: Task T01 references"),
+      "failure notification should include up to three actionable check details",
+    );
+    assert.ok(
+      !errorMessage.includes("missing-fourth-file.ts"),
+      "failure notification should truncate details beyond the display limit",
+    );
+    assert.ok(
+      errorMessage.includes("...and 1 more"),
+      "failure notification should summarize truncated blocking checks",
+    );
+    assert.ok(
+      errorMessage.includes(join(".gsd", "milestones", "M001", "slices", "S01", "S01-PRE-EXEC-VERIFY.json")),
+      "failure notification should point to the relative pre-exec evidence file path",
+    );
   });
 
   test("pauseAuto is called when enhanced_verification_strict: true and pre-execution returns warn", async () => {

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));
 
@@ -405,7 +410,6 @@ test("resumeAutoAfterProviderDelay restarts paused auto-mode from the recorded b
         basePath: "/tmp/project",
       }),
       resetTransientRetryState: () => {},
-      resetSessionTimeoutState: () => {},
       startAuto: async (_ctx, _pi, base, verboseMode, options) => {
         startCalls.push({ base, verboseMode, step: options?.step });
       },
@@ -431,7 +435,6 @@ test("resumeAutoAfterProviderDelay does not double-start when auto-mode is alrea
         basePath: "/tmp/project",
       }),
       resetTransientRetryState: () => {},
-      resetSessionTimeoutState: () => {},
       startAuto: async () => {
         startCalls += 1;
       },
@@ -463,7 +466,6 @@ test("resumeAutoAfterProviderDelay leaves auto paused when no base path is avail
         basePath: "",
       }),
       resetTransientRetryState: () => {},
-      resetSessionTimeoutState: () => {},
       startAuto: async () => {
         startCalls += 1;
       },
@@ -480,7 +482,7 @@ test("resumeAutoAfterProviderDelay leaves auto paused when no base path is avail
   ]);
 });
 
-test("resumeAutoAfterProviderDelay resets provider retry state before restarting auto-mode", async () => {
+test("resumeAutoAfterProviderDelay resets provider retry state without clearing session-timeout attempts", async () => {
   const calls: string[] = [];
 
   const result = await resumeAutoAfterProviderDelay(
@@ -496,9 +498,6 @@ test("resumeAutoAfterProviderDelay resets provider retry state before restarting
       resetTransientRetryState: () => {
         calls.push("reset-transient");
       },
-      resetSessionTimeoutState: () => {
-        calls.push("reset-session-timeout");
-      },
       startAuto: async () => {
         calls.push("start-auto");
       },
@@ -508,7 +507,6 @@ test("resumeAutoAfterProviderDelay resets provider retry state before restarting
   assert.equal(result, "resumed");
   assert.deepEqual(calls, [
     "reset-transient",
-    "reset-session-timeout",
     "start-auto",
   ]);
 });
@@ -684,13 +682,12 @@ 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}`,
   );
 });
 
@@ -738,20 +735,22 @@ test("classifyError: 'context window' with 'exceed' is transient 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"));
 });

package/src/resources/extensions/gsd/tests/queue-auto-guard.test.ts

@@ -178,4 +178,36 @@ describe("Windows pre-merge DB release (#4704)", () => {
       "openDatabase() called after the pre-merge stash",
     );
   });
+
+  it("pre-merge stash targets entries by marker instead of refs/stash or stash@{0}", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "auto-worktree.ts"),
+      "utf-8",
+    );
+
+    assert.ok(src.includes("stashMarker"), "stash marker is tracked");
+    assert.ok(
+      src.includes('"stash", "list", "--format=%gd%x00%s"'),
+      "stash lookup reads ref and message together",
+    );
+    assert.ok(!src.includes('"rev-parse", "refs/stash"'), "refs/stash is not used for identity");
+    assert.ok(!src.includes('["stash", "pop"]'), "stash pop is never unqualified");
+    assert.ok(!src.includes('["stash", "drop"]'), "stash drop is never unqualified");
+  });
+
+  it("stash drop after pop failure requires auto-resolved .gsd conflicts", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "auto-worktree.ts"),
+      "utf-8",
+    );
+
+    assert.ok(
+      src.includes("gsdUU.length > 0 && nonGsdUU.length === 0"),
+      "stash drop must only run after detected .gsd conflicts were auto-resolved",
+    );
+    assert.ok(
+      src.includes("git stash pop failed without resolvable conflict files; leaving stash for manual recovery"),
+      "non-conflict stash pop failures must leave the stash for manual recovery",
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/ready-phrase-no-files-4573.test.ts

@@ -60,10 +60,24 @@ function mkBase(): string {
   return base;
 }
 
-function assistantMsg(text: string, opts: { toolUse?: boolean } = {}): any {
+function assistantMsg(
+  text: string,
+  opts: { toolUse?: boolean | "toolCall" | "serverToolUse" } = {},
+): any {
   const content: any[] = [];
   if (text) content.push({ type: "text", text });
-  if (opts.toolUse) content.push({ type: "tool_use", name: "whatever", input: {} });
+  if (opts.toolUse) {
+    // The canonical pi-ai AssistantMessage uses "toolCall" / "serverToolUse"
+    // (see packages/pi-ai/src/types.ts). Every provider — anthropic-direct,
+    // claude-code-cli, openai — normalizes incoming tool blocks into these
+    // shapes before they reach guided-flow. The Anthropic-wire literal
+    // "tool_use" never appears here.
+    if (opts.toolUse === "serverToolUse") {
+      content.push({ type: "serverToolUse", id: "test-id", name: "web_search", input: {} });
+    } else {
+      content.push({ type: "toolCall", id: "test-id", name: "whatever", arguments: {} });
+    }
+  }
   return { role: "assistant", content };
 }
 
@@ -314,6 +328,65 @@ describe("#4573 maybeHandleEmptyIntentTurn", () => {
     }
   });
 
+  // Regression for #4658 — under claude-code-cli, MCP tool calls (e.g.
+  // ask_user_questions) reach guided-flow as canonical "toolCall" / "serverToolUse"
+  // blocks. Pre-fix, hasToolUse only matched the Anthropic-wire literal "tool_use",
+  // so the empty-turn nudge fired during pre-question narration and pre-empted the
+  // user's chance to answer.
+  test("cc-cli MCP tool call surfaced as canonical toolCall → not flagged", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        {
+          messages: [
+            assistantMsg("Let me call ask_user_questions to gather your preferences.", {
+              toolUse: "toolCall",
+            }),
+          ],
+        },
+        false,
+      );
+      assert.equal(handled, false);
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("serverToolUse block (cc-cli web search etc.) → not flagged", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        {
+          messages: [
+            assistantMsg("Let me invoke the search tool now.", {
+              toolUse: "serverToolUse",
+            }),
+          ],
+        },
+        false,
+      );
+      assert.equal(handled, false);
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
   test("ready phrase is NOT treated as empty-turn (handled by other recovery path)", () => {
     const base = mkBase();
     try {