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

package/src/resources/extensions/gsd/tests/rogue-file-detection.test.ts

@@ -149,7 +149,7 @@ test("rogue detection: DB not available → returns empty array (graceful degrad
   }
 });
 
-test("rogue detection: slice summary on disk, no DB row → auto-remediated (not rogue)", () => {
+test("rogue detection: slice summary on disk, no DB completion → detected as rogue without DB import", () => {
   const basePath = createTmpBase();
   const dbPath = join(basePath, ".gsd", "gsd.db");
   mkdirSync(join(basePath, ".gsd"), { recursive: true });
@@ -160,10 +160,9 @@ test("rogue detection: slice summary on disk, no DB row → auto-remediated (not
     const summaryPath = createSliceSummaryOnDisk(basePath, "M001", "S01");
     assert.ok(existsSync(summaryPath), "Slice summary file should exist on disk");
 
-    // Fix #3633: stale slice DB status is auto-remediated via updateSliceStatus()
-    // instead of being reported as rogue, so rogues array should be empty.
     const rogues = detectRogueFileWrites("complete-slice", "M001/S01", basePath);
-    assert.equal(rogues.length, 0, "Should auto-remediate stale slice, not report as rogue");
+    assert.equal(rogues.length, 1, "Should report stale disk summary instead of mutating DB");
+    assert.equal(rogues[0]?.path, summaryPath);
   } finally {
     closeDatabase();
     rmSync(basePath, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/slice-disk-reconcile.test.ts

@@ -1,10 +1,8 @@
 /**
  * slice-disk-reconcile.test.ts — #2533
  *
- * Slices that exist on disk (in ROADMAP.md) but are missing from the SQLite
- * database cause permanent "No slice eligible — check dependency ordering"
- * blocks. deriveStateFromDb must reconcile disk slices into the DB, just as
- * it already does for milestones (#2416).
+ * DB-authoritative state: slices that exist only in ROADMAP.md are projections
+ * and must not be imported into the SQLite database by deriveStateFromDb().
  *
  * Scenario: M001 has a ROADMAP with S01-S04. S01 and S02 have SUMMARY files
  * (complete on disk). S03 depends on S01. Only S04 is in the DB (depends on
@@ -70,7 +68,7 @@ const ROADMAP_CONTENT = `# M001: Test Milestone
 `;
 
 async function testMissingSlicesCauseBlock(): Promise<void> {
-  console.log("\n--- Test: missing DB slices cause permanent block (pre-fix) ---");
+  console.log("\n--- Test: missing DB slices are not imported from ROADMAP.md ---");
 
   const base = createFixtureBase();
   const dbPath = join(base, ".gsd", "gsd.db");
@@ -96,51 +94,11 @@ async function testMissingSlicesCauseBlock(): Promise<void> {
     invalidateStateCache();
     const state = await deriveStateFromDb(base);
 
-    // After the fix, slices S01-S03 should be reconciled into DB
     const dbSlices = getMilestoneSlices("M001");
-    assertTrue(
-      dbSlices.length === 4,
-      `All 4 roadmap slices should be in DB after reconciliation, got ${dbSlices.length}`,
-    );
-
-    // S01 and S02 should be marked complete (have SUMMARY files)
-    const s01 = dbSlices.find(s => s.id === "S01");
-    assertTrue(s01 !== undefined, "S01 should exist in DB after reconciliation");
-    if (s01) {
-      assertEq(s01.status, "complete", "S01 should be 'complete' (has SUMMARY on disk)");
-    }
-
-    const s02 = dbSlices.find(s => s.id === "S02");
-    assertTrue(s02 !== undefined, "S02 should exist in DB after reconciliation");
-    if (s02) {
-      assertEq(s02.status, "complete", "S02 should be 'complete' (has SUMMARY on disk)");
-    }
-
-    // S03 should be pending (no SUMMARY)
-    const s03 = dbSlices.find(s => s.id === "S03");
-    assertTrue(s03 !== undefined, "S03 should exist in DB after reconciliation");
-    if (s03) {
-      assertEq(s03.status, "pending", "S03 should be 'pending' (no SUMMARY on disk)");
-    }
-
-    // The state should NOT be blocked — S03 should be eligible (S01 dep satisfied)
-    assertTrue(
-      state.phase !== "blocked",
-      `Phase should not be 'blocked' after reconciliation, got '${state.phase}'`,
-    );
-
-    // Active slice should be S03 (S01 dep met, S03 is first incomplete with satisfied deps)
-    assertTrue(
-      state.activeSlice !== null,
-      "There should be an active slice after reconciliation",
-    );
-    if (state.activeSlice) {
-      assertEq(
-        state.activeSlice.id,
-        "S03",
-        "Active slice should be S03 (its dependency S01 is complete) (#2533)",
-      );
-    }
+    assertEq(dbSlices.length, 1, `Only DB slice S04 should remain, got ${dbSlices.length}`);
+    assertEq(dbSlices[0]?.id, "S04", "Disk-only slices are not inserted");
+    assertEq(state.phase, "blocked", "DB-only S04 remains blocked on missing DB dependency S03");
+    assertEq(state.activeSlice, null, "No active slice is inferred from roadmap-only rows");
   } finally {
     closeDatabase();
     cleanup(base);
@@ -148,7 +106,7 @@ async function testMissingSlicesCauseBlock(): Promise<void> {
 }
 
 async function testSliceReconciliationIdempotent(): Promise<void> {
-  console.log("\n--- Test: slice reconciliation is idempotent ---");
+  console.log("\n--- Test: disk-only slices remain absent on repeated derives ---");
 
   const base = createFixtureBase();
   const dbPath = join(base, ".gsd", "gsd.db");
@@ -178,11 +136,7 @@ async function testSliceReconciliationIdempotent(): Promise<void> {
       assertEq(s01.status, "complete", "S01 status should remain 'complete' (not overwritten)");
     }
 
-    // S02-S04 should have been added
-    assertTrue(
-      dbSlices.length === 4,
-      `Should have 4 slices after reconciliation (existing + new), got ${dbSlices.length}`,
-    );
+    assertEq(dbSlices.length, 1, `Only existing DB slice should remain, got ${dbSlices.length}`);
   } finally {
     closeDatabase();
     cleanup(base);
@@ -218,7 +172,7 @@ async function testNoRoadmapSkipsReconciliation(): Promise<void> {
 }
 
 async function main(): Promise<void> {
-  console.log("\n=== #2533: deriveStateFromDb reconciles disk slices ===");
+  console.log("\n=== deriveStateFromDb does not reconcile disk slices ===");
 
   await testMissingSlicesCauseBlock();
   await testSliceReconciliationIdempotent();

package/src/resources/extensions/gsd/tests/stale-slice-rows.test.ts

@@ -1,10 +1,9 @@
 /**
- * stale-slice-rows.test.ts — #3658
+ * stale-slice-rows.test.ts
  *
- * Verify that state.ts contains slice-level status reconciliation that
- * updates stale DB rows (status "pending") when disk artifacts (SUMMARY)
- * prove the slice is complete. Without this, the dependency resolver builds
- * doneSliceIds from stale DB rows and downstream slices stay blocked.
+ * Verify that state.ts no longer treats slice SUMMARY.md projections as
+ * authority for DB slice status. Slice rows must be updated through DB-backed
+ * completion/import APIs.
  */
 
 import { describe, test } from "node:test";
@@ -16,26 +15,26 @@ import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const sourceFile = join(__dirname, "..", "state.ts");
 
-describe("stale slice row reconciliation (#3658)", () => {
+describe("stale slice row DB-authoritative boundary", () => {
   const source = readFileSync(sourceFile, "utf-8");
 
-  test("imports updateSliceStatus from gsd-db", () => {
-    assert.match(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from/);
+  test("does not import updateSliceStatus into state derivation", () => {
+    assert.doesNotMatch(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from/);
   });
 
-  test("checks isStatusDone before reconciling slice rows", () => {
-    assert.match(source, /isStatusDone\(dbSlice\.status\)/);
+  test("does not scan DB slice rows for disk SUMMARY reconciliation", () => {
+    assert.doesNotMatch(source, /dbSlice/);
   });
 
-  test("resolves SUMMARY file to detect completed slices on disk", () => {
-    assert.match(source, /resolveSliceFile\(basePath,\s*mid,\s*dbSlice\.id,\s*["']SUMMARY["']\)/);
+  test("does not resolve slice SUMMARY to mutate DB state", () => {
+    assert.doesNotMatch(source, /resolveSliceFile\(basePath,\s*mid,\s*dbSlice\.id,\s*["']SUMMARY["']\)/);
   });
 
-  test("calls updateSliceStatus to reconcile stale rows", () => {
-    assert.match(source, /updateSliceStatus\(mid,\s*dbSlice\.id,\s*["']complete["']\)/);
+  test("does not call updateSliceStatus from state derivation", () => {
+    assert.doesNotMatch(source, /updateSliceStatus\(/);
   });
 
-  test("references issue #3599 in reconciliation comment", () => {
-    assert.match(source, /#3599/);
+  test("documents markdown projections as non-authoritative", () => {
+    assert.match(source, /Markdown files are projections only/);
   });
 });

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

@@ -69,6 +69,7 @@ function makeMilestoneRow(overrides: Partial<MilestoneRow> = {}): MilestoneRow {
     definition_of_done: [],
     requirement_coverage: "",
     boundary_map_markdown: "",
+    sequence: 0,
     ...overrides,
   };
 }

package/src/resources/extensions/gsd/tests/state-machine-full-walkthrough.test.ts

@@ -858,11 +858,11 @@ describe("state-machine-full-walkthrough", () => {
   });
 
   // ═══════════════════════════════════════════════════════════════════════════
-  // RECONCILIATION
+  // DB-AUTHORITATIVE DERIVATION
   // ═══════════════════════════════════════════════════════════════════════════
 
-  describe("Reconciliation", () => {
-    test("DB: task with SUMMARY on disk but DB says pending → reconciliation fixes status (#2514)", async () => {
+  describe("DB-authoritative derivation", () => {
+    test("DB: task with SUMMARY on disk but DB says pending → DB remains authoritative", async () => {
       const base = createFixtureBase();
       const dbPath = join(base, ".gsd", "gsd.db");
       openDatabase(dbPath);
@@ -875,19 +875,19 @@ describe("state-machine-full-walkthrough", () => {
       writeRoadmap(base, "M001", standardRoadmap());
       writePlan(base, "M001", "S01", standardPlan());
 
-      // Write SUMMARY files on disk for both tasks (simulating session disconnect)
+      // Write SUMMARY files on disk for both tasks. These are projections and
+      // must not complete pending DB tasks during runtime derivation.
       writeTaskSummary(base, "M001", "S01", "T01");
       writeTaskSummary(base, "M001", "S01", "T02");
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // Reconciliation should detect SUMMARY→DB mismatch and update
-      // All tasks done → summarizing (not executing)
-      assert.equal(state.phase, "summarizing", "reconciliation should advance past pending tasks");
+      assert.equal(state.phase, "executing", "disk SUMMARY projections must not complete DB tasks");
+      assert.equal(state.activeTask?.id, "T01", "first pending DB task remains active");
     });
 
-    test("empty DB with disk milestones → disk-to-DB sync (#2631)", async () => {
+    test("empty DB with disk milestones → no runtime disk-to-DB sync", async () => {
       const base = createFixtureBase();
       writeContext(base, "M001", "# M001: Test\n\nContext.");
 
@@ -899,11 +899,10 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveState(base);
 
-      // After deriveState, DB should have the disk milestone
+      // Runtime derivation must not import disk milestones into the DB.
       const after = getAllMilestones();
-      assert.ok(after.length > 0, "DB should have milestones after reconciliation");
-      assert.equal(after[0]!.id, "M001");
-      assert.ok(state.activeMilestone !== null);
+      assert.equal(after.length, 0, "DB should remain empty without explicit migration");
+      assert.equal(state.activeMilestone, null, "disk milestone is ignored while DB is authoritative");
     });
 
     test("ghost milestone (empty dir) → NOT in registry", async () => {
@@ -1063,7 +1062,7 @@ describe("state-machine-full-walkthrough", () => {
   // ═══════════════════════════════════════════════════════════════════════════
 
   describe("Recovery: DB has slice but no task rows (partial migration)", () => {
-    test("DB tasks empty but PLAN on disk has tasks → reconciles to executing", async () => {
+    test("DB tasks empty but PLAN on disk has tasks → stays planning", async () => {
       const base = createFixtureBase();
       const dbPath = join(base, ".gsd", "gsd.db");
       openDatabase(dbPath);
@@ -1078,15 +1077,13 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // FIX (#3600): plan-file tasks are now reconciled into the DB,
-      // so the phase correctly advances to executing instead of planning.
-      assert.equal(state.phase, "executing",
-        "reconciled plan-file tasks → executing (not stuck in planning)");
+      assert.equal(state.phase, "planning",
+        "PLAN.md projection must not import DB tasks during runtime derivation");
     });
   });
 
   describe("Failure: partial SUMMARY reconciliation", () => {
-    test("only one task has SUMMARY, other still pending → executing next task", async () => {
+    test("only one task has SUMMARY, other still pending → executing first DB-pending task", async () => {
       const base = createFixtureBase();
       const dbPath = join(base, ".gsd", "gsd.db");
       openDatabase(dbPath);
@@ -1104,9 +1101,8 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // T01 reconciled to complete, T02 still pending → executing T02
       assert.equal(state.phase, "executing");
-      assert.equal(state.activeTask?.id, "T02", "should advance to next pending task");
+      assert.equal(state.activeTask?.id, "T01", "disk SUMMARY must not advance past pending DB task");
     });
   });
 
@@ -1255,7 +1251,7 @@ describe("state-machine-full-walkthrough", () => {
   });
 
   describe("Failure: missing task plan files in DB path", () => {
-    test("DB has tasks but no T##-PLAN.md files → planning phase", async () => {
+    test("DB has tasks but no T##-PLAN.md files → executing phase", async () => {
       const base = createFixtureBase();
       const dbPath = join(base, ".gsd", "gsd.db");
       openDatabase(dbPath);
@@ -1273,8 +1269,8 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      assert.equal(state.phase, "planning",
-        "missing T##-PLAN.md files should keep state in planning");
+      assert.equal(state.phase, "executing",
+        "DB tasks are authoritative even when task plan projections are missing");
     });
   });
 
@@ -1591,7 +1587,7 @@ describe("state-machine-full-walkthrough", () => {
   });
 
   describe("Failure: multiple reconciliation in single derivation", () => {
-    test("DB has 3 stale tasks, all with SUMMARY on disk → all reconciled in one pass", async () => {
+    test("DB has 3 stale tasks, all with SUMMARY on disk → first DB-pending task remains active", async () => {
       const base = createFixtureBase();
       const dbPath = join(base, ".gsd", "gsd.db");
       openDatabase(dbPath);
@@ -1641,9 +1637,9 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // All 3 should be reconciled in one pass → summarizing
-      assert.equal(state.phase, "summarizing",
-        "all 3 stale tasks should be reconciled to complete in one derivation");
+      assert.equal(state.phase, "executing",
+        "disk SUMMARY projections must not reconcile DB task state");
+      assert.equal(state.activeTask?.id, "T01", "first non-closed DB task remains active");
     });
   });
 });

package/src/resources/extensions/gsd/tests/steer-worktree-path.test.ts

@@ -1,6 +1,6 @@
 // GSD Extension - Steer Worktree Path Resolution Test
-// Regression test for #3476: /gsd steer must write overrides to the worktree .gsd/,
-// not the project root .gsd/, when a worktree is active.
+// Worktrees share the canonical project .gsd state root. /gsd steer writes
+// overrides to that canonical root even when invoked with a worktree path.
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
@@ -27,32 +27,31 @@ describe("steer worktree path resolution (#3476)", () => {
     rmSync(projectRoot, { recursive: true, force: true });
   });
 
-  test("appendOverride writes to worktree .gsd/ when worktree path is used", async () => {
+  test("appendOverride writes to canonical project .gsd/ when worktree path is used", async () => {
     await appendOverride(worktreePath, "Use Postgres instead of SQLite", "M001/S01/T01");
 
-    // Override should be in the worktree .gsd/
+    // Override should be in the canonical project .gsd/
     const wtOverrides = join(worktreePath, ".gsd", "OVERRIDES.md");
-    assert.ok(existsSync(wtOverrides), "override file exists in worktree .gsd/");
+    const rootOverrides = join(projectRoot, ".gsd", "OVERRIDES.md");
+    assert.ok(!existsSync(wtOverrides), "no override file in worktree-local .gsd/");
+    assert.ok(existsSync(rootOverrides), "override file exists in project root .gsd/");
 
-    const content = readFileSync(wtOverrides, "utf-8");
+    const content = readFileSync(rootOverrides, "utf-8");
     assert.ok(content.includes("Use Postgres instead of SQLite"), "override content is correct");
-
-    // Override should NOT be in the project root .gsd/
-    const rootOverrides = join(projectRoot, ".gsd", "OVERRIDES.md");
-    assert.ok(!existsSync(rootOverrides), "no override file in project root .gsd/");
   });
 
-  test("loadActiveOverrides reads from worktree .gsd/ when worktree path is used", async () => {
+  test("loadActiveOverrides reads canonical project .gsd/ when worktree path is used", async () => {
     await appendOverride(worktreePath, "Switch to JWT auth", "M001/S02/T01");
 
-    // Loading from worktree should find the override
+    // Loading from worktree resolves to the canonical project state root.
     const wtOverrides = await loadActiveOverrides(worktreePath);
     assert.equal(wtOverrides.length, 1, "one active override in worktree");
     assert.equal(wtOverrides[0].change, "Switch to JWT auth");
 
-    // Loading from project root should find nothing
+    // Loading from project root sees the same canonical override.
     const rootOverrides = await loadActiveOverrides(projectRoot);
-    assert.equal(rootOverrides.length, 0, "no overrides in project root");
+    assert.equal(rootOverrides.length, 1, "same override visible from project root");
+    assert.equal(rootOverrides[0].change, "Switch to JWT auth");
   });
 
   test("appendOverride falls back to project root when no worktree exists", async () => {

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

@@ -135,7 +135,7 @@ test("stopAutoRemote sends SIGTERM to a live process and returns found:true", {
 
 // ─── Lock path: original project root vs worktree ────────────────────────
 
-test("lock file should be discoverable at project root, not worktree path", () => {
+test("lock file should be discoverable from project root and worktree path", () => {
   const projectRoot = makeTmpBase();
   const worktreePath = join(projectRoot, ".gsd", "worktrees", "M001");
   mkdirSync(join(worktreePath, ".gsd"), { recursive: true });
@@ -149,9 +149,10 @@ test("lock file should be discoverable at project root, not worktree path", () =
     assert.ok(lock, "lock should be found at project root");
     assert.equal(lock!.unitType, "execute-task");
 
-    // Worktree path should NOT have a lock
+    // Worktree path resolves to the same canonical project .gsd lock.
     const worktreeLock = readCrashLock(worktreePath);
-    assert.equal(worktreeLock, null, "lock should NOT exist at worktree path");
+    assert.ok(worktreeLock, "lock should be discoverable via worktree path");
+    assert.equal(worktreeLock!.unitType, "execute-task");
   } finally {
     cleanup(projectRoot);
   }

package/src/resources/extensions/gsd/tests/sync-worktree-skip-current.test.ts

@@ -1,12 +1,9 @@
 /**
- * Regression test for #3641 — syncWorktreeStateBack skips current milestone
+ * Regression test for DB-authoritative syncWorktreeStateBack behavior.
  *
- * When syncing worktree state back to main, the current milestone being
- * merged should be skipped. Its files are already in the milestone branch
- * and copying them back would conflict with the squash merge.
- *
- * The fix adds a `mid === milestoneId` skip guard inside the milestone
- * iteration loop in syncWorktreeStateBack.
+ * Worktree milestone projections are not authoritative. syncWorktreeStateBack
+ * may reconcile a legacy worktree DB and copy diagnostics, but must not copy
+ * milestone markdown directories back into the project root.
  */
 
 import { describe, it } from 'node:test'
@@ -20,7 +17,7 @@ const src = readFileSync(
   'utf-8',
 )
 
-describe('syncWorktreeStateBack skips current milestone (#3641)', () => {
+describe('syncWorktreeStateBack does not copy worktree milestone projections', () => {
   it('syncWorktreeStateBack function exists', () => {
     assert.ok(
       src.includes('function syncWorktreeStateBack('),
@@ -28,7 +25,7 @@ describe('syncWorktreeStateBack skips current milestone (#3641)', () => {
     )
   })
 
-  it('mid === milestoneId skip guard exists in the milestone loop', () => {
+  it('does not iterate worktree milestones for copy-back', () => {
     // Find syncWorktreeStateBack
     const fnStart = src.indexOf('function syncWorktreeStateBack(')
     assert.ok(fnStart !== -1)
@@ -36,31 +33,11 @@ describe('syncWorktreeStateBack skips current milestone (#3641)', () => {
     // Get a reasonable portion of the function
     const fnBlock = extractSourceRegion(src, 'function syncWorktreeStateBack(', { fromIdx: fnStart })
 
-    // Find the for loop iterating milestones
-    const loopIdx = fnBlock.indexOf('for (const mid of wtMilestones)')
-    assert.ok(loopIdx !== -1, 'milestone iteration loop must exist')
-
-    // After the loop, there should be the skip guard
-    const loopBody = extractSourceRegion(fnBlock, 'for (const mid of wtMilestones)', { fromIdx: loopIdx })
-    assert.ok(
-      loopBody.includes('mid === milestoneId'),
-      'mid === milestoneId skip guard must exist inside the milestone loop',
-    )
-    assert.ok(
-      loopBody.includes('continue'),
-      'skip guard must use continue to skip the current milestone',
-    )
+    assert.ok(!fnBlock.includes('for (const mid of wtMilestones)'), 'must not iterate worktree milestones')
+    assert.ok(!fnBlock.includes('syncMilestoneDir('), 'must not copy milestone markdown projections')
   })
 
-  it('syncMilestoneDir is still called for non-current milestones', () => {
-    const fnStart = src.indexOf('function syncWorktreeStateBack(')
-    assert.ok(fnStart !== -1)
-
-    const fnBlock = extractSourceRegion(src, 'function syncWorktreeStateBack(', { fromIdx: fnStart })
-
-    assert.ok(
-      fnBlock.includes('syncMilestoneDir('),
-      'syncMilestoneDir must still be called for other milestones',
-    )
+  it('legacy milestone copy helper has been removed', () => {
+    assert.ok(!src.includes('function syncMilestoneDir('), 'syncMilestoneDir helper should not exist')
   })
 })

package/src/resources/extensions/gsd/tests/validate-milestone-write-order.test.ts

@@ -85,7 +85,7 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     assert.doesNotMatch(validationMd, /## Verification Class Compliance/);
   });
 
-  it("rolls back DB row when disk write fails", async () => {
+  it("keeps DB row and reports stale projection when disk write fails", async () => {
     base = makeTmpBase();
     const dbPath = join(base, ".gsd", "gsd.db");
     openDatabase(dbPath);
@@ -101,16 +101,15 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
 
     const result = await handleValidateMilestone(VALID_PARAMS, base);
 
-    // Should return error
-    assert.ok("error" in result, "should return error when disk write fails");
-    assert.ok(result.error.includes("disk render failed"));
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+    assert.equal(result.stale, true, "result should report stale projection");
 
-    // DB row should have been rolled back (deleted)
     const adapter = _getAdapter()!;
     const row = adapter.prepare(
-      `SELECT * FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
-    ).get();
-    assert.equal(row, undefined, "assessment row should be deleted after disk-write rollback");
+      `SELECT status FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
+    ).get() as { status: string } | undefined;
+    assert.ok(row, "assessment row should remain committed");
+    assert.equal(row!.status, "pass");
   });
 
   it("persists milestone validation gate_runs rows when UOK gates are enabled", async () => {

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

@@ -394,7 +394,7 @@ test("dispatch rule skips when skip_milestone_validation preference is set", asy
   }
 });
 
-test("dispatch rule fails closed for failure-path SUMMARY when DB milestone is not complete (#4658)", async () => {
+test("dispatch rule ignores failure-path SUMMARY projection when DB milestone is not complete (#4658 superseded)", async () => {
   const state: GSDState = {
     activeMilestone: { id: "M001", title: "Test" },
     activeSlice: null,
@@ -422,17 +422,14 @@ test("dispatch rule fails closed for failure-path SUMMARY when DB milestone is n
       prefs: undefined,
     };
     const result = await resolveDispatch(ctx);
-    assert.equal(result.action, "stop");
-    if (result.action === "stop") {
-      assert.equal(result.level, "warning");
-      assert.match(result.reason, /failure-path SUMMARY/i);
-    }
+    assert.equal(result.action, "dispatch");
+    assert.equal(getMilestone("M001")?.status, "active");
   } finally {
     cleanup(base);
   }
 });
 
-test("dispatch rule reconciles DB for successful stale SUMMARY (#4658)", async () => {
+test("dispatch rule does not reconcile DB from successful stale SUMMARY projection (#4658 superseded)", async () => {
   const state: GSDState = {
     activeMilestone: { id: "M001", title: "Test" },
     activeSlice: null,
@@ -473,15 +470,15 @@ test("dispatch rule reconciles DB for successful stale SUMMARY (#4658)", async (
       prefs: undefined,
     };
     const result = await resolveDispatch(ctx);
-    assert.equal(result.action, "skip");
+    assert.equal(result.action, "dispatch");
     const milestone = getMilestone("M001");
-    assert.equal(milestone?.status, "complete");
+    assert.equal(milestone?.status, "active");
   } finally {
     cleanup(base);
   }
 });
 
-test("dispatch rule fails closed for ambiguous stale SUMMARY (#4658)", async () => {
+test("dispatch rule ignores ambiguous stale SUMMARY projection (#4658 superseded)", async () => {
   const state: GSDState = {
     activeMilestone: { id: "M001", title: "Test" },
     activeSlice: null,
@@ -509,11 +506,8 @@ test("dispatch rule fails closed for ambiguous stale SUMMARY (#4658)", async ()
       prefs: undefined,
     };
     const result = await resolveDispatch(ctx);
-    assert.equal(result.action, "stop");
-    if (result.action === "stop") {
-      assert.equal(result.level, "warning");
-      assert.match(result.reason, /ambiguous SUMMARY/i);
-    }
+    assert.equal(result.action, "dispatch");
+    assert.equal(getMilestone("M001")?.status, "active");
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/workflow-logger-wiring.test.ts

@@ -205,17 +205,22 @@ test("readTransaction logs ROLLBACK failures as split-brain signal", () => {
   );
 });
 
-// ─── Runtime: state.ts and workflow-projections.ts log silent bailouts ─────
+// ─── Runtime: startup/projection diagnostics stay explicit ─────────────────
 
-test("state.ts logs roadmap read failures instead of silently continuing", () => {
-  const stateSrc = readFileSync(
-    join(import.meta.dirname, "..", "state.ts"),
+test("auto-start initializes the DB without implicit markdown migration", () => {
+  const autoStartSrc = readFileSync(
+    join(import.meta.dirname, "..", "auto-start.ts"),
     "utf-8",
   );
+  assert.doesNotMatch(
+    autoStartSrc,
+    /migrateFromMarkdown|md-importer/,
+    "auto-start must not import markdown into the runtime DB implicitly",
+  );
   assert.match(
-    stateSrc,
-    /logWarning\("state",\s*"reconcileDiskToDb: roadmap read failed/,
-    "state.ts reconcileDiskToDb should log roadmap read failures",
+    autoStartSrc,
+    /failed to initialize project database/,
+    "DB initialization failures should still be logged",
   );
 });
 

package/src/resources/extensions/gsd/tests/workflow-mcp-auto-prep.test.ts

@@ -15,7 +15,7 @@ test("shouldAutoPrepareWorkflowMcp enables prep for externalCli local transport"
   assert.equal(result, true);
 });
 
-test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is ready", () => {
+test("shouldAutoPrepareWorkflowMcp stays disabled for non-Claude active provider even when claude-code is ready", () => {
   const result = shouldAutoPrepareWorkflowMcp({
     model: { provider: "openai", baseUrl: "https://api.openai.com" },
     modelRegistry: {
@@ -24,10 +24,10 @@ test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is rea
     },
   });
 
-  assert.equal(result, true);
+  assert.equal(result, false);
 });
 
-test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is registered", () => {
+test("shouldAutoPrepareWorkflowMcp stays disabled for non-Claude active provider even when claude-code is registered", () => {
   const result = shouldAutoPrepareWorkflowMcp({
     model: { provider: "openai", baseUrl: "https://api.openai.com" },
     modelRegistry: {
@@ -36,7 +36,7 @@ test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is reg
     },
   });
 
-  assert.equal(result, true);
+  assert.equal(result, false);
 });
 
 test("shouldAutoPrepareWorkflowMcp stays disabled when neither transport nor provider readiness match", () => {