gsd-pi 2.77.0-dev.c9c8932c6 → 2.77.0-dev.cfd69e714

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

@@ -21,10 +21,9 @@ import {
   realpathSync,
   readFileSync,
 } from "node:fs";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
 
 import {
   createAutoWorktree,
@@ -33,8 +32,6 @@ import {
   mergeMilestoneToMain,
 } from "../../auto-worktree.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
 function run(command: string, cwd: string): string {
   return execSync(command, {
     cwd,
@@ -75,58 +72,12 @@ function createMilestoneArtifacts(dir: string, mid: string): void {
   writeFileSync(join(msDir, `${mid}-ROADMAP.md`), roadmap);
 }
 
-// ─── Source-level: verify the merge code exists in the "all complete" path ────
-
-test("auto-loop 'all milestones complete' path merges before stopping (#962)", () => {
-  const loopSrc = readFileSync(join(__dirname, "../..", "auto", "phases.ts"), "utf-8");
-  const resolverSrc = readFileSync(
-    join(__dirname, "../..", "worktree-resolver.ts"),
-    "utf-8",
-  );
-
-  // Find the "incomplete.length === 0" block
-  const incompleteIdx = loopSrc.indexOf("incomplete.length === 0");
-  assert.ok(
-    incompleteIdx > -1,
-    "auto/phases.ts should have 'incomplete.length === 0' check",
-  );
-
-  // The merge call must appear BETWEEN the incomplete check and the stopAuto call.
-  const blockAfterIncomplete = loopSrc.slice(
-    incompleteIdx,
-    incompleteIdx + 3000,
-  );
-
-  assert.ok(
-    blockAfterIncomplete.includes("deps.resolver.mergeAndExit"),
-    "auto/phases.ts should call resolver.mergeAndExit in the 'all milestones complete' path",
-  );
-
-  // The merge should come before stopAuto in this block
-  const mergePos = blockAfterIncomplete.indexOf("deps.resolver.mergeAndExit");
-  const stopPos = blockAfterIncomplete.indexOf("stopAuto");
-  assert.ok(
-    mergePos < stopPos,
-    "resolver.mergeAndExit should be called before stopAuto in the 'all complete' path",
-  );
-
-  const helperIdx = resolverSrc.indexOf("mergeAndExit(milestoneId");
-  assert.ok(
-    helperIdx > -1,
-    "WorktreeResolver.mergeAndExit helper should exist",
-  );
-  const helperBlock = resolverSrc.slice(helperIdx, helperIdx + 2600);
-  assert.ok(
-    helperBlock.includes('mode === "worktree"') ||
-      helperBlock.includes('mode: "worktree"'),
-    "WorktreeResolver.mergeAndExit should handle worktree mode",
-  );
-  assert.ok(
-    helperBlock.includes('mode === "branch"') ||
-      helperBlock.includes('mode: "branch"'),
-    "WorktreeResolver.mergeAndExit should handle branch mode",
-  );
-});
+// Note: the prior phases.ts / worktree-resolver.ts source-grep block was
+// removed under #4825 — it asserted `deps.resolver.mergeAndExit` appears
+// before `stopAuto` via indexOf positions in the source text, which broke
+// on any helper refactor without catching a real regression. The two
+// integration tests below exercise the merge-before-stop behaviour end
+// to end through real git worktrees.
 
 // ─── Integration: single milestone completes → merged to main ────────────────
 

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

@@ -717,6 +717,26 @@ test("hasImplementationArtifacts returns 'present' when implementation files com
   assert.equal(result, "present", "should return 'present' when implementation files are present");
 });
 
+test("hasImplementationArtifacts finds production execute-task commits after retry resumes on main (#4699)", (t) => {
+  const base = makeGitBase();
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap");
+  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "chore: auto-commit after plan-milestone\n\nGSD-Unit: M001"], { cwd: base, stdio: "ignore" });
+
+  mkdirSync(join(base, "src"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"), "# Summary");
+  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "feat: add milestone feature\n\nGSD-Task: S01/T01"], { cwd: base, stdio: "ignore" });
+
+  const result = hasImplementationArtifacts(base, "M001");
+  assert.equal(result, "present", "main self-diff retry should find production execute-task commits");
+});
+
 test("hasImplementationArtifacts returns 'unknown' on non-git directory (fail-open)", (t) => {
   const base = join(tmpdir(), `gsd-test-nogit-${randomUUID()}`);
   mkdirSync(base, { recursive: true });

package/src/resources/extensions/gsd/tests/integration/auto-worktree-milestone-merge.test.ts

@@ -854,4 +854,34 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
       "#1906: codeFilesChanged must be true when real code files were merged");
     assert.ok(existsSync(join(repo, "real-code.ts")), "real-code.ts merged to main");
   });
+
+  // #2505 regression: when a per-entry restore of the milestone shelter fails,
+  // the shelter must be retained so the queued milestone files (whose sources
+  // were deleted during the shelter step) remain recoverable. Deleting the
+  // shelter unconditionally would permanently lose that data.
+  test("#2505: shelter retained when restore fails; cleaned up on success", () => {
+    const repo = freshRepo();
+    const wtPath = createAutoWorktree(repo, "M200");
+
+    addSliceToMilestone(repo, wtPath, "M200", "S01", "Feature", [
+      { file: "feature.ts", content: "export const f = 1;\n", message: "add feature" },
+    ]);
+
+    // Seed a queued (non-target) milestone in .gsd/milestones/ that will be
+    // sheltered during the merge and restored afterwards.
+    const queuedDir = join(repo, ".gsd", "milestones", "M201");
+    mkdirSync(queuedDir, { recursive: true });
+    writeFileSync(join(queuedDir, "CONTEXT.md"), "# queued\n");
+
+    const roadmap = makeRoadmap("M200", "Milestone w/ queued sibling", [
+      { id: "S01", title: "Feature" },
+    ]);
+
+    const result = mergeMilestoneToMain(repo, "M200", roadmap);
+
+    // Normal success path: queued milestone restored, shelter cleaned up.
+    assert.ok(existsSync(join(queuedDir, "CONTEXT.md")), "queued milestone restored from shelter");
+    assert.ok(!existsSync(join(repo, ".gsd", ".milestone-shelter")), "shelter removed on successful restore");
+    assert.ok(result.commitMessage.length > 0, "merge completed");
+  });
 });

package/src/resources/extensions/gsd/tests/integration/doctor-proactive.test.ts

@@ -161,11 +161,27 @@ describe('doctor-proactive', async () => {
     });
 
     test('escalation: no double escalation', () => {
-      // Don't reset — should already be escalated from previous test
+      // Self-contained: drive the escalated state from scratch in this test.
+      // Previously this relied on module-singleton state left over from the
+      // preceding 'escalation: at threshold' test, which silently broke under
+      // filtered/parallel/reordered runs (the fallback `shouldEscalate: false`
+      // path was satisfied by the wrong reason — see #4828).
+      resetProactiveHealing();
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(0, 0, 0); // older clean snapshots
+      }
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(2, 1, 0); // recent error snapshots → degrading trend
+      }
+      // First check: trigger escalation.
+      const first = checkHealEscalation(2, [{ code: "test", message: "test error", unitId: "M001/S01" }]);
+      assert.deepStrictEqual(first.shouldEscalate, true, "precondition: first call escalates");
+
+      // Second check: same session, must NOT double-escalate.
       recordHealthSnapshot(2, 0, 0);
       const result = checkHealEscalation(2, [{ code: "test", message: "test error", unitId: "M001/S01" }]);
       assert.deepStrictEqual(result.shouldEscalate, false, "no double escalation in same session");
-      assert.ok(result.reason.includes("already escalated"), "reason explains why no escalation");
+      assert.ok(result.reason.includes("already escalated"), `reason must explain no-re-escalation (got: ${result.reason})`);
     });
 
     test('escalation: deferred when improving', () => {

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -248,12 +248,13 @@ describe('git-service', async () => {
 
   assert.deepStrictEqual(
     RUNTIME_EXCLUSION_PATHS.length,
-    15,
-    "exactly 15 runtime exclusion paths"
+    16,
+    "exactly 16 runtime exclusion paths"
   );
 
   const expectedPaths = [
     ".gsd/activity/",
+    ".gsd/audit/",
     ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",

package/src/resources/extensions/gsd/tests/integration/queue-completed-milestone-perf.test.ts

@@ -140,12 +140,18 @@ for (let i = 1; i <= COMPLETED_COUNT; i++) {
 
 // ─── Test: the overall context should be reasonable in size ──────────────
 
-// With 25 completed milestones NOT loading files, the context should be
-// significantly smaller than if all files were loaded
+// Invariant (not absolute budget): the per-completed-milestone line
+// contribution should stay small and CONSTANT (not proportional to the
+// size of its CONTEXT.md / SUMMARY.md). With 50 lines of fixture text
+// per completed CONTEXT.md, a naive loader would produce >=50 lines per
+// completed milestone (>1250 lines for 25 milestones). The fix emits a
+// short summary section plus separator per completed milestone, which
+// stays well under 10 lines/milestone regardless of CONTEXT.md size.
 const contextLines = context.split("\n").length;
+const avgLinesPerCompletedMilestone = contextLines / COMPLETED_COUNT;
 assertTrue(
-  contextLines < 200,
-  `Context should be concise (got ${contextLines} lines); completed milestones should not inflate it`,
+  avgLinesPerCompletedMilestone < 10,
+  `Completed milestones should not inflate the context: got ${contextLines} lines across ${COMPLETED_COUNT} completed milestones (~${avgLinesPerCompletedMilestone.toFixed(1)}/milestone)`,
 );
 
 // ─── Cleanup ──────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/integration/state-machine-edge-cases.test.ts

@@ -277,6 +277,14 @@ function buildDispatchCtx(
   };
 }
 
+function getUatVerdictGate(): import("../../auto-dispatch.ts").DispatchRule {
+  const rule = DISPATCH_RULES.find(
+    r => r.name === "uat-verdict-gate (non-PASS blocks progression)",
+  );
+  assert.ok(rule, "uat-verdict-gate rule should be registered");
+  return rule;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Test Suite
 // ═══════════════════════════════════════════════════════════════════════════
@@ -355,10 +363,13 @@ describe("state derivation failures", () => {
     const state2 = await deriveState(base);
     assert.equal(state2.phase, "executing", "cached result should still show executing");
 
-    // After explicit invalidation, should reflect the DB mutation
+    // After explicit invalidation, should reflect the DB mutation and reconcile
+    // missing plan tasks instead of prematurely summarizing a partial DB row set.
     invalidateStateCache();
     const state3 = await deriveState(base);
-    assert.equal(state3.phase, "summarizing", "after cache invalidation should show summarizing");
+    assert.equal(state3.phase, "executing", "after cache invalidation should continue with the missing plan task");
+    assert.equal(state3.activeTask?.id, "T02", "missing plan task T02 should be imported and selected");
+    assert.deepEqual(state3.progress?.tasks, { done: 1, total: 2 });
   });
 
   test("corrupt ROADMAP: binary content does not crash deriveState", async () => {
@@ -691,7 +702,7 @@ describe("transition boundary failures", () => {
     );
   });
 
-  test("blocked state: all slices have unmet deps → fallback picks slice", async () => {
+  test("blocked state: all slices have unmet deps → blocks", async () => {
     base = makeTempDir();
     const mDir = join(base, ".gsd", "milestones", "M001");
     mkdirSync(join(mDir, "slices", "S01", "tasks"), { recursive: true });
@@ -736,9 +747,9 @@ describe("transition boundary failures", () => {
 
     invalidateAllCaches();
     const state = await deriveStateFromDb(base);
-    // With partial-dep fallback, circular deps no longer block — fallback picks first eligible slice
-    assert.equal(state.phase, "planning", "circular deps: fallback picks a slice instead of blocking");
-    assert.ok(state.activeSlice !== null, "activeSlice set via fallback");
+    assert.equal(state.phase, "blocked", "circular deps: no slice should be selected through unmet deps");
+    assert.equal(state.activeSlice, null, "activeSlice should remain null when all deps are blocked");
+    assert.ok(state.blockers.some(b => b.includes("No slice eligible")));
   });
 });
 
@@ -868,6 +879,132 @@ describe("dispatch failure modes", () => {
     // run-uat should come before uat-verdict-gate
     assert.ok(runUatIdx < uatGateIdx, "run-uat should precede uat-verdict-gate");
   });
+
+  test("UAT verdict gate: ASSESSMENT FAIL blocks closed slice progression", async () => {
+    base = createFullFixture();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Active", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First", status: "complete" });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Second", status: "pending" });
+
+    const s01Dir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    writeFileSync(
+      join(s01Dir, "S01-UAT.md"),
+      "# UAT File\n\n## UAT Type\n\n- UAT mode: artifact-driven\n",
+    );
+    writeFileSync(
+      join(s01Dir, "S01-ASSESSMENT.md"),
+      "---\nverdict: FAIL\n---\n# UAT Assessment\n",
+    );
+
+    const ctx = buildDispatchCtx(base, "M001", {
+      phase: "planning",
+      activeSlice: { id: "S02", title: "Second" },
+      activeTask: null,
+    });
+    ctx.prefs = { uat_dispatch: true } as any;
+
+    const result = await getUatVerdictGate().match(ctx);
+    assert.equal(result?.action, "stop", "ASSESSMENT FAIL should block progression");
+    assert.ok(
+      (result as any).reason?.includes('UAT verdict for S01 is "fail"'),
+      "stop reason should report normalized ASSESSMENT verdict",
+    );
+  });
+
+  test("UAT verdict gate: ROADMAP fallback gates done slices when DB is unavailable", async () => {
+    base = createFullFixture();
+    const mDir = join(base, ".gsd", "milestones", "M001");
+    writeFileSync(
+      join(mDir, "M001-ROADMAP.md"),
+      [
+        "# M001: Edge Case Milestone",
+        "",
+        "## Vision",
+        "Prove edge case correctness.",
+        "",
+        "## Success Criteria",
+        "- All edge cases handled",
+        "",
+        "## Slices",
+        "",
+        "- [x] **S01: First Feature** `risk:low` `depends:[]`",
+        "  - After this: First feature proven.",
+        "",
+        "- [ ] **S02: Second Feature** `risk:low` `depends:[]`",
+        "  - After this: Second feature proven.",
+        "",
+        "## Boundary Map",
+        "",
+        "| From | To | Produces | Consumes |",
+        "|------|----|----------|----------|",
+        "| S01 | terminal | feature-a | nothing |",
+        "| S02 | terminal | feature-b | nothing |",
+      ].join("\n"),
+    );
+
+    const s01Dir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    writeFileSync(
+      join(s01Dir, "S01-UAT.md"),
+      "# UAT File\n\n## UAT Type\n\n- UAT mode: artifact-driven\n",
+    );
+    writeFileSync(
+      join(s01Dir, "S01-ASSESSMENT.md"),
+      "---\nverdict: needs-remediation\n---\n# UAT Assessment\n",
+    );
+
+    const ctx = buildDispatchCtx(base, "M001", {
+      phase: "planning",
+      activeSlice: { id: "S02", title: "Second" },
+      activeTask: null,
+    });
+    ctx.prefs = { uat_dispatch: true } as any;
+
+    const result = await getUatVerdictGate().match(ctx);
+    assert.equal(result?.action, "stop", "ROADMAP done slices should be gated without DB");
+    assert.ok(
+      (result as any).reason?.includes('UAT verdict for S01 is "needs-remediation"'),
+      "stop reason should report normalized ASSESSMENT verdict from disk fallback",
+    );
+  });
+
+  for (const status of ["done", "skipped"]) {
+    test(`UAT verdict gate: legacy closed status "${status}" is gated`, async () => {
+      base = createFullFixture();
+      openDatabase(join(base, ".gsd", "gsd.db"));
+      insertMilestone({ id: "M001", title: "Active", status: "active" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "First", status });
+      insertSlice({ id: "S02", milestoneId: "M001", title: "Second", status: "pending" });
+
+      const s01Dir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+      writeFileSync(
+        join(s01Dir, "S01-UAT.md"),
+        "# UAT File\n\n## UAT Type\n\n- UAT mode: artifact-driven\n",
+      );
+      writeFileSync(
+        join(s01Dir, "S01-ASSESSMENT.md"),
+        "---\nverdict: needs-remediation\n---\n# UAT Assessment\n",
+      );
+
+      const ctx = buildDispatchCtx(base, "M001", {
+        phase: "planning",
+        activeSlice: { id: "S02", title: "Second" },
+        activeTask: null,
+      });
+      ctx.prefs = { uat_dispatch: true } as any;
+
+      const result = await getUatVerdictGate().match(ctx);
+      assert.equal(
+        result?.action,
+        "stop",
+        `${status} slices should be treated as closed for UAT verdict gating`,
+      );
+      assert.ok(
+        (result as any).reason?.includes('UAT verdict for S01 is "needs-remediation"'),
+        "stop reason should report normalized ASSESSMENT verdict",
+      );
+    });
+  }
 });
 
 // ─────────────────────────────────────────────────────────────────────────
@@ -1155,7 +1292,7 @@ describe("dispatch guard integration", () => {
     assert.ok(existsSync(validationPath), "VALIDATION file should be written");
     const content = readFileSync(validationPath, "utf-8");
     assert.ok(content.includes("verdict: pass"), "should contain pass verdict");
-    assert.ok(content.includes("skipped by preference"), "should note it was skipped");
+    assert.ok(content.includes("`skip_milestone_validation` preference"), "should note it was skipped via the preference path (#4781)");
   });
 
   test("rewrite-docs circuit breaker: exceeding MAX attempts resolves all overrides", async () => {

package/src/resources/extensions/gsd/tests/integration/state-machine-live-validation.test.ts

@@ -936,9 +936,11 @@ describe("state-machine-live-validation", () => {
       insertMilestone({ id: "M001", title: "Active", status: "active" });
       insertSlice({ id: "S01", milestoneId: "M001", title: "First", status: "in_progress" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "pending" });
+      insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", status: "pending" });
 
       // Complete task + slice
       await handleCompleteTask(makeTaskParams("T01", "S01", "M001") as any, base);
+      await handleCompleteTask(makeTaskParams("T02", "S01", "M001") as any, base);
       await handleCompleteSlice(makeSliceParams("S01", "M001") as any, base);
       assert.ok(isClosedStatus(getSlice("M001", "S01")!.status));
 
@@ -946,9 +948,11 @@ describe("state-machine-live-validation", () => {
       await handleReopenSlice({ milestoneId: "M001", sliceId: "S01" }, base);
       assert.equal(getSlice("M001", "S01")!.status, "in_progress");
       assert.equal(getTask("M001", "S01", "T01")!.status, "pending");
+      assert.equal(getTask("M001", "S01", "T02")!.status, "pending");
 
       // Re-complete task + slice succeeds
       await handleCompleteTask(makeTaskParams("T01", "S01", "M001") as any, base);
+      await handleCompleteTask(makeTaskParams("T02", "S01", "M001") as any, base);
       const r = await handleCompleteSlice(makeSliceParams("S01", "M001") as any, base);
       assert.ok(!("error" in r), `re-complete slice: ${JSON.stringify(r)}`);
       assert.ok(isClosedStatus(getSlice("M001", "S01")!.status));

package/src/resources/extensions/gsd/tests/integration/state-machine-runtime-failures.test.ts

@@ -48,9 +48,7 @@ import type { WindowEntry } from "../../auto/types.ts";
 import {
   AutoSession,
   NEW_SESSION_TIMEOUT_MS,
-  MAX_UNIT_DISPATCHES,
   STUB_RECOVERY_THRESHOLD,
-  MAX_LIFETIME_DISPATCHES,
 } from "../../auto/session.ts";
 
 // ── Auto-loop types ──────────────────────────────────────────────────────
@@ -364,14 +362,6 @@ describe("session management", () => {
     assert.equal(NEW_SESSION_TIMEOUT_MS, 120_000, "session timeout should be 120s");
   });
 
-  test("MAX_UNIT_DISPATCHES limits retries for a single unit", () => {
-    assert.equal(MAX_UNIT_DISPATCHES, 3, "max unit dispatches should be 3");
-  });
-
-  test("MAX_LIFETIME_DISPATCHES is the absolute limit per unit", () => {
-    assert.equal(MAX_LIFETIME_DISPATCHES, 6, "max lifetime dispatches should be 6");
-  });
-
   test("STUB_RECOVERY_THRESHOLD triggers recovery after N stub completions", () => {
     assert.equal(STUB_RECOVERY_THRESHOLD, 2, "stub recovery threshold should be 2");
   });
@@ -392,12 +382,8 @@ describe("session management", () => {
     s.unitDispatchCount.set(unitId, 2);
     assert.equal(s.unitDispatchCount.get(unitId), 2);
 
-    // Exceeding MAX_UNIT_DISPATCHES
-    s.unitDispatchCount.set(unitId, MAX_UNIT_DISPATCHES + 1);
-    assert.ok(
-      s.unitDispatchCount.get(unitId)! > MAX_UNIT_DISPATCHES,
-      "should track count beyond max for detection",
-    );
+    s.unitDispatchCount.set(unitId, 4);
+    assert.equal(s.unitDispatchCount.get(unitId), 4);
   });
 
   test("AutoSession toJSON() provides diagnostic snapshot", () => {

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

package/src/resources/extensions/gsd/tests/interrupted-session-ui.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -126,11 +126,8 @@ test("guided-flow stale paused-session scenario is suppressed when no resumable
   }
 });
 
-test("guided-flow source uses step-aware resume and clears stale paused metadata without changing discuss handoff semantics", () => {
-  const source = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8");
-  assert.ok(source.includes('const interrupted = await assessInterruptedSession(basePath);'));
-  assert.ok(source.includes('resumeLabel = interrupted.pausedSession?.stepMode'));
-  assert.ok(source.includes('step: interrupted.pausedSession?.stepMode ?? false'));
-  assert.ok(source.includes('unlinkSync(join(gsdRoot(basePath), "runtime", "paused-session.json"))'));
-  assert.ok(source.includes('pendingAutoStartMap.set(basePath,'));
-});
+// Note: the prior source-grep test that scanned guided-flow.ts for five
+// string literals was removed under #4827. The invariants it encoded
+// (step-aware resume + stale paused-session cleanup + pendingAutoStartMap
+// side effect) should be covered by a runtime drive of guided-flow —
+// tracked as a follow-up.

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -21,6 +21,13 @@ import type { IterationContext, LoopState, PreDispatchData, IterationData } from
 import type { SessionLockStatus } from "../session-lock.js";
 import { runDispatch, runUnitPhase, runPreDispatch, runFinalize } from "../auto/phases.js";
 import { readUnitRuntimeRecord } from "../unit-runtime.js";
+import {
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -644,6 +651,63 @@ test("terminal event is emitted on blocked state", async () => {
   assert.deepEqual((terminalEvents[0].data as any).blockers, ["Missing API key"]);
 });
 
+test("#4671: plan-v2 missing CONTEXT.md reaches dispatch recovery instead of pausing", async () => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-4671-predispatch-"));
+  mkdirSync(join(basePath, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  openDatabase(join(basePath, ".gsd", "gsd.db"));
+  try {
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice 1",
+      status: "in_progress",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      milestoneId: "M001",
+      sliceId: "S01",
+      title: "Task 1",
+      status: "pending",
+      keyFiles: ["src/task.ts"],
+      sequence: 1,
+    });
+
+    let pauseCalls = 0;
+    const capture = createEventCapture();
+    const deps = makeMockDeps(capture, {
+      pauseAuto: async () => { pauseCalls++; },
+      deriveState: async () => ({
+        phase: "executing",
+        activeMilestone: { id: "M001", title: "Test", status: "active" },
+        activeSlice: { id: "S01", title: "Slice 1" },
+        activeTask: { id: "T01", title: "Task 1" },
+        registry: [{ id: "M001", status: "active" }],
+        blockers: [],
+        recentDecisions: [],
+        nextAction: "dispatch",
+      }) as any,
+    });
+    const ic = makeIC(deps, {
+      prefs: { uok: { plan_v2: { enabled: true } } } as any,
+    });
+    ic.s.basePath = basePath;
+
+    const result = await runPreDispatch(ic, {
+      recentUnits: [],
+      stuckRecoveryAttempts: 0,
+      consecutiveFinalizeTimeouts: 0,
+    });
+
+    assert.equal(result.action, "next");
+    assert.equal(pauseCalls, 0, "missing CONTEXT.md should be handled by dispatch recovery, not plan gate pause");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
 test("milestone-transition event is emitted when milestone changes", async () => {
   const capture = createEventCapture();
   const deps = makeMockDeps(capture, {