@yemi33/minions 0.1.2108 → 0.1.2110

package/engine/small-state-store.js

@@ -521,6 +521,314 @@ function _mirrorWorktreePoolJson(filePath) {
   } catch { /* mirror best-effort */ }
 }
 
+// ─── qa_runs ───────────────────────────────────────────────────────────────
+// Shape: [ {id, runbookId, targetName, project, workItemId, status, startedAt,
+//           completedAt, createdAt, artifacts, summary, ...}, ... ]
+// SQL:   row per id, extracted query columns + JSON blob `data`.
+// Pattern: mirrors watches-store (top-level array, id-keyed diff).
+
+let _qaRunsHash = null;
+
+function _hydrateQaRuns(db) {
+  const fp = _resolveFilePath('qa-runs.json');
+  const raw = _readJson(fp) || [];
+  if (!Array.isArray(raw)) return;
+  db.prepare('DELETE FROM qa_runs').run();
+  const now = Date.now();
+  const ins = db.prepare(`
+    INSERT INTO qa_runs (id, runbook_id, target_name, project, work_item_id, status, started_at, completed_at, created_at, data)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO NOTHING
+  `);
+  for (const run of raw) {
+    if (!run || !run.id) continue;
+    ins.run(
+      String(run.id),
+      String(run.runbookId || ''),
+      String(run.targetName || ''),
+      run.project || null,
+      run.workItemId || null,
+      String(run.status || 'pending'),
+      _toMs(run.startedAt),
+      _toMs(run.completedAt),
+      _toMs(run.createdAt) || now,
+      JSON.stringify(run),
+    );
+  }
+}
+
+function _resyncQaRunsIfDiverged(db) {
+  const fp = _resolveFilePath('qa-runs.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_qaRunsHash != null && currentHash === _qaRunsHash) return;
+  if (_qaRunsHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM qa_runs LIMIT 1').get();
+    if (sqlHas) { _qaRunsHash = currentHash; return; }
+  }
+  _hydrateQaRuns(db);
+  _qaRunsHash = currentHash;
+}
+
+function _readQaRunsFromSqlOnly(db) {
+  const rows = db.prepare('SELECT data FROM qa_runs ORDER BY created_at, rowid').all();
+  const out = [];
+  for (const row of rows) {
+    try { out.push(JSON.parse(row.data)); } catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+function readQaRuns() {
+  const { getDb } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch { return _readJson(_resolveFilePath('qa-runs.json')) || []; }
+  _resyncQaRunsIfDiverged(db);
+  const out = _readQaRunsFromSqlOnly(db);
+  if (out.length === 0) {
+    const fallback = _readJson(_resolveFilePath('qa-runs.json'));
+    if (Array.isArray(fallback) && fallback.length > 0) return fallback;
+    return [];
+  }
+  return out;
+}
+
+function applyQaRunsMutation(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, () => {
+    _resyncQaRunsIfDiverged(db);
+    const before = _readQaRunsFromSqlOnly(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null)
+      ? before
+      : (Array.isArray(next) ? next : before);
+
+    const indexById = (arr) => {
+      const out = new Map();
+      for (const r of arr) {
+        if (r && r.id) out.set(String(r.id), r);
+      }
+      return out;
+    };
+    const beforeMap = indexById(beforeSnap);
+    const afterMap = indexById(after);
+
+    const now = Date.now();
+    const upsert = db.prepare(`
+      INSERT INTO qa_runs (id, runbook_id, target_name, project, work_item_id, status, started_at, completed_at, created_at, data)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        runbook_id   = excluded.runbook_id,
+        target_name  = excluded.target_name,
+        project      = excluded.project,
+        work_item_id = excluded.work_item_id,
+        status       = excluded.status,
+        started_at   = excluded.started_at,
+        completed_at = excluded.completed_at,
+        created_at   = excluded.created_at,
+        data         = excluded.data
+    `);
+    const del = db.prepare('DELETE FROM qa_runs WHERE id = ?');
+    let wrote = false;
+    for (const [id, run] of afterMap) {
+      const prev = beforeMap.get(id);
+      if (!prev || JSON.stringify(prev) !== JSON.stringify(run)) {
+        upsert.run(
+          id,
+          String(run.runbookId || ''),
+          String(run.targetName || ''),
+          run.project || null,
+          run.workItemId || null,
+          String(run.status || 'pending'),
+          _toMs(run.startedAt),
+          _toMs(run.completedAt),
+          _toMs(run.createdAt) || now,
+          JSON.stringify(run),
+        );
+        wrote = true;
+      }
+    }
+    for (const [id] of beforeMap) {
+      if (!afterMap.has(id)) { del.run(id); wrote = true; }
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorQaRunsJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const arr = _readQaRunsFromSqlOnly(getDb());
+    const target = filePath || _resolveFilePath('qa-runs.json');
+    shared.safeWrite(target, arr);
+    const h = _fileContentHash(target);
+    if (h != null) _qaRunsHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
+// ─── qa_sessions ───────────────────────────────────────────────────────────
+// Shape: [ {id, state, spec:{...}, primaryProject, coServices, setupStatus,
+//           workItems, managedSpawnName, qaRunId, testFile, summary,
+//           failureClass, error, createdAt, updatedAt, completedAt, ...}, ... ]
+// SQL:   row per id, extracted query columns + JSON blob.
+
+let _qaSessionsHash = null;
+
+function _qaSessionPrimaryProject(session) {
+  if (!session || typeof session !== 'object') return null;
+  if (session.primaryProject) return String(session.primaryProject);
+  if (session.spec && session.spec.project) return String(session.spec.project);
+  if (session.spec && Array.isArray(session.spec.projects) && session.spec.projects[0]) {
+    return String(session.spec.projects[0]);
+  }
+  return null;
+}
+
+function _hydrateQaSessions(db) {
+  const fp = _resolveFilePath('qa-sessions.json');
+  const raw = _readJson(fp) || [];
+  if (!Array.isArray(raw)) return;
+  db.prepare('DELETE FROM qa_sessions').run();
+  const now = Date.now();
+  const ins = db.prepare(`
+    INSERT INTO qa_sessions (id, state, primary_project, qa_run_id, created_at, updated_at, completed_at, data)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO NOTHING
+  `);
+  for (const session of raw) {
+    if (!session || !session.id) continue;
+    ins.run(
+      String(session.id),
+      String(session.state || 'pending'),
+      _qaSessionPrimaryProject(session),
+      session.qaRunId || null,
+      _toMs(session.createdAt) || now,
+      _toMs(session.updatedAt) || _toMs(session.createdAt) || now,
+      _toMs(session.completedAt),
+      JSON.stringify(session),
+    );
+  }
+}
+
+function _resyncQaSessionsIfDiverged(db) {
+  const fp = _resolveFilePath('qa-sessions.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_qaSessionsHash != null && currentHash === _qaSessionsHash) return;
+  if (_qaSessionsHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM qa_sessions LIMIT 1').get();
+    if (sqlHas) { _qaSessionsHash = currentHash; return; }
+  }
+  _hydrateQaSessions(db);
+  _qaSessionsHash = currentHash;
+}
+
+function _readQaSessionsFromSqlOnly(db) {
+  const rows = db.prepare('SELECT data FROM qa_sessions ORDER BY created_at, rowid').all();
+  const out = [];
+  for (const row of rows) {
+    try { out.push(JSON.parse(row.data)); } catch { /* skip */ }
+  }
+  return out;
+}
+
+function readQaSessions() {
+  const { getDb } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch { return _readJson(_resolveFilePath('qa-sessions.json')) || []; }
+  _resyncQaSessionsIfDiverged(db);
+  const out = _readQaSessionsFromSqlOnly(db);
+  if (out.length === 0) {
+    const fallback = _readJson(_resolveFilePath('qa-sessions.json'));
+    if (Array.isArray(fallback) && fallback.length > 0) return fallback;
+    return [];
+  }
+  return out;
+}
+
+function applyQaSessionsMutation(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, () => {
+    _resyncQaSessionsIfDiverged(db);
+    const before = _readQaSessionsFromSqlOnly(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null)
+      ? before
+      : (Array.isArray(next) ? next : before);
+
+    const indexById = (arr) => {
+      const out = new Map();
+      for (const s of arr) {
+        if (s && s.id) out.set(String(s.id), s);
+      }
+      return out;
+    };
+    const beforeMap = indexById(beforeSnap);
+    const afterMap = indexById(after);
+
+    const now = Date.now();
+    const upsert = db.prepare(`
+      INSERT INTO qa_sessions (id, state, primary_project, qa_run_id, created_at, updated_at, completed_at, data)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        state           = excluded.state,
+        primary_project = excluded.primary_project,
+        qa_run_id       = excluded.qa_run_id,
+        created_at      = excluded.created_at,
+        updated_at      = excluded.updated_at,
+        completed_at    = excluded.completed_at,
+        data            = excluded.data
+    `);
+    const del = db.prepare('DELETE FROM qa_sessions WHERE id = ?');
+    let wrote = false;
+    for (const [id, session] of afterMap) {
+      const prev = beforeMap.get(id);
+      if (!prev || JSON.stringify(prev) !== JSON.stringify(session)) {
+        upsert.run(
+          id,
+          String(session.state || 'pending'),
+          _qaSessionPrimaryProject(session),
+          session.qaRunId || null,
+          _toMs(session.createdAt) || now,
+          _toMs(session.updatedAt) || _toMs(session.createdAt) || now,
+          _toMs(session.completedAt),
+          JSON.stringify(session),
+        );
+        wrote = true;
+      }
+    }
+    for (const [id] of beforeMap) {
+      if (!afterMap.has(id)) { del.run(id); wrote = true; }
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorQaSessionsJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const arr = _readQaSessionsFromSqlOnly(getDb());
+    const target = filePath || _resolveFilePath('qa-sessions.json');
+    shared.safeWrite(target, arr);
+    const h = _fileContentHash(target);
+    if (h != null) _qaSessionsHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
 // ─── Test seam ─────────────────────────────────────────────────────────────
 
 function _resetAllForTest() {
@@ -531,11 +839,15 @@ function _resetAllForTest() {
     db.exec('DELETE FROM pipeline_runs');
     db.exec('DELETE FROM managed_processes');
     db.exec('DELETE FROM worktree_pool');
+    try { db.exec('DELETE FROM qa_runs'); } catch { /* migration not applied */ }
+    try { db.exec('DELETE FROM qa_sessions'); } catch { /* migration not applied */ }
   } catch { /* not initialized */ }
   _scheduleRunsHash = null;
   _pipelineRunsHash = null;
   _managedProcessesHash = null;
   _worktreePoolHash = null;
+  _qaRunsHash = null;
+  _qaSessionsHash = null;
 }
 
 module.exports = {
@@ -555,6 +867,14 @@ module.exports = {
   readWorktreePool,
   applyWorktreePoolMutation,
   _mirrorWorktreePoolJson,
+  // qa_runs
+  readQaRuns,
+  applyQaRunsMutation,
+  _mirrorQaRunsJson,
+  // qa_sessions
+  readQaSessions,
+  applyQaSessionsMutation,
+  _mirrorQaSessionsJson,
   // test seam
   _resetAllForTest,
 };

package/engine.js

@@ -877,7 +877,15 @@ async function pruneStaleWorktreeForBranch(rootDir, branchName, gitOpts) {
 //        can recover any unpushed work.
 //      - Otherwise (filesystem-only dirty) reset --hard + clean -fd, then
 //        re-verify.
-//   4. Return { clean, healed, reason, dirtyFiles, ahead, behind,
+//   4. W-mpykcky7: when the branch has no upstream AND the worktree is
+//      filesystem-clean AND HEAD is at the project main branch tip (caller
+//      passes opts.mainBranch), treat as safe-to-reuse — there are no
+//      local-only commits to lose. Without this, every reused worktree
+//      whose previous agent exited without making any commits gets
+//      quarantined in a false-positive loop. Any uncertainty (rev-list
+//      error, main missing, commitsAheadOfMain > 0) falls through to the
+//      conservative quarantine path.
+//   5. Return { clean, healed, reason, dirtyFiles, ahead, behind,
 //      quarantined, quarantinedPath, backupRef } so the caller can fail
 //      fast with a first-class DIRTY_WORKTREE / WORKTREE_DIRTY /
 //      WORKTREE_DIVERGENT reason and retry semantics.
@@ -955,7 +963,42 @@ async function assertCleanSharedWorktree(rootDir, worktreePath, branchName, disp
     return result;
   }
 
-  // 4. Unpushed-commit check — refuse to reset when local work would be lost.
+  // 4. No-upstream-but-at-main safe-path (W-mpykcky7). When the worktree's
+  //    branch has no upstream (never pushed), the original #2996 gate
+  //    conservatively assumed unpushed work and quarantined. But if the
+  //    worktree is filesystem-clean AND HEAD is at the project main branch
+  //    tip (no local-only commits beyond main), there is nothing to lose —
+  //    reuse is safe. Common case: a previous agent exited without making
+  //    any commits, leaving HEAD == origin/<mainBranch>. Falls through to
+  //    the conservative quarantine path on any uncertainty (rev-list error,
+  //    main branch missing, commitsAheadOfMain > 0).
+  //    Invariants preserved from #2996:
+  //      - filesystemDirty still quarantines (we're past that gate only if
+  //        statusOut was empty).
+  //      - upstreamKnown && ahead > 0 still quarantines below (untouched).
+  //      - other-dispatch-active (above) still returns without quarantine.
+  if (!filesystemDirty && !upstreamKnown && opts.mainBranch) {
+    let commitsAheadOfMain = null;
+    try {
+      const r = await execAsync(
+        `git rev-list ${opts.mainBranch}..HEAD --count`,
+        { ...gitOpts, cwd: worktreePath, timeout: 10000 },
+      );
+      const parsed = parseInt(String(r || '').trim(), 10);
+      if (Number.isFinite(parsed)) commitsAheadOfMain = parsed;
+    } catch {
+      // rev-list error (main missing locally, fetch failed, etc.) — fall
+      // through to the conservative quarantine path. Don't loosen on
+      // uncertainty.
+    }
+    if (commitsAheadOfMain === 0) {
+      result.clean = true;
+      result.reason = 'no-upstream-but-at-main';
+      return result;
+    }
+  }
+
+  // 5. Unpushed-commit check — refuse to reset when local work would be lost.
   //    Use the ahead count we already computed (cheaper + correct vs.
   //    `git log @{u}..HEAD` which needs an upstream config and silently
   //    returns empty when missing).
@@ -985,7 +1028,7 @@ async function assertCleanSharedWorktree(rootDir, worktreePath, branchName, disp
     return result;
   }
 
-  // 5. Safe to self-heal (filesystem-dirty only, no unpushed commits, no
+  // 6. Safe to self-heal (filesystem-dirty only, no unpushed commits, no
   //    other active dispatch): reset + clean.
   try {
     await execAsync('git reset --hard HEAD', { ...gitOpts, cwd: worktreePath, timeout: 30000 });
@@ -996,7 +1039,7 @@ async function assertCleanSharedWorktree(rootDir, worktreePath, branchName, disp
     return result;
   }
 
-  // 6. Re-verify
+  // 7. Re-verify
   try {
     const r2 = await execAsync('git status --porcelain', { ...gitOpts, cwd: worktreePath, timeout: 10000 });
     const after = (r2 || '').toString().trim();
@@ -1759,7 +1802,10 @@ async function spawnAgent(dispatchItem, config) {
     // implementation failures and cascading dependent items.
     if (worktreePath && fs.existsSync(worktreePath) && meta?.branchStrategy === 'shared-branch' && branchName) {
       _phaseT.cleanCheckStart = Date.now();
-      const cleanResult = await assertCleanSharedWorktree(rootDir, worktreePath, branchName, id, _gitOpts);
+      const cleanResult = await assertCleanSharedWorktree(
+        rootDir, worktreePath, branchName, id, _gitOpts,
+        { mainBranch: shared.resolveMainBranch(rootDir, project.mainBranch) },
+      );
       _phaseT.cleanCheckEnd = Date.now();
       if (!cleanResult.clean) {
         const previewFiles = (cleanResult.dirtyFiles || []).slice(0, 5).join(', ');
@@ -1817,7 +1863,7 @@ async function spawnAgent(dispatchItem, config) {
       _phaseT.dirtyReusedCheckStart = Date.now();
       const cleanResult = await assertCleanSharedWorktree(
         rootDir, worktreePath, branchName, id, _gitOpts,
-        { quarantineOnUnsafe: true },
+        { quarantineOnUnsafe: true, mainBranch: shared.resolveMainBranch(rootDir, project.mainBranch) },
       );
       _phaseT.dirtyReusedCheckEnd = Date.now();
       if (!cleanResult.clean) {

package/package.json

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