@yemi33/minions 0.1.2115 → 0.1.2117

package/engine/small-state-store.js

@@ -94,9 +94,7 @@ function _readScheduleRunsFromSql(db) {
 
 function readScheduleRuns() {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch { return _readJson(_resolveFilePath('schedule-runs.json')) || {}; }
+  const db = getDb();
   _resyncScheduleRunsIfDiverged(db);
   const out = _readScheduleRunsFromSql(db);
   if (Object.keys(out).length === 0) {
@@ -207,9 +205,7 @@ function _readPipelineRunsFromSql(db) {
 
 function readPipelineRuns() {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch { return _readJson(_resolveFilePath('pipeline-runs.json')) || {}; }
+  const db = getDb();
   _resyncPipelineRunsIfDiverged(db);
   const out = _readPipelineRunsFromSql(db);
   if (Object.keys(out).length === 0) {
@@ -329,9 +325,7 @@ function _readManagedProcessesFromSql(db) {
 
 function readManagedProcesses() {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch { return _readJson(_resolveFilePath('managed-processes.json')) || { specs: [] }; }
+  const db = getDb();
   _resyncManagedProcessesIfDiverged(db);
   const out = _readManagedProcessesFromSql(db);
   if (out.specs.length === 0) {
@@ -449,9 +443,7 @@ function _readWorktreePoolFromSql(db) {
 
 function readWorktreePool() {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch { return _readJson(_resolveFilePath('worktree-pool.json')) || { entries: [] }; }
+  const db = getDb();
   _resyncWorktreePoolIfDiverged(db);
   const out = _readWorktreePoolFromSql(db);
   if (out.entries.length === 0) {
@@ -581,9 +573,7 @@ function _readQaRunsFromSqlOnly(db) {
 
 function readQaRuns() {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch { return _readJson(_resolveFilePath('qa-runs.json')) || []; }
+  const db = getDb();
   _resyncQaRunsIfDiverged(db);
   const out = _readQaRunsFromSqlOnly(db);
   if (out.length === 0) {
@@ -741,9 +731,7 @@ function _readQaSessionsFromSqlOnly(db) {
 
 function readQaSessions() {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch { return _readJson(_resolveFilePath('qa-sessions.json')) || []; }
+  const db = getDb();
   _resyncQaSessionsIfDiverged(db);
   const out = _readQaSessionsFromSqlOnly(db);
   if (out.length === 0) {
@@ -875,9 +863,7 @@ function _readPrLinksFromSql(db) {
 
 function readPrLinks() {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch { return _readJson(_resolveFilePath('pr-links.json')) || {}; }
+  const db = getDb();
   try { _resyncPrLinksIfDiverged(db); }
   catch { /* table may be missing on a stale install — fall back to JSON */ }
   let out;
@@ -941,6 +927,430 @@ function _mirrorPrLinksJson(filePath) {
   } catch { /* mirror best-effort */ }
 }
 
+// ─── cooldowns ─────────────────────────────────────────────────────────────
+// Shape: { [key]: { timestamp, failures, ... } }
+// SQL:   row per key.
+
+let _cooldownsHash = null;
+
+function _hydrateCooldowns(db) {
+  const fp = _resolveFilePath('cooldowns.json');
+  const raw = _readJson(fp) || {};
+  db.prepare('DELETE FROM cooldowns').run();
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return;
+  const now = Date.now();
+  const ins = db.prepare('INSERT INTO cooldowns (key, data, updated_at) VALUES (?, ?, ?) ON CONFLICT(key) DO NOTHING');
+  for (const [key, value] of Object.entries(raw)) {
+    ins.run(String(key), JSON.stringify(value), now);
+  }
+}
+
+function _resyncCooldownsIfDiverged(db) {
+  const fp = _resolveFilePath('cooldowns.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_cooldownsHash != null && currentHash === _cooldownsHash) return;
+  if (_cooldownsHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM cooldowns LIMIT 1').get();
+    if (sqlHas) { _cooldownsHash = currentHash; return; }
+  }
+  _hydrateCooldowns(db);
+  _cooldownsHash = currentHash;
+}
+
+function _readCooldownsFromSql(db) {
+  const rows = db.prepare('SELECT key, data FROM cooldowns').all();
+  const out = {};
+  for (const row of rows) {
+    try { out[row.key] = JSON.parse(row.data); }
+    catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+function readCooldowns() {
+  const { getDb } = require('./db');
+  const db = getDb();
+  try { _resyncCooldownsIfDiverged(db); }
+  catch { /* table may be missing on stale install */ }
+  let out;
+  try { out = _readCooldownsFromSql(db); }
+  catch { return _readJson(_resolveFilePath('cooldowns.json')) || {}; }
+  if (Object.keys(out).length === 0) {
+    const fallback = _readJson(_resolveFilePath('cooldowns.json'));
+    if (fallback && Object.keys(fallback).length > 0) return fallback;
+    return {};
+  }
+  return out;
+}
+
+function applyCooldownsMutation(mutator) {
+  const { getDb, withTransaction } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`small-state-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    _resyncCooldownsIfDiverged(db);
+    const before = _readCooldownsFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+    if (!after || typeof after !== 'object' || Array.isArray(after)) {
+      return { wrote: false, result: beforeSnap };
+    }
+    const afterIds = new Set(Object.keys(after));
+    const beforeIds = new Set(Object.keys(beforeSnap));
+    let wrote = false;
+    const now = Date.now();
+    const upsert = db.prepare(`
+      INSERT INTO cooldowns (key, data, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(key) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM cooldowns WHERE key = ?');
+    for (const id of afterIds) {
+      if (!beforeIds.has(id) || JSON.stringify(beforeSnap[id]) !== JSON.stringify(after[id])) {
+        upsert.run(id, JSON.stringify(after[id]), now);
+        wrote = true;
+      }
+    }
+    for (const id of beforeIds) {
+      if (!afterIds.has(id)) { del.run(id); wrote = true; }
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorCooldownsJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const obj = _readCooldownsFromSql(getDb());
+    const target = filePath || _resolveFilePath('cooldowns.json');
+    shared.safeWrite(target, obj);
+    const h = _fileContentHash(target);
+    if (h != null) _cooldownsHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
+// ─── pending_rebases ───────────────────────────────────────────────────────
+// Shape: [ { prId, branch, projectName, mergedItemId, queuedAt, attempts, ... }, ... ]
+// SQL:   row per array entry (rowid auto-increment preserves insertion order).
+//        No stable natural key, so mutations are full clear+insert.
+
+let _pendingRebasesHash = null;
+
+function _hydratePendingRebases(db) {
+  const fp = _resolveFilePath('pending-rebases.json');
+  const raw = _readJson(fp) || [];
+  db.prepare('DELETE FROM pending_rebases').run();
+  if (!Array.isArray(raw)) return;
+  const now = Date.now();
+  const ins = db.prepare('INSERT INTO pending_rebases (data, updated_at) VALUES (?, ?)');
+  for (const entry of raw) {
+    if (!entry || typeof entry !== 'object') continue;
+    ins.run(JSON.stringify(entry), now);
+  }
+}
+
+function _resyncPendingRebasesIfDiverged(db) {
+  const fp = _resolveFilePath('pending-rebases.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_pendingRebasesHash != null && currentHash === _pendingRebasesHash) return;
+  if (_pendingRebasesHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM pending_rebases LIMIT 1').get();
+    if (sqlHas) { _pendingRebasesHash = currentHash; return; }
+  }
+  _hydratePendingRebases(db);
+  _pendingRebasesHash = currentHash;
+}
+
+function _readPendingRebasesFromSql(db) {
+  const rows = db.prepare('SELECT data FROM pending_rebases ORDER BY seq').all();
+  const out = [];
+  for (const row of rows) {
+    try { out.push(JSON.parse(row.data)); }
+    catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+function readPendingRebases() {
+  const { getDb } = require('./db');
+  const db = getDb();
+  try { _resyncPendingRebasesIfDiverged(db); }
+  catch { /* table missing */ }
+  let out;
+  try { out = _readPendingRebasesFromSql(db); }
+  catch { return _readJson(_resolveFilePath('pending-rebases.json')) || []; }
+  if (out.length === 0) {
+    const fallback = _readJson(_resolveFilePath('pending-rebases.json'));
+    if (Array.isArray(fallback) && fallback.length > 0) return fallback;
+    return [];
+  }
+  return out;
+}
+
+function applyPendingRebasesMutation(mutator) {
+  const { getDb, withTransaction } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`small-state-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    _resyncPendingRebasesIfDiverged(db);
+    const before = _readPendingRebasesFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+    if (!Array.isArray(after)) {
+      return { wrote: false, result: beforeSnap };
+    }
+    let wrote = false;
+    if (JSON.stringify(before) !== JSON.stringify(after)) {
+      const now = Date.now();
+      db.prepare('DELETE FROM pending_rebases').run();
+      const ins = db.prepare('INSERT INTO pending_rebases (data, updated_at) VALUES (?, ?)');
+      for (const entry of after) {
+        if (!entry || typeof entry !== 'object') continue;
+        ins.run(JSON.stringify(entry), now);
+      }
+      wrote = true;
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorPendingRebasesJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const arr = _readPendingRebasesFromSql(getDb());
+    const target = filePath || _resolveFilePath('pending-rebases.json');
+    shared.safeWrite(target, arr);
+    const h = _fileContentHash(target);
+    if (h != null) _pendingRebasesHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
+// ─── cc_sessions ───────────────────────────────────────────────────────────
+// Shape: [ { id, sessionId, title, _promptHash, lastActiveAt, ... }, ... ]
+// SQL:   row per id (each entry has a unique `id` tab key).
+
+let _ccSessionsHash = null;
+
+function _hydrateCcSessions(db) {
+  const fp = _resolveFilePath('cc-sessions.json');
+  const raw = _readJson(fp) || [];
+  db.prepare('DELETE FROM cc_sessions').run();
+  if (!Array.isArray(raw)) return;
+  const now = Date.now();
+  const ins = db.prepare('INSERT INTO cc_sessions (id, data, updated_at) VALUES (?, ?, ?) ON CONFLICT(id) DO NOTHING');
+  for (const entry of raw) {
+    if (!entry || typeof entry !== 'object' || !entry.id) continue;
+    ins.run(String(entry.id), JSON.stringify(entry), now);
+  }
+}
+
+function _resyncCcSessionsIfDiverged(db) {
+  const fp = _resolveFilePath('cc-sessions.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_ccSessionsHash != null && currentHash === _ccSessionsHash) return;
+  if (_ccSessionsHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM cc_sessions LIMIT 1').get();
+    if (sqlHas) { _ccSessionsHash = currentHash; return; }
+  }
+  _hydrateCcSessions(db);
+  _ccSessionsHash = currentHash;
+}
+
+function _readCcSessionsFromSql(db) {
+  const rows = db.prepare('SELECT data FROM cc_sessions ORDER BY updated_at, id').all();
+  const out = [];
+  for (const row of rows) {
+    try { out.push(JSON.parse(row.data)); }
+    catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+function readCcSessions() {
+  const { getDb } = require('./db');
+  const db = getDb();
+  try { _resyncCcSessionsIfDiverged(db); }
+  catch { /* table missing */ }
+  let out;
+  try { out = _readCcSessionsFromSql(db); }
+  catch { return _readJson(_resolveFilePath('cc-sessions.json')) || []; }
+  if (out.length === 0) {
+    const fallback = _readJson(_resolveFilePath('cc-sessions.json'));
+    if (Array.isArray(fallback) && fallback.length > 0) return fallback;
+    return [];
+  }
+  return out;
+}
+
+function applyCcSessionsMutation(mutator) {
+  const { getDb, withTransaction } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`small-state-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    _resyncCcSessionsIfDiverged(db);
+    const before = _readCcSessionsFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+    if (!Array.isArray(after)) {
+      return { wrote: false, result: beforeSnap };
+    }
+    const beforeById = new Map(beforeSnap.filter(e => e && e.id).map(e => [String(e.id), e]));
+    const afterById = new Map(after.filter(e => e && e.id).map(e => [String(e.id), e]));
+    let wrote = false;
+    const now = Date.now();
+    const upsert = db.prepare(`
+      INSERT INTO cc_sessions (id, data, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM cc_sessions WHERE id = ?');
+    for (const [id, entry] of afterById) {
+      const prior = beforeById.get(id);
+      if (!prior || JSON.stringify(prior) !== JSON.stringify(entry)) {
+        upsert.run(id, JSON.stringify(entry), now);
+        wrote = true;
+      }
+    }
+    for (const id of beforeById.keys()) {
+      if (!afterById.has(id)) { del.run(id); wrote = true; }
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorCcSessionsJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const arr = _readCcSessionsFromSql(getDb());
+    const target = filePath || _resolveFilePath('cc-sessions.json');
+    shared.safeWrite(target, arr);
+    const h = _fileContentHash(target);
+    if (h != null) _ccSessionsHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
+// ─── doc_sessions ──────────────────────────────────────────────────────────
+// Shape: { [filePath]: { sessionId, lastActiveAt, turnCount, ... } }
+// SQL:   row per filePath key.
+
+let _docSessionsHash = null;
+
+function _hydrateDocSessions(db) {
+  const fp = _resolveFilePath('doc-sessions.json');
+  const raw = _readJson(fp) || {};
+  db.prepare('DELETE FROM doc_sessions').run();
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return;
+  const now = Date.now();
+  const ins = db.prepare('INSERT INTO doc_sessions (key, data, updated_at) VALUES (?, ?, ?) ON CONFLICT(key) DO NOTHING');
+  for (const [key, value] of Object.entries(raw)) {
+    ins.run(String(key), JSON.stringify(value), now);
+  }
+}
+
+function _resyncDocSessionsIfDiverged(db) {
+  const fp = _resolveFilePath('doc-sessions.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_docSessionsHash != null && currentHash === _docSessionsHash) return;
+  if (_docSessionsHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM doc_sessions LIMIT 1').get();
+    if (sqlHas) { _docSessionsHash = currentHash; return; }
+  }
+  _hydrateDocSessions(db);
+  _docSessionsHash = currentHash;
+}
+
+function _readDocSessionsFromSql(db) {
+  const rows = db.prepare('SELECT key, data FROM doc_sessions').all();
+  const out = {};
+  for (const row of rows) {
+    try { out[row.key] = JSON.parse(row.data); }
+    catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+function readDocSessions() {
+  const { getDb } = require('./db');
+  const db = getDb();
+  try { _resyncDocSessionsIfDiverged(db); }
+  catch { /* table missing */ }
+  let out;
+  try { out = _readDocSessionsFromSql(db); }
+  catch { return _readJson(_resolveFilePath('doc-sessions.json')) || {}; }
+  if (Object.keys(out).length === 0) {
+    const fallback = _readJson(_resolveFilePath('doc-sessions.json'));
+    if (fallback && Object.keys(fallback).length > 0) return fallback;
+    return {};
+  }
+  return out;
+}
+
+function applyDocSessionsMutation(mutator) {
+  const { getDb, withTransaction } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`small-state-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    _resyncDocSessionsIfDiverged(db);
+    const before = _readDocSessionsFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+    if (!after || typeof after !== 'object' || Array.isArray(after)) {
+      return { wrote: false, result: beforeSnap };
+    }
+    const afterIds = new Set(Object.keys(after));
+    const beforeIds = new Set(Object.keys(beforeSnap));
+    let wrote = false;
+    const now = Date.now();
+    const upsert = db.prepare(`
+      INSERT INTO doc_sessions (key, data, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(key) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM doc_sessions WHERE key = ?');
+    for (const id of afterIds) {
+      if (!beforeIds.has(id) || JSON.stringify(beforeSnap[id]) !== JSON.stringify(after[id])) {
+        upsert.run(id, JSON.stringify(after[id]), now);
+        wrote = true;
+      }
+    }
+    for (const id of beforeIds) {
+      if (!afterIds.has(id)) { del.run(id); wrote = true; }
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorDocSessionsJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const obj = _readDocSessionsFromSql(getDb());
+    const target = filePath || _resolveFilePath('doc-sessions.json');
+    shared.safeWrite(target, obj);
+    const h = _fileContentHash(target);
+    if (h != null) _docSessionsHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
 // ─── Test seam ─────────────────────────────────────────────────────────────
 
 function _resetAllForTest() {
@@ -954,6 +1364,10 @@ function _resetAllForTest() {
     try { db.exec('DELETE FROM qa_runs'); } catch { /* migration not applied */ }
     try { db.exec('DELETE FROM qa_sessions'); } catch { /* migration not applied */ }
     try { db.exec('DELETE FROM pr_links'); } catch { /* migration not applied */ }
+    try { db.exec('DELETE FROM cooldowns'); } catch { /* migration not applied */ }
+    try { db.exec('DELETE FROM pending_rebases'); } catch { /* migration not applied */ }
+    try { db.exec('DELETE FROM cc_sessions'); } catch { /* migration not applied */ }
+    try { db.exec('DELETE FROM doc_sessions'); } catch { /* migration not applied */ }
   } catch { /* not initialized */ }
   _scheduleRunsHash = null;
   _pipelineRunsHash = null;
@@ -962,6 +1376,10 @@ function _resetAllForTest() {
   _qaRunsHash = null;
   _qaSessionsHash = null;
   _prLinksHash = null;
+  _cooldownsHash = null;
+  _pendingRebasesHash = null;
+  _ccSessionsHash = null;
+  _docSessionsHash = null;
 }
 
 module.exports = {
@@ -993,6 +1411,22 @@ module.exports = {
   readPrLinks,
   applyPrLinksMutation,
   _mirrorPrLinksJson,
+  // cooldowns
+  readCooldowns,
+  applyCooldownsMutation,
+  _mirrorCooldownsJson,
+  // pending_rebases
+  readPendingRebases,
+  applyPendingRebasesMutation,
+  _mirrorPendingRebasesJson,
+  // cc_sessions
+  readCcSessions,
+  applyCcSessionsMutation,
+  _mirrorCcSessionsJson,
+  // doc_sessions
+  readDocSessions,
+  applyDocSessionsMutation,
+  _mirrorDocSessionsJson,
   // test seam
   _resetAllForTest,
 };

package/engine/work-items-store.js

@@ -75,9 +75,7 @@ function _readJsonArrayFallback(scope) {
 
 function readWorkItemsForScope(scope) {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch { return _readJsonArrayFallback(scope); }
+  const db = getDb();
 
   _resyncScopeIfJsonDiverged(db, scope);
 
@@ -88,10 +86,9 @@ function readWorkItemsForScope(scope) {
   `).all(scope);
 
   if (rows.length === 0) {
-    // Same fallback shape as dispatch-store: SQL empty AND JSON has
-    // content means a test seeded via fs.writeFileSync (legacy helper)
-    // or a fresh install pre-migration. Returning the JSON keeps those
-    // call sites working without touching every helper.
+    // SQL empty AND JSON has content means a test seeded via fs.writeFileSync
+    // (legacy helper) or a fresh install pre-migration. Returning the JSON
+    // keeps those call sites working without touching every helper.
     const fallback = _readJsonArrayFallback(scope);
     if (fallback.length > 0) return fallback;
     return [];
@@ -161,29 +158,9 @@ function _enumerateJsonScopes() {
 // Read all rows across all scopes — used by queries.getWorkItems which
 // needs to surface central + every project's items in a single shot,
 // tagged with their source scope.
-//
-// Issue #3035: SQL-unavailable installs (Node 22.x without
-// --experimental-sqlite, prior to v0.1.2113) returned [] from this path
-// because `getDb()` throws and the legacy `return null` signal was
-// swallowed by `queries.getWorkItems`'s `|| []`. Mirror the per-scope
-// reader's JSON-fallback shape so the aggregate API stays useful on
-// Node versions that don't have node:sqlite enabled.
 function readAllWorkItems() {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch {
-    // SQLite unavailable — read every JSON scope on disk directly.
-    const out = [];
-    for (const scope of _enumerateJsonScopes()) {
-      for (const wi of _readJsonArrayFallback(scope)) {
-        if (!wi || typeof wi !== 'object') continue;
-        wi._source = scope;
-        out.push(wi);
-      }
-    }
-    return out;
-  }
+  const db = getDb();
 
   // Pick up any external JSON edits for every scope SQL knows about.
   // Also resync 'central' explicitly so first-time reads on a JSON-only
@@ -326,11 +303,7 @@ function _hydrateScopeFromJson(db, scope) {
 
 function applyWorkItemsMutation(scope, mutator) {
   const { getDb, withTransaction } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch (e) {
-    throw new Error(`engine/work-items-store: SQLite unavailable (${e.message}); cannot mutate work_items`);
-  }
+  const db = getDb();
 
   return withTransaction(db, () => {
     // Re-hydrate SQL from JSON if the file was touched outside the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2115",
+  "version": "0.1.2117",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"