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

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

@@ -0,0 +1,152 @@
+import type { Phase } from "./types.js";
+
+export type StateTransitionReasonCode =
+  | "state"
+  | "manual"
+  | "recovery"
+  | "dependency"
+  | "policy"
+  | "retry";
+
+export interface StateTransitionEntry {
+  from: Phase | "*";
+  event: string;
+  guard: string;
+  to: Phase;
+  onFail: Phase | "manual-attention" | "blocked" | "no-transition";
+  reasonCode: StateTransitionReasonCode;
+}
+
+export const STATE_TRANSITION_MATRIX: readonly StateTransitionEntry[] = [
+  {
+    from: "needs-discussion",
+    event: "context-ready",
+    guard: "CONTEXT artifact exists or PRD/context express path produced context",
+    to: "researching",
+    onFail: "needs-discussion",
+    reasonCode: "state",
+  },
+  {
+    from: "researching",
+    event: "research-ready",
+    guard: "RESEARCH artifact exists or research is explicitly skipped",
+    to: "planning",
+    onFail: "researching",
+    reasonCode: "state",
+  },
+  {
+    from: "planning",
+    event: "plan-ready",
+    guard: "ROADMAP/PLAN artifacts exist and plan gate passes",
+    to: "executing",
+    onFail: "replanning-slice",
+    reasonCode: "state",
+  },
+  {
+    from: "executing",
+    event: "task-dispatched",
+    guard: "task inputs are ready and dependencies are closed",
+    to: "executing",
+    onFail: "blocked",
+    reasonCode: "dependency",
+  },
+  {
+    from: "executing",
+    event: "slice-complete",
+    guard: "all slice tasks are closed and verification gate passes",
+    to: "summarizing",
+    onFail: "validating-milestone",
+    reasonCode: "state",
+  },
+  {
+    from: "summarizing",
+    event: "summary-ready",
+    guard: "SUMMARY artifact exists for the completed work unit",
+    to: "validating-milestone",
+    onFail: "summarizing",
+    reasonCode: "state",
+  },
+  {
+    from: "validating-milestone",
+    event: "validation-pass",
+    guard: "validation verdict is terminal and not remediation-required",
+    to: "completing-milestone",
+    onFail: "blocked",
+    reasonCode: "state",
+  },
+  {
+    from: "blocked",
+    event: "recovery-plan-ready",
+    guard: "reassessment produced an executable next action",
+    to: "executing",
+    onFail: "blocked",
+    reasonCode: "recovery",
+  },
+  {
+    from: "replanning-slice",
+    event: "replan-ready",
+    guard: "replacement slice/task plan exists and plan gate passes",
+    to: "executing",
+    onFail: "blocked",
+    reasonCode: "recovery",
+  },
+  {
+    from: "completing-milestone",
+    event: "closeout-complete",
+    guard: "closeout gate passes and git transaction succeeds",
+    to: "complete",
+    onFail: "blocked",
+    reasonCode: "state",
+  },
+  {
+    from: "*",
+    event: "manual-block",
+    guard: "operator or hard gate requested manual attention",
+    to: "blocked",
+    onFail: "manual-attention",
+    reasonCode: "manual",
+  },
+  {
+    from: "*",
+    event: "retryable-failure",
+    guard: "retry budget remains for failure class",
+    to: "executing",
+    onFail: "blocked",
+    reasonCode: "retry",
+  },
+] as const;
+
+export interface MatrixValidationResult {
+  ok: boolean;
+  missingEvents: string[];
+  duplicateKeys: string[];
+}
+
+export function findTransition(
+  from: Phase,
+  event: string,
+): StateTransitionEntry | undefined {
+  return STATE_TRANSITION_MATRIX.find((entry) =>
+    (entry.from === from || entry.from === "*") && entry.event === event,
+  );
+}
+
+export function validateTransitionMatrix(requiredEvents: readonly string[]): MatrixValidationResult {
+  const seen = new Set<string>();
+  const duplicateKeys: string[] = [];
+
+  for (const entry of STATE_TRANSITION_MATRIX) {
+    const key = `${entry.from}:${entry.event}`;
+    if (seen.has(key)) duplicateKeys.push(key);
+    seen.add(key);
+  }
+
+  const availableEvents = new Set(STATE_TRANSITION_MATRIX.map((entry) => entry.event));
+  const missingEvents = requiredEvents.filter((event) => !availableEvents.has(event));
+
+  return {
+    ok: missingEvents.length === 0 && duplicateKeys.length === 0,
+    missingEvents,
+    duplicateKeys,
+  };
+}

package/src/resources/extensions/gsd/state.ts

@@ -46,6 +46,7 @@ import { logWarning, logError } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
 import { loadEffectiveGSDPreferences } from './preferences.js';
 import { detectPendingEscalation } from './escalation.js';
+import { isTerminalMilestoneSummaryContent } from './milestone-summary-classifier.js';
 
 import {
   isDbAvailable,
@@ -139,6 +140,14 @@ export function isValidationTerminal(validationContent: string): boolean {
   return extractVerdict(validationContent) != null;
 }
 
+async function isTerminalMilestoneSummaryFile(
+  path: string,
+  loader: (path: string) => Promise<string | null>,
+): Promise<boolean> {
+  const content = await loader(path);
+  return content != null && isTerminalMilestoneSummaryContent(content);
+}
+
 // ─── State Derivation ──────────────────────────────────────────────────────
 
 // ── deriveState memoization ─────────────────────────────────────────────────
@@ -211,15 +220,15 @@ export async function getActiveMilestoneId(basePath: string): Promise<string | n
     const content = roadmapFile ? await loadFile(roadmapFile) : null;
     if (!content) {
       const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
-      if (summaryFile) continue;
+      if (summaryFile && await isTerminalMilestoneSummaryFile(summaryFile, loadFile)) continue;
       if (isGhostMilestone(basePath, mid)) continue;
       return mid;
     }
     const roadmap = parseRoadmap(content);
-    if (!isMilestoneComplete(roadmap)) {
-      const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
-      if (!summaryFile) return mid;
-    }
+    const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
+    if (summaryFile && await isTerminalMilestoneSummaryFile(summaryFile, loadFile)) continue;
+    if (!isMilestoneComplete(roadmap)) return mid;
+    return mid;
   }
   return null;
 }
@@ -668,7 +677,6 @@ function resolveSliceDependencies(activeMilestoneSlices: SliceRow[]): { activeSl
     }
   }
 
-  // First pass: find a slice with ALL dependencies satisfied (strict)
   let bestFallback: SliceRow | null = null;
   let bestFallbackSatisfied = -1;
 
@@ -678,7 +686,6 @@ function resolveSliceDependencies(activeMilestoneSlices: SliceRow[]): { activeSl
     if (s.depends.every(dep => doneSliceIds.has(dep))) {
       return { activeSlice: { id: s.id, title: s.title }, activeSliceRow: s };
     }
-    // Track the slice with the most satisfied dependencies as fallback
     const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
     if (satisfied > bestFallbackSatisfied || (satisfied === bestFallbackSatisfied && !bestFallback)) {
       bestFallback = s;
@@ -686,16 +693,13 @@ function resolveSliceDependencies(activeMilestoneSlices: SliceRow[]): { activeSl
     }
   }
 
-  // Fallback: if no slice has all deps met but there ARE incomplete non-deferred
-  // slices, pick the one with the most deps satisfied. This prevents hard-blocking
-  // when dependency metadata is stale (e.g. after reassessment added/removed slices)
-  // or when deps reference slices from previous milestones.
   if (bestFallback) {
     const unmet = bestFallback.depends.filter(dep => !doneSliceIds.has(dep));
-    logWarning("state",
+    logWarning(
+      "state",
       `No slice has all deps satisfied — falling back to ${bestFallback.id} ` +
-      `(${bestFallbackSatisfied}/${bestFallback.depends.length} deps met, ` +
-      `unmet: ${unmet.join(", ")})`,
+        `(${bestFallbackSatisfied}/${bestFallback.depends.length} deps met, ` +
+        `unmet: ${unmet.join(", ")})`,
       { mid: activeMilestoneSlices[0]?.milestone_id, sid: bestFallback.id },
     );
     return { activeSlice: { id: bestFallback.id, title: bestFallback.title }, activeSliceRow: bestFallback };
@@ -1160,7 +1164,7 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
     const rc = rf ? await cachedLoadFile(rf) : null;
     if (!rc) {
       const sf = resolveMilestoneFile(basePath, mid, "SUMMARY");
-      if (sf) completeMilestoneIds.add(mid);
+      if (sf && await isTerminalMilestoneSummaryFile(sf, cachedLoadFile)) completeMilestoneIds.add(mid);
       continue;
     }
     const rmap = parseRoadmap(rc);
@@ -1169,11 +1173,11 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       // Summary is the terminal artifact — if it exists, the milestone is
       // complete even when roadmap checkboxes weren't ticked (#864).
       const sf = resolveMilestoneFile(basePath, mid, "SUMMARY");
-      if (sf) completeMilestoneIds.add(mid);
+      if (sf && await isTerminalMilestoneSummaryFile(sf, cachedLoadFile)) completeMilestoneIds.add(mid);
       continue;
     }
     const sf = resolveMilestoneFile(basePath, mid, "SUMMARY");
-    if (sf) completeMilestoneIds.add(mid);
+    if (sf && await isTerminalMilestoneSummaryFile(sf, cachedLoadFile)) completeMilestoneIds.add(mid);
   }
 
   // Phase 2: Build registry using cached roadmaps (no re-parsing or re-reading)
@@ -1201,12 +1205,14 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
       if (summaryFile) {
         const summaryContent = await cachedLoadFile(summaryFile);
-        const summaryTitle = summaryContent
-          ? (parseSummary(summaryContent).title || mid)
-          : mid;
-        registry.push({ id: mid, title: summaryTitle, status: 'complete' });
-        completeMilestoneIds.add(mid);
-        continue;
+        if (summaryContent != null && isTerminalMilestoneSummaryContent(summaryContent)) {
+          const summaryTitle = summaryContent
+            ? (parseSummary(summaryContent).title || mid)
+            : mid;
+          registry.push({ id: mid, title: summaryTitle, status: 'complete' });
+          completeMilestoneIds.add(mid);
+          continue;
+        }
       }
       // Ghost milestone (only META.json, no CONTEXT/ROADMAP/SUMMARY) — skip entirely
       if (isGhostMilestone(basePath, mid)) continue;
@@ -1262,7 +1268,7 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       // needs-remediation is terminal but requires re-validation (#3596)
       const needsRevalidation = !validationTerminal || verdict === 'needs-remediation';
 
-      if (summaryFile) {
+      if (summaryFile && await isTerminalMilestoneSummaryFile(summaryFile, cachedLoadFile)) {
         // Summary exists → milestone is complete regardless of validation state.
         // The summary is the terminal artifact (#864).
         registry.push({ id: mid, title, status: 'complete' });
@@ -1288,7 +1294,7 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       // Roadmap slices not all checked — but if a summary exists, the milestone
       // is still complete. The summary is the terminal artifact (#864).
       const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
-      if (summaryFile) {
+      if (summaryFile && await isTerminalMilestoneSummaryFile(summaryFile, cachedLoadFile)) {
         registry.push({ id: mid, title, status: 'complete' });
       } else if (!activeMilestoneFound) {
         // Check milestone-level dependencies before promoting to active.
@@ -1572,7 +1578,6 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
         activeSlice = { id: s.id, title: s.title };
         break;
       }
-      // Track best fallback
       const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
       if (satisfied > bestFallbackLegacySatisfied) {
         bestFallbackLegacy = s;
@@ -1580,13 +1585,13 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       }
     }
 
-    // Fallback: if no slice has all deps met, pick the one with the most deps satisfied
     if (!activeSlice && bestFallbackLegacy) {
       const unmet = bestFallbackLegacy.depends.filter(dep => !doneSliceIds.has(dep));
-      logWarning("state",
+      logWarning(
+        "state",
         `No slice has all deps satisfied — falling back to ${bestFallbackLegacy.id} ` +
-        `(${bestFallbackLegacySatisfied}/${bestFallbackLegacy.depends.length} deps met, ` +
-        `unmet: ${unmet.join(", ")})`,
+          `(${bestFallbackLegacySatisfied}/${bestFallbackLegacy.depends.length} deps met, ` +
+          `unmet: ${unmet.join(", ")})`,
       );
       activeSlice = { id: bestFallbackLegacy.id, title: bestFallbackLegacy.title };
     }

package/src/resources/extensions/gsd/tests/artifacts-table-preserved-on-cache-invalidate.test.ts

@@ -22,6 +22,7 @@ import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
 import { invalidateAllCaches } from "../cache.ts";
+import { extractSourceRegion } from "./test-helpers.ts";
 import {
   openDatabase,
   closeDatabase,
@@ -160,7 +161,7 @@ describe("cache.ts must not re-import clearArtifacts into invalidateAllCaches",
   test("invalidateAllCaches does not call clearArtifacts", () => {
     const fnIdx = src.indexOf("function invalidateAllCaches");
     assert.ok(fnIdx !== -1);
-    const body = src.slice(fnIdx, fnIdx + 1000);
+    const body = extractSourceRegion(src, "function invalidateAllCaches", { fromIdx: fnIdx });
     assert.ok(
       !/\bclearArtifacts\s*\(/.test(body),
       "invalidateAllCaches must not call clearArtifacts() — it wipes the write-through store",

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

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
+import { extractSourceRegion } from "./test-helpers.ts";
 import {
   resolveAgentEnd,
   resolveAgentEndCancelled,
@@ -10,6 +11,7 @@ import {
   autoLoop,
   detectStuck,
   _resetPendingResolve,
+  _hasPendingResolveForTest,
   _setActiveSession,
   isSessionSwitchInFlight,
   type UnitResult,
@@ -379,6 +381,7 @@ test("runUnit cancels before dispatch when provider is not request-ready (#4555)
     /Provider anthropic is not request-ready/,
   );
   assert.equal(pi.calls.length, 0, "sendMessage must not be called when provider is not ready");
+  assert.equal(_hasPendingResolveForTest(), false, "provider cancellation must clear the pending resolver");
 });
 
 test("runUnit cancels before dispatch using currentUnitModel provider when set (#4555)", async () => {
@@ -593,7 +596,7 @@ test("auto/phases.ts: selectAndApplyModel called exactly once and before updateP
   // Extract the runUnitPhase function body
   const fnStart = src.indexOf("export async function runUnitPhase");
   assert.ok(fnStart > 0, "runUnitPhase should exist in phases.ts");
-  const fnBody = src.slice(fnStart, fnStart + 16000);
+  const fnBody = extractSourceRegion(src, "export async function runUnitPhase");
 
   // selectAndApplyModel must appear exactly once
   const allOccurrences = [...fnBody.matchAll(/selectAndApplyModel\(/g)];
@@ -849,6 +852,45 @@ test("autoLoop exits on terminal complete state", async (t) => {
   );
 });
 
+test("autoLoop pauses when provider readiness cancels before dispatch", async () => {
+  _resetPendingResolve();
+
+  const notifications: Array<{ message: string; level?: string }> = [];
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  ctx.ui.notify = (message: string, level?: string) => {
+    notifications.push({ message, level });
+  };
+  ctx.model = { provider: "anthropic", id: "claude-opus-4-6" };
+  ctx.modelRegistry = {
+    getProviderAuthMode: () => "api-key",
+    isProviderRequestReady: () => false,
+  };
+
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+  const deps = makeMockDeps({
+    selectAndApplyModel: async () => ({
+      routing: null,
+      appliedModel: { provider: "anthropic", id: "claude-opus-4-6" },
+    }),
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.equal(pi.calls.length, 0, "provider readiness cancellation must not dispatch a message");
+  assert.ok(deps.callLog.includes("pauseAuto"), "provider readiness cancellation should pause auto-mode");
+  assert.ok(!deps.callLog.includes("stopAuto"), "provider readiness cancellation should not hard-stop auto-mode");
+  assert.ok(
+    !deps.callLog.includes("postUnitPreVerification"),
+    "post-unit verification must not run after pre-dispatch provider cancellation",
+  );
+  assert.ok(
+    notifications.some(n => /Provider anthropic is not request-ready/.test(n.message)),
+    "provider pause should notify with the readiness failure",
+  );
+});
+
 test("autoLoop passes structured session-lock failure details to the handler", async () => {
   _resetPendingResolve();
 
@@ -1497,9 +1539,7 @@ test("auto.ts startAuto dispatches through the UOK kernel wrapper with explicit
   // Find the startAuto function body
   const fnIdx = src.indexOf("export async function startAuto");
   assert.ok(fnIdx > -1, "startAuto must exist in auto.ts");
-  const fnEnd = src.indexOf("\n// ─── ", fnIdx + 100);
-  const fnBlock =
-    fnEnd > -1 ? src.slice(fnIdx, fnEnd) : src.slice(fnIdx, fnIdx + 5000);
+  const fnBlock = extractSourceRegion(src, "export async function startAuto", "\n// ─── ");
   assert.ok(
     fnBlock.includes("runAutoLoopWithUok("),
     "startAuto must dispatch through runAutoLoopWithUok()",
@@ -1521,9 +1561,7 @@ test("startAuto calls selfHealRuntimeRecords before autoLoop (#1727)", { skip: "
   );
   const fnIdx = src.indexOf("export async function startAuto");
   assert.ok(fnIdx > -1, "startAuto must exist in auto.ts");
-  const fnEnd = src.indexOf("\n// ─── ", fnIdx + 100);
-  const fnBlock =
-    fnEnd > -1 ? src.slice(fnIdx, fnEnd) : src.slice(fnIdx, fnIdx + 5000);
+  const fnBlock = extractSourceRegion(src, "export async function startAuto", "\n// ─── ");
 
   // Both autoLoop call sites must be preceded by selfHealRuntimeRecords
   const healIdx = fnBlock.indexOf("selfHealRuntimeRecords");
@@ -1548,7 +1586,7 @@ test("startAuto guards against concurrent invocation (#2923)", () => {
   const fnIdx = src.indexOf("export async function startAuto");
   assert.ok(fnIdx > -1, "startAuto must exist in auto.ts");
   // The guard must appear before any other logic in the function body
-  const fnBody = src.slice(fnIdx, fnIdx + 500);
+  const fnBody = extractSourceRegion(src, "export async function startAuto");
   const activeGuard = fnBody.indexOf("if (s.active)");
   assert.ok(activeGuard > -1, "startAuto must check s.active to prevent concurrent auto-loops");
   const returnIdx = fnBody.indexOf("return;", activeGuard);
@@ -1609,9 +1647,16 @@ test("auto-timeout-recovery.ts calls resolveAgentEnd instead of dispatchNextUnit
     !src.includes("await dispatchNextUnit"),
     "auto-timeout-recovery.ts must not call dispatchNextUnit",
   );
+  // After PR #4716, advance branches go through bumpAndResolveSynthetic()
+  // (which bumps the turn epoch and calls resolveAgentEnd atomically).
+  // Either direct resolveAgentEnd() or the helper satisfies the invariant:
+  // the loop must be re-iterated on timeout recovery.
+  const reIteratesLoop =
+    src.includes("resolveAgentEnd(") ||
+    src.includes("bumpAndResolveSynthetic(");
   assert.ok(
-    src.includes("resolveAgentEnd("),
-    "auto-timeout-recovery.ts must call resolveAgentEnd to re-iterate the loop on timeout recovery",
+    reIteratesLoop,
+    "auto-timeout-recovery.ts must call resolveAgentEnd (directly or via bumpAndResolveSynthetic) to re-iterate the loop on timeout recovery",
   );
 });
 

package/src/resources/extensions/gsd/tests/auto-mode-guards.test.ts

@@ -0,0 +1,79 @@
+/**
+ * Regression tests for auto-mode guards (#4704 Tier 2 / #4712).
+ *
+ * Validates the defense-in-depth writer asserts in milestone-actions.ts —
+ * parkMilestone, unparkMilestone, and discardMilestone must refuse to run
+ * while auto-mode is active, regardless of the calling dispatch path.
+ */
+import { describe, test, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { parkMilestone, unparkMilestone, discardMilestone } from '../milestone-actions.ts';
+import { _setAutoActiveForTest } from '../auto.ts';
+
+function createFixture(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-guard-test-'));
+  const mDir = join(base, '.gsd', 'milestones', 'M001');
+  mkdirSync(mDir, { recursive: true });
+  writeFileSync(join(mDir, 'M001-ROADMAP.md'), '# M001\n', 'utf-8');
+  return base;
+}
+
+describe('auto-mode guards (milestone-actions)', () => {
+  afterEach(() => {
+    _setAutoActiveForTest(false);
+  });
+
+  test('parkMilestone throws when auto-mode is active', () => {
+    const base = createFixture();
+    try {
+      _setAutoActiveForTest(true);
+      assert.throws(
+        () => parkMilestone(base, 'M001', 'test'),
+        /auto-mode is active/,
+      );
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test('unparkMilestone throws when auto-mode is active', () => {
+    const base = createFixture();
+    try {
+      _setAutoActiveForTest(true);
+      assert.throws(
+        () => unparkMilestone(base, 'M001'),
+        /auto-mode is active/,
+      );
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test('discardMilestone throws when auto-mode is active', () => {
+    const base = createFixture();
+    try {
+      _setAutoActiveForTest(true);
+      assert.throws(
+        () => discardMilestone(base, 'M001'),
+        /auto-mode is active/,
+      );
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test('parkMilestone proceeds normally when auto-mode is inactive', () => {
+    const base = createFixture();
+    try {
+      _setAutoActiveForTest(false);
+      const result = parkMilestone(base, 'M001', 'baseline');
+      assert.ok(result, 'park succeeds when auto is inactive');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/auto-remediate-slice-status.test.ts

@@ -15,6 +15,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);
@@ -43,7 +44,9 @@ describe('auto-remediate stale slice status (#3673)', () => {
     assert.match(before, /try\s*\{/,
       'updateSliceStatus should be inside a try block');
 
-    const after = source.slice(updateIdx, updateIdx + 300);
+    // Bound the region to stop before the rogue fallback so /catch/ only
+    // matches this try block's catch, not an unrelated later one.
+    const after = extractSourceRegion(source, 'updateSliceStatus(mid, sid', 'rogues.push({');
     assert.match(after, /catch/,
       'try block should have a catch for fallback');
   });

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

@@ -16,6 +16,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
+import { extractSourceRegion } from "./test-helpers.ts";
 import {
   resetEvidence,
   getEvidence,
@@ -107,7 +108,9 @@ describe("register-hooks: skip prepareWorkflowMcpForProject inside auto-worktree
   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);
+    // Bound the extraction at the next pi.on(...) so adjacent handlers
+    // can't bleed into this handler's assertions.
+    const block = extractSourceRegion(src, 'pi.on("session_start"', 'pi.on("session_switch"');
     assert.ok(
       block.includes("isInAutoWorktree"),
       "session_start must consult isInAutoWorktree before preparing MCP",
@@ -121,7 +124,7 @@ describe("register-hooks: skip prepareWorkflowMcpForProject inside auto-worktree
   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);
+    const block = extractSourceRegion(src, 'pi.on("session_switch"', 'pi.on("tool_call"');
     assert.ok(
       block.includes("isInAutoWorktree"),
       "session_switch must consult isInAutoWorktree before preparing MCP",
@@ -192,7 +195,7 @@ describe("mcp-server workflow-tools: projectDir routing (Phase B root cause)", (
   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);
+    const block = extractSourceRegion(src, "const projectDirParam");
     assert.ok(
       block.includes(".optional()"),
       "projectDirParam must be optional so the agent stops deliberating",
@@ -206,7 +209,7 @@ describe("mcp-server workflow-tools: projectDir routing (Phase B root cause)", (
   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);
+    const block = extractSourceRegion(src, "function parseWorkflowArgs");
     assert.ok(
       block.includes("parsed.projectDir ?? process.cwd()"),
       "parseWorkflowArgs must fall back to process.cwd() when projectDir is omitted",
@@ -216,7 +219,7 @@ describe("mcp-server workflow-tools: projectDir routing (Phase B root cause)", (
   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);
+    const block = extractSourceRegion(src, "function validateProjectDir");
     assert.ok(
       block.includes("resolveExternalStateRoot"),
       "validateProjectDir must consult resolveExternalStateRoot for external-state layouts",
@@ -224,7 +227,7 @@ describe("mcp-server workflow-tools: projectDir routing (Phase B root cause)", (
 
     const helperIdx = src.indexOf("function resolveExternalStateRoot");
     assert.ok(helperIdx !== -1, "resolveExternalStateRoot helper must exist");
-    const helperBlock = src.slice(helperIdx, helperIdx + 600);
+    const helperBlock = extractSourceRegion(src, "function resolveExternalStateRoot");
     assert.ok(
       helperBlock.includes("realpathSync"),
       "resolveExternalStateRoot must use realpathSync to follow the symlink",
@@ -240,7 +243,7 @@ describe("mcp-server workflow-tools: projectDir routing (Phase B root cause)", (
     // 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);
+    const parseBlock = extractSourceRegion(src, "function parseWorkflowArgs");
     assert.ok(
       parseBlock.includes("resolveActiveWorktreeBasePath"),
       "parseWorkflowArgs must consult resolveActiveWorktreeBasePath",
@@ -254,7 +257,7 @@ describe("mcp-server workflow-tools: projectDir routing (Phase B root cause)", (
   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);
+    const block = extractSourceRegion(src, "function resolveActiveWorktreeBasePath");
     assert.ok(
       block.includes('existsSync(join(wtPath, ".git"))'),
       "resolveActiveWorktreeBasePath must verify a .git file exists in the worktree",
@@ -264,7 +267,7 @@ describe("mcp-server workflow-tools: projectDir routing (Phase B root cause)", (
   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);
+    const block = extractSourceRegion(src, "function extractMilestoneId");
     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");