gsd-pi 2.77.0 → 2.78.0-dev.aeeb2ca00

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));
 
@@ -404,6 +409,7 @@ test("resumeAutoAfterProviderDelay restarts paused auto-mode from the recorded b
         stepMode: true,
         basePath: "/tmp/project",
       }),
+      resetTransientRetryState: () => {},
       startAuto: async (_ctx, _pi, base, verboseMode, options) => {
         startCalls.push({ base, verboseMode, step: options?.step });
       },
@@ -428,6 +434,7 @@ test("resumeAutoAfterProviderDelay does not double-start when auto-mode is alrea
         stepMode: false,
         basePath: "/tmp/project",
       }),
+      resetTransientRetryState: () => {},
       startAuto: async () => {
         startCalls += 1;
       },
@@ -458,6 +465,7 @@ test("resumeAutoAfterProviderDelay leaves auto paused when no base path is avail
         stepMode: false,
         basePath: "",
       }),
+      resetTransientRetryState: () => {},
       startAuto: async () => {
         startCalls += 1;
       },
@@ -474,6 +482,35 @@ test("resumeAutoAfterProviderDelay leaves auto paused when no base path is avail
   ]);
 });
 
+test("resumeAutoAfterProviderDelay resets provider retry state without clearing session-timeout attempts", async () => {
+  const calls: string[] = [];
+
+  const result = await resumeAutoAfterProviderDelay(
+    {} as any,
+    { ui: { notify() {} } } as any,
+    {
+      getSnapshot: () => ({
+        active: false,
+        paused: true,
+        stepMode: false,
+        basePath: "/tmp/project",
+      }),
+      resetTransientRetryState: () => {
+        calls.push("reset-transient");
+      },
+      startAuto: async () => {
+        calls.push("start-auto");
+      },
+    },
+  );
+
+  assert.equal(result, "resumed");
+  assert.deepEqual(calls, [
+    "reset-transient",
+    "start-auto",
+  ]);
+});
+
 // ── Escalating backoff for transient errors (#1166) ─────────────────────────
 
 test("agent-end-recovery.ts tracks consecutive transient errors for escalating backoff", () => {
@@ -567,31 +604,6 @@ test("resetTransientRetryState is exported from agent-end-recovery.ts", () => {
   );
 });
 
-test("provider-error-resume.ts calls resetTransientRetryState before startAuto", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "provider-error-resume.ts"), "utf-8");
-  assert.ok(
-    src.includes("resetTransientRetryState"),
-    "provider-error-resume.ts must import and call resetTransientRetryState",
-  );
-  // Ensure reset is called BEFORE startAuto — order matters
-  const resetIdx = src.indexOf("resetTransientRetryState()");
-  const startIdx = src.indexOf("await deps.startAuto(");
-  assert.ok(
-    resetIdx !== -1 && startIdx !== -1 && resetIdx < startIdx,
-    "resetTransientRetryState() must be called before deps.startAuto()",
-  );
-  // Session timeout counter must also be reset before startAuto
-  assert.ok(
-    src.includes("resetSessionTimeoutState"),
-    "provider-error-resume.ts must import and call resetSessionTimeoutState",
-  );
-  const sessionResetIdx = src.indexOf("resetSessionTimeoutState()");
-  assert.ok(
-    sessionResetIdx !== -1 && startIdx !== -1 && sessionResetIdx < startIdx,
-    "resetSessionTimeoutState() must be called before deps.startAuto()",
-  );
-});
-
 // ── Fix 2: Session creation timeout treated as transient in phases.ts ───────
 
 test("phases.ts handles timeout session-creation failures with pause instead of stopAuto", () => {
@@ -670,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}`,
   );
 });
 
@@ -724,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

@@ -0,0 +1,213 @@
+/**
+ * Tests that /gsd queue is blocked when auto-mode is active.
+ *
+ * Relates to #4704: /gsd queue writes .gsd/PROJECT.md + QUEUE-ORDER.json
+ * directly into the project-root worktree, racing with auto-mode's
+ * pre-merge dirty-tree check and causing __dirty_working_tree__ failures.
+ *
+ * The fix adds an isAutoActive() guard in handleWorkflowCommand before
+ * delegating to showQueue, mirroring the existing /gsd quick guard (#2417).
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Structural test: verify the guard exists in source ──────────────────────
+
+describe("/gsd queue auto-mode guard (#4704)", () => {
+  it("handleWorkflowCommand checks isAutoActive() before calling showQueue", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    // Find the queue command block
+    const queueBlockMatch = src.match(
+      /if\s*\(\s*trimmed\s*===\s*"queue"\s*\)\s*\{([\s\S]*?)\n  \}/,
+    );
+    assert.ok(queueBlockMatch, "queue command block exists in handleWorkflowCommand");
+
+    const queueBlock = queueBlockMatch[1];
+
+    // Verify auto-mode guard comes BEFORE showQueue call. Accepts either the
+    // inline isAutoActive() check (Tier 1) or the shared requireNotAutoActive()
+    // helper (Tier 2 / #4712).
+    const guardIndex = Math.max(
+      queueBlock.indexOf("isAutoActive()"),
+      queueBlock.indexOf("requireNotAutoActive("),
+    );
+    const showQueueIndex = queueBlock.indexOf("showQueue(");
+
+    assert.ok(guardIndex !== -1, "auto-mode guard exists in queue command block");
+    assert.ok(showQueueIndex !== -1, "showQueue() call exists in queue command block");
+    assert.ok(
+      guardIndex < showQueueIndex,
+      "auto-mode guard appears before showQueue() call",
+    );
+  });
+
+  it("guard shows error message mentioning /gsd stop", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    assert.ok(
+      src.includes("cannot run while auto-mode is active"),
+      "error message explains that the command cannot run during auto-mode",
+    );
+    assert.ok(
+      src.includes("/gsd stop"),
+      "error message mentions /gsd stop as the resolution",
+    );
+  });
+
+  it("guard returns true (handled) to prevent falling through", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    const queueBlockMatch = src.match(
+      /if\s*\(\s*trimmed\s*===\s*"queue"\s*\)\s*\{([\s\S]*?)\n  \}/,
+    );
+    assert.ok(queueBlockMatch);
+    const queueBlock = queueBlockMatch[1];
+
+    // The guard block should have its own return true before showQueue
+    const guardBlock = queueBlock.slice(0, queueBlock.indexOf("showQueue("));
+    assert.ok(
+      guardBlock.includes("return true"),
+      "guard block returns true before showQueue is reached",
+    );
+  });
+});
+
+// ─── .gsd/audit/ runtime classification regression ──────────────────────────
+
+describe(".gsd/audit/ runtime classification (#4704)", () => {
+  it("GSD_RUNTIME_PATTERNS in gitignore.ts includes .gsd/audit/", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "gitignore.ts"),
+      "utf-8",
+    );
+    assert.ok(
+      src.includes('".gsd/audit/"'),
+      ".gsd/audit/ listed in GSD_RUNTIME_PATTERNS",
+    );
+  });
+
+  it("RUNTIME_EXCLUSION_PATHS in git-service.ts includes .gsd/audit/", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "git-service.ts"),
+      "utf-8",
+    );
+    assert.ok(
+      src.includes('".gsd/audit/"'),
+      ".gsd/audit/ listed in RUNTIME_EXCLUSION_PATHS",
+    );
+  });
+
+  it("SKIP_PATHS in worktree-manager.ts includes .gsd/audit/", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "worktree-manager.ts"),
+      "utf-8",
+    );
+    assert.ok(
+      src.includes('".gsd/audit/"'),
+      ".gsd/audit/ listed in SKIP_PATHS",
+    );
+  });
+});
+
+// ─── Windows gsd.db close+reopen around pre-merge stash ─────────────────────
+
+describe("Windows pre-merge DB release (#4704)", () => {
+  it("mergeMilestoneToMain closes gsd.db on win32 before git stash", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "auto-worktree.ts"),
+      "utf-8",
+    );
+
+    // Locate the stash push line and ensure a win32-gated closeDatabase()
+    // call precedes it in the same function scope.
+    const stashIndex = src.indexOf('"stash", "push", "--include-untracked"');
+    assert.ok(stashIndex !== -1, "pre-merge stash push exists");
+
+    const beforeStash = src.slice(0, stashIndex);
+    const win32Index = beforeStash.lastIndexOf('process.platform === "win32"');
+    const closeIndex = beforeStash.lastIndexOf("closeDatabase()");
+
+    assert.ok(win32Index !== -1, "win32 platform guard appears before stash");
+    assert.ok(closeIndex !== -1, "closeDatabase() invoked before stash");
+    assert.ok(
+      win32Index < closeIndex && closeIndex < stashIndex,
+      "platform guard wraps the closeDatabase() call before the stash",
+    );
+  });
+
+  it("openDatabase is called after the stash to reopen the connection", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "auto-worktree.ts"),
+      "utf-8",
+    );
+    const stashIndex = src.indexOf('"stash", "push", "--include-untracked"');
+    const afterStash = src.slice(stashIndex);
+    assert.ok(
+      afterStash.includes("openDatabase("),
+      "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/queue-draft-detection.test.ts

@@ -6,6 +6,7 @@ import { tmpdir } from "node:os";
 
 import { deriveState } from "../state.js";
 import { buildExistingMilestonesContext } from "../guided-flow.js";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 describe('queue-draft-detection', () => {
   test('draft and context milestone detection', async () => {
@@ -68,7 +69,7 @@ describe('queue-draft-detection', () => {
 
       // both files: CONTEXT.md wins, no draft label
       const m003Idx = context.indexOf("M003:");
-      const m003Section = context.slice(m003Idx, m003Idx + 500);
+      const m003Section = extractSourceRegion(context, "M003:");
       assert.ok(
         m003Section.includes("**Context:**"),
         "M003 (both files) should use 'Context:' label (CONTEXT.md wins)",
@@ -84,7 +85,7 @@ describe('queue-draft-detection', () => {
 
       // neither file: no context section
       const m004Idx = context.indexOf("M004:");
-      const m004Section = context.slice(m004Idx, m004Idx + 500);
+      const m004Section = extractSourceRegion(context, "M004:");
       assert.ok(
         !m004Section.includes("**Context:**"),
         "M004 (neither file) should not have Context: label",

package/src/resources/extensions/gsd/tests/queued-discuss-fast-path.test.ts

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -28,7 +29,7 @@ describe("queued-discuss-fast-path", () => {
     const fnStart = source.indexOf("async function dispatchDiscussForMilestone(");
     assert.ok(fnStart > 0, "dispatchDiscussForMilestone must exist");
     const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
-    const fnBody = fnEnd > 0 ? source.slice(fnStart, fnEnd) : source.slice(fnStart, fnStart + 2000);
+    const fnBody = extractSourceRegion(source, "async function dispatchDiscussForMilestone(");
     assert.ok(
       fnBody.includes("fastPathInstruction"),
       "dispatchDiscussForMilestone must compute fastPathInstruction",
@@ -61,8 +62,7 @@ describe("queued-discuss-fast-path", () => {
     const source = guidedFlowSrc();
     const fnStart = source.indexOf("async function showDiscussQueuedMilestone(");
     assert.ok(fnStart > 0, "showDiscussQueuedMilestone must exist");
-    const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
-    const fnBody = fnEnd > 0 ? source.slice(fnStart, fnEnd) : source.slice(fnStart, fnStart + 3000);
+    const fnBody = extractSourceRegion(source, "async function showDiscussQueuedMilestone(", "\nasync function ");
     assert.ok(
       fnBody.includes("hasDraft"),
       "showDiscussQueuedMilestone must check hasDraft",
@@ -81,8 +81,7 @@ describe("queued-discuss-fast-path", () => {
     const source = guidedFlowSrc();
     const fnStart = source.indexOf("async function showDiscussQueuedMilestone(");
     assert.ok(fnStart > 0, "showDiscussQueuedMilestone must exist");
-    const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
-    const fnBody = fnEnd > 0 ? source.slice(fnStart, fnEnd) : source.slice(fnStart, fnStart + 3000);
+    const fnBody = extractSourceRegion(source, "async function showDiscussQueuedMilestone(", "\nasync function ");
     assert.ok(
       fnBody.includes("let fastPath = hasDraft"),
       "showDiscussQueuedMilestone must set fastPath = hasDraft so draft presence auto-enables fast path",

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

@@ -35,15 +35,20 @@ describe("/gsd quick auto-mode guard (#2417)", () => {
 
     const quickBlock = quickBlockMatch[1];
 
-    // Verify isAutoActive guard comes BEFORE handleQuick call
-    const guardIndex = quickBlock.indexOf("isAutoActive()");
+    // Verify the shared auto-mode guard comes BEFORE handleQuick call.
+    // Accepts either the inline isAutoActive() check (legacy) or the shared
+    // requireNotAutoActive() helper (#4712).
+    const guardIndex = Math.max(
+      quickBlock.indexOf("isAutoActive()"),
+      quickBlock.indexOf("requireNotAutoActive("),
+    );
     const handleQuickIndex = quickBlock.indexOf("handleQuick(");
 
-    assert.ok(guardIndex !== -1, "isAutoActive() guard exists in quick command block");
+    assert.ok(guardIndex !== -1, "auto-mode guard exists in quick command block");
     assert.ok(handleQuickIndex !== -1, "handleQuick() call exists in quick command block");
     assert.ok(
       guardIndex < handleQuickIndex,
-      "isAutoActive() guard appears before handleQuick() call",
+      "auto-mode guard appears before handleQuick() call",
     );
   });
 
@@ -59,10 +64,11 @@ describe("/gsd quick auto-mode guard (#2417)", () => {
       "utf-8",
     );
 
-    // The error message should tell the user to stop auto-mode first
+    // The shared helper assembles the message dynamically from the command name,
+    // so assert on the message fragment and the /gsd stop instruction.
     assert.ok(
-      src.includes("/gsd quick cannot run while auto-mode is active"),
-      "error message explains that quick cannot run during auto-mode",
+      src.includes("cannot run while auto-mode is active"),
+      "error message explains that the command cannot run during auto-mode",
     );
     assert.ok(
       src.includes("/gsd stop"),

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 {