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

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

@@ -1558,6 +1558,14 @@ test("verifyExpectedArtifact complete-milestone passes when DB milestone is comp
 
     openDatabase(join(base, ".gsd", "gsd.db"));
     insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+    insertAssessment({
+      path: "milestones/M001/M001-VALIDATION.md",
+      milestoneId: "M001",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
 
     const result = verifyExpectedArtifact("complete-milestone", "M001", base);
     assert.equal(result, true, "complete-milestone should pass when DB status is complete");
@@ -1566,7 +1574,7 @@ test("verifyExpectedArtifact complete-milestone passes when DB milestone is comp
   }
 });
 
-test("verifyExpectedArtifact complete-milestone tolerates transient DB lag when SUMMARY is canonical success (#4658)", () => {
+test("verifyExpectedArtifact complete-milestone rejects success SUMMARY when DB milestone is still open (#4658)", () => {
   const base = makeGitBase();
   try {
     execFileSync("git", ["checkout", "-b", "feat/ms-db-lag-success"], { cwd: base, stdio: "ignore" });
@@ -1591,7 +1599,7 @@ test("verifyExpectedArtifact complete-milestone tolerates transient DB lag when
     insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
 
     const result = verifyExpectedArtifact("complete-milestone", "M001", base);
-    assert.equal(result, true, "canonical success SUMMARY should pass verification during transient DB lag");
+    assert.equal(result, false, "success SUMMARY must not overrule an open DB milestone");
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/auto-start-bootstrap-await-3420.test.ts

@@ -30,6 +30,7 @@ test("checkAutoStartAfterDiscuss waits until discussion artifacts exist before r
   setPendingAutoStart(base, {
     basePath: base,
     milestoneId: "M001",
+    startAuto: false,
     ctx: { ui: { notify: (message: string) => notifications.push(message) } } as any,
     pi: { sendMessage: () => {} } as any,
   });
@@ -41,5 +42,7 @@ test("checkAutoStartAfterDiscuss waits until discussion artifacts exist before r
   writeFileSync(join(base, ".gsd", "STATE.md"), "# State\n", "utf-8");
 
   assert.equal(checkAutoStartAfterDiscuss(), true);
-  assert.deepEqual(notifications, ["Milestone M001 ready."]);
+  assert.deepEqual(notifications, [
+    "Milestone M001 context captured. Continuing the planning pipeline.",
+  ]);
 });

package/src/resources/extensions/gsd/tests/auto-start-orphan-bootstrap.test.ts

@@ -118,6 +118,37 @@ function makeRepoWithMultipleStrandedMilestones(): string {
   return base;
 }
 
+function makeRepoWithActiveMismatchAndStrandedTarget(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-targeted-stranded-bootstrap-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M002"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\ngit:\n  isolation: \"worktree\"\n---\n",
+  );
+  runGit(base, ["init"]);
+  runGit(base, ["config", "user.email", "test@test.com"]);
+  runGit(base, ["config", "user.name", "Test"]);
+  writeFileSync(join(base, "README.md"), "# test\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "init"]);
+  runGit(base, ["branch", "-M", "main"]);
+
+  runGit(base, ["checkout", "-b", "milestone/M002"]);
+  writeFileSync(join(base, "m002.txt"), "target stranded work\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "feat: M002 in progress"]);
+  runGit(base, ["checkout", "main"]);
+  runGit(base, ["worktree", "add", ".gsd/worktrees/M002", "milestone/M002"]);
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Incorrect active milestone", status: "active" });
+  insertMilestone({ id: "M002", title: "Target stranded milestone", status: "active" });
+  closeDatabase();
+
+  return base;
+}
+
 function makeRepoWithRecoveredCleanupAndStrandedMismatch(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-headless-stranded-bootstrap-"));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
@@ -321,6 +352,9 @@ test("headless bootstrap checks stranded work before recovered-complete shortcut
     const messages = notifications.map((entry) => entry.message).join("\n");
     assert.equal(ready, false);
     assert.match(messages, /Stranded work for M002 blocks auto-mode/);
+    assert.match(messages, /\/gsd auto M002/);
+    assert.match(messages, /\/gsd park M002 "reason"/);
+    assert.match(messages, /\/gsd rethink/);
     assert.doesNotMatch(messages, /all milestones complete/);
   } finally {
     if (previousHeadless === undefined) {
@@ -409,6 +443,9 @@ test("bootstrap blocks active stranded recovery when another open milestone also
     assert.equal(ready, false);
     assert.deepEqual(adoptCalls, []);
     assert.match(messages, /Stranded work for M002 blocks auto-mode before M001/);
+    assert.match(messages, /\/gsd auto M002/);
+    assert.match(messages, /\/gsd park M002 "reason"/);
+    assert.match(messages, /explicitly discard M002/);
   } finally {
     try {
       closeDatabase();
@@ -418,6 +455,102 @@ test("bootstrap blocks active stranded recovery when another open milestone also
   }
 });
 
+test("bootstrap honors explicit solo milestone lock when recovering stranded target worktree", async () => {
+  const base = makeRepoWithActiveMismatchAndStrandedTarget();
+  const previousCwd = process.cwd();
+  const previousLock = process.env.GSD_MILESTONE_LOCK;
+  const previousWorker = process.env.GSD_PARALLEL_WORKER;
+  const s = new AutoSession();
+  const adoptCalls: Array<{ milestoneId: string; mode: string }> = [];
+  const notifications: Array<{ message: string; level?: string }> = [];
+
+  try {
+    delete process.env.GSD_PARALLEL_WORKER;
+    process.env.GSD_MILESTONE_LOCK = "M002";
+
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(notifications) as any,
+      {
+        getThinkingLevel: () => "medium",
+        getActiveTools: () => [],
+        events: { emit: () => {} },
+      } as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
+        lockBase: () => base,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+          enterMilestone: () => ({ ok: true, mode: "worktree", path: base }),
+          adoptStrandedMilestone: (
+            milestoneId: string,
+            sessionBase: string,
+            _ctx: unknown,
+            opts: { mode: "worktree" | "branch" },
+          ) => {
+            adoptCalls.push({ milestoneId, mode: opts.mode });
+            s.basePath = sessionBase;
+            s.originalBasePath = sessionBase;
+            s.strandedRecoveryIsolationMode = opts.mode;
+            return { ok: true, mode: opts.mode, path: sessionBase };
+          },
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
+        }) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    const messages = notifications.map((entry) => entry.message).join("\n");
+    assert.equal(ready, true);
+    assert.deepEqual(adoptCalls, [{ milestoneId: "M002", mode: "worktree" }]);
+    assert.equal(s.currentMilestoneId, "M002");
+    assert.match(messages, /Resuming saved milestone work for M002/);
+    assert.doesNotMatch(messages, /blocks auto-mode before M001/);
+    assert.doesNotMatch(messages, /Stranded work for in-progress milestone M002/);
+    assert.ok(
+      notifications.some((entry) => entry.level === "info" && entry.message.includes("Resuming saved milestone work for M002")),
+      "active recovery should be presented as an info-level resume",
+    );
+  } finally {
+    if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
+    else process.env.GSD_MILESTONE_LOCK = previousLock;
+    if (previousWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
+    else process.env.GSD_PARALLEL_WORKER = previousWorker;
+    try {
+      closeDatabase();
+    } catch {}
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("bootstrap adopts stranded active branch even when isolation is none", async () => {
   const base = makeRepoWithStrandedActiveMilestone();
   const previousCwd = process.cwd();
@@ -496,7 +629,11 @@ test("bootstrap adopts stranded active branch even when isolation is none", asyn
     assert.equal(s.strandedRecoveryIsolationMode, "branch");
     assert.match(
       notifications.map((entry) => entry.message).join("\n"),
-      /Recovering stranded work for M001/,
+      /Resuming saved milestone work for M001/,
+    );
+    assert.ok(
+      notifications.every((entry) => entry.level !== "warning" || !entry.message.includes("Stranded work for in-progress milestone M001")),
+      "adopting the active milestone should not emit a scary stranded-work warning",
     );
   } finally {
     try {
@@ -585,7 +722,11 @@ test("bootstrap adopts stranded active branch before deep project setup", async
     assert.equal(s.strandedRecoveryIsolationMode, "branch");
     assert.match(
       notifications.map((entry) => entry.message).join("\n"),
-      /Recovering stranded work for M001/,
+      /Resuming saved milestone work for M001/,
+    );
+    assert.ok(
+      notifications.every((entry) => entry.level !== "warning" || !entry.message.includes("Stranded work for in-progress milestone M001")),
+      "adopting the active milestone should not emit a scary stranded-work warning",
     );
   } finally {
     try {

package/src/resources/extensions/gsd/tests/auto-start-project-milestone-reconcile.test.ts

@@ -4,13 +4,35 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { closeDatabase, getAllMilestones, insertMilestone, isDbAvailable, openDatabase } from "../gsd-db.ts";
-import { reconcileProjectMilestonesFromDisk } from "../auto-start.ts";
+import { closeDatabase, getAllMilestones, getMilestone, insertMilestone, isDbAvailable, openDatabase } from "../gsd-db.ts";
+import { reconcileMergedMilestonesFromJournal, reconcileProjectMilestonesFromDisk } from "../auto-start.ts";
+import { emitWorktreeMerged } from "../worktree-telemetry.ts";
 
 test.afterEach(() => {
   if (isDbAvailable()) closeDatabase();
 });
 
+test("bootstrap reconciliation treats a successful worktree merge as milestone closed", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-merged-reconcile-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Merged Milestone", status: "active" });
+
+    emitWorktreeMerged(base, "M001", { reason: "milestone-complete", conflict: false });
+
+    const closed = reconcileMergedMilestonesFromJournal(base);
+    const row = getMilestone("M001");
+
+    assert.equal(closed, 1);
+    assert.equal(row?.status, "complete");
+    assert.ok(row?.completed_at);
+  } finally {
+    if (isDbAvailable()) closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("#5389: bootstrap reconciles PROJECT.md milestones that are missing from DB", () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-project-reconcile-"));
   try {

package/src/resources/extensions/gsd/tests/auto-warning-noise-regression.test.ts

@@ -92,13 +92,23 @@ test("checkAutoStartAfterDiscuss completes when discussion manifest is absent",
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
-      ctx: { ui: { notify: (message: string, level: string) => notifications.push({ message, level }) } } as any,
+      startAuto: false,
+      ctx: {
+        ui: {
+          notify: (message: string, level: string) => notifications.push({ message, level }),
+        },
+      } as any,
       pi: { sendMessage: () => { scheduled = true; } } as any,
     });
 
     assert.equal(checkAutoStartAfterDiscuss(), true);
     assert.equal(scheduled, false);
-    assert.deepEqual(notifications, [{ message: "Milestone M001 ready.", level: "success" }]);
+    assert.deepEqual(notifications, [
+      {
+        message: "Milestone M001 context captured. Continuing the planning pipeline.",
+        level: "success",
+      },
+    ]);
   } finally {
     clearPendingAutoStart(base);
     rmSync(base, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/browser-evidence.test.ts

@@ -0,0 +1,142 @@
+// Project/App: gsd-pi
+// File Purpose: Unit tests for hasBrowserRequiredText heading-depth section guard.
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { hasBrowserRequiredText } from '../browser-evidence.ts';
+
+describe('hasBrowserRequiredText', () => {
+  test('detects browser requirement in a plain test-cases section', () => {
+    const text = [
+      '## Test Cases',
+      '',
+      '1. Open index.html in a browser and navigate to /dashboard.',
+      '',
+    ].join('\n');
+    assert.ok(hasBrowserRequiredText(text), 'plain browser step should be detected');
+  });
+
+  test('ignores browser mention under a top-level non-requirement heading', () => {
+    const text = [
+      '## Not Proven',
+      '',
+      '- Keyboard usability through a real browser.',
+      '- Browser console cleanliness.',
+      '',
+    ].join('\n');
+    assert.ok(!hasBrowserRequiredText(text), 'browser mention under "Not Proven" should be ignored');
+  });
+
+  test('sub-heading inside a non-requirement section does not re-enable detection', () => {
+    // BUG (pre-fix): ### sub-heading under ## Not Proven resets inNonRequirementSection
+    // to false, causing subsequent lines to be detected as browser requirements.
+    const text = [
+      '## Not Proven By This UAT',
+      '',
+      '- No live browser session was used.',
+      '',
+      '### Visual Checks',
+      '',
+      '- Browser visual polish deferred to next slice.',
+      '- Keyboard interaction in a real browser is not proven here.',
+      '',
+    ].join('\n');
+    assert.ok(
+      !hasBrowserRequiredText(text),
+      'sub-heading under a non-requirement section must not re-enable browser detection',
+    );
+  });
+
+  test('requirement-level heading after non-requirement section re-enables detection', () => {
+    const text = [
+      '## Not Proven',
+      '',
+      '- Browser polish deferred.',
+      '',
+      '## Test Cases',
+      '',
+      '1. Launch browser and open localhost.',
+      '',
+    ].join('\n');
+    assert.ok(
+      hasBrowserRequiredText(text),
+      'browser step under "Test Cases" (same depth as "Not Proven") must still be detected',
+    );
+  });
+
+  test('deferred sub-heading inside a requirement section scopes exclusion to its own block', () => {
+    const text = [
+      '## Test Cases',
+      '',
+      '1. Open browser at localhost.',
+      '',
+      '### Deferred: keyboard check',
+      '',
+      '- Keyboard UAT deferred to next slice.',
+      '',
+      '### Step 2: Verify DOM',
+      '',
+      '1. Navigate to /dashboard in the browser.',
+      '',
+    ].join('\n');
+    assert.ok(
+      hasBrowserRequiredText(text),
+      'browser step under "Step 2" sub-heading must be detected after a sibling "Deferred" sub-heading',
+    );
+  });
+
+  test('deferred sub-heading at same depth as test cases does not escape to parent', () => {
+    const text = [
+      '## Test Cases',
+      '',
+      '### Deferred: responsive layout',
+      '',
+      '- Responsive layout check is deferred to S02.',
+      '',
+    ].join('\n');
+    assert.ok(
+      !hasBrowserRequiredText(text),
+      'content under a "Deferred" sub-heading should be excluded from detection',
+    );
+  });
+
+  test('detects browser requirement written only in a heading', () => {
+    // Regression: the line-by-line scan previously skip-continued past headings,
+    // missing browser obligations expressed only in heading text.
+    const text = '## Open browser session at localhost\n';
+    assert.ok(hasBrowserRequiredText(text), 'browser requirement in heading text must be detected');
+  });
+
+  test('heading that opens a non-requirement section is not itself detected as a requirement', () => {
+    const text = '## Not Proven\n\n- Some note.\n';
+    assert.ok(
+      !hasBrowserRequiredText(text),
+      'a non-requirement section heading should not trigger browser detection',
+    );
+  });
+
+  test('returns false for empty text', () => {
+    assert.ok(!hasBrowserRequiredText(''), 'empty string returns false');
+  });
+
+  test('notes-for-tester heading with sub-headings stays non-requirement', () => {
+    const text = [
+      '## Notes for Tester',
+      '',
+      '### Browser Setup',
+      '',
+      '- Run this spec without a browser; a DOM harness is sufficient.',
+      '- Browser-based visual checks are deferred.',
+      '',
+      '### Follow-up Items',
+      '',
+      '- Track browser session evidence in S02.',
+      '',
+    ].join('\n');
+    assert.ok(
+      !hasBrowserRequiredText(text),
+      'sub-headings under "Notes for Tester" should not re-enable browser detection',
+    );
+  });
+});

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");