gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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

@@ -1,5 +1,4 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
@@ -17,6 +16,7 @@ import {
   reconcileWorktreeDb,
 } from '../gsd-db.ts';
 
+const { assertEq, assertTrue, report } = createTestContext();
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
@@ -91,18 +91,18 @@ console.log('\n=== worktree-db: copyWorktreeDb ===');
   closeDatabase();
 
   const result = copyWorktreeDb(srcDb, destDb);
-  assert.ok(result === true, 'copyWorktreeDb returns true on success');
-  assert.ok(fs.existsSync(destDb), 'dest DB file exists after copy');
+  assertTrue(result === true, 'copyWorktreeDb returns true on success');
+  assertTrue(fs.existsSync(destDb), 'dest DB file exists after copy');
 
   // Open the copy and verify data is queryable
   openDatabase(destDb);
   const d = getDecisionById('D001');
-  assert.ok(d !== null, 'decision queryable in copied DB');
-  assert.deepStrictEqual(d?.choice, 'node:sqlite', 'decision data preserved in copy');
+  assertTrue(d !== null, 'decision queryable in copied DB');
+  assertEq(d?.choice, 'node:sqlite', 'decision data preserved in copy');
 
   const r = getRequirementById('R001');
-  assert.ok(r !== null, 'requirement queryable in copied DB');
-  assert.deepStrictEqual(r?.description, 'Must store decisions', 'requirement data preserved in copy');
+  assertTrue(r !== null, 'requirement queryable in copied DB');
+  assertEq(r?.description, 'Must store decisions', 'requirement data preserved in copy');
 
   cleanup(srcDir, destDir);
 }
@@ -123,9 +123,9 @@ console.log('\n=== worktree-db: copyWorktreeDb ===');
 
   copyWorktreeDb(srcDb, destDb);
 
-  assert.ok(fs.existsSync(destDb), 'DB file copied');
-  assert.ok(!fs.existsSync(destDb + '-wal'), 'WAL file NOT copied');
-  assert.ok(!fs.existsSync(destDb + '-shm'), 'SHM file NOT copied');
+  assertTrue(fs.existsSync(destDb), 'DB file copied');
+  assertTrue(!fs.existsSync(destDb + '-wal'), 'WAL file NOT copied');
+  assertTrue(!fs.existsSync(destDb + '-shm'), 'SHM file NOT copied');
 
   cleanup(srcDir, destDir);
 }
@@ -134,7 +134,7 @@ console.log('\n=== worktree-db: copyWorktreeDb ===');
 {
   const destDir = tempDir();
   const result = copyWorktreeDb('/nonexistent/path/gsd.db', path.join(destDir, 'gsd.db'));
-  assert.deepStrictEqual(result, false, 'returns false for missing source');
+  assertEq(result, false, 'returns false for missing source');
   cleanup(destDir);
 }
 
@@ -149,8 +149,8 @@ console.log('\n=== worktree-db: copyWorktreeDb ===');
   closeDatabase();
 
   const result = copyWorktreeDb(srcDb, deepDest);
-  assert.ok(result === true, 'copyWorktreeDb succeeds with nested dest');
-  assert.ok(fs.existsSync(deepDest), 'DB file created at deeply nested path');
+  assertTrue(result === true, 'copyWorktreeDb succeeds with nested dest');
+  assertTrue(fs.existsSync(deepDest), 'DB file created at deeply nested path');
 
   cleanup(srcDir, destDir);
 }
@@ -192,10 +192,10 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
   openDatabase(mainDb);
   const result = reconcileWorktreeDb(mainDb, wtDb);
 
-  assert.ok(result.decisions > 0, 'decisions merged count > 0');
+  assertTrue(result.decisions > 0, 'decisions merged count > 0');
   const d2 = getDecisionById('D002');
-  assert.ok(d2 !== null, 'D002 from worktree now in main');
-  assert.deepStrictEqual(d2?.choice, 'WAL', 'D002 data correct after merge');
+  assertTrue(d2 !== null, 'D002 from worktree now in main');
+  assertEq(d2?.choice, 'WAL', 'D002 data correct after merge');
 
   cleanup(mainDir, wtDir);
 }
@@ -231,10 +231,10 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
   openDatabase(mainDb);
   const result = reconcileWorktreeDb(mainDb, wtDb);
 
-  assert.ok(result.requirements > 0, 'requirements merged count > 0');
+  assertTrue(result.requirements > 0, 'requirements merged count > 0');
   const r2 = getRequirementById('R002');
-  assert.ok(r2 !== null, 'R002 from worktree now in main');
-  assert.deepStrictEqual(r2?.description, 'Must be fast', 'R002 data correct after merge');
+  assertTrue(r2 !== null, 'R002 from worktree now in main');
+  assertEq(r2?.description, 'Must be fast', 'R002 data correct after merge');
 
   cleanup(mainDir, wtDir);
 }
@@ -264,11 +264,11 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
   openDatabase(mainDb);
   const result = reconcileWorktreeDb(mainDb, wtDb);
 
-  assert.ok(result.artifacts > 0, 'artifacts merged count > 0');
+  assertTrue(result.artifacts > 0, 'artifacts merged count > 0');
   const adapter = _getAdapter()!;
   const row = adapter.prepare('SELECT * FROM artifacts WHERE path = ?').get('docs/api.md');
-  assert.ok(row !== null, 'artifact from worktree now in main');
-  assert.deepStrictEqual(row?.['artifact_type'], 'reference', 'artifact data correct after merge');
+  assertTrue(row !== null, 'artifact from worktree now in main');
+  assertEq(row?.['artifact_type'], 'reference', 'artifact data correct after merge');
 
   cleanup(mainDir, wtDir);
 }
@@ -305,15 +305,15 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
   openDatabase(mainDb);
   const result = reconcileWorktreeDb(mainDb, wtDb);
 
-  assert.ok(result.conflicts.length > 0, 'conflicts detected');
-  assert.ok(
+  assertTrue(result.conflicts.length > 0, 'conflicts detected');
+  assertTrue(
     result.conflicts.some(c => c.includes('D001')),
     'conflict mentions D001',
   );
 
   // Worktree-wins: D001 should now have worktree's value
   const d1 = getDecisionById('D001');
-  assert.deepStrictEqual(d1?.choice, 'sql.js', 'worktree wins on conflict (INSERT OR REPLACE)');
+  assertEq(d1?.choice, 'sql.js', 'worktree wins on conflict (INSERT OR REPLACE)');
 
   cleanup(mainDir, wtDir);
 }
@@ -326,10 +326,10 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
   seedMainDb(mainDb);
 
   const result = reconcileWorktreeDb(mainDb, '/nonexistent/worktree.db');
-  assert.deepStrictEqual(result.decisions, 0, 'no decisions merged for missing worktree DB');
-  assert.deepStrictEqual(result.requirements, 0, 'no requirements merged for missing worktree DB');
-  assert.deepStrictEqual(result.artifacts, 0, 'no artifacts merged for missing worktree DB');
-  assert.deepStrictEqual(result.conflicts.length, 0, 'no conflicts for missing worktree DB');
+  assertEq(result.decisions, 0, 'no decisions merged for missing worktree DB');
+  assertEq(result.requirements, 0, 'no requirements merged for missing worktree DB');
+  assertEq(result.artifacts, 0, 'no artifacts merged for missing worktree DB');
+  assertEq(result.conflicts.length, 0, 'no conflicts for missing worktree DB');
 
   cleanup(mainDir);
 }
@@ -366,9 +366,9 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
 
   openDatabase(mainDb);
   const result = reconcileWorktreeDb(mainDb, wtDb);
-  assert.ok(result.decisions > 0, 'reconciliation works with spaces in path');
+  assertTrue(result.decisions > 0, 'reconciliation works with spaces in path');
   const d3 = getDecisionById('D003');
-  assert.ok(d3 !== null, 'D003 merged from worktree with spaces in path');
+  assertTrue(d3 !== null, 'D003 merged from worktree with spaces in path');
 
   cleanup(baseDir);
 }
@@ -388,7 +388,7 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
   reconcileWorktreeDb(mainDb, wtDb);
 
   // Verify main DB is still fully usable after DETACH
-  assert.ok(isDbAvailable(), 'DB still available after reconciliation');
+  assertTrue(isDbAvailable(), 'DB still available after reconciliation');
 
   insertDecision({
     id: 'D099',
@@ -403,8 +403,8 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
   });
 
   const d99 = getDecisionById('D099');
-  assert.ok(d99 !== null, 'can insert and query after reconciliation');
-  assert.deepStrictEqual(d99?.choice, 'works', 'post-reconcile data correct');
+  assertTrue(d99 !== null, 'can insert and query after reconciliation');
+  assertEq(d99?.choice, 'works', 'post-reconcile data correct');
 
   // Verify no "wt" database still attached
   const adapter = _getAdapter()!;
@@ -415,7 +415,7 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
   } catch {
     // Expected — wt should be detached
   }
-  assert.ok(!wtAccessible, 'wt database is detached after reconciliation');
+  assertTrue(!wtAccessible, 'wt database is detached after reconciliation');
 
   cleanup(mainDir, wtDir);
 }
@@ -436,10 +436,11 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
   const result = reconcileWorktreeDb(mainDb, wtDb);
 
   // Should still report counts for the existing rows (INSERT OR REPLACE touches them)
-  assert.ok(result.conflicts.length === 0, 'no conflicts when DBs are identical');
-  assert.ok(isDbAvailable(), 'DB usable after no-change reconciliation');
+  assertTrue(result.conflicts.length === 0, 'no conflicts when DBs are identical');
+  assertTrue(isDbAvailable(), 'DB usable after no-change reconciliation');
 
   cleanup(mainDir, wtDir);
 }
 
 // ─── Final Report ──────────────────────────────────────────────────────────
+report();

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

@@ -22,9 +22,9 @@ import {
 import { getSliceBranchName } from "../worktree.ts";
 import { abortAndReset } from "../git-self-heal.ts";
 import { runGSDDoctor } from "../doctor.ts";
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from "./test-helpers.ts";
 
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 
 // ---- Helpers ----
 
@@ -80,7 +80,7 @@ function addSliceToMilestone(
   run(`git merge --no-ff ${sliceBranch} -m "merge ${sliceId}"`, wtPath);
 }
 
-describe('worktree-e2e', async () => {
+async function main(): Promise<void> {
   const savedCwd = process.cwd();
   const tempDirs: string[] = [];
 
@@ -100,7 +100,7 @@ describe('worktree-e2e', async () => {
       // Create worktree for M001
       const wtPath = createAutoWorktree(repo, "M001");
       tempDirs.push(wtPath);
-      assert.ok(existsSync(wtPath), "worktree directory created");
+      assertTrue(existsSync(wtPath), "worktree directory created");
 
       // Add two slices with commits
       addSliceToMilestone(repo, wtPath, "M001", "S01", "Add auth", [
@@ -124,19 +124,19 @@ describe('worktree-e2e', async () => {
       // Assert exactly one new commit on main
       const mainLogAfter = run("git log --oneline main", repo);
       const commitCountAfter = mainLogAfter.split("\n").length;
-      assert.deepStrictEqual(commitCountAfter, commitCountBefore + 1, "exactly one new commit on main");
+      assertEq(commitCountAfter, commitCountBefore + 1, "exactly one new commit on main");
 
       // Commit message contains both slice titles
       const lastCommitMsg = run("git log -1 --format=%B main", repo);
-      assert.match(lastCommitMsg, /Add auth/, "commit message contains S01 title");
-      assert.match(lastCommitMsg, /Add dashboard/, "commit message contains S02 title");
+      assertMatch(lastCommitMsg, /Add auth/, "commit message contains S01 title");
+      assertMatch(lastCommitMsg, /Add dashboard/, "commit message contains S02 title");
 
       // Worktree directory removed
-      assert.ok(!existsSync(wtPath), "worktree directory removed after merge");
+      assertTrue(!existsSync(wtPath), "worktree directory removed after merge");
 
       // Milestone branch deleted
       const branches = run("git branch", repo);
-      assert.ok(!branches.includes("milestone/M001"), "milestone branch deleted");
+      assertTrue(!branches.includes("milestone/M001"), "milestone branch deleted");
     }
 
     // ================================================================
@@ -159,11 +159,11 @@ describe('worktree-e2e', async () => {
 
       // Trigger merge conflict
       try { run("git merge feature", repo); } catch { /* expected */ }
-      assert.ok(existsSync(join(repo, ".git", "MERGE_HEAD")), "MERGE_HEAD exists before abort");
+      assertTrue(existsSync(join(repo, ".git", "MERGE_HEAD")), "MERGE_HEAD exists before abort");
 
       const abortResult = abortAndReset(repo);
-      assert.ok(!existsSync(join(repo, ".git", "MERGE_HEAD")), "MERGE_HEAD removed after abort");
-      assert.ok(abortResult.cleaned.length > 0, "abortAndReset reports cleaned items");
+      assertTrue(!existsSync(join(repo, ".git", "MERGE_HEAD")), "MERGE_HEAD removed after abort");
+      assertTrue(abortResult.cleaned.length > 0, "abortAndReset reports cleaned items");
     }
 
     // ================================================================
@@ -211,19 +211,19 @@ _None_
       // Detect
       const detect = await runGSDDoctor(repo, { isolationMode: "worktree" });
       const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
-      assert.ok(orphanIssues.length > 0, "doctor detects orphaned worktree");
-      assert.deepStrictEqual(orphanIssues[0]?.unitId, "M001", "orphaned worktree unitId is M001");
+      assertTrue(orphanIssues.length > 0, "doctor detects orphaned worktree");
+      assertEq(orphanIssues[0]?.unitId, "M001", "orphaned worktree unitId is M001");
 
       // Fix
       const fixed = await runGSDDoctor(repo, { fix: true, isolationMode: "worktree" });
-      assert.ok(
+      assertTrue(
         fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")),
         "doctor fix removes orphaned worktree",
       );
 
       // Verify gone
       const wtList = run("git worktree list", repo);
-      assert.ok(!wtList.includes("milestone/M001"), "worktree gone after doctor fix");
+      assertTrue(!wtList.includes("milestone/M001"), "worktree gone after doctor fix");
     }
     } else {
       console.log("\n=== Doctor: orphaned worktree detection (skipped on Windows) ===");
@@ -234,4 +234,8 @@ _None_
       try { rmSync(d, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-});
+
+  report();
+}
+
+main();

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

@@ -12,9 +12,9 @@ import { execSync } from "node:child_process";
 
 import { getWorktreeHealth, formatWorktreeStatusLine } from "../worktree-health.ts";
 import { listWorktrees } from "../worktree-manager.ts";
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from "./test-helpers.ts";
 
+const { assertEq, assertTrue, report } = createTestContext();
 
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -32,10 +32,11 @@ function createBaseRepo(): string {
   return dir;
 }
 
-describe('worktree-health', async () => {
+async function main(): Promise<void> {
   // Skip all tests on Windows — git worktree path resolution issues
   if (process.platform === "win32") {
     console.log("(all worktree-health tests skipped on Windows)");
+    report();
     return;
   }
 
@@ -58,16 +59,16 @@ describe('worktree-health', async () => {
 
       const worktrees = listWorktrees(dir);
       const wt = worktrees.find(w => w.name === "done-feature");
-      assert.ok(!!wt, "worktree found");
+      assertTrue(!!wt, "worktree found");
 
       const health = getWorktreeHealth(dir, wt!);
-      assert.ok(health.mergedIntoMain, "branch detected as merged");
-      assert.ok(!health.dirty, "not dirty");
-      assert.ok(health.safeToRemove, "safe to remove");
+      assertTrue(health.mergedIntoMain, "branch detected as merged");
+      assertTrue(!health.dirty, "not dirty");
+      assertTrue(health.safeToRemove, "safe to remove");
 
       const line = formatWorktreeStatusLine(health);
-      assert.ok(line.includes("merged"), "status line mentions merged");
-      assert.ok(line.includes("safe to remove"), "status line mentions safe to remove");
+      assertTrue(line.includes("merged"), "status line mentions merged");
+      assertTrue(line.includes("safe to remove"), "status line mentions safe to remove");
     }
 
     // ─── Test: unmerged worktree with dirty files ──────────────────────
@@ -88,13 +89,13 @@ describe('worktree-health', async () => {
 
       const worktrees = listWorktrees(dir);
       const wt = worktrees.find(w => w.name === "dirty-wip");
-      assert.ok(!!wt, "worktree found");
+      assertTrue(!!wt, "worktree found");
 
       const health = getWorktreeHealth(dir, wt!);
-      assert.ok(!health.mergedIntoMain, "not merged");
-      assert.ok(health.dirty, "dirty detected");
-      assert.ok(health.dirtyFileCount > 0, "dirty file count > 0");
-      assert.ok(!health.safeToRemove, "not safe to remove");
+      assertTrue(!health.mergedIntoMain, "not merged");
+      assertTrue(health.dirty, "dirty detected");
+      assertTrue(health.dirtyFileCount > 0, "dirty file count > 0");
+      assertTrue(!health.safeToRemove, "not safe to remove");
     }
 
     // ─── Test: unmerged worktree with unpushed commits ─────────────────
@@ -112,12 +113,12 @@ describe('worktree-health', async () => {
 
       const worktrees = listWorktrees(dir);
       const wt = worktrees.find(w => w.name === "unpushed");
-      assert.ok(!!wt, "worktree found");
+      assertTrue(!!wt, "worktree found");
 
       const health = getWorktreeHealth(dir, wt!);
-      assert.ok(!health.mergedIntoMain, "not merged");
-      assert.ok(health.unpushedCommits > 0, "unpushed commits detected");
-      assert.ok(!health.safeToRemove, "not safe to remove");
+      assertTrue(!health.mergedIntoMain, "not merged");
+      assertTrue(health.unpushedCommits > 0, "unpushed commits detected");
+      assertTrue(!health.safeToRemove, "not safe to remove");
     }
 
     // ─── Test: stale detection with short threshold ────────────────────
@@ -136,17 +137,17 @@ describe('worktree-health', async () => {
 
       const worktrees = listWorktrees(dir);
       const wt = worktrees.find(w => w.name === "stale-test");
-      assert.ok(!!wt, "worktree found");
+      assertTrue(!!wt, "worktree found");
 
       // With staleDays=0, any worktree should be stale (commit was just now, but threshold is 0)
       // Actually, a just-created worktree has lastCommitAgeDays ~0 which is >= 0
       const health = getWorktreeHealth(dir, wt!, 0);
-      assert.ok(health.stale, "stale with 0-day threshold");
-      assert.ok(health.lastCommitAgeDays >= 0, "last commit age is non-negative");
+      assertTrue(health.stale, "stale with 0-day threshold");
+      assertTrue(health.lastCommitAgeDays >= 0, "last commit age is non-negative");
 
       // With staleDays=9999, should NOT be stale
       const healthNotStale = getWorktreeHealth(dir, wt!, 9999);
-      assert.ok(!healthNotStale.stale, "not stale with high threshold");
+      assertTrue(!healthNotStale.stale, "not stale with high threshold");
     }
 
     // ─── Test: formatWorktreeStatusLine for clean active worktree ──────
@@ -165,12 +166,12 @@ describe('worktree-health', async () => {
 
       const worktrees = listWorktrees(dir);
       const wt = worktrees.find(w => w.name === "clean-active");
-      assert.ok(!!wt, "worktree found");
+      assertTrue(!!wt, "worktree found");
 
       const health = getWorktreeHealth(dir, wt!, 9999); // high threshold so not stale
       const line = formatWorktreeStatusLine(health);
       // Should show last commit age since it's not merged and not stale
-      assert.ok(line.includes("last commit"), "shows last commit age for active worktree");
+      assertTrue(line.includes("last commit"), "shows last commit age for active worktree");
     }
 
   } finally {
@@ -178,4 +179,8 @@ describe('worktree-health', async () => {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-});
+
+  report();
+}
+
+main();

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

@@ -29,9 +29,9 @@ import {
 } from "../worktree.ts";
 
 import { deriveState } from "../state.ts";
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
+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();
 }
@@ -73,42 +73,42 @@ writeFileSync(
 run("git add .", base);
 run('git commit -m "chore: init"', base);
 
-describe('worktree-integration', async () => {
+async function main(): Promise<void> {
   // ── Verify main tree baseline ──────────────────────────────────────────────
 
   console.log("\n=== Main tree baseline ===");
-  assert.deepStrictEqual(getMainBranch(base), "main", "main tree getMainBranch returns main");
-  assert.deepStrictEqual(detectWorktreeName(base), null, "main tree not detected as worktree");
+  assertEq(getMainBranch(base), "main", "main tree getMainBranch returns main");
+  assertEq(detectWorktreeName(base), null, "main tree not detected as worktree");
 
   // ── Create worktree and verify detection ───────────────────────────────────
 
   console.log("\n=== Create worktree ===");
   const wt = createWorktree(base, "alpha");
-  assert.ok(existsSync(wt.path), "worktree created on disk");
-  assert.deepStrictEqual(wt.branch, "worktree/alpha", "worktree branch name");
+  assertTrue(existsSync(wt.path), "worktree created on disk");
+  assertEq(wt.branch, "worktree/alpha", "worktree branch name");
 
   console.log("\n=== Worktree detection ===");
-  assert.deepStrictEqual(detectWorktreeName(wt.path), "alpha", "detectWorktreeName inside worktree");
-  assert.deepStrictEqual(getMainBranch(wt.path), "worktree/alpha", "getMainBranch returns worktree branch inside worktree");
+  assertEq(detectWorktreeName(wt.path), "alpha", "detectWorktreeName inside worktree");
+  assertEq(getMainBranch(wt.path), "worktree/alpha", "getMainBranch returns worktree branch inside worktree");
 
   // ── Verify current branch inside worktree ──────────────────────────────────
 
   console.log("\n=== Worktree initial branch ===");
-  assert.deepStrictEqual(getCurrentBranch(wt.path), "worktree/alpha", "worktree starts on its own branch");
+  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "worktree starts on its own branch");
 
   // ── Verify branch name helper ──────────────────────────────────────────────
 
   console.log("\n=== getSliceBranchName with worktree ===");
-  assert.deepStrictEqual(getSliceBranchName("M001", "S01", "alpha"), "gsd/alpha/M001/S01", "explicit worktree param");
-  assert.deepStrictEqual(getSliceBranchName("M001", "S01"), "gsd/M001/S01", "no worktree param = plain branch");
+  assertEq(getSliceBranchName("M001", "S01", "alpha"), "gsd/alpha/M001/S01", "explicit worktree param");
+  assertEq(getSliceBranchName("M001", "S01"), "gsd/M001/S01", "no worktree param = plain branch");
 
   // ── Slice branch creation and detection inside worktree ────────────────────
 
   console.log("\n=== Slice branch in worktree ===");
   const sliceBranch = getSliceBranchName("M001", "S01", "alpha");
   run(`git checkout -b ${sliceBranch}`, wt.path);
-  assert.deepStrictEqual(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "worktree-namespaced slice branch");
-  assert.ok(SLICE_BRANCH_RE.test(getCurrentBranch(wt.path)), "slice branch regex matches namespaced branch");
+  assertEq(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "worktree-namespaced slice branch");
+  assertTrue(SLICE_BRANCH_RE.test(getCurrentBranch(wt.path)), "slice branch regex matches namespaced branch");
 
   // ── Do work on slice branch, then merge to worktree branch ─────────────────
 
@@ -119,23 +119,23 @@ describe('worktree-integration', async () => {
 
   // Checkout worktree base branch and merge slice branch
   run("git checkout worktree/alpha", wt.path);
-  assert.deepStrictEqual(getCurrentBranch(wt.path), "worktree/alpha", "back on worktree branch");
+  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "back on worktree branch");
 
   run(`git merge --no-ff ${sliceBranch} -m "feat(M001/S01): First"`, wt.path);
   run(`git branch -d ${sliceBranch}`, wt.path);
-  assert.deepStrictEqual(getCurrentBranch(wt.path), "worktree/alpha", "still on worktree branch after merge");
-  assert.ok(readFileSync(join(wt.path, "feature.txt"), "utf-8").includes("new feature"), "merge brought feature to worktree branch");
+  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "still on worktree branch after merge");
+  assertTrue(readFileSync(join(wt.path, "feature.txt"), "utf-8").includes("new feature"), "merge brought feature to worktree branch");
 
   // Verify slice branch is gone
   const branches = run("git branch", base);
-  assert.ok(!branches.includes("gsd/alpha/M001/S01"), "slice branch cleaned up");
+  assertTrue(!branches.includes("gsd/alpha/M001/S01"), "slice branch cleaned up");
 
   // ── Second slice in same worktree ──────────────────────────────────────────
 
   console.log("\n=== Second slice in worktree ===");
   const sliceBranch2 = getSliceBranchName("M001", "S02", "alpha");
   run(`git checkout -b ${sliceBranch2}`, wt.path);
-  assert.deepStrictEqual(getCurrentBranch(wt.path), "gsd/alpha/M001/S02", "on S02 namespaced branch");
+  assertEq(getCurrentBranch(wt.path), "gsd/alpha/M001/S02", "on S02 namespaced branch");
 
   writeFileSync(join(wt.path, "feature2.txt"), "second feature\n", "utf-8");
   run("git add .", wt.path);
@@ -144,28 +144,28 @@ describe('worktree-integration', async () => {
   run("git checkout worktree/alpha", wt.path);
   run(`git merge --no-ff ${sliceBranch2} -m "feat(M001/S02): Second"`, wt.path);
   run(`git branch -d ${sliceBranch2}`, wt.path);
-  assert.deepStrictEqual(getCurrentBranch(wt.path), "worktree/alpha", "back on worktree branch");
+  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "back on worktree branch");
 
   // ── Parallel worktrees don't conflict ──────────────────────────────────────
 
   console.log("\n=== Parallel worktrees ===");
   const wt2 = createWorktree(base, "beta");
-  assert.deepStrictEqual(getMainBranch(wt2.path), "worktree/beta", "second worktree has its own base branch");
+  assertEq(getMainBranch(wt2.path), "worktree/beta", "second worktree has its own base branch");
 
   // Both worktrees can create S01 branches without conflict
   const betaBranch = getSliceBranchName("M001", "S01", "beta");
   run(`git checkout -b ${betaBranch}`, wt2.path);
-  assert.deepStrictEqual(getCurrentBranch(wt2.path), "gsd/beta/M001/S01", "beta has its own namespaced branch");
+  assertEq(getCurrentBranch(wt2.path), "gsd/beta/M001/S01", "beta has its own namespaced branch");
 
   // Alpha worktree can re-create S01 too (it was already merged+deleted earlier)
   const alphaReBranch = getSliceBranchName("M001", "S01", "alpha");
   run(`git checkout -b ${alphaReBranch}`, wt.path);
-  assert.deepStrictEqual(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "alpha re-created S01");
+  assertEq(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "alpha re-created S01");
 
   // Both exist simultaneously
   const allBranches = run("git branch", base);
-  assert.ok(allBranches.includes("gsd/alpha/M001/S01"), "alpha S01 branch exists");
-  assert.ok(allBranches.includes("gsd/beta/M001/S01"), "beta S01 branch exists");
+  assertTrue(allBranches.includes("gsd/alpha/M001/S01"), "alpha S01 branch exists");
+  assertTrue(allBranches.includes("gsd/beta/M001/S01"), "beta S01 branch exists");
 
   // ── State derivation in worktree ───────────────────────────────────────────
 
@@ -173,8 +173,8 @@ describe('worktree-integration', async () => {
   // Switch alpha back to its base so deriveState sees milestone files
   run("git checkout worktree/alpha", wt.path);
   const state = await deriveState(wt.path);
-  assert.ok(state.activeMilestone !== null, "worktree has active milestone");
-  assert.deepStrictEqual(state.activeMilestone?.id, "M001", "correct milestone");
+  assertTrue(state.activeMilestone !== null, "worktree has active milestone");
+  assertEq(state.activeMilestone?.id, "M001", "correct milestone");
 
   // ── autoCommitCurrentBranch in worktree ────────────────────────────────────
 
@@ -183,8 +183,8 @@ describe('worktree-integration', async () => {
   run(`git checkout ${betaBranch}`, wt2.path);
   writeFileSync(join(wt2.path, "dirty.txt"), "uncommitted\n", "utf-8");
   const commitMsg = autoCommitCurrentBranch(wt2.path, "execute-task", "M001/S01/T01");
-  assert.ok(commitMsg !== null, "auto-commit works in worktree");
-  assert.deepStrictEqual(run("git status --short", wt2.path), "", "worktree clean after auto-commit");
+  assertTrue(commitMsg !== null, "auto-commit works in worktree");
+  assertEq(run("git status --short", wt2.path), "", "worktree clean after auto-commit");
 
   // ── Cleanup ────────────────────────────────────────────────────────────────
 
@@ -194,7 +194,14 @@ describe('worktree-integration', async () => {
   run("git checkout worktree/beta", wt2.path);
   removeWorktree(base, "alpha", { deleteBranch: true });
   removeWorktree(base, "beta", { deleteBranch: true });
-  assert.deepStrictEqual(listWorktrees(base).length, 0, "all worktrees removed");
+  assertEq(listWorktrees(base).length, 0, "all worktrees removed");
 
   rmSync(base, { recursive: true, force: true });
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
 });