gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.d63175c

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

@@ -1,157 +0,0 @@
-/**
- * Unit tests for the queue-mode execution guard (#2545).
- *
- * When queue phase is active, the agent should only create milestones —
- * not execute work. This guard blocks write/edit/bash tool calls that
- * target source code (non-.gsd/ paths) during queue mode.
- *
- * Exercises shouldBlockQueueExecution() — a pure function that checks:
- *   (a) queuePhaseActive false → pass (not in queue mode)
- *   (b) toolName is read-only (read, grep, find, ls) → pass
- *   (c) toolName is ask_user_questions → pass (discussion tool)
- *   (d) write/edit to .gsd/ path → pass (planning artifacts)
- *   (e) write/edit to source path → block
- *   (f) bash command → block (could execute work)
- *   (g) registered GSD tools (gsd_milestone_generate_id, gsd_summary_save) → pass
- */
-
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { shouldBlockQueueExecution } from '../bootstrap/write-gate.ts';
-
-// ─── Scenario 1: Not in queue mode — all tools pass ──
-
-test('queue-guard: allows all tools when queue phase is not active', () => {
-  const r1 = shouldBlockQueueExecution('write', '/src/index.ts', false);
-  assert.strictEqual(r1.block, false, 'write should pass outside queue mode');
-
-  const r2 = shouldBlockQueueExecution('bash', 'npm test', false);
-  assert.strictEqual(r2.block, false, 'bash should pass outside queue mode');
-
-  const r3 = shouldBlockQueueExecution('edit', '/src/index.ts', false);
-  assert.strictEqual(r3.block, false, 'edit should pass outside queue mode');
-});
-
-// ─── Scenario 2: Read-only tools always pass in queue mode ──
-
-test('queue-guard: allows read-only tools during queue mode', () => {
-  for (const tool of ['read', 'grep', 'find', 'ls', 'glob']) {
-    const result = shouldBlockQueueExecution(tool, '/src/index.ts', true);
-    assert.strictEqual(result.block, false, `${tool} should pass in queue mode`);
-  }
-});
-
-// ─── Scenario 3: Discussion/planning tools pass in queue mode ──
-
-test('queue-guard: allows discussion and planning tools during queue mode', () => {
-  const r1 = shouldBlockQueueExecution('ask_user_questions', '', true);
-  assert.strictEqual(r1.block, false, 'ask_user_questions should pass');
-
-  const r2 = shouldBlockQueueExecution('gsd_milestone_generate_id', '', true);
-  assert.strictEqual(r2.block, false, 'gsd_milestone_generate_id should pass');
-
-  const r3 = shouldBlockQueueExecution('gsd_summary_save', '', true);
-  assert.strictEqual(r3.block, false, 'gsd_summary_save should pass');
-});
-
-// ─── Scenario 4: Write to .gsd/ paths passes (planning artifacts) ──
-
-test('queue-guard: allows writes to .gsd/ paths during queue mode', () => {
-  const r1 = shouldBlockQueueExecution('write', '.gsd/milestones/M001/M001-CONTEXT.md', true);
-  assert.strictEqual(r1.block, false, 'write to .gsd/ should pass');
-
-  const r2 = shouldBlockQueueExecution('write', '/project/.gsd/PROJECT.md', true);
-  assert.strictEqual(r2.block, false, 'write to .gsd/PROJECT.md should pass');
-
-  const r3 = shouldBlockQueueExecution('edit', '.gsd/QUEUE.md', true);
-  assert.strictEqual(r3.block, false, 'edit to .gsd/QUEUE.md should pass');
-
-  const r4 = shouldBlockQueueExecution('write', '.gsd/REQUIREMENTS.md', true);
-  assert.strictEqual(r4.block, false, 'write to .gsd/REQUIREMENTS.md should pass');
-
-  const r5 = shouldBlockQueueExecution('write', '.gsd/DECISIONS.md', true);
-  assert.strictEqual(r5.block, false, 'write to .gsd/DECISIONS.md should pass');
-});
-
-// ─── Scenario 5: Write/edit to source code paths blocked ──
-
-test('queue-guard: blocks writes to source code during queue mode', () => {
-  const r1 = shouldBlockQueueExecution('write', 'src/index.ts', true);
-  assert.strictEqual(r1.block, true, 'write to src/ should be blocked');
-  assert.ok(r1.reason, 'should provide a reason');
-  assert.ok(r1.reason!.includes('queue'), 'reason should mention queue');
-
-  const r2 = shouldBlockQueueExecution('write', '/project/src/components/App.tsx', true);
-  assert.strictEqual(r2.block, true, 'write to component file should be blocked');
-
-  const r3 = shouldBlockQueueExecution('edit', 'package.json', true);
-  assert.strictEqual(r3.block, true, 'edit to package.json should be blocked');
-
-  const r4 = shouldBlockQueueExecution('edit', '/project/lib/utils.ts', true);
-  assert.strictEqual(r4.block, true, 'edit to lib/ should be blocked');
-});
-
-// ─── Scenario 6: Bash commands blocked during queue mode ──
-
-test('queue-guard: blocks bash commands during queue mode', () => {
-  const r1 = shouldBlockQueueExecution('bash', 'npm install some-package', true);
-  assert.strictEqual(r1.block, true, 'npm install should be blocked');
-  assert.ok(r1.reason, 'should provide a reason');
-
-  const r2 = shouldBlockQueueExecution('bash', 'node src/index.ts', true);
-  assert.strictEqual(r2.block, true, 'running node should be blocked');
-});
-
-// ─── Scenario 7: Bash read-only commands pass during queue mode ──
-
-test('queue-guard: allows read-only bash commands during queue mode', () => {
-  const r1 = shouldBlockQueueExecution('bash', 'cat src/index.ts', true);
-  assert.strictEqual(r1.block, false, 'cat should pass');
-
-  const r2 = shouldBlockQueueExecution('bash', 'ls -la src/', true);
-  assert.strictEqual(r2.block, false, 'ls should pass');
-
-  const r3 = shouldBlockQueueExecution('bash', 'git log --oneline -10', true);
-  assert.strictEqual(r3.block, false, 'git log should pass');
-
-  const r4 = shouldBlockQueueExecution('bash', 'find . -name "*.ts"', true);
-  assert.strictEqual(r4.block, false, 'find should pass');
-
-  const r5 = shouldBlockQueueExecution('bash', 'grep -rn "TODO" src/', true);
-  assert.strictEqual(r5.block, false, 'grep should pass');
-
-  const r6 = shouldBlockQueueExecution('bash', 'head -20 src/index.ts', true);
-  assert.strictEqual(r6.block, false, 'head should pass');
-
-  const r7 = shouldBlockQueueExecution('bash', 'wc -l src/index.ts', true);
-  assert.strictEqual(r7.block, false, 'wc should pass');
-
-  const r8 = shouldBlockQueueExecution('bash', 'git diff HEAD~1', true);
-  assert.strictEqual(r8.block, false, 'git diff should pass');
-
-  const r9 = shouldBlockQueueExecution('bash', 'gh issue view 42', true);
-  assert.strictEqual(r9.block, false, 'gh issue view should pass');
-});
-
-// ─── Scenario 8: mkdir for .gsd/ milestone directories passes ──
-
-test('queue-guard: allows mkdir for .gsd/ milestone directories', () => {
-  const r1 = shouldBlockQueueExecution('bash', 'mkdir -p .gsd/milestones/M010/slices', true);
-  assert.strictEqual(r1.block, false, 'mkdir -p .gsd/ should pass');
-});
-
-// ─── Scenario 9: Web search and library tools pass ──
-
-test('queue-guard: allows web search and library tools during queue mode', () => {
-  const r1 = shouldBlockQueueExecution('search-the-web', '', true);
-  assert.strictEqual(r1.block, false, 'search-the-web should pass');
-
-  const r2 = shouldBlockQueueExecution('resolve_library', '', true);
-  assert.strictEqual(r2.block, false, 'resolve_library should pass');
-
-  const r3 = shouldBlockQueueExecution('get_library_docs', '', true);
-  assert.strictEqual(r3.block, false, 'get_library_docs should pass');
-
-  const r4 = shouldBlockQueueExecution('fetch_page', '', true);
-  assert.strictEqual(r4.block, false, 'fetch_page should pass');
-});

package/src/resources/extensions/gsd/tests/quick-turn-end-cleanup.test.ts

@@ -1,90 +0,0 @@
-/**
- * Tests that cleanupQuickBranch is called on turn_end to squash-merge the
- * quick branch back to the original branch after the agent completes.
- *
- * Relates to #2668: /gsd quick does not squash-merge branch back after agent
- * completes task. cleanupQuickBranch() exists but is never invoked.
- *
- * The fix registers a turn_end hook in register-hooks.ts that calls
- * cleanupQuickBranch() after each turn, which is a no-op when no quick-task
- * state is pending.
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-// ─── Structural test: verify turn_end hook exists in register-hooks.ts ──────
-
-describe("quick task turn_end cleanup (#2668)", () => {
-  const hooksSource = readFileSync(
-    join(import.meta.dirname, "..", "bootstrap", "register-hooks.ts"),
-    "utf-8",
-  );
-
-  it("register-hooks.ts imports cleanupQuickBranch from quick.ts", () => {
-    assert.ok(
-      hooksSource.includes("cleanupQuickBranch"),
-      "register-hooks.ts must reference cleanupQuickBranch",
-    );
-
-    // Verify it's imported (not just mentioned in a comment)
-    const importMatch = hooksSource.match(
-      /import\s*\{[^}]*cleanupQuickBranch[^}]*\}\s*from\s*["'][^"']*quick/,
-    );
-    assert.ok(
-      importMatch,
-      "cleanupQuickBranch must be imported from quick module",
-    );
-  });
-
-  it("registers a turn_end handler that calls cleanupQuickBranch", () => {
-    // Find the turn_end registration
-    const turnEndMatch = hooksSource.match(
-      /pi\.on\(\s*["']turn_end["']/,
-    );
-    assert.ok(
-      turnEndMatch,
-      "register-hooks.ts must register a turn_end handler",
-    );
-
-    // Extract the turn_end handler body — find everything from the pi.on("turn_end"
-    // to the matching closing });
-    const turnEndIdx = hooksSource.indexOf(turnEndMatch[0]);
-    assert.ok(turnEndIdx !== -1);
-
-    // Get the rest of the source from that point
-    const rest = hooksSource.slice(turnEndIdx);
-
-    // The handler must call cleanupQuickBranch
-    // Look for cleanupQuickBranch within the first handler body (up to first `});`)
-    const handlerEnd = rest.indexOf("});");
-    assert.ok(handlerEnd !== -1, "turn_end handler has a closing });");
-
-    const handlerBody = rest.slice(0, handlerEnd);
-    assert.ok(
-      handlerBody.includes("cleanupQuickBranch"),
-      "turn_end handler must call cleanupQuickBranch",
-    );
-  });
-
-  it("turn_end handler calls cleanupQuickBranch without arguments (uses cwd default)", () => {
-    // cleanupQuickBranch(basePath = process.cwd()) — calling without args is correct
-    // because the handler runs in the same process where handleQuick set up cwd
-    const turnEndIdx = hooksSource.indexOf('pi.on("turn_end"') !== -1
-      ? hooksSource.indexOf('pi.on("turn_end"')
-      : hooksSource.indexOf("pi.on('turn_end'");
-    assert.ok(turnEndIdx !== -1);
-
-    const rest = hooksSource.slice(turnEndIdx);
-    const handlerEnd = rest.indexOf("});");
-    const handlerBody = rest.slice(0, handlerEnd);
-
-    // Should call cleanupQuickBranch() — either bare or with no-arg form
-    assert.ok(
-      handlerBody.includes("cleanupQuickBranch("),
-      "turn_end handler invokes cleanupQuickBranch()",
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/reconciliation-edge-cases.test.ts

@@ -1,162 +0,0 @@
-// GSD State Machine Regression Tests — Event Replay & Reconciliation (#3161)
-
-import { describe, test, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { findForkPoint, readEvents, appendEvent } from "../workflow-events.ts";
-import type { WorkflowEvent } from "../workflow-events.ts";
-import { extractEntityKey, detectConflicts } from "../workflow-reconcile.ts";
-
-// ─── Helper: build a full WorkflowEvent from cmd + params ────────────────────
-
-function makeEvent(cmd: string, params: Record<string, unknown>, ts?: string): WorkflowEvent {
-  const hash = createHash("sha256")
-    .update(JSON.stringify({ cmd, params }))
-    .digest("hex")
-    .slice(0, 16);
-  return { cmd, params, ts: ts ?? new Date().toISOString(), hash, actor: "agent", session_id: "test-session" };
-}
-
-// ─── Temp dir management ─────────────────────────────────────────────────────
-
-const tempDirs: string[] = [];
-
-function tempDir(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-recon-test-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ }
-  }
-});
-
-// ─── Tests ────────────────────────────────────────────────────────────────────
-
-describe("reconciliation-edge-cases", () => {
-
-  // findForkPoint
-  test("findForkPoint returns -1 for completely diverged logs", () => {
-    const eA = makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" });
-    const eB = makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T02" });
-
-    const logA: WorkflowEvent[] = [eA];
-    const logB: WorkflowEvent[] = [eB];
-
-    assert.equal(findForkPoint(logA, logB), -1, "completely diverged logs should return -1");
-  });
-
-  test("findForkPoint returns last index when one log is prefix of another", () => {
-    const e1 = makeEvent("start_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" });
-    const e2 = makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" });
-    const e3 = makeEvent("complete_slice", { milestoneId: "M001", sliceId: "S01" });
-
-    const logA: WorkflowEvent[] = [e1, e2];
-    const logB: WorkflowEvent[] = [e1, e2, e3];
-
-    assert.equal(findForkPoint(logA, logB), 1, "prefix log should fork at last shared index");
-  });
-
-  test("findForkPoint returns -1 for empty logs", () => {
-    assert.equal(findForkPoint([], []), -1, "two empty logs should return -1");
-  });
-
-  // extractEntityKey
-  test("extractEntityKey returns null for malformed events (missing taskId)", () => {
-    const event = makeEvent("complete_task", {});
-    // params has no taskId — should return null rather than return a bad key
-    assert.equal(extractEntityKey(event), null, "missing taskId should yield null entity key");
-  });
-
-  test("extractEntityKey returns null for unknown commands", () => {
-    const event = makeEvent("future_cmd", { foo: "bar" });
-    assert.equal(extractEntityKey(event), null, "unknown command should yield null entity key");
-  });
-
-  test("plan_slice and complete_slice use different entity types", () => {
-    const planEvent = makeEvent("plan_slice", { sliceId: "S01" });
-    const completeEvent = makeEvent("complete_slice", { sliceId: "S01" });
-
-    const planKey = extractEntityKey(planEvent);
-    const completeKey = extractEntityKey(completeEvent);
-
-    assert.ok(planKey !== null, "plan_slice should produce an entity key");
-    assert.ok(completeKey !== null, "complete_slice should produce an entity key");
-    assert.equal(planKey!.type, "slice_plan", "plan_slice entity type should be 'slice_plan'");
-    assert.equal(completeKey!.type, "slice", "complete_slice entity type should be 'slice'");
-    assert.notEqual(
-      planKey!.type,
-      completeKey!.type,
-      "plan_slice and complete_slice must map to different entity types",
-    );
-  });
-
-  // detectConflicts
-  test("detectConflicts finds no conflicts when entities do not overlap", () => {
-    const mainDiverged: WorkflowEvent[] = [
-      makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" }),
-    ];
-    const wtDiverged: WorkflowEvent[] = [
-      makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T02" }),
-    ];
-
-    const conflicts = detectConflicts(mainDiverged, wtDiverged);
-    assert.equal(conflicts.length, 0, "non-overlapping task edits should produce no conflicts");
-  });
-
-  test("detectConflicts flags conflict when both sides touch the same task", () => {
-    const mainDiverged: WorkflowEvent[] = [
-      makeEvent("start_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" }),
-    ];
-    const wtDiverged: WorkflowEvent[] = [
-      makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" }),
-    ];
-
-    const conflicts = detectConflicts(mainDiverged, wtDiverged);
-    assert.equal(conflicts.length, 1, "same task touched by both sides should produce exactly one conflict");
-
-    const conflict = conflicts[0]!;
-    assert.equal(conflict.entityType, "task", "conflict entityType should be 'task'");
-    assert.equal(conflict.entityId, "T01", "conflict entityId should be 'T01'");
-  });
-
-  test("detectConflicts ignores events with null entity keys", () => {
-    // Events with unknown commands produce null keys and must not cause false conflicts.
-    const mainDiverged: WorkflowEvent[] = [
-      makeEvent("unknown_future_cmd", { milestoneId: "M001" }),
-    ];
-    const wtDiverged: WorkflowEvent[] = [
-      makeEvent("another_unknown_cmd", { milestoneId: "M001" }),
-    ];
-
-    const conflicts = detectConflicts(mainDiverged, wtDiverged);
-    assert.equal(conflicts.length, 0, "unknown commands with null entity keys should not produce conflicts");
-  });
-
-  // appendEvent — filesystem creation
-  test("appendEvent creates event log if directory does not exist", () => {
-    const base = tempDir();
-    // Remove the .gsd directory if it somehow exists — appendEvent should create it.
-    const gsdDir = path.join(base, ".gsd");
-    if (fs.existsSync(gsdDir)) fs.rmSync(gsdDir, { recursive: true, force: true });
-
-    appendEvent(base, {
-      cmd: "complete_task",
-      params: { milestoneId: "M001", sliceId: "S01", taskId: "T01" },
-      ts: new Date().toISOString(),
-      actor: "agent",
-    });
-
-    const logPath = path.join(base, ".gsd", "event-log.jsonl");
-    assert.ok(fs.existsSync(logPath), "event-log.jsonl should be created by appendEvent");
-
-    const events = readEvents(logPath);
-    assert.equal(events.length, 1, "event log should contain exactly one event");
-    assert.equal(events[0]!.cmd, "complete_task", "persisted event should have the correct cmd");
-  });
-});

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

@@ -1,233 +0,0 @@
-/**
- * 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).
- *
- * 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
- * S03). Without slice reconciliation, S01-S03 are invisible and S04 is
- * permanently blocked.
- */
-
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { deriveStateFromDb, invalidateStateCache } from "../state.ts";
-import {
-  openDatabase,
-  closeDatabase,
-  insertMilestone,
-  insertSlice,
-  getMilestoneSlices,
-} from "../gsd-db.ts";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
-
-function createFixtureBase(): string {
-  const base = mkdtempSync(join(tmpdir(), "gsd-slice-reconcile-"));
-  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
-  return base;
-}
-
-function writeFile(base: string, relativePath: string, content: string): void {
-  const full = join(base, ".gsd", relativePath);
-  mkdirSync(join(full, ".."), { recursive: true });
-  writeFileSync(full, content);
-}
-
-function cleanup(base: string): void {
-  rmSync(base, { recursive: true, force: true });
-}
-
-const CONTEXT_CONTENT = `# M001: Test Milestone
-
-This milestone tests slice reconciliation.
-
-## Must-Haves
-- Something important
-`;
-
-// Roadmap with 4 slices: S01 (no deps), S02 (no deps), S03 (depends S01), S04 (depends S03)
-const ROADMAP_CONTENT = `# M001: Test Milestone
-
-**Vision:** Test slice disk→DB reconciliation.
-
-## Slices
-
-- [x] **S01: Foundation** \`risk:low\` \`depends:[]\`
-  > Set up project structure.
-- [x] **S02: Core Utils** \`risk:low\` \`depends:[]\`
-  > Build utility functions.
-- [ ] **S03: Integration** \`risk:medium\` \`depends:[S01]\`
-  > Integrate components.
-- [ ] **S04: Final Assembly** \`risk:high\` \`depends:[S03]\`
-  > Assemble everything.
-`;
-
-async function testMissingSlicesCauseBlock(): Promise<void> {
-  console.log("\n--- Test: missing DB slices cause permanent block (pre-fix) ---");
-
-  const base = createFixtureBase();
-  const dbPath = join(base, ".gsd", "gsd.db");
-
-  try {
-    openDatabase(dbPath);
-
-    // M001 in DB
-    insertMilestone({ id: "M001", title: "M001: Test Milestone", status: "active", depends_on: [] });
-
-    // Only S04 is in the DB — S01-S03 are missing
-    insertSlice({ id: "S04", milestoneId: "M001", title: "S04: Final Assembly", status: "pending", risk: "high", depends: ["S03"] });
-
-    // Write disk files — S01 and S02 have SUMMARY (complete on disk)
-    writeFile(base, "milestones/M001/CONTEXT.md", CONTEXT_CONTENT);
-    writeFile(base, "milestones/M001/ROADMAP.md", ROADMAP_CONTENT);
-    writeFile(base, "milestones/M001/S01/PLAN.md", "# S01 Plan\n");
-    writeFile(base, "milestones/M001/S01/SUMMARY.md", "# S01 Summary\nDone.");
-    writeFile(base, "milestones/M001/S02/PLAN.md", "# S02 Plan\n");
-    writeFile(base, "milestones/M001/S02/SUMMARY.md", "# S02 Summary\nDone.");
-    writeFile(base, "milestones/M001/S03/PLAN.md", "# S03 Plan\n");
-
-    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)",
-      );
-    }
-  } finally {
-    closeDatabase();
-    cleanup(base);
-  }
-}
-
-async function testSliceReconciliationIdempotent(): Promise<void> {
-  console.log("\n--- Test: slice reconciliation is idempotent ---");
-
-  const base = createFixtureBase();
-  const dbPath = join(base, ".gsd", "gsd.db");
-
-  try {
-    openDatabase(dbPath);
-
-    insertMilestone({ id: "M001", title: "M001: Test", status: "active", depends_on: [] });
-    // S01 already in DB with correct status
-    insertSlice({ id: "S01", milestoneId: "M001", title: "S01: Foundation", status: "complete", depends: [] });
-
-    writeFile(base, "milestones/M001/CONTEXT.md", CONTEXT_CONTENT);
-    writeFile(base, "milestones/M001/ROADMAP.md", ROADMAP_CONTENT);
-    writeFile(base, "milestones/M001/S01/PLAN.md", "# S01 Plan\n");
-    writeFile(base, "milestones/M001/S01/SUMMARY.md", "# S01 Summary\nDone.");
-    writeFile(base, "milestones/M001/S02/PLAN.md", "# S02 Plan\n");
-    writeFile(base, "milestones/M001/S02/SUMMARY.md", "# S02 Summary\nDone.");
-
-    invalidateStateCache();
-    await deriveStateFromDb(base);
-
-    // S01 should still be complete (not overwritten)
-    const dbSlices = getMilestoneSlices("M001");
-    const s01 = dbSlices.find(s => s.id === "S01");
-    assertTrue(s01 !== undefined, "S01 should still exist in DB");
-    if (s01) {
-      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}`,
-    );
-  } finally {
-    closeDatabase();
-    cleanup(base);
-  }
-}
-
-async function testNoRoadmapSkipsReconciliation(): Promise<void> {
-  console.log("\n--- Test: no ROADMAP file skips slice reconciliation ---");
-
-  const base = createFixtureBase();
-  const dbPath = join(base, ".gsd", "gsd.db");
-
-  try {
-    openDatabase(dbPath);
-
-    insertMilestone({ id: "M001", title: "M001: No Roadmap", status: "active", depends_on: [] });
-
-    // Only a CONTEXT file, no ROADMAP
-    writeFile(base, "milestones/M001/CONTEXT.md", CONTEXT_CONTENT);
-
-    invalidateStateCache();
-    const state = await deriveStateFromDb(base);
-
-    const dbSlices = getMilestoneSlices("M001");
-    assertEq(dbSlices.length, 0, "No slices should be added when no ROADMAP exists");
-
-    // Should be in pre-planning (no roadmap)
-    assertEq(state.phase, "pre-planning", "Phase should be pre-planning with no roadmap");
-  } finally {
-    closeDatabase();
-    cleanup(base);
-  }
-}
-
-async function main(): Promise<void> {
-  console.log("\n=== #2533: deriveStateFromDb reconciles disk slices ===");
-
-  await testMissingSlicesCauseBlock();
-  await testSliceReconciliationIdempotent();
-  await testNoRoadmapSkipsReconciliation();
-
-  report();
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});