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

package/src/resources/extensions/gsd/tests/commands-dispatcher-validation-block.test.ts

@@ -40,10 +40,12 @@ function makeMockCtx(base: string): {
   calls: NotifyCall[];
   widgets: Array<[string, unknown]>;
   statuses: Array<[string, string | undefined]>;
+  newSessions: Array<{ workspaceRoot?: string }>;
 } {
   const calls: NotifyCall[] = [];
   const widgets: Array<[string, unknown]> = [];
   const statuses: Array<[string, string | undefined]> = [];
+  const newSessions: Array<{ workspaceRoot?: string }> = [];
   return {
     ctx: {
       cwd: base,
@@ -58,10 +60,15 @@ function makeMockCtx(base: string): {
           statuses.push([key, value]);
         },
       },
+      newSession: async (options?: { workspaceRoot?: string }) => {
+        newSessions.push(options ?? {});
+        return { cancelled: false };
+      },
     },
     calls,
     widgets,
     statuses,
+    newSessions,
   };
 }
 
@@ -77,7 +84,10 @@ function makeMockPi(): { pi: any; messages: SentMessage[] } {
   };
 }
 
-function seedValidationBlockedMilestone(base: string): void {
+function seedValidationBlockedMilestone(
+  base: string,
+  status: "needs-attention" | "needs-remediation" = "needs-attention",
+): void {
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M006", title: "Mark All Complete", status: "active" });
   insertSlice({
@@ -91,9 +101,9 @@ function seedValidationBlockedMilestone(base: string): void {
   insertAssessment({
     path: "milestones/M006/M006-VALIDATION.md",
     milestoneId: "M006",
-    status: "needs-attention",
+    status,
     scope: "milestone-validation",
-    fullContent: "verdict: needs-attention",
+    fullContent: `verdict: ${status}`,
   });
   invalidateStateCache();
 }
@@ -155,6 +165,31 @@ test("dispatcher blocks workflow-advancing aliases while validation is blocked",
   }
 });
 
+test("dispatcher allows reassess dispatch while validation needs remediation", async () => {
+  const base = makeBase();
+  try {
+    seedValidationBlockedMilestone(base, "needs-remediation");
+    const { ctx, calls, newSessions } = makeMockCtx(base);
+    const { pi, messages } = makeMockPi();
+
+    await handleGSDCommand("dispatch reassess", ctx, pi);
+
+    assert.equal(messages.length, 1);
+    assert.equal(messages[0].customType, "gsd-dispatch");
+    assert.equal(messages[0].display, false);
+    assert.match(messages[0].content, /UNIT: Reassess Roadmap/);
+    assert.ok(
+      calls.some((call) => call.kind === "info" && /Dispatching reassess-roadmap for M006\/S01/.test(call.message)),
+      `expected reassess dispatch notification, got: ${JSON.stringify(calls)}`,
+    );
+    assert.deepEqual(newSessions, [{ workspaceRoot: base }]);
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
 test("dispatcher still allows recovery commands while validation is blocked", async () => {
   const base = makeBase();
   try {

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

@@ -399,8 +399,12 @@ test("handleVerdict needs-remediation override with --rationale rewrites verdict
     assert.match(rewritten, /found missing slice/);
 
     assert.ok(
-      calls.some((c) => /gsd_reassess_roadmap/.test(c.message)),
-      "needs-remediation override should suggest gsd_reassess_roadmap follow-up",
+      calls.some((c) => /\/gsd dispatch reassess/.test(c.message)),
+      "needs-remediation override should suggest the reassess dispatch follow-up",
+    );
+    assert.ok(
+      calls.every((c) => !/gsd_reassess_roadmap/.test(c.message)),
+      "needs-remediation override should not expose the internal tool name",
     );
   } finally {
     closeDatabase();

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

@@ -12,6 +12,7 @@ import { tmpdir } from "node:os";
 
 import { buildSliceSummaryExcerpt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt } from "../auto-prompts.ts";
 import { invalidateAllCaches } from "../cache.ts";
+import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
 
 // ─── Fixture helpers ──────────────────────────────────────────────────────
 
@@ -364,3 +365,32 @@ test("validate-milestone prompt uses slice excerpts and on-demand paths instead
     "validate prompt must not inline full assessment traces",
   );
 });
+
+test("validate-milestone prompt inlines planned verification classes as canonical rows", async (t) => {
+  const base = createBase();
+  t.after(() => {
+    try { closeDatabase(); } catch { /* ignore */ }
+    cleanup(base);
+  });
+  invalidateAllCaches();
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({
+    id: "M001",
+    planning: {
+      verificationContract: "Local command exits 0.",
+      verificationOperational: "No long-running child process remains.",
+    },
+  });
+  writeRoadmap(base, makeRoadmap());
+  writeSummary(base, "S01", makeFatSummary("S01"));
+  writeSummary(base, "S02", makeFatSummary("S02"));
+
+  const prompt = await buildValidateMilestonePrompt("M001", "Test Milestone", base);
+
+  assert.match(prompt, /### Verification Classes \(from planning\)/);
+  assert.match(prompt, /Every row in this table must appear in `verificationClasses`/);
+  assert.match(prompt, /\| Class \| Planned Check \|/);
+  assert.match(prompt, /\| Contract \| Local command exits 0\. \|/);
+  assert.match(prompt, /\| Operational \| No long-running child process remains\. \|/);
+});

package/src/resources/extensions/gsd/tests/complete-slice-verification-gate.test.ts

@@ -20,6 +20,7 @@ import {
   insertMilestone,
   insertSlice,
   insertTask,
+  setSliceSummaryMd,
 } from '../gsd-db.ts';
 import { handleCompleteSlice } from '../tools/complete-slice.ts';
 import type { CompleteSliceParams } from '../types.ts';
@@ -153,4 +154,45 @@ describe('complete-slice verification gate (#3580)', () => {
       );
     }
   });
+
+  test('backfills prior verification narrative when verification is omitted on re-completion', async () => {
+    // Seed full_summary_md with a prior verification narrative (simulates a
+    // previous completion where the verification text was recorded).
+    const priorVerification = 'All 12 API integration tests pass — zero regressions detected.';
+    const priorSummary = [
+      '---',
+      'verification_result: passed',
+      '---',
+      '',
+      '# S01: Test Slice',
+      '',
+      '## What Happened',
+      '',
+      'narrative goes here',
+      '',
+      '## Verification',
+      '',
+      priorVerification,
+      '',
+      '## Requirements Advanced',
+      '',
+    ].join('\n');
+    setSliceSummaryMd('M001', 'S01', priorSummary, '');
+
+    // Complete slice without providing verification — handler must backfill
+    // from the existing summary rather than writing an empty section.
+    const result = await handleCompleteSlice(
+      makeParams({ verification: undefined }),
+      basePath,
+    );
+
+    assert.ok(!('error' in result), `expected success, got: ${'error' in result ? (result as { error: string }).error : ''}`);
+
+    const { summaryPath } = result as { summaryPath: string };
+    const written = fs.readFileSync(summaryPath, 'utf8');
+    assert.ok(
+      written.includes(priorVerification),
+      `prior verification narrative must be preserved when verification is omitted; got:\n${written}`,
+    );
+  });
 });

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

@@ -6,6 +6,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import { GSDDashboardOverlay } from "../dashboard-overlay.ts";
+import type { UnitMetrics } from "../metrics.ts";
 import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 const fakeTheme = {
@@ -23,3 +24,47 @@ test("GSDDashboardOverlay renders inside the shared full border", (t) => {
   assert.ok(lines.some((line) => line.startsWith("│")), "body rows should have side borders");
   assert.match(lines.at(-1) ?? "", /^╰─+╯$/);
 });
+
+test("GSDDashboardOverlay reuses metrics aggregations until the unit count changes", (t) => {
+  const overlay = new GSDDashboardOverlay({ requestRender() {} }, fakeTheme as any, () => {});
+  t.after(() => overlay.dispose());
+
+  const firstUnits = [makeUnit("M001/S001/T001", 0.25)];
+  const firstMetrics = (overlay as any).ensureMetricsCache(firstUnits);
+
+  overlay.invalidate();
+
+  const sameCountUnits = [makeUnit("M001/S001/T002", 0.5)];
+  const sameCountMetrics = (overlay as any).ensureMetricsCache(sameCountUnits);
+  assert.equal(sameCountMetrics, firstMetrics, "same unit count should reuse cached metrics");
+  assert.equal(sameCountMetrics.totals.cost, 0.25);
+
+  const increasedCountMetrics = (overlay as any).ensureMetricsCache([
+    ...sameCountUnits,
+    makeUnit("M001/S001/T003", 0.75),
+  ]);
+  assert.notEqual(increasedCountMetrics, firstMetrics, "changed unit count should recompute metrics");
+  assert.equal(increasedCountMetrics.totals.units, 2);
+  assert.equal(increasedCountMetrics.totals.cost, 1.25);
+});
+
+function makeUnit(id: string, cost: number): UnitMetrics {
+  return {
+    type: "execute-task",
+    id,
+    model: "claude-sonnet-4.5",
+    startedAt: 1000,
+    finishedAt: 2000,
+    tokens: {
+      input: 100,
+      output: 50,
+      cacheRead: 25,
+      cacheWrite: 10,
+      total: 185,
+    },
+    cost,
+    toolCalls: 1,
+    assistantMessages: 1,
+    userMessages: 1,
+  };
+}

package/src/resources/extensions/gsd/tests/deep-planning-mode-dispatch.test.ts

@@ -229,6 +229,24 @@ function makeIsolatedBaseWithCleanup(t: TestContext): string {
   return base;
 }
 
+function setGsdHeadless(t: TestContext): void {
+  const previous = process.env.GSD_HEADLESS;
+  process.env.GSD_HEADLESS = "1";
+  t.after(() => {
+    if (previous === undefined) delete process.env.GSD_HEADLESS;
+    else process.env.GSD_HEADLESS = previous;
+  });
+}
+
+function unsetGsdHeadless(t: TestContext): void {
+  const previous = process.env.GSD_HEADLESS;
+  delete process.env.GSD_HEADLESS;
+  t.after(() => {
+    if (previous === undefined) delete process.env.GSD_HEADLESS;
+    else process.env.GSD_HEADLESS = previous;
+  });
+}
+
 function writeValidProject(base: string): void {
   writeFileSync(join(base, ".gsd", "PROJECT.md"), VALID_PROJECT_MD);
 }
@@ -364,16 +382,33 @@ test("Deep mode: discuss-project does NOT dispatch when planning_depth is 'light
 test("Deep mode: discuss-project DOES dispatch when planning_depth is 'deep' and PROJECT.md missing", async (t) => {
   const base = makeIsolatedBaseWithCleanup(t);
 
+  unsetGsdHeadless(t);
+
   const prefs = { planning_depth: "deep" } as GSDPreferences;
   const result = await rule(PROJECT_RULE_NAME).match(makeCtx(base, prefs));
   assert.ok(result && result.action === "dispatch", "deep mode + missing PROJECT.md must dispatch");
   if (result.action === "dispatch") {
     assert.strictEqual(result.unitType, "discuss-project");
     assert.strictEqual(result.unitId, "PROJECT");
+    assert.strictEqual(result.pauseAfterDispatch, true);
     assert.ok(result.prompt.length > 0, "prompt must be non-empty");
   }
 });
 
+test("Deep mode: discuss-project does not pause when GSD_HEADLESS is set", async (t) => {
+  const base = makeIsolatedBaseWithCleanup(t);
+
+  setGsdHeadless(t);
+
+  const prefs = { planning_depth: "deep" } as GSDPreferences;
+  const result = await rule(PROJECT_RULE_NAME).match(makeCtx(base, prefs));
+  assert.ok(result && result.action === "dispatch", "deep mode + missing PROJECT.md must dispatch");
+  if (result.action === "dispatch") {
+    assert.strictEqual(result.unitType, "discuss-project");
+    assert.strictEqual(result.pauseAfterDispatch, false);
+  }
+});
+
 test("Deep mode: discuss-project does NOT dispatch when PROJECT.md already exists and is valid", async (t) => {
   const base = makeIsolatedBaseWithCleanup(t);
 
@@ -432,6 +467,8 @@ test("Deep mode: discuss-requirements does NOT dispatch when PROJECT.md missing
 test("Deep mode: discuss-requirements DOES dispatch when PROJECT.md exists and REQUIREMENTS.md missing", async (t) => {
   const base = makeIsolatedBaseWithCleanup(t);
 
+  unsetGsdHeadless(t);
+
   writeValidProject(base);
   const prefs = { planning_depth: "deep" } as GSDPreferences;
   const result = await rule(REQUIREMENTS_RULE_NAME).match(makeCtx(base, prefs));
@@ -439,6 +476,22 @@ test("Deep mode: discuss-requirements DOES dispatch when PROJECT.md exists and R
   if (result.action === "dispatch") {
     assert.strictEqual(result.unitType, "discuss-requirements");
     assert.strictEqual(result.unitId, "REQUIREMENTS");
+    assert.strictEqual(result.pauseAfterDispatch, true);
+  }
+});
+
+test("Deep mode: discuss-requirements does not pause when GSD_HEADLESS is set", async (t) => {
+  const base = makeIsolatedBaseWithCleanup(t);
+
+  setGsdHeadless(t);
+
+  writeValidProject(base);
+  const prefs = { planning_depth: "deep" } as GSDPreferences;
+  const result = await rule(REQUIREMENTS_RULE_NAME).match(makeCtx(base, prefs));
+  assert.ok(result && result.action === "dispatch", "deep mode + PROJECT.md present + REQUIREMENTS.md missing must dispatch");
+  if (result.action === "dispatch") {
+    assert.strictEqual(result.unitType, "discuss-requirements");
+    assert.strictEqual(result.pauseAfterDispatch, false);
   }
 });
 

package/src/resources/extensions/gsd/tests/derive-state-db.test.ts

@@ -868,6 +868,14 @@ describe('derive-state-db', async () => {
         dbState.blockers.some(b => b.includes('needs-remediation') && b.includes('M001')),
         'remediation-stuck-db: blocker message mentions milestone and verdict',
       );
+      assert.ok(
+        dbState.blockers.some(b => b.includes('/gsd dispatch reassess')),
+        'remediation-stuck-db: blocker message points users to the reassess command',
+      );
+      assert.ok(
+        dbState.blockers.every(b => !b.includes('gsd_reassess_roadmap')),
+        'remediation-stuck-db: blocker message does not expose the internal tool name',
+      );
 
       closeDatabase();
     } finally {

package/src/resources/extensions/gsd/tests/derive-state-helpers.test.ts

@@ -473,13 +473,13 @@ describe('derive-state-helpers', () => {
     }
   });
 
-	  test('getActiveMilestoneId: DB lock path ignores PARKED flag projection', async () => {
-	    const base = createFixtureBase();
-	    const previousLock = process.env.GSD_MILESTONE_LOCK;
-	    const previousWorker = process.env.GSD_PARALLEL_WORKER;
-	    try {
-	      process.env.GSD_MILESTONE_LOCK = 'M001';
-	      process.env.GSD_PARALLEL_WORKER = '1';
+  test('getActiveMilestoneId: DB lock path ignores PARKED flag projection', async () => {
+    const base = createFixtureBase();
+    const previousLock = process.env.GSD_MILESTONE_LOCK;
+    const previousWorker = process.env.GSD_PARALLEL_WORKER;
+    try {
+      process.env.GSD_MILESTONE_LOCK = 'M001';
+      process.env.GSD_PARALLEL_WORKER = '1';
       writeFile(base, 'milestones/M001/M001-PARKED.md', '# Parked on disk');
 
       openDatabase(':memory:');
@@ -487,12 +487,41 @@ describe('derive-state-helpers', () => {
 
       const id = await getActiveMilestoneId(base);
       assert.equal(id, 'M001', 'DB status remains authoritative despite PARKED projection');
-	    } 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;
-	      closeDatabase();
+    } 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;
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('deriveStateFromDb: solo milestone lock scopes state to the requested milestone', async () => {
+    const base = createFixtureBase();
+    const previousLock = process.env.GSD_MILESTONE_LOCK;
+    const previousWorker = process.env.GSD_PARALLEL_WORKER;
+    try {
+      delete process.env.GSD_PARALLEL_WORKER;
+      process.env.GSD_MILESTONE_LOCK = 'M002';
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Earlier', status: 'active' });
+      insertMilestone({ id: 'M002', title: 'Requested', status: 'active' });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+      const id = await getActiveMilestoneId(base);
+
+      assert.equal(state.activeMilestone?.id, 'M002', 'explicit lock chooses requested milestone');
+      assert.deepEqual(state.registry.map((entry) => entry.id), ['M002'], 'registry is scoped to requested milestone');
+      assert.equal(id, 'M002', 'active milestone helper honors solo lock');
+    } 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;
+      closeDatabase();
       cleanup(base);
     }
   });
@@ -526,6 +555,14 @@ describe('derive-state-helpers', () => {
         state.blockers.some(b => b.includes('needs-remediation') && b.includes('M001')),
         'remediation-stuck: blocker message mentions milestone and verdict',
       );
+      assert.ok(
+        state.blockers.some(b => b.includes('/gsd dispatch reassess')),
+        'remediation-stuck: blocker message points users to the reassess command',
+      );
+      assert.ok(
+        state.blockers.every(b => !b.includes('gsd_reassess_roadmap')),
+        'remediation-stuck: blocker message does not expose the internal tool name',
+      );
     } finally {
       closeDatabase();
       cleanup(base);

package/src/resources/extensions/gsd/tests/discuss-milestone-structured-questions.test.ts

@@ -44,14 +44,26 @@ function setGsdHeadless(t: { after: (fn: () => void) => void }): void {
   });
 }
 
+function unsetGsdHeadless(t: { after: (fn: () => void) => void }): void {
+  const previous = process.env.GSD_HEADLESS;
+  delete process.env.GSD_HEADLESS;
+  t.after(() => {
+    if (previous === undefined) delete process.env.GSD_HEADLESS;
+    else process.env.GSD_HEADLESS = previous;
+  });
+}
+
 test("auto-dispatch passes structuredQuestionsAvailable=true into discuss-milestone prompt", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-milestone-structured-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
+  unsetGsdHeadless(t);
+
   const result = await resolveDispatch(makeContext(tmp, "needs-discussion", "true"));
 
   assert.equal(result.action, "dispatch");
   assert.equal(result.unitType, "discuss-milestone");
+  assert.equal(result.pauseAfterDispatch, true);
   assert.match(
     result.prompt,
     /\*\*Structured questions available: true\*\*/,
@@ -62,10 +74,13 @@ test("auto-dispatch preserves structuredQuestionsAvailable=false for discuss-mil
   const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-milestone-plain-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
+  unsetGsdHeadless(t);
+
   const result = await resolveDispatch(makeContext(tmp, "pre-planning", "false"));
 
   assert.equal(result.action, "dispatch");
   assert.equal(result.unitType, "discuss-milestone");
+  assert.equal(result.pauseAfterDispatch, true);
   assert.match(
     result.prompt,
     /\*\*Structured questions available: false\*\*/,
@@ -82,6 +97,7 @@ test("auto-dispatch uses discuss-headless prompt when GSD_HEADLESS is set", asyn
 
   assert.equal(result.action, "dispatch");
   assert.equal(result.unitType, "discuss-milestone");
+  assert.equal(result.pauseAfterDispatch, false);
   assert.match(result.prompt, /This is a \*\*headless\*\* flow/);
   assert.doesNotMatch(result.prompt, /\*\*Structured questions available: true\*\*/);
 });
@@ -96,10 +112,24 @@ test("auto-dispatch uses discuss-headless prompt for needs-discussion when GSD_H
 
   assert.equal(result.action, "dispatch");
   assert.equal(result.unitType, "discuss-milestone");
+  assert.equal(result.pauseAfterDispatch, false);
   assert.match(result.prompt, /This is a \*\*headless\*\* flow/);
   assert.doesNotMatch(result.prompt, /\*\*Structured questions available: true\*\*/);
 });
 
+test("auto-dispatch pauses after execution-entry discuss-milestone recovery", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-milestone-executing-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  unsetGsdHeadless(t);
+
+  const result = await resolveDispatch(makeContext(tmp, "executing", "true"));
+
+  assert.equal(result.action, "dispatch");
+  assert.equal(result.unitType, "discuss-milestone");
+  assert.equal(result.pauseAfterDispatch, true);
+});
+
 test("auto-dispatch uses discuss-headless prompt for executing when GSD_HEADLESS is set", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-milestone-headless-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
@@ -110,6 +140,7 @@ test("auto-dispatch uses discuss-headless prompt for executing when GSD_HEADLESS
 
   assert.equal(result.action, "dispatch");
   assert.equal(result.unitType, "discuss-milestone");
+  assert.equal(result.pauseAfterDispatch, false);
   assert.match(result.prompt, /This is a \*\*headless\*\* flow/);
   assert.doesNotMatch(result.prompt, /\*\*Structured questions available: true\*\*/);
 });

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/dispatch-missing-task-plans.test.ts

@@ -19,6 +19,7 @@ import type { DispatchContext } from "../auto-dispatch.ts";
 import type { AutoSession } from "../auto/session.ts";
 import type { GSDState } from "../types.ts";
 import { enableDebug, disableDebug, getDebugLogPath } from "../debug-logger.ts";
+import { closeDatabase, insertMilestone, isDbAvailable, openDatabase } from "../gsd-db.ts";
 
 function makeState(overrides: Partial<GSDState> = {}): GSDState {
   return {
@@ -123,6 +124,29 @@ test("dispatch: missing task plan triggers plan-slice (not stop) — issue #909"
     `unitId should be M002/S03, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
 });
 
+test("dispatch: closed milestone is not implicitly recovered or reopened", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-closed-dispatch-"));
+  t.after(() => {
+    if (isDbAvailable()) closeDatabase();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  if (isDbAvailable()) closeDatabase();
+  mkdirSync(join(tmp, ".gsd"), { recursive: true });
+  openDatabase(join(tmp, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M002", title: "Closed Milestone", status: "complete" });
+  scaffoldMilestoneContext(tmp, "M002");
+  scaffoldSlicePlan(tmp, "M002", "S03");
+
+  const result = await resolveDispatch(makeContext(tmp));
+
+  assert.equal(result.action, "stop");
+  assert.ok(result.action === "stop");
+  assert.equal(result.level, "warning");
+  assert.match(result.reason, /Milestone M002 is closed/);
+  assert.match(result.reason, /will not reopen or recover it implicitly/);
+});
+
 test("dispatch: present task plan proceeds to execute-task normally", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-909-ok-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
@@ -141,6 +165,42 @@ test("dispatch: present task plan proceeds to execute-task normally", async (t)
     `unitId should be M002/S03/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
 });
 
+test("dispatch: session milestone mismatch stops before missing-task-plan recovery", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-session-milestone-mismatch-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const worktreeRoot = join(tmp, ".gsd", "worktrees", "M002");
+  mkdirSync(worktreeRoot, { recursive: true });
+
+  const ctx = makeContextFor(tmp, "M001", "S01", "T01", {
+    basePath: worktreeRoot,
+    originalBasePath: tmp,
+    currentMilestoneId: "M002",
+  });
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "stop");
+  assert.ok(result.action === "stop");
+  assert.equal(result.level, "warning");
+  assert.match(result.reason, /context mid "M001" does not match session\.currentMilestoneId "M002"/);
+});
+
+test("dispatch: worktree path mismatch stops before planning a different milestone", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-worktree-path-milestone-mismatch-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const worktreeRoot = join(tmp, ".gsd", "worktrees", "M002");
+  mkdirSync(worktreeRoot, { recursive: true });
+
+  const ctx = makeContextFor(worktreeRoot, "M001", "S01", "T01");
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "stop");
+  assert.ok(result.action === "stop");
+  assert.equal(result.level, "warning");
+  assert.match(result.reason, /context mid "M001" does not match basePath worktree "M002"/);
+});
+
 test("dispatch: executing recovery checks active milestone worktree task plans before re-dispatching plan-slice", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-6192-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));