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

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-backgroundable-annotation.test.ts

@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  annotateBackgroundable,
+  type AnnotatableDispatchAction,
+} from "../delegation-policy.js";
+
+function dispatchAction(unitType: string): AnnotatableDispatchAction {
+  return {
+    action: "dispatch",
+    unitType,
+    unitId: `M001/${unitType}`,
+    prompt: "(test prompt)",
+  };
+}
+
+test("annotateBackgroundable marks plan-slice as backgroundable", () => {
+  const annotated = annotateBackgroundable(dispatchAction("plan-slice"));
+  assert.equal(annotated.action, "dispatch");
+  if (annotated.action !== "dispatch") return;
+  assert.equal(annotated.backgroundable, true);
+  assert.equal(annotated.unitType, "plan-slice");
+});
+
+test("annotateBackgroundable marks validate-milestone and reassess-roadmap as backgroundable", () => {
+  for (const unitType of ["validate-milestone", "reassess-roadmap"]) {
+    const annotated = annotateBackgroundable(dispatchAction(unitType));
+    assert.equal(annotated.action, "dispatch");
+    if (annotated.action !== "dispatch") continue;
+    assert.equal(annotated.backgroundable, true, `${unitType} should be backgroundable`);
+  }
+});
+
+test("annotateBackgroundable marks plan-milestone and replan-slice as NOT backgroundable", () => {
+  for (const unitType of ["plan-milestone", "replan-slice"]) {
+    const annotated = annotateBackgroundable(dispatchAction(unitType));
+    assert.equal(annotated.action, "dispatch");
+    if (annotated.action !== "dispatch") continue;
+    assert.equal(annotated.backgroundable, false, `${unitType} should not be backgroundable`);
+  }
+});
+
+test("annotateBackgroundable defaults unknown unit types to false (default-deny)", () => {
+  const annotated = annotateBackgroundable(dispatchAction("execute-task"));
+  assert.equal(annotated.action, "dispatch");
+  if (annotated.action !== "dispatch") return;
+  assert.equal(annotated.backgroundable, false);
+});
+
+test("annotateBackgroundable leaves stop and skip actions untouched", () => {
+  const stop: AnnotatableDispatchAction = { action: "stop", reason: "test", level: "info" };
+  const skip: AnnotatableDispatchAction = { action: "skip" };
+  assert.deepEqual(annotateBackgroundable(stop), stop);
+  assert.deepEqual(annotateBackgroundable(skip), skip);
+});

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/draft-promotion.test.ts

@@ -133,29 +133,9 @@ assert(
   "stale CONTEXT-DRAFT.md should be deleted in both-files case",
 );
 
-// ─── Static: guided-flow.ts has cleanup code ───────────────────────────
-
-console.log("=== Static: cleanup code in guided-flow.ts ===");
-
-const { readFileSync } = await import("node:fs");
-const guidedFlowSource = readFileSync(
-  join(import.meta.dirname, "..", "guided-flow.ts"),
-  "utf-8",
-);
-
-const checkFnIdx = guidedFlowSource.indexOf("checkAutoStartAfterDiscuss");
-const checkFnEnd = guidedFlowSource.indexOf("\nexport ", checkFnIdx + 1);
-const checkFnChunk = guidedFlowSource.slice(checkFnIdx, checkFnEnd > checkFnIdx ? checkFnEnd : checkFnIdx + 5000);
-
-assert(
-  checkFnChunk.includes("CONTEXT-DRAFT"),
-  "checkAutoStartAfterDiscuss should reference CONTEXT-DRAFT for cleanup",
-);
-
-assert(
-  checkFnChunk.includes("unlinkSync"),
-  "checkAutoStartAfterDiscuss should use unlinkSync to delete the draft",
-);
+// Note: source-grep assertions removed per CONTRIBUTING.md (no asserting against
+// readFileSync of source). The behavioral scenarios above already exercise the
+// CONTEXT-DRAFT cleanup path end-to-end via the actual filesystem state.
 
 // ─── Cleanup ──────────────────────────────────────────────────────────