gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/windows-path-normalization.test.ts

@@ -6,9 +6,9 @@
  * strips backslashes (escape characters), producing `C:Usersuserproject`.
  */
 
-import { createTestContext } from "./test-helpers.ts";
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
 // ─── shellEscape + path normalization ──────────────────────────────────────
 
@@ -25,42 +25,42 @@ function bashPath(p: string): string {
 console.log("\n=== Windows backslash path normalization (#1436) ===");
 
 // Backslash paths are converted to forward slashes
-assertEq(
+assert.deepStrictEqual(
   bashPath("C:\\Users\\user\\project"),
   "'C:/Users/user/project'",
   "backslash path normalised to forward slashes in shell-escaped string",
 );
 
 // Unix paths pass through unchanged
-assertEq(
+assert.deepStrictEqual(
   bashPath("/home/user/project"),
   "'/home/user/project'",
   "Unix path unchanged",
 );
 
 // Mixed separators are normalised
-assertEq(
+assert.deepStrictEqual(
   bashPath("C:\\Users/user\\project/src"),
   "'C:/Users/user/project/src'",
   "mixed separators normalised",
 );
 
 // Paths with single quotes are still properly escaped
-assertEq(
+assert.deepStrictEqual(
   bashPath("C:\\Users\\o'brien\\project"),
   "'C:/Users/o'\\''brien/project'",
   "single quote in path is escaped after normalisation",
 );
 
 // UNC paths
-assertEq(
+assert.deepStrictEqual(
   bashPath("\\\\server\\share\\dir"),
   "'//server/share/dir'",
   "UNC path normalised",
 );
 
 // Empty string
-assertEq(
+assert.deepStrictEqual(
   bashPath(""),
   "''",
   "empty string handled",
@@ -72,14 +72,14 @@ console.log("\n=== cd command construction with normalised paths ===");
 
 const windowsCwd = "C:\\Users\\user\\project\\.gsd\\worktrees\\M001";
 const cdCommand = `cd ${bashPath(windowsCwd)}`;
-assertEq(
+assert.deepStrictEqual(
   cdCommand,
   "cd 'C:/Users/user/project/.gsd/worktrees/M001'",
   "cd command uses forward slashes for Windows worktree path",
 );
 
 // Verify the mangled form from #1436 is NOT produced
-assertTrue(
+assert.ok(
   !cdCommand.includes("C:Users"),
   "mangled path C:Usersuserproject must not appear",
 );
@@ -90,10 +90,8 @@ console.log("\n=== teardown orphan warning path formatting ===");
 
 const windowsWtDir = "C:\\Users\\user\\project\\.gsd\\worktrees\\M001";
 const helpCommand = `rm -rf "${windowsWtDir.replaceAll("\\", "/")}"`;
-assertEq(
+assert.deepStrictEqual(
   helpCommand,
   'rm -rf "C:/Users/user/project/.gsd/worktrees/M001"',
   "orphan cleanup help command uses forward slashes",
 );
-
-report();

package/src/resources/extensions/gsd/tests/worker-registry.test.ts

@@ -5,7 +5,8 @@
  * and the hasActiveWorkers() status check.
  */
 
-import { createTestContext } from './test-helpers.ts';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 import {
   registerWorker,
   updateWorker,
@@ -15,7 +16,6 @@ import {
   resetWorkerRegistry,
 } from '../../subagent/worker-registry.ts';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
 // ─── Setup ────────────────────────────────────────────────────────────────────
 
@@ -28,15 +28,15 @@ console.log("\n=== Worker Registration ===");
 {
   resetWorkerRegistry();
   const id = registerWorker("scout", "Explore codebase", 0, 3, "batch-1");
-  assertTrue(id.startsWith("worker-"), "worker ID has correct prefix");
+  assert.ok(id.startsWith("worker-"), "worker ID has correct prefix");
   const workers = getActiveWorkers();
-  assertEq(workers.length, 1, "one worker registered");
-  assertEq(workers[0].agent, "scout", "worker agent name correct");
-  assertEq(workers[0].task, "Explore codebase", "worker task correct");
-  assertEq(workers[0].status, "running", "worker starts as running");
-  assertEq(workers[0].index, 0, "worker index correct");
-  assertEq(workers[0].batchSize, 3, "worker batch size correct");
-  assertEq(workers[0].batchId, "batch-1", "worker batch ID correct");
+  assert.deepStrictEqual(workers.length, 1, "one worker registered");
+  assert.deepStrictEqual(workers[0].agent, "scout", "worker agent name correct");
+  assert.deepStrictEqual(workers[0].task, "Explore codebase", "worker task correct");
+  assert.deepStrictEqual(workers[0].status, "running", "worker starts as running");
+  assert.deepStrictEqual(workers[0].index, 0, "worker index correct");
+  assert.deepStrictEqual(workers[0].batchSize, 3, "worker batch size correct");
+  assert.deepStrictEqual(workers[0].batchId, "batch-1", "worker batch ID correct");
 }
 
 // ─── Multiple workers in a batch ──────────────────────────────────────────────
@@ -50,14 +50,14 @@ console.log("\n=== Multiple Workers in a Batch ===");
   const id3 = registerWorker("worker", "Task C", 2, 3, "batch-2");
 
   const workers = getActiveWorkers();
-  assertEq(workers.length, 3, "three workers registered");
-  assertTrue(hasActiveWorkers(), "has active workers");
+  assert.deepStrictEqual(workers.length, 3, "three workers registered");
+  assert.ok(hasActiveWorkers(), "has active workers");
 
   const batches = getWorkerBatches();
-  assertEq(batches.size, 1, "one batch");
+  assert.deepStrictEqual(batches.size, 1, "one batch");
   const batch = batches.get("batch-2");
-  assertTrue(batch !== undefined, "batch-2 exists");
-  assertEq(batch!.length, 3, "batch has 3 workers");
+  assert.ok(batch !== undefined, "batch-2 exists");
+  assert.deepStrictEqual(batch!.length, 3, "batch has 3 workers");
 }
 
 // ─── Worker status updates ────────────────────────────────────────────────────
@@ -72,11 +72,11 @@ console.log("\n=== Worker Status Updates ===");
   updateWorker(id1, "completed");
   const workers = getActiveWorkers();
   const w1 = workers.find(w => w.id === id1);
-  assertEq(w1?.status, "completed", "worker 1 marked completed");
+  assert.deepStrictEqual(w1?.status, "completed", "worker 1 marked completed");
 
   const w2 = workers.find(w => w.id === id2);
-  assertEq(w2?.status, "running", "worker 2 still running");
-  assertTrue(hasActiveWorkers(), "still has active workers (worker 2 running)");
+  assert.deepStrictEqual(w2?.status, "running", "worker 2 still running");
+  assert.ok(hasActiveWorkers(), "still has active workers (worker 2 running)");
 }
 
 // ─── Failed worker ────────────────────────────────────────────────────────────
@@ -88,7 +88,7 @@ console.log("\n=== Failed Worker ===");
   const id = registerWorker("scout", "Task A", 0, 1, "batch-4");
   updateWorker(id, "failed");
   const workers = getActiveWorkers();
-  assertEq(workers[0].status, "failed", "worker marked failed");
+  assert.deepStrictEqual(workers[0].status, "failed", "worker marked failed");
 }
 
 // ─── Multiple batches ─────────────────────────────────────────────────────────
@@ -102,9 +102,9 @@ console.log("\n=== Multiple Batches ===");
   registerWorker("researcher", "Task C", 0, 1, "batch-6");
 
   const batches = getWorkerBatches();
-  assertEq(batches.size, 2, "two batches");
-  assertEq(batches.get("batch-5")!.length, 2, "batch-5 has 2 workers");
-  assertEq(batches.get("batch-6")!.length, 1, "batch-6 has 1 worker");
+  assert.deepStrictEqual(batches.size, 2, "two batches");
+  assert.deepStrictEqual(batches.get("batch-5")!.length, 2, "batch-5 has 2 workers");
+  assert.deepStrictEqual(batches.get("batch-6")!.length, 1, "batch-6 has 1 worker");
 }
 
 // ─── hasActiveWorkers with all completed ──────────────────────────────────────
@@ -117,7 +117,7 @@ console.log("\n=== hasActiveWorkers — all completed ===");
   const id2 = registerWorker("worker", "Task B", 1, 2, "batch-7");
   updateWorker(id1, "completed");
   updateWorker(id2, "completed");
-  assertTrue(!hasActiveWorkers(), "no active workers when all completed");
+  assert.ok(!hasActiveWorkers(), "no active workers when all completed");
 }
 
 // ─── Reset clears everything ─────────────────────────────────────────────────
@@ -126,10 +126,10 @@ console.log("\n=== Reset ===");
 
 {
   registerWorker("scout", "Task", 0, 1, "batch-8");
-  assertTrue(getActiveWorkers().length > 0, "workers exist before reset");
+  assert.ok(getActiveWorkers().length > 0, "workers exist before reset");
   resetWorkerRegistry();
-  assertEq(getActiveWorkers().length, 0, "no workers after reset");
-  assertTrue(!hasActiveWorkers(), "hasActiveWorkers false after reset");
+  assert.deepStrictEqual(getActiveWorkers().length, 0, "no workers after reset");
+  assert.ok(!hasActiveWorkers(), "hasActiveWorkers false after reset");
 }
 
 // ─── Update non-existent worker is no-op ──────────────────────────────────────
@@ -140,9 +140,7 @@ console.log("\n=== Update non-existent worker ===");
   resetWorkerRegistry();
   // Should not throw
   updateWorker("nonexistent-id", "completed");
-  assertEq(getActiveWorkers().length, 0, "no workers created by updating nonexistent");
+  assert.deepStrictEqual(getActiveWorkers().length, 0, "no workers created by updating nonexistent");
 }
 
 // ─── Summary ──────────────────────────────────────────────────────────────────
-
-report();

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();
+});