gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0

package/src/resources/extensions/gsd/tests/slice-parallel-orchestrator.test.ts

@@ -6,13 +6,83 @@
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
+import { restoreSliceState } from "../slice-parallel-orchestrator.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const gsdDir = join(__dirname, "..");
 
+function readLinuxProcessStartFingerprint(pid: number): string | null {
+  try {
+    const stat = readFileSync(`/proc/${pid}/stat`, "utf-8");
+    const afterCommand = stat.slice(stat.lastIndexOf(")") + 2).trim();
+    const fields = afterCommand.split(/\s+/);
+    const startTimeTicks = fields[19];
+    return startTimeTicks ? `linux-stat:${startTimeTicks}` : null;
+  } catch {
+    return null;
+  }
+}
+
+function readPsProcessStartFingerprint(pid: number): string | null {
+  try {
+    const raw = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8",
+    }).trim().replace(/\s+/g, " ");
+    return raw ? `ps-lstart:${raw}` : null;
+  } catch {
+    return null;
+  }
+}
+
+function readProcessStartFingerprint(pid: number): string | null {
+  return readLinuxProcessStartFingerprint(pid) ?? readPsProcessStartFingerprint(pid);
+}
+
+function makeTempProject(): string {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-slice-parallel-"));
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+  return basePath;
+}
+
+function writeSliceOrchestratorState(
+  basePath: string,
+  worker: {
+    pid: number;
+    workerToken?: string;
+    processStartFingerprint?: string | null;
+  },
+): void {
+  writeFileSync(
+    join(basePath, ".gsd", "slice-orchestrator.json"),
+    JSON.stringify({
+      active: true,
+      workers: [{
+        milestoneId: "M900",
+        sliceId: "S01",
+        pid: worker.pid,
+        workerToken: worker.workerToken,
+        processStartFingerprint: worker.processStartFingerprint,
+        worktreePath: join(basePath, ".gsd", "worktrees", "M900-S01"),
+        startedAt: Date.now(),
+        state: "running",
+        completedUnits: 0,
+        cost: 0,
+      }],
+      totalCost: 0,
+      maxWorkers: 1,
+      startedAt: Date.now(),
+      basePath,
+    }),
+    "utf-8",
+  );
+}
+
 describe("slice-parallel-orchestrator structural tests", () => {
   it("orchestrator uses GSD_SLICE_LOCK env var", () => {
     const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
@@ -46,6 +116,99 @@ describe("slice-parallel-orchestrator structural tests", () => {
       "Orchestrator must also pass GSD_MILESTONE_LOCK for milestone context",
     );
   });
+
+  it("recovery preserves terminal workers for coordinator-side collection", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes('} else if (w.state === "running")') &&
+        source.includes("survivors.push(w);"),
+      "Recovery must only prune dead running workers, not stopped/error workers",
+    );
+  });
+
+  it("recovered PID-only workers are validated before signaling", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes("isRecoveredSliceWorkerAlive(worker)") &&
+        source.includes('process.kill(worker.pid, "SIGTERM")'),
+      "stopSliceParallel must validate recovered worker identity before signaling a PID",
+    );
+  });
+
+  it("persists worker identity for crash recovery", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes("workerToken") &&
+        source.includes("processStartFingerprint") &&
+        source.includes("GSD_SLICE_WORKER_TOKEN"),
+      "Orchestrator must persist stable worker identity metadata for recovered workers",
+    );
+  });
+
+  it("spawn failures remove stale worker state and worktree", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes("sliceState.workers.delete(slice.id)") &&
+        source.includes("removeWorktree(basePath, wtName, { deleteBranch: true, force: true })"),
+      "Failed slice worker spawns must remove stale worker state and clean up the worktree",
+    );
+  });
+});
+
+describe("slice-parallel-orchestrator recovery identity", () => {
+  it("rejects a live PID when the process start fingerprint does not match", () => {
+    const basePath = makeTempProject();
+    try {
+      writeSliceOrchestratorState(basePath, {
+        pid: process.pid,
+        processStartFingerprint: "mismatched-fingerprint",
+      });
+
+      const restored = restoreSliceState(basePath);
+      assert.equal(restored, null, "mismatched fingerprint is treated as a dead worker");
+      assert.equal(
+        existsSync(join(basePath, ".gsd", "slice-orchestrator.json")),
+        false,
+        "state file is removed when no recovered worker identity validates",
+      );
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps a recovered worker when PID, token, and process start fingerprint match", async () => {
+    const basePath = makeTempProject();
+    const token = `test-token-${Date.now()}`;
+    const child = spawn(
+      process.execPath,
+      ["-e", "setTimeout(() => {}, 30000)"],
+      {
+        env: { ...process.env, GSD_SLICE_WORKER_TOKEN: token },
+        stdio: "ignore",
+      },
+    );
+
+    try {
+      assert.ok(child.pid, "child process has a pid");
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      const fingerprint = readProcessStartFingerprint(child.pid!);
+      if (!fingerprint) return;
+
+      writeSliceOrchestratorState(basePath, {
+        pid: child.pid!,
+        workerToken: token,
+        processStartFingerprint: fingerprint,
+      });
+
+      const restored = restoreSliceState(basePath);
+      assert.ok(restored, "matching worker identity is restored");
+      assert.equal(restored.workers.length, 1);
+      assert.equal(restored.workers[0].pid, child.pid);
+    } finally {
+      child.kill("SIGTERM");
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
 });
 
 describe("slice_parallel preference gating", () => {

package/src/resources/extensions/gsd/tests/smart-entry-draft.test.ts

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 
 import { deriveState } from "../state.js";
 import { resolveMilestoneFile } from "../paths.js";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 let passed = 0;
 let failed = 0;
@@ -81,7 +82,7 @@ assert(
 
 // Check the branch has draft-aware menu options
 const branchIdx = guidedFlowSource.indexOf('state.phase === "needs-discussion"');
-const branchChunk = guidedFlowSource.slice(branchIdx, branchIdx + 4000);
+const branchChunk = extractSourceRegion(guidedFlowSource, 'state.phase === "needs-discussion"');
 
 assert(
   branchChunk.includes("discuss_draft"),

package/src/resources/extensions/gsd/tests/stale-dirlistcache-4648.test.ts

@@ -0,0 +1,112 @@
+/**
+ * GSD-2 / agent-end-recovery — regression tests for #4648
+ *
+ * Covers the stale `dirListCache` bug where `maybeHandleReadyPhraseWithoutFiles`
+ * (and `checkAutoStartAfterDiscuss`) falsely reported milestone artifacts as
+ * missing, because the directory-listing cache in `paths.ts` was populated
+ * before the LLM wrote the files during the same turn.
+ *
+ * The fix invalidates the cache at the top of `handleAgentEnd`, before any
+ * artifact-existence check runs.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  rmSync,
+  writeFileSync,
+  readFileSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+import { resolveMilestoneFile } from "../paths.ts";
+import { clearPathCache } from "../paths.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AGENT_END_RECOVERY_PATH = join(
+  __dirname,
+  "..",
+  "bootstrap",
+  "agent-end-recovery.ts",
+);
+
+function mkBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-4648-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  return base;
+}
+
+describe("#4648 stale dirListCache — behavioral", () => {
+  test("resolveMilestoneFile returns stale null until clearPathCache runs", () => {
+    const base = mkBase();
+    try {
+      clearPathCache();
+
+      // Prime the cache: directory exists but is empty at this point.
+      assert.equal(
+        resolveMilestoneFile(base, "M001", "CONTEXT"),
+        null,
+        "empty dir → null",
+      );
+
+      // Simulate the LLM writing CONTEXT.md during the turn.
+      writeFileSync(
+        join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+        "# M001 Context\n",
+      );
+
+      // Without a cache flush the resolver still reports null — this is the bug.
+      assert.equal(
+        resolveMilestoneFile(base, "M001", "CONTEXT"),
+        null,
+        "stale cache returns null even though the file exists on disk",
+      );
+
+      // The fix: clearPathCache() — after which the resolver finds the file.
+      clearPathCache();
+      const resolved = resolveMilestoneFile(base, "M001", "CONTEXT");
+      assert.ok(
+        resolved && /M001-CONTEXT\.md$/.test(resolved),
+        `after clearPathCache, resolver finds the file (got: ${resolved})`,
+      );
+    } finally {
+      clearPathCache();
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("#4648 agent-end-recovery wiring", () => {
+  test("handleAgentEnd invalidates the path cache before the discuss guards", () => {
+    const source = readFileSync(AGENT_END_RECOVERY_PATH, "utf-8");
+
+    assert.ok(
+      /import\s*\{\s*clearPathCache\s*\}\s*from\s*"\.\.\/paths\.js"/.test(source),
+      "agent-end-recovery.ts must import clearPathCache from ../paths.js",
+    );
+
+    const fnStart = source.indexOf("export async function handleAgentEnd");
+    assert.ok(fnStart > -1, "handleAgentEnd must exist");
+
+    const checkIdx = source.indexOf("checkAutoStartAfterDiscuss(", fnStart);
+    const clearIdx = source.indexOf("clearPathCache(", fnStart);
+    const readyIdx = source.indexOf(
+      "maybeHandleReadyPhraseWithoutFiles(",
+      fnStart,
+    );
+
+    assert.ok(clearIdx > -1, "handleAgentEnd must call clearPathCache");
+    assert.ok(
+      clearIdx < checkIdx,
+      "clearPathCache must run before checkAutoStartAfterDiscuss so the guard sees fresh disk state",
+    );
+    assert.ok(
+      clearIdx < readyIdx,
+      "clearPathCache must run before maybeHandleReadyPhraseWithoutFiles",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/state-machine-full-walkthrough.test.ts

@@ -13,6 +13,7 @@ import {
   isValidationTerminal,
   isGhostMilestone,
   invalidateStateCache,
+  getActiveMilestoneId,
 } from "../state.ts";
 import {
   openDatabase,
@@ -667,6 +668,29 @@ describe("state-machine-full-walkthrough", () => {
       assert.notEqual(state.phase, "completing-milestone", "should be complete, not completing");
       assert.equal(state.phase, "complete");
     });
+
+    test("failure-path milestone SUMMARY is not terminal completion", async () => {
+      const base = createFixtureBase();
+      writeRoadmap(base, "M001", doneSliceRoadmap());
+      writeMilestoneValidation(base, "M001", "pass");
+      const dir = join(base, ".gsd", "milestones", "M001");
+      writeFileSync(join(dir, "M001-SUMMARY.md"), [
+        "---",
+        "status: failed",
+        "---",
+        "",
+        "# BLOCKER",
+        "",
+        "auto-mode recovery failed; milestone is not complete.",
+      ].join("\n"));
+      invalidateStateCache();
+
+      const state = await deriveState(base);
+
+      assert.equal(state.phase, "completing-milestone");
+      assert.equal(state.registry[0]?.status, "active");
+      assert.equal(await getActiveMilestoneId(base), "M001");
+    });
   });
 
   // ═══════════════════════════════════════════════════════════════════════════
@@ -811,9 +835,9 @@ describe("state-machine-full-walkthrough", () => {
       assert.ok(state.blockers.length > 0, "should have blockers");
     });
 
-    test("no eligible slice (all deps unmet) → fallback picks slice with most deps satisfied", async () => {
+    test("no eligible slice (all deps unmet) → blocked", async () => {
       const base = createFixtureBase();
-      // S01 depends on S00 which doesn't exist — fallback picks S01 anyway
+      // S01 depends on S00 which doesn't exist.
       writeRoadmap(base, "M001", [
         "# M001: Test Milestone",
         "",
@@ -827,9 +851,9 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveState(base);
 
-      // With partial-dep fallback, S01 is picked despite unmet dep on S00
-      assert.equal(state.phase, "planning");
-      assert.equal(state.activeSlice?.id, "S01");
+      assert.equal(state.phase, "blocked");
+      assert.equal(state.activeSlice, null);
+      assert.ok(state.blockers.some(b => b.includes("No slice eligible")));
     });
   });
 

package/src/resources/extensions/gsd/tests/state-transition-matrix.test.ts

@@ -0,0 +1,44 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  STATE_TRANSITION_MATRIX,
+  findTransition,
+  validateTransitionMatrix,
+} from "../state-transition-matrix.ts";
+
+test("state transition matrix covers required swarm hardening events", () => {
+  const result = validateTransitionMatrix([
+    "context-ready",
+    "research-ready",
+    "plan-ready",
+    "task-dispatched",
+    "slice-complete",
+    "validation-pass",
+    "recovery-plan-ready",
+    "closeout-complete",
+  ]);
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.missingEvents, []);
+  assert.deepEqual(result.duplicateKeys, []);
+});
+
+test("state transition matrix fails closed for recovery and closeout guards", () => {
+  const recovery = findTransition("blocked", "recovery-plan-ready");
+  assert.equal(recovery?.to, "executing");
+  assert.equal(recovery?.onFail, "blocked");
+  assert.equal(recovery?.reasonCode, "recovery");
+
+  const closeout = findTransition("completing-milestone", "closeout-complete");
+  assert.equal(closeout?.to, "complete");
+  assert.equal(closeout?.onFail, "blocked");
+});
+
+test("state transition matrix entries all have guard and reason codes", () => {
+  assert.ok(STATE_TRANSITION_MATRIX.length >= 8);
+  for (const entry of STATE_TRANSITION_MATRIX) {
+    assert.ok(entry.guard.length > 0, `${entry.event} must document its guard`);
+    assert.ok(entry.reasonCode.length > 0, `${entry.event} must include reason code`);
+  }
+});

package/src/resources/extensions/gsd/tests/stop-auto-race-null-unit.test.ts

@@ -13,7 +13,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();
 
@@ -35,7 +35,7 @@ assertTrue(
 );
 
 // Extract the region from the closeout comment to the next section comment
-const closeoutRegion = phasesSrc.slice(closeoutIdx, closeoutIdx + 500);
+const closeoutRegion = extractSourceRegion(phasesSrc, closeoutComment);
 assertTrue(
   closeoutRegion.includes("if (s.currentUnit)"),
   "closeoutUnit call is guarded by `if (s.currentUnit)` check (#2939)",
@@ -52,7 +52,7 @@ assertTrue(
   "phases.ts contains the 'Zero tool-call guard' comment block",
 );
 
-const zeroToolRegion = phasesSrc.slice(zeroToolIdx, zeroToolIdx + 600);
+const zeroToolRegion = extractSourceRegion(phasesSrc, zeroToolComment);
 
 // The non-null assertion `s.currentUnit!.startedAt` must be replaced with
 // optional chaining `s.currentUnit?.startedAt`

package/src/resources/extensions/gsd/tests/structured-data-formatter.test.ts

@@ -271,96 +271,15 @@ describe("structured-data-formatter: measureSavings", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Realistic token savings measurement
+// Dropped (#4836): the previous "realistic savings" suite asserted that the
+// compact formatter beat hand-authored "typical markdown" baselines by 30%+.
+// Those baselines were written by the test author to make the assertion pass
+// — they are not the format GSD actually emits anywhere else, so shifting
+// the compact output by any amount could be absorbed by padding the baseline.
+// There was no regression signal.
+//
+// The unit tests above already pin the compact format's structure byte for
+// byte; a genuine regression changes one of those exact-string assertions.
+// If a size-budget guarantee is needed later, capture a real production
+// baseline into a fixture file and assert against a checked-in byte count.
 // ---------------------------------------------------------------------------
-
-describe("structured-data-formatter: realistic savings", () => {
-  it("decisions compact format saves 30%+ vs markdown table", () => {
-    const decisions = [sampleDecision, sampleDecision2];
-
-    // Simulate a typical markdown table
-    const markdownTable = [
-      "| ID   | When       | Scope        | Decision                | Choice                 | Rationale                | Revisable |",
-      "|------|------------|--------------|-------------------------|------------------------|--------------------------|-----------|",
-      "| D001 | M001/S01   | architecture | Use SQLite for storage  | WAL mode, single-writer | Built-in, no external deps | yes       |",
-      "| D002 | M001/S02   | testing      | Unit test all parsers   | node:test framework    | Fast, zero-dependency    | no        |",
-    ].join("\n");
-
-    const compactOutput = formatDecisionsCompact(decisions);
-    const savings = measureSavings(compactOutput, markdownTable);
-    assert.ok(
-      savings >= 30,
-      `expected >=30% savings, got ${savings.toFixed(1)}%`,
-    );
-  });
-
-  it("requirements compact format saves 30%+ vs markdown sections", () => {
-    const requirements = [sampleRequirement, sampleRequirement2];
-
-    // Simulate verbose markdown format with all fields
-    const markdownSections = [
-      "## R001",
-      "",
-      "- **Class:** functional",
-      "- **Status:** active",
-      "- **Description:** Response latency < 200ms for API endpoints",
-      "- **Why:** Critical for user experience",
-      "- **Source:** architecture review",
-      "- **Primary Owner:** S01",
-      "- **Supporting Slices:** S02, S03",
-      "- **Validation:** Load test confirms P99 < 200ms",
-      "- **Notes:** Monitor in production",
-      "",
-      "## R002",
-      "",
-      "- **Class:** non-functional",
-      "- **Status:** active",
-      "- **Description:** Data consistency across writes",
-      "- **Why:** Prevents data loss",
-      "- **Source:** data team review",
-      "- **Primary Owner:** S02",
-      "- **Supporting Slices:** S01",
-      "- **Validation:** Integration test suite",
-      "- **Notes:** Requires WAL mode",
-    ].join("\n");
-
-    const compactOutput = formatRequirementsCompact(requirements);
-    const savings = measureSavings(compactOutput, markdownSections);
-    assert.ok(
-      savings >= 30,
-      `expected >=30% savings, got ${savings.toFixed(1)}%`,
-    );
-  });
-
-  it("task plan compact format saves 30%+ vs markdown sections", () => {
-    const tasks = [sampleTaskDone, sampleTaskPending];
-
-    // Simulate verbose markdown task format
-    const markdownTasks = [
-      "## T01 - Database schema",
-      "",
-      "- **Status:** Done",
-      "- **Estimate:** 30m",
-      "- **Description:** Create tables for decisions and requirements",
-      "- **Files:**",
-      "  - src/db.ts",
-      "  - src/schema.ts",
-      "",
-      "## T02 - API endpoints",
-      "",
-      "- **Status:** Pending",
-      "- **Estimate:** 1h",
-      "- **Description:** REST endpoints for CRUD operations",
-      "- **Files:**",
-      "  - src/api.ts",
-      "- **Verify:** npm test",
-    ].join("\n");
-
-    const compactOutput = formatTaskPlanCompact(tasks);
-    const savings = measureSavings(compactOutput, markdownTasks);
-    assert.ok(
-      savings >= 30,
-      `expected >=30% savings, got ${savings.toFixed(1)}%`,
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/subagent-model-dispatch.test.ts

@@ -15,6 +15,7 @@ import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { validatePreferences } from "../preferences-validation.ts";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const promptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8");
@@ -59,7 +60,7 @@ test("reactive_execution: subagent_model rejects empty string", () => {
 test("buildReactiveExecutePrompt: accepts subagentModel parameter", () => {
   const fnStart = promptsSrc.indexOf("export async function buildReactiveExecutePrompt");
   assert.ok(fnStart !== -1, "buildReactiveExecutePrompt should be exported");
-  const signature = promptsSrc.slice(fnStart, fnStart + 300);
+  const signature = extractSourceRegion(promptsSrc, "export async function buildReactiveExecutePrompt", { fromIdx: fnStart });
   assert.ok(
     signature.includes("subagentModel"),
     "buildReactiveExecutePrompt should accept a subagentModel parameter",
@@ -69,7 +70,7 @@ test("buildReactiveExecutePrompt: accepts subagentModel parameter", () => {
 test("buildParallelResearchSlicesPrompt: accepts subagentModel parameter", () => {
   const fnStart = promptsSrc.indexOf("export async function buildParallelResearchSlicesPrompt");
   assert.ok(fnStart !== -1, "buildParallelResearchSlicesPrompt should be exported");
-  const signature = promptsSrc.slice(fnStart, fnStart + 300);
+  const signature = extractSourceRegion(promptsSrc, "export async function buildParallelResearchSlicesPrompt", { fromIdx: fnStart });
   assert.ok(
     signature.includes("subagentModel"),
     "buildParallelResearchSlicesPrompt should accept a subagentModel parameter",
@@ -79,7 +80,7 @@ test("buildParallelResearchSlicesPrompt: accepts subagentModel parameter", () =>
 test("buildGateEvaluatePrompt: accepts subagentModel parameter", () => {
   const fnStart = promptsSrc.indexOf("export async function buildGateEvaluatePrompt");
   assert.ok(fnStart !== -1, "buildGateEvaluatePrompt should be exported");
-  const signature = promptsSrc.slice(fnStart, fnStart + 300);
+  const signature = extractSourceRegion(promptsSrc, "export async function buildGateEvaluatePrompt", { fromIdx: fnStart });
   assert.ok(
     signature.includes("subagentModel"),
     "buildGateEvaluatePrompt should accept a subagentModel parameter",
@@ -129,7 +130,7 @@ test("auto-dispatch: passes model to buildReactiveExecutePrompt", () => {
   // Find the reactive-execute dispatch rule
   const ruleStart = dispatchSrc.indexOf("reactive-execute (parallel dispatch)");
   assert.ok(ruleStart !== -1, "reactive-execute dispatch rule should exist");
-  const ruleBlock = dispatchSrc.slice(ruleStart, ruleStart + 1000);
+  const ruleBlock = extractSourceRegion(dispatchSrc, "reactive-execute (parallel dispatch)", { fromIdx: ruleStart });
   assert.ok(
     ruleBlock.includes("subagent_model") || ruleBlock.includes("subagentModel"),
     "reactive-execute rule should resolve and pass the subagent model",
@@ -140,7 +141,7 @@ test("auto-dispatch: passes model to buildParallelResearchSlicesPrompt", () => {
   const callIdx = dispatchSrc.indexOf("buildParallelResearchSlicesPrompt(");
   assert.ok(callIdx !== -1, "buildParallelResearchSlicesPrompt call should exist");
   // The call site should pass a model argument (not just 4 args)
-  const callSite = dispatchSrc.slice(callIdx, callIdx + 300);
+  const callSite = extractSourceRegion(dispatchSrc, "buildParallelResearchSlicesPrompt(", { fromIdx: callIdx });
   assert.ok(
     callSite.includes("subagentModel") || callSite.includes("resolveModelWithFallbacksForUnit"),
     "buildParallelResearchSlicesPrompt call should include model argument",
@@ -150,7 +151,7 @@ test("auto-dispatch: passes model to buildParallelResearchSlicesPrompt", () => {
 test("auto-dispatch: passes model to buildGateEvaluatePrompt", () => {
   const callIdx = dispatchSrc.indexOf("buildGateEvaluatePrompt(");
   assert.ok(callIdx !== -1, "buildGateEvaluatePrompt call should exist");
-  const callSite = dispatchSrc.slice(callIdx, callIdx + 300);
+  const callSite = extractSourceRegion(dispatchSrc, "buildGateEvaluatePrompt(", { fromIdx: callIdx });
   assert.ok(
     callSite.includes("subagentModel") || callSite.includes("resolveModelWithFallbacksForUnit"),
     "buildGateEvaluatePrompt call should include model argument",