@yemi33/minions 0.1.2073 → 0.1.2074

package/engine/db/migrations/008-small-state.js

@@ -0,0 +1,155 @@
+// engine/db/migrations/008-small-state.js
+//
+// Phase 7: move the four remaining small state files into SQL in one
+// migration. Each gets its own table — the files are too dissimilar to
+// share schemas — but they ship together because they're all simple,
+// low-traffic singletons.
+//
+//   engine/schedule-runs.json      -> schedule_runs
+//   engine/pipeline-runs.json      -> pipeline_runs
+//   engine/managed-processes.json  -> managed_processes
+//   engine/worktree-pool.json      -> worktree_pool
+
+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 _toMs(v) {
+  if (v == null) return null;
+  if (typeof v === 'number') return Number.isFinite(v) ? v : null;
+  const parsed = Date.parse(v);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function _readJsonOr(filePath, fallback) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch { return fallback; }
+}
+
+module.exports = {
+  version: 8,
+  description: 'schedule_runs + pipeline_runs + managed_processes + worktree_pool',
+  up(db) {
+    db.exec(`
+      CREATE TABLE schedule_runs (
+        schedule_id  TEXT PRIMARY KEY,
+        data         TEXT NOT NULL,
+        updated_at   INTEGER NOT NULL
+      );
+
+      CREATE TABLE pipeline_runs (
+        pipeline_id  TEXT NOT NULL,
+        run_id       TEXT NOT NULL,
+        status       TEXT,
+        started_at   INTEGER,
+        data         TEXT NOT NULL,
+        updated_at   INTEGER NOT NULL,
+        PRIMARY KEY (pipeline_id, run_id)
+      );
+      CREATE INDEX idx_pipeline_runs_status   ON pipeline_runs(status);
+      CREATE INDEX idx_pipeline_runs_pipeline ON pipeline_runs(pipeline_id);
+
+      CREATE TABLE managed_processes (
+        name        TEXT PRIMARY KEY,
+        data        TEXT NOT NULL,
+        updated_at  INTEGER NOT NULL
+      );
+
+      CREATE TABLE worktree_pool (
+        entry_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;
+
+    // ── schedule_runs ──────────────────────────────────────────────────────
+    {
+      const raw = _readJsonOr(path.join(minionsDir, 'engine', 'schedule-runs.json'), null);
+      if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+        const ins = db.prepare(`INSERT INTO schedule_runs (schedule_id, data, updated_at) VALUES (?, ?, ?)`);
+        for (const [scheduleId, value] of Object.entries(raw)) {
+          try {
+            ins.run(scheduleId, JSON.stringify(value), now);
+            inserted += 1;
+          } catch { /* duplicate / corrupt — skip */ }
+        }
+      }
+    }
+
+    // ── pipeline_runs ──────────────────────────────────────────────────────
+    {
+      const raw = _readJsonOr(path.join(minionsDir, 'engine', 'pipeline-runs.json'), null);
+      if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+        const ins = db.prepare(`
+          INSERT INTO pipeline_runs (pipeline_id, run_id, status, started_at, data, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `);
+        for (const [pipelineId, runs] of Object.entries(raw)) {
+          if (!Array.isArray(runs)) continue;
+          for (const run of runs) {
+            if (!run || !run.runId) continue;
+            try {
+              ins.run(
+                pipelineId,
+                String(run.runId),
+                run.status || null,
+                _toMs(run.startedAt),
+                JSON.stringify(run),
+                now,
+              );
+              inserted += 1;
+            } catch { /* duplicate / corrupt — skip */ }
+          }
+        }
+      }
+    }
+
+    // ── managed_processes ──────────────────────────────────────────────────
+    {
+      const raw = _readJsonOr(path.join(minionsDir, 'engine', 'managed-processes.json'), null);
+      if (raw && Array.isArray(raw.specs)) {
+        const ins = db.prepare(`INSERT INTO managed_processes (name, data, updated_at) VALUES (?, ?, ?)`);
+        for (const spec of raw.specs) {
+          if (!spec || typeof spec !== 'object' || !spec.name) continue;
+          try {
+            ins.run(String(spec.name), JSON.stringify(spec), now);
+            inserted += 1;
+          } catch { /* duplicate name — skip */ }
+        }
+      }
+    }
+
+    // ── worktree_pool ──────────────────────────────────────────────────────
+    {
+      const raw = _readJsonOr(path.join(minionsDir, 'engine', 'worktree-pool.json'), null);
+      if (raw && Array.isArray(raw.entries)) {
+        const ins = db.prepare(`INSERT INTO worktree_pool (entry_id, data, updated_at) VALUES (?, ?, ?)`);
+        for (const entry of raw.entries) {
+          if (!entry || typeof entry !== 'object') continue;
+          // Worktree pool entries don't have an obvious unique id field;
+          // use the worktree path (always unique within a single pool).
+          const id = entry.path || entry.id || JSON.stringify(entry).slice(0, 64);
+          try {
+            ins.run(String(id), JSON.stringify(entry), now);
+            inserted += 1;
+          } catch { /* duplicate — skip */ }
+        }
+      }
+    }
+
+    // eslint-disable-next-line no-console
+    console.log(`[db-migrate] v8: backfilled ${inserted} small-state rows; JSON files kept as dual-write mirrors`);
+  },
+};

package/engine/managed-spawn.js

@@ -850,7 +850,7 @@ function _toStateRecord(spec, runtime, ctx) {
 function recordManagedSpec(spec, runtime, ctx) {
   if (!spec || !spec.name) throw new Error('recordManagedSpec: spec.name required');
   const statePath = _getStatePath();
-  shared.mutateJsonFileLocked(statePath, (data) => {
+  shared.mutateManagedProcesses((data) => {
     if (!data || typeof data !== 'object' || Array.isArray(data) || !Array.isArray(data.specs)) {
       data = _initialStateShape();
     }
@@ -865,7 +865,7 @@ function recordManagedSpec(spec, runtime, ctx) {
 function recordManagedBatch(items, ctx) {
   if (!Array.isArray(items) || items.length === 0) return;
   const statePath = _getStatePath();
-  shared.mutateJsonFileLocked(statePath, (data) => {
+  shared.mutateManagedProcesses((data) => {
     if (!data || typeof data !== 'object' || Array.isArray(data) || !Array.isArray(data.specs)) {
       data = _initialStateShape();
     }
@@ -886,7 +886,7 @@ function removeManagedSpec(name) {
   if (typeof name !== 'string' || name.length === 0) return;
   let killPid = null;
   const statePath = _getStatePath();
-  shared.mutateJsonFileLocked(statePath, (data) => {
+  shared.mutateManagedProcesses((data) => {
     if (!data || !Array.isArray(data.specs)) return data;
     const idx = data.specs.findIndex(s => s && s.name === name);
     if (idx < 0) return data;
@@ -1033,7 +1033,7 @@ async function runHealthcheck(spec) {
 // lock — this acquires its own.
 function _markHealthy(name, now) {
   const statePath = _getStatePath();
-  shared.mutateJsonFileLocked(statePath, (data) => {
+  shared.mutateManagedProcesses((data) => {
     if (!data || !Array.isArray(data.specs)) return data;
     const rec = data.specs.find(s => s && s.name === name);
     if (!rec) return data;
@@ -1334,7 +1334,7 @@ function _runManagedReconcile(opts) {
   const statePath = _getStatePath();
   const ttlPidsToKill = [];
   const survivors = []; // [{name, log_path}] post-mutation, used for log rotation + bootReconcile probes
-  shared.mutateJsonFileLocked(statePath, (data) => {
+  shared.mutateManagedProcesses((data) => {
     if (!data || typeof data !== 'object' || Array.isArray(data) || !Array.isArray(data.specs)) {
       stats.malformed++;
       return _initialStateShape();
@@ -1387,7 +1387,7 @@ function sweepManagedSpawn(opts) {
 // to (re)establish initial truth on engine restart).
 function _markBootProbe(name, result) {
   const statePath = _getStatePath();
-  shared.mutateJsonFileLocked(statePath, (data) => {
+  shared.mutateManagedProcesses((data) => {
     if (!data || !Array.isArray(data.specs)) return data;
     const rec = data.specs.find(s => s && s.name === name);
     if (!rec) return data;
@@ -1440,7 +1440,7 @@ function removeManagedSpecsForProject(projectName) {
   const statePath = _getStatePath();
   let toKill = [];
   let logPaths = [];
-  shared.mutateJsonFileLocked(statePath, (data) => {
+  shared.mutateManagedProcesses((data) => {
     if (!data || typeof data !== 'object' || !Array.isArray(data.specs)) {
       return _initialStateShape();
     }

package/engine/pipeline.js

@@ -8,7 +8,7 @@ const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
-const { safeJson, safeJsonNoRestore, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked, mutateWorkItems, slugify, formatTranscriptEntry, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, READ_ONLY_ROOT_TASK_TYPES, ENGINE_DEFAULTS, MINIONS_DIR } = shared;
+const { safeJson, safeJsonNoRestore, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked, mutateWorkItems, mutatePipelineRuns, slugify, formatTranscriptEntry, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, READ_ONLY_ROOT_TASK_TYPES, ENGINE_DEFAULTS, MINIONS_DIR } = shared;
 const routing = require('./routing');
 const http = require('http');
 const { parseCronExpr, shouldRunNow } = require('./scheduler');
@@ -90,18 +90,16 @@ function startRun(pipelineId, pipeline) {
   const run = { runId, pipelineId, startedAt: ts(), status: PIPELINE_STATUS.RUNNING, stages };
 
   let alreadyActive = false;
-  mutateJsonFileLocked(PIPELINE_RUNS_PATH, (data) => {
+  mutatePipelineRuns((data) => {
     if (!data[pipelineId]) data[pipelineId] = [];
-    // Guard: skip if there's already an active run (prevents race between ticks)
     if (data[pipelineId].some(r => r.status === PIPELINE_STATUS.RUNNING || r.status === PIPELINE_STATUS.PAUSED)) {
       alreadyActive = true;
       return data;
     }
-    // Keep last 10 runs per pipeline
     if (data[pipelineId].length >= 10) data[pipelineId] = data[pipelineId].slice(-9);
     data[pipelineId].push(run);
     return data;
-  }, { defaultValue: {} });
+  });
 
   if (alreadyActive) {
     log('info', `Pipeline ${pipelineId}: skipped startRun — active run already exists`);
@@ -118,14 +116,14 @@ function updateRunStage(pipelineId, runId, stageId, updates) {
       throw new Error(`updateRunStage: invalid status '${updates.status}' (expected one of: ${validStatuses.join('|')})`);
     }
   }
-  mutateJsonFileLocked(PIPELINE_RUNS_PATH, (data) => {
+  mutatePipelineRuns((data) => {
     const runs = data[pipelineId] || [];
     const run = runs.find(r => r.runId === runId);
     if (run && run.stages[stageId]) {
       Object.assign(run.stages[stageId], updates);
     }
     return data;
-  }, { defaultValue: {} });
+  });
 }
 
 function completeRun(pipelineId, runId, status) {
@@ -135,7 +133,7 @@ function completeRun(pipelineId, runId, status) {
   // never shows "in progress" for a stage inside a closed run.
   const TERMINAL = new Set([PIPELINE_STATUS.COMPLETED, PIPELINE_STATUS.FAILED, PIPELINE_STATUS.STOPPED]);
   const anomalies = [];
-  mutateJsonFileLocked(PIPELINE_RUNS_PATH, (data) => {
+  mutatePipelineRuns((data) => {
     const runs = data[pipelineId] || [];
     const run = runs.find(r => r.runId === runId);
     if (run) {
@@ -158,7 +156,7 @@ function completeRun(pipelineId, runId, status) {
       }
     }
     return data;
-  }, { defaultValue: {} });
+  });
   log('info', `Pipeline ${pipelineId}: run ${runId} → ${status}`);
   if (anomalies.length > 0) {
     log('warn', `Pipeline ${pipelineId}: run ${runId} closed COMPLETED with non-terminal stages [${anomalies.join(', ')}] — forced to completed`);

package/engine/scheduler.js

@@ -25,7 +25,7 @@ const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
 const routing = require('./routing');
-const { safeJson, safeWrite, mutateJsonFileLocked, ts, dateStamp, WI_STATUS, WORK_TYPE } = shared;
+const { safeJson, safeWrite, mutateJsonFileLocked, mutateScheduleRuns, ts, dateStamp, WI_STATUS, WORK_TYPE } = shared;
 
 const SCHEDULE_RUNS_PATH = path.join(shared.MINIONS_DIR, 'engine', 'schedule-runs.json');
 
@@ -194,10 +194,10 @@ function writeScheduleRunEntry(runs, scheduleId, workItemId) {
 
 function recordScheduleRun(scheduleId, workItemId) {
   let entry = null;
-  mutateJsonFileLocked(SCHEDULE_RUNS_PATH, (runs) => {
+  mutateScheduleRuns((runs) => {
     entry = writeScheduleRunEntry(runs, scheduleId, workItemId);
     return runs;
-  }, { defaultValue: {} });
+  });
   return entry;
 }
 
@@ -212,7 +212,7 @@ function discoverScheduledWork(config) {
 
   // Use file-locked mutation to prevent race conditions on rapid calls
   const work = [];
-  mutateJsonFileLocked(SCHEDULE_RUNS_PATH, (runs) => {
+  mutateScheduleRuns((runs) => {
     for (const sched of schedules) {
       if (!sched.id || !sched.cron || !sched.title) continue;
       if (sched.enabled === false) continue; // strict false check — undefined/null default to enabled per schema
@@ -236,7 +236,8 @@ function discoverScheduledWork(config) {
       // the double-fire window alongside the same-minute guard (W-mo3zu273f8tm).
       writeScheduleRunEntry(runs, sched.id, workItem.id);
     }
-  }, { defaultValue: {} });
+    return runs;
+  });
 
   return work;
 }

package/engine/shared.js

@@ -2744,6 +2744,69 @@ const WATCH_ACTION_TYPE = {
   RESUME_PLAN: 'resume-plan',
 };
 
+/**
+ * Phase 7 — small state file mutators. Each routes through the
+ * small-state-store, mirrors back to its JSON file, and emits a topic
+ * event on real writes. SQLite failure falls through to the legacy
+ * mutateJsonFileLocked path.
+ */
+function _smallStateMutator({ filePath, applyMutation, mirror, topic, defaultValue }) {
+  return (mutator) => {
+    try {
+      const store = require('./small-state-store');
+      const { wrote, result } = store[applyMutation]((obj) => mutator(obj) || obj);
+      if (wrote) {
+        try { store[mirror](filePath); } catch { /* mirror best-effort */ }
+        try { require('./db-events').emitStateEvent(topic); } catch { /* optional */ }
+      }
+      return result;
+    } catch (e) {
+      if (!e || !/SQLite unavailable|no such table|node:sqlite/.test(String(e.message))) throw e;
+    }
+    return mutateJsonFileLocked(filePath, (data) => {
+      if (data == null) data = defaultValue();
+      return mutator(data) || data;
+    }, {
+      defaultValue: defaultValue(),
+      onWrote: () => {
+        try { require('./db-events').emitStateEvent(topic); } catch { /* optional */ }
+      },
+    });
+  };
+}
+
+const mutateScheduleRuns = _smallStateMutator({
+  filePath: path.join(MINIONS_DIR, 'engine', 'schedule-runs.json'),
+  applyMutation: 'applyScheduleRunsMutation',
+  mirror: '_mirrorScheduleRunsJson',
+  topic: 'schedule_runs',
+  defaultValue: () => ({}),
+});
+
+const mutatePipelineRuns = _smallStateMutator({
+  filePath: path.join(MINIONS_DIR, 'engine', 'pipeline-runs.json'),
+  applyMutation: 'applyPipelineRunsMutation',
+  mirror: '_mirrorPipelineRunsJson',
+  topic: 'pipeline_runs',
+  defaultValue: () => ({}),
+});
+
+const mutateManagedProcesses = _smallStateMutator({
+  filePath: path.join(MINIONS_DIR, 'engine', 'managed-processes.json'),
+  applyMutation: 'applyManagedProcessesMutation',
+  mirror: '_mirrorManagedProcessesJson',
+  topic: 'managed_processes',
+  defaultValue: () => ({ specs: [] }),
+});
+
+const mutateWorktreePool = _smallStateMutator({
+  filePath: path.join(MINIONS_DIR, 'engine', 'worktree-pool.json'),
+  applyMutation: 'applyWorktreePoolMutation',
+  mirror: '_mirrorWorktreePoolJson',
+  topic: 'worktree_pool',
+  defaultValue: () => ({ entries: [] }),
+});
+
 /**
  * Route a watches mutation through the SQL store. Same shape as
  * mutateWorkItems / mutatePullRequests: mutator receives the watches
@@ -5262,7 +5325,7 @@ module.exports = {
   runtimeConfigWarnings,
   projectWorkSourceWarnings,
   backfillProjectWorkSourceDefaults,
-  WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, WORKTREE_REQUIRING_TYPES, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, PR_PENDING_REASON, DISPATCH_RESULT, mutateMetrics, mutateWatches, trackReviewMetric, queuePlanToPrd, extractPlanDeclaredProject,
+  WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, WORKTREE_REQUIRING_TYPES, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, PR_PENDING_REASON, DISPATCH_RESULT, mutateMetrics, mutateWatches, mutateScheduleRuns, mutatePipelineRuns, mutateManagedProcesses, mutateWorktreePool, trackReviewMetric, queuePlanToPrd, extractPlanDeclaredProject,
   WATCH_STATUS, WATCH_TARGET_TYPE, WATCH_CONDITION, WATCH_ABSOLUTE_CONDITIONS, WATCH_ACTION_TYPE,
   WATCH_STALLED_DEFAULT_TICKS, WATCH_STUCK_STAGE_DEFAULT_TICKS,
   PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, AGENT_STATUS,

package/engine/small-state-store.js

@@ -0,0 +1,560 @@
+// engine/small-state-store.js — SQL-backed implementations for the
+// four Phase 7 small state files:
+//
+//   schedule-runs.json      <-> schedule_runs       (object → row-per-id)
+//   pipeline-runs.json      <-> pipeline_runs       ({id:[runs]} → row-per-run)
+//   managed-processes.json  <-> managed_processes   ({specs:[]} → row-per-name)
+//   worktree-pool.json      <-> worktree_pool       ({entries:[]} → row-per-entry)
+//
+// They share enough infrastructure (content-hash fingerprint, mirror
+// writer, withTransaction wiring) that it's clearer to keep them in one
+// module — each store is small, and the JSON-shape transformations are
+// the only per-file divergence.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+function _toMs(v) {
+  if (v == null) return null;
+  if (typeof v === 'number') return Number.isFinite(v) ? v : null;
+  const parsed = Date.parse(v);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function _fileContentHash(filePath) {
+  try {
+    const buf = fs.readFileSync(filePath);
+    return crypto.createHash('sha1').update(buf).digest('hex');
+  }
+  catch { return null; }
+}
+
+function _readJson(filePath) {
+  let raw;
+  try { raw = fs.readFileSync(filePath, 'utf8'); }
+  catch { return null; }
+  try { return JSON.parse(raw); }
+  catch (e) {
+    try {
+      // eslint-disable-next-line no-console
+      console.warn(`[small-state-store] corrupt JSON in ${filePath}: ${e.message}`);
+    } catch { /* console wrapped */ }
+    return null;
+  }
+}
+
+function _resolveFilePath(rel) {
+  const shared = require('./shared');
+  return path.join(shared.MINIONS_DIR, 'engine', rel);
+}
+
+// ─── schedule_runs ──────────────────────────────────────────────────────────
+// Shape: { [scheduleId]: { lastRun, lastWorkItemId, lastResult, lastCompletedAt } }
+// SQL:   row per scheduleId, data = the value blob.
+
+let _scheduleRunsHash = null;
+
+function _hydrateScheduleRuns(db) {
+  const fp = _resolveFilePath('schedule-runs.json');
+  const raw = _readJson(fp) || {};
+  db.prepare('DELETE FROM schedule_runs').run();
+  const now = Date.now();
+  const ins = db.prepare('INSERT INTO schedule_runs (schedule_id, data, updated_at) VALUES (?, ?, ?) ON CONFLICT(schedule_id) DO NOTHING');
+  for (const [id, value] of Object.entries(raw)) {
+    ins.run(id, JSON.stringify(value), now);
+  }
+}
+
+function _resyncScheduleRunsIfDiverged(db) {
+  const fp = _resolveFilePath('schedule-runs.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_scheduleRunsHash != null && currentHash === _scheduleRunsHash) return;
+  if (_scheduleRunsHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM schedule_runs LIMIT 1').get();
+    if (sqlHas) {
+      _scheduleRunsHash = currentHash;
+      return;
+    }
+  }
+  _hydrateScheduleRuns(db);
+  _scheduleRunsHash = currentHash;
+}
+
+function _readScheduleRunsFromSql(db) {
+  const rows = db.prepare('SELECT schedule_id, data FROM schedule_runs').all();
+  const out = {};
+  for (const row of rows) {
+    try { out[row.schedule_id] = JSON.parse(row.data); }
+    catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+function readScheduleRuns() {
+  const { getDb } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch { return _readJson(_resolveFilePath('schedule-runs.json')) || {}; }
+  _resyncScheduleRunsIfDiverged(db);
+  const out = _readScheduleRunsFromSql(db);
+  if (Object.keys(out).length === 0) {
+    const fallback = _readJson(_resolveFilePath('schedule-runs.json'));
+    if (fallback && Object.keys(fallback).length > 0) return fallback;
+    return {};
+  }
+  return out;
+}
+
+function applyScheduleRunsMutation(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, () => {
+    _resyncScheduleRunsIfDiverged(db);
+    const before = _readScheduleRunsFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+    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 schedule_runs (schedule_id, data, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(schedule_id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM schedule_runs WHERE schedule_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 _mirrorScheduleRunsJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const obj = _readScheduleRunsFromSql(getDb());
+    const target = filePath || _resolveFilePath('schedule-runs.json');
+    shared.safeWrite(target, obj);
+    const h = _fileContentHash(target);
+    if (h != null) _scheduleRunsHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
+// ─── pipeline_runs ──────────────────────────────────────────────────────────
+// Shape: { [pipelineId]: [run, run, ...] }
+// SQL:   row per (pipelineId, runId). Reconstruct on read by grouping.
+
+let _pipelineRunsHash = null;
+
+function _hydratePipelineRuns(db) {
+  const fp = _resolveFilePath('pipeline-runs.json');
+  const raw = _readJson(fp) || {};
+  db.prepare('DELETE FROM pipeline_runs').run();
+  const now = Date.now();
+  const ins = db.prepare(`
+    INSERT INTO pipeline_runs (pipeline_id, run_id, status, started_at, data, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT(pipeline_id, run_id) DO NOTHING
+  `);
+  for (const [pipelineId, runs] of Object.entries(raw)) {
+    if (!Array.isArray(runs)) continue;
+    for (const run of runs) {
+      if (!run || !run.runId) continue;
+      ins.run(pipelineId, String(run.runId), run.status || null, _toMs(run.startedAt), JSON.stringify(run), now);
+    }
+  }
+}
+
+function _resyncPipelineRunsIfDiverged(db) {
+  const fp = _resolveFilePath('pipeline-runs.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_pipelineRunsHash != null && currentHash === _pipelineRunsHash) return;
+  if (_pipelineRunsHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM pipeline_runs LIMIT 1').get();
+    if (sqlHas) { _pipelineRunsHash = currentHash; return; }
+  }
+  _hydratePipelineRuns(db);
+  _pipelineRunsHash = currentHash;
+}
+
+function _readPipelineRunsFromSql(db) {
+  const rows = db.prepare('SELECT pipeline_id, data FROM pipeline_runs ORDER BY pipeline_id, rowid').all();
+  const out = {};
+  for (const row of rows) {
+    try {
+      const run = JSON.parse(row.data);
+      if (!out[row.pipeline_id]) out[row.pipeline_id] = [];
+      out[row.pipeline_id].push(run);
+    } catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+function readPipelineRuns() {
+  const { getDb } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch { return _readJson(_resolveFilePath('pipeline-runs.json')) || {}; }
+  _resyncPipelineRunsIfDiverged(db);
+  const out = _readPipelineRunsFromSql(db);
+  if (Object.keys(out).length === 0) {
+    const fallback = _readJson(_resolveFilePath('pipeline-runs.json'));
+    if (fallback && Object.keys(fallback).length > 0) return fallback;
+    return {};
+  }
+  return out;
+}
+
+function applyPipelineRunsMutation(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, () => {
+    _resyncPipelineRunsIfDiverged(db);
+    const before = _readPipelineRunsFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+
+    // Index by (pipelineId, runId).
+    const flatten = (obj) => {
+      const out = new Map();
+      for (const [pid, runs] of Object.entries(obj || {})) {
+        if (!Array.isArray(runs)) continue;
+        for (const run of runs) {
+          if (!run || !run.runId) continue;
+          out.set(`${pid}|${run.runId}`, { pid, run });
+        }
+      }
+      return out;
+    };
+    const beforeMap = flatten(beforeSnap);
+    const afterMap = flatten(after);
+
+    const now = Date.now();
+    const upsert = db.prepare(`
+      INSERT INTO pipeline_runs (pipeline_id, run_id, status, started_at, data, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(pipeline_id, run_id) DO UPDATE SET
+        status = excluded.status,
+        started_at = excluded.started_at,
+        data = excluded.data,
+        updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM pipeline_runs WHERE pipeline_id = ? AND run_id = ?');
+    let wrote = false;
+    for (const [key, { pid, run }] of afterMap) {
+      const prev = beforeMap.get(key);
+      if (!prev || JSON.stringify(prev.run) !== JSON.stringify(run)) {
+        upsert.run(pid, String(run.runId), run.status || null, _toMs(run.startedAt), JSON.stringify(run), now);
+        wrote = true;
+      }
+    }
+    for (const [key, { pid, run }] of beforeMap) {
+      if (!afterMap.has(key)) { del.run(pid, String(run.runId)); wrote = true; }
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorPipelineRunsJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const obj = _readPipelineRunsFromSql(getDb());
+    const target = filePath || _resolveFilePath('pipeline-runs.json');
+    shared.safeWrite(target, obj);
+    const h = _fileContentHash(target);
+    if (h != null) _pipelineRunsHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
+// ─── managed_processes ─────────────────────────────────────────────────────
+// Shape: { specs: [ {name, ...}, ... ] }
+// SQL:   row per name.
+
+let _managedProcessesHash = null;
+
+function _hydrateManagedProcesses(db) {
+  const fp = _resolveFilePath('managed-processes.json');
+  const raw = _readJson(fp) || {};
+  db.prepare('DELETE FROM managed_processes').run();
+  const specs = Array.isArray(raw.specs) ? raw.specs : [];
+  const now = Date.now();
+  const ins = db.prepare('INSERT INTO managed_processes (name, data, updated_at) VALUES (?, ?, ?) ON CONFLICT(name) DO NOTHING');
+  for (const spec of specs) {
+    if (!spec || !spec.name) continue;
+    ins.run(String(spec.name), JSON.stringify(spec), now);
+  }
+}
+
+function _resyncManagedProcessesIfDiverged(db) {
+  const fp = _resolveFilePath('managed-processes.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_managedProcessesHash != null && currentHash === _managedProcessesHash) return;
+  if (_managedProcessesHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM managed_processes LIMIT 1').get();
+    if (sqlHas) { _managedProcessesHash = currentHash; return; }
+  }
+  _hydrateManagedProcesses(db);
+  _managedProcessesHash = currentHash;
+}
+
+function _readManagedProcessesFromSql(db) {
+  const rows = db.prepare('SELECT data FROM managed_processes ORDER BY rowid').all();
+  const specs = [];
+  for (const row of rows) {
+    try { specs.push(JSON.parse(row.data)); } catch { /* skip */ }
+  }
+  return { specs };
+}
+
+function readManagedProcesses() {
+  const { getDb } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch { return _readJson(_resolveFilePath('managed-processes.json')) || { specs: [] }; }
+  _resyncManagedProcessesIfDiverged(db);
+  const out = _readManagedProcessesFromSql(db);
+  if (out.specs.length === 0) {
+    const fallback = _readJson(_resolveFilePath('managed-processes.json'));
+    if (fallback && Array.isArray(fallback.specs) && fallback.specs.length > 0) return fallback;
+    return { specs: [] };
+  }
+  return out;
+}
+
+function applyManagedProcessesMutation(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, () => {
+    _resyncManagedProcessesIfDiverged(db);
+    const before = _readManagedProcessesFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+    if (!after || !Array.isArray(after.specs)) after.specs = [];
+
+    const indexByName = (arr) => {
+      const out = new Map();
+      for (const spec of arr) {
+        if (spec && spec.name) out.set(String(spec.name), spec);
+      }
+      return out;
+    };
+    const beforeMap = indexByName(beforeSnap.specs);
+    const afterMap = indexByName(after.specs);
+
+    const now = Date.now();
+    const upsert = db.prepare(`
+      INSERT INTO managed_processes (name, data, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(name) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM managed_processes WHERE name = ?');
+    let wrote = false;
+    for (const [name, spec] of afterMap) {
+      const prev = beforeMap.get(name);
+      if (!prev || JSON.stringify(prev) !== JSON.stringify(spec)) {
+        upsert.run(name, JSON.stringify(spec), now);
+        wrote = true;
+      }
+    }
+    for (const [name] of beforeMap) {
+      if (!afterMap.has(name)) { del.run(name); wrote = true; }
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorManagedProcessesJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const obj = _readManagedProcessesFromSql(getDb());
+    const target = filePath || _resolveFilePath('managed-processes.json');
+    shared.safeWrite(target, obj);
+    const h = _fileContentHash(target);
+    if (h != null) _managedProcessesHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
+// ─── worktree_pool ─────────────────────────────────────────────────────────
+// Shape: { entries: [ {path, ...}, ... ] }
+// SQL:   row per entry, keyed by the worktree path (unique).
+
+let _worktreePoolHash = null;
+
+function _entryKey(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  return entry.path || entry.id || null;
+}
+
+function _hydrateWorktreePool(db) {
+  const fp = _resolveFilePath('worktree-pool.json');
+  const raw = _readJson(fp) || {};
+  db.prepare('DELETE FROM worktree_pool').run();
+  const entries = Array.isArray(raw.entries) ? raw.entries : [];
+  const now = Date.now();
+  const ins = db.prepare('INSERT INTO worktree_pool (entry_id, data, updated_at) VALUES (?, ?, ?) ON CONFLICT(entry_id) DO NOTHING');
+  for (const entry of entries) {
+    const id = _entryKey(entry);
+    if (!id) continue;
+    ins.run(String(id), JSON.stringify(entry), now);
+  }
+}
+
+function _resyncWorktreePoolIfDiverged(db) {
+  const fp = _resolveFilePath('worktree-pool.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_worktreePoolHash != null && currentHash === _worktreePoolHash) return;
+  if (_worktreePoolHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM worktree_pool LIMIT 1').get();
+    if (sqlHas) { _worktreePoolHash = currentHash; return; }
+  }
+  _hydrateWorktreePool(db);
+  _worktreePoolHash = currentHash;
+}
+
+function _readWorktreePoolFromSql(db) {
+  const rows = db.prepare('SELECT data FROM worktree_pool ORDER BY rowid').all();
+  const entries = [];
+  for (const row of rows) {
+    try { entries.push(JSON.parse(row.data)); } catch { /* skip */ }
+  }
+  return { entries };
+}
+
+function readWorktreePool() {
+  const { getDb } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch { return _readJson(_resolveFilePath('worktree-pool.json')) || { entries: [] }; }
+  _resyncWorktreePoolIfDiverged(db);
+  const out = _readWorktreePoolFromSql(db);
+  if (out.entries.length === 0) {
+    const fallback = _readJson(_resolveFilePath('worktree-pool.json'));
+    if (fallback && Array.isArray(fallback.entries) && fallback.entries.length > 0) return fallback;
+    return { entries: [] };
+  }
+  return out;
+}
+
+function applyWorktreePoolMutation(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, () => {
+    _resyncWorktreePoolIfDiverged(db);
+    const before = _readWorktreePoolFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+    if (!after || !Array.isArray(after.entries)) after.entries = [];
+
+    const indexByKey = (arr) => {
+      const out = new Map();
+      for (const e of arr) {
+        const k = _entryKey(e);
+        if (k) out.set(String(k), e);
+      }
+      return out;
+    };
+    const beforeMap = indexByKey(beforeSnap.entries);
+    const afterMap = indexByKey(after.entries);
+
+    const now = Date.now();
+    const upsert = db.prepare(`
+      INSERT INTO worktree_pool (entry_id, data, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(entry_id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM worktree_pool WHERE entry_id = ?');
+    let wrote = false;
+    for (const [id, entry] of afterMap) {
+      const prev = beforeMap.get(id);
+      if (!prev || JSON.stringify(prev) !== JSON.stringify(entry)) {
+        upsert.run(id, JSON.stringify(entry), now);
+        wrote = true;
+      }
+    }
+    for (const [id] of beforeMap) {
+      if (!afterMap.has(id)) { del.run(id); wrote = true; }
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorWorktreePoolJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const obj = _readWorktreePoolFromSql(getDb());
+    const target = filePath || _resolveFilePath('worktree-pool.json');
+    shared.safeWrite(target, obj);
+    const h = _fileContentHash(target);
+    if (h != null) _worktreePoolHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
+// ─── Test seam ─────────────────────────────────────────────────────────────
+
+function _resetAllForTest() {
+  const { getDb } = require('./db');
+  try {
+    const db = getDb();
+    db.exec('DELETE FROM schedule_runs');
+    db.exec('DELETE FROM pipeline_runs');
+    db.exec('DELETE FROM managed_processes');
+    db.exec('DELETE FROM worktree_pool');
+  } catch { /* not initialized */ }
+  _scheduleRunsHash = null;
+  _pipelineRunsHash = null;
+  _managedProcessesHash = null;
+  _worktreePoolHash = null;
+}
+
+module.exports = {
+  // schedule_runs
+  readScheduleRuns,
+  applyScheduleRunsMutation,
+  _mirrorScheduleRunsJson,
+  // pipeline_runs
+  readPipelineRuns,
+  applyPipelineRunsMutation,
+  _mirrorPipelineRunsJson,
+  // managed_processes
+  readManagedProcesses,
+  applyManagedProcessesMutation,
+  _mirrorManagedProcessesJson,
+  // worktree_pool
+  readWorktreePool,
+  applyWorktreePoolMutation,
+  _mirrorWorktreePoolJson,
+  // test seam
+  _resetAllForTest,
+};

package/engine/worktree-pool.js

@@ -61,12 +61,16 @@ function readPool() {
 }
 
 function mutateWorktreePool(mutator) {
-  return mutateJsonFileLocked(getPoolPath(), (data) => {
+  // Phase 7: route through shared.mutateWorktreePool (SQL-backed store +
+  // JSON mirror). Defensive wrappers around `data.entries` kept for the
+  // legacy fallback path inside the helper (when SQLite is unavailable
+  // and we fall through to mutateJsonFileLocked).
+  return shared.mutateWorktreePool((data) => {
     if (!data || typeof data !== 'object' || Array.isArray(data)) data = { entries: [] };
     if (!Array.isArray(data.entries)) data.entries = [];
     const next = mutator(data);
     return next === undefined ? data : next;
-  }, { defaultValue: { entries: [] }, skipWriteIfUnchanged: true });
+  });
 }
 
 /**

package/package.json

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