@opengsd/gsd-pi 1.1.1-dev.9bb7453 → 1.1.1-dev.a5a2de8

package/src/resources/extensions/gsd/tests/check-auto-start-pending-gate.test.ts

@@ -164,17 +164,13 @@ describe("checkAutoStartAfterDiscuss Gate 1a (pending depth-verification gate)",
   test("Gate 1a does NOT trip when the pending gate is for a DIFFERENT milestone", () => {
     base = mkBase();
     openDatabase(":memory:");
-    // status: "queued" so that Gate 1b downstream of Gate 1a fires its
-    // recovery notify ("context file exists but milestone is still queued") —
-    // observing that notify proves we advanced past Gate 1a. If Gate 1a
-    // wrongly tripped on the M999 gate it would `return false` immediately
-    // and Gate 1b would never run, so the notify would be absent.
     insertMilestone({ id: "M001", title: "Pending Gate Test", status: "queued" });
 
     cap = mkCapture();
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
+      startAuto: false,
       ctx: mkCtx(cap),
       pi: mkPi(cap),
     });
@@ -182,21 +178,19 @@ describe("checkAutoStartAfterDiscuss Gate 1a (pending depth-verification gate)",
     setPendingGate("depth_verification_M999_confirm", base);
 
     const result = checkAutoStartAfterDiscuss();
-    assert.equal(result, false, "Gate 1b returns false (expected) — but only if Gate 1a let us through");
+    assert.equal(result, true, "different milestone gate must not block this handoff");
 
-    // Positive proof we passed Gate 1a: Gate 1b emitted its recovery notify
-    // about M001 (not M999 — the pending-gate milestone is irrelevant here).
-    const gate1bNotify = cap.notifies.find(n =>
-      n.level === "warning" && /M001.*context file exists but milestone is still queued/i.test(n.msg)
+    const successNotify = cap.notifies.find(n =>
+      n.level === "success" && /M001 context captured/i.test(n.msg)
     );
     assert.ok(
-      gate1bNotify,
-      `expected Gate 1b warning notify about M001; got: ${JSON.stringify(cap.notifies)}`,
+      successNotify,
+      `expected context-captured success notify about M001; got: ${JSON.stringify(cap.notifies)}`,
     );
 
-    // Negative proof: no Gate 1a notification path exists in source today, but
-    // also assert no notify mentions M999 (the pending-gate milestone) — that
-    // would suggest Gate 1a is leaking the wrong milestone into messaging.
+    const retryNotify = cap.notifies.find(n => /queued|gsd_plan_milestone/i.test(n.msg));
+    assert.equal(retryNotify, undefined, "handoff must not mention queued state or internal plan retry");
+
     const m999Notify = cap.notifies.find(n => /M999/i.test(n.msg));
     assert.equal(m999Notify, undefined, "no notify should reference M999 (the pending-gate milestone)");
   });

package/src/resources/extensions/gsd/tests/check-auto-start-ready-guard.test.ts

@@ -1,9 +1,7 @@
-// gsd-pi + Regression tests for checkAutoStartAfterDiscuss "ready" notify guard (R3b)
+// gsd-pi + Regression tests for checkAutoStartAfterDiscuss handoff copy (R3b)
 //
-// Belt-and-suspenders: even when CONTEXT.md and STATE.md exist on disk, the
-// "Milestone X ready." success notify must not fire when the milestone DB row
-// is absent. Otherwise the user sees "ready" and then /gsd reports
-// "No Active Milestone" because the milestone was never registered.
+// Missing-row repair may accept a context handoff, but "Milestone X ready."
+// is reserved for executable plans with persisted slices in DB mode.
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
@@ -21,6 +19,7 @@ import {
   openDatabase,
   closeDatabase,
   insertMilestone,
+  insertSlice,
   getMilestone,
 } from "../gsd-db.ts";
 import {
@@ -92,49 +91,60 @@ describe("checkAutoStartAfterDiscuss ready-notify DB guard (R3b)", () => {
     }
   });
 
-  test("does not announce 'ready' when the milestone DB row is absent — recovers via Gate 1b", () => {
+  test("repairs a missing milestone DB row and accepts context-captured handoff", () => {
     base = mkBase();
-    // Open a fresh in-memory DB but DO NOT insertMilestone for M001.
     openDatabase(":memory:");
 
     cap = mkCapture();
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
+      startAuto: false,
       ctx: mkCtx(cap),
       pi: mkPi(cap),
     });
 
     const result = checkAutoStartAfterDiscuss();
-    assert.equal(result, false, "must return false when DB row missing");
+    assert.equal(result, true, "missing row with pinned context should repair and accept handoff");
 
-    // No success "ready" notify
     const successReady = cap.notifies.find(
       (n) => n.level === "success" && /ready\.?$/i.test(n.msg),
     );
     assert.equal(successReady, undefined, "must not announce 'ready' when DB row missing");
 
-    // When CONTEXT.md is on disk the R3b path recovers: it inserts a placeholder
-    // "queued" row (so Gate 1b can retry gsd_plan_milestone) and emits a warning.
     const recovered = getMilestone("M001");
     assert.ok(recovered, "R3b recovery must insert a placeholder 'queued' DB row");
     assert.equal(recovered!.status, "queued", "placeholder row must have status 'queued'");
 
-    const warnNotify = cap.notifies.find((n) => n.level === "warning");
-    assert.ok(warnNotify, "must emit a warning notify during R3b recovery");
-    assert.match(warnNotify!.msg, /M001/, "warning must mention the milestone id");
-    assert.match(warnNotify!.msg, /recovering/i, "warning must mention recovery");
+    assert.equal(
+      cap.notifies.some(n => n.level === "warning"),
+      false,
+      "successful missing-row repair must not warn the user",
+    );
+    assert.deepEqual(cap.notifies, [
+      {
+        msg: "Milestone M001 context captured. Continuing the planning pipeline.",
+        level: "success",
+      },
+    ]);
   });
 
-  test("announces 'ready' when DB row exists", () => {
+  test("announces 'ready' when DB row has executable slices", () => {
     base = mkBase();
     openDatabase(":memory:");
     insertMilestone({ id: "M001", title: "Ready Guard Test", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Executable Slice",
+      status: "pending",
+    });
 
     cap = mkCapture();
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
+      startAuto: false,
       ctx: mkCtx(cap),
       pi: mkPi(cap),
     });

package/src/resources/extensions/gsd/tests/commands-dispatcher-unmerged-milestone.test.ts

@@ -9,6 +9,7 @@ import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { handleGSDCommand } from "../commands/dispatcher.ts";
 import {
   closeDatabase,
+  insertAssessment,
   insertMilestone,
   insertSlice,
   openDatabase,
@@ -106,6 +107,13 @@ function seedRegisteredCompletedWorktreeWithoutRoadmap(base: string): void {
     title: "Live Text Search",
     status: "complete",
   });
+  insertAssessment({
+    path: "milestones/M008/M008-VALIDATION.md",
+    milestoneId: "M008",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
   writeFileSync(
     join(base, ".gsd", "PREFERENCES.md"),
     "---\ngit:\n  isolation: worktree\n---\n",
@@ -124,6 +132,19 @@ function seedRegisteredCompletedWorktree(base: string): void {
   mkdirSync(join(base, ".gsd"), { recursive: true });
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M008", title: "Live Text Search", status: "complete" });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M008",
+    title: "Live Text Search",
+    status: "complete",
+  });
+  insertAssessment({
+    path: "milestones/M008/M008-VALIDATION.md",
+    milestoneId: "M008",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
   writeWorktreePreferencesAndRoadmap(base);
 
   const worktreePath = join(base, ".gsd", "worktrees", "M008");

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

@@ -14,7 +14,7 @@ import { execFileSync } from "node:child_process";
 
 import { DISPATCH_RULES, resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
 import { AutoSession } from "../auto/session.ts";
-import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
+import { closeDatabase, insertAssessment, insertGateRow, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 
 function makeBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-complete-dispatch-"));
@@ -225,6 +225,14 @@ describe("complete phase dispatch guard (#5683)", () => {
     base = makeBase();
     openDatabase(join(base, ".gsd", "gsd.db"));
     insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Done", status: "complete" });
+    insertAssessment({
+      path: "milestones/M001/M001-VALIDATION.md",
+      milestoneId: "M001",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
 
     const ctx = buildDispatchCtx(base);
     ctx.state.phase = "complete";
@@ -234,6 +242,37 @@ describe("complete phase dispatch guard (#5683)", () => {
     assert.equal(result?.action, "stop");
     assert.equal(result?.reason, "All milestones complete.");
   });
+
+  test("blocks terminal stop when closed milestone still has pending gates", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Done", status: "complete" });
+    insertAssessment({
+      path: "milestones/M001/M001-VALIDATION.md",
+      milestoneId: "M001",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
+    insertGateRow({
+      milestoneId: "M001",
+      sliceId: "S01",
+      gateId: "Q3",
+      scope: "slice",
+      status: "pending",
+    });
+
+    const ctx = buildDispatchCtx(base);
+    ctx.state.phase = "complete";
+
+    const result = await rule.match(ctx);
+
+    assert.equal(result?.action, "stop");
+    assert.equal(result?.level, "warning");
+    assert.match(result?.reason ?? "", /closeout-consistency-blocked/);
+    assert.match(result?.reason ?? "", /quality gate Q3 is still pending/);
+  });
 });
 
 describe("complete milestone context recovery guard (#5831)", () => {

package/src/resources/extensions/gsd/tests/gate-1b-orphan-discrimination.test.ts

@@ -1,12 +1,9 @@
 /**
- * gsd-pi / guided-flow — regression tests for Gate 1b orphan discrimination
+ * gsd-pi / guided-flow — regression tests for Gate 1b discussion handoff
  *
- * Gate 1b in checkAutoStartAfterDiscuss discriminates between two "queued" states:
- *   (a) plan-blocked: discuss completed (CONTEXT.md on disk), but gsd_plan_milestone
- *       was hard-blocked by the depth-verification gate.  DB row stuck at "queued".
- *       → emit recovery hint directing the LLM to retry gsd_plan_milestone.
- *   (b) discuss-incomplete: discuss did not finish, no CONTEXT.md, DB row "queued".
- *       → silent block (no recovery hint).
+ * Gate 1b treats queued + pinned CONTEXT.md as Discussion Complete, Planning
+ * Pending. It must accept the handoff without warning the user or injecting a
+ * hidden gsd_plan_milestone retry.
  */
 
 import { describe, test, beforeEach, afterEach } from "node:test";
@@ -27,8 +24,6 @@ import {
   insertMilestone,
 } from "../gsd-db.ts";
 
-// ─── Harness ───────────────────────────────────────────────────────────────
-
 interface MockCapture {
   notifies: Array<{ msg: string; level: string }>;
   messages: Array<{ payload: any; options: any }>;
@@ -58,24 +53,26 @@ function mkPi(cap: MockCapture): any {
   };
 }
 
-/**
- * Create a minimal temp tree with a .gsd/milestones/M001 directory.
- */
 function mkBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-gate1b-"));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
   return base;
 }
 
-// ─── Tests ─────────────────────────────────────────────────────────────────
+function writeContext(base: string): void {
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001: Test Milestone\n\nContext written by discuss phase.\n",
+  );
+}
 
-describe("Gate 1b orphan discrimination in checkAutoStartAfterDiscuss", () => {
+describe("Gate 1b discussion handoff in checkAutoStartAfterDiscuss", () => {
   let base: string;
   let cap: MockCapture;
 
   beforeEach(() => {
     clearPendingAutoStart();
-    drainLogs(); // discard noise from prior tests
+    drainLogs();
   });
 
   afterEach(() => {
@@ -86,104 +83,59 @@ describe("Gate 1b orphan discrimination in checkAutoStartAfterDiscuss", () => {
     }
   });
 
-  test("plan-blocked: CONTEXT.md present + DB row queued → returns false + recovery hint emitted", () => {
+  test("queued row + CONTEXT.md accepts context-captured handoff without hidden retry", () => {
     base = mkBase();
     openDatabase(":memory:");
-
-    // DB row exists with status "queued" (plan_milestone was blocked)
     insertMilestone({ id: "M001", title: "Test Milestone", status: "queued" });
-
-    // CONTEXT.md on disk (discuss phase completed)
-    writeFileSync(
-      join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
-      "# M001: Test Milestone\n\nContext written by discuss phase.\n",
-    );
+    writeContext(base);
 
     cap = mkCapture();
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
+      startAuto: false,
       ctx: mkCtx(cap),
       pi: mkPi(cap),
     });
 
     const result = checkAutoStartAfterDiscuss();
 
-    // Must return false — auto-start should not proceed
-    assert.equal(result, false, "checkAutoStartAfterDiscuss must return false (plan still blocked)");
-
-    // Recovery hint must be sent to the LLM
-    assert.equal(
-      cap.messages.length,
-      1,
-      "exactly one sendMessage call expected for the recovery hint",
-    );
-    assert.equal(
-      cap.messages[0].payload.customType,
-      "gsd-plan-milestone-blocked-recovery",
-      "recovery message must have customType gsd-plan-milestone-blocked-recovery",
-    );
+    assert.equal(result, true, "queued + context is a valid planning-pending handoff");
+    assert.equal(cap.messages.length, 0, "must not inject a hidden recovery turn");
+    assert.equal(cap.notifies.length, 1, "must emit one success notification");
+    assert.deepEqual(cap.notifies[0], {
+      msg: "Milestone M001 context captured. Continuing the planning pipeline.",
+      level: "success",
+    });
     assert.equal(
-      cap.messages[0].options.triggerTurn,
-      true,
-      "recovery message must set triggerTurn: true",
-    );
-    assert.match(
-      cap.messages[0].payload.content,
-      /gsd_plan_milestone/,
-      "recovery message content must mention gsd_plan_milestone",
+      cap.notifies.some(n => /queued|gsd_plan_milestone/i.test(n.msg)),
+      false,
+      "user-visible copy must not mention queued state or internal plan tool retry",
     );
-
-    // User must be notified via ctx.ui.notify
-    assert.ok(
-      cap.notifies.some((n) => n.level === "warning" && /queued/.test(n.msg)),
-      "user must be notified with a warning about the queued state",
-    );
-
-    // logWarning must have recorded the Gate 1b event
-    const logs = drainLogs();
-    const gate1bLog = logs.find(
-      (e) => e.component === "guided" && /Gate 1b/.test(e.message),
-    );
-    assert.ok(gate1bLog, "Gate 1b warning must be logged via logWarning");
   });
 
-  test("discuss-incomplete: no CONTEXT.md + DB row queued → returns false silently (no recovery hint)", () => {
+  test("queued row without CONTEXT.md still waits silently for discussion output", () => {
     base = mkBase();
     openDatabase(":memory:");
-
-    // DB row exists with status "queued", but NO CONTEXT.md on disk
     insertMilestone({ id: "M001", title: "Test Milestone", status: "queued" });
 
-    // No CONTEXT.md written — discuss phase is incomplete
     cap = mkCapture();
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
+      startAuto: false,
       ctx: mkCtx(cap),
       pi: mkPi(cap),
     });
 
-    drainLogs(); // clear any noise before the call
+    drainLogs();
 
     const result = checkAutoStartAfterDiscuss();
 
-    // Must return false — silent block
-    assert.equal(result, false, "checkAutoStartAfterDiscuss must return false when discuss is incomplete");
-
-    // No recovery hint — Gate 1 blocks before Gate 1b is reached
-    assert.equal(
-      cap.messages.length,
-      0,
-      "no sendMessage calls expected when CONTEXT.md is absent",
-    );
-    assert.equal(
-      cap.notifies.length,
-      0,
-      "no user notifications expected for discuss-incomplete case",
-    );
+    assert.equal(result, false, "must keep waiting while discuss has not written context");
+    assert.equal(cap.messages.length, 0, "no hidden recovery turn expected");
+    assert.equal(cap.notifies.length, 0, "no user notifications expected");
 
-    // No Gate 1b log entry
     const logs = drainLogs();
     const gate1bLog = logs.find(
       (e) => e.component === "guided" && /Gate 1b/.test(e.message),

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/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();
 }

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

@@ -11,6 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { extractUatType } from '../../files.ts';
 import { resolveSliceFile } from '../../paths.ts';
 import { buildRunUatPrompt, checkNeedsRunUat } from '../../auto-prompts.ts';
+import { buildRunUatResultPresentation, RUN_UAT_TOOL_PRESENTATION_PLAN_ID } from '../../tool-presentation-plan.ts';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const worktreePromptsDir = join(__dirname, '../..', 'prompts');
@@ -20,6 +21,8 @@ function loadPromptFromWorktree(name: string, vars: Record<string, string> = {})
   let content = readFileSync(path, 'utf-8');
   const effectiveVars = {
     skillActivation: 'If no installed skill clearly matches this unit, skip explicit skill activation and continue with the required workflow.',
+    canonicalPresentation: JSON.stringify(buildRunUatResultPresentation(), null, 2),
+    toolPresentationPlanId: RUN_UAT_TOOL_PRESENTATION_PLAN_ID,
     ...vars,
   };
   for (const [key, value] of Object.entries(effectiveVars)) {

package/src/resources/extensions/gsd/tests/merge-closeout-consistency-gate.test.ts

@@ -0,0 +1,63 @@
+// Project/App: gsd-pi
+// File Purpose: Regression tests for DB-backed closeout consistency before merge.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function createRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "merge-closeout-gate-")));
+  git(["init"], dir);
+  git(["config", "user.email", "test@test.com"], dir);
+  git(["config", "user.name", "Test"], dir);
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  git(["add", "."], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+
+  git(["checkout", "-b", "milestone/M001"], dir);
+  writeFileSync(join(dir, "feature.ts"), "export const feature = true;\n");
+  git(["add", "feature.ts"], dir);
+  git(["commit", "-m", "feat: milestone work"], dir);
+  git(["checkout", "main"], dir);
+  return dir;
+}
+
+test("mergeMilestoneToMain blocks when project DB closeout is still open", () => {
+  const savedCwd = process.cwd();
+  const repo = createRepo();
+  try {
+    assert.equal(openDatabase(join(repo, ".gsd", "gsd.db")), true);
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+
+    const mainHeadBefore = git(["rev-parse", "main"], repo);
+    process.chdir(repo);
+
+    assert.throws(
+      () => mergeMilestoneToMain(repo, "M001", "# M001\n- [x] **S01: Done**\n"),
+      /closeout-consistency-blocked/,
+    );
+
+    assert.equal(git(["rev-parse", "main"], repo), mainHeadBefore);
+    assert.equal(git(["branch", "--show-current"], repo), "main");
+  } finally {
+    closeDatabase();
+    process.chdir(savedCwd);
+    if (existsSync(repo)) rmSync(repo, { recursive: true, force: true });
+  }
+});