gsd-pi 2.73.1-dev.47ed32a → 2.73.1-dev.49397e5

package/src/resources/extensions/gsd/tests/commands-backlog.test.ts

@@ -0,0 +1,158 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-backlog-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function backlogPath(base: string): string {
+  return join(base, ".gsd", "BACKLOG.md");
+}
+
+function writeBacklog(base: string, content: string): void {
+  writeFileSync(backlogPath(base), content, "utf-8");
+}
+
+function readBacklog(base: string): string {
+  return readFileSync(backlogPath(base), "utf-8");
+}
+
+// Test the parsing/writing logic inline since the handler requires runtime context
+
+interface BacklogItem {
+  id: string;
+  title: string;
+  done: boolean;
+  note: string;
+}
+
+function parseBacklog(content: string): BacklogItem[] {
+  const items: BacklogItem[] = [];
+  for (const line of content.split("\n")) {
+    const match = line.match(/^- \[([ x])\] (999\.\d+) — (.+?)(?:\s*\((.+)\))?$/);
+    if (match) {
+      items.push({
+        id: match[2],
+        title: match[3].trim(),
+        done: match[1] === "x",
+        note: match[4] ?? "",
+      });
+    }
+  }
+  return items;
+}
+
+function formatBacklog(items: BacklogItem[]): string {
+  const lines = ["# Backlog\n"];
+  for (const item of items) {
+    const check = item.done ? "x" : " ";
+    const note = item.note ? ` (${item.note})` : "";
+    lines.push(`- [${check}] ${item.id} — ${item.title}${note}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────
+
+test("backlog: parse empty file returns empty array", () => {
+  const items = parseBacklog("");
+  assert.equal(items.length, 0);
+});
+
+test("backlog: parse valid entries", () => {
+  const content = `# Backlog
+
+- [ ] 999.1 — OAuth support (added 2026-03-23)
+- [x] 999.2 — Rate limiting (promoted 2026-03-24)
+- [ ] 999.3 — Dark mode`;
+
+  const items = parseBacklog(content);
+  assert.equal(items.length, 3);
+  assert.equal(items[0].id, "999.1");
+  assert.equal(items[0].title, "OAuth support");
+  assert.equal(items[0].done, false);
+  assert.equal(items[0].note, "added 2026-03-23");
+
+  assert.equal(items[1].id, "999.2");
+  assert.equal(items[1].done, true);
+  assert.equal(items[1].note, "promoted 2026-03-24");
+
+  assert.equal(items[2].id, "999.3");
+  assert.equal(items[2].title, "Dark mode");
+  assert.equal(items[2].note, "");
+});
+
+test("backlog: format roundtrips correctly", () => {
+  const items: BacklogItem[] = [
+    { id: "999.1", title: "OAuth support", done: false, note: "added 2026-03-23" },
+    { id: "999.2", title: "Rate limiting", done: true, note: "promoted 2026-03-24" },
+  ];
+
+  const formatted = formatBacklog(items);
+  const parsed = parseBacklog(formatted);
+
+  assert.equal(parsed.length, 2);
+  assert.equal(parsed[0].id, "999.1");
+  assert.equal(parsed[0].title, "OAuth support");
+  assert.equal(parsed[1].done, true);
+});
+
+test("backlog: write and read from disk", () => {
+  const base = makeTmpBase();
+  try {
+    const items: BacklogItem[] = [
+      { id: "999.1", title: "Test item", done: false, note: "added 2026-03-23" },
+    ];
+    writeBacklog(base, formatBacklog(items));
+
+    assert.ok(existsSync(backlogPath(base)));
+    const content = readBacklog(base);
+    assert.ok(content.includes("999.1"));
+    assert.ok(content.includes("Test item"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("backlog: next ID increments correctly", () => {
+  const items: BacklogItem[] = [
+    { id: "999.1", title: "First", done: false, note: "" },
+    { id: "999.2", title: "Second", done: false, note: "" },
+    { id: "999.5", title: "Fifth", done: false, note: "" },
+  ];
+
+  let maxNum = 0;
+  for (const item of items) {
+    const match = item.id.match(/^999\.(\d+)$/);
+    if (match) {
+      const num = parseInt(match[1], 10);
+      if (num > maxNum) maxNum = num;
+    }
+  }
+  const nextId = `999.${maxNum + 1}`;
+  assert.equal(nextId, "999.6");
+});
+
+test("backlog: empty backlog returns no items", () => {
+  const base = makeTmpBase();
+  try {
+    // No BACKLOG.md exists
+    assert.ok(!existsSync(backlogPath(base)));
+    // Would return empty array
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/commands-do.test.ts

@@ -0,0 +1,127 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// ─── Mock dispatcher to capture routed commands ─────────────────────────
+
+let lastRouted: string | null = null;
+let lastQuick: string | null = null;
+
+const mockCtx = {
+  ui: {
+    notify: (_msg: string, _level: string) => {},
+  },
+} as any;
+
+// We test the keyword matching logic directly since the handler imports
+// the dispatcher dynamically (which requires the full extension runtime).
+
+// Inline the route-matching logic from commands-do.ts for unit testing.
+interface Route {
+  keywords: string[];
+  command: string;
+}
+
+const ROUTES: Route[] = [
+  { keywords: ["progress", "status", "dashboard", "how far", "where are we"], command: "status" },
+  { keywords: ["auto", "autonomous", "run all", "keep going", "start auto"], command: "auto" },
+  { keywords: ["stop", "halt", "abort"], command: "stop" },
+  { keywords: ["pause", "break", "take a break"], command: "pause" },
+  { keywords: ["history", "past", "what happened", "previous"], command: "history" },
+  { keywords: ["doctor", "health", "diagnose", "check health"], command: "doctor" },
+  { keywords: ["clean up", "cleanup", "remove old", "prune", "tidy"], command: "cleanup" },
+  { keywords: ["ship", "pull request", "create pr", "open pr", "merge"], command: "ship" },
+  { keywords: ["discuss", "talk about", "architecture", "design"], command: "discuss" },
+  { keywords: ["undo", "revert", "rollback", "take back"], command: "undo" },
+  { keywords: ["skip", "skip task", "skip this"], command: "skip" },
+  { keywords: ["visualize", "viz", "graph", "chart", "show graph"], command: "visualize" },
+  { keywords: ["capture", "note", "idea", "thought", "remember"], command: "capture" },
+  { keywords: ["inspect", "database", "sqlite", "db state"], command: "inspect" },
+  { keywords: ["session report", "session summary", "cost summary", "how much"], command: "session-report" },
+  { keywords: ["backlog", "parking lot", "later", "someday"], command: "backlog" },
+  { keywords: ["add tests", "write tests", "generate tests", "test coverage"], command: "add-tests" },
+  { keywords: ["next", "step", "next step", "what's next"], command: "next" },
+];
+
+interface MatchResult {
+  command: string;
+  remainingArgs: string;
+  score: number;
+}
+
+function matchRoute(input: string): MatchResult | null {
+  const lower = input.toLowerCase();
+  let bestMatch: MatchResult | null = null;
+
+  for (const route of ROUTES) {
+    for (const keyword of route.keywords) {
+      if (lower.includes(keyword)) {
+        const score = keyword.length;
+        if (!bestMatch || score > bestMatch.score) {
+          const idx = lower.indexOf(keyword);
+          const remaining = (input.slice(0, idx) + input.slice(idx + keyword.length)).trim();
+          bestMatch = { command: route.command, remainingArgs: remaining, score };
+        }
+      }
+    }
+  }
+
+  return bestMatch;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────
+
+test("/gsd do: routes 'show me progress' to status", () => {
+  const match = matchRoute("show me progress");
+  assert.ok(match);
+  assert.equal(match.command, "status");
+});
+
+test("/gsd do: routes 'run autonomously' to auto", () => {
+  const match = matchRoute("run autonomously");
+  assert.ok(match);
+  assert.equal(match.command, "auto");
+});
+
+test("/gsd do: routes 'clean up old branches' to cleanup", () => {
+  const match = matchRoute("clean up old branches");
+  assert.ok(match);
+  assert.equal(match.command, "cleanup");
+  assert.equal(match.remainingArgs, "old branches");
+});
+
+test("/gsd do: routes 'create pr for milestone' to ship", () => {
+  const match = matchRoute("create pr for milestone");
+  assert.ok(match);
+  assert.equal(match.command, "ship");
+});
+
+test("/gsd do: routes 'add tests for S03' to add-tests", () => {
+  const match = matchRoute("add tests for S03");
+  assert.ok(match);
+  assert.equal(match.command, "add-tests");
+});
+
+test("/gsd do: routes 'what is next' to next", () => {
+  const match = matchRoute("what's next");
+  assert.ok(match);
+  assert.equal(match.command, "next");
+});
+
+test("/gsd do: returns null for unrecognized input", () => {
+  const match = matchRoute("florbinate the gizmo");
+  assert.equal(match, null);
+});
+
+test("/gsd do: prefers longer keyword match", () => {
+  // "check health" (12 chars) should beat "health" (6 chars)
+  const match = matchRoute("check health of the system");
+  assert.ok(match);
+  assert.equal(match.command, "doctor");
+  assert.ok(match.score >= 12);
+});
+
+test("/gsd do: routes 'session report' to session-report", () => {
+  const match = matchRoute("show me the session report");
+  assert.ok(match);
+  assert.equal(match.command, "session-report");
+});

package/src/resources/extensions/gsd/tests/commands-pr-branch.test.ts

@@ -0,0 +1,68 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// Test the filtering logic used by /gsd pr-branch.
+// Full integration requires git operations, so we test the path filtering.
+
+test("pr-branch: identifies .gsd/ paths", () => {
+  const files = [
+    ".gsd/milestones/M001/ROADMAP.md",
+    ".gsd/metrics.json",
+    "src/main.ts",
+    "package.json",
+    ".planning/PLAN.md",
+    "PLAN.md",
+  ];
+
+  const codeFiles = files.filter(
+    (f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md",
+  );
+
+  assert.deepEqual(codeFiles, ["src/main.ts", "package.json"]);
+});
+
+test("pr-branch: all .gsd/ files returns empty", () => {
+  const files = [
+    ".gsd/milestones/M001/ROADMAP.md",
+    ".gsd/metrics.json",
+    ".gsd/BACKLOG.md",
+  ];
+
+  const codeFiles = files.filter(
+    (f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md",
+  );
+
+  assert.equal(codeFiles.length, 0);
+});
+
+test("pr-branch: mixed commits with code changes", () => {
+  const files = [
+    ".gsd/milestones/M001/ROADMAP.md",
+    "src/auth.ts",
+    "src/auth.test.ts",
+  ];
+
+  const hasCodeChanges = files.some(
+    (f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md",
+  );
+
+  assert.ok(hasCodeChanges);
+});
+
+test("pr-branch: --dry-run flag", () => {
+  assert.ok("--dry-run".includes("--dry-run"));
+  assert.ok(!"--name my-branch".includes("--dry-run"));
+});
+
+test("pr-branch: --name flag parsing", () => {
+  const args = "--name my-clean-pr";
+  const nameMatch = args.match(/--name\s+(\S+)/);
+  assert.ok(nameMatch);
+  assert.equal(nameMatch[1], "my-clean-pr");
+});
+
+test("pr-branch: default branch name", () => {
+  const currentBranch = "feat/add-auth";
+  const prBranch = `pr/${currentBranch}`;
+  assert.equal(prBranch, "pr/feat/add-auth");
+});

package/src/resources/extensions/gsd/tests/commands-session-report.test.ts

@@ -0,0 +1,82 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// Test the formatting logic used by session-report.
+// The actual handler requires runtime context (metrics module), so we
+// test the core formatting and aggregation patterns.
+
+test("session-report: format cost correctly", () => {
+  // Simple cost formatting test
+  const formatCost = (cost: number): string => {
+    if (cost < 0.01) return "<$0.01";
+    return `$${cost.toFixed(2)}`;
+  };
+
+  assert.equal(formatCost(0), "<$0.01");
+  assert.equal(formatCost(0.005), "<$0.01");
+  assert.equal(formatCost(1.5), "$1.50");
+  assert.equal(formatCost(10.999), "$11.00");
+});
+
+test("session-report: format token count", () => {
+  const formatTokenCount = (count: number): string => {
+    if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+    if (count >= 1_000) return `${(count / 1_000).toFixed(1)}K`;
+    return String(count);
+  };
+
+  assert.equal(formatTokenCount(500), "500");
+  assert.equal(formatTokenCount(1500), "1.5K");
+  assert.equal(formatTokenCount(1_200_000), "1.2M");
+});
+
+test("session-report: aggregate by model", () => {
+  interface UnitMetric {
+    model: string;
+    cost: number;
+  }
+
+  const units: UnitMetric[] = [
+    { model: "opus", cost: 1.0 },
+    { model: "opus", cost: 0.8 },
+    { model: "sonnet", cost: 0.3 },
+    { model: "sonnet", cost: 0.5 },
+    { model: "sonnet", cost: 0.2 },
+  ];
+
+  const byModel = new Map<string, { count: number; cost: number }>();
+  for (const u of units) {
+    const existing = byModel.get(u.model) ?? { count: 0, cost: 0 };
+    existing.count++;
+    existing.cost += u.cost;
+    byModel.set(u.model, existing);
+  }
+
+  const opus = byModel.get("opus")!;
+  assert.equal(opus.count, 2);
+  assert.ok(Math.abs(opus.cost - 1.8) < 0.01);
+
+  const sonnet = byModel.get("sonnet")!;
+  assert.equal(sonnet.count, 3);
+  assert.ok(Math.abs(sonnet.cost - 1.0) < 0.01);
+});
+
+test("session-report: --json flag detection", () => {
+  const args1 = "--json";
+  const args2 = "--save --json";
+  const args3 = "something else";
+
+  assert.ok(args1.includes("--json"));
+  assert.ok(args2.includes("--json"));
+  assert.ok(!args3.includes("--json"));
+});
+
+test("session-report: --save flag detection", () => {
+  const args1 = "--save";
+  const args2 = "--save --json";
+  const args3 = "";
+
+  assert.ok(args1.includes("--save"));
+  assert.ok(args2.includes("--save"));
+  assert.ok(!args3.includes("--save"));
+});

package/src/resources/extensions/gsd/tests/commands-ship.test.ts

@@ -0,0 +1,71 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// Test the PR content generation logic used by /gsd ship.
+// Full integration requires gh CLI + git, so we test the text generation.
+
+test("ship: generates TL;DR format", () => {
+  // Simulate generatePRContent output structure
+  const milestoneId = "M001";
+  const milestoneTitle = "User authentication system";
+
+  const title = `feat: ${milestoneTitle}`;
+  assert.equal(title, "feat: User authentication system");
+  assert.ok(title.length < 80); // PR title should be short
+});
+
+test("ship: --dry-run flag detection", () => {
+  const args1 = "--dry-run";
+  const args2 = "--draft --dry-run";
+  const args3 = "--draft";
+
+  assert.ok(args1.includes("--dry-run"));
+  assert.ok(args2.includes("--dry-run"));
+  assert.ok(!args3.includes("--dry-run"));
+});
+
+test("ship: --base flag parsing", () => {
+  const args = "--base develop --draft";
+  const baseMatch = args.match(/--base\s+(\S+)/);
+  assert.ok(baseMatch);
+  assert.equal(baseMatch[1], "develop");
+});
+
+test("ship: --base flag absent defaults", () => {
+  const args = "--draft";
+  const baseMatch = args.match(/--base\s+(\S+)/);
+  assert.equal(baseMatch, null);
+});
+
+test("ship: --force flag detection", () => {
+  const args1 = "--force";
+  const args2 = "";
+
+  assert.ok(args1.includes("--force"));
+  assert.ok(!args2.includes("--force"));
+});
+
+test("ship: change type checklist format", () => {
+  const checklist = [
+    "- [x] `feat` — New feature or capability",
+    "- [ ] `fix` — Bug fix",
+    "- [ ] `refactor` — Code restructuring",
+    "- [ ] `test` — Adding or updating tests",
+    "- [ ] `docs` — Documentation only",
+    "- [ ] `chore` — Build, CI, or tooling changes",
+  ];
+
+  // Verify format matches CONTRIBUTING.md expectations
+  for (const line of checklist) {
+    assert.match(line, /^- \[[ x]\] `\w+` — .+$/);
+  }
+});
+
+test("ship: PR body contains required sections", () => {
+  const requiredSections = ["## TL;DR", "## Change type"];
+  const body = "## TL;DR\n\n**What:** Ship M001\n\n## Change type\n\n- [x] `feat`";
+
+  for (const section of requiredSections) {
+    assert.ok(body.includes(section), `Missing section: ${section}`);
+  }
+});

package/src/resources/extensions/gsd/tests/commands-workflow-custom.test.ts

@@ -217,6 +217,20 @@ describe("workflow command handler", () => {
     );
   });
 
+  it("preserves quoted workflow run overrides (#4130)", async () => {
+    const { parseWorkflowRunArgs } = await import("../commands/handlers/workflow.ts");
+    assert.deepStrictEqual(
+      parseWorkflowRunArgs('demo-workflow target="multi word target" region=\'us east\''),
+      {
+        defName: "demo-workflow",
+        overrides: {
+          target: "multi word target",
+          region: "us east",
+        },
+      },
+    );
+  });
+
   it("'/gsd workflow run nonexistent' shows error for missing definition", async () => {
     const { handled, notifications } = await callHandler("workflow run nonexistent-def-12345");
     assert.ok(handled, "should be handled");

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

@@ -0,0 +1,142 @@
+/**
+ * complete-milestone-false-merge.test.ts — Regression test for #4175.
+ *
+ * Before the fix, a failed complete-milestone unit could leave a stub
+ * SUMMARY blocker placeholder on disk. stopAuto's SUMMARY-presence check
+ * then treated the milestone as complete and merged the worktree branch
+ * into main — emitting a misleading metadata-only merge warning for a
+ * milestone that was never legitimately finished.
+ *
+ * The fix has three cooperating parts:
+ *   1. stopAuto uses DB status (authoritative) instead of SUMMARY presence
+ *      when the project DB is available.
+ *   2. postUnitPreVerification pauses auto-mode for complete-milestone
+ *      after retries are exhausted instead of writing a blocker placeholder.
+ *   3. recoverTimedOutUnit pauses for complete-milestone instead of
+ *      writing a blocker placeholder.
+ *
+ * This test guards all three via source inspection so a future refactor
+ * cannot silently reintroduce the false-merge path.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const gsdDir = join(import.meta.dirname, "..");
+const autoSrc = readFileSync(join(gsdDir, "auto.ts"), "utf-8");
+const postUnitSrc = readFileSync(join(gsdDir, "auto-post-unit.ts"), "utf-8");
+const timeoutSrc = readFileSync(join(gsdDir, "auto-timeout-recovery.ts"), "utf-8");
+
+test("#4175: stopAuto uses DB status as the authoritative milestone-complete signal", () => {
+  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
+  assert.ok(step4Idx !== -1, "Step 4 comment exists in stopAuto");
+  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
+  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+
+  assert.ok(
+    step4Block.includes("isDbAvailable()"),
+    "Step 4 should branch on isDbAvailable() so DB is consulted when present",
+  );
+  assert.ok(
+    step4Block.includes("getMilestone(s.currentMilestoneId)"),
+    "Step 4 should read authoritative milestone status via getMilestone()",
+  );
+  assert.ok(
+    /status\s*===\s*"complete"/.test(step4Block),
+    'Step 4 should compare the DB row status to "complete"',
+  );
+});
+
+test("#4175: stopAuto imports getMilestone from gsd-db", () => {
+  assert.ok(
+    /import\s*\{[^}]*\bgetMilestone\b[^}]*\}\s*from\s*"\.\/gsd-db\.js"/.test(autoSrc),
+    "auto.ts should import getMilestone from ./gsd-db.js",
+  );
+});
+
+test("#4175: stopAuto still falls back to SUMMARY presence when DB is unavailable", () => {
+  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
+  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
+  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+
+  assert.ok(
+    step4Block.includes("resolveMilestoneFile"),
+    "Step 4 should keep SUMMARY-file resolution for DB-unavailable projects",
+  );
+  assert.ok(
+    step4Block.includes("preserveBranch"),
+    "Step 4 should still preserve branch for incomplete milestones (fallback path)",
+  );
+});
+
+test("#4175: postUnitPreVerification pauses complete-milestone after retries exhausted", () => {
+  // The pause branch must live inside the retries-exhausted block, above the
+  // writeBlockerPlaceholder call — otherwise the stub SUMMARY is still written.
+  const retriesExhaustedIdx = postUnitSrc.indexOf(
+    "if (attempt > MAX_VERIFICATION_RETRIES)",
+  );
+  assert.ok(
+    retriesExhaustedIdx !== -1,
+    "retries-exhausted guard exists in postUnitPreVerification",
+  );
+
+  const blockerCallIdx = postUnitSrc.indexOf("writeBlockerPlaceholder", retriesExhaustedIdx);
+  assert.ok(
+    blockerCallIdx !== -1,
+    "blocker placeholder call still exists for non-milestone units",
+  );
+
+  const exhaustedBlock = postUnitSrc.slice(retriesExhaustedIdx, blockerCallIdx);
+
+  assert.ok(
+    /s\.currentUnit\.type\s*===\s*"complete-milestone"/.test(exhaustedBlock),
+    "retries-exhausted block should specifically handle complete-milestone",
+  );
+  assert.ok(
+    /pauseAuto\s*\(\s*ctx\s*,\s*pi\s*\)/.test(exhaustedBlock),
+    "complete-milestone path should call pauseAuto instead of falling through",
+  );
+  // The pause branch must return so execution never reaches writeBlockerPlaceholder.
+  assert.ok(
+    /return\s+"dispatched"\s*;/.test(exhaustedBlock),
+    "complete-milestone pause branch should return before the placeholder call",
+  );
+});
+
+test("#4175: recoverTimedOutUnit pauses complete-milestone instead of writing a blocker placeholder", () => {
+  // The complete-milestone pause branch must sit immediately above the
+  // "retries exhausted" writeBlockerPlaceholder call so a failed
+  // complete-milestone never produces a stub SUMMARY. Anchor on the
+  // comment that precedes that specific placeholder call rather than the
+  // function's earlier writeBlockerPlaceholder use sites or its import.
+  // Use lastIndexOf so we find the final retries-exhausted block in
+  // recoverTimedOutUnit, not an earlier helper with the same comment.
+  const exhaustedAnchor = "Retries exhausted — write a blocker placeholder";
+  const exhaustedIdx = timeoutSrc.lastIndexOf(exhaustedAnchor);
+  assert.ok(
+    exhaustedIdx !== -1,
+    "retries-exhausted blocker-placeholder path still exists for non-milestone units",
+  );
+
+  const guardIdx = timeoutSrc.lastIndexOf(
+    'unitType === "complete-milestone"',
+    exhaustedIdx,
+  );
+  assert.ok(
+    guardIdx !== -1,
+    "complete-milestone guard should appear above the retries-exhausted placeholder call",
+  );
+
+  const guardBlock = timeoutSrc.slice(guardIdx, exhaustedIdx);
+  assert.ok(
+    /return\s+"paused"\s*;/.test(guardBlock),
+    "complete-milestone guard should return 'paused' before the placeholder call",
+  );
+  // The guard itself must not call writeBlockerPlaceholder.
+  assert.ok(
+    !guardBlock.includes("writeBlockerPlaceholder"),
+    "complete-milestone guard must not write a blocker placeholder",
+  );
+});