gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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

@@ -5,8 +5,6 @@
  * 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";
@@ -22,9 +20,10 @@ import {
   getActiveAutoWorktreeContext,
 } from "../auto-worktree.ts";
 
-// 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.
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
 function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
@@ -43,19 +42,11 @@ function createTempRepo(): string {
   return dir;
 }
 
-describe("auto-worktree lifecycle", () => {
+async function main(): Promise<void> {
   const savedCwd = process.cwd();
   let tempDir = "";
 
-  afterEach(() => {
-    process.chdir(savedCwd);
-    if (tempDir && existsSync(tempDir)) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-    tempDir = "";
-  });
-
-  test("create → detect → teardown", () => {
+  try {
     tempDir = createTempRepo();
 
     // Create .gsd/milestones/M003 with a dummy file (simulates planning artifacts)
@@ -65,26 +56,28 @@ describe("auto-worktree lifecycle", () => {
     run("git add .", tempDir);
     run("git commit -m \"add milestone\"", tempDir);
 
+    console.log("\n=== auto-worktree lifecycle ===");
+
     // ─── createAutoWorktree ──────────────────────────────────────────
     const wtPath = createAutoWorktree(tempDir, "M003");
 
-    assert.ok(existsSync(wtPath), "worktree directory exists after create");
-    assert.strictEqual(process.cwd(), wtPath, "process.cwd() is worktree path after create");
+    assertTrue(existsSync(wtPath), "worktree directory exists after create");
+    assertEq(process.cwd(), wtPath, "process.cwd() is worktree path after create");
 
     const branch = run("git branch --show-current", wtPath);
-    assert.strictEqual(branch, "milestone/M003", "git branch is milestone/M003");
+    assertEq(branch, "milestone/M003", "git branch is milestone/M003");
 
-    assert.ok(
+    assertTrue(
       existsSync(join(wtPath, ".gsd", "milestones", "M003", "CONTEXT.md")),
       "planning files inherited in worktree",
     );
 
     // ─── isInAutoWorktree ────────────────────────────────────────────
-    assert.ok(isInAutoWorktree(tempDir), "isInAutoWorktree returns true when inside");
+    assertTrue(isInAutoWorktree(tempDir), "isInAutoWorktree returns true when inside");
 
     // ─── getAutoWorktreeOriginalBase ─────────────────────────────────
-    assert.strictEqual(getAutoWorktreeOriginalBase(), tempDir, "originalBase returns temp dir");
-    assert.deepStrictEqual(
+    assertEq(getAutoWorktreeOriginalBase(), tempDir, "originalBase returns temp dir");
+    assertEq(
       getActiveAutoWorktreeContext(),
       {
         originalBase: tempDir,
@@ -95,39 +88,33 @@ describe("auto-worktree lifecycle", () => {
     );
 
     // ─── getAutoWorktreePath ─────────────────────────────────────────
-    assert.strictEqual(getAutoWorktreePath(tempDir, "M003"), wtPath, "getAutoWorktreePath returns correct path");
-    assert.strictEqual(getAutoWorktreePath(tempDir, "M999"), null, "getAutoWorktreePath returns null for nonexistent");
+    assertEq(getAutoWorktreePath(tempDir, "M003"), wtPath, "getAutoWorktreePath returns correct path");
+    assertEq(getAutoWorktreePath(tempDir, "M999"), null, "getAutoWorktreePath returns null for nonexistent");
 
     // ─── teardownAutoWorktree ────────────────────────────────────────
     teardownAutoWorktree(tempDir, "M003");
 
-    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");
-  });
+    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");
 
-  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);
+    // ─── Re-entry: create again, exit without teardown, re-enter ─────
+    console.log("\n=== re-entry ===");
 
     const wtPath2 = createAutoWorktree(tempDir, "M003");
-    assert.ok(existsSync(wtPath2), "worktree re-created");
+    assertTrue(existsSync(wtPath2), "worktree re-created");
 
     // Manually chdir out (simulates pause/crash)
     process.chdir(tempDir);
 
     // enterAutoWorktree should re-enter
     const entered = enterAutoWorktree(tempDir, "M003");
-    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(
+    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(
       getActiveAutoWorktreeContext(),
       {
         originalBase: tempDir,
@@ -139,151 +126,142 @@ describe("auto-worktree lifecycle", () => {
 
     // Cleanup
     teardownAutoWorktree(tempDir, "M003");
-  });
 
-  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);
+    // ─── Coexistence with manual worktree ─────────────────────────────
+    console.log("\n=== coexistence ===");
 
     // 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");
-    assert.ok(existsSync(manualWt.path), "manual worktree exists");
-    assert.strictEqual(manualWt.branch, "worktree/feature-x", "manual worktree uses worktree/ prefix");
+    assertTrue(existsSync(manualWt.path), "manual worktree exists");
+    assertEq(manualWt.branch, "worktree/feature-x", "manual worktree uses worktree/ prefix");
 
     // Create auto-worktree alongside
     const autoWtPath = createAutoWorktree(tempDir, "M003");
-    assert.ok(existsSync(autoWtPath), "auto-worktree coexists with manual");
-    assert.ok(existsSync(manualWt.path), "manual worktree still exists");
+    assertTrue(existsSync(autoWtPath), "auto-worktree coexists with manual");
+    assertTrue(existsSync(manualWt.path), "manual worktree still exists");
 
     // Cleanup both
     teardownAutoWorktree(tempDir, "M003");
     const { removeWorktree } = await import("../worktree-manager.ts");
     removeWorktree(tempDir, "feature-x");
-  });
-
-  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);
-
-    createAutoWorktree(tempDir, "M003");
-    teardownAutoWorktree(tempDir, "M003");
-
-    assert.strictEqual(getAutoWorktreeOriginalBase(), null, "no split-brain: originalBase cleared");
-  });
-
-  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);
-
-    const { GitServiceImpl } = await import("../git-service.ts");
-
-    // 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");
-
-    // Verify getMainBranch returns the milestone branch
-    const mainBranch = gitService.getMainBranch();
-    assert.strictEqual(mainBranch, "milestone/M005", "getMainBranch returns milestone/<MID> in auto-worktree");
-
-    // Cleanup
-    teardownAutoWorktree(tempDir, "M005");
-  });
 
-  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);
+    // ─── Failure: split-brain prevention ──────────────────────────────
+    console.log("\n=== split-brain prevention ===");
+    // After teardown, originalBase should be null
+    assertEq(getAutoWorktreeOriginalBase(), null, "no split-brain: originalBase cleared");
 
-    // 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");
+    // ─── #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 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);
+      // 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");
 
-    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");
+      // Verify getMainBranch returns the milestone branch
+      const mainBranch = gitService.getMainBranch();
+      assertEq(mainBranch, "milestone/M005", "getMainBranch returns milestone/<MID> in auto-worktree");
 
-    // 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",
-    );
+      // Cleanup
+      teardownAutoWorktree(tempDir, "M005");
+    }
 
-    run(`git add .`, tempDir);
-    run(`git commit -m "add plan with T01 and T02 checked" --allow-empty`, tempDir);
+    // ─── #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 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",
-    );
+    // ─── #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");
+      }
+    }
 
-    // Create worktree re-attached to existing milestone branch (T02 still [ ] in branch)
-    const wtPath = createAutoWorktree(tempDir, "M004");
+  } finally {
+    // Always restore cwd and clean up
+    process.chdir(savedCwd);
+    if (tempDir && existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
 
-    try {
-      const wtPlanPath = join(wtPath, planRelPath);
-      assert.ok(existsSync(wtPlanPath), "plan file exists in worktree after re-attach");
+  report();
+}
 
-      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");
-    }
-  });
-});
+main();

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

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