gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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

@@ -1,3 +1,5 @@
+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.
 //
@@ -5,14 +7,11 @@
 // "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;
@@ -28,141 +27,134 @@ function cleanupDir(dir: string): void {
 // ensureDbOpen creates DB + migrates when .gsd/ has Markdown
 // ═══════════════════════════════════════════════════════════════════════════
 
-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');
+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);
     }
-  } finally {
-    process.cwd = origCwd;
-    closeDatabase();
-    cleanupDir(tmpDir);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ensureDbOpen returns false when no .gsd/ exists
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n── ensureDbOpen: no .gsd/ returns false ──');
-
-{
-  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();
-    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();
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 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);
+    }
+  });
 
-  assertTrue(fs.existsSync(dbPath), 'DB file should exist from manual create');
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ensureDbOpen opens existing DB without re-migration
+  // ═══════════════════════════════════════════════════════════════════════════
 
-  const origCwd = process.cwd;
-  process.cwd = () => tmpDir;
+  test('ensureDbOpen: opens existing DB', async () => {
+    const tmpDir = makeTmpDir();
+    const gsdDir = path.join(tmpDir, '.gsd');
+    fs.mkdirSync(gsdDir, { recursive: true });
 
-  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;
+    // Create a DB file first
+    const dbPath = path.join(gsdDir, 'gsd.db');
+    const { openDatabase } = await import('../gsd-db.ts');
+    openDatabase(dbPath);
     closeDatabase();
-    cleanupDir(tmpDir);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ensureDbOpen returns false for empty .gsd/ (no Markdown, no DB)
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n── ensureDbOpen: empty .gsd/ returns false ──');
 
-{
-  const tmpDir = makeTmpDir();
-  fs.mkdirSync(path.join(tmpDir, '.gsd'), { recursive: true });
-  // .gsd/ exists but no DECISIONS.md, REQUIREMENTS.md, or milestones/
+    assert.ok(fs.existsSync(dbPath), 'DB file should exist from manual create');
 
-  try { closeDatabase(); } catch { /* ok */ }
-  const origCwd = process.cwd;
-  process.cwd = () => tmpDir;
+    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);
-  }
-}
+    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);
+    }
+  });
 
-// ═══════════════════════════════════════════════════════════════════════════
+  // ═══════════════════════════════════════════════════════════════════════════
 
-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 () => {
+test("/exit requests graceful shutdown instead of process.exit", async (t) => {
   const commands = new Map<
     string,
     {
@@ -35,15 +35,13 @@ test("/exit requests graceful shutdown instead of process.exit", async () => {
     throw new Error(`process.exit should not be called: ${code ?? "undefined"}`);
   }) as typeof process.exit;
 
-  try {
-    await exit.handler("", {
-      async shutdown() {
-        shutdownCalls += 1;
-      },
-    });
-  } finally {
-    process.exit = originalExit;
-  }
+  t.after(() => { process.exit = originalExit; });
+
+  await exit.handler("", {
+    async shutdown() {
+      shutdownCalls += 1;
+    },
+  });
 
   assert.equal(stopAutoCalls, 1, "handler should stop auto-mode exactly once before shutdown");
   assert.equal(shutdownCalls, 1, "handler should request graceful shutdown exactly once");
@@ -51,7 +49,7 @@ test("/exit requests graceful shutdown instead of process.exit", async () => {
 
 // ─── #1839 regression: ESM cache mismatch must not crash exit ────────────────
 
-test("/exit still shuts down gracefully when stopAuto throws (ESM module cache mismatch)", async () => {
+test("/exit still shuts down gracefully when stopAuto throws (ESM module cache mismatch)", async (t) => {
   const commands = new Map<string, { description?: string; handler: (args: string, ctx: any) => Promise<void> }>();
 
   const pi = {
@@ -80,20 +78,18 @@ 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;
 
-  try {
-    await exit.handler("", {
-      async shutdown() {
-        shutdownCalls += 1;
-      },
-      ui: {
-        notify(msg: string, level: string) {
-          notifications.push({ msg, level });
-        },
+  t.after(() => { process.exit = originalExit; });
+
+  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,3 +1,5 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 /**
  * feature-branch-lifecycle.test.ts — Integration tests for the feature-branch workflow.
  *
@@ -29,10 +31,6 @@ 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 {
@@ -137,7 +135,7 @@ function addSliceToMilestone(
 
 // ─── Tests ──────────────────────────────────────────────────────────────────
 
-async function main(): Promise<void> {
+describe('feature-branch-lifecycle-integration', async () => {
   const savedCwd = process.cwd();
   const tempDirs: string[] = [];
 
@@ -154,14 +152,13 @@ async function main(): Promise<void> {
     // Start on f-new-shiny-thing with uncommitted changes, create
     // worktree, add slices, merge back. Assert main is untouched.
     // ================================================================
-    console.log("\n=== Feature-branch lifecycle with unique milestone IDs ===");
-    {
+    test('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);
-      assertMatch(milestoneId, /^M001-[a-z0-9]{6}$/, "unique milestone ID format");
+      assert.match(milestoneId, /^M001-[a-z0-9]{6}$/, "unique milestone ID format");
 
       // Snapshot main before anything happens
       const mainShaBefore = headSha(repo, "main");
@@ -174,8 +171,8 @@ async function main(): Promise<void> {
 
       // Verify files are uncommitted
       const statusBefore = run("git status --short", repo);
-      assertTrue(statusBefore.includes("wip-config.ts"), "wip-config.ts is uncommitted");
-      assertTrue(statusBefore.includes("wip-types.ts"), "wip-types.ts is uncommitted");
+      assert.ok(statusBefore.includes("wip-config.ts"), "wip-config.ts is uncommitted");
+      assert.ok(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
@@ -198,7 +195,7 @@ async function main(): Promise<void> {
 
       // Verify integration branch recorded
       const recorded = readIntegrationBranch(repo, milestoneId);
-      assertEq(recorded, featureBranch, "integration branch recorded as feature branch");
+      assert.deepStrictEqual(recorded, featureBranch, "integration branch recorded as feature branch");
 
       // Snapshot feature branch SHA after metadata commit (HEAD may have advanced)
       const featureShaBeforeWorktree = headSha(repo, featureBranch);
@@ -206,28 +203,28 @@ async function main(): Promise<void> {
       // ── Create the auto-worktree ──
       const wtPath = createAutoWorktree(repo, milestoneId);
       tempDirs.push(wtPath);
-      assertTrue(existsSync(wtPath), "worktree directory created");
+      assert.ok(existsSync(wtPath), "worktree directory created");
 
       // Worktree should be on milestone/<unique-id> branch
       const wtBranch = run("git branch --show-current", wtPath);
-      assertEq(wtBranch, `milestone/${milestoneId}`, "worktree is on milestone branch");
+      assert.deepStrictEqual(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}`);
-      assertEq(
+      assert.deepStrictEqual(
         milestoneBranchBase,
         featureShaBeforeWorktree,
         "milestone branch starts from feature branch HEAD",
       );
 
       // Feature-branch-only file should be in the worktree
-      assertTrue(
+      assert.ok(
         existsSync(join(wtPath, "feature-setup.ts")),
         "feature branch file (feature-setup.ts) exists in worktree",
       );
 
       // Main should be completely untouched at this point
-      assertEq(headSha(repo, "main"), mainShaBefore, "main SHA unchanged after worktree creation");
+      assert.deepStrictEqual(headSha(repo, "main"), mainShaBefore, "main SHA unchanged after worktree creation");
 
       // ── Do work in slices ──
       addSliceToMilestone(wtPath, milestoneId, "S01", "Auth module", [
@@ -250,62 +247,62 @@ async function main(): Promise<void> {
 
       // ── Assert: feature branch received the merge ──
       const currentBranch = run("git branch --show-current", repo);
-      assertEq(currentBranch, featureBranch, "repo is on feature branch after merge");
+      assert.deepStrictEqual(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);
-      assertTrue(
+      assert.ok(
         featureLog.includes(`feat(${milestoneId})`),
         "feature branch has milestone merge commit",
       );
 
       // Slice files are on the 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");
+      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");
 
       // Original feature branch file still present
-      assertTrue(existsSync(join(repo, "feature-setup.ts")), "feature-setup.ts still on feature branch");
+      assert.ok(existsSync(join(repo, "feature-setup.ts")), "feature-setup.ts still on feature branch");
 
       // Commit message is well-formed
-      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(
+      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(
         result.commitMessage.includes(`milestone/${milestoneId}`),
         "commit message references milestone branch with unique ID",
       );
 
       // ── Assert: main is COMPLETELY untouched ──
-      assertEq(headSha(repo, "main"), mainShaBefore, "main SHA unchanged after merge");
-      assertEq(commitCount(repo, "main"), mainCommitsBefore, "main commit count unchanged");
+      assert.deepStrictEqual(headSha(repo, "main"), mainShaBefore, "main SHA unchanged after merge");
+      assert.deepStrictEqual(commitCount(repo, "main"), mainCommitsBefore, "main commit count unchanged");
 
       // Main should NOT have any of the milestone files
       run("git checkout main", repo);
-      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");
+      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");
       run(`git checkout ${featureBranch}`, repo);
 
       // ── Assert: worktree cleaned up ──
       const worktreeDir = join(repo, ".gsd", "worktrees", milestoneId);
-      assertTrue(!existsSync(worktreeDir), "worktree directory removed");
+      assert.ok(!existsSync(worktreeDir), "worktree directory removed");
 
       // Milestone branch deleted
-      assertTrue(
+      assert.ok(
         !branchExists(repo, `milestone/${milestoneId}`),
         "milestone branch deleted after merge",
       );
 
       // Only expected branches remain
       const branches = allBranches(repo);
-      assertTrue(branches.includes("main"), "main branch exists");
-      assertTrue(branches.includes(featureBranch), "feature branch exists");
-      assertTrue(
+      assert.ok(branches.includes("main"), "main branch exists");
+      assert.ok(branches.includes(featureBranch), "feature branch exists");
+      assert.ok(
         !branches.some(b => b.startsWith("milestone/")),
         "no milestone branches remain",
       );
-    }
+    });
 
     // ================================================================
     // Test 2: Uncommitted .gsd/ planning files are available in worktree
@@ -314,8 +311,7 @@ async function main(): Promise<void> {
     // Planning artifacts should be carried into the worktree even if
     // they weren't committed on the feature branch.
     // ================================================================
-    console.log("\n=== Untracked planning files copied to worktree ===");
-    {
+    test('Untracked planning files copied to worktree', () => {
       const featureBranch = "f-planning-test";
       const repo = fresh(featureBranch);
       const milestoneId = nextMilestoneId([], true);
@@ -334,7 +330,7 @@ async function main(): Promise<void> {
       writeFileSync(join(repo, ".gsd", "DECISIONS.md"), "# Decisions\n\n## D001\nTest decision.\n");
 
       // These files are untracked
-      assertTrue(run("git status --short", repo).length > 0, "repo has untracked files");
+      assert.ok(run("git status --short", repo).length > 0, "repo has untracked files");
 
       // Record integration branch and create worktree
       writeIntegrationBranch(repo, milestoneId, featureBranch);
@@ -344,11 +340,11 @@ async function main(): Promise<void> {
       // 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");
-      assertTrue(existsSync(wtGsd), "worktree .gsd exists (symlink or dir)");
+      assert.ok(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
@@ -356,8 +352,7 @@ async function main(): Promise<void> {
     // Proves that unique IDs prevent collision when running successive
     // milestones, and each merge lands on the feature branch.
     // ================================================================
-    console.log("\n=== Multiple unique milestones on same feature branch ===");
-    {
+    test('Multiple unique milestones on same feature branch', () => {
       const featureBranch = "f-multi-milestone";
       const repo = fresh(featureBranch);
 
@@ -377,12 +372,12 @@ async function main(): Promise<void> {
       mergeMilestoneToMain(repo, mid1, makeRoadmap(mid1, "First", [{ id: "S01", title: "First milestone work" }]));
       process.chdir(savedCwd);
 
-      assertTrue(existsSync(join(repo, "m1-feature.ts")), "m1 file on feature branch");
+      assert.ok(existsSync(join(repo, "m1-feature.ts")), "m1 file on feature branch");
 
       // Second milestone — different unique ID
       const mid2 = nextMilestoneId([mid1], true);
-      assertTrue(mid1 !== mid2, "second milestone has different ID");
-      assertMatch(mid2, /^M002-[a-z0-9]{6}$/, "second milestone is M002-xxxxxx");
+      assert.ok(mid1 !== mid2, "second milestone has different ID");
+      assert.match(mid2, /^M002-[a-z0-9]{6}$/, "second milestone is M002-xxxxxx");
 
       mkdirSync(join(repo, ".gsd", "milestones", mid2), { recursive: true });
       writeIntegrationBranch(repo, mid2, featureBranch);
@@ -397,19 +392,19 @@ async function main(): Promise<void> {
       process.chdir(savedCwd);
 
       // Both milestone files 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");
+      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");
 
       // Main completely untouched
-      assertEq(headSha(repo, "main"), mainShaBefore, "main unchanged after two milestones");
+      assert.deepStrictEqual(headSha(repo, "main"), mainShaBefore, "main unchanged after two milestones");
 
       // No milestone branches remain
       const branches = allBranches(repo);
-      assertTrue(
+      assert.ok(
         !branches.some(b => b.startsWith("milestone/")),
         "no milestone branches remain after two milestones",
       );
-    }
+    });
 
   } finally {
     process.chdir(savedCwd);
@@ -417,8 +412,4 @@ async function main(): Promise<void> {
       try { rmSync(d, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-
-  report();
-}
-
-main();
+});