@yemi33/minions 0.1.2113 → 0.1.2115

package/bin/minions.js

@@ -231,6 +231,27 @@ function _openStdioLog(name) {
   return shared.openAppendLogFd(name, dir, { fallback: 'ignore' }).fd;
 }
 
+/**
+ * Node flag args required for SQLite to load. On Node 22.x, `node:sqlite`
+ * is gated behind `--experimental-sqlite`; on Node 24+ it is unflagged.
+ * Issue #3035: without this, every engine/dashboard/supervisor spawn on
+ * Node 22.x loses the SQL store and falls back to the JSON path —
+ * /api/work-items returns [] from the aggregate reader because the
+ * Phase-9-canonical SQL path is unreachable.
+ *
+ * Honors NODE_OPTIONS / MINIONS_FORCE_JSON: if the caller already has the
+ * flag set (via NODE_OPTIONS) or has opted out of SQL entirely
+ * (MINIONS_FORCE_JSON=1), we add nothing — the child inherits the env.
+ */
+function _sqliteSpawnFlags() {
+  if (process.env.MINIONS_FORCE_JSON === '1') return [];
+  const major = parseInt(String(process.versions.node).split('.')[0], 10);
+  if (!Number.isFinite(major) || major < 22 || major >= 24) return [];
+  const nodeOpts = String(process.env.NODE_OPTIONS || '');
+  if (nodeOpts.includes('--experimental-sqlite')) return [];
+  return ['--experimental-sqlite'];
+}
+
 /** Spawn a detached dashboard with self-open suppressed — the CLI decides
  *  when to open a browser based on whether a real tab reconnects post-health.
  *  stdout/stderr land in engine/dashboard-stdio.log so silent startup crashes
@@ -239,7 +260,7 @@ function spawnDashboard() {
   const env = { ...process.env, MINIONS_NO_AUTO_OPEN: '1' };
   const out = _openStdioLog('dashboard-stdio.log');
   const err = _openStdioLog('dashboard-stdio.log');
-  const proc = spawn(process.execPath, [path.join(MINIONS_HOME, 'dashboard.js')], {
+  const proc = spawn(process.execPath, [..._sqliteSpawnFlags(), path.join(MINIONS_HOME, 'dashboard.js')], {
     cwd: MINIONS_HOME, stdio: ['ignore', out, err], detached: true, windowsHide: true, env
   });
   proc.unref();
@@ -255,7 +276,7 @@ function spawnDashboard() {
 function spawnSupervisor() {
   const out = _openStdioLog('supervisor-stdio.log');
   const err = _openStdioLog('supervisor-stdio.log');
-  const proc = spawn(process.execPath, [path.join(MINIONS_HOME, 'engine', 'supervisor.js')], {
+  const proc = spawn(process.execPath, [..._sqliteSpawnFlags(), path.join(MINIONS_HOME, 'engine', 'supervisor.js')], {
     cwd: MINIONS_HOME, stdio: ['ignore', out, err], detached: true, windowsHide: true,
   });
   proc.unref();
@@ -277,7 +298,7 @@ const _supervisorPidPath = () => path.join(MINIONS_HOME, 'engine', 'supervisor.p
 function spawnFullStackAndVerify({ rest, forceOpen, dashWasUp, restartStartMs }) {
   const engineOut = _openStdioLog('engine-stdio.log');
   const engineErr = _openStdioLog('engine-stdio.log');
-  const engineProc = spawn(process.execPath, [path.join(MINIONS_HOME, 'engine.js'), 'start', ...rest], {
+  const engineProc = spawn(process.execPath, [..._sqliteSpawnFlags(), path.join(MINIONS_HOME, 'engine.js'), 'start', ...rest], {
     cwd: MINIONS_HOME, stdio: ['ignore', engineOut, engineErr], detached: true, windowsHide: true
   });
   engineProc.unref();
@@ -631,7 +652,7 @@ function init() {
   console.log(isUpgrade
     ? `\n  Upgrade complete (${pkgVersion}). Restarting engine and dashboard...\n`
     : '\n  Starting engine and dashboard...\n');
-  const engineProc = spawn(process.execPath, [path.join(MINIONS_HOME, 'engine.js'), 'start'], {
+  const engineProc = spawn(process.execPath, [..._sqliteSpawnFlags(), path.join(MINIONS_HOME, 'engine.js'), 'start'], {
     cwd: MINIONS_HOME, stdio: 'ignore', detached: true, windowsHide: true
   });
   engineProc.unref();
@@ -840,7 +861,7 @@ function ensureInstalled() {
 
 function delegate(script, args) {
   ensureInstalled();
-  const child = spawn(process.execPath, [path.join(MINIONS_HOME, script), ...args], {
+  const child = spawn(process.execPath, [..._sqliteSpawnFlags(), path.join(MINIONS_HOME, script), ...args], {
     stdio: 'inherit',
     cwd: MINIONS_HOME,
     env: { ...process.env, MINIONS_HOME },

package/engine/db/index.js

@@ -54,6 +54,14 @@ function _installExperimentalWarningFilter() {
 }
 
 function getDb() {
+  // Hard opt-out (issue #3035, option #3): MINIONS_FORCE_JSON=1 makes
+  // every getDb() call throw, forcing the entire stack onto the JSON
+  // fallback path. Useful for users who can't enable
+  // --experimental-sqlite on Node 22.x and for regression tests that
+  // need to exercise the JSON-fallback branches deterministically.
+  if (process.env.MINIONS_FORCE_JSON === '1') {
+    throw new Error('engine/db: SQL disabled via MINIONS_FORCE_JSON=1');
+  }
   // Re-resolve the DB path on every call so tests that swap MINIONS_TEST_DIR
   // (or production-side configuration that changes MINIONS_HOME between
   // operations) get a fresh connection to the new location instead of
@@ -94,10 +102,11 @@ function getDb() {
     runMigrations(_db);
     return _db;
   } catch (e) {
-    _dbInitError = new Error(
-      `engine/db: failed to open SQLite — ${e.message}. ` +
-      `Node 22.5+ required for built-in 'node:sqlite' support.`
-    );
+    const nodeMajor = parseInt(String(process.versions.node).split('.')[0], 10);
+    const flagHint = nodeMajor === 22
+      ? ` On Node 22.x, node:sqlite is gated behind --experimental-sqlite. Restart with NODE_OPTIONS=--experimental-sqlite, upgrade to Node 24+, or set MINIONS_FORCE_JSON=1 to bypass SQL.`
+      : ` Node 22.5+ (with --experimental-sqlite on 22.x) or 24+ required for built-in 'node:sqlite' support.`;
+    _dbInitError = new Error(`engine/db: failed to open SQLite — ${e.message}.${flagHint}`);
     throw _dbInitError;
   }
 }

package/engine/db/migrations/010-pr-links.js

@@ -0,0 +1,61 @@
+// engine/db/migrations/010-pr-links.js
+//
+// Phase 9.1: move `engine/pr-links.json` into SQL.
+//
+// pr-links.json is the *fallback* PR → work-item linkage store. The
+// primary source is `pull_requests.prdItems[]` (managed via the
+// pull-requests-store). Stray PR IDs that aren't covered by a project
+// pull-requests record still need to be discoverable — that's what this
+// table holds.
+//
+// Shape: { [prId]: <value> } where <value> is typically an array of item IDs
+// but may also be a bare string from legacy writes. Readers normalize.
+
+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: 10,
+  description: 'pr_links: schema + pr-links.json backfill (fallback static store)',
+  up(db) {
+    db.exec(`
+      CREATE TABLE pr_links (
+        pr_id      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;
+
+    const raw = _readJsonOr(path.join(minionsDir, 'engine', 'pr-links.json'), null);
+    if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+      const ins = db.prepare(`INSERT INTO pr_links (pr_id, data, updated_at) VALUES (?, ?, ?)`);
+      for (const [prId, value] of Object.entries(raw)) {
+        try {
+          ins.run(String(prId), JSON.stringify(value), now);
+          inserted += 1;
+        } catch { /* duplicate / corrupt — skip */ }
+      }
+    }
+
+    // eslint-disable-next-line no-console
+    console.log(`[db-migrate] v10: backfilled ${inserted} pr-links rows; pr-links.json kept as dual-write mirror`);
+  },
+};

package/engine/pull-requests-store.js

@@ -149,11 +149,44 @@ function readPullRequestsForScope(scope) {
   return out;
 }
 
+// Enumerate scopes that have a JSON file on disk — used as the
+// SQL-unavailable fallback for `readAllPullRequests`. Mirrors
+// work-items-store's `_enumerateJsonScopes` shape.
+function _enumerateJsonScopes() {
+  const shared = require('./shared');
+  const scopes = [];
+  const centralPath = path.join(shared.MINIONS_DIR, 'pull-requests.json');
+  if (fs.existsSync(centralPath)) scopes.push('central');
+  const projectsDir = path.join(shared.MINIONS_DIR, 'projects');
+  try {
+    for (const d of fs.readdirSync(projectsDir, { withFileTypes: true })) {
+      if (!d.isDirectory()) continue;
+      const fp = path.join(projectsDir, d.name, 'pull-requests.json');
+      if (fs.existsSync(fp)) scopes.push(d.name);
+    }
+  } catch { /* projects dir missing on fresh install */ }
+  return scopes;
+}
+
 function readAllPullRequests() {
   const { getDb } = require('./db');
   let db;
   try { db = getDb(); }
-  catch { return null; }
+  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;
+  }
 
   try { _resyncScopeIfJsonDiverged(db, 'central'); } catch {}
   const knownScopes = db.prepare('SELECT DISTINCT scope FROM pull_requests').all().map(r => r.scope);

package/engine/shared.js

@@ -532,6 +532,10 @@ function _routeJsonReadToSql(p) {
       const store = require('./small-state-store');
       return { value: store.readQaSessions() };
     }
+    if (norm.endsWith('/engine/pr-links.json')) {
+      const store = require('./small-state-store');
+      return { value: store.readPrLinks() };
+    }
     // Per-project work-items.json — match `/projects/<name>/work-items.json`.
     // When SQL has no rows for the scope AND the JSON file is absent on
     // disk, preserve the legacy "file missing → null" semantic. This guards
@@ -582,9 +586,9 @@ function _routeJsonReadToSql(p) {
  *
  * **SQL routing (Phase 9):** when the path matches a migrated state file
  * (work-items, pull-requests, dispatch, metrics, watches, schedule-runs,
- * pipeline-runs, managed-processes, worktree-pool, qa-runs, qa-sessions),
- * the read is served from SQLite via `_routeJsonReadToSql` — the JSON file
- * on disk is no longer authoritative.
+ * pipeline-runs, managed-processes, worktree-pool, qa-runs, qa-sessions,
+ * pr-links), the read is served from SQLite via `_routeJsonReadToSql` — the
+ * JSON file on disk is no longer authoritative.
  *
  * Counterpart: `safeJsonNoRestore` for terminal artifacts and "missing == gone"
  * reads (cooldowns, archived PRDs, ephemeral session state) where reviving a
@@ -4988,9 +4992,19 @@ function getPrLinks() {
       mergePrLinkItems(links, pr.id, pr.prdItems || []);
     }
   } catch { /* SQL unavailable — skip primary source */ }
-  // Fallback: static pr-links.json for entries not covered above
+  // Fallback: pr_links SQL store (was static pr-links.json file). Phase 9.1
+  // routes both reads and writes through small-state-store; the JSON file is
+  // kept as a dual-write mirror. SQL failures fall through to the JSON file.
+  let static_ = null;
   try {
-    const static_ = JSON.parse(fs.readFileSync(PR_LINKS_PATH, 'utf8'));
+    const store = require('./small-state-store');
+    static_ = store.readPrLinks();
+  } catch { static_ = null; }
+  if (!static_ || Object.keys(static_).length === 0) {
+    try { static_ = JSON.parse(fs.readFileSync(PR_LINKS_PATH, 'utf8')); }
+    catch { static_ = null; }
+  }
+  if (static_ && typeof static_ === 'object' && !Array.isArray(static_)) {
     for (const [k, v] of Object.entries(static_)) {
       const canonical = parseCanonicalPrId(k);
       let normalizedKey = canonical ? `${canonical.scope}#${canonical.prNumber}` : k;
@@ -5004,7 +5018,7 @@ function getPrLinks() {
       }
       if (!links[normalizedKey]) mergePrLinkItems(links, normalizedKey, v);
     }
-  } catch { /* missing */ }
+  }
   return links;
 }
 
@@ -5030,7 +5044,7 @@ function addPrLink(prId, itemId, { project = null, url = '', prNumber = null } =
   const effectivePrId = canonicalPrId || prId;
   if (!effectivePrId || !itemId) return;
   const legacyPrId = String(prId || '');
-  mutateJsonFileLocked(PR_LINKS_PATH, (links) => {
+  const mutator = (links) => {
     if (!links || Array.isArray(links) || typeof links !== 'object') links = {};
     const mergedCurrent = new Set(normalizePrLinkItems(links[effectivePrId]));
     if (legacyPrId && legacyPrId !== effectivePrId && links[legacyPrId]) {
@@ -5040,7 +5054,24 @@ function addPrLink(prId, itemId, { project = null, url = '', prNumber = null } =
     if (!mergedCurrent.has(itemId)) mergedCurrent.add(itemId);
     links[effectivePrId] = [...mergedCurrent];
     return links;
-  }, { defaultValue: {} });
+  };
+  // Phase 9.1: pr-links is SQL-canonical via small-state-store; the JSON file
+  // is a dual-write mirror. SQLite failures fall through to the legacy JSON
+  // path so older installs without --experimental-sqlite still work.
+  let routedViaSql = false;
+  try {
+    const store = require('./small-state-store');
+    store.applyPrLinksMutation(mutator);
+    try { store._mirrorPrLinksJson(); } catch { /* mirror best-effort */ }
+    routedViaSql = true;
+  } catch (e) {
+    if (!e || !/SQLite unavailable|no such table|node:sqlite/.test(String(e.message))) {
+      throw e;
+    }
+  }
+  if (!routedViaSql) {
+    mutateJsonFileLocked(PR_LINKS_PATH, mutator, { defaultValue: {} });
+  }
 
   if (!project) return;
   const prPath = projectPrPath(project);

package/engine/small-state-store.js

@@ -829,6 +829,118 @@ function _mirrorQaSessionsJson(filePath) {
   } catch { /* mirror best-effort */ }
 }
 
+// ─── pr_links ───────────────────────────────────────────────────────────────
+// Shape: { [prId]: <value> } where <value> is typically array of item IDs
+// but may also be a bare string (legacy). Readers normalize.
+
+let _prLinksHash = null;
+
+function _hydratePrLinks(db) {
+  const fp = _resolveFilePath('pr-links.json');
+  const raw = _readJson(fp) || {};
+  db.prepare('DELETE FROM pr_links').run();
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return;
+  const now = Date.now();
+  const ins = db.prepare('INSERT INTO pr_links (pr_id, data, updated_at) VALUES (?, ?, ?) ON CONFLICT(pr_id) DO NOTHING');
+  for (const [prId, value] of Object.entries(raw)) {
+    ins.run(String(prId), JSON.stringify(value), now);
+  }
+}
+
+function _resyncPrLinksIfDiverged(db) {
+  const fp = _resolveFilePath('pr-links.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_prLinksHash != null && currentHash === _prLinksHash) return;
+  if (_prLinksHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM pr_links LIMIT 1').get();
+    if (sqlHas) {
+      _prLinksHash = currentHash;
+      return;
+    }
+  }
+  _hydratePrLinks(db);
+  _prLinksHash = currentHash;
+}
+
+function _readPrLinksFromSql(db) {
+  const rows = db.prepare('SELECT pr_id, data FROM pr_links').all();
+  const out = {};
+  for (const row of rows) {
+    try { out[row.pr_id] = JSON.parse(row.data); }
+    catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+function readPrLinks() {
+  const { getDb } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch { return _readJson(_resolveFilePath('pr-links.json')) || {}; }
+  try { _resyncPrLinksIfDiverged(db); }
+  catch { /* table may be missing on a stale install — fall back to JSON */ }
+  let out;
+  try { out = _readPrLinksFromSql(db); }
+  catch { return _readJson(_resolveFilePath('pr-links.json')) || {}; }
+  if (Object.keys(out).length === 0) {
+    const fallback = _readJson(_resolveFilePath('pr-links.json'));
+    if (fallback && Object.keys(fallback).length > 0) return fallback;
+    return {};
+  }
+  return out;
+}
+
+function applyPrLinksMutation(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, () => {
+    _resyncPrLinksIfDiverged(db);
+    const before = _readPrLinksFromSql(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 pr_links (pr_id, data, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(pr_id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM pr_links WHERE pr_id = ?');
+    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 _mirrorPrLinksJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const obj = _readPrLinksFromSql(getDb());
+    const target = filePath || _resolveFilePath('pr-links.json');
+    shared.safeWrite(target, obj);
+    const h = _fileContentHash(target);
+    if (h != null) _prLinksHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
 // ─── Test seam ─────────────────────────────────────────────────────────────
 
 function _resetAllForTest() {
@@ -841,6 +953,7 @@ function _resetAllForTest() {
     db.exec('DELETE FROM worktree_pool');
     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 */ }
   } catch { /* not initialized */ }
   _scheduleRunsHash = null;
   _pipelineRunsHash = null;
@@ -848,6 +961,7 @@ function _resetAllForTest() {
   _worktreePoolHash = null;
   _qaRunsHash = null;
   _qaSessionsHash = null;
+  _prLinksHash = null;
 }
 
 module.exports = {
@@ -875,6 +989,10 @@ module.exports = {
   readQaSessions,
   applyQaSessionsMutation,
   _mirrorQaSessionsJson,
+  // pr_links
+  readPrLinks,
+  applyPrLinksMutation,
+  _mirrorPrLinksJson,
   // test seam
   _resetAllForTest,
 };

package/engine/supervisor.js

@@ -133,10 +133,19 @@ function openAppendFd(name) {
   try { return fs.openSync(path.join(dir, name), 'a'); } catch { return 'ignore'; }
 }
 
+function _sqliteSpawnFlags() {
+  if (process.env.MINIONS_FORCE_JSON === '1') return [];
+  const major = parseInt(String(process.versions.node).split('.')[0], 10);
+  if (!Number.isFinite(major) || major < 22 || major >= 24) return [];
+  const nodeOpts = String(process.env.NODE_OPTIONS || '');
+  if (nodeOpts.includes('--experimental-sqlite')) return [];
+  return ['--experimental-sqlite'];
+}
+
 function spawnEngine() {
   const out = openAppendFd('engine-stdio.log');
   const err = openAppendFd('engine-stdio.log');
-  const proc = spawn(process.execPath, [path.join(MINIONS_DIR, 'engine.js'), 'start'], {
+  const proc = spawn(process.execPath, [..._sqliteSpawnFlags(), path.join(MINIONS_DIR, 'engine.js'), 'start'], {
     cwd: MINIONS_DIR,
     stdio: ['ignore', out, err],
     detached: true,
@@ -150,7 +159,7 @@ function spawnDashboard() {
   const out = openAppendFd('dashboard-stdio.log');
   const err = openAppendFd('dashboard-stdio.log');
   const env = { ...process.env, MINIONS_NO_AUTO_OPEN: '1' };
-  const proc = spawn(process.execPath, [path.join(MINIONS_DIR, 'dashboard.js')], {
+  const proc = spawn(process.execPath, [..._sqliteSpawnFlags(), path.join(MINIONS_DIR, 'dashboard.js')], {
     cwd: MINIONS_DIR,
     stdio: ['ignore', out, err],
     detached: true,

package/engine/work-items-store.js

@@ -138,14 +138,52 @@ function _resyncScopeIfJsonDiverged(db, scope) {
   _lastMirrorHashByScope.set(scope, currentHash);
 }
 
+// Enumerate scopes that have a JSON file on disk — used as the SQL-
+// unavailable fallback for `readAllWorkItems`. Walks `<MINIONS_DIR>/
+// projects/*/work-items.json` plus the central `<MINIONS_DIR>/work-
+// items.json`. Silently swallows missing dirs (fresh installs).
+function _enumerateJsonScopes() {
+  const shared = require('./shared');
+  const scopes = [];
+  const centralPath = path.join(shared.MINIONS_DIR, 'work-items.json');
+  if (fs.existsSync(centralPath)) scopes.push('central');
+  const projectsDir = path.join(shared.MINIONS_DIR, 'projects');
+  try {
+    for (const d of fs.readdirSync(projectsDir, { withFileTypes: true })) {
+      if (!d.isDirectory()) continue;
+      const fp = path.join(projectsDir, d.name, 'work-items.json');
+      if (fs.existsSync(fp)) scopes.push(d.name);
+    }
+  } catch { /* projects dir missing on fresh install */ }
+  return scopes;
+}
+
 // 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 { return null; }  // signal: SQL unavailable, caller must fall back
+  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;
+  }
 
   // Pick up any external JSON edits for every scope SQL knows about.
   // Also resync 'central' explicitly so first-time reads on a JSON-only

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2113",
+  "version": "0.1.2115",
   "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"