gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

package/src/resources/extensions/gsd/tests/workflow-templates.test.ts

@@ -2,7 +2,8 @@
 //
 // Tests registry loading, template resolution, auto-detection, and listing.
 
-import { createTestContext } from './test-helpers.ts';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 import {
   loadRegistry,
   resolveByName,
@@ -12,7 +13,6 @@ import {
   loadWorkflowTemplate,
 } from '../workflow-templates.ts';
 
-const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Registry Loading
@@ -22,23 +22,23 @@ console.log('\n── Registry Loading ──');
 
 {
   const registry = loadRegistry();
-  assertTrue(registry !== null, 'Registry should load');
-  assertEq(registry.version, 1, 'Registry version should be 1');
-  assertTrue(Object.keys(registry.templates).length >= 8, 'Should have at least 8 templates');
+  assert.ok(registry !== null, 'Registry should load');
+  assert.deepStrictEqual(registry.version, 1, 'Registry version should be 1');
+  assert.ok(Object.keys(registry.templates).length >= 8, 'Should have at least 8 templates');
 
   // Verify required template keys exist
   const expectedIds = ['full-project', 'bugfix', 'small-feature', 'refactor', 'spike', 'hotfix', 'security-audit', 'dep-upgrade'];
   for (const id of expectedIds) {
-    assertTrue(id in registry.templates, `Template "${id}" should exist in registry`);
+    assert.ok(id in registry.templates, `Template "${id}" should exist in registry`);
   }
 
   // Verify each template has required fields
   for (const [id, entry] of Object.entries(registry.templates)) {
-    assertTrue(typeof entry.name === 'string' && entry.name.length > 0, `${id}: name should be non-empty string`);
-    assertTrue(typeof entry.description === 'string' && entry.description.length > 0, `${id}: description should be non-empty`);
-    assertTrue(typeof entry.file === 'string' && entry.file.endsWith('.md'), `${id}: file should be a .md path`);
-    assertTrue(Array.isArray(entry.phases) && entry.phases.length > 0, `${id}: phases should be non-empty array`);
-    assertTrue(Array.isArray(entry.triggers) && entry.triggers.length > 0, `${id}: triggers should be non-empty array`);
+    assert.ok(typeof entry.name === 'string' && entry.name.length > 0, `${id}: name should be non-empty string`);
+    assert.ok(typeof entry.description === 'string' && entry.description.length > 0, `${id}: description should be non-empty`);
+    assert.ok(typeof entry.file === 'string' && entry.file.endsWith('.md'), `${id}: file should be a .md path`);
+    assert.ok(Array.isArray(entry.phases) && entry.phases.length > 0, `${id}: phases should be non-empty array`);
+    assert.ok(Array.isArray(entry.triggers) && entry.triggers.length > 0, `${id}: triggers should be non-empty array`);
   }
 }
 
@@ -51,31 +51,31 @@ console.log('\n── Resolve by Name ──');
 {
   // Exact match
   const bugfix = resolveByName('bugfix');
-  assertTrue(bugfix !== null, 'Should resolve "bugfix"');
-  assertEq(bugfix!.id, 'bugfix', 'ID should be "bugfix"');
-  assertEq(bugfix!.confidence, 'exact', 'Exact name should have exact confidence');
+  assert.ok(bugfix !== null, 'Should resolve "bugfix"');
+  assert.deepStrictEqual(bugfix!.id, 'bugfix', 'ID should be "bugfix"');
+  assert.deepStrictEqual(bugfix!.confidence, 'exact', 'Exact name should have exact confidence');
 
   // Case-insensitive name match
   const spike = resolveByName('Research Spike');
-  assertTrue(spike !== null, 'Should resolve "Research Spike" by name');
-  assertEq(spike!.id, 'spike', 'Should resolve to spike');
+  assert.ok(spike !== null, 'Should resolve "Research Spike" by name');
+  assert.deepStrictEqual(spike!.id, 'spike', 'Should resolve to spike');
 
   // Alias match
   const bug = resolveByName('bug');
-  assertTrue(bug !== null, 'Should resolve "bug" alias');
-  assertEq(bug!.id, 'bugfix', 'Alias "bug" should map to bugfix');
+  assert.ok(bug !== null, 'Should resolve "bug" alias');
+  assert.deepStrictEqual(bug!.id, 'bugfix', 'Alias "bug" should map to bugfix');
 
   const feat = resolveByName('feat');
-  assertTrue(feat !== null, 'Should resolve "feat" alias');
-  assertEq(feat!.id, 'small-feature', 'Alias "feat" should map to small-feature');
+  assert.ok(feat !== null, 'Should resolve "feat" alias');
+  assert.deepStrictEqual(feat!.id, 'small-feature', 'Alias "feat" should map to small-feature');
 
   const deps = resolveByName('deps');
-  assertTrue(deps !== null, 'Should resolve "deps" alias');
-  assertEq(deps!.id, 'dep-upgrade', 'Alias "deps" should map to dep-upgrade');
+  assert.ok(deps !== null, 'Should resolve "deps" alias');
+  assert.deepStrictEqual(deps!.id, 'dep-upgrade', 'Alias "deps" should map to dep-upgrade');
 
   // No match
   const missing = resolveByName('nonexistent-template');
-  assertTrue(missing === null, 'Should return null for unknown template');
+  assert.ok(missing === null, 'Should return null for unknown template');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -87,32 +87,32 @@ console.log('\n── Auto-Detection ──');
 {
   // Should detect bugfix from "fix" keyword
   const fixMatches = autoDetect('fix the login button');
-  assertTrue(fixMatches.length > 0, 'Should detect matches for "fix the login button"');
-  assertTrue(fixMatches.some(m => m.id === 'bugfix'), 'Should include bugfix in matches');
+  assert.ok(fixMatches.length > 0, 'Should detect matches for "fix the login button"');
+  assert.ok(fixMatches.some(m => m.id === 'bugfix'), 'Should include bugfix in matches');
 
   // Should detect spike from "research" keyword
   const researchMatches = autoDetect('research authentication libraries');
-  assertTrue(researchMatches.length > 0, 'Should detect matches for "research"');
-  assertTrue(researchMatches.some(m => m.id === 'spike'), 'Should include spike in matches');
+  assert.ok(researchMatches.length > 0, 'Should detect matches for "research"');
+  assert.ok(researchMatches.some(m => m.id === 'spike'), 'Should include spike in matches');
 
   // Should detect hotfix from "urgent" keyword
   const urgentMatches = autoDetect('urgent production is down');
-  assertTrue(urgentMatches.length > 0, 'Should detect matches for "urgent"');
-  assertTrue(urgentMatches.some(m => m.id === 'hotfix'), 'Should include hotfix in matches');
+  assert.ok(urgentMatches.length > 0, 'Should detect matches for "urgent"');
+  assert.ok(urgentMatches.some(m => m.id === 'hotfix'), 'Should include hotfix in matches');
 
   // Should detect dep-upgrade from "upgrade" keyword
   const upgradeMatches = autoDetect('upgrade react to v19');
-  assertTrue(upgradeMatches.length > 0, 'Should detect matches for "upgrade"');
-  assertTrue(upgradeMatches.some(m => m.id === 'dep-upgrade'), 'Should include dep-upgrade in matches');
+  assert.ok(upgradeMatches.length > 0, 'Should detect matches for "upgrade"');
+  assert.ok(upgradeMatches.some(m => m.id === 'dep-upgrade'), 'Should include dep-upgrade in matches');
 
   // Multi-word triggers should score higher
   const projectMatches = autoDetect('create a new project from scratch');
   const projectMatch = projectMatches.find(m => m.id === 'full-project');
-  assertTrue(projectMatch !== undefined, 'Should detect full-project for "from scratch"');
+  assert.ok(projectMatch !== undefined, 'Should detect full-project for "from scratch"');
 
   // Empty input should return no matches
   const emptyMatches = autoDetect('');
-  assertEq(emptyMatches.length, 0, 'Empty input should return no matches');
+  assert.deepStrictEqual(emptyMatches.length, 0, 'Empty input should return no matches');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -123,11 +123,11 @@ console.log('\n── List Templates ──');
 
 {
   const output = listTemplates();
-  assertTrue(output.includes('Workflow Templates'), 'Should have header');
-  assertTrue(output.includes('bugfix'), 'Should list bugfix');
-  assertTrue(output.includes('spike'), 'Should list spike');
-  assertTrue(output.includes('hotfix'), 'Should list hotfix');
-  assertTrue(output.includes('/gsd start'), 'Should include usage hint');
+  assert.ok(output.includes('Workflow Templates'), 'Should have header');
+  assert.ok(output.includes('bugfix'), 'Should list bugfix');
+  assert.ok(output.includes('spike'), 'Should list spike');
+  assert.ok(output.includes('hotfix'), 'Should list hotfix');
+  assert.ok(output.includes('/gsd start'), 'Should include usage hint');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -138,13 +138,13 @@ console.log('\n── Template Info ──');
 
 {
   const info = getTemplateInfo('bugfix');
-  assertTrue(info !== null, 'Should return info for bugfix');
-  assertTrue(info!.includes('Bug Fix'), 'Should include template name');
-  assertTrue(info!.includes('triage'), 'Should include phase names');
-  assertTrue(info!.includes('Triggers'), 'Should include triggers section');
+  assert.ok(info !== null, 'Should return info for bugfix');
+  assert.ok(info!.includes('Bug Fix'), 'Should include template name');
+  assert.ok(info!.includes('triage'), 'Should include phase names');
+  assert.ok(info!.includes('Triggers'), 'Should include triggers section');
 
   const missing = getTemplateInfo('nonexistent');
-  assertTrue(missing === null, 'Should return null for unknown template');
+  assert.ok(missing === null, 'Should return null for unknown template');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -155,19 +155,17 @@ console.log('\n── Load Workflow Template ──');
 
 {
   const content = loadWorkflowTemplate('bugfix');
-  assertTrue(content !== null, 'Should load bugfix template');
-  assertTrue(content!.includes('Bugfix Workflow'), 'Should contain workflow title');
-  assertTrue(content!.includes('Phase 1: Triage'), 'Should contain triage phase');
-  assertTrue(content!.includes('Phase 4: Ship'), 'Should contain ship phase');
+  assert.ok(content !== null, 'Should load bugfix template');
+  assert.ok(content!.includes('Bugfix Workflow'), 'Should contain workflow title');
+  assert.ok(content!.includes('Phase 1: Triage'), 'Should contain triage phase');
+  assert.ok(content!.includes('Phase 4: Ship'), 'Should contain ship phase');
 
   const hotfixContent = loadWorkflowTemplate('hotfix');
-  assertTrue(hotfixContent !== null, 'Should load hotfix template');
-  assertTrue(hotfixContent!.includes('Hotfix Workflow'), 'Should contain hotfix title');
+  assert.ok(hotfixContent !== null, 'Should load hotfix template');
+  assert.ok(hotfixContent!.includes('Hotfix Workflow'), 'Should contain hotfix title');
 
   const missingContent = loadWorkflowTemplate('nonexistent');
-  assertTrue(missingContent === null, 'Should return null for unknown template');
+  assert.ok(missingContent === null, 'Should return null for unknown template');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-
-report();

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

@@ -14,12 +14,10 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 import { describe, it, after } from "node:test";
+import assert from 'node:assert/strict';
 
 import { resolveGitDir } from "../worktree-manager.ts";
 import { detectWorktreeName, captureIntegrationBranch } from "../worktree.ts";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
 
 // ─── Helpers ──────────────────────────────────────────────────────────────
 
@@ -40,7 +38,6 @@ describe("worktree-bugfix", () => {
   const dirs: string[] = [];
   after(() => {
     for (const d of dirs) rmSync(d, { recursive: true, force: true });
-    report();
   });
 
   it("resolveGitDir returns .git directory in normal repo", () => {
@@ -48,8 +45,8 @@ describe("worktree-bugfix", () => {
     dirs.push(repo);
     initRepo(repo);
     const gitDir = resolveGitDir(repo);
-    assertTrue(gitDir.endsWith(".git"), "ends with .git");
-    assertTrue(existsSync(gitDir), ".git dir exists");
+    assert.ok(gitDir.endsWith(".git"), "ends with .git");
+    assert.ok(existsSync(gitDir), ".git dir exists");
   });
 
   it("resolveGitDir follows gitdir: pointer in worktree", () => {
@@ -65,18 +62,18 @@ describe("worktree-bugfix", () => {
     writeFileSync(join(wtDir, ".git"), `gitdir: ${realGitDir}\n`);
 
     const resolved = resolveGitDir(wtDir);
-    assertEq(resolved, realGitDir, "resolves to real git dir");
+    assert.deepStrictEqual(resolved, realGitDir, "resolves to real git dir");
   });
 
   it("resolveGitDir returns default when .git doesn't exist", () => {
     const noGit = mkdtempSync(join(tmpdir(), "gsd-wt-fix-"));
     dirs.push(noGit);
     const gitDir = resolveGitDir(noGit);
-    assertTrue(gitDir.endsWith(".git"), "returns default .git path");
+    assert.ok(gitDir.endsWith(".git"), "returns default .git path");
   });
 
   it("detectWorktreeName returns name for worktree path", () => {
-    assertEq(
+    assert.deepStrictEqual(
       detectWorktreeName("/project/.gsd/worktrees/M005"),
       "M005",
       "detects worktree name",
@@ -84,7 +81,7 @@ describe("worktree-bugfix", () => {
   });
 
   it("detectWorktreeName returns null for normal repo", () => {
-    assertEq(
+    assert.deepStrictEqual(
       detectWorktreeName("/project"),
       null,
       "null for non-worktree path",
@@ -106,7 +103,7 @@ describe("worktree-bugfix", () => {
     // captureIntegrationBranch should be a no-op — no META.json written
     const metaPath = join(wtPath, ".gsd", "milestones", "M005", "M005-META.json");
     captureIntegrationBranch(wtPath, "M005");
-    assertTrue(!existsSync(metaPath), "no META.json written in worktree");
+    assert.ok(!existsSync(metaPath), "no META.json written in worktree");
   });
 
   it("detectWorktreeName prevents pull in worktree context", () => {
@@ -114,7 +111,7 @@ describe("worktree-bugfix", () => {
     // the caller should skip pull/fetch operations
     const inWorktree = detectWorktreeName("/project/.gsd/worktrees/M006");
     const inNormal = detectWorktreeName("/project");
-    assertTrue(inWorktree !== null, "worktree detected → skip pull");
-    assertTrue(inNormal === null, "normal repo → allow pull");
+    assert.ok(inWorktree !== null, "worktree detected → skip pull");
+    assert.ok(inNormal === null, "normal repo → allow pull");
   });
 });

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

@@ -29,9 +29,9 @@ import {
   isDbAvailable,
 } from "../gsd-db.ts";
 
-import { createTestContext } from "./test-helpers.ts";
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
 function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -49,7 +49,7 @@ function createTempRepo(): string {
   return dir;
 }
 
-async function main(): Promise<void> {
+describe('worktree-db-integration', async () => {
   const savedCwd = process.cwd();
   const tempDirs: string[] = [];
 
@@ -82,7 +82,7 @@ async function main(): Promise<void> {
       const wtPath = createAutoWorktree(tempDir, "M004");
 
       const worktreeDbPath = join(worktreePath(tempDir, "M004"), ".gsd", "gsd.db");
-      assertTrue(
+      assert.ok(
         existsSync(worktreeDbPath),
         "gsd.db exists in worktree .gsd after createAutoWorktree",
       );
@@ -107,10 +107,10 @@ async function main(): Promise<void> {
         console.error("  Unexpected throw:", err);
       }
 
-      assertTrue(!threw, "createAutoWorktree does not throw when no source DB");
+      assert.ok(!threw, "createAutoWorktree does not throw when no source DB");
 
       const worktreeDbPath = join(worktreePath(tempDir, "M004"), ".gsd", "gsd.db");
-      assertTrue(
+      assert.ok(
         !existsSync(worktreeDbPath),
         "gsd.db is absent in worktree when source had none",
       );
@@ -145,7 +145,7 @@ async function main(): Promise<void> {
 
       // Reconcile worktree → main
       const result = reconcileWorktreeDb(mainDbPath, worktreeDbPath);
-      assertTrue(result.decisions >= 1, "reconcile reports at least 1 decision merged");
+      assert.ok(result.decisions >= 1, "reconcile reports at least 1 decision merged");
 
       // Open main DB and verify the row is present
       openDatabase(mainDbPath);
@@ -153,7 +153,7 @@ async function main(): Promise<void> {
       closeDatabase();
 
       const found = decisions.some((d) => d.id === "D-WT-001");
-      assertTrue(found, "worktree decision D-WT-001 present in main DB after reconcile");
+      assert.ok(found, "worktree decision D-WT-001 present in main DB after reconcile");
     }
 
     // ─── Test 4: reconcile non-fatal when both paths nonexistent ─────
@@ -165,7 +165,7 @@ async function main(): Promise<void> {
       } catch {
         threw = true;
       }
-      assertTrue(!threw, "reconcileWorktreeDb does not throw when worktree DB is absent");
+      assert.ok(!threw, "reconcileWorktreeDb does not throw when worktree DB is absent");
     }
 
     // ─── Test 5: failure path observable via stderr (diagnostic) ─────
@@ -181,10 +181,10 @@ async function main(): Promise<void> {
       closeDatabase();
 
       const result = reconcileWorktreeDb(mainDbPath, "/definitely/does/not/exist.db");
-      assertEq(result.decisions, 0, "decisions is 0 when worktree DB absent");
-      assertEq(result.requirements, 0, "requirements is 0 when worktree DB absent");
-      assertEq(result.artifacts, 0, "artifacts is 0 when worktree DB absent");
-      assertEq(result.conflicts.length, 0, "conflicts is empty when worktree DB absent");
+      assert.deepStrictEqual(result.decisions, 0, "decisions is 0 when worktree DB absent");
+      assert.deepStrictEqual(result.requirements, 0, "requirements is 0 when worktree DB absent");
+      assert.deepStrictEqual(result.artifacts, 0, "artifacts is 0 when worktree DB absent");
+      assert.deepStrictEqual(result.conflicts.length, 0, "conflicts is empty when worktree DB absent");
     }
 
   } finally {
@@ -199,8 +199,4 @@ async function main(): Promise<void> {
       }
     }
   }
-
-  report();
-}
-
-main();
+});

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

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