@yemi33/minions 0.1.2112 → 0.1.2114

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/check-status.js

@@ -4,7 +4,7 @@ const dir = path.resolve(__dirname, '..');
 
 console.log('=== Work Items (non-done) ===');
 let items = [];
-try { items = JSON.parse(fs.readFileSync(path.join(dir, 'work-items.json'), 'utf8')); } catch {}
+try { items = require('./queries').getWorkItems() || []; } catch {}
 items.filter(i => i.status !== 'done').forEach(i => {
   console.log(i.id, (i.status || '').padEnd(12), (i.type || '').padEnd(12), (i.title || '').slice(0, 60));
 });

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/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

@@ -4970,33 +4970,24 @@ function getPrLinks() {
     if (!knownPrIdsByDisplay.has(displayId)) knownPrIdsByDisplay.set(displayId, new Set());
     knownPrIdsByDisplay.get(displayId).add(pr.id);
   };
-  // Primary source: derive from all projects/*/pull-requests.json prdItems
-  const projectsDir = path.join(MINIONS_DIR, 'projects');
+  // Primary source: derive from all per-project + central PR records via the
+  // SQL-canonical store (Phase 9). `readAllPullRequests` decorates each row
+  // with `_scope` so we can look up the owning project for legacy-ID
+  // normalization.
   const projectsByName = new Map(getProjects().map(project => [project.name || path.basename(project.localPath || ''), project]));
   try {
-    for (const d of fs.readdirSync(projectsDir, { withFileTypes: true })) {
-      if (!d.isDirectory()) continue;
-      try {
-        const prs = JSON.parse(fs.readFileSync(path.join(projectsDir, d.name, 'pull-requests.json'), 'utf8'));
-        const project = projectsByName.get(d.name) || null;
-        normalizePrRecords(prs, project);
-        for (const pr of prs) {
-          if (!pr.id) continue;
-          registerPrId(pr);
-          mergePrLinkItems(links, pr.id, pr.prdItems || []);
-        }
-      } catch { /* missing or invalid */ }
-    }
-  } catch { /* projects dir missing */ }
-  try {
-    const centralPrs = JSON.parse(fs.readFileSync(path.join(MINIONS_DIR, 'pull-requests.json'), 'utf8'));
-    normalizePrRecords(centralPrs, null);
-    for (const pr of centralPrs) {
-      if (!pr.id) continue;
+    const store = require('./pull-requests-store');
+    const allPrs = store.readAllPullRequests() || [];
+    for (const pr of allPrs) {
+      if (!pr?.id) continue;
+      const scope = pr._scope;
+      delete pr._scope;
+      const project = scope && scope !== 'central' ? (projectsByName.get(scope) || null) : null;
+      normalizePrRecords([pr], project);
       registerPrId(pr);
       mergePrLinkItems(links, pr.id, pr.prdItems || []);
     }
-  } catch { /* central file optional */ }
+  } catch { /* SQL unavailable — skip primary source */ }
   // Fallback: static pr-links.json for entries not covered above
   try {
     const static_ = JSON.parse(fs.readFileSync(PR_LINKS_PATH, 'utf8'));
@@ -5054,27 +5045,21 @@ function addPrLink(prId, itemId, { project = null, url = '', prNumber = null } =
   if (!project) return;
   const prPath = projectPrPath(project);
   const effectivePrNumber = getPrNumber(prNumber ?? effectivePrId);
-  const prLockPath = `${prPath}.lock`;
-  withFileLock(prLockPath, () => {
-    if (!fs.existsSync(prPath)) return;
-    let prs = safeJson(prPath);
-    if (!Array.isArray(prs)) prs = [];
+  // Phase 9 SQL routing: mutatePullRequests writes through pull-requests-store
+  // so SQL stays canonical; the JSON mirror is regenerated by the store.
+  mutatePullRequests(prPath, (prs) => {
+    if (!Array.isArray(prs) || prs.length === 0) return prs;
     normalizePrRecords(prs, project);
     const existingPr = prs.find(pr =>
       pr?.id === effectivePrId
       || (url && pr?.url === url)
       || (effectivePrNumber != null && getPrNumber(pr) === effectivePrNumber)
     );
-    if (!existingPr) return;
-    const backupPath = prPath + '.backup';
-    try { if (fs.existsSync(prPath)) fs.copyFileSync(prPath, backupPath); } catch { /* backup is best-effort */ }
+    if (!existingPr) return prs;
     existingPr.prdItems = Array.isArray(existingPr.prdItems) ? existingPr.prdItems : [];
-    if (existingPr.prdItems.includes(itemId)) return;
+    if (existingPr.prdItems.includes(itemId)) return prs;
     existingPr.prdItems.push(itemId);
-    safeWrite(prPath, prs);
-  }, {
-    retries: ENGINE_DEFAULTS.lockRetries,
-    retryBackoffMs: ENGINE_DEFAULTS.lockRetryBackoffMs
+    return prs;
   });
 }
 

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.2112",
+  "version": "0.1.2114",
   "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"