gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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

@@ -20,11 +20,11 @@ import {
   _getRegisteredLockDirs,
 } from '../session-lock.ts';
 import { gsdRoot } from '../paths.ts';
-import { createTestContext } from './test-helpers.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
-async function main(): Promise<void> {
+describe('session-lock-multipath', async () => {
 
   // ─── 1. Lock dir registry tracks gsdDir on acquisition ──────────────────
   console.log('\n=== 1. Lock dir registry tracks gsdDir on acquisition ===');
@@ -34,17 +34,17 @@ async function main(): Promise<void> {
 
     try {
       const result = acquireSessionLock(base);
-      assertTrue(result.acquired, 'lock acquired');
+      assert.ok(result.acquired, 'lock acquired');
 
       const registered = _getRegisteredLockDirs();
       const gsdDir = gsdRoot(base);
-      assertTrue(registered.includes(gsdDir), 'gsdDir is registered in lock dir registry');
+      assert.ok(registered.includes(gsdDir), 'gsdDir is registered in lock dir registry');
 
       releaseSessionLock(base);
 
       // After release, registry should be cleared
       const afterRelease = _getRegisteredLockDirs();
-      assertEq(afterRelease.length, 0, 'lock dir registry cleared after release');
+      assert.deepStrictEqual(afterRelease.length, 0, 'lock dir registry cleared after release');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -62,7 +62,7 @@ async function main(): Promise<void> {
 
     try {
       const result = acquireSessionLock(base);
-      assertTrue(result.acquired, 'lock acquired');
+      assert.ok(result.acquired, 'lock acquired');
 
       // Manually plant a stale lock file at the secondary path to simulate
       // multi-path lock accumulation
@@ -72,8 +72,8 @@ async function main(): Promise<void> {
       mkdirSync(secondaryLockDir, { recursive: true });
 
       // Verify they exist before release
-      assertTrue(existsSync(secondaryLockFile), 'secondary lock file exists before release');
-      assertTrue(existsSync(secondaryLockDir), 'secondary lock dir exists before release');
+      assert.ok(existsSync(secondaryLockFile), 'secondary lock file exists before release');
+      assert.ok(existsSync(secondaryLockDir), 'secondary lock dir exists before release');
 
       // Manually add the secondary dir to the registry (simulating ensureExitHandler call)
       // We do this by acquiring knowledge of internals — the registry is populated
@@ -83,10 +83,10 @@ async function main(): Promise<void> {
 
       // Primary lock artifacts should be cleaned
       const primaryLockFile = join(gsdRoot(base), 'auto.lock');
-      assertTrue(!existsSync(primaryLockFile), 'primary auto.lock removed after release');
+      assert.ok(!existsSync(primaryLockFile), 'primary auto.lock removed after release');
 
       const primaryLockDir = gsdRoot(base) + '.lock';
-      assertTrue(!existsSync(primaryLockDir), 'primary .gsd.lock/ removed after release');
+      assert.ok(!existsSync(primaryLockDir), 'primary .gsd.lock/ removed after release');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -106,7 +106,7 @@ async function main(): Promise<void> {
       const gsdDir = gsdRoot(base);
       // Should only appear once (Set deduplication)
       const count = registered.filter(d => d === gsdDir).length;
-      assertEq(count, 1, 'gsdDir registered exactly once after re-entrant acquisition');
+      assert.deepStrictEqual(count, 1, 'gsdDir registered exactly once after re-entrant acquisition');
 
       releaseSessionLock(base);
     } finally {
@@ -124,17 +124,17 @@ async function main(): Promise<void> {
 
     try {
       const r1 = acquireSessionLock(base1);
-      assertTrue(r1.acquired, 'first base lock acquired');
+      assert.ok(r1.acquired, 'first base lock acquired');
 
       // Release first to acquire second (module state is single-lock)
       releaseSessionLock(base1);
 
       const r2 = acquireSessionLock(base2);
-      assertTrue(r2.acquired, 'second base lock acquired');
+      assert.ok(r2.acquired, 'second base lock acquired');
 
       const registered = _getRegisteredLockDirs();
       const gsd2 = gsdRoot(base2);
-      assertTrue(registered.includes(gsd2), 'second gsdDir is registered');
+      assert.ok(registered.includes(gsd2), 'second gsdDir is registered');
 
       releaseSessionLock(base2);
     } finally {
@@ -156,18 +156,11 @@ async function main(): Promise<void> {
       // Verify everything is clean
       const lockFile = join(gsdRoot(base), 'auto.lock');
       const lockDir = gsdRoot(base) + '.lock';
-      assertTrue(!existsSync(lockFile), 'auto.lock cleaned');
-      assertTrue(!existsSync(lockDir), '.gsd.lock/ cleaned');
-      assertEq(_getRegisteredLockDirs().length, 0, 'registry empty');
+      assert.ok(!existsSync(lockFile), 'auto.lock cleaned');
+      assert.ok(!existsSync(lockDir), '.gsd.lock/ cleaned');
+      assert.deepStrictEqual(_getRegisteredLockDirs().length, 0, 'registry empty');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
   }
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });

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

@@ -0,0 +1,209 @@
+// shared-wal.test.ts — Tests for shared WAL DB path resolution and concurrent writes.
+// Verifies: resolveProjectRootDbPath() for worktree/root paths, WAL concurrent writes.
+
+import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { join, sep } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { resolveProjectRootDbPath } from '../bootstrap/dynamic-tools.ts';
+import {
+  openDatabase,
+  closeDatabase,
+  transaction,
+  insertMilestone,
+  getAllMilestones,
+  _getAdapter,
+} from '../gsd-db.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+
+
+// ─── Helpers ──────────────────────────────────────────────────────────────
+
+function createTmpDir(suffix: string): string {
+  return mkdtempSync(join(tmpdir(), `gsd-wal-${suffix}-`));
+}
+
+function cleanup(dir: string): void {
+  rmSync(dir, { recursive: true, force: true });
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────
+
+describe('shared-wal', async () => {
+  // ─── 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'),
+      'worktree path resolves to project root DB');
+  }
+
+  // ─── Test (b): resolveProjectRootDbPath returns same base for project root ────
+  console.log('\n=== shared-wal: resolve project root path ===');
+  {
+    const projectRoot = '/home/user/myproject';
+    const result = resolveProjectRootDbPath(projectRoot);
+    assert.deepStrictEqual(result, join(projectRoot, '.gsd', 'gsd.db'),
+      'project root path stays at project root DB');
+  }
+
+  // ─── Test (c): resolve nested worktree subdir ──────────────────────────
+  console.log('\n=== shared-wal: resolve nested worktree subdir ===');
+  {
+    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'),
+      'nested worktree subdir resolves to project root DB');
+  }
+
+  // ─── Test (d): resolve with forward slashes (cross-platform) ──────────
+  console.log('\n=== shared-wal: resolve forward-slash path ===');
+  {
+    const result = resolveProjectRootDbPath('/proj/.gsd/worktrees/M001');
+    assert.deepStrictEqual(result, join('/proj', '.gsd', 'gsd.db'),
+      'forward-slash worktree path resolves correctly');
+  }
+
+  // ─── Test (e): Concurrent writes — 3 connections to same WAL DB ───────
+  console.log('\n=== shared-wal: concurrent writes via WAL ===');
+  {
+    const tmp = createTmpDir('concurrent');
+    const dbPath = join(tmp, 'test.db');
+    try {
+      // Open with openDatabase to init schema + WAL mode
+      openDatabase(dbPath);
+
+      // Insert milestones from the main connection
+      insertMilestone({
+        id: 'M001', title: 'From conn 1', status: 'active',
+      });
+
+      // Open two additional raw connections via openDatabase in separate calls.
+      // Since openDatabase closes the previous connection and opens a new one,
+      // we simulate concurrent access by using the transaction() wrapper to
+      // verify WAL allows reads while writes are happening.
+
+      // Write M002
+      insertMilestone({
+        id: 'M002', title: 'From conn 2', status: 'active',
+      });
+
+      // Write M003
+      insertMilestone({
+        id: 'M003', title: 'From conn 3', status: 'active',
+      });
+
+      // Verify all 3 milestones are visible
+      const all = getAllMilestones();
+      assert.deepStrictEqual(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');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(tmp);
+    }
+  }
+
+  // ─── Test (f): WAL concurrent — multiple raw connections to file DB ────
+  console.log('\n=== shared-wal: true concurrent connections via raw SQLite ===');
+  {
+    const tmp = createTmpDir('rawconc');
+    const dbPath = join(tmp, 'concurrent.db');
+    try {
+      // Open first connection and init schema
+      openDatabase(dbPath);
+      closeDatabase();
+
+      // To test true concurrent access, we open 3 separate raw connections
+      // using the same provider. The openDatabase/closeDatabase cycle proves
+      // WAL mode persists and multiple sequential openers see each other's writes.
+
+      // Connection 1: write M001
+      openDatabase(dbPath);
+      insertMilestone({ id: 'M001', title: 'Writer 1', status: 'active' });
+      closeDatabase();
+
+      // Connection 2: write M002, verify sees M001
+      openDatabase(dbPath);
+      const afterConn2Before = getAllMilestones();
+      assert.ok(afterConn2Before.some(m => m.id === 'M001'),
+        'rawconc: conn2 sees M001 from conn1');
+      insertMilestone({ id: 'M002', title: 'Writer 2', status: 'active' });
+      closeDatabase();
+
+      // Connection 3: write M003, verify sees M001 + M002
+      openDatabase(dbPath);
+      const afterConn3Before = getAllMilestones();
+      assert.ok(afterConn3Before.some(m => m.id === 'M001'),
+        'rawconc: conn3 sees M001');
+      assert.ok(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(
+        finalAll.map(m => m.id).sort(),
+        ['M001', 'M002', 'M003'],
+        'rawconc: all IDs present',
+      );
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(tmp);
+    }
+  }
+
+  // ─── Test (g): BUSY retry — transaction wrapper handles contention ─────
+  console.log('\n=== shared-wal: transaction rollback on error ===');
+  {
+    const tmp = createTmpDir('busy');
+    const dbPath = join(tmp, 'busy.db');
+    try {
+      openDatabase(dbPath);
+
+      // Insert a milestone in a transaction
+      transaction(() => {
+        insertMilestone({ id: 'M001', title: 'In txn', status: 'active' });
+      });
+
+      // Verify it committed
+      const all = getAllMilestones();
+      assert.deepStrictEqual(all.length, 1, 'busy: M001 committed via transaction');
+
+      // Verify transaction rolls back on error
+      let errorCaught = false;
+      try {
+        transaction(() => {
+          insertMilestone({ id: 'M002', title: 'Will fail', status: 'active' });
+          throw new Error('Simulated failure');
+        });
+      } catch (err) {
+        errorCaught = true;
+        assert.ok(
+          (err as Error).message.includes('Simulated failure'),
+          'busy: error propagated from transaction',
+        );
+      }
+      assert.ok(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');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(tmp);
+    }
+  }
+});

package/src/resources/extensions/gsd/tests/sqlite-unavailable-gate.test.ts

@@ -0,0 +1,63 @@
+/**
+ * sqlite-unavailable-gate.test.ts — #2419
+ *
+ * When the SQLite provider fails to open, bootstrapAutoSession must
+ * refuse to start auto-mode. Otherwise gsd_task_complete returns
+ * "db_unavailable", artifact retry re-dispatches the same task, and
+ * the session loops forever.
+ *
+ * This test verifies the gate by reading auto-start.ts source and
+ * confirming the pattern: after the DB lifecycle block, if the DB
+ * file exists on disk but isDbAvailable() still returns false after
+ * the open attempt, bootstrap must abort with an error notification.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, report } = createTestContext();
+
+const srcPath = join(import.meta.dirname, "..", "auto-start.ts");
+const src = readFileSync(srcPath, "utf-8");
+
+console.log("\n=== #2419: SQLite unavailable gate in auto-start.ts ===");
+
+// The DB lifecycle section tries to open the DB. After those try/catch
+// blocks, there must be a HARD GATE: if the DB file exists on disk but
+// isDbAvailable() is still false (open failed), bootstrap must abort
+// by calling releaseLockAndReturn() with an error notification.
+
+const dbLifecycleIdx = src.indexOf("DB lifecycle");
+assertTrue(dbLifecycleIdx > 0, "auto-start.ts has a DB lifecycle section");
+
+const afterDbLifecycle = src.slice(dbLifecycleIdx);
+
+// Find the second isDbAvailable check — the one AFTER the open attempts.
+// The first check at line ~543 tries to open the DB.
+// There must be a SECOND check that gates bootstrap if it's still unavailable.
+const firstCheck = afterDbLifecycle.indexOf("isDbAvailable()");
+assertTrue(firstCheck > 0, "DB lifecycle section has isDbAvailable() check");
+
+const afterFirstCheck = afterDbLifecycle.slice(firstCheck + "isDbAvailable()".length);
+const secondCheck = afterFirstCheck.indexOf("isDbAvailable()");
+
+assertTrue(
+  secondCheck > 0,
+  "auto-start.ts has a SECOND isDbAvailable() check after the open attempt — this is the gate (#2419)",
+);
+
+// The second check must lead to releaseLockAndReturn (abort bootstrap)
+if (secondCheck > 0) {
+  const gateRegion = afterFirstCheck.slice(secondCheck, secondCheck + 500);
+  assertTrue(
+    gateRegion.includes("releaseLockAndReturn"),
+    "The DB availability gate calls releaseLockAndReturn() to abort bootstrap (#2419)",
+  );
+  assertTrue(
+    /database|sqlite|db.*unavailable/i.test(gateRegion),
+    "The DB availability gate includes a user-facing error message about the database (#2419)",
+  );
+}
+
+report();

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 { createTestContext } from './test-helpers.ts';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 
-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;
-    assertTrue(
+    assert.ok(
       err.message.includes("path") || err.message.includes("string") || err.code === "ERR_INVALID_ARG_TYPE",
       `should crash with path/type error, got: ${err.message}`,
     );
   }
-  assertTrue(crashed, "should crash when basePath is undefined (reproduces #1855)");
+  assert.ok(crashed, "should crash when basePath is undefined (reproduces #1855)");
 }
 
 // ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
@@ -90,13 +90,11 @@ function makeMockPi() {
       crashed = true;
       console.error(`  Unexpected crash: ${err.message}`);
     }
-    assertTrue(!crashed, "should not crash with valid basePath");
+    assert.ok(!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".
-    assertTrue(result === "recovered", `should return 'recovered', got '${result}'`);
+    assert.ok(result === "recovered", `should return 'recovered', got '${result}'`);
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
 }
-
-report();