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

package/src/resources/extensions/gsd/tests/artifact-corruption-2630.test.ts

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

package/src/resources/extensions/gsd/tests/auto-paused-session-validation.test.ts

@@ -40,6 +40,12 @@ test("auto.ts validates milestone before restoring paused session (#1664)", () =
     "auto.ts must check for SUMMARY file to detect completed milestones",
   );
 
+  assert.ok(
+    source.includes("await ensureDbOpen(base)") &&
+      source.indexOf("await ensureDbOpen(base)") < source.indexOf('resolveMilestoneFile(base, meta.milestoneId, "SUMMARY")'),
+    "auto.ts must open the canonical DB before using SUMMARY as a paused-session fallback",
+  );
+
   // Resume path must sanitize paused session file metadata before unlink/recovery.
   assert.ok(
     source.includes("normalizeSessionFilePath(meta.sessionFile ?? null)"),

package/src/resources/extensions/gsd/tests/auto-remediate-slice-status.test.ts

@@ -1,13 +1,12 @@
 /**
- * Regression test for #3673 — auto-remediate stale slice DB status
+ * Regression test for DB-authoritative rogue detection.
  *
- * When complete-slice fails after writing SUMMARY.md but before calling
- * updateSliceStatus(), the DB stays stale and the post-unit check
- * previously reported this as a "rogue" artifact, causing infinite
- * re-dispatch. The fix calls updateSliceStatus() to sync the DB.
+ * A SUMMARY.md on disk is a projection/diagnostic. Runtime post-unit checks
+ * must not use it to mark the DB slice complete; explicit import/recovery
+ * commands own markdown-to-DB behavior.
  *
- * This structural test verifies updateSliceStatus is imported and called
- * in the complete-slice branch of auto-post-unit.ts.
+ * This structural test verifies the complete-slice rogue branch reports the
+ * stale projection without calling updateSliceStatus().
  */
 
 import { describe, test } from 'node:test';
@@ -22,38 +21,26 @@ const __dirname = dirname(__filename);
 
 const source = readFileSync(join(__dirname, '..', 'auto-post-unit.ts'), 'utf-8');
 
-describe('auto-remediate stale slice status (#3673)', () => {
-  test('updateSliceStatus is imported from gsd-db', () => {
-    assert.match(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from\s*["']\.\/gsd-db/,
-      'updateSliceStatus should be imported from gsd-db');
+describe('DB-authoritative slice rogue detection', () => {
+  test('updateSliceStatus is not imported for post-unit rogue reconciliation', () => {
+    assert.doesNotMatch(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from\s*["']\.\/gsd-db/,
+      'auto-post-unit must not import updateSliceStatus for disk-to-DB reconciliation');
   });
 
-  test('updateSliceStatus is called with "complete" status', () => {
-    assert.match(source, /updateSliceStatus\(mid,\s*sid,\s*["']complete["']/,
-      'updateSliceStatus should be called with "complete" status');
+  test('complete-slice rogue branch does not mark DB complete from disk', () => {
+    assert.doesNotMatch(source, /updateSliceStatus\(mid,\s*sid,\s*["']complete["']/,
+      'SUMMARY.md on disk must not mark slice complete in DB');
   });
 
-  test('remediation is wrapped in try-catch for fallback to rogue detection', () => {
-    // The updateSliceStatus call should be in a try block with a catch
-    // that falls back to rogues.push
-    const updateIdx = source.indexOf('updateSliceStatus(mid, sid');
-    assert.ok(updateIdx > 0, 'updateSliceStatus call should exist');
-
-    // Find surrounding try-catch
-    const before = source.slice(Math.max(0, updateIdx - 200), updateIdx);
-    assert.match(before, /try\s*\{/,
-      'updateSliceStatus should be inside a try block');
-
-    // Bound the region to stop before the rogue fallback so /catch/ only
-    // matches this try block's catch, not an unrelated later one.
-    const after = extractSourceRegion(source, 'updateSliceStatus(mid, sid', 'rogues.push({');
-    assert.match(after, /catch/,
-      'try block should have a catch for fallback');
+  test('explicit rogue diagnostic reports stale slice summary projection', () => {
+    const branch = extractSourceRegion(source, 'unitType === "complete-slice"', 'unitType === "plan-milestone"');
+    assert.match(branch, /rogues\.push\(\{\s*path:\s*summaryPath,\s*unitType,\s*unitId\s*\}\)/,
+      'complete-slice branch should report stale SUMMARY.md as rogue');
   });
 
-  test('rogue detection still exists as fallback', () => {
-    // rogues.push should appear in the catch block
-    assert.match(source, /rogues\.push\(\{.*path:\s*summaryPath/,
-      'rogues.push fallback should still exist');
+  test('post-unit runtime does not call rogue diagnostics automatically', () => {
+    const postUnit = extractSourceRegion(source, 'export async function postUnitPostVerification');
+    assert.doesNotMatch(postUnit, /detectRogueFileWrites\(/,
+      'runtime post-unit path must not scan disk projections for rogue files');
   });
 });

package/src/resources/extensions/gsd/tests/complete-task-rollback-evidence.test.ts

@@ -41,7 +41,7 @@ const VALID_PARAMS = {
   ],
 };
 
-describe("complete-task rollback cleans up verification_evidence (#2724)", () => {
+describe("complete-task projection failures keep DB completion committed", () => {
   let base: string;
 
   afterEach(() => {
@@ -75,7 +75,7 @@ describe("complete-task rollback cleans up verification_evidence (#2724)", () =>
     assert.equal(rows.length, 2, "should have 2 evidence rows after success");
   });
 
-  it("deletes verification_evidence rows on disk-render rollback", async () => {
+  it("keeps task completion and verification_evidence when disk projection write fails", async () => {
     base = makeTmpBase();
     openDatabase(join(base, ".gsd", "gsd.db"));
     insertMilestone({ id: "M001" });
@@ -87,20 +87,19 @@ describe("complete-task rollback cleans up verification_evidence (#2724)", () =>
     writeFileSync(tasksDir, "not-a-directory");
 
     const result = await handleCompleteTask(VALID_PARAMS, base);
-    assert.ok("error" in result, "should return error when disk write fails");
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+    assert.equal(result.stale, true, "result should report stale projection");
 
-    // Task should be rolled back to pending
     const adapter = _getAdapter()!;
     const task = adapter.prepare(
       `SELECT status FROM tasks WHERE milestone_id = 'M001' AND slice_id = 'S01' AND id = 'T01'`,
     ).get() as { status: string } | undefined;
     assert.ok(task, "task row should still exist");
-    assert.equal(task!.status, "pending", "task status should be rolled back to pending");
+    assert.equal(task!.status, "complete", "task status should remain complete");
 
-    // Verification evidence should be cleaned up — no orphaned rows
     const evidenceRows = adapter.prepare(
       `SELECT * FROM verification_evidence WHERE task_id = 'T01' AND slice_id = 'S01' AND milestone_id = 'M001'`,
     ).all();
-    assert.equal(evidenceRows.length, 0, "verification_evidence should be empty after rollback");
+    assert.equal(evidenceRows.length, 2, "verification_evidence should remain committed");
   });
 });

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

@@ -403,12 +403,11 @@ console.log('\n=== complete-task: handler idempotency ===');
   const r1 = await handleCompleteTask(params, basePath);
   assertTrue(!('error' in r1), 'first call should succeed');
 
-  // Verify complete-task did not duplicate T01. State reconciliation may import
-  // the remaining plan task from disk so the DB stays aligned with S01-PLAN.md.
+  // Verify complete-task did not duplicate T01. S01-PLAN.md is a projection,
+  // so the remaining plan task is not imported implicitly.
   const tasks = getSliceTasks('M001', 'S01');
-  assertEq(tasks.length, 2, 'should have T01 plus reconciled T02 after first call');
+  assertEq(tasks.length, 1, 'should only have the completed DB task after first call');
   assertEq(tasks.filter(t => t.id === 'T01').length, 1, 'should have exactly one T01 row after first call');
-  assertEq(tasks.find(t => t.id === 'T02')?.status, 'pending', 'T02 should be reconciled as pending');
 
   // Second call with same params — state machine guard rejects (task is already complete)
   const r2 = await handleCompleteTask(params, basePath);
@@ -419,7 +418,7 @@ console.log('\n=== complete-task: handler idempotency ===');
 
   // Still no duplicate rows from the rejected second call.
   const tasksAfter = getSliceTasks('M001', 'S01');
-  assertEq(tasksAfter.length, 2, 'should still have T01 plus reconciled T02 after rejected second call');
+  assertEq(tasksAfter.length, 1, 'should still only have T01 after rejected second call');
   assertEq(tasksAfter.filter(t => t.id === 'T01').length, 1, 'should still have exactly one T01 row');
 
   cleanupDir(basePath);
@@ -447,10 +446,13 @@ console.log('\n=== complete-task: handler with missing plan file ===');
   const params = makeValidParams();
   const result = await handleCompleteTask(params, basePath);
 
-  // Should succeed even without plan file — just skip checkbox toggle
+  // Should succeed and regenerate the missing plan projection from DB.
   assertTrue(!('error' in result), 'handler should succeed without plan file');
   if (!('error' in result)) {
     assertTrue(fs.existsSync(result.summaryPath), 'summary should be written even without plan file');
+    const planPath = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md');
+    assertTrue(fs.existsSync(planPath), 'missing plan projection should be regenerated from DB');
+    assertTrue(fs.readFileSync(planPath, 'utf-8').includes('[x] **T01:'), 'regenerated plan should reflect DB task completion');
   }
 
   cleanupDir(basePath);

package/src/resources/extensions/gsd/tests/completed-at-reconcile.test.ts

@@ -1,15 +1,9 @@
 /**
- * Behavioural regression test for #4129.
+ * Behavioural regression test for DB-authoritative task completion.
  *
- * When deriveStateFromDb's reconcileSliceTasks finds a SUMMARY.md on disk
- * for a task whose DB row is still pending, it flips the row to "complete".
- * Before #4129, the call to updateTaskStatus omitted the completedAt
- * timestamp, leaving completed_at NULL forever.
- *
- * The fix passes new Date().toISOString() as the 5th argument; this test
- * exercises that path end-to-end and asserts the column is populated.
- *
- * Refs #4829 (rewrite from positional source-grep).
+ * A task SUMMARY.md on disk is a projection, not a completion command.
+ * deriveStateFromDb must not flip a pending DB task to complete or invent a
+ * completed_at timestamp from disk evidence.
  */
 
 import { describe, test, beforeEach, afterEach } from 'node:test';
@@ -46,27 +40,26 @@ function setupProject(): void {
     `# M001\n\n## Slices\n\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  - After this: works\n`,
   );
 
-  // Plan file for the slice so reconcile can populate task list if DB is empty.
+  // Plan file for the slice. It is a projection and must not drive DB state.
   writeFileSync(
     join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md'),
     `# S01: Slice\n\n## Tasks\n\n- [ ] **T01: Test task** \`est:30m\`\n  - Do: x\n  - Verify: y\n`,
   );
 
-  // The summary file: this is the on-disk evidence that flips the task
-  // status to "complete" inside reconcileSliceTasks.
+  // The summary file is a projection and must not complete the task.
   writeFileSync(
     join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks', 'T01-SUMMARY.md'),
     '---\nid: T01\nparent: S01\nmilestone: M001\nblocker_discovered: false\n---\n# T01\n',
   );
 }
 
-describe('completed_at reconcile (#4129)', () => {
+describe('completed_at DB-authoritative derivation', () => {
   beforeEach(() => {
     setupProject();
     openDatabase(join(basePath, '.gsd', 'gsd.db'));
     insertMilestone({ id: 'M001', title: 'M001', status: 'active' });
     insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice', status: 'active' });
-    // Task is "pending" in DB, but SUMMARY.md exists on disk → reconcile flips it.
+    // Task is "pending" in DB, even though SUMMARY.md exists on disk.
     insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Test task', status: 'pending' });
     invalidateStateCache();
   });
@@ -76,24 +69,16 @@ describe('completed_at reconcile (#4129)', () => {
     try { rmSync(basePath, { recursive: true, force: true }); } catch { /* */ }
   });
 
-  test('reconcileSliceTasks sets completed_at when flipping a pending task to complete via SUMMARY.md', async () => {
+  test('deriveStateFromDb does not set completed_at from a disk SUMMARY projection', async () => {
     const before = getTask('M001', 'S01', 'T01');
     assert.strictEqual(before?.status, 'pending', 'task starts pending');
     assert.strictEqual(before?.completed_at, null, 'task starts with completed_at NULL');
 
-    // Trigger the reconcile path (state.ts → reconcileSliceTasks).
+    // Derive runtime state. Disk SUMMARY.md must not mutate the DB row.
     await deriveStateFromDb(basePath);
 
     const after = getTask('M001', 'S01', 'T01');
-    assert.strictEqual(after?.status, 'complete', 'task should be flipped to complete');
-    assert.ok(
-      typeof after?.completed_at === 'string' && after.completed_at.length > 0,
-      `completed_at must be populated by reconcileSliceTasks (#4129); got ${JSON.stringify(after?.completed_at)}`,
-    );
-    // Sanity: timestamp parses as a valid ISO date.
-    assert.ok(
-      !Number.isNaN(Date.parse(after!.completed_at!)),
-      `completed_at should be a valid ISO timestamp, got ${after!.completed_at}`,
-    );
+    assert.strictEqual(after?.status, 'pending', 'task remains pending');
+    assert.strictEqual(after?.completed_at, null, 'completed_at remains NULL');
   });
 });

package/src/resources/extensions/gsd/tests/completed-units-metrics-sync.test.ts

@@ -58,13 +58,26 @@ test("#2313: syncStateToProjectRoot should sync metrics.json", () => {
   );
 });
 
-test("#2313: syncWorktreeStateBack should include metrics.json in ROOT_STATE_FILES", () => {
+test("syncStateToProjectRoot should back-sync completed-units.json", () => {
+  const syncSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
+  const syncSrc = readFileSync(syncSrcPath, "utf-8");
+  const fnIdx = syncSrc.indexOf("export function syncStateToProjectRoot(");
+  assert.ok(fnIdx !== -1, "syncStateToProjectRoot exists");
+  const fnBlock = syncSrc.slice(fnIdx, syncSrc.indexOf("// ─── Resource Staleness", fnIdx));
+
+  assert.ok(
+    fnBlock.includes('"completed-units.json"'),
+    "syncStateToProjectRoot should copy completed-units.json back to the project root",
+  );
+});
+
+test("#2313: syncWorktreeStateBack should include metrics.json in ROOT_DIAGNOSTIC_FILES", () => {
   const autoWorktreeSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
   const autoWorktreeSrc = readFileSync(autoWorktreeSrcPath, "utf-8");
 
-  // Find the ROOT_STATE_FILES constant (single source of truth for both sync directions)
-  const constIdx = autoWorktreeSrc.indexOf("ROOT_STATE_FILES");
-  assert.ok(constIdx !== -1, "ROOT_STATE_FILES constant exists");
+  // Find the ROOT_DIAGNOSTIC_FILES constant used for worktree copy-back.
+  const constIdx = autoWorktreeSrc.indexOf("ROOT_DIAGNOSTIC_FILES");
+  assert.ok(constIdx !== -1, "ROOT_DIAGNOSTIC_FILES constant exists");
 
   // Get the array content
   const arrayStart = autoWorktreeSrc.indexOf("[", constIdx);
@@ -73,7 +86,7 @@ test("#2313: syncWorktreeStateBack should include metrics.json in ROOT_STATE_FIL
 
   assert.ok(
     rootFilesBlock.includes("metrics.json"),
-    "metrics.json should be in ROOT_STATE_FILES list",
+    "metrics.json should be in ROOT_DIAGNOSTIC_FILES list",
   );
 });
 

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

@@ -47,7 +47,7 @@ const symlinkResult = resolveProjectRootDbPath(symlinkPath);
 assertEq(
   symlinkResult,
   join("/home/user/myproject/.gsd/projects/abc123def", "gsd.db"),
-  "/.gsd/projects/<hash>/worktrees/ resolves to hash-level DB (#2517, updated for #2952)",
+  "/.gsd/projects/<hash>/worktrees/ resolves to external project state DB",
 );
 
 // Windows-style separators for symlink layout
@@ -57,7 +57,7 @@ if (sep === "\\") {
   assertEq(
     winResult,
     join("C:\\Users\\dev\\project\\.gsd\\projects\\abc123def", "gsd.db"),
-    "Windows /.gsd/projects/<hash>/worktrees/ resolves to hash-level DB",
+    "Windows /.gsd/projects/<hash>/worktrees/ resolves to external project state DB",
   );
 } else {
   // On non-Windows, test forward-slash variant explicitly
@@ -66,7 +66,7 @@ if (sep === "\\") {
   assertEq(
     fwdResult,
     join("/home/user/myproject/.gsd/projects/abc123def", "gsd.db"),
-    "Forward-slash /.gsd/projects/<hash>/worktrees/ resolves to hash-level DB on POSIX",
+    "Forward-slash /.gsd/projects/<hash>/worktrees/ resolves to external project state DB on POSIX",
   );
 }
 
@@ -76,7 +76,7 @@ const deepResult = resolveProjectRootDbPath(deepSymlinkPath);
 assertEq(
   deepResult,
   join("/home/user/myproject/.gsd/projects/deadbeef42", "gsd.db"),
-  "Deep /.gsd/projects/<hash>/worktrees/ path resolves to hash-level DB (#2952)",
+  "Deep /.gsd/projects/<hash>/worktrees/ path resolves to external project state DB",
 );
 
 // Non-worktree path should be unchanged

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

@@ -481,7 +481,7 @@ describe('db-writer', () => {
     }
   });
 
-  test('updateRequirementInDb — seeds from REQUIREMENTS.md when DB empty (#3346)', async () => {
+  test('updateRequirementInDb — ignores REQUIREMENTS.md projection when DB empty', async () => {
     const tmpDir = makeTmpDir();
     const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
     openDatabase(dbPath);
@@ -515,31 +515,28 @@ describe('db-writer', () => {
       ].join('\n');
       fs.writeFileSync(path.join(tmpDir, '.gsd', 'REQUIREMENTS.md'), reqContent);
 
-      // DB is empty — no requirements seeded. Update R005 to "validated".
-      // Before #3346 fix: this would create a skeleton with empty fields.
-      // After fix: this seeds all 3 requirements from REQUIREMENTS.md first.
+      // DB is empty. REQUIREMENTS.md is a projection and must not be imported
+      // implicitly by a runtime DB write.
       await updateRequirementInDb('R005', {
         status: 'validated',
         validation: 'S02 — auth flow verified',
       }, tmpDir);
 
-      // R005 should have the update AND the original content from markdown
+      // R005 should have the requested update only; disk projection content is ignored.
       const r005 = getRequirementById('R005');
       assert.ok(r005, 'R005 should exist');
       assert.equal(r005!.status, 'validated', 'status should be updated');
       assert.equal(r005!.validation, 'S02 — auth flow verified', 'validation should be updated');
-      assert.equal(r005!.class, 'functional', 'class should be preserved from REQUIREMENTS.md');
-      assert.ok(r005!.description?.includes('authentication') || r005!.full_content?.includes('authentication'),
-        'original content should be preserved');
+      assert.equal(r005!.class, '', 'class should not be imported from REQUIREMENTS.md');
+      assert.ok(!r005!.description?.includes('authentication'), 'description should not be imported');
+      assert.ok(!r005!.full_content?.includes('authentication'), 'full content should not be imported');
 
-      // R007 and R001 should also be seeded (not just the one being updated)
+      // Other requirements in the projection are not seeded.
       const r007 = getRequirementById('R007');
-      assert.ok(r007, 'R007 should be seeded from REQUIREMENTS.md');
-      assert.equal(r007!.status, 'active', 'R007 status should be active');
+      assert.equal(r007, null, 'R007 should not be imported from REQUIREMENTS.md');
 
       const r001 = getRequirementById('R001');
-      assert.ok(r001, 'R001 should be seeded from REQUIREMENTS.md');
-      assert.equal(r001!.status, 'validated', 'R001 status should be validated (from section heading)');
+      assert.equal(r001, null, 'R001 should not be imported from REQUIREMENTS.md');
     } finally {
       closeDatabase();
       cleanupDir(tmpDir);
@@ -663,15 +660,16 @@ describe('db-writer', () => {
         'disk file preserved — shrinkage guard prevented overwrite',
       );
 
-      // DB should contain the full disk content, not the abbreviated content
+      // DB should keep the caller-provided content. The larger disk file is a
+      // stale projection, not runtime authority.
       const adapter = _getAdapter();
       const row = adapter!
         .prepare('SELECT full_content FROM artifacts WHERE path = ?')
         .get(relPath);
       assert.deepStrictEqual(
         row!['full_content'],
-        fullContent,
-        'DB stores the richer disk content instead of abbreviated content',
+        abbreviatedContent,
+        'DB stores caller-provided content instead of importing disk projection content',
       );
     } finally {
       closeDatabase();

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

@@ -20,7 +20,7 @@ import {
   insertSlice,
   insertTask,
 } from '../gsd-db.ts';
-import { migrateHierarchyToDb } from '../md-importer.ts';
+import { migrateFromMarkdown, migrateHierarchyToDb } from '../md-importer.ts';
 import type { GSDState } from '../types.ts';
 
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
@@ -479,12 +479,13 @@ skills_used: []
 
       // Step 2: Migrate markdown to DB
       openDatabase(':memory:');
-      const counts = migrateHierarchyToDb(base);
+      const counts = migrateFromMarkdown(base);
 
       // Verify migration populated correctly
-      assert.ok(counts.milestones >= 1, 'G-roundtrip: migrated milestones');
-      assert.ok(counts.slices >= 2, 'G-roundtrip: migrated slices');
-      assert.ok(counts.tasks >= 3, 'G-roundtrip: migrated tasks');
+      assert.ok(counts.hierarchy.milestones >= 1, 'G-roundtrip: migrated milestones');
+      assert.ok(counts.hierarchy.slices >= 2, 'G-roundtrip: migrated slices');
+      assert.ok(counts.hierarchy.tasks >= 3, 'G-roundtrip: migrated tasks');
+      assert.equal(counts.requirements, 3, 'G-roundtrip: migrated requirements');
 
       // Step 3: Get DB-backed state
       invalidateStateCache();

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

@@ -1,10 +1,9 @@
 /**
  * derive-state-db-disk-reconcile.test.ts — #2416
  *
- * After migration to DB-backed state, milestones that exist on disk
- * (in .gsd/milestones/) but were never imported into the DB become
- * invisible to deriveStateFromDb(). This test verifies that
- * deriveStateFromDb reconciles disk milestones with DB milestones.
+ * DB-authoritative state: milestones that exist only as markdown projections
+ * are not imported by deriveStateFromDb(). Explicit migration/import is the
+ * only markdown-to-DB path.
  */
 
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
@@ -17,7 +16,6 @@ import {
   closeDatabase,
   insertMilestone,
   insertSlice,
-  insertTask,
 } from "../gsd-db.ts";
 import { createTestContext } from "./test-helpers.ts";
 
@@ -58,7 +56,7 @@ const ROADMAP_CONTENT = `# M002: Disk-Only Milestone
 `;
 
 async function main(): Promise<void> {
-  console.log("\n=== #2416: deriveStateFromDb reconciles disk milestones ===");
+  console.log("\n=== deriveStateFromDb does not reconcile disk milestones ===");
 
   // Set up: M001 in DB, M002 on disk only
   const base = createFixtureBase();
@@ -81,12 +79,9 @@ async function main(): Promise<void> {
     invalidateStateCache();
     const state = await deriveStateFromDb(base);
 
-    // M002 should be visible in the registry
+    // M002 is disk-only and should not be visible in DB-backed state.
     const m002Entry = state.registry.find((m) => m.id === "M002");
-    assertTrue(
-      m002Entry !== undefined,
-      "M002 (disk-only milestone) should appear in state.registry (#2416)",
-    );
+    assertEq(m002Entry, undefined, "M002 disk-only milestone should not appear in DB-backed state");
 
     // M001 should still be in the registry
     const m001Entry = state.registry.find((m) => m.id === "M001");
@@ -95,24 +90,14 @@ async function main(): Promise<void> {
       "M001 (DB milestone) should still appear in state.registry",
     );
 
-    // The active milestone should be M002 (since M001 is complete)
-    assertTrue(
-      state.activeMilestone !== null,
-      "There should be an active milestone",
-    );
-    if (state.activeMilestone) {
-      assertEq(
-        state.activeMilestone.id,
-        "M002",
-        "Active milestone should be M002 (disk-only, not complete) (#2416)",
-      );
-    }
+    assertEq(state.activeMilestone, null, "No active milestone should be inferred from disk-only markdown");
+    assertEq(state.phase, "complete", "DB-only complete milestone drives complete state");
   } finally {
     closeDatabase();
     cleanup(base);
   }
 
-  console.log("\n=== #4974: summary-only disk milestones keep parsed title ===");
+    console.log("\n=== summary-only disk milestones are not imported ===");
 
   {
     const summaryOnlyBase = createFixtureBase();
@@ -132,20 +117,7 @@ async function main(): Promise<void> {
       const state = await deriveStateFromDb(summaryOnlyBase);
       const m002Entry = state.registry.find((m) => m.id === "M002");
 
-      assertTrue(
-        m002Entry !== undefined,
-        "M002 summary-only disk milestone should appear in state.registry (#4974)",
-      );
-      assertEq(
-        m002Entry?.title,
-        "Summary-Only Milestone",
-        "M002 summary-only disk milestone should use parsed SUMMARY title (#4974)",
-      );
-      assertEq(
-        m002Entry?.status,
-        "complete",
-        "M002 summary-only disk milestone should reconcile as complete (#4974)",
-      );
+      assertEq(m002Entry, undefined, "M002 summary-only disk milestone should not appear without explicit import");
     } finally {
       closeDatabase();
       cleanup(summaryOnlyBase);