gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/session-lock-regression.test.ts

@@ -25,9 +25,9 @@ import {
   isSessionLockHeld,
 } from '../session-lock.ts';
 import { gsdRoot } from '../paths.ts';
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
 
+const { assertEq, assertTrue, report } = createTestContext();
 const require = createRequire(import.meta.url);
 
 function hasProperLockfile(): boolean {
@@ -41,7 +41,7 @@ function hasProperLockfile(): boolean {
 
 const properLockfileAvailable = hasProperLockfile();
 
-describe('session-lock-regression', async () => {
+async function main(): Promise<void> {
 
   // ─── 1. Basic acquire/release lifecycle ───────────────────────────────
   console.log('\n=== 1. acquire → validate → release lifecycle ===');
@@ -51,22 +51,22 @@ describe('session-lock-regression', async () => {
 
     try {
       const result = acquireSessionLock(base);
-      assert.ok(result.acquired, 'lock acquired successfully');
+      assertTrue(result.acquired, 'lock acquired successfully');
 
       const valid = validateSessionLock(base);
-      assert.ok(valid, 'lock validates after acquisition');
+      assertTrue(valid, 'lock validates after acquisition');
 
-      assert.ok(isSessionLockHeld(base), 'isSessionLockHeld returns true');
+      assertTrue(isSessionLockHeld(base), 'isSessionLockHeld returns true');
 
       releaseSessionLock(base);
 
       // After release, the lock file should be cleaned up
       const lockFile = join(gsdRoot(base), 'auto.lock');
-      assert.ok(!existsSync(lockFile), 'lock file removed after release');
+      assertTrue(!existsSync(lockFile), 'lock file removed after release');
 
       // The .gsd.lock/ directory should be cleaned up
       const lockDir = gsdRoot(base) + '.lock';
-      assert.ok(!existsSync(lockDir), '.gsd.lock/ directory removed after release (#1245)');
+      assertTrue(!existsSync(lockDir), '.gsd.lock/ directory removed after release (#1245)');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -88,7 +88,7 @@ describe('session-lock-regression', async () => {
       } catch {
         threw = true;
       }
-      assert.ok(!threw, 'double release does not throw');
+      assertTrue(!threw, 'double release does not throw');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -106,13 +106,13 @@ describe('session-lock-regression', async () => {
       updateSessionLock(base, 'execute-task', 'M001/S01/T01', 5, '/tmp/session.json');
 
       const data = readSessionLockData(base);
-      assert.ok(data !== null, 'lock data readable after update');
+      assertTrue(data !== null, 'lock data readable after update');
       if (data) {
-        assert.deepStrictEqual(data.pid, process.pid, 'lock data has correct PID');
-        assert.deepStrictEqual(data.unitType, 'execute-task', 'lock data has correct unit type');
-        assert.deepStrictEqual(data.unitId, 'M001/S01/T01', 'lock data has correct unit ID');
-        assert.deepStrictEqual(data.completedUnits, 5, 'lock data has correct completed count');
-        assert.deepStrictEqual(data.sessionFile, '/tmp/session.json', 'lock data has session file');
+        assertEq(data.pid, process.pid, 'lock data has correct PID');
+        assertEq(data.unitType, 'execute-task', 'lock data has correct unit type');
+        assertEq(data.unitId, 'M001/S01/T01', 'lock data has correct unit ID');
+        assertEq(data.completedUnits, 5, 'lock data has correct completed count');
+        assertEq(data.sessionFile, '/tmp/session.json', 'lock data has session file');
       }
 
       releaseSessionLock(base);
@@ -142,7 +142,7 @@ describe('session-lock-regression', async () => {
 
       // Should be able to acquire despite the stale lock
       const result = acquireSessionLock(base);
-      assert.ok(result.acquired, '#1245: stale lock from dead PID → re-acquirable');
+      assertTrue(result.acquired, '#1245: stale lock from dead PID → re-acquirable');
 
       releaseSessionLock(base);
     } finally {
@@ -158,7 +158,7 @@ describe('session-lock-regression', async () => {
 
     try {
       const data = readSessionLockData(base);
-      assert.deepStrictEqual(data, null, 'no lock file → null');
+      assertEq(data, null, 'no lock file → null');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -176,7 +176,7 @@ describe('session-lock-regression', async () => {
       // Multiple validations should all return true (regression for #1257)
       for (let i = 0; i < 5; i++) {
         const valid = validateSessionLock(base);
-        assert.ok(valid, `#1257: validation ${i + 1} returns true for own lock`);
+        assertTrue(valid, `#1257: validation ${i + 1} returns true for own lock`);
       }
 
       releaseSessionLock(base);
@@ -196,7 +196,7 @@ describe('session-lock-regression', async () => {
       writeFileSync(lockFile, 'NOT VALID JSON {{{');
 
       const data = readSessionLockData(base);
-      assert.deepStrictEqual(data, null, 'corrupt JSON → null');
+      assertEq(data, null, 'corrupt JSON → null');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -210,9 +210,9 @@ describe('session-lock-regression', async () => {
 
     try {
       const status = getSessionLockStatus(base);
-      assert.deepStrictEqual(status.valid, false, 'missing lock metadata is invalid');
-      assert.deepStrictEqual(status.failureReason, 'missing-metadata', 'missing metadata reason is surfaced');
-      assert.deepStrictEqual(status.expectedPid, process.pid, 'expected PID is included');
+      assertEq(status.valid, false, 'missing lock metadata is invalid');
+      assertEq(status.failureReason, 'missing-metadata', 'missing metadata reason is surfaced');
+      assertEq(status.expectedPid, process.pid, 'expected PID is included');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -237,10 +237,10 @@ describe('session-lock-regression', async () => {
       }, null, 2));
 
       const status = getSessionLockStatus(base);
-      assert.deepStrictEqual(status.valid, false, 'foreign PID lock is invalid');
-      assert.deepStrictEqual(status.failureReason, 'pid-mismatch', 'PID mismatch reason is surfaced');
-      assert.deepStrictEqual(status.existingPid, foreignPid, 'existing PID is included');
-      assert.deepStrictEqual(status.expectedPid, process.pid, 'expected PID is included');
+      assertEq(status.valid, false, 'foreign PID lock is invalid');
+      assertEq(status.failureReason, 'pid-mismatch', 'PID mismatch reason is surfaced');
+      assertEq(status.existingPid, foreignPid, 'existing PID is included');
+      assertEq(status.expectedPid, process.pid, 'expected PID is included');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -254,11 +254,11 @@ describe('session-lock-regression', async () => {
 
     try {
       const r1 = acquireSessionLock(base);
-      assert.ok(r1.acquired, 'first acquisition');
+      assertTrue(r1.acquired, 'first acquisition');
       releaseSessionLock(base);
 
       const r2 = acquireSessionLock(base);
-      assert.ok(r2.acquired, 're-acquisition after release');
+      assertTrue(r2.acquired, 're-acquisition after release');
       releaseSessionLock(base);
     } finally {
       rmSync(base, { recursive: true, force: true });
@@ -273,13 +273,13 @@ describe('session-lock-regression', async () => {
 
     try {
       const r1 = acquireSessionLock(base);
-      assert.ok(r1.acquired, 'first acquisition succeeds');
+      assertTrue(r1.acquired, 'first acquisition succeeds');
 
       const r2 = acquireSessionLock(base);
-      assert.ok(r2.acquired, 're-entrant acquisition succeeds');
+      assertTrue(r2.acquired, 're-entrant acquisition succeeds');
 
       const valid = validateSessionLock(base);
-      assert.ok(valid, 're-entrant acquisition does not corrupt validation state');
+      assertTrue(valid, 're-entrant acquisition does not corrupt validation state');
 
       releaseSessionLock(base);
     } finally {
@@ -295,24 +295,31 @@ describe('session-lock-regression', async () => {
 
     try {
       const r1 = acquireSessionLock(base);
-      assert.ok(r1.acquired, 'first acquisition succeeds');
+      assertTrue(r1.acquired, 'first acquisition succeeds');
 
       const lockDir = gsdRoot(base) + '.lock';
       if (properLockfileAvailable) {
-        assert.ok(existsSync(lockDir), '.gsd.lock/ exists after first acquisition');
+        assertTrue(existsSync(lockDir), '.gsd.lock/ exists after first acquisition');
       }
 
       const r2 = acquireSessionLock(base);
-      assert.ok(r2.acquired, 'second acquisition succeeds');
+      assertTrue(r2.acquired, 'second acquisition succeeds');
       if (properLockfileAvailable) {
-        assert.ok(existsSync(lockDir), '.gsd.lock/ exists after re-entrant acquisition');
+        assertTrue(existsSync(lockDir), '.gsd.lock/ exists after re-entrant acquisition');
       }
-      assert.ok(validateSessionLock(base), 'lock remains valid after re-entrant acquisition');
+      assertTrue(validateSessionLock(base), 'lock remains valid after re-entrant acquisition');
 
       releaseSessionLock(base);
-      assert.ok(!existsSync(lockDir), '.gsd.lock/ is removed after release');
+      assertTrue(!existsSync(lockDir), '.gsd.lock/ is removed after release');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
   }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
 });

package/src/resources/extensions/gsd/tests/shared-wal.test.ts

@@ -14,9 +14,9 @@ import {
   getAllMilestones,
   _getAdapter,
 } from '../gsd-db.ts';
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
 
+const { assertEq, assertTrue, report } = createTestContext();
 
 // ─── Helpers ──────────────────────────────────────────────────────────────
 
@@ -30,14 +30,14 @@ function cleanup(dir: string): void {
 
 // ─── Tests ────────────────────────────────────────────────────────────────
 
-describe('shared-wal', async () => {
+async function main() {
   // ─── Test (a): resolveProjectRootDbPath returns project root DB for worktree path ───
   console.log('\n=== shared-wal: resolve worktree path to project root DB ===');
   {
     const projectRoot = '/home/user/myproject';
     const worktreePath = join(projectRoot, '.gsd', 'worktrees', 'M001');
     const result = resolveProjectRootDbPath(worktreePath);
-    assert.deepStrictEqual(result, join(projectRoot, '.gsd', 'gsd.db'),
+    assertEq(result, join(projectRoot, '.gsd', 'gsd.db'),
       'worktree path resolves to project root DB');
   }
 
@@ -46,7 +46,7 @@ describe('shared-wal', async () => {
   {
     const projectRoot = '/home/user/myproject';
     const result = resolveProjectRootDbPath(projectRoot);
-    assert.deepStrictEqual(result, join(projectRoot, '.gsd', 'gsd.db'),
+    assertEq(result, join(projectRoot, '.gsd', 'gsd.db'),
       'project root path stays at project root DB');
   }
 
@@ -56,7 +56,7 @@ describe('shared-wal', async () => {
     const projectRoot = '/home/user/myproject';
     const nestedPath = join(projectRoot, '.gsd', 'worktrees', 'M002', 'src', 'lib');
     const result = resolveProjectRootDbPath(nestedPath);
-    assert.deepStrictEqual(result, join(projectRoot, '.gsd', 'gsd.db'),
+    assertEq(result, join(projectRoot, '.gsd', 'gsd.db'),
       'nested worktree subdir resolves to project root DB');
   }
 
@@ -64,7 +64,7 @@ describe('shared-wal', async () => {
   console.log('\n=== shared-wal: resolve forward-slash path ===');
   {
     const result = resolveProjectRootDbPath('/proj/.gsd/worktrees/M001');
-    assert.deepStrictEqual(result, join('/proj', '.gsd', 'gsd.db'),
+    assertEq(result, join('/proj', '.gsd', 'gsd.db'),
       'forward-slash worktree path resolves correctly');
   }
 
@@ -99,9 +99,9 @@ describe('shared-wal', async () => {
 
       // Verify all 3 milestones are visible
       const all = getAllMilestones();
-      assert.deepStrictEqual(all.length, 3, 'concurrent: all 3 milestones visible');
+      assertEq(all.length, 3, 'concurrent: all 3 milestones visible');
       const ids = all.map(m => m.id).sort();
-      assert.deepStrictEqual(ids, ['M001', 'M002', 'M003'], 'concurrent: correct IDs');
+      assertEq(ids, ['M001', 'M002', 'M003'], 'concurrent: correct IDs');
 
       closeDatabase();
     } finally {
@@ -132,7 +132,7 @@ describe('shared-wal', async () => {
       // Connection 2: write M002, verify sees M001
       openDatabase(dbPath);
       const afterConn2Before = getAllMilestones();
-      assert.ok(afterConn2Before.some(m => m.id === 'M001'),
+      assertTrue(afterConn2Before.some(m => m.id === 'M001'),
         'rawconc: conn2 sees M001 from conn1');
       insertMilestone({ id: 'M002', title: 'Writer 2', status: 'active' });
       closeDatabase();
@@ -140,16 +140,16 @@ describe('shared-wal', async () => {
       // Connection 3: write M003, verify sees M001 + M002
       openDatabase(dbPath);
       const afterConn3Before = getAllMilestones();
-      assert.ok(afterConn3Before.some(m => m.id === 'M001'),
+      assertTrue(afterConn3Before.some(m => m.id === 'M001'),
         'rawconc: conn3 sees M001');
-      assert.ok(afterConn3Before.some(m => m.id === 'M002'),
+      assertTrue(afterConn3Before.some(m => m.id === 'M002'),
         'rawconc: conn3 sees M002');
       insertMilestone({ id: 'M003', title: 'Writer 3', status: 'active' });
 
       // Final read: all 3 visible
       const finalAll = getAllMilestones();
-      assert.deepStrictEqual(finalAll.length, 3, 'rawconc: all 3 milestones visible');
-      assert.deepStrictEqual(
+      assertEq(finalAll.length, 3, 'rawconc: all 3 milestones visible');
+      assertEq(
         finalAll.map(m => m.id).sort(),
         ['M001', 'M002', 'M003'],
         'rawconc: all IDs present',
@@ -177,7 +177,7 @@ describe('shared-wal', async () => {
 
       // Verify it committed
       const all = getAllMilestones();
-      assert.deepStrictEqual(all.length, 1, 'busy: M001 committed via transaction');
+      assertEq(all.length, 1, 'busy: M001 committed via transaction');
 
       // Verify transaction rolls back on error
       let errorCaught = false;
@@ -188,17 +188,17 @@ describe('shared-wal', async () => {
         });
       } catch (err) {
         errorCaught = true;
-        assert.ok(
+        assertTrue(
           (err as Error).message.includes('Simulated failure'),
           'busy: error propagated from transaction',
         );
       }
-      assert.ok(errorCaught, 'busy: transaction threw on error');
+      assertTrue(errorCaught, 'busy: transaction threw on error');
 
       // M002 should NOT be visible (rolled back)
       const afterRollback = getAllMilestones();
-      assert.deepStrictEqual(afterRollback.length, 1, 'busy: M002 rolled back — still only 1 milestone');
-      assert.deepStrictEqual(afterRollback[0]!.id, 'M001', 'busy: only M001 survives');
+      assertEq(afterRollback.length, 1, 'busy: M002 rolled back — still only 1 milestone');
+      assertEq(afterRollback[0]!.id, 'M001', 'busy: only M001 survives');
 
       closeDatabase();
     } finally {
@@ -206,4 +206,11 @@ describe('shared-wal', async () => {
       cleanup(tmp);
     }
   }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
 });

package/src/resources/extensions/gsd/tests/stalled-tool-recovery.test.ts

@@ -19,9 +19,9 @@ import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { recoverTimedOutUnit, type RecoveryContext } from "../auto-timeout-recovery.ts";
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
 
+const { assertTrue, report } = createTestContext();
 
 // Minimal mock for ExtensionContext — only the fields recoverTimedOutUnit touches.
 function makeMockCtx() {
@@ -55,12 +55,12 @@ function makeMockPi() {
     await recoverTimedOutUnit(ctx, pi, "execute-task", "M001/S01/T01", "idle", emptyRctx);
   } catch (err: any) {
     crashed = true;
-    assert.ok(
+    assertTrue(
       err.message.includes("path") || err.message.includes("string") || err.code === "ERR_INVALID_ARG_TYPE",
       `should crash with path/type error, got: ${err.message}`,
     );
   }
-  assert.ok(crashed, "should crash when basePath is undefined (reproduces #1855)");
+  assertTrue(crashed, "should crash when basePath is undefined (reproduces #1855)");
 }
 
 // ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
@@ -90,11 +90,13 @@ function makeMockPi() {
       crashed = true;
       console.error(`  Unexpected crash: ${err.message}`);
     }
-    assert.ok(!crashed, "should not crash with valid basePath");
+    assertTrue(!crashed, "should not crash with valid basePath");
     // With no runtime record on disk and recoveryAttempts=0, the function
     // should attempt steering recovery (sendMessage) and return "recovered".
-    assert.ok(result === "recovered", `should return 'recovered', got '${result}'`);
+    assertTrue(result === "recovered", `should return 'recovered', got '${result}'`);
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
 }
+
+report();

package/src/resources/extensions/gsd/tests/symlink-numbered-variants.test.ts

@@ -23,15 +23,15 @@ import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { ensureGsdSymlink, externalGsdRoot } from "../repo-identity.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();
 }
 
-describe('symlink-numbered-variants', async () => {
+async function main(): Promise<void> {
   const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-symlink-variants-")));
   const stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-variants-")));
 
@@ -58,14 +58,14 @@ describe('symlink-numbered-variants', async () => {
       mkdirSync(join(base, ".gsd 4"), { recursive: true });
 
       const result = ensureGsdSymlink(base);
-      assert.deepStrictEqual(result, externalPath, "ensureGsdSymlink returns external path");
-      assert.ok(existsSync(join(base, ".gsd")), ".gsd exists after ensureGsdSymlink");
-      assert.ok(lstatSync(join(base, ".gsd")).isSymbolicLink(), ".gsd is a symlink");
+      assertEq(result, externalPath, "ensureGsdSymlink returns external path");
+      assertTrue(existsSync(join(base, ".gsd")), ".gsd exists after ensureGsdSymlink");
+      assertTrue(lstatSync(join(base, ".gsd")).isSymbolicLink(), ".gsd is a symlink");
 
       // The numbered variants must have been removed
-      assert.ok(!existsSync(join(base, ".gsd 2")), '".gsd 2" directory was cleaned up');
-      assert.ok(!existsSync(join(base, ".gsd 3")), '".gsd 3" directory was cleaned up');
-      assert.ok(!existsSync(join(base, ".gsd 4")), '".gsd 4" directory was cleaned up');
+      assertTrue(!existsSync(join(base, ".gsd 2")), '".gsd 2" directory was cleaned up');
+      assertTrue(!existsSync(join(base, ".gsd 3")), '".gsd 3" directory was cleaned up');
+      assertTrue(!existsSync(join(base, ".gsd 4")), '".gsd 4" directory was cleaned up');
     }
 
     // ── Test: numbered variant symlinks are cleaned up ─────────────────
@@ -82,12 +82,12 @@ describe('symlink-numbered-variants', async () => {
       symlinkSync(staleTarget, join(base, ".gsd 3"), "junction");
 
       const result = ensureGsdSymlink(base);
-      assert.deepStrictEqual(result, externalPath, "ensureGsdSymlink returns external path when variants exist");
-      assert.ok(existsSync(join(base, ".gsd")), ".gsd exists");
-      assert.ok(lstatSync(join(base, ".gsd")).isSymbolicLink(), ".gsd is a symlink");
+      assertEq(result, externalPath, "ensureGsdSymlink returns external path when variants exist");
+      assertTrue(existsSync(join(base, ".gsd")), ".gsd exists");
+      assertTrue(lstatSync(join(base, ".gsd")).isSymbolicLink(), ".gsd is a symlink");
 
-      assert.ok(!existsSync(join(base, ".gsd 2")), '".gsd 2" symlink variant was cleaned up');
-      assert.ok(!existsSync(join(base, ".gsd 3")), '".gsd 3" symlink variant was cleaned up');
+      assertTrue(!existsSync(join(base, ".gsd 2")), '".gsd 2" symlink variant was cleaned up');
+      assertTrue(!existsSync(join(base, ".gsd 3")), '".gsd 3" symlink variant was cleaned up');
     }
 
     // ── Test: real .gsd directory blocks symlink, but variants still cleaned ──
@@ -104,12 +104,12 @@ describe('symlink-numbered-variants', async () => {
 
       const result = ensureGsdSymlink(base);
       // When .gsd is a real directory, ensureGsdSymlink preserves it
-      assert.deepStrictEqual(result, join(base, ".gsd"), "real .gsd directory preserved");
-      assert.ok(lstatSync(join(base, ".gsd")).isDirectory(), ".gsd remains a directory");
+      assertEq(result, join(base, ".gsd"), "real .gsd directory preserved");
+      assertTrue(lstatSync(join(base, ".gsd")).isDirectory(), ".gsd remains a directory");
 
       // But the numbered variants should still be cleaned up
-      assert.ok(!existsSync(join(base, ".gsd 2")), '".gsd 2" cleaned even when .gsd is a directory');
-      assert.ok(!existsSync(join(base, ".gsd 3")), '".gsd 3" cleaned even when .gsd is a directory');
+      assertTrue(!existsSync(join(base, ".gsd 2")), '".gsd 2" cleaned even when .gsd is a directory');
+      assertTrue(!existsSync(join(base, ".gsd 3")), '".gsd 3" cleaned even when .gsd is a directory');
     }
 
     // ── Test: only numeric-suffixed variants are removed ───────────────
@@ -127,10 +127,10 @@ describe('symlink-numbered-variants', async () => {
 
       ensureGsdSymlink(base);
 
-      assert.ok(existsSync(join(base, ".gsd-backup")), ".gsd-backup is NOT removed");
-      assert.ok(existsSync(join(base, ".gsd_old")), ".gsd_old is NOT removed");
-      assert.ok(!existsSync(join(base, ".gsd 2")), '".gsd 2" removed');
-      assert.ok(!existsSync(join(base, ".gsd 10")), '".gsd 10" removed');
+      assertTrue(existsSync(join(base, ".gsd-backup")), ".gsd-backup is NOT removed");
+      assertTrue(existsSync(join(base, ".gsd_old")), ".gsd_old is NOT removed");
+      assertTrue(!existsSync(join(base, ".gsd 2")), '".gsd 2" removed');
+      assertTrue(!existsSync(join(base, ".gsd 10")), '".gsd 10" removed');
 
       // Cleanup non-variant dirs
       rmSync(join(base, ".gsd-backup"), { recursive: true, force: true });
@@ -141,5 +141,11 @@ describe('symlink-numbered-variants', async () => {
     delete process.env.GSD_STATE_DIR;
     try { rmSync(base, { recursive: true, force: true }); } catch { /* ignore */ }
     try { rmSync(stateDir, { recursive: true, force: true }); } catch { /* ignore */ }
+    report();
   }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
 });