gsd-pi 2.76.0 → 2.77.0-dev.1594b263e

package/src/resources/extensions/gsd/tests/auto-retry-mcp-churn-fixes.test.ts

@@ -1,20 +1,20 @@
 /**
  * Regression tests for PR #4288 — auto-retry bug, .mcp.json churn, and MCP
- * worktree routing fixes.
+ * worktree routing fixes (behaviour subset).
  *
- * Covers four source-file changes:
- *   1. src/resources/extensions/gsd/safety/evidence-collector.ts (functional)
- *   2. src/resources/extensions/gsd/bootstrap/register-hooks.ts (source shape)
- *   3. src/resources/extensions/gsd/auto-recovery.ts (source shape)
- *   4. packages/mcp-server/src/workflow-tools.ts (source shape)
+ * The remaining 13 structural assertions (source-grep against register-hooks,
+ * auto-recovery, workflow-tools) were removed in favour of follow-up issues
+ * tracking a pure-helper extraction per the #4832/PR #4859 precedent. This
+ * file retains only the real behaviour tests against the public API of
+ * evidence-collector.
+ *
+ * Follow-ups filed for the removed coverage — see PR body.
  *
  * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
  */
 
 import { describe, it, beforeEach } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 
 import {
   resetEvidence,
@@ -24,8 +24,6 @@ import {
   type BashEvidence,
 } from "../safety/evidence-collector.js";
 
-// ─── 1. evidence-collector: functional ─────────────────────────────────────
-
 describe("evidence-collector: toolCallId-based matching (A-3)", () => {
   beforeEach(() => {
     resetEvidence();
@@ -42,14 +40,9 @@ describe("evidence-collector: toolCallId-based matching (A-3)", () => {
   });
 
   it("matches results to the correct entry by toolCallId, not insertion order", () => {
-    // Simulate two parallel bash calls dispatched in order tc-1, tc-2.
     recordToolCall("tc-1", "bash", { command: "slow-thing" });
     recordToolCall("tc-2", "bash", { command: "fast-thing" });
 
-    // Results arrive out of order: tc-2 first (fast), then tc-1 (slow).
-    // With the old empty-string-matching strategy, tc-2's result would be
-    // stapled to tc-1's entry because findLastUnresolved scanned backwards
-    // for empty ids. Now we match by id directly.
     recordToolResult("tc-2", "bash", "Command exited with code 0\nfast-output", false);
     recordToolResult("tc-1", "bash", "Command exited with code 1\nslow-failure", true);
 
@@ -59,9 +52,6 @@ describe("evidence-collector: toolCallId-based matching (A-3)", () => {
 
     assert.ok(tc1, "tc-1 entry must exist");
     assert.ok(tc2, "tc-2 entry must exist");
-
-    // The original command stays attached to the entry it was recorded with,
-    // and the result matches the id it was reported for.
     assert.equal(tc1.command, "slow-thing");
     assert.equal(tc1.exitCode, 1);
     assert.ok(tc1.outputSnippet.includes("slow-failure"));
@@ -78,7 +68,6 @@ describe("evidence-collector: toolCallId-based matching (A-3)", () => {
     const entries = getEvidence() as readonly BashEvidence[];
     assert.equal(entries.length, 1);
     assert.equal(entries[0].toolCallId, "tc-1");
-    // tc-1 must be untouched — no result was reported for it.
     assert.equal(entries[0].exitCode, -1);
     assert.equal(entries[0].outputSnippet, "");
   });
@@ -95,178 +84,3 @@ describe("evidence-collector: toolCallId-based matching (A-3)", () => {
     assert.equal(entries[1].toolCallId, "tc-edit");
   });
 });
-
-// ─── 2. register-hooks: MCP auto-prep gated inside auto-worktrees (A-1) ────
-
-describe("register-hooks: skip prepareWorkflowMcpForProject inside auto-worktrees (A-1)", () => {
-  const src = readFileSync(
-    resolve(process.cwd(), "src", "resources", "extensions", "gsd", "bootstrap", "register-hooks.ts"),
-    "utf-8",
-  );
-
-  it("session_start hook is gated on isInAutoWorktree", () => {
-    const idx = src.indexOf('pi.on("session_start"');
-    assert.ok(idx !== -1, "session_start handler must exist");
-    const block = src.slice(idx, idx + 2500);
-    assert.ok(
-      block.includes("isInAutoWorktree"),
-      "session_start must consult isInAutoWorktree before preparing MCP",
-    );
-    assert.ok(
-      block.includes("prepareWorkflowMcpForProject"),
-      "session_start still prepares MCP for non-worktree paths",
-    );
-  });
-
-  it("session_switch hook is gated on isInAutoWorktree", () => {
-    const idx = src.indexOf('pi.on("session_switch"');
-    assert.ok(idx !== -1, "session_switch handler must exist");
-    const block = src.slice(idx, idx + 2500);
-    assert.ok(
-      block.includes("isInAutoWorktree"),
-      "session_switch must consult isInAutoWorktree before preparing MCP",
-    );
-  });
-
-  it("tool_call hook forwards event.toolCallId into safetyRecordToolCall (A-3)", () => {
-    // Find the call site (skip the import line by looking for the opening paren).
-    const idx = src.indexOf("safetyRecordToolCall(");
-    assert.ok(idx !== -1, "safetyRecordToolCall call must exist");
-    const line = src.slice(idx, src.indexOf("\n", idx));
-    assert.ok(
-      line.includes("event.toolCallId"),
-      "safetyRecordToolCall must receive event.toolCallId as the first argument",
-    );
-  });
-});
-
-// ─── 3. auto-recovery: verify-fail instrumentation ─────────────────────────
-
-describe("verifyExpectedArtifact: verify-fail exit-point logging (Phase B diag)", () => {
-  const src = readFileSync(
-    resolve(process.cwd(), "src", "resources", "extensions", "gsd", "auto-recovery.ts"),
-    "utf-8",
-  );
-
-  it("logs a verify-fail warning on the null-absPath exit", () => {
-    assert.ok(
-      src.includes('verify-fail ${unitType} ${unitId}: resolveExpectedArtifactPath returned null'),
-      "null-absPath branch must emit a diagnostic line",
-    );
-  });
-
-  it("logs a verify-fail warning on the existsSync-false exit", () => {
-    assert.ok(
-      src.includes("verify-fail ${unitType} ${unitId}: existsSync false"),
-      "existsSync-false branch must emit a diagnostic line",
-    );
-  });
-
-  it("logs a verify-fail warning on the plan-slice no-task-entry exit", () => {
-    assert.ok(
-      src.includes("verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading"),
-      "plan-slice no-task branch must emit a diagnostic line",
-    );
-  });
-
-  it("plan-slice task-plan-files check fails fast on missing tasks dir (hardening)", () => {
-    // The original check silently passed when resolveTasksDir returned null.
-    // The new check returns false with a diagnostic, which is correct — if
-    // the tool successfully planned tasks, the tasks/ dir must exist.
-    const idx = src.indexOf('verify-fail ${unitType} ${unitId}: resolveTasksDir returned null');
-    assert.ok(
-      idx !== -1,
-      "resolveTasksDir-null branch must emit a diagnostic and return false",
-    );
-  });
-});
-
-// ─── 4. workflow-tools (mcp-server): guard + optional projectDir + routing ─
-
-describe("mcp-server workflow-tools: projectDir routing (Phase B root cause)", () => {
-  const src = readFileSync(
-    resolve(process.cwd(), "packages", "mcp-server", "src", "workflow-tools.ts"),
-    "utf-8",
-  );
-
-  it("projectDirParam is optional and documents the default", () => {
-    const idx = src.indexOf("const projectDirParam");
-    assert.ok(idx !== -1, "projectDirParam definition must exist");
-    const block = src.slice(idx, idx + 600);
-    assert.ok(
-      block.includes(".optional()"),
-      "projectDirParam must be optional so the agent stops deliberating",
-    );
-    assert.ok(
-      /Omit this field/i.test(block),
-      "description must tell the agent to omit the field",
-    );
-  });
-
-  it("parseWorkflowArgs defaults projectDir to process.cwd() when omitted", () => {
-    const idx = src.indexOf("function parseWorkflowArgs");
-    assert.ok(idx !== -1, "parseWorkflowArgs must exist");
-    const block = src.slice(idx, idx + 1500);
-    assert.ok(
-      block.includes("parsed.projectDir ?? process.cwd()"),
-      "parseWorkflowArgs must fall back to process.cwd() when projectDir is omitted",
-    );
-  });
-
-  it("validateProjectDir accepts external-state worktree paths via .gsd symlink target", () => {
-    const idx = src.indexOf("function validateProjectDir");
-    assert.ok(idx !== -1, "validateProjectDir must exist");
-    const block = src.slice(idx, idx + 2500);
-    assert.ok(
-      block.includes("resolveExternalStateRoot"),
-      "validateProjectDir must consult resolveExternalStateRoot for external-state layouts",
-    );
-
-    const helperIdx = src.indexOf("function resolveExternalStateRoot");
-    assert.ok(helperIdx !== -1, "resolveExternalStateRoot helper must exist");
-    const helperBlock = src.slice(helperIdx, helperIdx + 600);
-    assert.ok(
-      helperBlock.includes("realpathSync"),
-      "resolveExternalStateRoot must use realpathSync to follow the symlink",
-    );
-    assert.ok(
-      /join\([^)]*\.gsd/.test(helperBlock),
-      "resolveExternalStateRoot must resolve <allowedRoot>/.gsd",
-    );
-  });
-
-  it("parseWorkflowArgs routes tool writes to the active worktree when one exists", () => {
-    // This is the Phase B root-cause fix: when the tool call is scoped to a
-    // milestone that has an auto-worktree at <projectRoot>/.gsd/worktrees/<MID>/,
-    // tool writes must go to the worktree .gsd rather than the shared project .gsd.
-    const parseIdx = src.indexOf("function parseWorkflowArgs");
-    const parseBlock = src.slice(parseIdx, parseIdx + 2500);
-    assert.ok(
-      parseBlock.includes("resolveActiveWorktreeBasePath"),
-      "parseWorkflowArgs must consult resolveActiveWorktreeBasePath",
-    );
-    assert.ok(
-      parseBlock.includes("extractMilestoneId"),
-      "parseWorkflowArgs must extract the milestoneId to locate the worktree",
-    );
-  });
-
-  it("resolveActiveWorktreeBasePath checks .git presence to avoid hijacking stray directories", () => {
-    const idx = src.indexOf("function resolveActiveWorktreeBasePath");
-    assert.ok(idx !== -1, "resolveActiveWorktreeBasePath helper must exist");
-    const block = src.slice(idx, idx + 1200);
-    assert.ok(
-      block.includes('existsSync(join(wtPath, ".git"))'),
-      "resolveActiveWorktreeBasePath must verify a .git file exists in the worktree",
-    );
-  });
-
-  it("extractMilestoneId handles camelCase, snake_case, and short aliases", () => {
-    const idx = src.indexOf("function extractMilestoneId");
-    assert.ok(idx !== -1, "extractMilestoneId helper must exist");
-    const block = src.slice(idx, idx + 600);
-    assert.ok(block.includes("milestoneId"), "must check milestoneId");
-    assert.ok(block.includes("milestone_id"), "must check milestone_id");
-    assert.ok(block.includes("mid"), "must check mid");
-  });
-});

package/src/resources/extensions/gsd/tests/auto-start-bootstrap-await-3420.test.ts

@@ -0,0 +1,141 @@
+/**
+ * auto-start-bootstrap-await-3420.test.ts — Regression test for #3420.
+ *
+ * Bug: In bootstrapAutoSession, when state.phase === "pre-planning" and no
+ * context file exists, showSmartEntry is called to dispatch a discuss workflow.
+ * showSmartEntry calls dispatchWorkflow which calls pi.sendMessage() — a
+ * fire-and-forget call that returns immediately. The LLM discussion runs
+ * asynchronously in a separate turn.
+ *
+ * The bug: after showSmartEntry returns (before the LLM has run), the code
+ * immediately calls invalidateAllCaches() + deriveState() + checks postState.
+ * Since the discussion hasn't run yet, postState.phase is still "pre-planning"
+ * and the context check fails, producing the warning:
+ *   "Discussion completed but milestone context is still missing. Run /gsd to try again."
+ *
+ * The discussion never ran — the warning fires immediately.
+ *
+ * Fix: bootstrapAutoSession must return false (release lock) after showSmartEntry
+ * dispatches the workflow. The checkAutoStartAfterDiscuss callback in guided-flow.ts
+ * already handles re-entering auto-mode when the discussion completes.
+ *
+ * This test verifies the fix by asserting that the pre-planning !hasContext block
+ * does NOT contain a postState phase check after showSmartEntry — it must
+ * return false immediately to let the async dispatch complete.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const sourcePath = join(import.meta.dirname, "..", "auto-start.ts");
+const source = readFileSync(sourcePath, "utf-8");
+
+test("bootstrapAutoSession: pre-planning no-context path does NOT check postState immediately after showSmartEntry (#3420)", () => {
+  // Find the pre-planning block that handles the case where context is missing.
+  // This block dispatches showSmartEntry which is async (fire-and-forget via pi.sendMessage).
+  // After the dispatch, checking postState.phase immediately is premature — the
+  // LLM discussion hasn't run yet. The block should return false instead.
+  const prePlanningNoContextBlock = source.match(
+    /\/\/ Active milestone exists but has no roadmap\s*\n\s*if\s*\(\s*state\.phase\s*===\s*"pre-planning"\s*\)([\s\S]*?)\/\/ Active milestone has CONTEXT-DRAFT/,
+  );
+  assert.ok(
+    !!prePlanningNoContextBlock,
+    "auto-start.ts must have the pre-planning handler block before needs-discussion",
+  );
+
+  const block = prePlanningNoContextBlock![1];
+
+  // The block must call showSmartEntry when !hasContext
+  assert.ok(
+    block.includes("showSmartEntry"),
+    "pre-planning !hasContext block must call showSmartEntry to dispatch the discuss workflow",
+  );
+
+  // FAILING ASSERTION (before fix): after showSmartEntry, the block must NOT
+  // immediately check postState.phase — that check fires before the LLM runs.
+  // Instead, it must return false (release lock) so the async dispatch can complete.
+  // The warning "Discussion completed but milestone context is still missing"
+  // fires prematurely when this postState check exists.
+  assert.ok(
+    !block.includes("Discussion completed but milestone context is still missing"),
+    "pre-planning !hasContext block must NOT check postState.phase immediately after showSmartEntry — " +
+    "the dispatch is async (pi.sendMessage is fire-and-forget) and the discussion hasn't run yet; " +
+    "return false instead so checkAutoStartAfterDiscuss can re-enter auto-mode after discussion completes (#3420)",
+  );
+});
+
+test("bootstrapAutoSession: complete/no-milestone path does NOT check postState immediately after showSmartEntry (#3420)", () => {
+  // Find the complete/no-milestone block
+  const completeBlock = source.match(
+    /\/\/ No active work — start a new milestone via discuss flow\s*\n\s*if\s*\(!state\.activeMilestone\s*\|\|\s*state\.phase\s*===\s*"complete"\s*\)([\s\S]*?)\/\/ Active milestone exists but has no roadmap/,
+  );
+  assert.ok(
+    !!completeBlock,
+    "auto-start.ts must have the complete/no-milestone handler block",
+  );
+
+  const block = completeBlock![1];
+
+  // The block must call showSmartEntry
+  assert.ok(
+    block.includes("showSmartEntry"),
+    "complete/no-milestone block must call showSmartEntry",
+  );
+
+  // After showSmartEntry dispatches, checking postState.phase is premature —
+  // the LLM hasn't had a turn yet. The block should return false.
+  // Specifically, the "no milestone context was written" warning fires too early.
+  assert.ok(
+    !block.includes("Discussion completed but no milestone context was written"),
+    "complete/no-milestone block must NOT check postState.phase immediately after showSmartEntry dispatch — " +
+    "return false instead so the async LLM turn can complete (#3420)",
+  );
+});
+
+test("bootstrapAutoSession: showSmartEntry in pre-planning path is followed by releaseLockAndReturn, not postState check (#3420)", () => {
+  // After the fix, the pre-planning !hasContext branch should call showSmartEntry
+  // and then immediately return releaseLockAndReturn() — not check postState.
+  const prePlanningNoContextBlock = source.match(
+    /\/\/ Active milestone exists but has no roadmap\s*\n\s*if\s*\(\s*state\.phase\s*===\s*"pre-planning"\s*\)([\s\S]*?)\/\/ Active milestone has CONTEXT-DRAFT/,
+  );
+  assert.ok(!!prePlanningNoContextBlock, "pre-planning handler block found");
+
+  const block = prePlanningNoContextBlock![1];
+
+  // After the fix, the !hasContext branch ends with releaseLockAndReturn
+  assert.ok(
+    block.includes("releaseLockAndReturn"),
+    "pre-planning !hasContext block must call releaseLockAndReturn() after showSmartEntry dispatch (#3420)",
+  );
+
+  // The showSmartEntry call must appear before releaseLockAndReturn
+  const showSmartEntryIdx = block.indexOf("showSmartEntry");
+  const releaseLockIdx = block.indexOf("releaseLockAndReturn");
+  assert.ok(
+    showSmartEntryIdx > -1 && releaseLockIdx > -1,
+    "both showSmartEntry and releaseLockAndReturn must appear in the block",
+  );
+  assert.ok(
+    showSmartEntryIdx < releaseLockIdx,
+    "showSmartEntry must appear before releaseLockAndReturn in pre-planning !hasContext block",
+  );
+
+  // There must be NO invalidateAllCaches between showSmartEntry and releaseLockAndReturn
+  // (invalidateAllCaches + deriveState after showSmartEntry is the buggy premature check)
+  const afterShowSmartEntry = block.substring(showSmartEntryIdx);
+  const cacheInvalidateIdx = afterShowSmartEntry.indexOf("invalidateAllCaches");
+  const releaseFromShowIdx = afterShowSmartEntry.indexOf("releaseLockAndReturn");
+
+  // If invalidateAllCaches appears, it must appear AFTER releaseLockAndReturn
+  // (which is impossible since releaseLockAndReturn returns) — so invalidateAllCaches
+  // must not appear at all between showSmartEntry and the end of the !hasContext block.
+  if (cacheInvalidateIdx !== -1) {
+    assert.ok(
+      cacheInvalidateIdx > releaseFromShowIdx,
+      "invalidateAllCaches must NOT appear between showSmartEntry and releaseLockAndReturn — " +
+      "this is the premature postState check that causes #3420",
+    );
+  }
+});

package/src/resources/extensions/gsd/tests/auto-start-clean-runtime-db-gated.test.ts

@@ -0,0 +1,64 @@
+// GSD-2 auto-start regression test: cleanStaleRuntimeUnits is DB-gated (#4663)
+//
+// Source-level structural check that the stale-runtime-cleanup predicate in
+// auto-start.ts consults DB status when available instead of treating a
+// SUMMARY-file on disk as proof of milestone completion. Pairs with #4658 /
+// PR #4660 fix in auto-dispatch + auto-recovery.
+
+import { describe, 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 { extractSourceRegion } from "./test-helpers.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const sourceFile = join(__dirname, "..", "auto-start.ts");
+
+describe("auto-start cleanStaleRuntimeUnits DB gating (#4663)", () => {
+  const source = readFileSync(sourceFile, "utf-8");
+
+  test("imports isClosedStatus for DB-status check", () => {
+    assert.match(
+      source,
+      /import\s*\{\s*isClosedStatus\s*\}\s*from\s*["']\.\/status-guards/,
+    );
+  });
+
+  test("cleanStaleRuntimeUnits is called after openProjectDbIfPresent", () => {
+    const openDbIdx = source.indexOf("await openProjectDbIfPresent(base)");
+    assert.ok(openDbIdx > -1, "openProjectDbIfPresent should be called in auto-start");
+    const cleanIdx = source.indexOf("cleanStaleRuntimeUnits(", openDbIdx);
+    assert.ok(
+      cleanIdx > -1,
+      "cleanStaleRuntimeUnits must run AFTER openProjectDbIfPresent so predicate can consult DB",
+    );
+  });
+
+  test("cleanStaleRuntimeUnits predicate consults DB status when available", () => {
+    const cleanIdx = source.indexOf("cleanStaleRuntimeUnits(");
+    assert.ok(cleanIdx > -1);
+    const snippet = extractSourceRegion(source, "cleanStaleRuntimeUnits(");
+    assert.match(
+      snippet,
+      /isDbAvailable\(\)/,
+      "predicate must branch on DB availability",
+    );
+    assert.match(
+      snippet,
+      /isClosedStatus\(/,
+      "predicate must check DB status via isClosedStatus",
+    );
+  });
+
+  test("cleanStaleRuntimeUnits predicate still falls back to SUMMARY-file when DB unavailable", () => {
+    const cleanIdx = source.indexOf("cleanStaleRuntimeUnits(");
+    assert.ok(cleanIdx > -1);
+    const snippet = extractSourceRegion(source, "cleanStaleRuntimeUnits(");
+    assert.match(
+      snippet,
+      /resolveMilestoneFile\(base,\s*mid,\s*["']SUMMARY["']\)/,
+      "legacy FS-fallback branch should still use SUMMARY file presence",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/auto-start-cold-db-bootstrap.test.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { createTestContext } from "./test-helpers.ts";
+import {createTestContext, extractSourceRegion } from "./test-helpers.ts";
 
 const { assertTrue, report } = createTestContext();
 
@@ -13,7 +13,7 @@ console.log("\n=== #2841: cold DB opened before initial deriveState ===");
 const helperIdx = src.indexOf("async function openProjectDbIfPresent");
 assertTrue(helperIdx >= 0, "auto-start.ts defines a helper for pre-derive DB open (#2841)");
 
-const helperRegion = helperIdx >= 0 ? src.slice(helperIdx, helperIdx + 500) : "";
+const helperRegion = helperIdx >= 0 ? extractSourceRegion(src, "async function openProjectDbIfPresent") : "";
 assertTrue(
   helperRegion.includes("resolveProjectRootDbPath(basePath)"),
   "pre-derive DB helper resolves the project-root DB path (#2841)",

package/src/resources/extensions/gsd/tests/auto-start-needs-discussion.test.ts

@@ -157,62 +157,19 @@ describe("auto-start-needs-discussion (#1726)", () => {
     }
   });
 
-  test("6. No infinite loop: needs-discussion always routes to showSmartEntry", () => {
-    const source = readAutoStartSource();
-
-    // Verify needs-discussion does NOT appear in auto-dispatch trigger conditions
-    // within auto-start.ts. The only place needs-discussion should appear is in
-    // the showSmartEntry routing block.
-    const survivorSection = source.match(
-      /\/\/ Milestone branch recovery.*?let hasSurvivorBranch = false;[\s\S]*?if\s*\([^)]*state\.phase[^)]*\)\s*\{/,
-    );
-    if (survivorSection) {
-      assert.ok(
-        !survivorSection[0].includes("needs-discussion"),
-        "survivor branch phase condition must not mention needs-discussion",
-      );
-    }
-
-    // Verify needs-discussion IS handled inside the !hasSurvivorBranch block
-    const notSurvivorBlock = source.match(
-      /if\s*\(!hasSurvivorBranch\)\s*\{([\s\S]*?)\/\/ Unreachable safety check/,
-    );
-    assert.ok(!!notSurvivorBlock,
-      "found !hasSurvivorBranch block in auto-start.ts");
-    if (notSurvivorBlock) {
-      assert.ok(
-        notSurvivorBlock[1].includes('"needs-discussion"'),
-        "!hasSurvivorBranch block must handle needs-discussion phase",
-      );
-    }
-  });
-
-  test("7. Survivor branch + needs-discussion routes to showSmartEntry", () => {
-    const source = readAutoStartSource();
-
-    // When hasSurvivorBranch is true AND phase is needs-discussion, the code
-    // must route to showSmartEntry instead of falling through to auto-mode.
-    const survivorNeedsDiscussion = source.match(
-      /if\s*\(hasSurvivorBranch\s*&&\s*state\.phase\s*===\s*"needs-discussion"\)\s*\{[^}]*showSmartEntry/s,
-    );
-    assert.ok(!!survivorNeedsDiscussion,
-      "hasSurvivorBranch && needs-discussion must route to showSmartEntry");
-
-    // Verify the handler checks if the discussion succeeded
-    const handlerBlock = source.match(
-      /if\s*\(hasSurvivorBranch\s*&&\s*state\.phase\s*===\s*"needs-discussion"\)\s*\{([\s\S]*?)\n    \}/,
-    );
-    assert.ok(!!handlerBlock,
-      "found survivor + needs-discussion handler block");
-    if (handlerBlock) {
-      assert.ok(
-        handlerBlock[1].includes('postState.phase !== "needs-discussion"'),
-        "handler must check if phase advanced after discussion",
-      );
-      assert.ok(
-        handlerBlock[1].includes("releaseLockAndReturn"),
-        "handler must abort if discussion didn't promote draft",
-      );
-    }
-  });
+  // Tests 6 and 7 removed in the #4832 follow-up.
+  //
+  // They source-grepped `auto-start.ts` for specific regex patterns like
+  // `if (hasSurvivorBranch && state.phase === "needs-discussion")` —
+  // which broke (correctly so) when the three-way survivor decision was
+  // extracted into the `decideSurvivorAction` pure helper. The
+  // behavioural invariants they were trying to uphold are now covered
+  // directly in `survivor-branch-complete.test.ts`:
+  //   - (hasSurvivor=true, phase="needs-discussion") → "discuss"
+  //   - (hasSurvivor=false, phase="needs-discussion") → "none"
+  //   - (hasSurvivor=true, phase=other)              → "none"
+  // Those tests fail on real decision regressions without the
+  // source-grep brittleness. Tests 1–5 above remain — they hit
+  // `deriveState` on real fixtures and defend the #1726 infinite-loop
+  // fix end-to-end.
 });

package/src/resources/extensions/gsd/tests/auto-start-worktree-db-path.test.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { createTestContext } from "./test-helpers.ts";
+import {createTestContext, extractSourceRegion } from "./test-helpers.ts";
 
 const { assertTrue, report } = createTestContext();
 
@@ -13,7 +13,7 @@ console.log("\n=== #3822: worktree bootstrap uses project DB path ===");
 const dbLifecycleIdx = src.indexOf("// ── DB lifecycle ──");
 assertTrue(dbLifecycleIdx > 0, "auto-start.ts has a DB lifecycle section");
 
-const dbLifecycleRegion = dbLifecycleIdx > 0 ? src.slice(dbLifecycleIdx, dbLifecycleIdx + 600) : "";
+const dbLifecycleRegion = dbLifecycleIdx > 0 ? extractSourceRegion(src, "// ── DB lifecycle ──") : "";
 
 assertTrue(
   dbLifecycleRegion.includes("const gsdDbPath = resolveProjectRootDbPath(s.basePath);"),

package/src/resources/extensions/gsd/tests/auto-thinking-restore.test.ts

@@ -0,0 +1,39 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { extractSourceRegion } from "./test-helpers.ts";
+
+const autoSrc = readFileSync(join(import.meta.dirname, "..", "auto.ts"), "utf-8");
+const phasesSrc = readFileSync(join(import.meta.dirname, "..", "auto", "phases.ts"), "utf-8");
+
+test("stopAuto restores original thinking level", () => {
+  assert.ok(
+    autoSrc.includes("if (pi && s.originalThinkingLevel)"),
+    "auto.ts should conditionally restore original thinking level in stopAuto",
+  );
+  assert.ok(
+    autoSrc.includes("pi.setThinkingLevel(s.originalThinkingLevel)"),
+    "auto.ts should call pi.setThinkingLevel with originalThinkingLevel",
+  );
+});
+
+test("runUnitPhase threads captured thinking level into selectAndApplyModel", () => {
+  const callIdx = phasesSrc.indexOf("deps.selectAndApplyModel(");
+  assert.ok(callIdx > -1, "phases.ts should call selectAndApplyModel");
+  const callBlock = extractSourceRegion(phasesSrc, "deps.selectAndApplyModel(");
+  assert.ok(
+    callBlock.includes("s.autoModeStartThinkingLevel"),
+    "runUnitPhase should pass autoModeStartThinkingLevel to selectAndApplyModel",
+  );
+});
+
+test("hook model override preserves captured thinking level", () => {
+  const hookIdx = phasesSrc.indexOf("const hookModelOverride = sidecarItem?.model ?? iterData.hookModelOverride;");
+  assert.ok(hookIdx > -1, "phases.ts should include hook model override handling");
+  const hookBlock = extractSourceRegion(phasesSrc, "const hookModelOverride = sidecarItem?.model ?? iterData.hookModelOverride;");
+  assert.ok(
+    hookBlock.includes("pi.setThinkingLevel(s.autoModeStartThinkingLevel)"),
+    "hook model override should re-apply captured thinking level after setModel",
+  );
+});

package/src/resources/extensions/gsd/tests/auto-warning-noise-regression.test.ts

@@ -27,6 +27,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { buildFlatRateContext } from "../auto-model-selection.ts";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 // ─── Bug 2: this-binding regression ─────────────────────────────────────
 
@@ -69,7 +70,7 @@ test("isSamePath short-circuits ENOENT before logging a warning", () => {
   assert.ok(fnIdx !== -1, "isSamePath function exists");
 
   // Grab the function body (enough to cover the catch block).
-  const fnBody = src.slice(fnIdx, fnIdx + 600);
+  const fnBody = extractSourceRegion(src, "function isSamePath", { fromIdx: fnIdx });
 
   const catchIdx = fnBody.indexOf("catch");
   assert.ok(catchIdx !== -1, "isSamePath has a catch block");
@@ -103,7 +104,7 @@ test("checkAutoStartAfterDiscuss guards DISCUSSION-MANIFEST.json unlink with exi
 
   // Everything from the comment to a short distance below should contain
   // the existsSync guard before the unlinkSync call.
-  const block = src.slice(cleanupIdx, cleanupIdx + 400);
+  const block = extractSourceRegion(src, "remove discussion manifest after auto-start", { fromIdx: cleanupIdx });
 
   const existsIdx = block.indexOf("existsSync(manifestPath)");
   const unlinkIdx = block.indexOf("unlinkSync(manifestPath)");

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

@@ -144,3 +144,26 @@ describe("#3512: pauseAuto and stopAuto must flush queued follow-up messages", (
     );
   });
 });
+
+describe("#4365: tool_execution_start hook must pass toolName to markToolStart", () => {
+  test("tool_execution_start handler passes event.toolName to markToolStart", () => {
+    // The tool_execution_start handler must forward toolName so that
+    // hasInteractiveToolInFlight() can correctly identify ask_user_questions
+    // and prevent the idle watchdog from firing during interactive tool calls.
+    const startMarker = 'pi.on("tool_execution_start", async (event) => {';
+    const endMarker = 'pi.on("tool_execution_end", async (event) => {';
+    const toolExecutionStartSection = registerHooksSrc.slice(
+      registerHooksSrc.indexOf(startMarker),
+      registerHooksSrc.indexOf(endMarker),
+    );
+
+    assert.ok(
+      toolExecutionStartSection.length > 0,
+      "Could not locate tool_execution_start handler section",
+    );
+    assert.ok(
+      toolExecutionStartSection.includes("markToolStart(event.toolCallId, event.toolName)"),
+      "tool_execution_start handler must pass event.toolName to markToolStart so hasInteractiveToolInFlight() works correctly",
+    );
+  });
+});