@yemi33/minions 0.1.2370 → 0.1.2371

package/engine/pull-requests-store.js

@@ -1,21 +1,10 @@
-// engine/pull-requests-store.js — SQL-backed implementation of the
-// per-file pull-requests array. Same external contract as the legacy
-// JSON-file reader, modeled directly on work-items-store.js.
+// engine/pull-requests-store.js — SQL-backed scoped pull-request storage.
 //
 //   readPullRequestsForScope(scope)        -> [pr, pr, ...]
 //   applyPullRequestsMutation(scope, fn)   -> diff-then-apply,
 //                                             returns { wrote, result }
 //
-// `scope` is 'central' for the top-level pull-requests.json or a project
-// name for projects/<name>/pull-requests.json.
-//
-// External-edit detection mirrors work-items-store: per-scope last-mirror
-// mtime is recorded after every write; if the JSON file's mtime advances
-// outside our knowledge (test re-seed, operator hand-edit), we treat the
-// JSON as canonical and rebuild SQL before the next read or mutation.
-
-const path = require('path');
-const fs = require('fs');
+// `scope` is 'central' or a project name.
 
 function _toMs(v) {
   if (v == null) return null;
@@ -31,12 +20,12 @@ function scopeForFilePath(filePath) {
   return 'central';
 }
 
+// Compatibility adapter for callers that still pass a path-shaped scope token
+// into shared.mutatePullRequests. No file is read or written.
 function _filePathForScope(scope) {
   const shared = require('./shared');
-  if (scope === 'central') {
-    return path.join(shared.MINIONS_DIR, 'pull-requests.json');
-  }
-  return path.join(shared.MINIONS_DIR, 'projects', scope, 'pull-requests.json');
+  if (!scope || scope === 'central') return shared.centralPullRequestsPath(shared.MINIONS_DIR);
+  return require('path').join(shared.MINIONS_DIR, 'projects', scope, 'pull-requests.json');
 }
 
 function _parseRow(row) {
@@ -45,143 +34,16 @@ function _parseRow(row) {
   catch { return null; }
 }
 
-function _readJsonArrayFallback(scope) {
-  const fp = _filePathForScope(scope);
-  let raw;
-  try { raw = fs.readFileSync(fp, 'utf8'); }
-  catch { return []; }
-  try {
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch (e) {
-    try {
-      // eslint-disable-next-line no-console
-      console.warn(`[pull-requests-store] corrupt JSON in ${fp}: ${e.message}`);
-    } catch { /* console may be wrapped in tests */ }
-    return [];
-  }
-}
-
-// Content-hash fingerprint per scope: same-length swaps (timestamps,
-// reviewStatus enums) collide on (mtime, size) but never on SHA-1.
-//
-// W-mrcg7j9k000ja233 (#759): this used to be an in-memory-only Map, which
-// resets to empty on every process restart. Persist it in SQL instead
-// (`pr_mirror_hashes`) so a restart can't blank out the "does JSON already
-// agree with SQL" trust state — that reset, combined with a restart landing
-// mid-flight of another process's mirror write, is exactly what let a stale
-// JSON snapshot get treated as canonical and silently wipe SQL rows for a
-// scope (see _resyncScopeIfJsonDiverged / _hydrateScopeFromJson below).
-function _getLastMirrorHash(db, scope) {
-  try {
-    const row = db.prepare('SELECT hash FROM pr_mirror_hashes WHERE scope = ?').get(scope);
-    return row ? row.hash : null;
-  } catch { return null; }
-}
-
-function _setLastMirrorHash(db, scope, hash) {
-  try {
-    db.prepare(`
-      INSERT INTO pr_mirror_hashes (scope, hash, updated_at) VALUES (?, ?, ?)
-      ON CONFLICT(scope) DO UPDATE SET hash = excluded.hash, updated_at = excluded.updated_at
-    `).run(scope, hash, Date.now());
-  } catch { /* best-effort — a missed persisted-hash write just means the next resync re-checks */ }
-}
-
-function _forgetLastMirrorHash(db, scope) {
-  try { db.prepare('DELETE FROM pr_mirror_hashes WHERE scope = ?').run(scope); } catch { /* best-effort */ }
-}
-
-const crypto = require('crypto');
-
-function _fileContentHash(filePath) {
-  try {
-    const buf = fs.readFileSync(filePath);
-    return crypto.createHash('sha1').update(buf).digest('hex');
-  }
-  catch { return null; }
-}
-
-function _hydrateScopeFromJson(db, scope) {
-  const jsonItems = _readJsonArrayFallback(scope);
-  const beforeCount = db.prepare('SELECT COUNT(*) AS n FROM pull_requests WHERE scope = ?').get(scope).n;
-  const beforeIds = db.prepare('SELECT id FROM pull_requests WHERE scope = ?').all(scope).map(r => r.id);
-  db.prepare('DELETE FROM pull_requests WHERE scope = ?').run(scope);
-  // #759 — this DELETE used to be completely silent. Log every hydrate at
-  // warn level with before/after counts + the ids that are about to be
-  // dropped, so a JSON<->SQL resync that removes rows the operator didn't
-  // expect leaves a trace in engine-stdio.log instead of vanishing without
-  // explanation.
-  try {
-    const afterIds = new Set(jsonItems.filter(pr => pr && pr.id).map(pr => String(pr.id)));
-    const droppedIds = beforeIds.filter(id => !afterIds.has(id));
-    // eslint-disable-next-line no-console
-    console.warn(
-      `[pull-requests-store] _hydrateScopeFromJson(scope=${scope}): rebuilding SQL from JSON mirror — `
-      + `before=${beforeCount} row(s), after=${jsonItems.length} row(s)`
-      + (droppedIds.length ? `, dropping id(s): ${droppedIds.join(', ')}` : ''),
-    );
-  } catch { /* logging must never block the resync */ }
-  if (jsonItems.length === 0) return;
-  const now = Date.now();
-  const ins = db.prepare(`
-    INSERT INTO pull_requests (id, scope, status, review_status, agent, branch, pr_number, created_at, last_polled_at, data, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(scope, id) DO NOTHING
-  `);
-  for (const pr of jsonItems) {
-    if (!pr || !pr.id) continue;
-    ins.run(
-      String(pr.id),
-      scope,
-      String(pr.status || 'active'),
-      pr.reviewStatus || null,
-      pr.agent || null,
-      pr.branch || null,
-      Number.isFinite(pr.prNumber) ? pr.prNumber : null,
-      _toMs(pr.created),
-      _toMs(pr.lastPolledAt || pr.lastPolled),
-      JSON.stringify(pr),
-      now,
-    );
-  }
-}
-
-function _resyncScopeIfJsonDiverged(db, scope) {
-  const jsonPath = _filePathForScope(scope);
-  const currentHash = _fileContentHash(jsonPath);
-  const lastHash = _getLastMirrorHash(db, scope);
-  if (currentHash == null) return;
-  if (lastHash != null && currentHash === lastHash) return;
-  if (lastHash == null) {
-    const sqlHas = db.prepare('SELECT 1 FROM pull_requests WHERE scope = ? LIMIT 1').get(scope);
-    if (sqlHas) {
-      _setLastMirrorHash(db, scope, currentHash);
-      return;
-    }
-  }
-  _hydrateScopeFromJson(db, scope);
-  _setLastMirrorHash(db, scope, currentHash);
-}
-
 function readPullRequestsForScope(scope) {
   const { getDb } = require('./db');
   const db = getDb();
 
-  _resyncScopeIfJsonDiverged(db, scope);
-
   const rows = db.prepare(`
     SELECT data FROM pull_requests
     WHERE scope = ?
     ORDER BY rowid
   `).all(scope);
 
-  if (rows.length === 0) {
-    const fallback = _readJsonArrayFallback(scope);
-    if (fallback.length > 0) return fallback;
-    return [];
-  }
-
   const out = [];
   for (const row of rows) {
     const pr = _parseRow(row);
@@ -190,36 +52,10 @@ 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');
   const db = getDb();
 
-  try { _resyncScopeIfJsonDiverged(db, 'central'); } catch {}
-  const knownScopes = db.prepare('SELECT DISTINCT scope FROM pull_requests').all().map(r => r.scope);
-  for (const s of knownScopes) {
-    if (s === 'central') continue;
-    try { _resyncScopeIfJsonDiverged(db, s); } catch {}
-  }
-
   const rows = db.prepare('SELECT data, scope FROM pull_requests ORDER BY rowid').all();
   const out = [];
   for (const row of rows) {
@@ -296,12 +132,11 @@ function _applyPullRequestsDiff(db, diff) {
   return true;
 }
 
-function applyPullRequestsMutation(scope, mutator, options = {}) {
+function applyPullRequestsMutation(scope, mutator) {
   const { getDb, withTransaction } = require('./db');
   const db = getDb();
 
   return withTransaction(db, () => {
-    _resyncScopeIfJsonDiverged(db, scope);
     const before = readPullRequestsForScope(scope);
     // Strip the _scope decoration that readAllPullRequests adds, in case
     // a caller round-trips records from there back through here.
@@ -313,56 +148,10 @@ function applyPullRequestsMutation(scope, mutator, options = {}) {
       : (Array.isArray(next) ? next : before);
     const diff = _computePullRequestsDiff(scope, beforeSnapshot, after);
     const wrote = _applyPullRequestsDiff(db, diff);
-    // W-mrcg7j9k000ja233 (#759) — mirror the JSON sidecar INSIDE this same
-    // SQL write transaction, BEFORE it commits, instead of after (as the
-    // caller in shared.js used to do post-return). This mirrors the fix
-    // already applied to work-items-store.js (W-mr9vcxvy000cdb4e): SQLite
-    // only allows one writer transaction at a time, so mirroring here
-    // guarantees the on-disk JSON file reflects this commit by the time it
-    // becomes visible to any other reader/writer. Without this ordering, a
-    // sibling process (dashboard vs. engine — separate Node processes, each
-    // with its own resync state) could observe the freshly committed SQL
-    // rows before the mirror file caught up, decide its own cached hash no
-    // longer matched the (still-stale) JSON file, and call
-    // _hydrateScopeFromJson — which DELETEs + reinserts the whole scope
-    // from that stale file, silently dropping the row this transaction just
-    // committed.
-    if (wrote) {
-      try { _mirrorJsonFromSql(scope, options.mirrorPath); } catch { /* best-effort — mirror failure must not block the SQL write */ }
-    }
     return { wrote, result: after };
   });
 }
 
-function _mirrorJsonFromSql(scope, filePath) {
-  try {
-    const shared = require('./shared');
-    const { getDb } = require('./db');
-    // Read SQL directly for this scope — bypass JSON fallback so a
-    // mutation that empties SQL for the scope doesn't resurrect stale
-    // JSON content.
-    const db = getDb();
-    const rows = db.prepare('SELECT data FROM pull_requests WHERE scope = ? ORDER BY rowid').all(scope);
-    const items = [];
-    for (const row of rows) {
-      const pr = _parseRow(row);
-      if (!pr) continue;
-      if (pr._scope) delete pr._scope;
-      items.push(pr);
-    }
-    const target = filePath || _filePathForScope(scope);
-    shared.safeWrite(target, items);
-    const h = _fileContentHash(target);
-    if (h != null) _setLastMirrorHash(db, scope, h);
-  } catch {
-    // Mirror failures are non-fatal — SQL has already committed.
-  }
-}
-
-// Drop every SQL row for `scope` and forget its mirror-hash. Called by
-// removeProject after the JSON file is archived so safeJson shim reads no
-// longer surface the removed project's records.
-//
 // Per CLAUDE.md's mutator contract, every mutator wrapper must call
 // emitStateEvent() so the dashboard's MAX(events.id) cache-version
 // advances — otherwise the dashboard keeps serving stale cached
@@ -372,20 +161,7 @@ function _mirrorJsonFromSql(scope, filePath) {
 function dropScope(scope) {
   try {
     const { getDb } = require('./db');
-    const db = getDb();
-    const result = db.prepare('DELETE FROM pull_requests WHERE scope = ?').run(scope);
-    // Mirror the work-items-store.js fix (W-mr96m3hm000fd5d7): don't blindly
-    // forget the mirror-hash. _resyncScopeIfJsonDiverged treats "no recorded
-    // hash" + "zero SQL rows" as a first-install hydrate and rebuilds SQL from
-    // whatever JSON is on disk. removeProject with dataMode:'keep' leaves this
-    // scope's JSON file untouched, so forgetting the hash here would let the
-    // very next read/write resurrect the just-dropped project's stale PR rows.
-    // Adopt the file's current hash instead (or forget it only if the file is
-    // actually gone, e.g. dataMode: 'purge'/'archive').
-    const jsonPath = _filePathForScope(scope);
-    const currentHash = _fileContentHash(jsonPath);
-    if (currentHash == null) _forgetLastMirrorHash(db, scope);
-    else _setLastMirrorHash(db, scope, currentHash);
+    const result = getDb().prepare('DELETE FROM pull_requests WHERE scope = ?').run(scope);
     if (result && result.changes > 0) {
       try { require('./db-events').emitStateEvent('pull_requests'); } catch { /* optional */ }
     }
@@ -393,11 +169,10 @@ function dropScope(scope) {
 }
 
 module.exports = {
+  _filePathForScope,
   scopeForFilePath,
   readPullRequestsForScope,
   readAllPullRequests,
   applyPullRequestsMutation,
   dropScope,
-  _filePathForScope,
-  _mirrorJsonFromSql,
 };

package/engine/qa-runs.js

@@ -5,18 +5,14 @@
  * a managed target. Records carry status, timing, work-item linkage, and an
  * artifacts array (screenshots, logs, videos captured during the run).
  *
- * Persistence: SQLite (engine/state.db, `qa_runs` table) as source of truth
- * since Phase 8 (PRD: migrate-qa-state-to-sqlite). The legacy JSON sidecar
- * at engine/qa-runs.json is dual-written on every mutation when
- * `engine.qaDualWriteJson` is true (default) so external tooling and the
- * rollback path keep working. Artifacts live on disk under
+ * Persistence: SQLite (engine/state.db, `qa_runs` table). Artifacts live on disk under
  * engine/qa-artifacts/<runId>/ — the run record stores relative paths
  * (`type`, `path`, `label`, `capturedAt`), and the dashboard exposes them
  * through GET /api/qa/artifacts/<runId>/<file>.
  *
  * Concurrency: every mutation goes through shared.mutateQaRuns, which routes
  * to small-state-store.applyQaRunsMutation inside a SQLite transaction
- * (BEGIN IMMEDIATE) plus a content-hash divergence rehydrate on read.
+ * (BEGIN IMMEDIATE).
  * Callbacks are synchronous and never await.
  *
  * Status state machine:
@@ -35,7 +31,7 @@ const path = require('path');
 const shared = require('./shared');
 const { mutateQaRuns, uid, ts, log } = shared;
 
-// Cap qa-runs.json so the file (and qa_runs table) doesn't grow unboundedly
+// Cap qa_runs so the table doesn't grow unboundedly
 // over months of nightly QA dispatch. Mirrors the 2500-entry cap on
 // engine/log.json. createRun trims oldest-by-createdAt when crossing the
 // threshold; terminal-status runs that have already shipped completion
@@ -252,15 +248,8 @@ function getRun(id) {
   return run || null;
 }
 
-// Internal helper — reads via the small-state store (SQL → JSON fallback)
-// when available, falling back to direct JSON read if SQLite is unavailable.
 function _readRuns() {
-  try {
-    const store = require('./small-state-store');
-    const arr = store.readQaRuns();
-    if (Array.isArray(arr)) return arr;
-  } catch { /* fall back */ }
-  return shared.safeJsonArr(qaRunsPath());
+  return require('./small-state-store').readQaRuns();
 }
 
 /**

package/engine/qa-sessions.js

@@ -30,8 +30,7 @@
  *
  * Concurrency: every mutation goes through shared.mutateQaSessions, which
  * routes to small-state-store.applyQaSessionsMutation inside a SQLite
- * transaction (BEGIN IMMEDIATE) plus a content-hash divergence rehydrate on
- * read. Callbacks are synchronous and never await. Slow filesystem work
+ * transaction (BEGIN IMMEDIATE). Callbacks are synchronous and never await. Slow filesystem work
  * (qa-tests/<id>/ scaffolding, dispatch enqueueing) runs OUTSIDE the lock.
  *
  * Path-traversal hardening: sessionId is generated by createSession() with a
@@ -40,10 +39,7 @@
  * a filesystem path or a session lookup. Mirrors engine/qa-runbooks.js
  * _isSafeId (PR #2694 review feedback).
  *
- * Persistence: SQLite (engine/state.db, `qa_sessions` table) as source of
- * truth since Phase 8 (PRD: migrate-qa-state-to-sqlite). The legacy JSON
- * sidecar at engine/qa-sessions.json is dual-written on every mutation when
- * `engine.qaDualWriteJson` is true (default). Capped at
+ * Persistence: SQLite (engine/state.db, `qa_sessions` table). Capped at
  * QA_SESSIONS_MAX_RECORDS via createSession-time rotation.
  */
 
@@ -52,22 +48,14 @@ const path = require('path');
 const shared = require('./shared');
 const { mutateQaSessions, uid, ts, log } = shared;
 
-// Internal helper — read sessions via the small-state store when available
-// (SQL → JSON fallback inside the store), else direct JSON read.
 function _readSessions() {
-  try {
-    const store = require('./small-state-store');
-    const arr = store.readQaSessions();
-    if (Array.isArray(arr)) return arr;
-  } catch { /* fall back */ }
-  return _readSessions();
+  return require('./small-state-store').readQaSessions();
 }
 
-// Cap engine/qa-sessions.json. Sessions cost more than runs (3 WIs, a
+// Sessions cost more than runs (3 WIs, a
 // managed-spawn, artifacts) so the operational steady state is meaningfully
 // smaller than QA_RUNS_MAX_RECORDS (2000). 500 covers ~2 months of nightly +
-// ad-hoc sessions without ballooning the JSON parse cost on /api/status's
-// fast-state slice (W-mpehsyhv event-loop budget — see qa-runs.js cap notes).
+// ad-hoc sessions.
 const QA_SESSIONS_MAX_RECORDS = 500;
 
 const QA_SESSION_STATE = Object.freeze({

package/engine/queries.js

@@ -178,19 +178,10 @@ function timeSince(ms) {
 }
 
 function readJsonNoRestore(filePath) {
-  let raw;
   try {
-    raw = fs.readFileSync(filePath, 'utf8');
+    return shared.safeJsonNoRestore(filePath);
   } catch (e) {
-    if (e && e.code !== 'ENOENT') {
-      console.warn(`[queries] failed to read ${_relativeStatePath(filePath)}: ${e.message}`);
-    }
-    return null;
-  }
-  try {
-    return JSON.parse(raw);
-  } catch (e) {
-    console.warn(`[queries] corrupt JSON in ${_relativeStatePath(filePath)}: ${e.message}`);
+    console.warn(`[queries] failed to read ${_relativeStatePath(filePath)}: ${e.message}`);
     return null;
   }
 }
@@ -398,7 +389,7 @@ function getDispatchQueue() {
   const d = getDispatch();
   const allCompleted = d.completed || [];
   // Lifetime total from metrics (dispatch.completed is capped at 100)
-  const metrics = readJsonNoRestore(path.join(ENGINE_DIR, 'metrics.json')) || {};
+  const metrics = require('./metrics-store').readMetrics() || {};
   // Periodically prune cache entries for dispatches that have rotated out of the queue.
   if (_completionReportCache.size >= 200) {
     const activeIds = new Set();
@@ -846,7 +837,8 @@ function getAgentDetail(id) {
 
 function getPrs(project) {
   if (project) {
-    const prs = readJsonNoRestore(projectPrPath(project)) || [];
+    const store = require('./pull-requests-store');
+    const prs = store.readPullRequestsForScope(store.scopeForFilePath(projectPrPath(project))) || [];
     shared.normalizePrRecords(prs, project);
     return prs;
   }
@@ -1217,10 +1209,9 @@ function _skillsCacheKeyFor(config, homeDir) {
 // it via `runtimes: [name, ...]` so diagnostics can show provenance.
 //
 // Consumers: dashboard `/api/status` skills/MCP slices (via collectSkillFiles
-// / collectCommandFiles refactor), the planned `/api/harness/diagnostics`
-// endpoint, `engine.js#spawnAgent` for `computeAddDirs` project-local asset
-// propagation, and `minions doctor --harness` (preflight.js still calls the
-// per-adapter methods directly there to label by adapter — that's intentional).
+// / collectCommandFiles refactor), the `/api/harness/diagnostics` inventory,
+// and `minions doctor --harness` (preflight.js calls the per-adapter methods
+// directly there to label by adapter — that's intentional).
 //
 // Return shape:
 //   { skills: HarnessEntry[], commands: HarnessEntry[], mcps: HarnessEntry[] }
@@ -1321,49 +1312,6 @@ function getProjectHarnesses(project) {
   );
 }
 
-// buildHarnessPropagatedManifest (P-a8f3c2d1) — pure mapper that folds the
-// getUserHarnesses + getProjectHarnesses aggregation (HarnessEntry roots) and a
-// resolved `--add-dir` set into the canonical grounding-manifest shape persisted
-// onto the dispatch record as `_harnessPropagated`:
-//   { skills:[{name,source,path}], mcpServers:[{name,scope}],
-//     commands:[{name,scope}], addDirs:[...] }
-// Unions BOTH user-scope and project-scope contributions (the CRITICAL note in
-// P-a8f3c2d1: omitting user-scope harnesses wrongly flags ~/.agents / ~/.claude
-// skill usage grounded:false downstream) and dedups by absolute path / scoped
-// name. Pure: no fs, no os, no runtime registry — all inputs are injected, so it
-// unit-tests trivially against a fixture project.
-function buildHarnessPropagatedManifest({ userHarnesses, projectHarnesses, addDirs } = {}) {
-  const u = userHarnesses || { skills: [], commands: [], mcps: [] };
-  const p = projectHarnesses || { skills: [], commands: [], mcps: [] };
-  const mapSkill = (e) => ({ name: path.basename(e.dir || ''), source: e.scope || 'unknown', path: e.dir || '' });
-  const mapCommand = (e) => ({ name: path.basename(e.dir || ''), scope: e.scope || 'unknown' });
-  const mapMcp = (e) => ({ name: path.basename(e.file || ''), scope: e.scope || 'unknown' });
-  const dedupBy = (arr, keyFn) => {
-    const seen = new Set();
-    const out = [];
-    for (const item of arr) {
-      const k = keyFn(item);
-      if (seen.has(k)) continue;
-      seen.add(k);
-      out.push(item);
-    }
-    return out;
-  };
-  const skills = dedupBy(
-    [...(u.skills || []), ...(p.skills || [])].filter(e => e && e.dir).map(mapSkill),
-    (s) => s.path,
-  );
-  const commands = dedupBy(
-    [...(u.commands || []), ...(p.commands || [])].filter(e => e && e.dir).map(mapCommand),
-    (c) => `${c.scope}:${c.name}`,
-  );
-  const mcpServers = dedupBy(
-    [...(u.mcps || []), ...(p.mcps || [])].filter(e => e && e.file).map(mapMcp),
-    (m) => `${m.scope}:${m.name}`,
-  );
-  return { skills, mcpServers, commands, addDirs: Array.isArray(addDirs) ? addDirs : [] };
-}
-
 function collectSkillFiles(config) {
   const now = Date.now();
   config = config || getConfig();
@@ -2132,33 +2080,19 @@ function getWorkItems(config, opts) {
 // ── PRD Progress ────────────────────────────────────────────────────────────
 
 // Module-level caches for getPrdInfo() — avoids re-reading unchanged PRD data
-let _prdDirMtimes = { prd: 0, archive: 0 }; // directory mtimes to detect new/deleted files
 let _prdResultCache = null;            // cached final result
-let _prdResultInputHash = '';          // hash of all input mtimes to detect any change
+let _prdResultInputHash = '';          // SQL event version + authored-plan mtimes
 
 /**
  * Collect mtimes of all input files that affect getPrdInfo() output.
  * Returns a string hash for quick equality check plus the dir mtimes.
  */
-function _getPrdInputHash(projects) {
+function _getPrdInputHash() {
   const mtimes = [];
-  // PRD directory mtimes (detect new/deleted files)
-  let prdDirMtime = 0, archiveDirMtime = 0;
-  try { prdDirMtime = fs.statSync(PRD_DIR).mtimeMs; } catch { /* optional */ }
-  const archiveDir = path.join(PRD_DIR, 'archive');
-  try { archiveDirMtime = fs.statSync(archiveDir).mtimeMs; } catch { /* optional */ }
-  mtimes.push(prdDirMtime, archiveDirMtime);
-  // Work-items file mtimes (affect status display)
-  for (const project of projects) {
-    try { mtimes.push(fs.statSync(projectWorkItemsPath(project)).mtimeMs); } catch { mtimes.push(0); }
-  }
-  try { mtimes.push(fs.statSync(path.join(MINIONS_DIR, 'work-items.json')).mtimeMs); } catch { mtimes.push(0); }
-  // PR file mtimes (affect PR links)
-  for (const project of projects) {
-    try { mtimes.push(fs.statSync(projectPrPath(project)).mtimeMs); } catch { mtimes.push(0); }
-  }
-  // Static pr-links.json overrides (affect shared.getPrLinks(); missing project mtimes otherwise)
-  try { mtimes.push(fs.statSync(path.join(MINIONS_DIR, 'engine', 'pr-links.json')).mtimeMs); } catch { mtimes.push(0); }
+  try {
+    const row = require('./db').getDb().prepare('SELECT COALESCE(MAX(id), 0) AS version FROM events').get();
+    mtimes.push(Number(row?.version) || 0);
+  } catch { mtimes.push(0); }
   // W-mqacrzis0003df4a — Source-plan markdown mtimes. Without this, the
   // per-PRD planStale fresh-computation at lines ~1568-1576 is never reached
   // after the user revises plans/<x>.md until the engine tick (~10s) flips
@@ -2174,7 +2108,7 @@ function _getPrdInputHash(projects) {
       try { mtimes.push(fs.statSync(path.join(PLANS_DIR, f)).mtimeMs); } catch { mtimes.push(0); }
     }
   } catch { /* plans/ may not exist in some test/init states */ }
-  return { hash: mtimes.join(','), prdDirMtime, archiveDirMtime };
+  return mtimes.join(',');
 }
 
 function getPrdInfo(config) {
@@ -2182,7 +2116,7 @@ function getPrdInfo(config) {
   const projects = getProjects(config);
 
   // Quick mtime check — return cached result if nothing changed
-  const { hash, prdDirMtime, archiveDirMtime } = _getPrdInputHash(projects);
+  const hash = _getPrdInputHash();
   if (_prdResultCache && hash === _prdResultInputHash) return _prdResultCache;
 
   let allPrdItems = [];
@@ -2192,10 +2126,7 @@ function getPrdInfo(config) {
   // filename so render-prd.js#renderE2eSection can merge them with the live
   // tracker and keep rendering a merged aggregate after its live record is swept.
   const verifyPrsByPlan = {};
-  let latestStat = null;
-
-  // Check if directory listings need refresh (used by mtime hash)
-  _prdDirMtimes = { prd: prdDirMtime, archive: archiveDirMtime };
+  let latestUpdatedAt = 0;
 
   // Phase 10 step 4.3 — FK-based WI↔PRD-item join scaffolding. `prdItemIdByKey`
   // maps `${physicalArchived} ${filename} ${feature_id}` → prd_items.id so each
@@ -2275,22 +2206,12 @@ function getPrdInfo(config) {
     } catch { prdItemIdByKey = null; }
   }
 
-  // Phase 10 step 3 (read-flip complete) — SQL mirror is the unconditional
-  // source. reconcilePrdsFromDisk() catches PRDs written outside the dual-write
-  // chokepoint (plan-to-prd agent direct writes, archive moves, deletes). Files
-  // still live on disk in this phase, so stat them for mtime fields + `age`.
+  // SQLite is the unconditional PRD source.
   const prdStore = require('./prd-store');
-  prdStore.reconcilePrdsFromDisk();
-  for (const { filename, archived, plan } of prdStore.listPrdRows()) {
+  for (const { filename, archived, plan, updatedAt } of prdStore.listPrdRows()) {
     try {
-      const dir = archived ? path.join(PRD_DIR, 'archive') : PRD_DIR;
-      let mtimeMs = 0;
-      try {
-        const stat = fs.statSync(path.join(dir, filename));
-        mtimeMs = stat.mtimeMs;
-        if (!latestStat || stat.mtimeMs > latestStat.mtimeMs) latestStat = stat;
-      } catch { /* file may have just moved/deleted between reconcile and read */ }
-      processPrd(filename, archived, plan, mtimeMs);
+      latestUpdatedAt = Math.max(latestUpdatedAt, updatedAt);
+      processPrd(filename, archived, plan, updatedAt);
     } catch { /* optional */ }
   }
   if (allPrdItems.length === 0) return { progress: null, status: null };
@@ -2527,7 +2448,7 @@ function getPrdInfo(config) {
   };
 
   const status = {
-    exists: true, age: latestStat ? timeSince(latestStat.mtimeMs) : 'unknown',
+    exists: true, age: latestUpdatedAt ? timeSince(latestUpdatedAt) : 'unknown',
     existing: existingPrds, missing: items.filter(i => i.status === 'missing').length, questions: 0, summary: '',
     missingList: items.filter(i => i.status === 'missing').map(f => ({ id: f.id, name: f.name || f.title, priority: f.priority, complexity: f.estimated_complexity || f.size })),
   };
@@ -2540,7 +2461,6 @@ function getPrdInfo(config) {
 
 /** Reset PRD info cache — exported for testing */
 function resetPrdInfoCache() {
-  _prdDirMtimes = { prd: 0, archive: 0 };
   _prdResultCache = null;
   _prdResultInputHash = '';
 }
@@ -3454,7 +3374,7 @@ module.exports = {
 
   // Harness aggregation (P-f5a91c30) — shared union over per-runtime
   // getSkillRoots / getCommandRoots / getMcpConfigPaths.
-  getUserHarnesses, getProjectHarnesses, buildHarnessPropagatedManifest,
+  getUserHarnesses, getProjectHarnesses,
 
   // Knowledge base
   getKnowledgeBaseEntries, getKnowledgeBaseEntriesSnapshot, getKnowledgeBaseIndex,

package/engine/routing.js

@@ -64,7 +64,7 @@ function getRoutingTableCached() {
 // ─── Budget ──────────────────────────────────────────────────────────────────
 
 function getMonthlySpend(agentId) {
-  const metrics = safeJson(path.join(ENGINE_DIR, 'metrics.json')) || {};
+  const metrics = queries.getMetrics() || {};
   const daily = metrics._daily || {};
   const now = new Date();
   const monthPrefix = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;

package/engine/runtimes/claude.js

@@ -206,7 +206,7 @@ const MODELS_CACHE = path.join(_CACHE_DIR, 'claude-models.json');
  *
  * Conditional flags are emitted ONLY when their corresponding capability is
  * truthy. Copilot-only flags (`stream`, `disableBuiltinMcps`,
- * `suppressAgentsMd`, `reasoningSummaries`) are silently ignored on the Claude
+ * `reasoningSummaries`) are silently ignored on the Claude
  * path — runtime adapters MUST be tolerant of unknown opts so engine code can
  * pass the same option bag to every adapter without branching.
  */
@@ -264,7 +264,6 @@ function buildSpawnFlags(opts = {}) {
   if (opts.fallbackModel) flags.push('--fallback-model', String(opts.fallbackModel));
   if (opts.stream != null && opts.stream !== '') flags.push('--stream', String(opts.stream));
   if (opts.disableBuiltinMcps === true) flags.push('--disable-builtin-mcps');
-  if (opts.suppressAgentsMd === true) flags.push('--no-custom-instructions');
   if (opts.reasoningSummaries === true) flags.push('--enable-reasoning-summaries');
   return flags;
 }