@yemi33/minions 0.1.2115 → 0.1.2117

package/bin/minions.js

@@ -34,6 +34,27 @@
  *   minions uninstall --confirm      Remove Minions and uninstall package
  */
 
+// Phase 9.4 (issue #3035 hardening): self-reexec on Node 22.x without
+// --experimental-sqlite so the CLI PARENT process can load `node:sqlite`
+// for in-process store reads (status, doctor, etc.). On Node 24+ this is a
+// no-op (sqlite is unflagged). Must run BEFORE any `require('engine/*')` —
+// engine modules pull in `node:sqlite` transitively via `engine/db`.
+(function _ensureSqliteFlagSelfReexec() {
+  const major = parseInt(String(process.versions.node).split('.')[0], 10);
+  if (!Number.isFinite(major) || major < 22 || major >= 24) return;
+  const opts = String(process.env.NODE_OPTIONS || '');
+  if (opts.includes('--experimental-sqlite')) return;
+  if (process.env.MINIONS_FORCE_JSON === '1') return; // explicit opt-out
+  const { spawnSync } = require('child_process');
+  const nextOpts = (opts + ' --experimental-sqlite').trim();
+  const res = spawnSync(
+    process.execPath,
+    ['--experimental-sqlite', __filename, ...process.argv.slice(2)],
+    { stdio: 'inherit', env: { ...process.env, NODE_OPTIONS: nextOpts } }
+  );
+  process.exit(res.status == null ? 1 : res.status);
+})();
+
 const fs = require('fs');
 const path = require('path');
 const os = require('os');

package/engine/cleanup.js

@@ -1410,12 +1410,19 @@ async function runCleanup(config, verbose = false) {
   } catch (e) { log('warn', 'clean stale PID files: ' + e.message); }
 
   // 13. Prune test-results.json — keep last 200 entries
+  // Phase 9.3: route through shared.mutateTestResults so the read+trim+write
+  // is atomic under the file lock (previously a safeJsonArr → safeWrite race).
   try {
     const testResultsPath = path.join(ENGINE_DIR, 'test-results.json');
-    const results = shared.safeJsonArr(testResultsPath);
     const TEST_RESULTS_CAP = 200;
-    if (results.length > TEST_RESULTS_CAP) {
-      safeWrite(testResultsPath, results.slice(-TEST_RESULTS_CAP));
+    // Fast path: skip lock acquisition entirely when the file is already
+    // under cap. The atomic re-check inside the mutator handles the race.
+    const probe = shared.safeJsonArr(testResultsPath);
+    if (probe.length > TEST_RESULTS_CAP) {
+      shared.mutateTestResults((curr) => {
+        if (curr.length > TEST_RESULTS_CAP) return curr.slice(-TEST_RESULTS_CAP);
+        return undefined; // already trimmed by a concurrent writer
+      });
     }
   } catch { /* optional — file may not exist */ }
 

package/engine/consolidation.js

@@ -849,7 +849,7 @@ function classifyToKnowledgeBase(items, config) {
       const dir = path.join(KNOWLEDGE_DIR, cat);
       if (fs.existsSync(dir)) count += fs.readdirSync(dir).length;
     }
-    safeWrite(path.join(ENGINE_DIR, 'kb-checkpoint.json'), JSON.stringify({ count, updatedAt: ts() }));
+    shared.mutateKbCheckpoint(() => ({ count, updatedAt: ts() }));
   } catch (err) { log('warn', `KB checkpoint: ${err.message}`); }
 }
 

package/engine/db/index.js

@@ -88,16 +88,45 @@ function getDb() {
   try {
     _installExperimentalWarningFilter();
     const { DatabaseSync } = require('node:sqlite');
-    _db = new DatabaseSync(dbPath);
-    _dbPath = dbPath;
-    // WAL mode lets the engine writer and dashboard reader hit the same
-    // file from two processes without lock contention. NORMAL synchronous
-    // is the recommended WAL pairing (durable enough; one OS-level fsync
-    // per checkpoint instead of per write).
-    _db.exec('PRAGMA journal_mode = WAL');
-    _db.exec('PRAGMA foreign_keys = ON');
-    _db.exec('PRAGMA synchronous = NORMAL');
-    _db.exec('PRAGMA busy_timeout = 5000');
+    // Concurrent cold-openers (parallel child processes in tests; engine
+    // + dashboard cold-starting together) can race on the exclusive lock
+    // that SQLite needs to either create the file or upgrade
+    // journal_mode to WAL on the first connection. `busy_timeout` only
+    // applies to PRAGMAs and queries AFTER the connection is open, so
+    // `new DatabaseSync(dbPath)` itself and the initial WAL PRAGMA can
+    // still return SQLITE_BUSY. Retry the whole open+PRAGMA sequence
+    // with backoff so a brief lock contention isn't a hard failure.
+    // Phase 9.4 removed the JSON fallback that previously hid this
+    // race — without retry, parallel test runs fail intermittently with
+    // "small-state-store: SQLite unavailable (... database is locked)".
+    const maxAttempts = 20;
+    let lastErr = null;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        _db = new DatabaseSync(dbPath);
+        // busy_timeout MUST be set before any other PRAGMA so subsequent
+        // statements wait instead of failing immediately on contention.
+        _db.exec('PRAGMA busy_timeout = 5000');
+        _db.exec('PRAGMA journal_mode = WAL');
+        _db.exec('PRAGMA foreign_keys = ON');
+        _db.exec('PRAGMA synchronous = NORMAL');
+        _dbPath = dbPath;
+        lastErr = null;
+        break;
+      } catch (e) {
+        lastErr = e;
+        const msg = String(e && e.message || '');
+        const isBusy = /database is locked|SQLITE_BUSY|SQLITE_LOCKED/i.test(msg);
+        if (!isBusy || attempt === maxAttempts - 1) throw e;
+        if (_db) { try { _db.close(); } catch { /* best-effort */ } _db = null; }
+        // Synchronous backoff: 10ms, 20ms, 40ms... capped at 250ms.
+        // Total worst-case wait ~3s, still under the 5s busy_timeout.
+        const delayMs = Math.min(250, 10 * (1 << Math.min(attempt, 5)));
+        const end = Date.now() + delayMs;
+        while (Date.now() < end) { /* busy-wait — sub-300ms total */ }
+      }
+    }
+    if (lastErr) throw lastErr;
     const { runMigrations } = require('./migrate');
     runMigrations(_db);
     return _db;

package/engine/db/migrate.js

@@ -35,17 +35,24 @@ function runMigrations(db) {
     )
   `);
 
-  const currentRow = db.prepare('SELECT COALESCE(MAX(version), 0) AS v FROM schema_version').get();
-  const current = Number(currentRow.v) || 0;
   const migrations = _loadMigrations();
 
   for (const m of migrations) {
     if (typeof m.version !== 'number' || typeof m.up !== 'function') {
       throw new Error(`engine/db/migrate: migration missing { version, up }: ${JSON.stringify(Object.keys(m))}`);
     }
-    if (m.version <= current) continue;
-    db.exec('BEGIN');
+    // Concurrent-startup safety: take the SQLite write lock BEFORE re-reading
+    // schema_version. With plain `BEGIN` (deferred), two processes booting at
+    // the same time can both observe schema_version=N, both decide to apply
+    // N+1, and one then fails with "table already exists" while the other
+    // succeeds — leaving the loser stuck on `_dbInitError` for the lifetime
+    // of its process. `BEGIN IMMEDIATE` serializes the version check itself
+    // so the second arrival simply sees the updated schema_version and skips.
+    db.exec('BEGIN IMMEDIATE');
     try {
+      const currentRow = db.prepare('SELECT COALESCE(MAX(version), 0) AS v FROM schema_version').get();
+      const current = Number(currentRow.v) || 0;
+      if (m.version <= current) { db.exec('COMMIT'); continue; }
       // eslint-disable-next-line no-console
       console.log(`[db-migrate] Applying v${m.version}: ${m.description || '(no description)'}`);
       m.up(db, { fs, path });

package/engine/db/migrations/011-remaining-state.js

@@ -0,0 +1,116 @@
+// engine/db/migrations/011-remaining-state.js
+//
+// Phase 9.2: finish the JSON→SQL migration. Four remaining engine state
+// files move into their own tables; the JSON files are kept as dual-write
+// mirrors for back-compat.
+//
+//   engine/cooldowns.json        -> cooldowns
+//   engine/pending-rebases.json  -> pending_rebases
+//   engine/cc-sessions.json      -> cc_sessions
+//   engine/doc-sessions.json     -> doc_sessions
+
+const path = require('path');
+const fs = require('fs');
+
+function _resolveMinionsDir() {
+  const envHome = process.env.MINIONS_HOME || process.env.MINIONS_TEST_DIR;
+  if (envHome) return envHome;
+  try { return require('../../shared').MINIONS_DIR; } catch { return null; }
+}
+
+function _readJsonOr(filePath, fallback) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch { return fallback; }
+}
+
+module.exports = {
+  version: 11,
+  description: 'cooldowns + pending_rebases + cc_sessions + doc_sessions',
+  up(db) {
+    db.exec(`
+      CREATE TABLE cooldowns (
+        key         TEXT PRIMARY KEY,
+        data        TEXT NOT NULL,
+        updated_at  INTEGER NOT NULL
+      );
+
+      CREATE TABLE pending_rebases (
+        seq         INTEGER PRIMARY KEY AUTOINCREMENT,
+        data        TEXT NOT NULL,
+        updated_at  INTEGER NOT NULL
+      );
+
+      CREATE TABLE cc_sessions (
+        id          TEXT PRIMARY KEY,
+        data        TEXT NOT NULL,
+        updated_at  INTEGER NOT NULL
+      );
+
+      CREATE TABLE doc_sessions (
+        key         TEXT PRIMARY KEY,
+        data        TEXT NOT NULL,
+        updated_at  INTEGER NOT NULL
+      );
+    `);
+
+    const minionsDir = _resolveMinionsDir();
+    if (!minionsDir) return;
+    const now = Date.now();
+    let inserted = 0;
+
+    // ── cooldowns ──────────────────────────────────────────────────────────
+    {
+      const raw = _readJsonOr(path.join(minionsDir, 'engine', 'cooldowns.json'), null);
+      if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+        const ins = db.prepare(`INSERT INTO cooldowns (key, data, updated_at) VALUES (?, ?, ?)`);
+        for (const [k, v] of Object.entries(raw)) {
+          try { ins.run(String(k), JSON.stringify(v), now); inserted += 1; }
+          catch { /* duplicate / corrupt — skip */ }
+        }
+      }
+    }
+
+    // ── pending_rebases ────────────────────────────────────────────────────
+    {
+      const raw = _readJsonOr(path.join(minionsDir, 'engine', 'pending-rebases.json'), null);
+      if (Array.isArray(raw)) {
+        const ins = db.prepare(`INSERT INTO pending_rebases (data, updated_at) VALUES (?, ?)`);
+        for (const entry of raw) {
+          if (!entry || typeof entry !== 'object') continue;
+          try { ins.run(JSON.stringify(entry), now); inserted += 1; }
+          catch { /* corrupt — skip */ }
+        }
+      }
+    }
+
+    // ── cc_sessions ────────────────────────────────────────────────────────
+    {
+      const raw = _readJsonOr(path.join(minionsDir, 'engine', 'cc-sessions.json'), null);
+      if (Array.isArray(raw)) {
+        const ins = db.prepare(`INSERT INTO cc_sessions (id, data, updated_at) VALUES (?, ?, ?)`);
+        for (const entry of raw) {
+          if (!entry || typeof entry !== 'object' || !entry.id) continue;
+          try { ins.run(String(entry.id), JSON.stringify(entry), now); inserted += 1; }
+          catch { /* duplicate id — skip */ }
+        }
+      }
+    }
+
+    // ── doc_sessions ───────────────────────────────────────────────────────
+    {
+      const raw = _readJsonOr(path.join(minionsDir, 'engine', 'doc-sessions.json'), null);
+      if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+        const ins = db.prepare(`INSERT INTO doc_sessions (key, data, updated_at) VALUES (?, ?, ?)`);
+        for (const [k, v] of Object.entries(raw)) {
+          try { ins.run(String(k), JSON.stringify(v), now); inserted += 1; }
+          catch { /* duplicate / corrupt — skip */ }
+        }
+      }
+    }
+
+    // eslint-disable-next-line no-console
+    console.log(`[db-migrate] v11: backfilled ${inserted} small-state rows; JSON files kept as dual-write mirrors`);
+  },
+};

package/engine/dispatch-store.js

@@ -36,9 +36,7 @@ function _parseRow(row) {
 
 function readDispatchSectioned() {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch { return _readDispatchJsonFallback(); }  // SQLite unavailable
+  const db = getDb();
 
   // All rows, all statuses. Matches the legacy dispatch.json reader's
   // semantics — returns the complete dispatch state regardless of how old

package/engine/dispatch.js

@@ -10,11 +10,11 @@ const queries = require('./queries');
 const { setCooldown, setCooldownFailure } = require('./cooldown');
 const dispatchEvents = require('./dispatch-events');
 
-const { safeJsonArr, mutateJsonFileLocked, mutateWorkItems,
+const { safeJsonArr, mutateWorkItems,
   mutatePullRequests, getProjects, projectPrPath, log, ts, dateStamp,
   sidecarDispatchPrompt, deleteDispatchPromptSidecar,
   WI_STATUS, WORK_TYPE, DISPATCH_RESULT, ENGINE_DEFAULTS, AGENT_STATUS, FAILURE_CLASS, PR_STATUS } = shared;
-const { getConfig, DISPATCH_PATH, INBOX_DIR } = queries;
+const { getConfig, INBOX_DIR } = queries;
 
 const MINIONS_DIR = shared.MINIONS_DIR;
 
@@ -58,72 +58,37 @@ function _sidecarChangedPrompts(dispatch, prevSnap) {
   }
 }
 
-// SQL-backed mutator (Phase 1). Same external contract as the legacy
-// JSON path: mutator receives a `{ pending, active, completed, review }`
-// object, mutates in place (or returns a replacement), and the changes
-// land transactionally in the dispatches table. The diff-then-apply trick
-// in dispatch-store preserves every field via the `data` JSON column, so
-// new dispatch fields the engine adds in future commits don't need any
-// migration — they round-trip automatically.
-//
-// Fallback path: if SQLite is unavailable (Node < 22.5, the DB init failed,
-// the table doesn't exist yet because the migration hasn't run) we fall
-// back to the legacy mutateJsonFileLocked flow against dispatch.json.
-// The migration leaves dispatch.json.pre-sql-<ts> on disk, so an operator
-// pinning to an older release can rename it back.
+// SQL-backed mutator (Phase 9.4 SQL-only). mutator receives a
+// `{ pending, active, completed, review }` object, mutates in place
+// (or returns a replacement), and the changes land transactionally in
+// the dispatches table. The diff-then-apply trick in dispatch-store
+// preserves every field via the `data` JSON column, so new dispatch
+// fields the engine adds in future commits don't need any migration —
+// they round-trip automatically. SQLite failures propagate; the CLI
+// shim in bin/minions.js guarantees node:sqlite is loadable.
 function mutateDispatch(mutator) {
-  // Try the SQL path first.
-  try {
-    const store = require('./dispatch-store');
-    const { wrote, result } = store.applyDispatchMutation((dispatch) => {
-      dispatch.pending = Array.isArray(dispatch.pending) ? dispatch.pending : [];
-      dispatch.active = Array.isArray(dispatch.active) ? dispatch.active : [];
-      dispatch.completed = Array.isArray(dispatch.completed) ? dispatch.completed : [];
-      dispatch.review = Array.isArray(dispatch.review) ? dispatch.review : [];
-      const prevSnap = _snapshotPrompts(dispatch);
-      const next = mutator(dispatch) ?? dispatch;
-      // Prompt-size guard: only scan items whose prompt changed (or new items),
-      // so a 100-item status-flip doesn't re-byte-count every prompt.
-      _sidecarChangedPrompts(next, prevSnap);
-      return next;
-    });
-    if (wrote) {
-      try { require('./queries').invalidateDispatchCache(); } catch {}
-      try { require('./db-events').emitStateEvent('dispatch'); } catch { /* optional */ }
-      // Mirror back to dispatch.json for tests + tools that fs.readFileSync
-      // the file directly. SQL is the source of truth; the JSON file is
-      // regenerated from SQL on every successful mutation, never independently
-      // mutated. Cheap to delete once those direct-JSON readers are gone.
-      try { store._mirrorJsonFromSql(); } catch { /* best-effort */ }
-    }
-    return result;
-  } catch (e) {
-    // Only fall back if the failure looks like a "DB not available" case,
-    // not a programming error. Surface mutator exceptions to the caller.
-    if (e && /SQLite unavailable|no such table|node:sqlite/.test(String(e.message))) {
-      // fall through to legacy JSON path below
-    } else {
-      throw e;
-    }
-  }
-
-  // Legacy JSON path (pre-Phase 1 fallback). Same code as before.
-  const defaultDispatch = { pending: [], active: [], completed: [] };
-  const result = mutateJsonFileLocked(DISPATCH_PATH, (dispatch) => {
+  const store = require('./dispatch-store');
+  const { wrote, result } = store.applyDispatchMutation((dispatch) => {
     dispatch.pending = Array.isArray(dispatch.pending) ? dispatch.pending : [];
     dispatch.active = Array.isArray(dispatch.active) ? dispatch.active : [];
     dispatch.completed = Array.isArray(dispatch.completed) ? dispatch.completed : [];
+    dispatch.review = Array.isArray(dispatch.review) ? dispatch.review : [];
     const prevSnap = _snapshotPrompts(dispatch);
     const next = mutator(dispatch) ?? dispatch;
+    // Prompt-size guard: only scan items whose prompt changed (or new items),
+    // so a 100-item status-flip doesn't re-byte-count every prompt.
     _sidecarChangedPrompts(next, prevSnap);
     return next;
-  }, {
-    defaultValue: defaultDispatch,
-    onWrote: () => {
-      try { require('./db-events').emitStateEvent('dispatch'); } catch { /* optional */ }
-    },
   });
-  try { require('./queries').invalidateDispatchCache(); } catch {}
+  if (wrote) {
+    try { require('./queries').invalidateDispatchCache(); } catch {}
+    try { require('./db-events').emitStateEvent('dispatch'); } catch { /* optional */ }
+    // Mirror back to dispatch.json for tests + tools that fs.readFileSync
+    // the file directly. SQL is the source of truth; the JSON file is
+    // regenerated from SQL on every successful mutation, never independently
+    // mutated. Cheap to delete once those direct-JSON readers are gone.
+    try { store._mirrorJsonFromSql(); } catch { /* best-effort */ }
+  }
   return result;
 }
 

package/engine/kb-sweep.js

@@ -288,8 +288,10 @@ function _writeSweepState(state) {
   // can distinguish "still running" from "runner crashed". When this module is
   // imported by the detached runner, process.pid is the runner's pid — which
   // is exactly what we want.
+  // Phase 9.3: route through shared.mutateKbSweepState (file-locked RMW) so
+  // the dashboard process + the detached runner can't race each other.
   const augmented = { pid: process.pid, ...state };
-  try { safeWrite(KB_SWEEP_STATE_PATH, JSON.stringify(augmented)); } catch { /* ignore */ }
+  try { shared.mutateKbSweepState(() => augmented); } catch { /* ignore */ }
 }
 
 /**
@@ -416,10 +418,10 @@ function reconcileSweepStateOnBoot(opts = {}) {
     error: `sweep abandoned: ${reason}`,
     reconciliationReason: reason,
   };
-  // Direct safeWrite (NOT _writeSweepState) so the original pid is preserved
-  // for forensics — _writeSweepState would overwrite it with this process's
-  // pid, destroying the diagnostic value of the record.
-  try { safeWrite(KB_SWEEP_STATE_PATH, JSON.stringify(failedState)); } catch { /* ignore */ }
+  // Direct mutateKbSweepState (NOT _writeSweepState) so the original pid is
+  // preserved for forensics — _writeSweepState would overwrite it with this
+  // process's pid, destroying the diagnostic value of the record.
+  try { shared.mutateKbSweepState(() => failedState); } catch { /* ignore */ }
   return {
     scanned: 1, released: 1, reason,
     prevStatus: state.status, prevPid: pid,
@@ -551,7 +553,7 @@ async function _runKbSweepImpl(opts = {}) {
   summary.summary = `${summary.hashDuplicatesArchived} hash-dup, ${summary.llmDuplicatesArchived} llm-dup, ${summary.staleRemoved} stale, ${summary.reclassified} reclassified, ${summary.rewritten} rewritten (${(summary.bytesBefore - summary.bytesAfter).toLocaleString()} bytes saved)`;
 
   if (!opts.dryRun) {
-    try { safeWrite(path.join(ENGINE_DIR, 'kb-swept.json'), JSON.stringify({ timestamp: ts(), summary: summary.summary, detail: summary })); } catch { /* ignore */ }
+    try { shared.mutateKbSwept(() => ({ timestamp: ts(), summary: summary.summary, detail: summary })); } catch { /* ignore */ }
     try { queries.invalidateKnowledgeBaseCache(); } catch { /* ignore */ }
   }
   return summary;
@@ -587,7 +589,7 @@ function spawnSweepRunnerDetached(opts = {}) {
   const sweepToken = `${startedAt}-${Math.random().toString(36).slice(2, 8)}`;
 
   try {
-    safeWrite(KB_SWEEP_STATE_PATH, JSON.stringify({
+    shared.mutateKbSweepState(() => ({
       status: 'starting', startedAt, startedAtIso: new Date().toISOString(),
       sweepToken, pid: null,
     }));
@@ -637,14 +639,18 @@ function spawnSweepRunnerDetached(opts = {}) {
   }
   if (logFdNum != null) try { fsLocal.closeSync(logFdNum); } catch { /* ignore */ }
 
+  // Phase 9.3: atomic starting→in-flight transition under the file lock
+  // (was previously a safeJson→safeWrite race).
   try {
-    const current = safeJson(KB_SWEEP_STATE_PATH);
-    if (current && current.status === 'starting' && current.sweepToken === sweepToken) {
-      safeWrite(KB_SWEEP_STATE_PATH, JSON.stringify({
-        status: 'in-flight', startedAt, startedAtIso: new Date().toISOString(),
-        sweepToken, pid: proc.pid,
-      }));
-    }
+    shared.mutateKbSweepState((current) => {
+      if (current && current.status === 'starting' && current.sweepToken === sweepToken) {
+        return {
+          status: 'in-flight', startedAt, startedAtIso: new Date().toISOString(),
+          sweepToken, pid: proc.pid,
+        };
+      }
+      return undefined; // unchanged → skipWriteIfUnchanged suppresses the write
+    });
   } catch { /* best-effort */ }
 
   proc.unref();

package/engine/pull-requests-store.js

@@ -123,9 +123,7 @@ function _resyncScopeIfJsonDiverged(db, scope) {
 
 function readPullRequestsForScope(scope) {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch { return _readJsonArrayFallback(scope); }
+  const db = getDb();
 
   _resyncScopeIfJsonDiverged(db, scope);
 
@@ -170,23 +168,7 @@ function _enumerateJsonScopes() {
 
 function readAllPullRequests() {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch {
-    // Issue #3035: SQLite unavailable (Node 22.x without
-    // --experimental-sqlite) — read every JSON scope on disk so the
-    // aggregate readers (queries.getPullRequests, shared.getPrLinks)
-    // continue to return real data instead of [].
-    const out = [];
-    for (const scope of _enumerateJsonScopes()) {
-      for (const pr of _readJsonArrayFallback(scope)) {
-        if (!pr || typeof pr !== 'object') continue;
-        pr._scope = scope;
-        out.push(pr);
-      }
-    }
-    return out;
-  }
+  const db = getDb();
 
   try { _resyncScopeIfJsonDiverged(db, 'central'); } catch {}
   const knownScopes = db.prepare('SELECT DISTINCT scope FROM pull_requests').all().map(r => r.scope);
@@ -273,11 +255,7 @@ function _applyPullRequestsDiff(db, diff) {
 
 function applyPullRequestsMutation(scope, mutator) {
   const { getDb, withTransaction } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch (e) {
-    throw new Error(`engine/pull-requests-store: SQLite unavailable (${e.message}); cannot mutate pull_requests`);
-  }
+  const db = getDb();
 
   return withTransaction(db, () => {
     _resyncScopeIfJsonDiverged(db, scope);