gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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

@@ -5,6 +5,8 @@
  * Runs in a real temp git repo.
  */
 
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -20,10 +22,9 @@ import {
   getActiveAutoWorktreeContext,
 } from "../auto-worktree.ts";
 
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
-
+// Note: execSync is used intentionally in tests for git operations with
+// controlled, hardcoded inputs (no user input). This is safe and matches
+// the pattern used by the original test file.
 function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
@@ -42,11 +43,19 @@ function createTempRepo(): string {
   return dir;
 }
 
-async function main(): Promise<void> {
+describe("auto-worktree lifecycle", () => {
   const savedCwd = process.cwd();
   let tempDir = "";
 
-  try {
+  afterEach(() => {
+    process.chdir(savedCwd);
+    if (tempDir && existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+    tempDir = "";
+  });
+
+  test("create → detect → teardown", () => {
     tempDir = createTempRepo();
 
     // Create .gsd/milestones/M003 with a dummy file (simulates planning artifacts)
@@ -56,28 +65,26 @@ async function main(): Promise<void> {
     run("git add .", tempDir);
     run("git commit -m \"add milestone\"", tempDir);
 
-    console.log("\n=== auto-worktree lifecycle ===");
-
     // ─── createAutoWorktree ──────────────────────────────────────────
     const wtPath = createAutoWorktree(tempDir, "M003");
 
-    assertTrue(existsSync(wtPath), "worktree directory exists after create");
-    assertEq(process.cwd(), wtPath, "process.cwd() is worktree path after create");
+    assert.ok(existsSync(wtPath), "worktree directory exists after create");
+    assert.strictEqual(process.cwd(), wtPath, "process.cwd() is worktree path after create");
 
     const branch = run("git branch --show-current", wtPath);
-    assertEq(branch, "milestone/M003", "git branch is milestone/M003");
+    assert.strictEqual(branch, "milestone/M003", "git branch is milestone/M003");
 
-    assertTrue(
+    assert.ok(
       existsSync(join(wtPath, ".gsd", "milestones", "M003", "CONTEXT.md")),
       "planning files inherited in worktree",
     );
 
     // ─── isInAutoWorktree ────────────────────────────────────────────
-    assertTrue(isInAutoWorktree(tempDir), "isInAutoWorktree returns true when inside");
+    assert.ok(isInAutoWorktree(tempDir), "isInAutoWorktree returns true when inside");
 
     // ─── getAutoWorktreeOriginalBase ─────────────────────────────────
-    assertEq(getAutoWorktreeOriginalBase(), tempDir, "originalBase returns temp dir");
-    assertEq(
+    assert.strictEqual(getAutoWorktreeOriginalBase(), tempDir, "originalBase returns temp dir");
+    assert.deepStrictEqual(
       getActiveAutoWorktreeContext(),
       {
         originalBase: tempDir,
@@ -88,33 +95,39 @@ async function main(): Promise<void> {
     );
 
     // ─── getAutoWorktreePath ─────────────────────────────────────────
-    assertEq(getAutoWorktreePath(tempDir, "M003"), wtPath, "getAutoWorktreePath returns correct path");
-    assertEq(getAutoWorktreePath(tempDir, "M999"), null, "getAutoWorktreePath returns null for nonexistent");
+    assert.strictEqual(getAutoWorktreePath(tempDir, "M003"), wtPath, "getAutoWorktreePath returns correct path");
+    assert.strictEqual(getAutoWorktreePath(tempDir, "M999"), null, "getAutoWorktreePath returns null for nonexistent");
 
     // ─── teardownAutoWorktree ────────────────────────────────────────
     teardownAutoWorktree(tempDir, "M003");
 
-    assertEq(process.cwd(), tempDir, "process.cwd() back to original after teardown");
-    assertTrue(!existsSync(wtPath), "worktree directory removed after teardown");
-    assertTrue(!isInAutoWorktree(tempDir), "isInAutoWorktree returns false after teardown");
-    assertEq(getAutoWorktreeOriginalBase(), null, "originalBase is null after teardown");
-    assertEq(getActiveAutoWorktreeContext(), null, "active auto-worktree context clears after teardown");
+    assert.strictEqual(process.cwd(), tempDir, "process.cwd() back to original after teardown");
+    assert.ok(!existsSync(wtPath), "worktree directory removed after teardown");
+    assert.ok(!isInAutoWorktree(tempDir), "isInAutoWorktree returns false after teardown");
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null, "originalBase is null after teardown");
+    assert.strictEqual(getActiveAutoWorktreeContext(), null, "active auto-worktree context clears after teardown");
+  });
 
-    // ─── Re-entry: create again, exit without teardown, re-enter ─────
-    console.log("\n=== re-entry ===");
+  test("re-entry: create again, exit without teardown, re-enter", () => {
+    tempDir = createTempRepo();
+    const msDir = join(tempDir, ".gsd", "milestones", "M003");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M003 Context\n");
+    run("git add .", tempDir);
+    run("git commit -m \"add milestone\"", tempDir);
 
     const wtPath2 = createAutoWorktree(tempDir, "M003");
-    assertTrue(existsSync(wtPath2), "worktree re-created");
+    assert.ok(existsSync(wtPath2), "worktree re-created");
 
     // Manually chdir out (simulates pause/crash)
     process.chdir(tempDir);
 
     // enterAutoWorktree should re-enter
     const entered = enterAutoWorktree(tempDir, "M003");
-    assertEq(process.cwd(), entered, "re-entered worktree via enterAutoWorktree");
-    assertEq(getAutoWorktreeOriginalBase(), tempDir, "originalBase restored on re-entry");
-    assertTrue(isInAutoWorktree(tempDir), "isInAutoWorktree true after re-entry");
-    assertEq(
+    assert.strictEqual(process.cwd(), entered, "re-entered worktree via enterAutoWorktree");
+    assert.strictEqual(getAutoWorktreeOriginalBase(), tempDir, "originalBase restored on re-entry");
+    assert.ok(isInAutoWorktree(tempDir), "isInAutoWorktree true after re-entry");
+    assert.deepStrictEqual(
       getActiveAutoWorktreeContext(),
       {
         originalBase: tempDir,
@@ -126,142 +139,151 @@ async function main(): Promise<void> {
 
     // Cleanup
     teardownAutoWorktree(tempDir, "M003");
+  });
 
-    // ─── Coexistence with manual worktree ─────────────────────────────
-    console.log("\n=== coexistence ===");
+  test("coexistence with manual worktree", async () => {
+    tempDir = createTempRepo();
+    const msDir = join(tempDir, ".gsd", "milestones", "M003");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M003 Context\n");
+    run("git add .", tempDir);
+    run("git commit -m \"add milestone\"", tempDir);
 
     // Import createWorktree directly for manual worktree
     const { createWorktree } = await import("../worktree-manager.ts");
 
     // Create manual worktree (uses worktree/<name> branch)
     const manualWt = createWorktree(tempDir, "feature-x");
-    assertTrue(existsSync(manualWt.path), "manual worktree exists");
-    assertEq(manualWt.branch, "worktree/feature-x", "manual worktree uses worktree/ prefix");
+    assert.ok(existsSync(manualWt.path), "manual worktree exists");
+    assert.strictEqual(manualWt.branch, "worktree/feature-x", "manual worktree uses worktree/ prefix");
 
     // Create auto-worktree alongside
     const autoWtPath = createAutoWorktree(tempDir, "M003");
-    assertTrue(existsSync(autoWtPath), "auto-worktree coexists with manual");
-    assertTrue(existsSync(manualWt.path), "manual worktree still exists");
+    assert.ok(existsSync(autoWtPath), "auto-worktree coexists with manual");
+    assert.ok(existsSync(manualWt.path), "manual worktree still exists");
 
     // Cleanup both
     teardownAutoWorktree(tempDir, "M003");
     const { removeWorktree } = await import("../worktree-manager.ts");
     removeWorktree(tempDir, "feature-x");
+  });
 
-    // ─── Failure: split-brain prevention ──────────────────────────────
-    console.log("\n=== split-brain prevention ===");
-    // After teardown, originalBase should be null
-    assertEq(getAutoWorktreeOriginalBase(), null, "no split-brain: originalBase cleared");
+  test("split-brain prevention: originalBase cleared after teardown", () => {
+    tempDir = createTempRepo();
+    const msDir = join(tempDir, ".gsd", "milestones", "M003");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M003 Context\n");
+    run("git add .", tempDir);
+    run("git commit -m \"add milestone\"", tempDir);
 
-    // ─── #1526: getMainBranch returns milestone branch in auto-worktree ──
-    console.log("\n=== #1526: getMainBranch() returns milestone/<MID> in auto-worktree ===");
-    {
-      const { GitServiceImpl } = await import("../git-service.ts");
+    createAutoWorktree(tempDir, "M003");
+    teardownAutoWorktree(tempDir, "M003");
 
-      // Create worktree
-      const wtPath = createAutoWorktree(tempDir, "M005");
-      // Don't set main_branch pref so getMainBranch falls through to worktree detection
-      const gitService = new GitServiceImpl(wtPath);
-      gitService.setMilestoneId("M005");
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null, "no split-brain: originalBase cleared");
+  });
 
-      // Verify getMainBranch returns the milestone branch
-      const mainBranch = gitService.getMainBranch();
-      assertEq(mainBranch, "milestone/M005", "getMainBranch returns milestone/<MID> in auto-worktree");
+  test("#1526: getMainBranch returns milestone/<MID> in auto-worktree", async () => {
+    tempDir = createTempRepo();
+    const msDir = join(tempDir, ".gsd", "milestones", "M005");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M005 Context\n");
+    run("git add .", tempDir);
+    run("git commit -m \"add milestone\"", tempDir);
 
-      // Cleanup
-      teardownAutoWorktree(tempDir, "M005");
-    }
+    const { GitServiceImpl } = await import("../git-service.ts");
 
-    // ─── #1713: stale worktree directory recovery ─────────────────────
-    console.log("\n=== #1713: stale worktree directory without .git file ===");
-    {
-      // Simulate a crash leaving a stale directory with no .git file.
-      // createAutoWorktree should detect and remove the stale directory,
-      // then successfully create a fresh worktree.
-      const { worktreePath } = await import("../worktree-manager.ts");
-      const staleDir = worktreePath(tempDir, "M010");
-      mkdirSync(staleDir, { recursive: true });
-      // Write a dummy file to prove it's not an empty directory
-      writeFileSync(join(staleDir, "orphan.txt"), "stale leftover\n");
-      assertTrue(existsSync(staleDir), "stale directory exists before recovery");
-      assertTrue(!existsSync(join(staleDir, ".git")), "stale directory has no .git file");
-
-      // createAutoWorktree should remove the stale dir and create a real worktree
-      const recoveredPath = createAutoWorktree(tempDir, "M010");
-      assertTrue(existsSync(recoveredPath), "worktree created after stale dir recovery");
-      assertTrue(existsSync(join(recoveredPath, ".git")), "recovered worktree has .git file");
-      assertTrue(!existsSync(join(recoveredPath, "orphan.txt")), "stale file removed by recovery");
-
-      teardownAutoWorktree(tempDir, "M010");
-    }
+    // Create worktree
+    const wtPath = createAutoWorktree(tempDir, "M005");
+    // Don't set main_branch pref so getMainBranch falls through to worktree detection
+    const gitService = new GitServiceImpl(wtPath);
+    gitService.setMilestoneId("M005");
 
-    // ─── #778: reconcile plan checkboxes on re-attach ─────────────────
-    console.log("\n=== #778: reconcile plan checkboxes on re-attach ===");
-    {
-      // Simulate: T01 [x] was committed to milestone branch, T02 [x] was
-      // written to project root by syncStateToProjectRoot() but the
-      // auto-commit crashed before it fired. On restart the worktree is
-      // re-created from the milestone branch HEAD (T02 still [ ]).
-      // reconcilePlanCheckboxes should forward-apply T02 [x] from the root.
-
-      const planRelPath = join(".gsd", "milestones", "M004", "slices", "S01", "S01-PLAN.md");
-      const planDir = join(tempDir, ".gsd", "milestones", "M004", "slices", "S01");
-      const { mkdirSync: mkdir, writeFileSync: write, readFileSync: read } = await import("node:fs");
-
-      // Plan on integration branch (project root): T01 [x], T02 [x]
-      mkdir(planDir, { recursive: true });
-      write(
-        join(tempDir, planRelPath),
-        "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
-      );
-
-      // Write integration-branch plan to git so milestone branch starts from it
-      run(`git add .`, tempDir);
-      run(`git commit -m "add plan with T01 and T02 checked" --allow-empty`, tempDir);
-
-      // Create milestone branch with only T01 [x] (simulating crash before T02 commit)
-      const milestoneBranch = "milestone/M004";
-      run(`git checkout -b ${milestoneBranch}`, tempDir);
-      mkdir(planDir, { recursive: true });
-      write(
-        join(tempDir, planRelPath),
-        "# S01 Plan\n- [x] **T01:** task one\n- [ ] **T02:** task two\n- [ ] **T03:** task three\n",
-      );
-      run(`git add .`, tempDir);
-      run(`git commit -m "milestone: only T01 checked"`, tempDir);
-      run(`git checkout main`, tempDir);
-
-      // Restore project root plan (T01+T02 [x]) — simulates syncStateToProjectRoot
-      write(
-        join(tempDir, planRelPath),
-        "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
-      );
-
-      // Create worktree re-attached to existing milestone branch (T02 still [ ] in branch)
-      const wtPath = createAutoWorktree(tempDir, "M004");
-
-      try {
-        const wtPlanPath = join(wtPath, planRelPath);
-        assertTrue(existsSync(wtPlanPath), "plan file exists in worktree after re-attach");
-
-        const wtPlan = read(wtPlanPath, "utf-8");
-        assertTrue(wtPlan.includes("- [x] **T02:"), "T02 should be [x] after reconciliation (was [ ] on branch)");
-        assertTrue(wtPlan.includes("- [x] **T01:"), "T01 stays [x]");
-        assertTrue(wtPlan.includes("- [ ] **T03:"), "T03 stays [ ] (not in root either)");
-      } finally {
-        teardownAutoWorktree(tempDir, "M004");
-      }
-    }
+    // Verify getMainBranch returns the milestone branch
+    const mainBranch = gitService.getMainBranch();
+    assert.strictEqual(mainBranch, "milestone/M005", "getMainBranch returns milestone/<MID> in auto-worktree");
 
-  } finally {
-    // Always restore cwd and clean up
-    process.chdir(savedCwd);
-    if (tempDir && existsSync(tempDir)) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-  }
+    // Cleanup
+    teardownAutoWorktree(tempDir, "M005");
+  });
 
-  report();
-}
+  test("#1713: stale worktree directory without .git file", async () => {
+    tempDir = createTempRepo();
+    const msDir = join(tempDir, ".gsd", "milestones", "M010");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M010 Context\n");
+    run("git add .", tempDir);
+    run("git commit -m \"add milestone\"", tempDir);
+
+    // Simulate a crash leaving a stale directory with no .git file.
+    const { worktreePath } = await import("../worktree-manager.ts");
+    const staleDir = worktreePath(tempDir, "M010");
+    mkdirSync(staleDir, { recursive: true });
+    writeFileSync(join(staleDir, "orphan.txt"), "stale leftover\n");
+    assert.ok(existsSync(staleDir), "stale directory exists before recovery");
+    assert.ok(!existsSync(join(staleDir, ".git")), "stale directory has no .git file");
+
+    // createAutoWorktree should remove the stale dir and create a real worktree
+    const recoveredPath = createAutoWorktree(tempDir, "M010");
+    assert.ok(existsSync(recoveredPath), "worktree created after stale dir recovery");
+    assert.ok(existsSync(join(recoveredPath, ".git")), "recovered worktree has .git file");
+    assert.ok(!existsSync(join(recoveredPath, "orphan.txt")), "stale file removed by recovery");
+
+    teardownAutoWorktree(tempDir, "M010");
+  });
+
+  test("#778: reconcile plan checkboxes on re-attach", async () => {
+    tempDir = createTempRepo();
+    const msDir = join(tempDir, ".gsd", "milestones", "M003");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M003 Context\n");
+    run("git add .", tempDir);
+    run("git commit -m \"add milestone\"", tempDir);
+
+    const planRelPath = join(".gsd", "milestones", "M004", "slices", "S01", "S01-PLAN.md");
+    const planDir = join(tempDir, ".gsd", "milestones", "M004", "slices", "S01");
+    const { mkdirSync: mkdir, writeFileSync: write, readFileSync: read } = await import("node:fs");
+
+    // Plan on integration branch (project root): T01 [x], T02 [x]
+    mkdir(planDir, { recursive: true });
+    write(
+      join(tempDir, planRelPath),
+      "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
+    );
+
+    run(`git add .`, tempDir);
+    run(`git commit -m "add plan with T01 and T02 checked" --allow-empty`, tempDir);
+
+    // Create milestone branch with only T01 [x] (simulating crash before T02 commit)
+    const milestoneBranch = "milestone/M004";
+    run(`git checkout -b ${milestoneBranch}`, tempDir);
+    mkdir(planDir, { recursive: true });
+    write(
+      join(tempDir, planRelPath),
+      "# S01 Plan\n- [x] **T01:** task one\n- [ ] **T02:** task two\n- [ ] **T03:** task three\n",
+    );
+    run(`git add .`, tempDir);
+    run(`git commit -m "milestone: only T01 checked"`, tempDir);
+    run(`git checkout main`, tempDir);
+
+    // Restore project root plan (T01+T02 [x])
+    write(
+      join(tempDir, planRelPath),
+      "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
+    );
+
+    // Create worktree re-attached to existing milestone branch (T02 still [ ] in branch)
+    const wtPath = createAutoWorktree(tempDir, "M004");
 
-main();
+    try {
+      const wtPlanPath = join(wtPath, planRelPath);
+      assert.ok(existsSync(wtPlanPath), "plan file exists in worktree after re-attach");
+
+      const wtPlan = read(wtPlanPath, "utf-8");
+      assert.ok(wtPlan.includes("- [x] **T02:"), "T02 should be [x] after reconciliation (was [ ] on branch)");
+      assert.ok(wtPlan.includes("- [x] **T01:"), "T01 stays [x]");
+      assert.ok(wtPlan.includes("- [ ] **T03:"), "T03 stays [ ] (not in root either)");
+    } finally {
+      teardownAutoWorktree(tempDir, "M004");
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/cache-staleness-regression.test.ts

@@ -12,15 +12,14 @@
  * Pattern: derive state → write file → invalidate cache → derive again → verify update
  */
 
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
 import { deriveState, invalidateStateCache } from '../state.ts';
 import { invalidateAllCaches } from '../cache.ts';
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
 
 function createBase(): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-cache-stale-'));
@@ -44,11 +43,9 @@ function writeSliceFile(base: string, mid: string, sid: string, suffix: string,
   writeFileSync(join(dir, `${sid}-${suffix}.md`), content);
 }
 
-async function main(): Promise<void> {
+describe("cache-staleness-regression", () => {
 
-  // ─── 1. Regression #1240: New roadmap detected after cache invalidation ─
-  console.log('\n=== 1. #1240: roadmap written after first derive → detected after invalidation ===');
-  {
+  test("#1240: roadmap written after first derive → detected after invalidation", async () => {
     const base = createBase();
     try {
       // Step 1: Create milestone with just context (no roadmap)
@@ -57,7 +54,7 @@ async function main(): Promise<void> {
       invalidateAllCaches();
       invalidateStateCache();
       const state1 = await deriveState(base);
-      assertEq(state1.phase, 'pre-planning', 'initial: pre-planning (no roadmap)');
+      assert.strictEqual(state1.phase, 'pre-planning', 'initial: pre-planning (no roadmap)');
 
       // Step 2: Write roadmap (simulating what the LLM does during planning)
       const roadmap = [
@@ -80,16 +77,14 @@ async function main(): Promise<void> {
       invalidateAllCaches();
       invalidateStateCache();
       const state2 = await deriveState(base);
-      assertEq(state2.phase, 'planning', '#1240: after roadmap write + invalidation → planning phase');
-      assertEq(state2.activeSlice?.id, 'S01', '#1240: S01 is now the active slice');
+      assert.strictEqual(state2.phase, 'planning', '#1240: after roadmap write + invalidation → planning phase');
+      assert.strictEqual(state2.activeSlice?.id, 'S01', '#1240: S01 is now the active slice');
     } finally {
       cleanup(base);
     }
-  }
+  });
 
-  // ─── 2. Regression #1249: Slice context detected after cache invalidation ─
-  console.log('\n=== 2. #1249: slice context written mid-loop → detected after invalidation ===');
-  {
+  test("#1249: slice context written mid-loop → detected after invalidation", async () => {
     const base = createBase();
     try {
       // Create a milestone in needs-discussion phase (CONTEXT-DRAFT, no CONTEXT)
@@ -100,7 +95,7 @@ async function main(): Promise<void> {
       invalidateAllCaches();
       invalidateStateCache();
       const state1 = await deriveState(base);
-      assertEq(state1.phase, 'needs-discussion', 'initial: needs-discussion');
+      assert.strictEqual(state1.phase, 'needs-discussion', 'initial: needs-discussion');
 
       // Simulate: discussion completes, CONTEXT.md is written
       writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001: Test\n\nFull context after discussion.\n');
@@ -112,21 +107,16 @@ async function main(): Promise<void> {
       invalidateAllCaches();
       invalidateStateCache();
       const state2 = await deriveState(base);
-      // Should now be pre-planning (has context, but no roadmap yet)
-      // Actually needs-discussion won't trigger because now CONTEXT exists
-      // The state should advance past needs-discussion
-      assertTrue(
+      assert.ok(
         state2.phase !== 'needs-discussion',
         '#1249: after context write + invalidation → not stuck in needs-discussion',
       );
     } finally {
       cleanup(base);
     }
-  }
+  });
 
-  // ─── 3. State cache TTL expires naturally ─────────────────────────────
-  console.log('\n=== 3. state cache TTL: fresh reads after 100ms ===');
-  {
+  test("state cache TTL: fresh reads after 100ms", async () => {
     const base = createBase();
     try {
       writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001\n\nDesc.\n');
@@ -134,7 +124,7 @@ async function main(): Promise<void> {
       invalidateAllCaches();
       invalidateStateCache();
       const state1 = await deriveState(base);
-      assertEq(state1.phase, 'pre-planning', 'initial: pre-planning');
+      assert.strictEqual(state1.phase, 'pre-planning', 'initial: pre-planning');
 
       // Write roadmap immediately
       writeMilestoneFile(base, 'M001', 'ROADMAP', [
@@ -157,15 +147,13 @@ async function main(): Promise<void> {
       invalidateAllCaches();
       invalidateStateCache();
       const state3 = await deriveState(base);
-      assertEq(state3.phase, 'planning', 'after TTL expiry + invalidation → planning');
+      assert.strictEqual(state3.phase, 'planning', 'after TTL expiry + invalidation → planning');
     } finally {
       cleanup(base);
     }
-  }
+  });
 
-  // ─── 4. Task completion detection after file write ────────────────────
-  console.log('\n=== 4. task marked done in plan → state advances ===');
-  {
+  test("task marked done in plan → state advances", async () => {
     const base = createBase();
     try {
       writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001\n\nDesc.\n');
@@ -194,7 +182,7 @@ async function main(): Promise<void> {
       invalidateAllCaches();
       invalidateStateCache();
       const state1 = await deriveState(base);
-      assertEq(state1.activeTask?.id, 'T01', 'initial: T01 is active task');
+      assert.strictEqual(state1.activeTask?.id, 'T01', 'initial: T01 is active task');
 
       // Mark T01 as done by rewriting the plan
       writeSliceFile(base, 'M001', 'S01', 'PLAN', [
@@ -210,15 +198,13 @@ async function main(): Promise<void> {
       invalidateAllCaches();
       invalidateStateCache();
       const state2 = await deriveState(base);
-      assertEq(state2.activeTask?.id, 'T02', 'after T01 done → T02 is active task');
+      assert.strictEqual(state2.activeTask?.id, 'T02', 'after T01 done → T02 is active task');
     } finally {
       cleanup(base);
     }
-  }
+  });
 
-  // ─── 5. Slice completion detection ────────────────────────────────────
-  console.log('\n=== 5. all tasks done → summarizing phase ===');
-  {
+  test("all tasks done → summarizing phase", async () => {
     const base = createBase();
     try {
       writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001\n\nDesc.\n');
@@ -245,7 +231,7 @@ async function main(): Promise<void> {
       invalidateAllCaches();
       invalidateStateCache();
       const state1 = await deriveState(base);
-      assertEq(state1.phase, 'executing', 'initial: executing');
+      assert.strictEqual(state1.phase, 'executing', 'initial: executing');
 
       // Mark task done
       writeSliceFile(base, 'M001', 'S01', 'PLAN', [
@@ -260,15 +246,13 @@ async function main(): Promise<void> {
       invalidateAllCaches();
       invalidateStateCache();
       const state2 = await deriveState(base);
-      assertEq(state2.phase, 'summarizing', 'after all tasks done → summarizing');
+      assert.strictEqual(state2.phase, 'summarizing', 'after all tasks done → summarizing');
     } finally {
       cleanup(base);
     }
-  }
+  });
 
-  // ─── 6. Roadmap slice marked done → advance to next slice ─────────────
-  console.log('\n=== 6. roadmap slice marked [x] → next slice active ===');
-  {
+  test("roadmap slice marked [x] → next slice active", async () => {
     const base = createBase();
     try {
       writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001\n\nDesc.\n');
@@ -285,7 +269,7 @@ async function main(): Promise<void> {
       invalidateAllCaches();
       invalidateStateCache();
       const state1 = await deriveState(base);
-      assertEq(state1.activeSlice?.id, 'S01', 'initial: S01 active');
+      assert.strictEqual(state1.activeSlice?.id, 'S01', 'initial: S01 active');
 
       // Mark S01 as done in roadmap
       writeMilestoneFile(base, 'M001', 'ROADMAP', [
@@ -302,16 +286,9 @@ async function main(): Promise<void> {
       invalidateAllCaches();
       invalidateStateCache();
       const state2 = await deriveState(base);
-      assertEq(state2.activeSlice?.id, 'S02', 'after S01 done → S02 active');
+      assert.strictEqual(state2.activeSlice?.id, 'S02', 'after S01 done → S02 active');
     } finally {
       cleanup(base);
     }
-  }
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
+  });
 });