gsd-pi 2.77.0-dev.1d17f366c → 2.77.0-dev.58d3d4d6c

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/bootstrap-derive-state-db-open.test.ts

@@ -2,6 +2,7 @@ import { describe, 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 systemContextSrc = readFileSync(
   join(import.meta.dirname, "..", "bootstrap", "system-context.ts"),
@@ -29,7 +30,7 @@ describe("bootstrap deriveState DB guards (#3844)", () => {
   test("register-hooks opens DB before deriveState in session_before_compact", () => {
     const compactIdx = registerHooksSrc.indexOf('pi.on("session_before_compact"');
     assert.ok(compactIdx > -1, "register-hooks should define session_before_compact");
-    const compactSection = registerHooksSrc.slice(compactIdx, compactIdx + 1600);
+    const compactSection = extractSourceRegion(registerHooksSrc, 'pi.on("session_before_compact"');
     const ensureIdx = compactSection.indexOf("ensureDbOpen()");
     const deriveIdx = compactSection.indexOf("deriveState(basePath)");
     assert.ok(ensureIdx > -1, "session_before_compact should call ensureDbOpen()");

package/src/resources/extensions/gsd/tests/canonical-milestone-root.test.ts

@@ -0,0 +1,108 @@
+/**
+ * Tests for resolveCanonicalMilestoneRoot — the worktree-aware reader
+ * that fixes #4761 (worktree work stranded when auto-loop exits without
+ * milestone completion).
+ *
+ * Contract: given (basePath, milestoneId), return the worktree path if a
+ * live git worktree exists for that milestone at .gsd/worktrees/<MID>/;
+ * otherwise return basePath unchanged. A live worktree has a .git file
+ * (not directory) — a bare directory without .git is a stale leftover.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { resolveCanonicalMilestoneRoot } from "../worktree-manager.ts";
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-canon-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+}
+
+/**
+ * Create a worktree directory shape that looks live: the .gsd/worktrees/<MID>/
+ * directory with a .git file containing a gitdir: pointer. We don't need a
+ * real git worktree — the resolver only checks for the .git file's presence.
+ */
+function makeLiveWorktree(base: string, mid: string): string {
+  const wtPath = join(base, ".gsd", "worktrees", mid);
+  mkdirSync(wtPath, { recursive: true });
+  writeFileSync(
+    join(wtPath, ".git"),
+    `gitdir: ${join(base, ".git", "worktrees", mid)}\n`,
+  );
+  return wtPath;
+}
+
+function makeStaleWorktree(base: string, mid: string): string {
+  const wtPath = join(base, ".gsd", "worktrees", mid);
+  mkdirSync(wtPath, { recursive: true });
+  // No .git file — this is the stale-leftover shape createWorktree() sees
+  // and cleans up.
+  return wtPath;
+}
+
+test("returns worktree path when a live worktree exists for the milestone", () => {
+  const base = makeTmpBase();
+  try {
+    const wtPath = makeLiveWorktree(base, "M001");
+    const result = resolveCanonicalMilestoneRoot(base, "M001");
+    assert.equal(result, wtPath);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("returns basePath when no worktree directory exists", () => {
+  const base = makeTmpBase();
+  try {
+    const result = resolveCanonicalMilestoneRoot(base, "M001");
+    assert.equal(result, base);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("returns basePath when worktree directory exists but has no .git file (stale)", () => {
+  const base = makeTmpBase();
+  try {
+    makeStaleWorktree(base, "M001");
+    const result = resolveCanonicalMilestoneRoot(base, "M001");
+    assert.equal(result, base);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("returns basePath for invalid milestoneId (path separators)", () => {
+  const base = makeTmpBase();
+  try {
+    // Even if a worktree coincidentally exists, the guard should reject.
+    assert.equal(resolveCanonicalMilestoneRoot(base, "../evil"), base);
+    assert.equal(resolveCanonicalMilestoneRoot(base, "M001/subdir"), base);
+    assert.equal(resolveCanonicalMilestoneRoot(base, "M001\\subdir"), base);
+    assert.equal(resolveCanonicalMilestoneRoot(base, ""), base);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("only returns the worktree for the requested milestone, not siblings", () => {
+  const base = makeTmpBase();
+  try {
+    makeLiveWorktree(base, "M001");
+    const result = resolveCanonicalMilestoneRoot(base, "M002");
+    assert.equal(result, base, "M002 has no worktree → basePath");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/complete-slice-verification-gate.test.ts

@@ -11,6 +11,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', 'tools', 'complete-slice.ts'),
@@ -59,7 +60,7 @@ describe('complete-slice verification gate (#3580)', () => {
     const gateIdx = src.indexOf('BLOCKED_SIGNALS.test(')
     assert.ok(gateIdx !== -1)
 
-    const afterGate = src.slice(gateIdx, gateIdx + 500)
+    const afterGate = extractSourceRegion(src, 'BLOCKED_SIGNALS.test(')
     assert.ok(
       afterGate.includes('return { error:'),
       'blocked signal detection must return an error',

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

@@ -627,4 +627,83 @@ Integration tests mock external services.
 
     assert.strictEqual(result, '', 'empty content returns empty string');
   });
+
+  // ── Regression: issue #4719 — single-H2 with many H3 entries ──────────────
+  // A KNOWLEDGE.md structured as one top-level H2 with many H3 entries must
+  // filter at H3 granularity; otherwise one keyword match against the H2
+  // header or first paragraph returns the entire file.
+  test("single H2 with many H3 entries filters at H3 level (issue #4719)", async () => {
+    const singleH2Knowledge = `# Project Knowledge
+
+## Patterns
+
+### Database: prepared statements
+Always use prepared statements with SQLite.
+
+### API: versioned paths
+Use /v1/resource style versioning.
+
+### Testing: node:test
+Prefer node:test over external frameworks.
+
+### Deployment: blue-green
+Blue-green deployment for zero-downtime releases.
+`;
+
+    const result = await queryKnowledge(singleH2Knowledge, ['database']);
+
+    // Should include only the matching H3 entry, not the whole file
+    assert.match(result, /Database: prepared statements/, 'includes matching H3 entry');
+    assert.ok(
+      !result.includes('API: versioned paths'),
+      'does not include non-matching H3 entry',
+    );
+    assert.ok(
+      !result.includes('Testing: node:test'),
+      'does not include non-matching H3 entry',
+    );
+    assert.ok(
+      !result.includes('Deployment: blue-green'),
+      'does not include non-matching H3 entry',
+    );
+    // The returned payload must be dramatically smaller than the full content
+    assert.ok(
+      result.length < singleH2Knowledge.length / 2,
+      `scoped result (${result.length} chars) should be <50% of full content (${singleH2Knowledge.length} chars)`,
+    );
+  });
+
+  test("single H2 with H3 entries returns empty when no H3 matches (issue #4719)", async () => {
+    const singleH2Knowledge = `# Project Knowledge
+
+## Patterns
+
+### Database: prepared statements
+Always use prepared statements with SQLite.
+
+### API: versioned paths
+Use /v1/resource style versioning.
+`;
+
+    const result = await queryKnowledge(singleH2Knowledge, ['nonexistent']);
+
+    assert.strictEqual(result, '', 'no H3 match returns empty string');
+  });
+
+  test("falls back to H2 when no H3 headings exist at all", async () => {
+    // Backwards-compat: files with only H2 topic headers must still filter.
+    const h2OnlyKnowledge = `# Project Knowledge
+
+## Database Patterns
+Use prepared statements.
+
+## API Design
+REST with OpenAPI.
+`;
+
+    const result = await queryKnowledge(h2OnlyKnowledge, ['database']);
+
+    assert.match(result, /Database Patterns/, 'H2-only file falls back to H2 filtering');
+    assert.ok(!result.includes('API Design'), 'non-matching H2 section excluded');
+  });
 });

package/src/resources/extensions/gsd/tests/copy-planning-artifacts-samepath.test.ts

@@ -2,6 +2,7 @@ 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";
 
 test("copyPlanningArtifacts skips when source and destination .gsd resolve to the same path", () => {
   const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
@@ -10,7 +11,7 @@ test("copyPlanningArtifacts skips when source and destination .gsd resolve to th
   const fnIdx = src.indexOf("function copyPlanningArtifacts");
   assert.ok(fnIdx !== -1, "copyPlanningArtifacts function exists");
 
-  const fnBody = src.slice(fnIdx, fnIdx + 2400);
+  const fnBody = extractSourceRegion(src, "function copyPlanningArtifacts");
 
   const guardIdx = fnBody.indexOf("if (isSamePath(srcGsd, dstGsd)) return;");
   const copyIdx = fnBody.indexOf("safeCopyRecursive(join(srcGsd, \"milestones\")");

package/src/resources/extensions/gsd/tests/discuss-slice-structured-questions.test.ts

@@ -11,6 +11,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 template = readFileSync(
   resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'prompts', 'guided-discuss-slice.md'),
@@ -37,7 +38,7 @@ describe('discuss-slice structuredQuestionsAvailable template variable', () => {
     const falseIdx = template.indexOf('`{{structuredQuestionsAvailable}}` is `false`')
     assert.ok(falseIdx !== -1)
 
-    const afterFalse = template.slice(falseIdx, falseIdx + 300)
+    const afterFalse = extractSourceRegion(template, '`{{structuredQuestionsAvailable}}` is `false`')
     assert.ok(
       afterFalse.includes('plain text'),
       'when structuredQuestionsAvailable is false, questions should be in plain text',

package/src/resources/extensions/gsd/tests/discuss-tool-scope-leak.test.ts

@@ -22,6 +22,7 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { DISCUSS_TOOLS_ALLOWLIST } from "../constants.ts";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const guidedFlowSource = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
@@ -58,7 +59,7 @@ describe("#3616 — discuss tool scoping must not leak across sessions", () => {
 		);
 		const newSessionStart = agentSessionSource.indexOf("async newSession(options?:");
 		assert.ok(newSessionStart >= 0, "should find newSession");
-		const body = agentSessionSource.slice(newSessionStart, newSessionStart + 3000);
+		const body = extractSourceRegion(agentSessionSource, "async newSession(options?:");
 
 		// Both branches (cwd-changed and cwd-unchanged) must include extension tools
 		assert.ok(

package/src/resources/extensions/gsd/tests/double-merge-guard.test.ts

@@ -4,6 +4,7 @@ import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { AutoSession } from "../auto/session.ts";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -20,7 +21,7 @@ describe("double mergeAndExit guard (#2645)", () => {
     const completeIdx = phasesSrc.indexOf('state.phase === "complete"');
     assert.ok(completeIdx > 0, "phases.ts should have a 'complete' phase check");
 
-    const afterComplete = phasesSrc.slice(completeIdx, completeIdx + 600);
+    const afterComplete = extractSourceRegion(phasesSrc, 'state.phase === "complete"');
     const mergeIdx = afterComplete.indexOf("deps.resolver.mergeAndExit");
     const flagIdx = afterComplete.indexOf("s.milestoneMergedInPhases = true");
 
@@ -42,7 +43,7 @@ describe("double mergeAndExit guard (#2645)", () => {
     const allCompleteIdx = phasesSrc.indexOf("incomplete.length === 0");
     assert.ok(allCompleteIdx > 0, "phases.ts should have an all-milestones-complete check");
 
-    const afterAllComplete = phasesSrc.slice(allCompleteIdx, allCompleteIdx + 800);
+    const afterAllComplete = extractSourceRegion(phasesSrc, "incomplete.length === 0");
     const mergeIdx = afterAllComplete.indexOf("deps.resolver.mergeAndExit");
     const flagIdx = afterAllComplete.indexOf("s.milestoneMergedInPhases = true");
 
@@ -64,7 +65,7 @@ describe("double mergeAndExit guard (#2645)", () => {
     const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
     assert.ok(step4Idx > 0, "auto.ts should have Step 4 worktree exit");
 
-    const step4Block = autoSrc.slice(step4Idx, step4Idx + 600);
+    const step4Block = extractSourceRegion(autoSrc, "Step 4: Auto-worktree exit");
     assert.ok(
       step4Block.includes("milestoneMergedInPhases"),
       "stopAuto Step 4 must check milestoneMergedInPhases before merging",

package/src/resources/extensions/gsd/tests/empty-content-abort-loop.test.ts

@@ -13,6 +13,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 RECOVERY_PATH = join(__dirname, "..", "bootstrap", "agent-end-recovery.ts");
@@ -30,7 +31,7 @@ test("agent-end-recovery.ts does not pause on aborted messages with empty conten
   assert.ok(abortIdx > -1, "abort handler must exist in agent-end-recovery.ts");
 
   // Extract the region around the abort handler (enough to see the guard logic)
-  const abortRegion = source.slice(Math.max(0, abortIdx - 200), abortIdx + 600);
+  const abortRegion = extractSourceRegion(source, 'stopReason === "aborted"', { fromIdx: abortIdx });
 
   // Must check for empty content before pausing
   assert.ok(
@@ -48,7 +49,7 @@ test("agent-end-recovery.ts routes empty-content aborted messages to resolveAgen
   assert.ok(abortIdx > -1, "abort handler must exist");
 
   // Get the full abort handling block (from the if to the next stopReason check or success path)
-  const afterAbort = source.slice(abortIdx, abortIdx + 800);
+  const afterAbort = extractSourceRegion(source, 'stopReason === "aborted"');
 
   // The abort block must have a code path that calls resolveAgentEnd (for empty-content case)
   assert.ok(
@@ -63,7 +64,7 @@ test("agent-end-recovery.ts checks for errorMessage presence in abort handler (#
   const abortIdx = source.indexOf('stopReason === "aborted"');
   assert.ok(abortIdx > -1, "abort handler must exist");
 
-  const abortRegion = source.slice(abortIdx, abortIdx + 600);
+  const abortRegion = extractSourceRegion(source, 'stopReason === "aborted"');
 
   // Fatal aborts should have error context (errorMessage field).
   // The handler should check for this to distinguish fatal from non-fatal aborts.

package/src/resources/extensions/gsd/tests/finalize-timeout-guard.test.ts

@@ -16,7 +16,7 @@
  * isolated unit testing.
  */
 
-import { createTestContext } from "./test-helpers.ts";
+import {createTestContext, extractSourceRegion } from "./test-helpers.ts";
 import {
   withTimeout,
   FINALIZE_PRE_TIMEOUT_MS,
@@ -163,7 +163,7 @@ function getRunFinalizeBody(phasesSource: string): string {
   assertTrue(preVerIdx > 0, "postUnitPreVerification should appear in runFinalize");
 
   // The first withTimeout should wrap postUnitPreVerification (not postUnitPostVerification)
-  const firstWithTimeout = fnBody.slice(preTimeoutIdx, preTimeoutIdx + 200);
+  const firstWithTimeout = extractSourceRegion(fnBody, "withTimeout(");
   assertTrue(
     firstWithTimeout.includes("postUnitPreVerification"),
     "first withTimeout in runFinalize should wrap postUnitPreVerification",

package/src/resources/extensions/gsd/tests/forensics-hook-key-parse.test.ts

@@ -14,6 +14,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 gsdDir = join(__dirname, "..");
@@ -43,7 +44,7 @@ describe("forensics hook compound key parsing (#2826)", () => {
   it("detectMissingArtifacts delegates to splitCompletedKey", () => {
     const fnStart = forensicsSrc.indexOf("function detectMissingArtifacts(");
     assert.ok(fnStart !== -1, "detectMissingArtifacts must exist in forensics.ts");
-    const fnBody = forensicsSrc.slice(fnStart, fnStart + 1000);
+    const fnBody = extractSourceRegion(forensicsSrc, "function detectMissingArtifacts(");
     assert.ok(
       fnBody.includes("splitCompletedKey("),
       "detectMissingArtifacts must call splitCompletedKey() rather than inline the split logic",

package/src/resources/extensions/gsd/tests/forensics-worktree-telemetry.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Tests for the #4764 forensics integration — verifies that
+ * buildForensicReport picks up worktree telemetry aggregates and emits
+ * anomalies for orphans and auto-exits with unmerged work.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, mkdirSync, rmSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+
+import {
+  emitWorktreeOrphaned,
+  emitAutoExit,
+  emitWorktreeCreated,
+  emitWorktreeMerged,
+} from "../worktree-telemetry.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const gsdDir = join(__dirname, "..");
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-for-tel-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+}
+
+describe("#4764 forensics + worktree telemetry integration", () => {
+  const forensicsSrc = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
+
+  it("forensics.ts imports the telemetry summarizer", () => {
+    assert.ok(
+      forensicsSrc.includes("summarizeWorktreeTelemetry"),
+      "forensics must consume the telemetry aggregator",
+    );
+  });
+
+  it("forensics.ts does NOT call queryJournal directly (memory guard)", () => {
+    // The same invariant guarded by forensics-journal.test.ts — re-asserted
+    // here so this feature change doesn't regress it.
+    assert.ok(
+      !forensicsSrc.includes("queryJournal("),
+      "forensics.ts must route journal reads through aggregators, not queryJournal",
+    );
+  });
+
+  it("ForensicReport includes worktreeTelemetry field", () => {
+    assert.ok(
+      forensicsSrc.includes("worktreeTelemetry"),
+      "report shape must include the telemetry summary",
+    );
+  });
+
+  it("formatReportForPrompt gates Worktree Telemetry section on signal", () => {
+    assert.ok(
+      forensicsSrc.includes("Worktree Telemetry"),
+      "prompt formatter must include a Worktree Telemetry section",
+    );
+  });
+
+  it("new anomaly types worktree-orphan and worktree-unmerged-exit exist on the union", () => {
+    assert.ok(forensicsSrc.includes('"worktree-orphan"'));
+    assert.ok(forensicsSrc.includes('"worktree-unmerged-exit"'));
+  });
+
+  it("buildForensicReport surfaces worktree-orphan anomaly when the journal shows an in-progress orphan", async () => {
+    const base = makeTmpBase();
+    try {
+      // Seed the journal with one in-progress orphan event
+      emitWorktreeOrphaned(base, "M001", {
+        reason: "in-progress-unmerged",
+        commitsAhead: 3,
+        worktreeDirExists: true,
+      });
+
+      const { buildForensicReport } = await import("../forensics.ts");
+      const report = await buildForensicReport(base);
+
+      const orphanAnomalies = report.anomalies.filter(a => a.type === "worktree-orphan");
+      assert.ok(orphanAnomalies.length >= 1, `expected a worktree-orphan anomaly; got ${JSON.stringify(report.anomalies.map(a => a.type))}`);
+      assert.equal(orphanAnomalies[0].severity, "warning", "in-progress orphan should be a warning");
+
+      // Aggregate fields surface in the telemetry summary
+      assert.ok(report.worktreeTelemetry, "report should carry the telemetry summary");
+      assert.equal(report.worktreeTelemetry!.orphansDetected, 1);
+      assert.equal(report.worktreeTelemetry!.orphansByReason["in-progress-unmerged"], 1);
+    } finally { cleanup(base); }
+  });
+
+  it("buildForensicReport surfaces worktree-unmerged-exit anomaly when auto-exit left work unmerged", async () => {
+    const base = makeTmpBase();
+    try {
+      emitAutoExit(base, { reason: "pause", milestoneId: "M002", milestoneMerged: false });
+      emitAutoExit(base, { reason: "stop", milestoneId: "M002", milestoneMerged: false });
+      emitAutoExit(base, { reason: "all-complete", milestoneId: "M001", milestoneMerged: true });
+
+      const { buildForensicReport } = await import("../forensics.ts");
+      const report = await buildForensicReport(base);
+
+      const unmergedExitAnomalies = report.anomalies.filter(a => a.type === "worktree-unmerged-exit");
+      assert.equal(unmergedExitAnomalies.length, 1, "exactly one aggregate unmerged-exit anomaly");
+      assert.equal(unmergedExitAnomalies[0].severity, "warning");
+      assert.ok(
+        unmergedExitAnomalies[0].summary.includes("2"),
+        "summary should mention the count (2 unmerged exits out of 3 total)",
+      );
+
+      assert.equal(report.worktreeTelemetry!.exitsWithUnmergedWork, 2);
+    } finally { cleanup(base); }
+  });
+
+  it("buildForensicReport emits no telemetry anomalies when there are no signals", async () => {
+    const base = makeTmpBase();
+    try {
+      // Healthy path — worktree created and merged without incident
+      emitWorktreeCreated(base, "M001");
+      emitWorktreeMerged(base, "M001", {
+        reason: "milestone-complete",
+        durationMs: 250,
+        conflict: false,
+      });
+      emitAutoExit(base, { reason: "all-complete", milestoneId: "M001", milestoneMerged: true });
+
+      const { buildForensicReport } = await import("../forensics.ts");
+      const report = await buildForensicReport(base);
+
+      const telemetryAnomalies = report.anomalies.filter(a =>
+        a.type === "worktree-orphan" || a.type === "worktree-unmerged-exit"
+      );
+      assert.deepStrictEqual(telemetryAnomalies, [], "no orphans, no unmerged exits → no telemetry anomalies");
+
+      assert.equal(report.worktreeTelemetry!.worktreesCreated, 1);
+      assert.equal(report.worktreeTelemetry!.worktreesMerged, 1);
+      assert.equal(report.worktreeTelemetry!.orphansDetected, 0);
+      assert.equal(report.worktreeTelemetry!.exitsWithUnmergedWork, 0);
+    } finally { cleanup(base); }
+  });
+});

package/src/resources/extensions/gsd/tests/idle-watchdog-stall-override.test.ts

@@ -18,6 +18,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { test, describe } from "node:test";
 import assert from "node:assert/strict";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const TIMERS_SRC = readFileSync(
   join(import.meta.dirname, "..", "auto-timers.ts"),
@@ -97,7 +98,11 @@ describe("#2527 Bug 2: null guard after async recovery prevents crash", () => {
 
     // The null guard must appear between the recovery call and the next
     // writeUnitRuntimeRecord that accesses s.currentUnit.startedAt
-    const afterRecovery = TIMERS_SRC.slice(idleRecovery, idleRecovery + 400);
+    const afterRecovery = extractSourceRegion(
+      TIMERS_SRC,
+      'recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle"',
+      { fromIdx: idleRecovery },
+    );
     assert.ok(
       afterRecovery.includes("if (!s.currentUnit) return"),
       "null guard for s.currentUnit must exist after idle recoverTimedOutUnit",

package/src/resources/extensions/gsd/tests/import-done-milestones.test.ts

@@ -10,6 +10,7 @@ import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -30,7 +31,7 @@ describe('import done milestones as complete (#3699)', () => {
     // Find the all-done guard and verify it sets 'complete'
     const everyIdx = importerSrc.indexOf('roadmap.slices.every(s => s.done)');
     assert.ok(everyIdx > -1, 'all-slices-done check should exist');
-    const afterCheck = importerSrc.slice(everyIdx, everyIdx + 200);
+    const afterCheck = extractSourceRegion(importerSrc, 'roadmap.slices.every(s => s.done)');
     assert.match(afterCheck, /milestoneStatus\s*=\s*'complete'/,
       'should set milestoneStatus to complete when all slices are done');
   });

package/src/resources/extensions/gsd/tests/integration/all-milestones-complete-merge.test.ts

@@ -12,6 +12,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { extractSourceRegion } from "../test-helpers.ts";
 import {
   mkdtempSync,
   mkdirSync,
@@ -115,7 +116,7 @@ test("auto-loop 'all milestones complete' path merges before stopping (#962)", (
     helperIdx > -1,
     "WorktreeResolver.mergeAndExit helper should exist",
   );
-  const helperBlock = resolverSrc.slice(helperIdx, helperIdx + 2600);
+  const helperBlock = extractSourceRegion(resolverSrc, "mergeAndExit(milestoneId");
   assert.ok(
     helperBlock.includes('mode === "worktree"') ||
       helperBlock.includes('mode: "worktree"'),

package/src/resources/extensions/gsd/tests/interactive-routing-bypass.test.ts

@@ -8,6 +8,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));
 
@@ -62,7 +63,7 @@ describe("interactive routing bypass (#3962)", () => {
     );
     // The function should check isAutoMode before routing synthesis
     const fnIdx = modelSelectionSrc.indexOf("function resolvePreferredModelConfig");
-    const fnBody = modelSelectionSrc.slice(fnIdx, fnIdx + 900);
+    const fnBody = extractSourceRegion(modelSelectionSrc, "function resolvePreferredModelConfig");
     assert.ok(
       fnBody.includes("isAutoMode"),
       "resolvePreferredModelConfig should accept isAutoMode parameter",
@@ -137,8 +138,13 @@ describe("model downgrade notifications always visible (#3962)", () => {
     const escalatedIdx = modelSelectionSrc.indexOf("if (escalated)");
     assert.ok(escalatedIdx > 0, "escalation block should exist");
 
-    // Get the block from "if (escalated)" to the next closing brace pattern
-    const block = modelSelectionSrc.slice(escalatedIdx, escalatedIdx + 400);
+    // Get the block from "if (escalated)" to the next distinctive marker
+    // (the capability-override loading that immediately follows).
+    const block = extractSourceRegion(
+      modelSelectionSrc,
+      "if (escalated)",
+      "// Load user capability overrides",
+    );
     assert.ok(
       block.includes("Tier escalation:"),
       "escalation block should contain the notification",