@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.75048e7

package/src/resources/extensions/gsd/tests/gsd-rebuild.test.ts

@@ -0,0 +1,199 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { handleRebuild } from "../commands-maintenance.ts";
+import {
+  closeDatabase,
+  getTask,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
+import { invalidateStateCache } from "../state.ts";
+
+type Note = { message: string; kind: string };
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-rebuild-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), {
+    recursive: true,
+  });
+  return base;
+}
+
+function cleanup(base: string): void {
+  closeDatabase();
+  invalidateStateCache();
+  rmSync(base, { recursive: true, force: true });
+}
+
+function makeCtx(): { ctx: any; notes: Note[] } {
+  const notes: Note[] = [];
+  return {
+    ctx: {
+      ui: {
+        notify: (message: string, kind: string) => notes.push({ message, kind }),
+      },
+    },
+    notes,
+  };
+}
+
+function seedOpenTask(): void {
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Slice",
+    status: "in_progress",
+    risk: "low",
+    depends: [],
+  });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task",
+    status: "pending",
+  });
+}
+
+function listFiles(dir: string): string[] {
+  if (!existsSync(dir)) return [];
+  const out: string[] = [];
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const full = join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else {
+        out.push(full);
+      }
+    }
+  }
+  return out.sort();
+}
+
+test("handleRebuild quarantines stale completion projections without mutating DB state", async () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    seedOpenTask();
+
+    const summaryPath = join(
+      base,
+      ".gsd",
+      "milestones",
+      "M001",
+      "slices",
+      "S01",
+      "tasks",
+      "T01-SUMMARY.md",
+    );
+    writeFileSync(summaryPath, "# T01 Summary\n\nDisk-only completion.\n", "utf-8");
+
+    const { ctx, notes } = makeCtx();
+    await handleRebuild(ctx, base, "markdown");
+
+    assert.equal(existsSync(summaryPath), false, "stale SUMMARY projection should be moved aside");
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "pending", "DB task status remains authoritative");
+    assert.equal(task?.full_summary_md, "", "disk summary must not be imported into DB");
+
+    const quarantined = listFiles(join(base, ".gsd", "quarantine", "projections"));
+    assert.equal(quarantined.length, 1);
+    assert.match(readFileSync(quarantined[0]!, "utf-8"), /Disk-only completion/);
+    assert.match(notes.at(-1)?.message ?? "", /Quarantined:\s+1/);
+    assert.equal(notes.at(-1)?.kind, "success");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("handleRebuild re-renders missing task summary projections from DB", async () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    seedOpenTask();
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task",
+      status: "complete",
+      oneLiner: "Task complete",
+      narrative: "Finished through the DB.",
+      verificationResult: "passed",
+      fullSummaryMd: "# T01 Summary\n\nRendered from DB.\n",
+    });
+
+    const summaryPath = join(
+      base,
+      ".gsd",
+      "milestones",
+      "M001",
+      "slices",
+      "S01",
+      "tasks",
+      "T01-SUMMARY.md",
+    );
+    rmSync(summaryPath, { force: true });
+
+    const { ctx, notes } = makeCtx();
+    await handleRebuild(ctx, base);
+
+    assert.equal(existsSync(summaryPath), true, "missing SUMMARY projection should be regenerated");
+    assert.equal(readFileSync(summaryPath, "utf-8"), "# T01 Summary\n\nRendered from DB.\n");
+    assert.match(notes.at(-1)?.message ?? "", /rebuilt markdown projections from the canonical DB/);
+    assert.match(notes.at(-1)?.message ?? "", /Quarantined:\s+0/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("handleRebuild database target is reserved and does not import markdown", async () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    seedOpenTask();
+
+    const summaryPath = join(
+      base,
+      ".gsd",
+      "milestones",
+      "M001",
+      "slices",
+      "S01",
+      "tasks",
+      "T01-SUMMARY.md",
+    );
+    writeFileSync(summaryPath, "# T01 Summary\n\nShould not import.\n", "utf-8");
+
+    const { ctx, notes } = makeCtx();
+    await handleRebuild(ctx, base, "database");
+
+    assert.equal(existsSync(summaryPath), true, "reserved DB rebuild must not move projection files");
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "pending", "reserved DB rebuild must not mutate task status");
+    assert.equal(task?.full_summary_md, "", "reserved DB rebuild must not import markdown");
+    assert.match(notes.at(-1)?.message ?? "", /reserved/);
+    assert.match(notes.at(-1)?.message ?? "", /\/gsd recover --confirm/);
+    assert.equal(notes.at(-1)?.kind, "warning");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/gsd-recover.test.ts

@@ -24,6 +24,7 @@ import {
 } from '../gsd-db.ts';
 import { migrateHierarchyToDb } from '../md-importer.ts';
 import { deriveStateFromDb, invalidateStateCache } from '../state.ts';
+import { handleRecover } from '../commands-maintenance.ts';
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -42,6 +43,22 @@ function cleanup(base: string): void {
   rmSync(base, { recursive: true, force: true });
 }
 
+function makeCtx(confirm?: () => Promise<boolean>): {
+  ctx: any;
+  notes: Array<{ message: string; kind: string }>;
+} {
+  const notes: Array<{ message: string; kind: string }> = [];
+  return {
+    ctx: {
+      ui: {
+        notify: (message: string, kind: string) => notes.push({ message, kind }),
+        ...(confirm ? { confirm: async () => confirm() } : {}),
+      },
+    },
+    notes,
+  };
+}
+
 // ─── Fixture Content ──────────────────────────────────────────────────────
 
 const ROADMAP_M001 = `# M001: Recovery Test
@@ -437,4 +454,62 @@ describe('gsd-recover', async () => {
       cleanup(base);
     }
   });
+
+  test('handleRecover warns and does not import markdown without confirmation', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
+
+      const { ctx, notes } = makeCtx();
+      await handleRecover(ctx, base);
+
+      assert.ok(getMilestone('M999'), 'existing DB row remains when recover is unconfirmed');
+      assert.equal(getMilestone('M001'), null, 'markdown milestone is not imported without confirmation');
+      assert.equal(notes.at(-1)?.kind, 'warning');
+      assert.match(notes.at(-1)?.message ?? '', /\/gsd recover --confirm/);
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('handleRecover interactive cancellation leaves DB unchanged', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
+
+      const { ctx, notes } = makeCtx(async () => false);
+      await handleRecover(ctx, base);
+
+      assert.ok(getMilestone('M999'), 'existing DB row remains when recover is cancelled');
+      assert.equal(getMilestone('M001'), null, 'markdown milestone is not imported after cancellation');
+      assert.match(notes.at(-1)?.message ?? '', /cancelled/);
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('handleRecover imports markdown after explicit confirmation', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
+
+      const { ctx, notes } = makeCtx();
+      await handleRecover(ctx, base, '--confirm');
+
+      assert.equal(getMilestone('M999'), null, 'confirmed recover clears old hierarchy rows');
+      assert.ok(getMilestone('M001'), 'confirmed recover imports markdown hierarchy');
+      assert.equal(notes.at(-1)?.kind, 'success');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/guided-discuss-milestone-prompt-rendering.test.ts

@@ -3,10 +3,11 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { VISION_ASK_VARIANTS } from "../vision-ask.ts";
+import { buildDiscussMilestonePrompt } from "../auto-prompts.ts";
 
 test("guided milestone prompt renders compact interview and context guidance", async (t) => {
   const previousGsdHome = process.env.GSD_HOME;
@@ -47,3 +48,41 @@ test("guided milestone prompt renders compact interview and context guidance", a
   assert.match(prompt, /milestone_id: M001/);
   assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
 });
+
+test("guided milestone prompt builder preloads milestone planning context", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-context-"));
+  try {
+    const milestonesRoot = join(base, ".gsd", "milestones");
+    const priorDir = join(milestonesRoot, "M001");
+    const currentDir = join(milestonesRoot, "M002");
+    const futureDir = join(milestonesRoot, "M003");
+    mkdirSync(priorDir, { recursive: true });
+    mkdirSync(currentDir, { recursive: true });
+    mkdirSync(futureDir, { recursive: true });
+
+    writeFileSync(join(base, ".gsd", "DECISIONS.md"), "# Decisions\n\nDECISION-SIGNAL", "utf-8");
+    writeFileSync(join(priorDir, "M001-SUMMARY.md"), "# M001 Summary\n\nPRIOR-SUMMARY-SIGNAL", "utf-8");
+    writeFileSync(join(currentDir, "M002-ROADMAP.md"), "# M002 Roadmap\n\nROADMAP-SIGNAL", "utf-8");
+    writeFileSync(join(currentDir, "M002-CONTEXT.md"), "# M002 Context\n\nCONTEXT-SIGNAL", "utf-8");
+    writeFileSync(join(currentDir, "M002-RESEARCH.md"), "# M002 Research\n\nRESEARCH-SIGNAL", "utf-8");
+    writeFileSync(join(futureDir, "M003-SUMMARY.md"), "# M003 Summary\n\nFUTURE-SUMMARY-SIGNAL", "utf-8");
+
+    const prompt = await buildDiscussMilestonePrompt("M002", "Checkout Polish", base, "true");
+
+    assert.match(prompt, /## Inlined Context \(preloaded — do not re-read these files\)/);
+    assert.match(prompt, /### Milestone Roadmap/);
+    assert.match(prompt, /ROADMAP-SIGNAL/);
+    assert.match(prompt, /### Milestone Context/);
+    assert.match(prompt, /CONTEXT-SIGNAL/);
+    assert.match(prompt, /### Milestone Research/);
+    assert.match(prompt, /RESEARCH-SIGNAL/);
+    assert.match(prompt, /### Decisions Register/);
+    assert.match(prompt, /DECISION-SIGNAL/);
+    assert.match(prompt, /### M001 Prior Milestone Summary/);
+    assert.match(prompt, /PRIOR-SUMMARY-SIGNAL/);
+    assert.doesNotMatch(prompt, /FUTURE-SUMMARY-SIGNAL/);
+    assert.match(prompt, /### Output Template: Context/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/guided-dispatch-root.test.ts

@@ -104,3 +104,89 @@ test("guided dispatch passes the explicit project root through model and compati
     rmSync(otherRoot, { recursive: true, force: true });
   }
 });
+
+test("guided dispatch accepts workflow MCP tools absent from parent active tool surface", async () => {
+  const explicitRoot = mkdtempSync(join(tmpdir(), "gsd-guided-mcp-surface-"));
+  const workflowPath = join(explicitRoot, "GSD-WORKFLOW.md");
+  const originalWorkflowPath = process.env.GSD_WORKFLOW_PATH;
+  const originalMcpCommand = process.env.GSD_WORKFLOW_MCP_COMMAND;
+  const notifications: string[] = [];
+  let sent = false;
+
+  const ctx = {
+    model: { provider: "claude-code", baseUrl: "local://claude-code" },
+    modelRegistry: {
+      getProviderAuthMode: () => "externalCli",
+    },
+    ui: {
+      notify: (message: string) => {
+        notifications.push(message);
+      },
+    },
+  };
+
+  let activeTools = [
+    "ScheduleWakeup",
+    "ToolSearch",
+    "ask_user_questions",
+    "bash",
+    "read",
+    "write",
+  ];
+
+  const pi = {
+    getActiveTools: () => [...activeTools],
+    setActiveTools: (tools: string[]) => {
+      activeTools = [...tools];
+    },
+    sendMessage: () => {
+      sent = true;
+    },
+  };
+
+  try {
+    writeFileSync(workflowPath, "# Workflow\n", "utf-8");
+    process.env.GSD_WORKFLOW_PATH = workflowPath;
+    process.env.GSD_WORKFLOW_MCP_COMMAND = "node";
+
+    await _dispatchWorkflowForTest(
+      pi as any,
+      "Discuss the milestone.",
+      "gsd-discuss",
+      ctx as any,
+      "discuss-milestone",
+      {
+        basePath: explicitRoot,
+        deps: {
+          loadPreferences: () => ({ preferences: {} }) as any,
+          selectModel: (async () => ({
+            routing: null,
+            appliedModel: {
+              provider: "claude-code",
+              id: "claude-opus-4-8",
+              baseUrl: "local://claude-code",
+            },
+          })) as any,
+        },
+      },
+    );
+
+    assert.equal(sent, true);
+    assert.equal(
+      notifications.some((message) => message.includes("cannot run guided flow")),
+      false,
+    );
+  } finally {
+    if (originalWorkflowPath === undefined) {
+      delete process.env.GSD_WORKFLOW_PATH;
+    } else {
+      process.env.GSD_WORKFLOW_PATH = originalWorkflowPath;
+    }
+    if (originalMcpCommand === undefined) {
+      delete process.env.GSD_WORKFLOW_MCP_COMMAND;
+    } else {
+      process.env.GSD_WORKFLOW_MCP_COMMAND = originalMcpCommand;
+    }
+    rmSync(explicitRoot, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/guided-flow-session-isolation.test.ts

@@ -178,7 +178,7 @@ test("checkAutoStartAfterDiscuss(basePath) selects the matching pending entry wh
   }
 });
 
-test("checkAutoStartAfterDiscuss can emit ready without scheduling auto-start", () => {
+test("checkAutoStartAfterDiscuss can accept context handoff without scheduling auto-start", () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-auto-start-headless-owned-"));
   let waitForIdleCalls = 0;
   const notifications: string[] = [];
@@ -209,9 +209,11 @@ test("checkAutoStartAfterDiscuss can emit ready without scheduling auto-start",
     });
 
     assert.equal(checkAutoStartAfterDiscuss(base), true);
-    assert.deepEqual(notifications, ["Milestone M001 ready."]);
+    assert.deepEqual(notifications, [
+      "Milestone M001 context captured. Continuing the planning pipeline.",
+    ]);
     assert.equal(waitForIdleCalls, 0, "headless-owned auto start must not schedule guided-flow auto");
-    assert.equal(getDiscussionMilestoneId(base), null, "ready handoff should still be cleared");
+    assert.equal(getDiscussionMilestoneId(base), null, "accepted handoff should still be cleared");
   } finally {
     clearPendingAutoStart();
     rmSync(base, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/guided-flow-state-rebuild.test.ts

@@ -135,7 +135,13 @@ describe("guided-flow STATE.md rebuild (#3475)", () => {
 
     assert.equal(accepted, true);
     assert.equal(notifications.some(n => n.level === "error" && n.message.includes("no DB row exists")), false);
-    assert.ok(notifications.some(n => n.level === "success" && n.message.includes("Milestone M001 ready.")));
+    assert.ok(
+      notifications.some(
+        n =>
+          n.level === "success" &&
+          n.message.includes("Milestone M001 context captured. Continuing the planning pipeline."),
+      ),
+    );
     clearPendingAutoStart(base);
   });
 
@@ -157,13 +163,13 @@ describe("guided-flow STATE.md rebuild (#3475)", () => {
     };
     setPendingAutoStart(base, { basePath: base, milestoneId: "M001", ctx: ctx as any, pi: {} as any });
 
-    for (let i = 0; i < 4; i += 1) {
+    for (let i = 0; i < 3; i += 1) {
       assert.equal(checkAutoStartAfterDiscuss(), false);
     }
 
     assert.equal(
-      notifications.filter(n => n.level === "warning" && n.message.includes("recovering. Retrying gsd_plan_milestone")).length,
-      3,
+      notifications.filter(n => n.level === "warning").length,
+      0,
     );
     assert.equal(
       notifications.filter(n => n.level === "error" && n.message.includes("DB row recovery failed")).length,
@@ -171,4 +177,34 @@ describe("guided-flow STATE.md rebuild (#3475)", () => {
     );
     clearPendingAutoStart(base);
   });
+
+  test("checkAutoStartAfterDiscuss does not double-notify on 4th+ call after recovery limit", () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+    const db = _getAdapter();
+    assert.ok(db, "database should be open");
+    db.exec("DROP TABLE milestones");
+    db.exec("CREATE TABLE milestones (id TEXT PRIMARY KEY)");
+
+    writeFile(base, "milestones/M001/M001-CONTEXT.md", "# M001: Planned\n");
+    writeFile(base, "STATE.md", "# GSD State\n\n**Active Milestone:** M001: Planned\n");
+
+    const notifications: Array<{ message: string; level: string }> = [];
+    const ctx = {
+      ui: { notify: (message: string, level: string) => notifications.push({ message, level }) },
+      waitForIdle: () => new Promise<void>(() => {}),
+    };
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M001", ctx: ctx as any, pi: {} as any });
+
+    for (let i = 0; i < 5; i += 1) {
+      assert.equal(checkAutoStartAfterDiscuss(), false);
+    }
+
+    assert.equal(
+      notifications.filter(n => n.level === "error" && n.message.includes("DB row recovery failed")).length,
+      1,
+      "user must see exactly one error notification even after repeated calls past the recovery limit",
+    );
+    clearPendingAutoStart(base);
+  });
 });

package/src/resources/extensions/gsd/tests/guided-flow.test.ts

@@ -8,14 +8,17 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 
 test("guided milestone discussion callsites pass workingDirectory to loadPrompt", () => {
   const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
-  const calls = [...source.matchAll(/loadPrompt\("guided-discuss-milestone",\s*\{([\s\S]*?)\}\)/g)];
 
-  assert.equal(calls.length, 8, "all guided-flow guided-discuss-milestone callsites should be covered");
-  for (const call of calls) {
-    assert.match(
-      call[1] ?? "",
-      /\bworkingDirectory:\s*basePath\b/,
-      "guided-discuss-milestone prompts need workingDirectory so template validation does not crash",
-    );
-  }
+  // All guided-discuss-milestone dispatches now go through buildDiscussMilestonePrompt,
+  // which centralises the loadPrompt call and always passes workingDirectory.
+  // Verify no callsite bypasses the builder by calling loadPrompt directly.
+  const directCalls = [...source.matchAll(/loadPrompt\("guided-discuss-milestone"/g)];
+  assert.equal(
+    directCalls.length,
+    0,
+    'guided-flow.ts must not call loadPrompt("guided-discuss-milestone") directly — use buildDiscussMilestonePrompt',
+  );
+
+  const calls = [...source.matchAll(/\bawait buildDiscussMilestonePrompt\(/g)];
+  assert.equal(calls.length, 9, "all guided-flow guided-discuss-milestone callsites should be covered");
 });

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

@@ -119,8 +119,8 @@ test("resolveExpectedArtifactPath returns correct path for all slice-level types
 // ─── run-uat artifact path contract (#2873) ──────────────────────────────
 
 test("resolveExpectedArtifactPath for run-uat returns ASSESSMENT path, not UAT (#2873)", (t) => {
-  // The run-uat prompt instructs the agent to call gsd_summary_save with
-  // artifact_type: "ASSESSMENT", which writes S##-ASSESSMENT.md. The artifact
+  // The run-uat prompt instructs the agent to call gsd_uat_result_save, which
+  // writes S##-ASSESSMENT.md through the workflow persistence path. The artifact
   // verification path must match — otherwise verification fails and auto-mode
   // retries the unit in an infinite loop.
   const base = makeTmpBase();
@@ -147,12 +147,12 @@ test("diagnoseExpectedArtifact for run-uat references ASSESSMENT (#2873)", (t) =
 });
 
 test("verifyExpectedArtifact passes for run-uat when ASSESSMENT file exists (#2873)", (t) => {
-  // Regression test: run-uat writes S##-ASSESSMENT.md via gsd_summary_save,
+  // Regression test: run-uat writes S##-ASSESSMENT.md via gsd_uat_result_save,
   // but verification looked for S##-UAT.md, causing false stuck retries.
   const base = makeTmpBase();
   t.after(() => cleanup(base));
 
-  // Write the ASSESSMENT file (what gsd_summary_save actually produces)
+  // Write the ASSESSMENT file (what gsd_uat_result_save actually produces)
   const assessPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-ASSESSMENT.md");
   writeFileSync(assessPath, "---\nverdict: PASS\n---\n# UAT Assessment\n");
 

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

@@ -29,6 +29,7 @@ import { nativeMergeSquash } from "../../native-git-bridge.ts";
 import { drainLogs, setStderrLoggingEnabled } from "../../workflow-logger.ts";
 import {
   closeDatabase,
+  insertAssessment,
   insertMilestone,
   insertSlice,
   insertTask,
@@ -207,6 +208,13 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
         });
       }
     }
+    insertAssessment({
+      path: "milestones/M020/M020-VALIDATION.md",
+      milestoneId: "M020",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
 
     const roadmap = makeRoadmap("M020", "Backend foundation", [
       { id: "S01", title: "Core API" },

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

@@ -41,6 +41,7 @@ import {
 import {
   openDatabase,
   closeDatabase,
+  insertAssessment,
   insertMilestone,
   insertSlice,
   updateMilestoneStatus,
@@ -347,6 +348,13 @@ test("mergeCompletedMilestone — synthesizes roadmap from DB when projection is
       title: "Search Bar",
       status: "complete",
     });
+    insertAssessment({
+      path: "milestones/M010/M010-VALIDATION.md",
+      milestoneId: "M010",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
 
     createMilestoneBranch(repo, "M010", [
       { name: "app.js", content: "export const app = true;\n" },
@@ -671,6 +679,14 @@ function setupCanonicalDbWithWorktree(basePath: string, mid: string): void {
   const dbPath = join(basePath, ".gsd", "gsd.db");
   openDatabase(dbPath);
   insertMilestone({ id: mid, title: `Milestone ${mid}`, status: "complete" });
+  insertSlice({ id: "S01", milestoneId: mid, title: "Done Slice", status: "complete" });
+  insertAssessment({
+    path: `milestones/${mid}/${mid}-VALIDATION.md`,
+    milestoneId: mid,
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
   updateMilestoneStatus(mid, "complete", new Date().toISOString());
   closeDatabase();
 }