@yemi33/minions 0.1.2379 → 0.1.2380

package/engine/work-items-store.js

@@ -7,9 +7,6 @@
 //                                          { wrote, result }.
 //
 // `scope` is 'central' or a project name.
-//
-// All callers go through shared.mutateWorkItems and
-// queries.getWorkItems — those are thin wrappers over the helpers here.
 
 function _toMs(v) {
   if (v == null) return null;
@@ -18,21 +15,6 @@ function _toMs(v) {
   return Number.isFinite(parsed) ? parsed : null;
 }
 
-// Map an absolute filePath → scope key. The store doesn't know about the
-// caller's file layout; we derive scope from the path's last two segments
-// because every work-items file in this codebase sits at either
-// <root>/work-items.json (central) or <root>/projects/<name>/work-items.json.
-function scopeForFilePath(filePath) {
-  const norm = String(filePath).replace(/\\/g, '/');
-  const m = norm.match(/projects\/([^/]+)\/work-items\.json$/);
-  if (m) return m[1];
-  // Anything else — including the central work-items.json under MINIONS_DIR
-  // and any one-off test fixture file — lands in 'central'. Tests that
-  // need to keep multiple fixture files distinct should put them under a
-  // synthetic projects/<name>/ subtree.
-  return 'central';
-}
-
 function _parseRow(row) {
   if (!row || !row.data) return null;
   try { return JSON.parse(row.data); }
@@ -45,7 +27,7 @@ function readWorkItemsForScope(scope) {
 
   const rows = db.prepare(`
     SELECT data FROM work_items
-    WHERE scope = ?
+    WHERE scope = ? AND archived = 0
     ORDER BY rowid
   `).all(scope);
 
@@ -64,7 +46,7 @@ function readAllWorkItems() {
   const { getDb } = require('./db');
   const db = getDb();
 
-  const rows = db.prepare('SELECT data, scope FROM work_items ORDER BY rowid').all();
+  const rows = db.prepare('SELECT data, scope FROM work_items WHERE archived = 0 ORDER BY rowid').all();
   const out = [];
   for (const row of rows) {
     const wi = _parseRow(row);
@@ -85,14 +67,18 @@ function _indexById(arr) {
   return out;
 }
 
-function _computeWorkItemsDiff(scope, before, after) {
+function _computeWorkItemsDiff(scope, before, after, { allowIncomplete = false } = {}) {
   const beforeMap = _indexById(before);
   const afterMap = _indexById(after);
   const toUpsert = [];
   const toDelete = [];
   for (const [id, wi] of afterMap) {
     const prev = beforeMap.get(id);
-    if (!prev) { toUpsert.push(wi); continue; }
+    if (!prev) {
+      if (!allowIncomplete) require('./work-item-validation').validateNewWorkItem(wi);
+      toUpsert.push(wi);
+      continue;
+    }
     if (JSON.stringify(prev) !== JSON.stringify(wi)) toUpsert.push(wi);
   }
   for (const [id] of beforeMap) {
@@ -105,8 +91,8 @@ function _applyWorkItemsDiff(db, diff) {
   if (diff.toUpsert.length === 0 && diff.toDelete.length === 0) return false;
   const now = Date.now();
   const upsertStmt = db.prepare(`
-    INSERT INTO work_items (id, scope, status, type, agent, parent_id, created_at, completed_at, data, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO work_items (id, scope, status, type, agent, parent_id, created_at, completed_at, data, updated_at, archived)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
     ON CONFLICT(scope, id) DO UPDATE SET
       status        = excluded.status,
       type          = excluded.type,
@@ -115,9 +101,10 @@ function _applyWorkItemsDiff(db, diff) {
       created_at    = excluded.created_at,
       completed_at  = excluded.completed_at,
       data          = excluded.data,
-      updated_at    = excluded.updated_at
+      updated_at    = excluded.updated_at,
+      archived      = 0
   `);
-  const deleteStmt = db.prepare('DELETE FROM work_items WHERE scope = ? AND id = ?');
+  const deleteStmt = db.prepare('DELETE FROM work_items WHERE scope = ? AND id = ? AND archived = 0');
 
   for (const wi of diff.toUpsert) {
     upsertStmt.run(
@@ -147,7 +134,7 @@ function _applyWorkItemsDiff(db, diff) {
 //   wrote  — true iff at least one INSERT/UPDATE/DELETE landed
 //   result — the post-mutation array (legacy return shape of
 //            mutateJsonFileLocked)
-function applyWorkItemsMutation(scope, mutator) {
+function applyWorkItemsMutation(scope, mutator, opts) {
   const { getDb, withTransaction } = require('./db');
   const db = getDb();
 
@@ -162,7 +149,7 @@ function applyWorkItemsMutation(scope, mutator) {
     const after = (next === undefined || next === null)
       ? before
       : (Array.isArray(next) ? next : before);
-    const diff = _computeWorkItemsDiff(scope, beforeSnapshot, after);
+    const diff = _computeWorkItemsDiff(scope, beforeSnapshot, after, opts);
     const wrote = _applyWorkItemsDiff(db, diff);
     return { wrote, result: after };
   });
@@ -185,10 +172,121 @@ function dropScope(scope) {
   } catch { /* db unavailable */ }
 }
 
+function readArchivedWorkItemsForScope(scope) {
+  const rows = require('./db').getDb().prepare(`
+    SELECT data FROM work_items
+    WHERE scope = ? AND archived = 1
+    ORDER BY updated_at DESC, rowid DESC
+  `).all(scope);
+  const out = [];
+  for (const row of rows) {
+    const item = _parseRow(row);
+    if (item) out.push(item);
+  }
+  return out;
+}
+
+function archiveWorkItem(scope, id) {
+  const { getDb, withTransaction } = require('./db');
+  const db = getDb();
+  const archived = withTransaction(db, () => {
+    const row = db.prepare('SELECT data FROM work_items WHERE scope=? AND id=? AND archived=0').get(scope, String(id));
+    if (!row) return null;
+    const item = _parseRow(row);
+    if (!item) throw new Error(`work item ${id} has invalid SQL data`);
+    item._archived = true;
+    item.archivedAt = item.archivedAt || new Date().toISOString();
+    db.prepare('UPDATE work_items SET archived=1, data=?, updated_at=? WHERE scope=? AND id=?')
+      .run(JSON.stringify(item), Date.now(), scope, String(id));
+    return item;
+  });
+  if (archived) {
+    try { require('./db-events').emitStateEvent('work_items'); } catch { /* optional */ }
+    try { require('./queries').invalidateWorkItemsCache(); } catch { /* queries not loaded */ }
+  }
+  return archived;
+}
+
+function replaceArchivedWorkItems(scope, items) {
+  const { getDb, withTransaction } = require('./db');
+  const db = getDb();
+  const count = withTransaction(db, () => {
+    db.prepare('DELETE FROM work_items WHERE scope=? AND archived=1').run(scope);
+    const insert = db.prepare(`
+      INSERT OR IGNORE INTO work_items
+        (id, scope, status, type, agent, parent_id, created_at, completed_at, data, updated_at, archived)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
+    `);
+    const now = Date.now();
+    let inserted = 0;
+    for (const raw of Array.isArray(items) ? items : []) {
+      if (!raw || typeof raw !== 'object' || !raw.id) continue;
+      const item = { ...raw, _archived: true };
+      item.archivedAt = item.archivedAt || new Date(now).toISOString();
+      const result = insert.run(
+        String(item.id),
+        scope,
+        String(item.status || 'done'),
+        item.type || null,
+        item.dispatched_to || item.agent || null,
+        item.parent_id || null,
+        _toMs(item.created_at || item.created),
+        _toMs(item.completed_at || item.completedAt),
+        JSON.stringify(item),
+        now,
+      );
+      inserted += Number(result.changes) || 0;
+    }
+    return inserted;
+  });
+  try { require('./db-events').emitStateEvent('work_items'); } catch { /* optional */ }
+  try { require('./queries').invalidateWorkItemsCache(); } catch { /* queries not loaded */ }
+  return count;
+}
+
+function moveWorkItem(sourceScope, targetScope, id, item) {
+  const { getDb, withTransaction } = require('./db');
+  const db = getDb();
+  const moved = withTransaction(db, () => {
+    const source = db.prepare('SELECT 1 FROM work_items WHERE scope=? AND id=? AND archived=0')
+      .get(sourceScope, String(id));
+    if (!source) return false;
+    const target = db.prepare('SELECT 1 FROM work_items WHERE scope=? AND id=?').get(targetScope, String(id));
+    if (target) throw new Error(`work item ${id} already exists in scope ${targetScope}`);
+    const result = db.prepare(`
+      UPDATE work_items SET
+        scope=?, status=?, type=?, agent=?, parent_id=?, created_at=?,
+        completed_at=?, data=?, updated_at=?
+      WHERE scope=? AND id=? AND archived=0
+    `).run(
+      targetScope,
+      String(item.status || 'pending'),
+      item.type || null,
+      item.dispatched_to || item.agent || null,
+      item.parent_id || null,
+      _toMs(item.created_at || item.created),
+      _toMs(item.completed_at || item.completedAt),
+      JSON.stringify(item),
+      Date.now(),
+      sourceScope,
+      String(id),
+    );
+    return Number(result.changes) > 0;
+  });
+  if (moved) {
+    try { require('./db-events').emitStateEvent('work_items'); } catch { /* optional */ }
+    try { require('./queries').invalidateWorkItemsCache(); } catch { /* queries not loaded */ }
+  }
+  return moved;
+}
+
 module.exports = {
-  scopeForFilePath,
   readWorkItemsForScope,
   readAllWorkItems,
+  readArchivedWorkItemsForScope,
+  archiveWorkItem,
+  replaceArchivedWorkItems,
+  moveWorkItem,
   applyWorkItemsMutation,
   dropScope,
 };

package/engine/worktree-gc.js

@@ -10,7 +10,7 @@
 //      anchored by live keep_processes PIDs / managed_spawn cwds.
 //
 //   2. On engine boot (engine/cli.js): scan each project's worktree root
-//      for orphan W-* dirs whose dispatch is not in dispatch.json (active
+//      for orphan W-* dirs whose dispatch is not active
 //      or pending) AND that are not pool entries. Such dirs are leftovers
 //      from a prior crash that block retries with
 //      `fatal: 'work/W-…' is already used by worktree at …`.
@@ -698,7 +698,7 @@ function gcDispatchWorktreeIfOrphan(opts) {
  * Walk each project's worktree root and evict orphan W-* dirs.
  *
  *   - `projects`        — array of `{ name, localPath }`
- *   - `dispatchSnap`    — `{ active: [...], pending: [...] }` (work-item dispatch.json)
+ *   - `dispatchSnap`    — `{ active: [...], pending: [...] }` dispatch state
  *   - `worktreeRootRel` — relative dir under each project's localPath (default '../worktrees')
  *   - `log`             — log(level, msg) function (optional)
  *   - `fs`/`removeWorktree`/`buildWorktreeDirName`/`listManagedSpecs` — test injection points

package/engine/worktree-pool.js

@@ -7,10 +7,10 @@
  * detached at `origin/<mainBranch>` and reused by the next dispatch for the
  * same project — saving the cold install/build cost on subsequent WIs.
  *
- * Concurrency: all state flips go through `mutateJsonFileLocked` so two
- * spawning ticks cannot double-borrow the same idle entry. Per CLAUDE.md, git
- * commands NEVER run inside the lock callback — callers must do `tryBorrow`,
- * then run git in their own scope, then call `evictEntry` on failure.
+ * Concurrency: all state flips use a SQLite transaction so two spawning ticks
+ * cannot double-borrow the same idle entry. Git commands never run inside the
+ * transaction — callers must do `tryBorrow`, then run git in their own scope,
+ * then call `evictEntry` on failure.
  *
  * Idle worktrees are detached at origin/<main>, NOT checked out on the local
  * `main` branch. Local-main is typically already checked out in the project
@@ -22,16 +22,12 @@
 const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
+const smallStateStore = require('./small-state-store');
 
-const { log, ENGINE_DEFAULTS, mutateJsonFileLocked, safeJson } = shared;
+const { log, ENGINE_DEFAULTS } = shared;
 
-const WORKTREE_POOL_FILENAME = 'worktree-pool.json';
 const POOL_STATE = Object.freeze({ IDLE: 'idle', BORROWED: 'borrowed' });
 
-function getPoolPath() {
-  return path.join(shared.MINIONS_DIR, 'engine', WORKTREE_POOL_FILENAME);
-}
-
 function _normalizePath(p) {
   if (!p) return '';
   let resolved;
@@ -55,17 +51,13 @@ function _entriesArray(data) {
 }
 
 function readPool() {
-  const data = safeJson(getPoolPath());
+  const data = smallStateStore.readWorktreePool();
   if (!data || !Array.isArray(data.entries)) return { entries: [] };
   return data;
 }
 
 function mutateWorktreePool(mutator) {
-  // 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) => {
+  return smallStateStore.applyWorktreePoolMutation((data) => {
     if (!data || typeof data !== 'object' || Array.isArray(data)) data = { entries: [] };
     if (!Array.isArray(data.entries)) data.entries = [];
     const next = mutator(data);
@@ -320,9 +312,7 @@ function getIdlePaths() {
 }
 
 module.exports = {
-  WORKTREE_POOL_FILENAME,
   POOL_STATE,
-  getPoolPath,
   readPool,
   mutateWorktreePool,
   getProjectPoolSize,