gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0-dev.aeeb2ca00

package/src/resources/extensions/gsd/tests/auto-thinking-restore.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";
 
 const autoSrc = readFileSync(join(import.meta.dirname, "..", "auto.ts"), "utf-8");
 const phasesSrc = readFileSync(join(import.meta.dirname, "..", "auto", "phases.ts"), "utf-8");
@@ -20,7 +21,7 @@ test("stopAuto restores original thinking level", () => {
 test("runUnitPhase threads captured thinking level into selectAndApplyModel", () => {
   const callIdx = phasesSrc.indexOf("deps.selectAndApplyModel(");
   assert.ok(callIdx > -1, "phases.ts should call selectAndApplyModel");
-  const callBlock = phasesSrc.slice(callIdx, callIdx + 600);
+  const callBlock = extractSourceRegion(phasesSrc, "deps.selectAndApplyModel(");
   assert.ok(
     callBlock.includes("s.autoModeStartThinkingLevel"),
     "runUnitPhase should pass autoModeStartThinkingLevel to selectAndApplyModel",
@@ -30,7 +31,7 @@ test("runUnitPhase threads captured thinking level into selectAndApplyModel", ()
 test("hook model override preserves captured thinking level", () => {
   const hookIdx = phasesSrc.indexOf("const hookModelOverride = sidecarItem?.model ?? iterData.hookModelOverride;");
   assert.ok(hookIdx > -1, "phases.ts should include hook model override handling");
-  const hookBlock = phasesSrc.slice(hookIdx, hookIdx + 600);
+  const hookBlock = extractSourceRegion(phasesSrc, "const hookModelOverride = sidecarItem?.model ?? iterData.hookModelOverride;");
   assert.ok(
     hookBlock.includes("pi.setThinkingLevel(s.autoModeStartThinkingLevel)"),
     "hook model override should re-apply captured thinking level after setModel",

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/cache-staleness-regression.test.ts

@@ -69,11 +69,11 @@ describe("cache-staleness-regression", () => {
       ].join('\n');
       writeMilestoneFile(base, 'M001', 'ROADMAP', roadmap);
 
-      // Step 3: WITHOUT invalidation, the old state might be cached
-      // The state cache has a 100ms TTL, so wait just past it
-      await new Promise(r => setTimeout(r, 150));
-
-      // Step 4: Invalidate and re-derive — should see the new roadmap
+      // Step 3: Explicit invalidation — this is the #1240 fix path. We
+      // do NOT rely on the 100ms TTL here; the production code calls
+      // invalidateAllCaches() / invalidateStateCache() immediately after
+      // writing planning files, so the next deriveState() must see the
+      // new roadmap without any wall-clock wait.
       invalidateAllCaches();
       invalidateStateCache();
       const state2 = await deriveState(base);
@@ -100,10 +100,8 @@ describe("cache-staleness-regression", () => {
       // Simulate: discussion completes, CONTEXT.md is written
       writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001: Test\n\nFull context after discussion.\n');
 
-      // Wait past TTL
-      await new Promise(r => setTimeout(r, 150));
-
-      // Without invalidation, we'd still see 'needs-discussion'
+      // Explicit invalidation is the production fix path for #1249 —
+      // no wall-clock wait needed.
       invalidateAllCaches();
       invalidateStateCache();
       const state2 = await deriveState(base);
@@ -116,7 +114,7 @@ describe("cache-staleness-regression", () => {
     }
   });
 
-  test("state cache TTL: fresh reads after 100ms", async () => {
+  test("state cache TTL: within window returns cached; past window re-derives", async () => {
     const base = createBase();
     try {
       writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001\n\nDesc.\n');
@@ -126,7 +124,7 @@ describe("cache-staleness-regression", () => {
       const state1 = await deriveState(base);
       assert.strictEqual(state1.phase, 'pre-planning', 'initial: pre-planning');
 
-      // Write roadmap immediately
+      // Write roadmap immediately — no invalidation
       writeMilestoneFile(base, 'M001', 'ROADMAP', [
         '# M001: Test',
         '',
@@ -136,18 +134,19 @@ describe("cache-staleness-regression", () => {
         '',
       ].join('\n'));
 
-      // Immediately after writing (within 100ms TTL), the cache might be stale
+      // Within the TTL window, deriveState() must return the cached
+      // pre-planning state — this is the "cached" half of the TTL
+      // contract and the reason invalidateStateCache() exists.
       const state2 = await deriveState(base);
-      // This MAY still show pre-planning if within TTL — that's expected behavior
+      assert.strictEqual(state2.phase, 'pre-planning', 'within TTL: cached pre-planning is returned');
 
-      // Wait past TTL
+      // Past the TTL + explicit parse-cache flush, the fresh derive must
+      // see the new roadmap. invalidateAllCaches() is required because
+      // the file-parse cache is independent of the state TTL.
       await new Promise(r => setTimeout(r, 150));
-
-      // ALSO invalidate parse cache (not just state cache)
       invalidateAllCaches();
-      invalidateStateCache();
       const state3 = await deriveState(base);
-      assert.strictEqual(state3.phase, 'planning', 'after TTL expiry + invalidation → planning');
+      assert.strictEqual(state3.phase, 'planning', 'past TTL: re-derive sees new roadmap');
     } finally {
       cleanup(base);
     }
@@ -194,7 +193,6 @@ describe("cache-staleness-regression", () => {
         '- [ ] **T02: Second Task** `est:1h`',
       ].join('\n'));
 
-      await new Promise(r => setTimeout(r, 150));
       invalidateAllCaches();
       invalidateStateCache();
       const state2 = await deriveState(base);
@@ -242,7 +240,6 @@ describe("cache-staleness-regression", () => {
         '- [x] **T01: Task** `est:1h`',
       ].join('\n'));
 
-      await new Promise(r => setTimeout(r, 150));
       invalidateAllCaches();
       invalidateStateCache();
       const state2 = await deriveState(base);
@@ -282,7 +279,6 @@ describe("cache-staleness-regression", () => {
         '',
       ].join('\n'));
 
-      await new Promise(r => setTimeout(r, 150));
       invalidateAllCaches();
       invalidateStateCache();
       const state2 = await deriveState(base);

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-milestone-excerpt.test.ts

@@ -0,0 +1,263 @@
+// GSD-2 — #4780: slice-summary excerpts replace full inlining in
+// buildCompleteMilestonePrompt. Verify (a) the excerpt helper emits
+// frontmatter fields + section heads + on-demand path, (b) the closer
+// prompt lists all slice SUMMARY paths under "On-demand Slice Summaries",
+// (c) regression on prompt size.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildSliceSummaryExcerpt, buildCompleteMilestonePrompt } from "../auto-prompts.ts";
+import { invalidateAllCaches } from "../cache.ts";
+
+// ─── Fixture helpers ──────────────────────────────────────────────────────
+
+function createBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-cm-excerpt-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "tasks"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+function writeRoadmap(base: string, content: string): void {
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), content);
+}
+
+function writeSummary(base: string, sid: string, content: string): void {
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", sid, `${sid}-SUMMARY.md`),
+    content,
+  );
+}
+
+// A summary with enough body narrative that full inlining would balloon the
+// prompt. The excerpt should keep frontmatter + sections but drop the
+// "What Happened" narrative.
+function makeFatSummary(sid: string): string {
+  const narrativePara =
+    "The team discovered several subtle integration issues, traced them to the cache layer, and produced a patch set that threads the cache key through every call site. ".repeat(20);
+  return [
+    "---",
+    `id: ${sid}`,
+    "parent: M001",
+    "milestone: M001",
+    "provides:",
+    "  - compact slice-summary excerpts",
+    "  - on-demand read path registry",
+    "affects:",
+    "  - complete-milestone prompt builder",
+    "key_decisions:",
+    "  - use parseSummary for frontmatter extraction",
+    "  - fall back to full inline when frontmatter fails",
+    "patterns_established:",
+    "  - excerpt-first inlining for closer units",
+    "key_files:",
+    "  - src/resources/extensions/gsd/auto-prompts.ts",
+    "duration: 1h",
+    "verification_result: passed",
+    "completed_at: 2026-04-24",
+    "blocker_discovered: false",
+    "---",
+    "",
+    `# ${sid}: Slice summary`,
+    "**Short one-liner for the slice**",
+    "",
+    "## What Happened",
+    "",
+    narrativePara,
+    "",
+    "## Deviations",
+    "",
+    "Extended the excerpt helper scope at review time.",
+    "",
+    "## Known Limitations",
+    "",
+    "Does not yet cover validate-milestone — follow-up.",
+    "",
+    "## Follow-ups",
+    "",
+    "- Wire the same excerpt into buildValidateMilestonePrompt",
+  ].join("\n");
+}
+
+function makeRoadmap(): string {
+  return [
+    "# M001 Roadmap",
+    "## Slices",
+    "- [x] **S01: Excerpt helper** `risk:medium` `depends:[]`",
+    "- [x] **S02: Closer wiring** `risk:low` `depends:[S01]`",
+  ].join("\n");
+}
+
+// ─── buildSliceSummaryExcerpt unit tests ──────────────────────────────────
+
+test("#4780 excerpt: emits compact block with frontmatter fields + section heads", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  const absPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+  const relPath = ".gsd/milestones/M001/slices/S01/S01-SUMMARY.md";
+  writeSummary(base, "S01", makeFatSummary("S01"));
+
+  const out = await buildSliceSummaryExcerpt(absPath, relPath, "S01");
+
+  // Compact header with source path for on-demand Read
+  assert.match(out, /### S01 Summary \(excerpt\)/);
+  assert.match(out, /Source: `\.gsd\/milestones\/M001\/slices\/S01\/S01-SUMMARY\.md`/);
+
+  // Frontmatter fields surfaced
+  assert.match(out, /\*\*Title:\*\* S01: Slice summary/);
+  assert.match(out, /\*\*One-liner:\*\*/);
+  assert.match(out, /\*\*Verification:\*\* `passed`/);
+  assert.match(out, /\*\*Blockers:\*\* none/);
+  assert.match(out, /\*\*Provides:\*\* compact slice-summary excerpts;/);
+  assert.match(out, /\*\*Key decisions:\*\* use parseSummary/);
+  assert.match(out, /\*\*Patterns established:\*\* excerpt-first inlining/);
+
+  // Section heads included (body-section markdown), not whole sections inlined
+  assert.match(out, /#### Deviations/);
+  assert.match(out, /#### Known limitations/);
+  assert.match(out, /#### Follow-ups/);
+
+  // On-demand instruction present
+  assert.match(out, /On-demand.*read.*for the full "What Happened"/);
+
+  // Bulk narrative is NOT inlined — excerpt is meaningfully shorter than full
+  // A 20x-repeated paragraph produces ~2.5KB; excerpt should come in well under.
+  const fullSize = makeFatSummary("S01").length;
+  assert.ok(
+    out.length < fullSize * 0.6,
+    `excerpt length ${out.length} should be < 60% of full summary length ${fullSize}`,
+  );
+});
+
+test("#4780 excerpt: blocker_discovered=true surfaces prominent marker", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  const content = [
+    "---",
+    "id: S01",
+    "parent: M001",
+    "milestone: M001",
+    "blocker_discovered: true",
+    "---",
+    "# S01",
+    "**One-liner**",
+    "",
+    "## What Happened",
+    "content",
+  ].join("\n");
+  const absPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+  writeSummary(base, "S01", content);
+
+  const out = await buildSliceSummaryExcerpt(absPath, "rel", "S01");
+  assert.match(out, /Blockers:\*\* ⚠️ blocker recorded/);
+});
+
+test("#4780 excerpt: fall back to full inline when frontmatter is unrecognizable", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  // No frontmatter, no id — parser returns empty id, triggering fallback
+  const garbage = "# S99\n\nJust a wall of text with no frontmatter at all.\n";
+  const absPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S99-SUMMARY.md");
+  writeFileSync(absPath, garbage);
+
+  const out = await buildSliceSummaryExcerpt(absPath, "rel/path.md", "S99");
+  // Full content preserved (no excerpt wrapper), no data-loss
+  assert.match(out, /Just a wall of text/);
+  assert.match(out, /### S99 Summary/);
+});
+
+test("#4780 excerpt: missing file reports not-found fallback", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+
+  const out = await buildSliceSummaryExcerpt(null, "rel/missing.md", "S42");
+  assert.match(out, /### S42 Summary \(excerpt\)/);
+  assert.match(out, /not found — file does not exist yet/);
+});
+
+test("#4780 excerpt: section bodies are capped (coderabbit review)", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  // Long Follow-ups section (~4.8KB) would balloon the excerpt without
+  // the cap — regression coverage for the coderabbit finding on #4908.
+  const longFollowUps = "A verbose follow-up bullet that keeps restating the same point. ".repeat(60);
+  const content = [
+    "---",
+    "id: S01",
+    "parent: M001",
+    "milestone: M001",
+    "---",
+    "# S01: Test",
+    "**One-liner**",
+    "",
+    "## Follow-ups",
+    longFollowUps,
+  ].join("\n");
+  const absPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+  writeSummary(base, "S01", content);
+
+  const out = await buildSliceSummaryExcerpt(absPath, "rel/path.md", "S01");
+
+  assert.match(out, /\(truncated — see full `rel\/path\.md`\)/);
+  assert.ok(
+    out.length < 2000,
+    `excerpt length ${out.length} should be well under 2KB when one section hits the cap`,
+  );
+});
+
+// ─── buildCompleteMilestonePrompt integration test ─────────────────────────
+
+test("#4780 closer prompt: uses excerpts + lists on-demand slice SUMMARY paths", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  writeRoadmap(base, makeRoadmap());
+  writeSummary(base, "S01", makeFatSummary("S01"));
+  writeSummary(base, "S02", makeFatSummary("S02"));
+
+  const prompt = await buildCompleteMilestonePrompt("M001", "Test Milestone", base);
+
+  // Excerpt markers present for each slice
+  assert.match(prompt, /### S01 Summary \(excerpt\)/);
+  assert.match(prompt, /### S02 Summary \(excerpt\)/);
+
+  // On-demand path section exists with both slice paths
+  assert.match(prompt, /### On-demand Slice Summaries/);
+  assert.match(prompt, /S01-SUMMARY\.md/);
+  assert.match(prompt, /S02-SUMMARY\.md/);
+
+  // Fat narrative (the 20x-repeated paragraph) is NOT inlined
+  assert.ok(
+    !prompt.includes("threads the cache key through every call site."),
+    "closer prompt must not inline full 'What Happened' narrative after #4780",
+  );
+
+  // Prompt size is bounded — the two fat summaries' narratives alone would
+  // have exceeded ~4KB each. Post-fix closer prompt should be meaningfully
+  // smaller than their combined raw size.
+  const rawSize = makeFatSummary("S01").length + makeFatSummary("S02").length;
+  // Prompt includes roadmap, templates, and other inlines, so it may still
+  // be sizable — the guard is specifically that the fat narrative is gone.
+  // Use a soft bound: prompt - overhead should be less than 2x one summary.
+  assert.ok(
+    prompt.length < rawSize + 20_000,
+    `closer prompt length ${prompt.length} should be < raw summary size ${rawSize} + 20KB headroom`,
+  );
+});

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

@@ -153,6 +153,31 @@ describe("complete-milestone", () => {
     );
   });
 
+  test("prompt does not hard-fail main self-diff as missing implementation (#4699)", () => {
+    const prompt = loadPromptFromWorktree("complete-milestone", {
+      workingDirectory: "/tmp/test-project",
+      milestoneId: "M001",
+      milestoneTitle: "Main Retry Test",
+      roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
+      inlinedContext: "context",
+    });
+
+    assert.ok(
+      !prompt.includes("git diff --stat HEAD $(git merge-base HEAD main) -- ':!.gsd/'"),
+      "prompt must not require the known self-diff command from #4699",
+    );
+    assert.match(
+      prompt,
+      /self-diff/i,
+      "prompt should explicitly guard retries where HEAD and the integration branch are the same commit",
+    );
+    assert.match(
+      prompt,
+      /GSD-(?:Task|Unit)/,
+      "prompt should direct main-branch retries toward milestone-scoped GSD commit evidence",
+    );
+  });
+
   test("handleCompleteMilestone rejects when verificationPassed is false", async () => {
     const { handleCompleteMilestone } = await import("../tools/complete-milestone.ts");
     const base = createFixtureBase();