@yemi33/minions 0.1.2379 → 0.1.2380

package/engine/small-state-store.js

@@ -1,12 +1,4 @@
-// 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 transaction and JSON-shape transformation infrastructure.
+// SQL stores for low-traffic runtime state.
 
 function _toMs(v) {
   if (v == null) return null;
@@ -15,6 +7,47 @@ function _toMs(v) {
   return Number.isFinite(parsed) ? parsed : null;
 }
 
+const ENGINE_STATE_MARKER = 'engine_state';
+
+function _readEngineStateFromSql(db) {
+  const row = db.prepare('SELECT value FROM state_markers WHERE key = ?').get(ENGINE_STATE_MARKER);
+  if (!row) return {};
+  try {
+    const state = JSON.parse(row.value);
+    return state && typeof state === 'object' && !Array.isArray(state) ? state : {};
+  } catch {
+    return {};
+  }
+}
+
+function readEngineState() {
+  const { getDb } = require('./db');
+  return _readEngineStateFromSql(getDb());
+}
+
+function applyEngineStateMutation(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, () => {
+    const before = _readEngineStateFromSql(db);
+    const next = mutator(JSON.parse(JSON.stringify(before)));
+    const after = next === undefined ? before : next;
+    if (!after || typeof after !== 'object' || Array.isArray(after)) {
+      return { wrote: false, result: before };
+    }
+    if (JSON.stringify(before) === JSON.stringify(after)) return { wrote: false, result: after };
+    db.prepare(`
+      INSERT INTO state_markers (key, value, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+    `).run(ENGINE_STATE_MARKER, JSON.stringify(after), Date.now());
+    return { wrote: true, result: after };
+  });
+}
+
 // ─── schedule_runs ──────────────────────────────────────────────────────────
 // Shape: { [scheduleId]: { lastRun, lastWorkItemId, lastResult, lastCompletedAt } }
 // SQL:   row per scheduleId, data = the value blob.
@@ -618,8 +651,10 @@ function applyPendingRebasesMutation(mutator) {
 // Shape: [ { id, sessionId, title, _promptHash, lastActiveAt, ... }, ... ]
 // SQL:   row per id (each entry has a unique `id` tab key).
 
+const CC_GLOBAL_SESSION_ID = '__global__';
+
 function _readCcSessionsFromSql(db) {
-  const rows = db.prepare('SELECT data FROM cc_sessions ORDER BY updated_at, id').all();
+  const rows = db.prepare('SELECT data FROM cc_sessions WHERE id <> ? ORDER BY updated_at, id').all(CC_GLOBAL_SESSION_ID);
   const out = [];
   for (const row of rows) {
     try { out.push(JSON.parse(row.data)); }
@@ -671,6 +706,46 @@ function applyCcSessionsMutation(mutator) {
   });
 }
 
+function readCcGlobalSession() {
+  const { getDb } = require('./db');
+  const row = getDb().prepare('SELECT data FROM cc_sessions WHERE id = ?').get(CC_GLOBAL_SESSION_ID);
+  if (!row) return null;
+  try {
+    const session = JSON.parse(row.data);
+    return session && typeof session === 'object' && !Array.isArray(session) ? session : null;
+  } catch {
+    return null;
+  }
+}
+
+function applyCcGlobalSessionMutation(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, () => {
+    const row = db.prepare('SELECT data FROM cc_sessions WHERE id = ?').get(CC_GLOBAL_SESSION_ID);
+    let before = {};
+    try {
+      const parsed = row ? JSON.parse(row.data) : {};
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) before = parsed;
+    } catch { /* replace malformed state */ }
+    const next = mutator(JSON.parse(JSON.stringify(before)));
+    const after = next === undefined ? before : next;
+    if (!after || typeof after !== 'object' || Array.isArray(after)) {
+      return { wrote: false, result: before };
+    }
+    if (JSON.stringify(before) === JSON.stringify(after)) return { wrote: false, result: after };
+    db.prepare(`
+      INSERT INTO cc_sessions (id, data, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `).run(CC_GLOBAL_SESSION_ID, JSON.stringify(after), Date.now());
+    return { wrote: true, result: after };
+  });
+}
+
 // ─── doc_sessions ──────────────────────────────────────────────────────────
 // Shape: { [filePath]: { sessionId, lastActiveAt, turnCount, ... } }
 // SQL:   row per filePath key.
@@ -728,6 +803,8 @@ function applyDocSessionsMutation(mutator) {
 }
 
 module.exports = {
+  readEngineState,
+  applyEngineStateMutation,
   // schedule_runs
   readScheduleRuns,
   applyScheduleRunsMutation,
@@ -758,6 +835,8 @@ module.exports = {
   // cc_sessions
   readCcSessions,
   applyCcSessionsMutation,
+  readCcGlobalSession,
+  applyCcGlobalSessionMutation,
   // doc_sessions
   readDocSessions,
   applyDocSessionsMutation,

package/engine/state-operations.js

@@ -83,6 +83,11 @@ function importLegacyJson(sourceRoot) {
     imported[fn] = (imported[fn] || 0) + 1;
   };
 
+  replace(
+    './small-state-store',
+    'applyEngineStateMutation',
+    _readJson(path.join(root, 'engine', 'state.json'), 'object'),
+  );
   replace('./dispatch-store', 'applyDispatchMutation', _readJson(path.join(root, 'engine', 'dispatch.json'), 'object'));
   replace('./metrics-store', 'applyMetricsMutation', _readJson(path.join(root, 'engine', 'metrics.json'), 'object'));
   replace('./watches-store', 'applyWatchesMutation', _readJson(path.join(root, 'engine', 'watches.json'), 'array'));
@@ -103,6 +108,11 @@ function importLegacyJson(sourceRoot) {
   for (const [filename, fn, shape] of small) {
     replace('./small-state-store', fn, _readJson(path.join(root, 'engine', filename), shape));
   }
+  replace(
+    './small-state-store',
+    'applyCcGlobalSessionMutation',
+    _readJson(path.join(root, 'engine', 'cc-session.json'), 'object'),
+  );
 
   const workItemsStore = require('./work-items-store');
   const pullRequestsStore = require('./pull-requests-store');
@@ -112,6 +122,11 @@ function importLegacyJson(sourceRoot) {
       workItemsStore.applyWorkItemsMutation(scope, () => workItems);
       imported.workItemScopes = (imported.workItemScopes || 0) + 1;
     }
+    const archivedWorkItems = _readJson(path.join(dir, 'work-items-archive.json'), 'array');
+    if (archivedWorkItems) {
+      workItemsStore.replaceArchivedWorkItems(scope, archivedWorkItems);
+      imported.archivedWorkItemScopes = (imported.archivedWorkItemScopes || 0) + 1;
+    }
     const pullRequests = _readJson(path.join(dir, 'pull-requests.json'), 'array');
     if (pullRequests) {
       pullRequestsStore.applyPullRequestsMutation(scope, () => pullRequests);
@@ -133,10 +148,7 @@ function importLegacyJson(sourceRoot) {
     try { files = fs.readdirSync(dir).filter(name => name.endsWith('.json')); } catch { continue; }
     for (const filename of files) {
       const prd = _readJson(path.join(dir, filename), 'object');
-      const target = archived
-        ? path.join(require('./shared').MINIONS_DIR, 'prd', 'archive', filename)
-        : path.join(require('./shared').MINIONS_DIR, 'prd', filename);
-      prdStore.writePrd(target, prd);
+      prdStore.writePrd(filename, prd, { archived });
       imported.prds = (imported.prds || 0) + 1;
     }
   }

package/engine/stdio-timestamps.js

@@ -5,7 +5,7 @@
  *
  * Required at the very top of dashboard.js and engine.js (and supervisor.js).
  * Without this, "what was the dashboard doing at 01:01:56?" requires fishing
- * through log.json's adjacent engine entries and hoping timing lines up.
+ * through adjacent engine-log entries and hoping timing lines up.
  *
  * The wrap is a no-op when MINIONS_NO_STDIO_TIMESTAMPS is truthy (used by
  * tests that compare console output verbatim).

package/engine/timeout.js

@@ -13,7 +13,7 @@ const shared = require('./shared');
 const queries = require('./queries');
 const steering = require('./steering');
 
-const { safeRead, safeWrite, safeJson, mutateJsonFileLocked, getProjects, projectWorkItemsPath, log, ts,
+const { safeRead, safeWrite, safeJson, mutateWorkItems, getProjects, log, ts,
   ENGINE_DEFAULTS, ENGINE_DIR, WI_STATUS, WORK_TYPE, DISPATCH_RESULT, AGENT_STATUS, FAILURE_CLASS } = shared;
 const { getDispatch, getAgentStatus } = queries;
 const AGENTS_DIR = queries.AGENTS_DIR;
@@ -984,21 +984,14 @@ function checkTimeouts(config) {
     });
   }
 
-  // Agent status is now derived from dispatch.json at read time (getAgentStatus).
+  // Agent status is derived from dispatch state at read time (getAgentStatus).
   // No reconcile sweep needed — dispatch IS the source of truth.
 
   // Reconcile: find work items stuck in "dispatched" with no matching active dispatch
   const activeKeys = new Set((dispatchData.active || []).map(d => d.meta?.dispatchKey).filter(Boolean));
-  const allWiPaths = [path.join(MINIONS_DIR, 'work-items.json')];
-  for (const project of getProjects(config)) {
-    allWiPaths.push(projectWorkItemsPath(project));
-  }
-  for (const wiPath of allWiPaths) {
-    // skipWriteIfUnchanged is critical — checkTimeouts runs every tick, and
-    // without this gate the file's mtime updates on every call (no real
-    // change), tripping the cli.js work-items.json watcher → triggering tick
-    // → calling checkTimeouts → ... a 5-6s loop of "File change detected".
-    mutateJsonFileLocked(wiPath, (items) => {
+  const workItemScopes = ['central', ...getProjects(config)];
+  for (const scope of workItemScopes) {
+    mutateWorkItems(scope, (items) => {
       if (!items || !Array.isArray(items)) return items;
       let changed = false;
       for (const item of items) {

package/engine/watch-actions.js

@@ -32,7 +32,7 @@ const { URL } = require('url');
 const shared = require('./shared');
 const {
   WATCH_ACTION_TYPE, WI_STATUS, WORK_TYPE, DONE_STATUSES, PLAN_STATUS,
-  log, ts, uid, mutateWorkItems, mutateJsonFileLocked, projectWorkItemsPath,
+  log, ts, uid, mutateWorkItems,
 } = shared;
 
 // BUG-H10 (P-h10-watch-flood): statuses that mean the dispatched WI is still
@@ -387,7 +387,7 @@ registerActionType(WATCH_ACTION_TYPE.NOTIFY, {
   },
 });
 
-// dispatch-work-item — append a new WI to the project (or central) work-items.json.
+// dispatch-work-item — append a new WI to the project or central scope.
 registerActionType(WATCH_ACTION_TYPE.DISPATCH_WORK_ITEM, {
   label: 'Dispatch Work Item',
   description: 'Create and queue a new work item when the watch fires. Templated params support {{target}}, {{condition}}, {{prNumber}}, {{workItemId}}, etc.',
@@ -405,9 +405,7 @@ registerActionType(WATCH_ACTION_TYPE.DISPATCH_WORK_ITEM, {
     if (!title) return { ok: false, summary: 'dispatch-work-item: title is required' };
 
     const project = p.project || watch.project || null;
-    const wiPath = project
-      ? projectWorkItemsPath({ name: project })
-      : path.join(shared.MINIONS_DIR, 'work-items.json');
+    const scope = project || 'central';
 
     const id = 'W-' + uid();
     const item = {
@@ -437,7 +435,7 @@ registerActionType(WATCH_ACTION_TYPE.DISPATCH_WORK_ITEM, {
 
     let appended = false;
     let dedupedAgainstId = null;
-    mutateWorkItems(wiPath, (items) => {
+    mutateWorkItems(scope, (items) => {
       const existing = items.find(it =>
         it
         && it.meta
@@ -663,10 +661,10 @@ registerActionType(WATCH_ACTION_TYPE.MINIONS_API, {
   },
 });
 
-// cancel-work-item — flip a WI to CANCELLED across project + central files.
+// cancel-work-item — flip a WI to CANCELLED across project + central scopes.
 registerActionType(WATCH_ACTION_TYPE.CANCEL_WORK_ITEM, {
   label: 'Cancel Work Item',
-  description: 'Cancel a work item by ID. Searches the central work-items.json plus all project work-items.json files.',
+  description: 'Cancel a work item by ID. Searches central and project scopes.',
   params: [
     { key: 'id', required: true, description: 'Work item ID to cancel.' },
     { key: 'reason', required: false, description: 'Reason recorded on the item (defaults to "watch:<id>").' },
@@ -677,17 +675,17 @@ registerActionType(WATCH_ACTION_TYPE.CANCEL_WORK_ITEM, {
     if (!targetId) return { ok: false, summary: 'cancel-work-item: id is required' };
 
     const reason = p.reason || `watch:${watch.id}`;
-    const candidates = [path.join(shared.MINIONS_DIR, 'work-items.json')];
+    const candidates = ['central'];
     try {
       const config = shared.safeJson(path.join(shared.MINIONS_DIR, 'config.json')) || {};
       for (const proj of (config.projects || [])) {
-        if (proj && proj.name) candidates.push(projectWorkItemsPath(proj));
+        if (proj && proj.name) candidates.push(proj);
       }
     } catch { /* config optional */ }
 
     let cancelled = false;
-    for (const wiPath of candidates) {
-      mutateWorkItems(wiPath, (items) => {
+    for (const scope of candidates) {
+      mutateWorkItems(scope, (items) => {
         const it = items.find(i => i && i.id === targetId);
         if (!it) return items;
         if (DONE_STATUSES.has(it.status) || it.status === WI_STATUS.CANCELLED) return items;
@@ -730,10 +728,10 @@ registerActionType(WATCH_ACTION_TYPE.TRIGGER_PIPELINE, {
   },
 });
 
-// archive-plan — mark the PRD JSON file as archived (status=archived, archivedAt=now).
+// archive-plan — mark the PRD as archived.
 registerActionType(WATCH_ACTION_TYPE.ARCHIVE_PLAN, {
   label: 'Archive Plan',
-  description: 'Mark a PRD/plan as archived. Sets status="archived" and archivedAt on the PRD JSON.',
+  description: 'Mark a PRD/plan as archived. Sets status="archived" and archivedAt.',
   params: [
     { key: 'planFile', required: false, description: 'PRD .json filename (defaults to {{planFile}} from trigger context).' },
   ],
@@ -741,16 +739,16 @@ registerActionType(WATCH_ACTION_TYPE.ARCHIVE_PLAN, {
     const p = ctx.params || {};
     const planFile = String(p.planFile || ctx.planFile || '').trim();
     if (!planFile) return { ok: false, summary: 'archive-plan: planFile is required' };
-    const prdPath = path.join(shared.MINIONS_DIR, 'prd', planFile);
-    if (!shared.safeJsonNoRestore(prdPath)) return { ok: false, summary: `archive-plan: ${planFile} not found` };
+    const store = require('./prd-store');
+    if (!store.readPrd(planFile)) return { ok: false, summary: `archive-plan: ${planFile} not found` };
     let updated = false;
-    mutateJsonFileLocked(prdPath, (data) => {
+    store.mutatePrd(planFile, (data) => {
       if (!data || typeof data !== 'object' || Array.isArray(data)) data = {};
       data.status = 'archived';
       data.archivedAt = ts();
       updated = true;
       return data;
-    }, { defaultValue: {} });
+    });
     return updated
       ? { ok: true, summary: `archived plan ${planFile}` }
       : { ok: false, summary: `archive-plan: ${planFile} write failed` };
@@ -768,16 +766,16 @@ registerActionType(WATCH_ACTION_TYPE.RESUME_PLAN, {
     const p = ctx.params || {};
     const planFile = String(p.planFile || ctx.planFile || '').trim();
     if (!planFile) return { ok: false, summary: 'resume-plan: planFile is required' };
-    const prdPath = path.join(shared.MINIONS_DIR, 'prd', planFile);
-    if (!shared.safeJsonNoRestore(prdPath)) return { ok: false, summary: `resume-plan: ${planFile} not found` };
+    const store = require('./prd-store');
+    if (!store.readPrd(planFile)) return { ok: false, summary: `resume-plan: ${planFile} not found` };
     let updated = false;
-    mutateJsonFileLocked(prdPath, (data) => {
+    store.mutatePrd(planFile, (data) => {
       if (!data || typeof data !== 'object' || Array.isArray(data)) data = {};
       data.status = PLAN_STATUS.ACTIVE;
       delete data.planStale;
       updated = true;
       return data;
-    }, { defaultValue: {} });
+    });
     return updated
       ? { ok: true, summary: `resumed plan ${planFile}` }
       : { ok: false, summary: `resume-plan: ${planFile} write failed` };

package/engine/watches-store.js

@@ -1,4 +1,4 @@
-// engine/watches-store.js — SQL-backed implementation of engine/watches.json.
+// engine/watches-store.js — SQL-backed watches.
 //
 // A single SQL table (no per-scope split), with a diff-then-apply mutator.
 //

package/engine/watches.js

@@ -61,26 +61,23 @@
  * `pipelines/`); no sandboxing. Hot-reload is not supported — restart the
  * engine to pick up new plugin files (matches how playbooks already work).
  *
- * State stored in engine/watches.json — concurrency-safe via mutateJsonFileLocked.
+ * State is stored transactionally in SQLite.
  */
 
 const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
-const { safeJsonArr, mutateJsonFileLocked, mutateWatches, ts, uid, log, writeToInbox,
+const { mutateWatches, ts, uid, log, writeToInbox,
   WATCH_STATUS, WATCH_TARGET_TYPE, WATCH_CONDITION, WATCH_ABSOLUTE_CONDITIONS } = shared;
 const watchActions = require('./watch-actions');
 
-// Dynamic path — respects MINIONS_TEST_DIR for test isolation
-function _watchesPath() { return path.join(shared.MINIONS_DIR, 'engine', 'watches.json'); }
-
 // Default check interval: 5 minutes (300000ms). Engine tick runs every 10s
 // (W-mpxpckey000laa4f), so watches are checked every N ticks where
 // N = ceil(interval / tickInterval).
 const DEFAULT_WATCH_INTERVAL = 300000;
 
 // P-w12d8f3a — Phase 6.2: per-watch evaluation history is capped at 25
-// entries (oldest-first). Bounded to keep watches.json compact:
+// entries (oldest-first). Bounded to keep watch state compact:
 // 25 entries × ~200 bytes × 100 watches ≈ 500 KB ceiling. History entries
 // never contain full state snapshots — only the trigger reason — per the
 // "history is small and bounded" design principle.
@@ -177,11 +174,11 @@ function listTargetTypes() {
 }
 
 /**
- * Read all watches from disk.
+ * Read all watches from SQLite.
  * @returns {Array<object>}
  */
 function getWatches() {
-  return safeJsonArr(_watchesPath());
+  return require('./watches-store').readWatches();
 }
 
 /**
@@ -1366,7 +1363,7 @@ registerTargetType(WATCH_TARGET_TYPE.AGENT, {
   // P-w2c8d1e7 — Phase 1.2: surface currentDispatchId so predicates can
   // distinguish "agent now working on a different dispatch" from a plain
   // status flip. Sourced from queries.getAgents() which derives it from
-  // dispatch.json (active list) via getAgentStatus.dispatch_id.
+  // active dispatch state via getAgentStatus.dispatch_id.
   captureState: (a) => ({
     status: a.status || null,
     currentDispatchId: a.currentDispatchId || null,
@@ -1459,7 +1456,6 @@ module.exports = {
   runWatchActionChain: watchActions.runWatchActionChain,
   validateAction: watchActions.validateAction,
   _captureState,  // exported for testing
-  _watchesPath,   // exported for testing — dynamic, respects MINIONS_TEST_DIR
   _runActionTask, // exported for testing — invoked by checkWatches per fired action
   _TARGET_TYPES: TARGET_TYPES, // exported for testing — direct registry access
   _loadPluginTargetTypes, // exported for testing — re-scans watches.d/

package/engine/work-item-validation.js

@@ -0,0 +1,52 @@
+function _hasText(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function _hasObjectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).length > 0;
+}
+
+function hasWorkItemSemantics(item) {
+  return _hasText(item?.title)
+    || _hasText(item?.description)
+    || _hasText(item?.type)
+    || _hasText(item?.itemType);
+}
+
+function hasWorkItemProvenance(item) {
+  return [
+    'created', 'created_at', 'createdAt', 'createdBy', 'sourcePlan', 'planFile',
+    'project', 'parent_id', 'prd_item_id', '_originWi', '_originAgent',
+    '_pipelineRun', '_pipelineStage',
+  ].some(key => item?.[key] !== undefined && item[key] !== null && item[key] !== '')
+    || _hasObjectValue(item?.meta)
+    || (Array.isArray(item?.references) && item.references.length > 0);
+}
+
+function validateNewWorkItem(item) {
+  if (!item || typeof item !== 'object' || Array.isArray(item)) {
+    throw new Error('malformed work item: record must be an object');
+  }
+  if (!_hasText(String(item.id || ''))) {
+    throw new Error('malformed work item: id is required');
+  }
+  if (!hasWorkItemSemantics(item) && !hasWorkItemProvenance(item)) {
+    throw new Error(`malformed work item ${item.id}: semantic content or provenance is required`);
+  }
+}
+
+function isMalformedPhantomWorkItem(item) {
+  return !!item
+    && typeof item === 'object'
+    && item.status === 'failed'
+    && !hasWorkItemSemantics(item)
+    && !hasWorkItemProvenance(item);
+}
+
+module.exports = {
+  hasWorkItemSemantics,
+  hasWorkItemProvenance,
+  validateNewWorkItem,
+  isMalformedPhantomWorkItem,
+};