@opengsd/gsd-pi 1.1.1-dev.74e8dd1 → 1.1.1-dev.a5a2de8

package/src/resources/extensions/gsd/rule-types.ts

@@ -32,6 +32,8 @@ export interface RuleLifecycle {
   retry_on?: string;
   /** Max times this hook can fire for the same trigger unit. */
   max_cycles?: number;
+  /** Whether this hook is advisory or blocking. */
+  criticality?: PostUnitHookConfig["criticality"];
   /** Idempotency key pattern for this hook. */
   idempotency_key?: string;
 }

package/src/resources/extensions/gsd/state.ts

@@ -896,8 +896,8 @@ export async function deriveStateFromDb(
   }
 
   // ADR-011 Phase 2: pause-on-escalation takes precedence over dispatching the
-  // next task. `awaiting_review` tasks (continueWithDefault=true) are NOT
-  // surfaced here — they let the loop continue.
+  // next task. `awaiting_review` tasks (continueWithDefault=true) still pause
+  // here so silence is never treated as consent.
   //
   // We do NOT gate this on `phases.mid_execution_escalation` — creation of
   // new escalations is gated at the write site (tools/complete-task.ts:315),

package/src/resources/extensions/gsd/templates/plan.md

@@ -132,14 +132,16 @@
   Verify field rules:
   - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
   - MUST NOT use shell pipes, redirects, semicolons, backticks, command substitution, output trimming, or grep regex alternation with `|`
+  - For absence checks, use `! grep -q "pattern" file` or `! rg -q "pattern" file`; do not use `grep -c` or `rg -c` to assert zero matches because count commands exit 1 when they find zero matches
   - MUST NOT use inline `node -e` assertions for verification; put assertions in a real test file and run it with `node --test` or a package test script
   - For content/document tasks: verify file existence, section count, YAML validity, or word count
     NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
   - If no command can verify the output, write: "Manual review — file exists and is non-empty"
   - BAD: `python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5`
+  - BAD: `grep -c "old_api" src/index.ts`
   - BAD: "Sections 3.1 and 3.2 exist with exact formulas. Zero TBD/TODO."
   - GOOD: `python3 -m pytest tests/ -q --tb=short`
-  - GOOD: `node --test tests/verify-doc.test.js`, `grep -q "Required heading" doc.md`, `test -s doc.md`
+  - GOOD: `node --test tests/verify-doc.test.js`, `grep -q "Required heading" doc.md`, `! grep -q "old_api" src/index.ts`, `test -s doc.md`
 
   Integration closure rule:
   - At least one slice in any multi-boundary milestone should perform real composition/wiring, not just contract hardening

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

@@ -4,6 +4,7 @@ import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
+import { visibleWidth } from "@gsd/pi-tui";
 
 import {
   unitVerb,
@@ -57,6 +58,17 @@ function cleanup(dir: string): void {
   }
 }
 
+function assertLinesFit(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
+    );
+  }
+}
+
+type RenderableWidget = { render(width: number): string[]; invalidate(): void; dispose?: () => void };
+
 // ─── unitVerb ─────────────────────────────────────────────────────────────
 
 test("unitVerb maps known unit types to verbs", () => {
@@ -662,6 +674,95 @@ test("updateProgressWidget full mode keeps footer-owned signals out of auto deck
   assert.doesNotMatch(rendered, /\$/, "footer owns session cost display");
 });
 
+test("updateProgressWidget small mode renders the dense horizontal grid", (t) => {
+  const dir = makeTempDir("small-dense-grid");
+  const homeDir = makeTempDir("small-dense-grid-home");
+  const projectPrefsPath = join(dir, ".gsd", "preferences.md");
+  const globalPrefsPath = join(homeDir, ".gsd", "preferences.md");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  mkdirSync(join(homeDir, ".gsd"), { recursive: true });
+  writeFileSync(projectPrefsPath, "---\nversion: 1\nwidget_mode: full\n---\n", "utf-8");
+  writeFileSync(globalPrefsPath, "---\nversion: 1\nwidget_mode: full\n---\n", "utf-8");
+
+  const holder: { widget?: RenderableWidget } = {};
+
+  t.after(() => {
+    holder.widget?.dispose?.();
+    closeDatabase();
+    clearSliceProgressCache();
+    _resetWidgetModeForTests();
+    cleanup(dir);
+    cleanup(homeDir);
+  });
+
+  openDatabase(join(dir, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M004", title: "Budget Tracking", status: "active" });
+  insertSlice({ milestoneId: "M004", id: "S01", title: "Schema migration", status: "complete", sequence: 1 });
+  insertSlice({ milestoneId: "M004", id: "S02", title: "Expense add", status: "pending", sequence: 2 });
+  insertTask({ milestoneId: "M004", sliceId: "S01", id: "T01", title: "Add repeat column via idempotent ALTER TABLE", status: "complete" });
+  insertTask({ milestoneId: "M004", sliceId: "S01", id: "T02", title: "Backfill repeat metadata", status: "pending" });
+
+  _resetWidgetModeForTests();
+  setWidgetMode("small", projectPrefsPath, globalPrefsPath);
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setHeader() {},
+        setStatus() {},
+        setWidget(_key: string, factory: any) {
+          if (_key === "gsd-progress") {
+            holder.widget = factory(
+              { requestRender() {} },
+              { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+            );
+          }
+        },
+      },
+    } as any,
+    "execute-task",
+    "M004/S01/T02",
+    {
+      phase: "executing",
+      activeMilestone: { id: "M004", title: "Budget Tracking" },
+      activeSlice: { id: "S01", title: "Schema migration" },
+      activeTask: { id: "T02", title: "Backfill repeat metadata" },
+    } as any,
+    {
+      getAutoStartTime: () => Date.now() - 18_000,
+      isStepMode: () => false,
+      getCmdCtx: () => null,
+      getBasePath: () => dir,
+      isVerbose: () => false,
+      isSessionSwitching: () => false,
+      getCurrentDispatchedModelId: () => null,
+    },
+  );
+
+  assert.ok(holder.widget, "progress widget should be installed");
+  const widget = holder.widget;
+  const lines = widget.render(120);
+  const rendered = lines.join("\n");
+
+  assert.equal(lines.length, 4, `small widget should render as rule + two dense rows + rule:\n${rendered}`);
+  assert.match(rendered, /STATUS\s+.*AUTO\s+running/);
+  assert.match(rendered, /UNIT\s+M004\/S01\/T02/);
+  assert.match(rendered, /SPEND/);
+  assert.match(rendered, /TIME/);
+  assert.match(rendered, /PHASE\s+execute-task/);
+  assert.match(rendered, /WORK\s+T02: Backfill repeat m/);
+  assert.match(rendered, /TASK\s+2\/2/);
+  assert.match(rendered, /SLICE.*1\/2/);
+  assert.doesNotMatch(rendered, /\/gsd next|\/gsd status/);
+  assert.doesNotMatch(rendered, /dashboard|esc pause/);
+
+  for (const width of [40, 80, 120]) {
+    widget.invalidate();
+    assertLinesFit(widget.render(width), width);
+  }
+});
+
 test("updateProgressWidget shows provider-waiting state consistently for auto and next modes", (t) => {
   const dir = makeTempDir("auto-next-dashboard");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
@@ -720,14 +821,14 @@ test("updateProgressWidget shows provider-waiting state consistently for auto an
   const autoRendered = renderDashboard(false);
   const nextRendered = renderDashboard(true);
 
-  assert.match(autoRendered, /GSD\s+·\s+AUTO\s+·\s+running/);
-  assert.match(nextRendered, /GSD\s+·\s+NEXT\s+·\s+running/);
+  assert.match(autoRendered, /STATUS\s+.*AUTO\s+running/);
+  assert.match(nextRendered, /STATUS\s+.*NEXT\s+running/);
   assert.doesNotMatch(autoRendered.split("\n")[1] ?? "", /completing M003\/S01/);
   assert.doesNotMatch(nextRendered.split("\n")[1] ?? "", /completing M003\/S01/);
   assert.doesNotMatch(autoRendered, /waiting on provider.*Waiting on provider/i);
   assert.doesNotMatch(nextRendered, /waiting on provider.*Waiting on provider/i);
-  assert.match(autoRendered, /completing\s+M003\/S01/);
-  assert.match(nextRendered, /completing\s+M003\/S01/);
+  assert.match(autoRendered, /PHASE\s+complete-slice/);
+  assert.match(nextRendered, /PHASE\s+complete-slice/);
   assert.doesNotMatch(autoRendered, /Working/);
   assert.doesNotMatch(nextRendered, /Working/);
 });

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

@@ -574,6 +574,43 @@ test("completeActiveUnit allows a different next unit to advance", async () => {
   assert.deepEqual(second.unit, { unitType: "execute-task", unitId: "T02" });
 });
 
+test("completeActiveUnit guard survives an intervening advance and blocks X→Y→X re-dispatch", async () => {
+  // Regression test for issue #415: lastFinalizedUnitKey was wiped on every advance(),
+  // allowing completed units to be re-dispatched after any interleaving unit (X→Y→X).
+  let nextTaskId = "T01";
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        return { unitType: "execute-task", unitId: nextTaskId, reason: "ready", preconditions: [] };
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  // Step 1: advance X (T01)
+  const first = await orchestrator.advance();
+  assert.equal(first.kind, "advanced");
+  if (first.kind !== "advanced") throw new Error("expected first advance");
+
+  // Step 2: complete X (T01) — sets lastFinalizedUnitKey = 'execute-task:T01'
+  await orchestrator.completeActiveUnit(first.unit);
+
+  // Step 3: advance Y (T02) — must NOT clear lastFinalizedUnitKey
+  nextTaskId = "T02";
+  const second = await orchestrator.advance();
+  assert.equal(second.kind, "advanced");
+  if (second.kind !== "advanced") throw new Error("expected second advance (T02)");
+  assert.deepEqual(second.unit, { unitType: "execute-task", unitId: "T02" });
+
+  // Step 4: re-select X (T01) — must be blocked because T01 was finalized
+  nextTaskId = "T01";
+  const third = await orchestrator.advance();
+  assert.equal(third.kind, "blocked");
+  if (third.kind !== "blocked") throw new Error("expected X→Y→X re-dispatch to be blocked");
+  assert.equal(third.action, "stop");
+  assert.equal(third.reason, "state did not advance after finalized execute-task T01");
+});
+
 test("retryActiveUnit clears in-flight idempotency without marking the unit finalized", async () => {
   const { deps, calls } = makeDeps();
   const orchestrator = createAutoOrchestrator(deps);

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