gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.58d3d4d6c

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

@@ -11,6 +11,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));
 const SESSION_TS_PATH = join(__dirname, "..", "auto", "session.ts");
@@ -52,7 +53,7 @@ test("SidecarItem type is exported from session.ts", () => {
 test("SidecarItem has required kind field with hook/triage/quick-task union", () => {
   const source = getSessionTsSource();
   const ifaceIdx = source.indexOf("export interface SidecarItem");
-  const ifaceBlock = source.slice(ifaceIdx, ifaceIdx + 500);
+  const ifaceBlock = extractSourceRegion(source, "export interface SidecarItem");
   assert.ok(
     ifaceBlock.includes('"hook"') && ifaceBlock.includes('"triage"') && ifaceBlock.includes('"quick-task"'),
     "SidecarItem.kind must be a union of 'hook' | 'triage' | 'quick-task'",
@@ -77,7 +78,7 @@ test("AutoSession resets sidecarQueue in reset()", () => {
   const source = getSessionTsSource();
   const resetIdx = source.indexOf("reset(): void");
   assert.ok(resetIdx > -1, "AutoSession must have a reset() method");
-  const resetBlock = source.slice(resetIdx, resetIdx + 3000);
+  const resetBlock = extractSourceRegion(source, "reset(): void");
   assert.ok(
     resetBlock.includes("sidecarQueue"),
     "reset() must clear sidecarQueue",

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

@@ -0,0 +1,242 @@
+/**
+ * Tests for slice-cadence collapse — #4765.
+ *
+ * Covers mergeSliceToMain (squash + advance), resquashMilestoneOnMain,
+ * and the preference accessors.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import {
+  mergeSliceToMain,
+  resquashMilestoneOnMain,
+  getCollapseCadence,
+  getMilestoneResquash,
+} from "../slice-cadence.ts";
+import { MergeConflictError } from "../git-service.ts";
+import { summarizeWorktreeTelemetry } from "../worktree-telemetry.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+/** Create a temp git repo with an initial commit on main. */
+function createRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "slice-cad-test-")));
+  git(["init"], dir);
+  git(["config", "user.email", "test@test.com"], dir);
+  git(["config", "user.name", "Test"], dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  git(["add", "."], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+function enterMilestoneBranch(dir: string, milestoneId: string): void {
+  git(["checkout", "-b", `milestone/${milestoneId}`], dir);
+}
+
+function commitFile(dir: string, file: string, content: string, msg: string): string {
+  writeFileSync(join(dir, file), content);
+  git(["add", "."], dir);
+  git(["commit", "-m", msg], dir);
+  return git(["rev-parse", "HEAD"], dir);
+}
+
+describe("getCollapseCadence / getMilestoneResquash", () => {
+  test("defaults to milestone cadence", () => {
+    assert.equal(getCollapseCadence(undefined), "milestone");
+    assert.equal(getCollapseCadence(null), "milestone");
+    assert.equal(getCollapseCadence({}), "milestone");
+    assert.equal(getCollapseCadence({ git: {} }), "milestone");
+  });
+  test("reads slice cadence when set", () => {
+    assert.equal(getCollapseCadence({ git: { collapse_cadence: "slice" } }), "slice");
+  });
+  test("milestone_resquash defaults to true when not set", () => {
+    assert.equal(getMilestoneResquash(undefined), true);
+    assert.equal(getMilestoneResquash({ git: {} }), true);
+    assert.equal(getMilestoneResquash({ git: { milestone_resquash: true } }), true);
+  });
+  test("milestone_resquash can be disabled explicitly", () => {
+    assert.equal(getMilestoneResquash({ git: { milestone_resquash: false } }), false);
+  });
+});
+
+describe("mergeSliceToMain", () => {
+  let dir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    dir = createRepo();
+    originalCwd = process.cwd();
+  });
+
+  afterEach(() => {
+    try { process.chdir(originalCwd); } catch { /* */ }
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("squashes one slice's commits onto main and advances the milestone branch", () => {
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "feature.txt", "slice 1 work\n", "feat: S01 work");
+
+    process.chdir(dir);
+    const result = mergeSliceToMain(dir, "M001", "S01");
+
+    assert.equal(result.skipped, false);
+    assert.ok(result.commitSha, "expected a commit SHA");
+    assert.equal(result.milestoneBranch, "milestone/M001");
+    assert.equal(result.mainBranch, "main");
+
+    const mainLog = git(["log", "main", "--oneline"], dir);
+    assert.ok(mainLog.includes("S01 of M001 (slice-cadence)"), `main log: ${mainLog}`);
+    assert.equal(readFileSync(join(dir, "feature.txt"), "utf-8"), "slice 1 work\n");
+
+    const mainSha = git(["rev-parse", "main"], dir);
+    const milestoneSha = git(["rev-parse", "milestone/M001"], dir);
+    assert.equal(milestoneSha, mainSha, "milestone branch must be advanced to main");
+
+    const summary = summarizeWorktreeTelemetry(dir);
+    assert.equal(summary.slicesMerged, 1);
+    assert.equal(summary.sliceMergeConflicts, 0);
+  });
+
+  test("handles sequential slice merges cleanly", () => {
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "a.txt", "slice 1\n", "feat: S01");
+
+    process.chdir(dir);
+    mergeSliceToMain(dir, "M001", "S01");
+
+    git(["checkout", "milestone/M001"], dir);
+    commitFile(dir, "b.txt", "slice 2\n", "feat: S02");
+
+    const result = mergeSliceToMain(dir, "M001", "S02");
+    assert.equal(result.skipped, false);
+
+    const mainLog = git(["log", "main", "--oneline"], dir);
+    assert.ok(mainLog.includes("S01 of M001"));
+    assert.ok(mainLog.includes("S02 of M001"));
+
+    assert.equal(readFileSync(join(dir, "a.txt"), "utf-8"), "slice 1\n");
+    assert.equal(readFileSync(join(dir, "b.txt"), "utf-8"), "slice 2\n");
+
+    const summary = summarizeWorktreeTelemetry(dir);
+    assert.equal(summary.slicesMerged, 2);
+  });
+
+  test("returns skipped when milestone branch has no commits ahead of main", () => {
+    enterMilestoneBranch(dir, "M001");
+
+    process.chdir(dir);
+    const result = mergeSliceToMain(dir, "M001", "S01");
+
+    assert.equal(result.skipped, true);
+    assert.equal(result.skippedReason, "no-commits-ahead");
+    assert.equal(result.commitSha, null);
+  });
+
+  test("throws MergeConflictError on a real conflict and leaves no merge artifacts", () => {
+    writeFileSync(join(dir, "shared.txt"), "main version\n");
+    git(["add", "."], dir);
+    git(["commit", "-m", "main-seed"], dir);
+
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "shared.txt", "slice version\n", "feat: S01 conflicting");
+
+    git(["checkout", "main"], dir);
+    commitFile(dir, "shared.txt", "main evolved\n", "main evolved");
+    git(["checkout", "milestone/M001"], dir);
+
+    process.chdir(dir);
+    assert.throws(
+      () => mergeSliceToMain(dir, "M001", "S01"),
+      (err: unknown) => err instanceof MergeConflictError,
+    );
+
+    const gitDir = join(dir, ".git");
+    for (const f of ["SQUASH_MSG", "MERGE_MSG", "MERGE_HEAD"]) {
+      assert.ok(!existsSync(join(gitDir, f)), `${f} should be cleaned up`);
+    }
+
+    const summary = summarizeWorktreeTelemetry(dir);
+    assert.equal(summary.sliceMergeConflicts, 1);
+  });
+
+  test("restores cwd even when merge fails (dirty working tree)", () => {
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "feature.txt", "slice 1\n", "feat: S01");
+    // Introduce an untracked file AFTER the slice commit so it's still
+    // present when mergeSliceToMain runs its status check.
+    writeFileSync(join(dir, "dirty.txt"), "uncommitted\n");
+
+    process.chdir(dir);
+    const cwdBefore = process.cwd();
+    assert.throws(() => mergeSliceToMain(dir, "M001", "S01"));
+    assert.equal(process.cwd(), cwdBefore, "cwd must be restored on failure");
+  });
+});
+
+describe("resquashMilestoneOnMain", () => {
+  let dir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    dir = createRepo();
+    originalCwd = process.cwd();
+  });
+
+  afterEach(() => {
+    try { process.chdir(originalCwd); } catch { /* */ }
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("collapses N slice commits on main into one milestone commit", () => {
+    const startSha = git(["rev-parse", "main"], dir);
+
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "a.txt", "slice 1\n", "feat: S01");
+    process.chdir(dir);
+    mergeSliceToMain(dir, "M001", "S01");
+
+    git(["checkout", "milestone/M001"], dir);
+    commitFile(dir, "b.txt", "slice 2\n", "feat: S02");
+    mergeSliceToMain(dir, "M001", "S02");
+
+    const beforeCount = parseInt(git(["rev-list", "--count", `${startSha}..main`], dir), 10);
+    assert.equal(beforeCount, 2);
+
+    const result = resquashMilestoneOnMain(dir, "M001", startSha);
+    assert.equal(result.resquashed, true);
+    assert.ok(result.newSha);
+
+    git(["checkout", "main"], dir);
+    const afterCount = parseInt(git(["rev-list", "--count", `${startSha}..main`], dir), 10);
+    assert.equal(afterCount, 1, "slice commits collapsed into one milestone commit");
+
+    const msg = git(["log", "-1", "--format=%s", "main"], dir);
+    assert.ok(msg.includes("M001") && msg.includes("2 slices"), `commit message should describe the resquash; got: ${msg}`);
+
+    assert.equal(readFileSync(join(dir, "a.txt"), "utf-8"), "slice 1\n");
+    assert.equal(readFileSync(join(dir, "b.txt"), "utf-8"), "slice 2\n");
+
+    const summary = summarizeWorktreeTelemetry(dir);
+    assert.equal(summary.milestoneResquashes, 1);
+  });
+
+  test("no-op when startSha equals HEAD", () => {
+    const startSha = git(["rev-parse", "main"], dir);
+    process.chdir(dir);
+    const result = resquashMilestoneOnMain(dir, "M001", startSha);
+    assert.equal(result.resquashed, false);
+    assert.equal(result.newSha, null);
+  });
+});

package/src/resources/extensions/gsd/tests/slice-context-injection.test.ts

@@ -11,6 +11,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));
 const autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
@@ -32,7 +33,7 @@ describe("slice CONTEXT.md injection into prompt builders (#3452)", () => {
       assert.ok(fnStart !== -1, `${builder} should exist in auto-prompts.ts`);
 
       // Get a reasonable chunk after the function start
-      const chunk = source.slice(fnStart, fnStart + 3000);
+      const chunk = extractSourceRegion(source, `export async function ${builder}`);
 
       // ADR-011: buildPlanSlicePrompt / buildRefineSlicePrompt now delegate to
       // a shared helper (renderSlicePrompt) that performs the slice CONTEXT
@@ -42,7 +43,7 @@ describe("slice CONTEXT.md injection into prompt builders (#3452)", () => {
         ? (() => {
             const helperStart = source.indexOf("async function renderSlicePrompt");
             assert.ok(helperStart !== -1, "renderSlicePrompt helper must exist");
-            return source.slice(helperStart, helperStart + 3000);
+            return extractSourceRegion(source, "async function renderSlicePrompt");
           })()
         : chunk;
 

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");
+    });
   });
 
   // ═══════════════════════════════════════════════════════════════════════════

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/stuck-detection-coverage.test.ts

@@ -142,9 +142,9 @@ test("Rule 3: A-A-A-A triggers Rule 2 not Rule 3", () => {
 
 test("Rule 4: same ENOENT path in two entries triggers stuck", () => {
   const result = detectStuck([
-    { key: "A", error: "ENOENT: no such file or directory, access '/home/user/.gsd/agent/skills/debug-like-expert/SKILL.md'" },
+    { key: "A", error: "ENOENT: no such file or directory, access '/home/user/.agents/skills/debug-like-expert/SKILL.md'" },
     { key: "B" },
-    { key: "A", error: "ENOENT: no such file or directory, access '/home/user/.gsd/agent/skills/debug-like-expert/SKILL.md'" },
+    { key: "A", error: "ENOENT: no such file or directory, access '/home/user/.agents/skills/debug-like-expert/SKILL.md'" },
   ]);
   assert.notEqual(result, null);
   assert.equal(result!.stuck, true);

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",

package/src/resources/extensions/gsd/tests/sync-worktree-skip-current.test.ts

@@ -13,6 +13,7 @@ import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const src = readFileSync(
   resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'auto-worktree.ts'),
@@ -33,14 +34,14 @@ describe('syncWorktreeStateBack skips current milestone (#3641)', () => {
     assert.ok(fnStart !== -1)
 
     // Get a reasonable portion of the function
-    const fnBlock = src.slice(fnStart, fnStart + 3000)
+    const fnBlock = extractSourceRegion(src, 'function syncWorktreeStateBack(', { fromIdx: fnStart })
 
     // Find the for loop iterating milestones
     const loopIdx = fnBlock.indexOf('for (const mid of wtMilestones)')
     assert.ok(loopIdx !== -1, 'milestone iteration loop must exist')
 
     // After the loop, there should be the skip guard
-    const loopBody = fnBlock.slice(loopIdx, loopIdx + 300)
+    const loopBody = extractSourceRegion(fnBlock, 'for (const mid of wtMilestones)', { fromIdx: loopIdx })
     assert.ok(
       loopBody.includes('mid === milestoneId'),
       'mid === milestoneId skip guard must exist inside the milestone loop',
@@ -55,7 +56,7 @@ describe('syncWorktreeStateBack skips current milestone (#3641)', () => {
     const fnStart = src.indexOf('function syncWorktreeStateBack(')
     assert.ok(fnStart !== -1)
 
-    const fnBlock = src.slice(fnStart, fnStart + 3000)
+    const fnBlock = extractSourceRegion(src, 'function syncWorktreeStateBack(', { fromIdx: fnStart })
 
     assert.ok(
       fnBlock.includes('syncMilestoneDir('),