gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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

@@ -1,5 +1,3 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 // ensureDbOpen — Tests that the lazy DB opener creates + migrates the database
 // when .gsd/ exists with Markdown content but no gsd.db file.
 //
@@ -7,11 +5,14 @@ import assert from 'node:assert/strict';
 // "GSD database is not available" because ensureDbOpen only opened
 // existing DB files but never created them.
 
+import { createTestContext } from './test-helpers.ts';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import * as fs from 'node:fs';
 import { closeDatabase, isDbAvailable, getDecisionById } from '../gsd-db.ts';
 
+const { assertEq, assertTrue, report } = createTestContext();
+
 function makeTmpDir(): string {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-ensure-db-'));
   return dir;
@@ -27,134 +28,141 @@ function cleanupDir(dir: string): void {
 // ensureDbOpen creates DB + migrates when .gsd/ has Markdown
 // ═══════════════════════════════════════════════════════════════════════════
 
-describe('ensure-db-open', () => {
-  test('ensureDbOpen: creates DB from Markdown', async () => {
-    const tmpDir = makeTmpDir();
-    const gsdDir = path.join(tmpDir, '.gsd');
-    fs.mkdirSync(gsdDir, { recursive: true });
-
-    // Write a minimal DECISIONS.md so migration has content
-    const decisionsContent = `# Decisions
-
-  | # | When | Scope | Decision | Choice | Rationale | Revisable |
-  |---|------|-------|----------|--------|-----------|-----------|
-  | D001 | M001 | architecture | Use SQLite | SQLite | Sync API | Yes |
-  `;
-    fs.writeFileSync(path.join(gsdDir, 'DECISIONS.md'), decisionsContent);
-
-    // Verify no DB file exists yet
-    const dbPath = path.join(gsdDir, 'gsd.db');
-    assert.ok(!fs.existsSync(dbPath), 'DB file should not exist before ensureDbOpen');
-
-    // Close any previously open DB
-    try { closeDatabase(); } catch { /* ok */ }
-
-    // Override process.cwd to point at tmpDir for ensureDbOpen
-    const origCwd = process.cwd;
-    process.cwd = () => tmpDir;
-
-    try {
-      // Dynamic import to get the freshest version
-      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
-
-      const result = await ensureDbOpen();
-
-      assert.ok(result === true, 'ensureDbOpen should return true when .gsd/ has Markdown');
-      assert.ok(fs.existsSync(dbPath), 'DB file should be created after ensureDbOpen');
-      assert.ok(isDbAvailable(), 'DB should be available after ensureDbOpen');
-
-      // Verify that Markdown migration actually ran
-      const decision = getDecisionById('D001');
-      assert.ok(decision !== null, 'D001 should be migrated from DECISIONS.md');
-      if (decision) {
-        assert.deepStrictEqual(decision.scope, 'architecture', 'Migrated decision scope should match');
-        assert.deepStrictEqual(decision.choice, 'SQLite', 'Migrated decision choice should match');
-      }
-    } finally {
-      process.cwd = origCwd;
-      closeDatabase();
-      cleanupDir(tmpDir);
-    }
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // ensureDbOpen returns false when no .gsd/ exists
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  test('ensureDbOpen: no .gsd/ returns false', async () => {
-    const tmpDir = makeTmpDir();
-    // No .gsd/ directory at all
-
-    try { closeDatabase(); } catch { /* ok */ }
-    const origCwd = process.cwd;
-    process.cwd = () => tmpDir;
-
-    try {
-      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
-      const result = await ensureDbOpen();
-      assert.ok(result === false, 'ensureDbOpen should return false when no .gsd/ exists');
-      assert.ok(!isDbAvailable(), 'DB should not be available');
-    } finally {
-      process.cwd = origCwd;
-      cleanupDir(tmpDir);
+console.log('\n── ensureDbOpen: creates DB from Markdown ──');
+
+{
+  const tmpDir = makeTmpDir();
+  const gsdDir = path.join(tmpDir, '.gsd');
+  fs.mkdirSync(gsdDir, { recursive: true });
+
+  // Write a minimal DECISIONS.md so migration has content
+  const decisionsContent = `# Decisions
+
+| # | When | Scope | Decision | Choice | Rationale | Revisable |
+|---|------|-------|----------|--------|-----------|-----------|
+| D001 | M001 | architecture | Use SQLite | SQLite | Sync API | Yes |
+`;
+  fs.writeFileSync(path.join(gsdDir, 'DECISIONS.md'), decisionsContent);
+
+  // Verify no DB file exists yet
+  const dbPath = path.join(gsdDir, 'gsd.db');
+  assertTrue(!fs.existsSync(dbPath), 'DB file should not exist before ensureDbOpen');
+
+  // Close any previously open DB
+  try { closeDatabase(); } catch { /* ok */ }
+
+  // Override process.cwd to point at tmpDir for ensureDbOpen
+  const origCwd = process.cwd;
+  process.cwd = () => tmpDir;
+
+  try {
+    // Dynamic import to get the freshest version
+    const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+
+    const result = await ensureDbOpen();
+
+    assertTrue(result === true, 'ensureDbOpen should return true when .gsd/ has Markdown');
+    assertTrue(fs.existsSync(dbPath), 'DB file should be created after ensureDbOpen');
+    assertTrue(isDbAvailable(), 'DB should be available after ensureDbOpen');
+
+    // Verify that Markdown migration actually ran
+    const decision = getDecisionById('D001');
+    assertTrue(decision !== null, 'D001 should be migrated from DECISIONS.md');
+    if (decision) {
+      assertEq(decision.scope, 'architecture', 'Migrated decision scope should match');
+      assertEq(decision.choice, 'SQLite', 'Migrated decision choice should match');
     }
-  });
+  } finally {
+    process.cwd = origCwd;
+    closeDatabase();
+    cleanupDir(tmpDir);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// ensureDbOpen returns false when no .gsd/ exists
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── ensureDbOpen: no .gsd/ returns false ──');
 
-  // ═══════════════════════════════════════════════════════════════════════════
-  // ensureDbOpen opens existing DB without re-migration
-  // ═══════════════════════════════════════════════════════════════════════════
+{
+  const tmpDir = makeTmpDir();
+  // No .gsd/ directory at all
 
-  test('ensureDbOpen: opens existing DB', async () => {
-    const tmpDir = makeTmpDir();
-    const gsdDir = path.join(tmpDir, '.gsd');
-    fs.mkdirSync(gsdDir, { recursive: true });
+  try { closeDatabase(); } catch { /* ok */ }
+  const origCwd = process.cwd;
+  process.cwd = () => tmpDir;
 
-    // Create a DB file first
-    const dbPath = path.join(gsdDir, 'gsd.db');
-    const { openDatabase } = await import('../gsd-db.ts');
-    openDatabase(dbPath);
+  try {
+    const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+    const result = await ensureDbOpen();
+    assertTrue(result === false, 'ensureDbOpen should return false when no .gsd/ exists');
+    assertTrue(!isDbAvailable(), 'DB should not be available');
+  } finally {
+    process.cwd = origCwd;
+    cleanupDir(tmpDir);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// ensureDbOpen opens existing DB without re-migration
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── ensureDbOpen: opens existing DB ──');
+
+{
+  const tmpDir = makeTmpDir();
+  const gsdDir = path.join(tmpDir, '.gsd');
+  fs.mkdirSync(gsdDir, { recursive: true });
+
+  // Create a DB file first
+  const dbPath = path.join(gsdDir, 'gsd.db');
+  const { openDatabase } = await import('../gsd-db.ts');
+  openDatabase(dbPath);
+  closeDatabase();
+
+  assertTrue(fs.existsSync(dbPath), 'DB file should exist from manual create');
+
+  const origCwd = process.cwd;
+  process.cwd = () => tmpDir;
+
+  try {
+    const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+    const result = await ensureDbOpen();
+    assertTrue(result === true, 'ensureDbOpen should open existing DB');
+    assertTrue(isDbAvailable(), 'DB should be available');
+  } finally {
+    process.cwd = origCwd;
     closeDatabase();
+    cleanupDir(tmpDir);
+  }
+}
 
-    assert.ok(fs.existsSync(dbPath), 'DB file should exist from manual create');
+// ═══════════════════════════════════════════════════════════════════════════
+// ensureDbOpen returns false for empty .gsd/ (no Markdown, no DB)
+// ═══════════════════════════════════════════════════════════════════════════
 
-    const origCwd = process.cwd;
-    process.cwd = () => tmpDir;
+console.log('\n── ensureDbOpen: empty .gsd/ returns false ──');
 
-    try {
-      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
-      const result = await ensureDbOpen();
-      assert.ok(result === true, 'ensureDbOpen should open existing DB');
-      assert.ok(isDbAvailable(), 'DB should be available');
-    } finally {
-      process.cwd = origCwd;
-      closeDatabase();
-      cleanupDir(tmpDir);
-    }
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // ensureDbOpen returns false for empty .gsd/ (no Markdown, no DB)
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  test('ensureDbOpen: empty .gsd/ returns false', async () => {
-    const tmpDir = makeTmpDir();
-    fs.mkdirSync(path.join(tmpDir, '.gsd'), { recursive: true });
-    // .gsd/ exists but no DECISIONS.md, REQUIREMENTS.md, or milestones/
-
-    try { closeDatabase(); } catch { /* ok */ }
-    const origCwd = process.cwd;
-    process.cwd = () => tmpDir;
-
-    try {
-      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
-      const result = await ensureDbOpen();
-      assert.ok(result === false, 'ensureDbOpen should return false for empty .gsd/');
-    } finally {
-      process.cwd = origCwd;
-      cleanupDir(tmpDir);
-    }
-  });
+{
+  const tmpDir = makeTmpDir();
+  fs.mkdirSync(path.join(tmpDir, '.gsd'), { recursive: true });
+  // .gsd/ exists but no DECISIONS.md, REQUIREMENTS.md, or milestones/
 
-  // ═══════════════════════════════════════════════════════════════════════════
+  try { closeDatabase(); } catch { /* ok */ }
+  const origCwd = process.cwd;
+  process.cwd = () => tmpDir;
+
+  try {
+    const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+    const result = await ensureDbOpen();
+    assertTrue(result === false, 'ensureDbOpen should return false for empty .gsd/');
+  } finally {
+    process.cwd = origCwd;
+    cleanupDir(tmpDir);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
 
-});
+report();

package/src/resources/extensions/gsd/tests/exit-command.test.ts

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 
 import { registerExitCommand } from "../exit-command.ts";
 
-test("/exit requests graceful shutdown instead of process.exit", async (t) => {
+test("/exit requests graceful shutdown instead of process.exit", async () => {
   const commands = new Map<
     string,
     {
@@ -35,13 +35,15 @@ test("/exit requests graceful shutdown instead of process.exit", async (t) => {
     throw new Error(`process.exit should not be called: ${code ?? "undefined"}`);
   }) as typeof process.exit;
 
-  t.after(() => { process.exit = originalExit; });
-
-  await exit.handler("", {
-    async shutdown() {
-      shutdownCalls += 1;
-    },
-  });
+  try {
+    await exit.handler("", {
+      async shutdown() {
+        shutdownCalls += 1;
+      },
+    });
+  } finally {
+    process.exit = originalExit;
+  }
 
   assert.equal(stopAutoCalls, 1, "handler should stop auto-mode exactly once before shutdown");
   assert.equal(shutdownCalls, 1, "handler should request graceful shutdown exactly once");
@@ -49,7 +51,7 @@ test("/exit requests graceful shutdown instead of process.exit", async (t) => {
 
 // ─── #1839 regression: ESM cache mismatch must not crash exit ────────────────
 
-test("/exit still shuts down gracefully when stopAuto throws (ESM module cache mismatch)", async (t) => {
+test("/exit still shuts down gracefully when stopAuto throws (ESM module cache mismatch)", async () => {
   const commands = new Map<string, { description?: string; handler: (args: string, ctx: any) => Promise<void> }>();
 
   const pi = {
@@ -78,18 +80,20 @@ test("/exit still shuts down gracefully when stopAuto throws (ESM module cache m
     throw new Error(`process.exit should not be called: ${code ?? "undefined"}`);
   }) as typeof process.exit;
 
-  t.after(() => { process.exit = originalExit; });
-
-  await exit.handler("", {
-    async shutdown() {
-      shutdownCalls += 1;
-    },
-    ui: {
-      notify(msg: string, level: string) {
-        notifications.push({ msg, level });
+  try {
+    await exit.handler("", {
+      async shutdown() {
+        shutdownCalls += 1;
       },
-    },
-  });
+      ui: {
+        notify(msg: string, level: string) {
+          notifications.push({ msg, level });
+        },
+      },
+    });
+  } finally {
+    process.exit = originalExit;
+  }
 
   assert.equal(shutdownCalls, 1, "shutdown must still be called even when stopAuto throws");
   assert.equal(notifications.length, 1, "should emit exactly one warning notification");

package/src/resources/extensions/gsd/tests/feature-branch-lifecycle-integration.test.ts

@@ -1,5 +1,3 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 /**
  * feature-branch-lifecycle.test.ts — Integration tests for the feature-branch workflow.
  *
@@ -31,6 +29,10 @@ import { captureIntegrationBranch, getSliceBranchName } from "../worktree.ts";
 import { writeIntegrationBranch, readIntegrationBranch } from "../git-service.ts";
 import { nextMilestoneId, generateMilestoneSuffix } from "../guided-flow.ts";
 
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
 function run(cmd: string, cwd: string): string {
@@ -135,7 +137,7 @@ function addSliceToMilestone(
 
 // ─── Tests ──────────────────────────────────────────────────────────────────
 
-describe('feature-branch-lifecycle-integration', async () => {
+async function main(): Promise<void> {
   const savedCwd = process.cwd();
   const tempDirs: string[] = [];
 
@@ -152,13 +154,14 @@ describe('feature-branch-lifecycle-integration', async () => {
     // Start on f-new-shiny-thing with uncommitted changes, create
     // worktree, add slices, merge back. Assert main is untouched.
     // ================================================================
-    test('Feature-branch lifecycle with unique milestone IDs', () => {
+    console.log("\n=== Feature-branch lifecycle with unique milestone IDs ===");
+    {
       const featureBranch = "f-new-shiny-thing";
       const repo = fresh(featureBranch);
 
       // Generate a unique milestone ID (M001-xxxxxx format)
       const milestoneId = nextMilestoneId([], true);
-      assert.match(milestoneId, /^M001-[a-z0-9]{6}$/, "unique milestone ID format");
+      assertMatch(milestoneId, /^M001-[a-z0-9]{6}$/, "unique milestone ID format");
 
       // Snapshot main before anything happens
       const mainShaBefore = headSha(repo, "main");
@@ -171,8 +174,8 @@ describe('feature-branch-lifecycle-integration', async () => {
 
       // Verify files are uncommitted
       const statusBefore = run("git status --short", repo);
-      assert.ok(statusBefore.includes("wip-config.ts"), "wip-config.ts is uncommitted");
-      assert.ok(statusBefore.includes("wip-types.ts"), "wip-types.ts is uncommitted");
+      assertTrue(statusBefore.includes("wip-config.ts"), "wip-config.ts is uncommitted");
+      assertTrue(statusBefore.includes("wip-types.ts"), "wip-types.ts is uncommitted");
 
       // ── Simulate what startAuto does: commit dirty state, capture integration branch ──
       // startAuto bootstraps .gsd/ which commits .gsd/ files. It also calls
@@ -195,7 +198,7 @@ describe('feature-branch-lifecycle-integration', async () => {
 
       // Verify integration branch recorded
       const recorded = readIntegrationBranch(repo, milestoneId);
-      assert.deepStrictEqual(recorded, featureBranch, "integration branch recorded as feature branch");
+      assertEq(recorded, featureBranch, "integration branch recorded as feature branch");
 
       // Snapshot feature branch SHA after metadata commit (HEAD may have advanced)
       const featureShaBeforeWorktree = headSha(repo, featureBranch);
@@ -203,28 +206,28 @@ describe('feature-branch-lifecycle-integration', async () => {
       // ── Create the auto-worktree ──
       const wtPath = createAutoWorktree(repo, milestoneId);
       tempDirs.push(wtPath);
-      assert.ok(existsSync(wtPath), "worktree directory created");
+      assertTrue(existsSync(wtPath), "worktree directory created");
 
       // Worktree should be on milestone/<unique-id> branch
       const wtBranch = run("git branch --show-current", wtPath);
-      assert.deepStrictEqual(wtBranch, `milestone/${milestoneId}`, "worktree is on milestone branch");
+      assertEq(wtBranch, `milestone/${milestoneId}`, "worktree is on milestone branch");
 
       // Milestone branch should be rooted at the feature branch, not main
       const milestoneBranchBase = headSha(repo, `milestone/${milestoneId}`);
-      assert.deepStrictEqual(
+      assertEq(
         milestoneBranchBase,
         featureShaBeforeWorktree,
         "milestone branch starts from feature branch HEAD",
       );
 
       // Feature-branch-only file should be in the worktree
-      assert.ok(
+      assertTrue(
         existsSync(join(wtPath, "feature-setup.ts")),
         "feature branch file (feature-setup.ts) exists in worktree",
       );
 
       // Main should be completely untouched at this point
-      assert.deepStrictEqual(headSha(repo, "main"), mainShaBefore, "main SHA unchanged after worktree creation");
+      assertEq(headSha(repo, "main"), mainShaBefore, "main SHA unchanged after worktree creation");
 
       // ── Do work in slices ──
       addSliceToMilestone(wtPath, milestoneId, "S01", "Auth module", [
@@ -247,62 +250,62 @@ describe('feature-branch-lifecycle-integration', async () => {
 
       // ── Assert: feature branch received the merge ──
       const currentBranch = run("git branch --show-current", repo);
-      assert.deepStrictEqual(currentBranch, featureBranch, "repo is on feature branch after merge");
+      assertEq(currentBranch, featureBranch, "repo is on feature branch after merge");
 
       // Exactly one new commit on feature branch (the squash merge)
       const featureLog = run(`git log --oneline ${featureBranch}`, repo);
-      assert.ok(
+      assertTrue(
         featureLog.includes(`feat(${milestoneId})`),
         "feature branch has milestone merge commit",
       );
 
       // Slice files are on the feature branch
-      assert.ok(existsSync(join(repo, "auth.ts")), "auth.ts on feature branch");
-      assert.ok(existsSync(join(repo, "dashboard.ts")), "dashboard.ts on feature branch");
-      assert.ok(existsSync(join(repo, "auth-utils.ts")), "auth-utils.ts on feature branch");
+      assertTrue(existsSync(join(repo, "auth.ts")), "auth.ts on feature branch");
+      assertTrue(existsSync(join(repo, "dashboard.ts")), "dashboard.ts on feature branch");
+      assertTrue(existsSync(join(repo, "auth-utils.ts")), "auth-utils.ts on feature branch");
 
       // Original feature branch file still present
-      assert.ok(existsSync(join(repo, "feature-setup.ts")), "feature-setup.ts still on feature branch");
+      assertTrue(existsSync(join(repo, "feature-setup.ts")), "feature-setup.ts still on feature branch");
 
       // Commit message is well-formed
-      assert.ok(result.commitMessage.includes("New shiny feature"), "commit message has milestone title");
-      assert.ok(result.commitMessage.includes("S01: Auth module"), "commit message lists S01");
-      assert.ok(result.commitMessage.includes("S02: Dashboard"), "commit message lists S02");
-      assert.ok(
+      assertTrue(result.commitMessage.includes("New shiny feature"), "commit message has milestone title");
+      assertTrue(result.commitMessage.includes("S01: Auth module"), "commit message lists S01");
+      assertTrue(result.commitMessage.includes("S02: Dashboard"), "commit message lists S02");
+      assertTrue(
         result.commitMessage.includes(`milestone/${milestoneId}`),
         "commit message references milestone branch with unique ID",
       );
 
       // ── Assert: main is COMPLETELY untouched ──
-      assert.deepStrictEqual(headSha(repo, "main"), mainShaBefore, "main SHA unchanged after merge");
-      assert.deepStrictEqual(commitCount(repo, "main"), mainCommitsBefore, "main commit count unchanged");
+      assertEq(headSha(repo, "main"), mainShaBefore, "main SHA unchanged after merge");
+      assertEq(commitCount(repo, "main"), mainCommitsBefore, "main commit count unchanged");
 
       // Main should NOT have any of the milestone files
       run("git checkout main", repo);
-      assert.ok(!existsSync(join(repo, "auth.ts")), "auth.ts NOT on main");
-      assert.ok(!existsSync(join(repo, "dashboard.ts")), "dashboard.ts NOT on main");
-      assert.ok(!existsSync(join(repo, "feature-setup.ts")), "feature-setup.ts NOT on main");
+      assertTrue(!existsSync(join(repo, "auth.ts")), "auth.ts NOT on main");
+      assertTrue(!existsSync(join(repo, "dashboard.ts")), "dashboard.ts NOT on main");
+      assertTrue(!existsSync(join(repo, "feature-setup.ts")), "feature-setup.ts NOT on main");
       run(`git checkout ${featureBranch}`, repo);
 
       // ── Assert: worktree cleaned up ──
       const worktreeDir = join(repo, ".gsd", "worktrees", milestoneId);
-      assert.ok(!existsSync(worktreeDir), "worktree directory removed");
+      assertTrue(!existsSync(worktreeDir), "worktree directory removed");
 
       // Milestone branch deleted
-      assert.ok(
+      assertTrue(
         !branchExists(repo, `milestone/${milestoneId}`),
         "milestone branch deleted after merge",
       );
 
       // Only expected branches remain
       const branches = allBranches(repo);
-      assert.ok(branches.includes("main"), "main branch exists");
-      assert.ok(branches.includes(featureBranch), "feature branch exists");
-      assert.ok(
+      assertTrue(branches.includes("main"), "main branch exists");
+      assertTrue(branches.includes(featureBranch), "feature branch exists");
+      assertTrue(
         !branches.some(b => b.startsWith("milestone/")),
         "no milestone branches remain",
       );
-    });
+    }
 
     // ================================================================
     // Test 2: Uncommitted .gsd/ planning files are available in worktree
@@ -311,7 +314,8 @@ describe('feature-branch-lifecycle-integration', async () => {
     // Planning artifacts should be carried into the worktree even if
     // they weren't committed on the feature branch.
     // ================================================================
-    test('Untracked planning files copied to worktree', () => {
+    console.log("\n=== Untracked planning files copied to worktree ===");
+    {
       const featureBranch = "f-planning-test";
       const repo = fresh(featureBranch);
       const milestoneId = nextMilestoneId([], true);
@@ -330,7 +334,7 @@ describe('feature-branch-lifecycle-integration', async () => {
       writeFileSync(join(repo, ".gsd", "DECISIONS.md"), "# Decisions\n\n## D001\nTest decision.\n");
 
       // These files are untracked
-      assert.ok(run("git status --short", repo).length > 0, "repo has untracked files");
+      assertTrue(run("git status --short", repo).length > 0, "repo has untracked files");
 
       // Record integration branch and create worktree
       writeIntegrationBranch(repo, milestoneId, featureBranch);
@@ -340,11 +344,11 @@ describe('feature-branch-lifecycle-integration', async () => {
       // With external state, worktree .gsd is a symlink to shared state.
       // Verify symlink was created (planning files are shared, not copied).
       const wtGsd = join(wtPath, ".gsd");
-      assert.ok(existsSync(wtGsd), "worktree .gsd exists (symlink or dir)");
+      assertTrue(existsSync(wtGsd), "worktree .gsd exists (symlink or dir)");
 
       // Clean up: chdir back before teardown
       process.chdir(savedCwd);
-    });
+    }
 
     // ================================================================
     // Test 3: Multiple milestones on the same feature branch
@@ -352,7 +356,8 @@ describe('feature-branch-lifecycle-integration', async () => {
     // Proves that unique IDs prevent collision when running successive
     // milestones, and each merge lands on the feature branch.
     // ================================================================
-    test('Multiple unique milestones on same feature branch', () => {
+    console.log("\n=== Multiple unique milestones on same feature branch ===");
+    {
       const featureBranch = "f-multi-milestone";
       const repo = fresh(featureBranch);
 
@@ -372,12 +377,12 @@ describe('feature-branch-lifecycle-integration', async () => {
       mergeMilestoneToMain(repo, mid1, makeRoadmap(mid1, "First", [{ id: "S01", title: "First milestone work" }]));
       process.chdir(savedCwd);
 
-      assert.ok(existsSync(join(repo, "m1-feature.ts")), "m1 file on feature branch");
+      assertTrue(existsSync(join(repo, "m1-feature.ts")), "m1 file on feature branch");
 
       // Second milestone — different unique ID
       const mid2 = nextMilestoneId([mid1], true);
-      assert.ok(mid1 !== mid2, "second milestone has different ID");
-      assert.match(mid2, /^M002-[a-z0-9]{6}$/, "second milestone is M002-xxxxxx");
+      assertTrue(mid1 !== mid2, "second milestone has different ID");
+      assertMatch(mid2, /^M002-[a-z0-9]{6}$/, "second milestone is M002-xxxxxx");
 
       mkdirSync(join(repo, ".gsd", "milestones", mid2), { recursive: true });
       writeIntegrationBranch(repo, mid2, featureBranch);
@@ -392,19 +397,19 @@ describe('feature-branch-lifecycle-integration', async () => {
       process.chdir(savedCwd);
 
       // Both milestone files on feature branch
-      assert.ok(existsSync(join(repo, "m1-feature.ts")), "m1 file still on feature branch");
-      assert.ok(existsSync(join(repo, "m2-feature.ts")), "m2 file on feature branch");
+      assertTrue(existsSync(join(repo, "m1-feature.ts")), "m1 file still on feature branch");
+      assertTrue(existsSync(join(repo, "m2-feature.ts")), "m2 file on feature branch");
 
       // Main completely untouched
-      assert.deepStrictEqual(headSha(repo, "main"), mainShaBefore, "main unchanged after two milestones");
+      assertEq(headSha(repo, "main"), mainShaBefore, "main unchanged after two milestones");
 
       // No milestone branches remain
       const branches = allBranches(repo);
-      assert.ok(
+      assertTrue(
         !branches.some(b => b.startsWith("milestone/")),
         "no milestone branches remain after two milestones",
       );
-    });
+    }
 
   } finally {
     process.chdir(savedCwd);
@@ -412,4 +417,8 @@ describe('feature-branch-lifecycle-integration', async () => {
       try { rmSync(d, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-});
+
+  report();
+}
+
+main();

package/src/resources/extensions/gsd/tests/files-loadfile-eisdir.test.ts

@@ -6,13 +6,15 @@ import fs from "node:fs";
 
 import { loadFile } from "../files.ts";
 
-test("loadFile returns null for directory paths instead of throwing EISDIR", async (t) => {
+test("loadFile returns null for directory paths instead of throwing EISDIR", async () => {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-loadfile-eisdir-"));
   const dirPath = path.join(tmp, "tasks");
   fs.mkdirSync(dirPath);
 
-  t.after(() => { fs.rmSync(tmp, { recursive: true, force: true }); });
-
-  const result = await loadFile(dirPath);
-  assert.equal(result, null);
+  try {
+    const result = await loadFile(dirPath);
+    assert.equal(result, null);
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
 });