gsd-pi 2.78.1-dev.b0759e59b → 2.78.1-dev.e9d88a536

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

@@ -1,12 +1,9 @@
-// GSD Extension — Tests for extracted deriveStateFromDb helper functions
+// GSD Extension — Tests for DB-authoritative deriveStateFromDb behavior
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 //
-// Tests the composable helpers extracted from deriveStateFromDb:
-//   reconcileDiskToDb, buildCompletenessSet, buildRegistryAndFindActive,
-//   handleNoActiveMilestone, resolveSliceDependencies, reconcileSliceTasks,
-//   detectBlockers, checkReplanTrigger, checkInterruptedWork
-//
-// Helpers are private — exercised through deriveStateFromDb integration.
+// Private helper behavior is exercised through deriveStateFromDb integration.
+// Markdown files in these tests are projections unless the DB row explicitly
+// makes them authoritative.
 
 import { describe, test, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
@@ -14,13 +11,16 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { invalidateStateCache, deriveStateFromDb } from '../state.ts';
+import { invalidateStateCache, deriveStateFromDb, getActiveMilestoneId } from '../state.ts';
 import {
   openDatabase,
   closeDatabase,
+  insertAssessment,
   insertMilestone,
+  insertRequirement,
   insertSlice,
   insertTask,
+  setMilestoneQueueOrder,
   updateTaskStatus,
 } from '../gsd-db.ts';
 
@@ -112,6 +112,20 @@ describe('derive-state-helpers', () => {
 
       openDatabase(':memory:');
       insertMilestone({ id: 'M001', title: 'First', status: 'complete' });
+      insertRequirement({
+        id: 'R001',
+        class: 'functional',
+        status: 'active',
+        description: 'Unmapped',
+        why: 'test',
+        source: 'test',
+        primary_owner: '',
+        supporting_slices: '',
+        validation: '',
+        notes: '',
+        full_content: '',
+        superseded_by: null,
+      });
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
@@ -126,10 +140,11 @@ describe('derive-state-helpers', () => {
   });
 
   // ─── resolveSliceDependencies: GSD_SLICE_LOCK with missing slice ────
-  test('resolveSliceDependencies: GSD_SLICE_LOCK pointing to non-existent slice returns blocked', async () => {
-    const base = createFixtureBase();
-    const origLock = process.env.GSD_SLICE_LOCK;
-    try {
+	  test('resolveSliceDependencies: GSD_SLICE_LOCK pointing to non-existent slice returns blocked', async () => {
+	    const base = createFixtureBase();
+	    const origLock = process.env.GSD_SLICE_LOCK;
+	    const origWorker = process.env.GSD_PARALLEL_WORKER;
+	    try {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/tasks/.gitkeep', '');
@@ -140,26 +155,30 @@ describe('derive-state-helpers', () => {
       insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First', status: 'active', risk: 'low', depends: [] });
       insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'First Task', status: 'pending' });
 
-      process.env.GSD_SLICE_LOCK = 'S99';
+	      process.env.GSD_SLICE_LOCK = 'S99';
+	      process.env.GSD_PARALLEL_WORKER = '1';
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
       assert.equal(state.phase, 'blocked', 'slice-lock-miss: phase is blocked');
       assert.ok(state.blockers.some(b => b.includes('GSD_SLICE_LOCK=S99')), 'slice-lock-miss: blocker mentions lock');
-    } finally {
-      if (origLock !== undefined) process.env.GSD_SLICE_LOCK = origLock;
-      else delete process.env.GSD_SLICE_LOCK;
-      closeDatabase();
+	    } finally {
+	      if (origLock !== undefined) process.env.GSD_SLICE_LOCK = origLock;
+	      else delete process.env.GSD_SLICE_LOCK;
+	      if (origWorker !== undefined) process.env.GSD_PARALLEL_WORKER = origWorker;
+	      else delete process.env.GSD_PARALLEL_WORKER;
+	      closeDatabase();
       cleanup(base);
     }
   });
 
   // ─── resolveSliceDependencies: GSD_SLICE_LOCK with valid slice ──────
-  test('resolveSliceDependencies: GSD_SLICE_LOCK targeting valid slice bypasses deps', async () => {
-    const base = createFixtureBase();
-    const origLock = process.env.GSD_SLICE_LOCK;
-    try {
+	  test('resolveSliceDependencies: GSD_SLICE_LOCK targeting valid slice bypasses deps', async () => {
+	    const base = createFixtureBase();
+	    const origLock = process.env.GSD_SLICE_LOCK;
+	    const origWorker = process.env.GSD_PARALLEL_WORKER;
+	    try {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
       // S02 depends on S01 but we lock to S02 directly
       writeFile(base, 'milestones/M001/slices/S02/S02-PLAN.md', `# S02\n\n**Goal:** Test.\n**Demo:** Pass.\n\n## Tasks\n\n- [ ] **T01: Task** \`est:5m\`\n  Do thing.\n`);
@@ -172,23 +191,26 @@ describe('derive-state-helpers', () => {
       insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second', status: 'pending', risk: 'low', depends: ['S01'] });
       insertTask({ id: 'T01', sliceId: 'S02', milestoneId: 'M001', title: 'Task', status: 'pending' });
 
-      process.env.GSD_SLICE_LOCK = 'S02';
+	      process.env.GSD_SLICE_LOCK = 'S02';
+	      process.env.GSD_PARALLEL_WORKER = '1';
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
       assert.equal(state.activeSlice?.id, 'S02', 'slice-lock-valid: activeSlice is S02 (locked)');
       assert.equal(state.phase, 'executing', 'slice-lock-valid: phase is executing');
-    } finally {
-      if (origLock !== undefined) process.env.GSD_SLICE_LOCK = origLock;
-      else delete process.env.GSD_SLICE_LOCK;
-      closeDatabase();
+	    } finally {
+	      if (origLock !== undefined) process.env.GSD_SLICE_LOCK = origLock;
+	      else delete process.env.GSD_SLICE_LOCK;
+	      if (origWorker !== undefined) process.env.GSD_PARALLEL_WORKER = origWorker;
+	      else delete process.env.GSD_PARALLEL_WORKER;
+	      closeDatabase();
       cleanup(base);
     }
   });
 
-  // ─── reconcileSliceTasks: plan file imports tasks when DB empty ──────
-  test('reconcileSliceTasks: imports tasks from plan file when DB has zero tasks (#3600)', async () => {
+  // ─── DB-authoritative tasks: plan projection does not import tasks ──────
+  test('deriveStateFromDb: DB-empty task list does not import PLAN tasks', async () => {
     const base = createFixtureBase();
     try {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
@@ -200,24 +222,23 @@ describe('derive-state-helpers', () => {
       insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
       insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First', status: 'active', risk: 'low', depends: [] });
       insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second', status: 'pending', risk: 'low', depends: ['S01'] });
-      // No tasks inserted — reconcileSliceTasks should import from plan file
+      // No tasks inserted — PLAN.md is a projection and must not be imported.
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // Plan has T01 (pending) and T02 (done) — reconciliation imports both
-      assert.equal(state.phase, 'executing', 'task-reconcile: phase is executing (tasks imported)');
-      assert.equal(state.activeTask?.id, 'T01', 'task-reconcile: activeTask is T01');
-      assert.equal(state.progress?.tasks?.total, 2, 'task-reconcile: total tasks = 2');
-      assert.equal(state.progress?.tasks?.done, 1, 'task-reconcile: done tasks = 1 (T02 was [x])');
+      assert.equal(state.phase, 'planning', 'db-empty-tasks: phase is planning');
+      assert.equal(state.activeTask, null, 'db-empty-tasks: no active task');
+      assert.equal(state.progress?.tasks?.total, 0, 'db-empty-tasks: no tasks imported');
+      assert.equal(state.progress?.tasks?.done, 0, 'db-empty-tasks: no completed tasks imported');
     } finally {
       closeDatabase();
       cleanup(base);
     }
   });
 
-  // ─── reconcileSliceTasks: stale task reconciled from disk summary ────
-  test('reconcileSliceTasks: stale pending task reconciled to complete when disk SUMMARY exists (#2514)', async () => {
+  // ─── DB-authoritative tasks: SUMMARY projection does not complete task ────
+  test('deriveStateFromDb: disk SUMMARY does not reconcile pending task', async () => {
     const base = createFixtureBase();
     try {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
@@ -237,11 +258,9 @@ describe('derive-state-helpers', () => {
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // T01 should have been reconciled to complete (SUMMARY exists on disk)
-      // Both tasks complete → phase should be summarizing
-      assert.equal(state.phase, 'summarizing', 'stale-task: phase is summarizing (T01 reconciled)');
-      assert.equal(state.activeTask, null, 'stale-task: no active task (all done)');
-      assert.equal(state.progress?.tasks?.done, 2, 'stale-task: tasks.done = 2');
+      assert.equal(state.phase, 'executing', 'disk-summary-ignored: phase is executing');
+      assert.equal(state.activeTask?.id, 'T01', 'disk-summary-ignored: T01 remains active');
+      assert.equal(state.progress?.tasks?.done, 1, 'disk-summary-ignored: only DB-complete task is done');
     } finally {
       closeDatabase();
       cleanup(base);
@@ -256,7 +275,8 @@ describe('derive-state-helpers', () => {
       writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
       writeFile(base, 'milestones/M001/slices/S01/tasks/.gitkeep', '');
       writeFile(base, 'milestones/M001/slices/S01/tasks/T01-PLAN.md', '# T01 Plan');
-      // T02 completed with blocker discovered — written in summary frontmatter
+      // T02 completed with blocker discovered. The disk summary is a projection;
+      // only the DB blocker flag is authoritative for deriveStateFromDb().
       writeFile(base, 'milestones/M001/slices/S01/tasks/T02-SUMMARY.md',
         '---\nblocker_discovered: true\n---\n\n# T02 Summary\n\nFound a blocker.');
 
@@ -265,7 +285,7 @@ describe('derive-state-helpers', () => {
       insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First', status: 'active', risk: 'low', depends: [] });
       insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second', status: 'pending', risk: 'low', depends: ['S01'] });
       insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'First Task', status: 'pending' });
-      insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Done Task', status: 'complete' });
+      insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Done Task', status: 'complete', blockerDiscovered: true });
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
@@ -278,8 +298,8 @@ describe('derive-state-helpers', () => {
     }
   });
 
-  // ─── checkInterruptedWork: continue.md triggers resume hint ─────────
-  test('checkInterruptedWork: continue.md present triggers resume nextAction', async () => {
+  // ─── CONTINUE.md projection is ignored by DB derive ─────────────────
+  test('deriveStateFromDb: continue.md projection does not trigger resume nextAction', async () => {
     const base = createFixtureBase();
     try {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
@@ -299,8 +319,8 @@ describe('derive-state-helpers', () => {
       const state = await deriveStateFromDb(base);
 
       assert.equal(state.phase, 'executing', 'continue: phase is still executing');
-      assert.ok(state.nextAction.includes('Resume interrupted work'), 'continue: nextAction mentions resume');
-      assert.ok(state.nextAction.includes('continue.md'), 'continue: nextAction mentions continue.md');
+      assert.ok(!state.nextAction.includes('Resume interrupted work'), 'continue: nextAction does not mention resume');
+      assert.ok(!state.nextAction.includes('continue.md'), 'continue: nextAction does not mention continue.md');
     } finally {
       closeDatabase();
       cleanup(base);
@@ -380,6 +400,13 @@ describe('derive-state-helpers', () => {
       insertMilestone({ id: 'M001', title: 'First', status: 'active' });
       insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First', status: 'complete', risk: 'low', depends: [] });
       insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second', status: 'complete', risk: 'low', depends: ['S01'] });
+      insertAssessment({
+        path: 'milestones/M001/M001-VALIDATION.md',
+        milestoneId: 'M001',
+        status: 'pass',
+        scope: 'milestone-validation',
+        fullContent: 'verdict: passed',
+      });
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
@@ -394,34 +421,34 @@ describe('derive-state-helpers', () => {
     }
   });
 
-  // ─── reconcileDiskToDb: disk slices synced into DB (#2533) ──────────
-  test('reconcileDiskToDb: slices in ROADMAP.md but missing from DB are auto-inserted (#2533)', async () => {
+  // ─── DB-authoritative slices: roadmap projection does not insert slices ───
+  test('deriveStateFromDb: ROADMAP slices missing from DB are not auto-inserted', async () => {
     const base = createFixtureBase();
     try {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
 
       openDatabase(':memory:');
       insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
-      // No slices inserted — reconcileDiskToDb should insert from roadmap
+      // No slices inserted — ROADMAP.md is a projection and must not be imported.
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // Slices should have been reconciled from roadmap, S01 should be the active slice
-      assert.equal(state.activeMilestone?.id, 'M001', 'slice-reconcile: M001 is active');
-      assert.equal(state.activeSlice?.id, 'S01', 'slice-reconcile: S01 reconciled and active');
-      assert.ok((state.progress?.slices?.total ?? 0) >= 2, 'slice-reconcile: at least 2 slices reconciled');
+      assert.equal(state.activeMilestone?.id, 'M001', 'roadmap-projection: M001 is active');
+      assert.equal(state.activeSlice, null, 'roadmap-projection: no active slice imported');
+      assert.equal(state.phase, 'pre-planning', 'roadmap-projection: no DB slices routes to pre-planning');
+      assert.equal(state.progress?.slices, undefined, 'roadmap-projection: no slice progress from projection');
     } finally {
       closeDatabase();
       cleanup(base);
     }
   });
 
-  // ─── Queue order: milestones sorted by custom queue order ───────────
-  test('deriveStateFromDb respects custom queue order from QUEUE-ORDER.json', async () => {
+  // ─── Queue order: DB sequence is authoritative ─────────────────────
+  test('deriveStateFromDb ignores QUEUE-ORDER.json and uses DB sequence', async () => {
     const base = createFixtureBase();
     try {
-      // M003 should come first per queue order, M001 second
+      // QUEUE-ORDER.json is a projection and should not drive DB derivation.
       const queueOrder = JSON.stringify({ order: ['M003', 'M001', 'M002'], updatedAt: new Date().toISOString() });
       writeFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), queueOrder);
       writeFile(base, 'milestones/M001/M001-CONTEXT.md', '# M001\n\nContext.');
@@ -429,23 +456,47 @@ describe('derive-state-helpers', () => {
       writeFile(base, 'milestones/M003/M003-CONTEXT.md', '# M003\n\nContext.');
 
       openDatabase(':memory:');
-      // Insert in natural order — queue ordering should override
+      // Insert in natural order, then store the authoritative DB sequence.
       insertMilestone({ id: 'M001', title: 'First', status: 'active' });
       insertMilestone({ id: 'M002', title: 'Second', status: 'active' });
       insertMilestone({ id: 'M003', title: 'Third', status: 'active' });
+      setMilestoneQueueOrder(['M002', 'M001', 'M003']);
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // M003 should be the active milestone (first in queue)
-      assert.equal(state.activeMilestone?.id, 'M003', 'queue-order: M003 is active (first in queue)');
-      assert.equal(state.registry[0]?.id, 'M003', 'queue-order: registry[0] is M003');
+      assert.equal(state.activeMilestone?.id, 'M002', 'queue-order: DB sequence chooses M002');
+      assert.equal(state.registry[0]?.id, 'M002', 'queue-order: registry[0] follows DB sequence');
     } finally {
       closeDatabase();
       cleanup(base);
     }
   });
 
+	  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:');
+      insertMilestone({ id: 'M001', title: 'Active in DB', status: 'active' });
+
+      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();
+      cleanup(base);
+    }
+  });
+
   // ─── handleAllSlicesDone: needs-remediation + all slices done → blocked (#4506) ──
   test('handleAllSlicesDone: needs-remediation with all slices done returns blocked', async () => {
     const base = createFixtureBase();
@@ -458,6 +509,13 @@ describe('derive-state-helpers', () => {
       openDatabase(':memory:');
       insertMilestone({ id: 'M001', title: 'Remediation Test', status: 'active' });
       insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Done', status: 'complete', risk: 'low', depends: [] });
+      insertAssessment({
+        path: 'milestones/M001/M001-VALIDATION.md',
+        milestoneId: 'M001',
+        status: 'needs-remediation',
+        scope: 'milestone-validation',
+        fullContent: 'verdict: needs-remediation',
+      });
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);

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

@@ -5,6 +5,10 @@ import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
 import { deriveState, isSliceComplete, isMilestoneComplete, isGhostMilestone } from '../state.ts';
+
+// This suite exercises the explicit legacy markdown derivation path.
+process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK = '1';
+
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {

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

@@ -47,26 +47,12 @@ describe("completing-milestone dispatch guard (#4324)", () => {
     assert.ok(dispatchIdx > -1, "complete-milestone dispatch should exist after the skip guard");
   });
 
-  test("classifies SUMMARY outcome and conditionally reconciles DB (#4658)", () => {
+  test("does not reconcile DB from SUMMARY.md projection (#4658 superseded)", () => {
     const phaseCheck = source.indexOf('phase !== "completing-milestone"');
-    // The SUMMARY-exists reconciliation guard must appear in this rule
-    const summaryGuard = source.indexOf('resolveMilestoneFile(basePath, mid, "SUMMARY")', phaseCheck);
-    assert.ok(summaryGuard > -1, "SUMMARY file check should exist in the completing-milestone rule");
-
-    const classifyCall = source.indexOf("classifyMilestoneSummaryContent", summaryGuard);
-    assert.ok(classifyCall > -1, "SUMMARY mismatch handling should classify summary content");
-    const dbGateBeforeClassify = source.indexOf("existingSummary && isDbAvailable()", summaryGuard);
-    assert.ok(
-      dbGateBeforeClassify === -1 || dbGateBeforeClassify > classifyCall,
-      "SUMMARY classification must not be gated on DB availability",
-    );
-
-    const reconcileCall = source.indexOf('updateMilestoneStatus(mid, "complete"', summaryGuard);
-    assert.ok(reconcileCall > -1, "successful SUMMARY should reconcile DB to complete");
-
-    const stopAction = source.indexOf('action: "stop"', summaryGuard);
-    assert.ok(stopAction > -1, "SUMMARY mismatch should return stop action");
-    const warningLevel = source.indexOf('level: "warning"', summaryGuard);
-    assert.ok(warningLevel > -1, "SUMMARY mismatch should be warning-level stop (pauses auto-mode)");
+    assert.ok(phaseCheck > -1, "completing-milestone phase check should exist");
+    const ruleTail = source.slice(phaseCheck, source.indexOf('name:', phaseCheck + 1));
+    assert.doesNotMatch(ruleTail, /resolveMilestoneFile\(basePath,\s*mid,\s*"SUMMARY"\)/);
+    assert.doesNotMatch(ruleTail, /classifyMilestoneSummaryContent/);
+    assert.doesNotMatch(ruleTail, /updateMilestoneStatus\(mid,\s*"complete"/);
   });
 });

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

@@ -225,14 +225,14 @@ test("dispatch guard allows slice with all declared dependencies complete", (t)
   );
 });
 
-test("dispatch guard skips completed milestone with SUMMARY even if it has unchecked remediation slices (#1716)", (t) => {
+test("dispatch guard does not skip prior milestone from SUMMARY projection when DB is not closed", (t) => {
   const repo = setupRepo();
   t.after(() => teardownRepo(repo));
 
   mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
   mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
 
-  // M001 is complete (has SUMMARY) but has unchecked remediation slices in DB
+  // M001 has a successful SUMMARY projection but is not closed in the DB.
   insertMilestone({ id: "M001", title: "Previous" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Core", status: "complete", depends: [], sequence: 1 });
   insertSlice({ id: "S02", milestoneId: "M001", title: "Tests", status: "complete", depends: ["S01"], sequence: 2 });
@@ -242,16 +242,15 @@ test("dispatch guard skips completed milestone with SUMMARY even if it has unche
   insertMilestone({ id: "M002", title: "Current" });
   insertSlice({ id: "S01", milestoneId: "M002", title: "Start", status: "pending", depends: [], sequence: 1 });
 
-  // M001 SUMMARY on disk triggers skip
+  // M001 SUMMARY on disk must not trigger skip while DB remains open/active.
   writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
   writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-SUMMARY.md"),
     "---\nstatus: complete\n---\n# M001 Summary\nDone.\n");
   writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), "# M002\n");
 
-  // M001 has SUMMARY — should be skipped, not block M002/S01
   assert.equal(
     getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M002/S01"),
-    null,
+    "Cannot dispatch plan-slice M002/S01: earlier slice M001/S03-R is not complete.",
   );
 });
 

package/src/resources/extensions/gsd/tests/dispatcher-stuck-planning.test.ts

@@ -1,10 +1,9 @@
 /**
- * dispatcher-stuck-planning.test.ts — #3656
+ * dispatcher-stuck-planning.test.ts
  *
- * Verify that state.ts contains the disk-to-DB task reconciliation logic
- * that prevents the dispatcher from getting stuck in an infinite planning
- * loop when the planner writes a PLAN.md but never calls the persistence
- * tool, leaving the DB with zero or partial task rows.
+ * Verify that state.ts no longer imports disk PLAN.md tasks into the runtime
+ * DB. PLAN.md is a projection; task rows must be created through DB-backed
+ * planning/import APIs.
  */
 
 import { describe, test } from "node:test";
@@ -16,23 +15,23 @@ import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const sourceFile = join(__dirname, "..", "state.ts");
 
-describe("dispatcher stuck-planning reconciliation (#3656)", () => {
+describe("dispatcher DB-authoritative planning boundary", () => {
   const source = readFileSync(sourceFile, "utf-8");
 
-  test("imports insertTask from gsd-db", () => {
-    assert.match(source, /import\s*\{[^}]*insertTask[^}]*\}\s*from/);
+  test("does not import insertTask into state derivation", () => {
+    assert.doesNotMatch(source, /import\s*\{[^}]*insertTask[^}]*\}\s*from/);
   });
 
-  test("contains plan-file task reconciliation block", () => {
-    assert.match(source, /if\s*\(\s*planFile\s*\)/);
-    assert.match(source, /dbTaskIds\.has\(t\.id\)/);
+  test("does not contain plan-file task reconciliation block", () => {
+    assert.doesNotMatch(source, /dbTaskIds\.has\(t\.id\)/);
+    assert.match(source, /Slice \$\{activeSlice\.id\} has no DB tasks/);
   });
 
-  test("calls insertTask for each disk plan task", () => {
-    assert.match(source, /insertTask\(\{/);
+  test("does not call insertTask from state derivation", () => {
+    assert.doesNotMatch(source, /insertTask\(\{/);
   });
 
-  test("references issue #3600 in reconciliation comment", () => {
-    assert.match(source, /#3600/);
+  test("documents markdown projections as non-authoritative", () => {
+    assert.match(source, /Markdown files are projections only/);
   });
 });

package/src/resources/extensions/gsd/tests/ensure-db-open.test.ts

@@ -1,7 +1,7 @@
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-// ensureDbOpen — Tests that the lazy DB opener creates + migrates the database
-// when .gsd/ exists with Markdown content but no gsd.db file.
+// ensureDbOpen — Tests that the lazy DB opener creates/opens the authoritative
+// database without implicitly importing markdown projections.
 //
 // This covers the bug where interactive (non-auto) sessions got
 // "GSD database is not available" because ensureDbOpen only opened
@@ -11,7 +11,7 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import * as fs from 'node:fs';
 import { createRequire } from 'node:module';
-import { closeDatabase, isDbAvailable, getDecisionById, _getAdapter } from '../gsd-db.ts';
+import { closeDatabase, isDbAvailable, getDecisionById, SCHEMA_VERSION, _getAdapter } from '../gsd-db.ts';
 
 const _require = createRequire(import.meta.url);
 
@@ -284,11 +284,11 @@ function createLegacyV15Db(dbPath: string): void {
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// ensureDbOpen creates DB + migrates when .gsd/ has Markdown
+// ensureDbOpen creates DB without implicit Markdown migration
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe('ensure-db-open', () => {
-  test('ensureDbOpen: creates DB from Markdown', async () => {
+  test('ensureDbOpen: creates empty DB without importing Markdown', async () => {
     const tmpDir = makeTmpDir();
     const gsdDir = path.join(tmpDir, '.gsd');
     fs.mkdirSync(gsdDir, { recursive: true });
@@ -319,17 +319,12 @@ describe('ensure-db-open', () => {
 
       const result = await ensureDbOpen();
 
-      assert.ok(result === true, 'ensureDbOpen should return true when .gsd/ has Markdown');
+      assert.ok(result === true, 'ensureDbOpen should return true when .gsd/ exists');
       assert.ok(fs.existsSync(dbPath), 'DB file should be created after ensureDbOpen');
       assert.ok(isDbAvailable(), 'DB should be available after ensureDbOpen');
 
-      // Verify that Markdown migration actually ran
       const decision = getDecisionById('D001');
-      assert.ok(decision !== null, 'D001 should be migrated from DECISIONS.md');
-      if (decision) {
-        assert.deepStrictEqual(decision.scope, 'architecture', 'Migrated decision scope should match');
-        assert.deepStrictEqual(decision.choice, 'SQLite', 'Migrated decision choice should match');
-      }
+      assert.equal(decision, null, 'D001 should not be imported from DECISIONS.md without explicit migration');
     } finally {
       process.cwd = origCwd;
       closeDatabase();
@@ -360,7 +355,7 @@ describe('ensure-db-open', () => {
       assert.ok(result === true, 'ensureDbOpen should honor explicit basePath');
       assert.equal(process.cwd(), originalCwd, 'ensureDbOpen should not mutate process.cwd');
       assert.ok(isDbAvailable(), 'DB should be available after explicit open');
-      assert.ok(getDecisionById('D777') !== null, 'explicit basePath DB should be opened');
+      assert.equal(getDecisionById('D777'), null, 'explicit basePath should not import DECISIONS.md');
     } finally {
       closeDatabase();
       cleanupDir(tmpDir);
@@ -389,7 +384,7 @@ describe('ensure-db-open', () => {
       assert.ok(db, 'adapter should be available after ensureDbOpen');
       assert.equal(
         db.prepare('SELECT MAX(version) as version FROM schema_version').get()?.version,
-        22,
+        SCHEMA_VERSION,
         'legacy DB should migrate to current schema version',
       );
 
@@ -519,9 +514,9 @@ describe('ensure-db-open', () => {
     try {
       const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
       assert.equal(await ensureDbOpen(firstDir), true);
-      assert.ok(getDecisionById('D101') !== null, 'first DB should be active');
+      assert.equal(getDecisionById('D101'), null, 'first DB should not import DECISIONS.md');
       assert.equal(await ensureDbOpen(secondDir), true);
-      assert.ok(getDecisionById('D202') !== null, 'second DB should be active after switch');
+      assert.equal(getDecisionById('D202'), null, 'second DB should not import DECISIONS.md');
       assert.equal(getDecisionById('D101'), null, 'first DB should no longer be active after switch');
     } finally {
       closeDatabase();

package/src/resources/extensions/gsd/tests/escalation.test.ts

@@ -19,6 +19,7 @@ import {
   claimEscalationOverride,
   findUnappliedEscalationOverride,
   listEscalationArtifacts,
+  SCHEMA_VERSION,
   _getAdapter,
 } from "../gsd-db.ts";
 import {
@@ -348,7 +349,7 @@ test("ADR-011 P2: schema v20 fresh DB has all escalation columns on tasks + sour
   assert.ok(decCols.includes("source"), "decisions table must have source column");
 
   const version = adapter.prepare("SELECT MAX(version) as v FROM schema_version").get();
-  assert.equal(version?.["v"], 22);
+  assert.equal(version?.["v"], SCHEMA_VERSION);
 });
 
 test("ADR-011 P2: findUnappliedEscalationOverride returns null when escalation_pending=1 (still pending)", (t) => {

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

@@ -11,6 +11,7 @@ import {
   wasDbOpenAttempted,
   getDbProvider,
   getDbStatus,
+  SCHEMA_VERSION,
   insertDecision,
   getDecisionById,
   insertRequirement,
@@ -101,7 +102,7 @@ describe('gsd-db', () => {
     // Check schema_version table
     const adapter = _getAdapter()!;
     const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
-    assert.deepStrictEqual(version?.['version'], 22, 'schema version should be 22');
+    assert.deepStrictEqual(version?.['version'], SCHEMA_VERSION, `schema version should be ${SCHEMA_VERSION}`);
 
     // Check tables exist by querying them
     const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();