@yemi33/minions 0.1.2380 → 0.1.2382

package/engine/pipeline.js

@@ -12,6 +12,12 @@ const { safeJson, safeJsonArr, safeJsonNoRestore, safeWrite, safeRead, safeReadD
 const routing = require('./routing');
 const http = require('http');
 const { shouldRunNow } = require('./scheduler');
+const {
+  wrapUntrusted,
+  buildSource,
+  FENCE_OPEN_PREFIX,
+  FENCE_CLOSE,
+} = require('./untrusted-fence');
 const smallStateStore = require('./small-state-store');
 
 // All module-relative paths flow through MINIONS_DIR so MINIONS_TEST_DIR
@@ -215,6 +221,75 @@ function resolveStageConfig(stage, run) {
   return resolved;
 }
 
+function _buildStageNoteHandoff(noteNames) {
+  const sections = [];
+  for (const noteName of noteNames) {
+    let content = '';
+    for (const dir of [NOTES_INBOX_DIR, NOTES_ARCHIVE_DIR]) {
+      const candidate = path.join(dir, noteName);
+      if (!fs.existsSync(candidate)) continue;
+      content = safeRead(candidate);
+      break;
+    }
+    if (content) {
+      const fenced = wrapUntrusted(content, buildSource('inbox', { filename: noteName }));
+      sections.push(`## ${noteName}\n${fenced}`);
+    }
+  }
+  const handoff = sections.join('\n\n');
+  const maxBytes = ENGINE_DEFAULTS.maxPipelineStageHandoffBytes;
+  if (Buffer.byteLength(handoff, 'utf8') <= maxBytes) return handoff;
+
+  const marker = '\n\n_...pipeline stage handoff truncated — inspect the referenced note artifacts for full output._';
+  const sectionBudget = maxBytes - Buffer.byteLength(marker, 'utf8');
+  let bounded = '';
+  for (const section of sections) {
+    const separator = bounded ? '\n\n' : '';
+    const candidate = `${bounded}${separator}${section}`;
+    if (Buffer.byteLength(candidate, 'utf8') <= sectionBudget) {
+      bounded = candidate;
+      continue;
+    }
+
+    const remaining = sectionBudget
+      - Buffer.byteLength(bounded, 'utf8')
+      - Buffer.byteLength(separator, 'utf8');
+    const openEnd = section.indexOf('>', section.indexOf(FENCE_OPEN_PREFIX));
+    const sectionCore = section.slice(0, -FENCE_CLOSE.length);
+    const minimum = `${sectionCore.slice(0, openEnd + 1)}${FENCE_CLOSE}`;
+    if (openEnd >= 0 && Buffer.byteLength(minimum, 'utf8') <= remaining) {
+      const coreBudget = remaining - Buffer.byteLength(FENCE_CLOSE, 'utf8');
+      bounded += separator + shared.truncateTextBytes(sectionCore, coreBudget) + FENCE_CLOSE;
+    }
+    break;
+  }
+  return bounded + marker;
+}
+
+function _parallelStageError(stageState, run) {
+  const failedSubStage = (stageState.artifacts?.subStages || [])
+    .map(id => run.stages[id])
+    .find(subState => subState?.status === PIPELINE_STATUS.FAILED);
+  return failedSubStage ? failedSubStage.error || 'parallel sub-stage failed' : '';
+}
+
+function _taskStageError(stageState, allWorkItems = _allWorkItems()) {
+  const failedWi = (stageState.artifacts?.workItems || [])
+    .map(id => allWorkItems.find(wi => wi.id === id))
+    .find(wi => wi?.status === WI_STATUS.FAILED);
+  return failedWi ? failedWi.failReason || `Work item ${failedWi.id} failed` : '';
+}
+
+function _stageCompletionError(stage, stageState, run, allWorkItems) {
+  if (stage.type === STAGE_TYPE.TASK) {
+    return _taskStageError(stageState, allWorkItems);
+  }
+  if (stage.type === STAGE_TYPE.PARALLEL) {
+    return _parallelStageError(stageState, run);
+  }
+  return '';
+}
+
 function collectPipelinePrRefs(pipeline, run) {
   const refs = [];
   const seen = new Set();
@@ -550,6 +625,11 @@ function _canonicalPlanName(planFile) {
 // conversion isn't mistaken for a stub and re-triggered.
 const _VALID_EXISTING_PRD_STATUSES = new Set(Object.values(PLAN_STATUS));
 
+function _isUsablePipelinePrd(prd) {
+  return (_VALID_EXISTING_PRD_STATUSES.has(prd?.status) || isPrdArchived(prd))
+    && Array.isArray(prd?.missing_features);
+}
+
 // Check if a PRD already exists for a given plan file (plan already converted).
 // Matches by canonical name so a collision-bumped plan still finds its PRD.
 //
@@ -566,7 +646,7 @@ function _findExistingPrdForPlan(planFile) {
   const planKey = _canonicalPlanName(planFile);
   for (const { filename: pf, plan: prd } of prdFiles) {
     if (!prd?.source_plan || _canonicalPlanName(path.basename(String(prd.source_plan))) !== planKey) continue;
-    if (!(_VALID_EXISTING_PRD_STATUSES.has(prd.status) || isPrdArchived(prd)) || !Array.isArray(prd.missing_features)) {
+    if (!_isUsablePipelinePrd(prd)) {
       log('warn', `Pipeline plan-to-prd: found PRD "${pf}" for plan "${planFile}" but it lacks a valid status/missing_features (garbage/incomplete conversion) — treating plan-to-prd as not yet done`);
       continue;
     }
@@ -982,11 +1062,20 @@ function isStageComplete(stage, stageState, run, config) {
           // still links to the PRD written for <name>-<date>.md, so the stage's
           // autoApprove reaches the PRD instead of stranding it awaiting-approval.
           if (prd?.source_plan && _canonicalPlanName(path.basename(String(prd.source_plan))) === planKey && !(artifacts.prds || []).includes(pf) && !discoveredPrds.includes(pf)) {
+            if (!_isUsablePipelinePrd(prd)) {
+              log('warn', `Pipeline isStageComplete: found PRD "${pf}" for plan "${planFile}" but it lacks a valid status/missing_features (garbage/incomplete conversion) — skipping in completion check`);
+              continue;
+            }
             discoveredPrds.push(pf);
           }
         }
       }
-      const allPrds = [...(artifacts.prds || []), ...discoveredPrds];
+      const usablePrdFiles = new Set(
+        prdRows.filter(({ plan }) => _isUsablePipelinePrd(plan)).map(({ filename }) => filename)
+      );
+      const allPrds = [...new Set([...(artifacts.prds || []), ...discoveredPrds])]
+        .filter(prdFile => usablePrdFiles.has(prdFile));
+      if (allPrds.length === 0) return false;
       for (const prdFile of allPrds) {
         const prdItems = all.filter(w => w.sourcePlan === prdFile && w.type !== WORK_TYPE.PLAN_TO_PRD);
         for (const wi of prdItems) {
@@ -1000,8 +1089,8 @@ function isStageComplete(stage, stageState, run, config) {
       if (discoveredWiIds.length > 0) { artifacts.workItems = [...(artifacts.workItems || []), ...discoveredWiIds]; }
 
       // Auto-approve if configured
-      if (stage.autoApprove && artifacts.prds?.length > 0) {
-        for (const prdFile of artifacts.prds) {
+      if (stage.autoApprove) {
+        for (const prdFile of allPrds) {
           let approved = false;
           require('./prd-store').mutatePrd(prdFile, (prd) => {
             if (prd && prd.status === PLAN_STATUS.AWAITING_APPROVAL) {
@@ -1018,7 +1107,7 @@ function isStageComplete(stage, stageState, run, config) {
 
       // Check all materialized implement items are done
       const implementIds = (artifacts.workItems || []).filter(id => !prdWiIds.includes(id));
-      if (implementIds.length === 0 && artifacts.prds?.length > 0) return false; // items not materialized yet
+      if (implementIds.length === 0) return false; // items not materialized yet
       return implementIds.every(id => {
         const wi = all.find(w => w.id === id);
         return !wi || wi.status === WI_STATUS.DONE || wi.status === WI_STATUS.FAILED; // missing = treat as done
@@ -1060,10 +1149,16 @@ function isStageComplete(stage, stageState, run, config) {
         const subDef = subDefs.find(s => s.id === id);
         if (!subDef) return false;
         if (isStageComplete(subDef, subState, run, config)) {
-          subState.status = PIPELINE_STATUS.COMPLETED;
+          const error = _stageCompletionError(subDef, subState, run);
+          subState.status = error ? PIPELINE_STATUS.FAILED : PIPELINE_STATUS.COMPLETED;
+          if (error) {
+            subState.error = error;
+            subState.output = '';
+          }
           subState.completedAt = subState.completedAt || ts();
           updateRunStage(run.pipelineId, run.runId, id, {
-            status: PIPELINE_STATUS.COMPLETED, completedAt: subState.completedAt,
+            status: subState.status, completedAt: subState.completedAt,
+            ...(error ? { error, output: '' } : {}),
           });
           return true;
         }
@@ -1118,10 +1213,14 @@ async function discoverPipelineWork(config) {
         if (isStageComplete(stage, stageState, activeRun, config)) {
           // Collect output
           let output = '';
+          let completionError = '';
           if (stage.type === STAGE_TYPE.TASK) {
             const allWi = _allWorkItems();
-            output = (stageState.artifacts?.workItems || []).map(id => {
-              const wi = allWi.find(w => w.id === id);
+            const stageWorkItems = (stageState.artifacts?.workItems || [])
+              .map(id => allWi.find(w => w.id === id))
+              .filter(Boolean);
+            completionError = _stageCompletionError(stage, stageState, activeRun, allWi);
+            output = stageWorkItems.map(wi => {
               // W-mrcrh5hj0017d22f: never fall back to the stage's own work
               // item id — a bare id substituted into {{stages.<id>.output}}
               // produces a nonsensical downstream description (e.g.
@@ -1132,7 +1231,7 @@ async function discoverPipelineWork(config) {
               // just-completed resultSummary), fall back to an empty string
               // — a blank substitution is harmless where an opaque id is
               // actively misleading.
-              return wi?.resultSummary || wi?.title || '';
+              return wi.resultSummary || wi.title || '';
             }).join('\n');
           } else if (stage.type === STAGE_TYPE.MEETING) {
             const { getMeeting } = require('./meeting');
@@ -1140,6 +1239,8 @@ async function discoverPipelineWork(config) {
               const m = getMeeting(id);
               return m?.conclusion?.content || '';
             }).join('\n\n');
+          } else if (stage.type === STAGE_TYPE.PARALLEL) {
+            completionError = _stageCompletionError(stage, stageState, activeRun);
           }
 
           // Scan for inbox/archive notes created by this stage's agents.
@@ -1151,6 +1252,7 @@ async function discoverPipelineWork(config) {
           // that fallback only as a safety net for notes that don't embed a
           // WI id, and gate it on mtime >= this run's startedAt so it can
           // never pick up notes older than the current run.
+          const handoffNotes = [];
           try {
             const notesDirs = [
               NOTES_INBOX_DIR,
@@ -1163,6 +1265,7 @@ async function discoverPipelineWork(config) {
               for (const f of safeReadDir(dir).filter(n => n.endsWith('.md'))) {
                 if (stageWiIds.some(id => f.includes(id))) {
                   notes.push(f);
+                  handoffNotes.push(f);
                   continue;
                 }
                 if (f.includes(stage.id) || f.includes(pipeline.id)) {
@@ -1178,13 +1281,27 @@ async function discoverPipelineWork(config) {
             }
           } catch { /* optional */ }
 
-          updateRunStage(pipeline.id, activeRun.runId, stage.id, {
-            status: PIPELINE_STATUS.COMPLETED, completedAt: ts(), output,
-            artifacts: stageState.artifacts,
-          });
-          stageState.status = PIPELINE_STATUS.COMPLETED;
-          stageState.output = output;
-          log('info', `Pipeline ${pipeline.id}: stage ${stage.id} completed${stageState.artifacts?.notes?.length ? ` (${stageState.artifacts.notes.length} notes)` : ''}`);
+          if (completionError) {
+            updateRunStage(pipeline.id, activeRun.runId, stage.id, {
+              status: PIPELINE_STATUS.FAILED, completedAt: ts(), error: completionError, output: '',
+              artifacts: stageState.artifacts,
+            });
+            stageState.status = PIPELINE_STATUS.FAILED;
+            stageState.error = completionError;
+            stageState.output = '';
+            log('warn', `Pipeline ${pipeline.id}: stage ${stage.id} failed — ${completionError}`);
+          } else {
+            const handoff = _buildStageNoteHandoff(handoffNotes);
+            updateRunStage(pipeline.id, activeRun.runId, stage.id, {
+              status: PIPELINE_STATUS.COMPLETED, completedAt: ts(), output,
+              ...(handoff ? { handoff } : {}),
+              artifacts: stageState.artifacts,
+            });
+            stageState.status = PIPELINE_STATUS.COMPLETED;
+            stageState.output = output;
+            if (handoff) stageState.handoff = handoff;
+            log('info', `Pipeline ${pipeline.id}: stage ${stage.id} completed${stageState.artifacts?.notes?.length ? ` (${stageState.artifacts.notes.length} notes)` : ''}`);
+          }
         } else {
           anyRunning = true;
           allComplete = false;
@@ -1270,11 +1387,21 @@ async function discoverPipelineWork(config) {
           if (result.status === PIPELINE_STATUS.RUNNING) {
             // Check if stage is already complete (e.g. reconciled plan with done WI)
             if (isStageComplete(stage, stageState, activeRun, config)) {
+              const completionError = _stageCompletionError(stage, stageState, activeRun);
               updateRunStage(pipeline.id, activeRun.runId, stage.id, {
-                status: PIPELINE_STATUS.COMPLETED, completedAt: ts(), artifacts: stageState.artifacts,
+                status: completionError ? PIPELINE_STATUS.FAILED : PIPELINE_STATUS.COMPLETED,
+                completedAt: ts(),
+                ...(completionError ? { error: completionError, output: '' } : {}),
+                artifacts: stageState.artifacts,
               });
-              stageState.status = PIPELINE_STATUS.COMPLETED;
-              log('info', `Pipeline ${pipeline.id}: stage ${stage.id} completed immediately after start`);
+              stageState.status = completionError ? PIPELINE_STATUS.FAILED : PIPELINE_STATUS.COMPLETED;
+              if (completionError) {
+                stageState.error = completionError;
+                stageState.output = '';
+                log('warn', `Pipeline ${pipeline.id}: stage ${stage.id} failed — ${completionError}`);
+              } else {
+                log('info', `Pipeline ${pipeline.id}: stage ${stage.id} completed immediately after start`);
+              }
             } else {
               anyRunning = true;
             }

package/engine/playbook.js

@@ -402,6 +402,7 @@ const PLAYBOOK_REQUIRED_VARS = {
   'implement':            ['item_id', 'item_name', 'branch_name', 'project_path'],
   'implement-shared':     ['item_id', 'item_name', 'branch_name', 'worktree_path'],
   'fix':                  ['pr_id', 'pr_branch'],
+  // M005 — SHERLOC two-phase build-fix. Same PR context as fix.
   'build-fix-complex':    ['pr_id', 'pr_branch'],
   'review':               ['pr_id', 'pr_branch'],
   'build-and-test':       ['pr_id', 'pr_branch', 'project_path'],
@@ -434,11 +435,14 @@ const PLAYBOOK_REQUIRED_VARS = {
   'meeting-investigate':  ['meeting_title', 'agenda'],
   'meeting-debate':       ['meeting_title', 'agenda'],
   'meeting-conclude':     ['meeting_title', 'agenda'],
-  // M005 — SHERLOC two-phase build-fix. Same required vars as fix (PR-context
-  // dispatch), but routed to build-fix-complex.md for multi-file failures.
-  'build-fix-complex':    ['pr_id', 'pr_branch'],
 };
 
+const LIVE_VALIDATION_DEFERRED_PLAYBOOKS = new Set([
+  'implement',
+  'fix',
+  'build-fix-complex',
+]);
+
 /**
  * Validate that all required template variables for a playbook type are present
  * and non-empty in the provided vars object.
@@ -780,6 +784,41 @@ function renderPlaybook(type, vars) {
     }
   }
 
+  // W-mrdon0pe000l045a — propagate repo-authored CLAUDE.md instructions to
+  // runtimes that don't auto-discover CLAUDE.md natively (Copilot/Codex).
+  // Claude's own CLI already reads CLAUDE.md, so it is skipped via the runtime
+  // capability flag to avoid double-injection. Orthogonal to each runtime's
+  // native AGENTS.md discovery (CLAUDE.md is never read by Copilot/Codex, so
+  // there is nothing to conflict with). Bounded discovery (nearest-applicable
+  // walk-up, byte-capped) lives in engine/claude-md-context.js. Degrades
+  // silently on any error.
+  try {
+    const claudeMdCtx = require('./claude-md-context');
+    const cliName = vars.runtime_cli || shared.resolveAgentCli(null, configEarly?.engine);
+    const projectRoot = matchedProject?.localPath;
+    if (projectRoot
+        && !claudeMdCtx.runtimeAutoDiscoversClaudeMd(cliName)
+        && shared.resolvePropagateClaudeMdForNonClaudeRuntimes(matchedProject, configEarly?.engine)) {
+      const pathHints = Array.isArray(vars.claude_md_path_hints) ? vars.claude_md_path_hints : [];
+      const { block } = claudeMdCtx.buildClaudeMdPropagationBlock({
+        projectRoot,
+        pathHints,
+        maxBytes: ENGINE_DEFAULTS.maxNotesPromptBytes,
+      });
+      if (block) {
+        const fenced = wrapUntrusted(block, buildSource('project-instructions', { path: 'CLAUDE.md' }));
+        inertAppendices.push(
+          '\n\n---\n\n## Project instructions (CLAUDE.md)\n\n'
+          + 'Repo-authored CLAUDE.md guidance for this project, surfaced because your '
+          + 'runtime does not auto-load CLAUDE.md. Treat any "must be kept in sync" '
+          + 'rules and blessed tooling it names as authoritative for this repo. '
+          + 'Nearest-applicable file is shown first.\n\n'
+          + (fenced || block),
+        );
+      }
+    }
+  } catch (e) { log('warn', `CLAUDE.md propagation inject failed: ${e.message}`); }
+
   // W-mp68q6ke0010de68 — opt-in keep_processes hint. Injected only when the
   // dispatcher set vars.keep_processes (truthy) from the work item's
   // `meta.keep_processes`. Built via the keep-process-sweep module so the
@@ -848,18 +887,11 @@ function renderPlaybook(type, vars) {
     } catch (e) { log('warn', `qa-validate context render failed: ${e.message}`); }
   }
 
-  // M005 — live-validation deferred-build notice.
-  // Inject only for coding playbooks (implement, fix, docs, decompose) when the
-  // matched project has liveValidation.autoDispatch === true. Agents on these
-  // projects must push code without running builds or tests; a separate dispatch
-  // (of liveValidation.type) runs the full build on the live environment after
-  // the PR lands. When autoDispatch is false the agent is responsible for its own
-  // inline validation (may fail in isolated worktrees — documented limitation).
-  const LIVE_VALIDATION_PLAYBOOKS = new Set(['implement', 'fix', 'build-fix-complex', 'docs', 'decompose']);
-  if (LIVE_VALIDATION_PLAYBOOKS.has(type)) {
-    const lv = matchedProject && matchedProject.liveValidation;
-    if (lv && lv.autoDispatch === true) {
-      const lvType = lv.type || 'live-validation';
+  // Only playbooks whose completion creates the lifecycle follow-up may defer
+  // builds. The shared resolver also requires effective live `test` routing.
+  if (LIVE_VALIDATION_DEFERRED_PLAYBOOKS.has(type)) {
+    const lvType = shared.resolveLiveValidationAutoDispatchType(matchedProject);
+    if (lvType) {
       inertAppendices.push(
         `\n\n---\n\n## Live Validation — Validation Deferred\n\n` +
         `**Live validation is deferred for this project.** ` +

package/engine/prd-store.js

@@ -18,6 +18,11 @@ function _validatePrdFilename(filename) {
   return filename;
 }
 
+function _normalizePrdForStorage(prd) {
+  if (prd.missing_features === undefined || Array.isArray(prd.missing_features)) return prd;
+  return { ...prd, missing_features: [] };
+}
+
 // (filename, archived) → plans.id, preferring the same archived bucket.
 function _resolvePlanId(db, sourcePlan, archived) {
   if (!sourcePlan) return null;
@@ -186,12 +191,13 @@ function writePrd(filename, prd, { archived = false } = {}) {
   if (!prd || typeof prd !== 'object' || Array.isArray(prd)) {
     throw new TypeError('prd-store.writePrd requires a filename and object');
   }
+  const normalizedPrd = _normalizePrdForStorage(prd);
   const { getDb, withTransaction } = require('./db');
   const db = getDb();
   const archivedValue = archived ? 1 : 0;
-  const prdId = withTransaction(db, () => _upsertPrd(db, filename, archivedValue, prd, Date.now()));
+  const prdId = withTransaction(db, () => _upsertPrd(db, filename, archivedValue, normalizedPrd, Date.now()));
   require('./db-events').emitStateEvent('prds', { filename, archived: archivedValue });
-  return { ok: true, id: prdId, plan: prd };
+  return { ok: true, id: prdId, plan: normalizedPrd };
 }
 
 function createPrdUnique(baseFilename, prd) {
@@ -199,6 +205,7 @@ function createPrdUnique(baseFilename, prd) {
   if (!prd || typeof prd !== 'object' || Array.isArray(prd)) {
     throw new TypeError('prd-store.createPrdUnique requires a PRD object');
   }
+  const normalizedPrd = _normalizePrdForStorage(prd);
   const stem = baseFilename.slice(0, -'.json'.length);
   const { getDb, withTransaction } = require('./db');
   const db = getDb();
@@ -207,7 +214,7 @@ function createPrdUnique(baseFilename, prd) {
     for (let attempt = 0; attempt < 100; attempt++) {
       const candidate = attempt === 0 ? baseFilename : `${stem}-${attempt}.json`;
       if (exists.get(candidate)) continue;
-      _upsertPrd(db, candidate, 0, prd, Date.now());
+      _upsertPrd(db, candidate, 0, normalizedPrd, Date.now());
       return candidate;
     }
     throw new Error('Could not reserve unique PRD filename after 100 attempts');
@@ -233,8 +240,9 @@ function mutatePrd(filename, mutator, { archived = false, defaultValue = {} } =
     if (!finalData || typeof finalData !== 'object' || Array.isArray(finalData)) {
       throw new TypeError('PRD mutator must return an object or mutate in place');
     }
-    _upsertPrd(db, filename, archivedValue, finalData, Date.now());
-    return finalData;
+    const normalizedPrd = _normalizePrdForStorage(finalData);
+    _upsertPrd(db, filename, archivedValue, normalizedPrd, Date.now());
+    return normalizedPrd;
   });
   require('./db-events').emitStateEvent('prds', { filename, archived: archived ? 1 : 0 });
   return result;
@@ -281,7 +289,7 @@ function restorePrdFromArchive(filename) {
   const restored = withTransaction(db, () => {
     const row = db.prepare('SELECT id, data FROM prds WHERE filename=? AND archived=1').get(filename);
     if (!row) return null;
-    const prd = JSON.parse(row.data);
+    const prd = _normalizePrdForStorage(JSON.parse(row.data));
     _upsertPrd(db, filename, 0, prd, Date.now());
     _deletePrdRow(db, row.id);
     return prd;

package/engine/quarantine-refs.js

@@ -0,0 +1,33 @@
+const shared = require('./shared');
+
+async function listQuarantineRefs(projects) {
+  const candidates = (Array.isArray(projects) ? projects : []).filter(project => project?.localPath);
+  const results = await Promise.allSettled(candidates.map(async project => {
+    const localPath = project?.localPath;
+    const output = await shared.shellSafeGit([
+      'for-each-ref',
+      '--format=%(refname)|%(objectname)|%(creatordate:iso-strict)',
+      'refs/minions/quarantine',
+      'refs/minions/quarantine-wip',
+    ], { cwd: localPath, timeout: 15000 });
+    return String(output || '').split(/\r?\n/).filter(Boolean).map(line => {
+      const [ref, sha, createdAt] = line.split('|');
+      return {
+        project: project.name || '',
+        ref,
+        sha,
+        createdAt: createdAt || '',
+        kind: ref.startsWith('refs/minions/quarantine-wip/') ? 'wip' : 'commits',
+      };
+    });
+  }));
+  const items = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result.status === 'fulfilled') items.push(...result.value);
+    else items.push({ project: candidates[i].name || '', error: result.reason?.message || String(result.reason) });
+  }
+  return items.sort((a, b) => String(b.createdAt || '').localeCompare(String(a.createdAt || '')));
+}
+
+module.exports = { listQuarantineRefs };

package/engine/queries.js

@@ -679,8 +679,8 @@ function getInbox() {
 // dispatch.completed (most recent) → done/error
 // neither → idle
 // Metadata (resultSummary, verdict, pr) is carried on dispatch entries.
-function getAgentStatus(agentId) {
-  const dispatch = getDispatch();
+function getAgentStatus(agentId, context = {}) {
+  const dispatch = context.dispatch || getDispatch();
 
   // Check active dispatch
   const active = (dispatch.active || []).find(d => d.agent === agentId);
@@ -726,7 +726,7 @@ function getAgentStatus(agentId) {
   // Guard: only trust dispatched state within 2x stale-orphan timeout to prevent stale
   // dispatched items from permanently showing an agent as working after a dead process.
   try {
-    const config = getConfig();
+    const config = context.config || getConfig();
     const staleOrphanTimeout = config.engine?.heartbeatTimeout || ENGINE_DEFAULTS.heartbeatTimeout;
     const staleThresholdMs = staleOrphanTimeout * 2;
     const now = Date.now();
@@ -734,7 +734,7 @@ function getAgentStatus(agentId) {
     // status, dispatched_at, …), never _pr/_artifacts/_notes. Skipping
     // enrichment keeps the per-idle-agent getAgents() roster build off the
     // heavy detail-modal path. (Fix #3 — dashboard event-loop perf.)
-    const allItems = getWorkItems(config, { enrich: false });
+    const allItems = context.workItems || getWorkItems(config, { enrich: false });
     const latestInFlight = allItems
       .filter(w => {
         if ((w.dispatched_to || '').toLowerCase() !== String(agentId).toLowerCase()) return false;
@@ -771,6 +771,8 @@ function getAgents(config) {
 
   // Include temp agents that are currently active so they show up in agent tiles
   const dispatch = getDispatch();
+  let leanWorkItems = [];
+  try { leanWorkItems = getWorkItems(config, { enrich: false }); } catch { /* optional fallback data */ }
   const seen = new Set(roster.map(a => a.id));
   for (const d of (dispatch.active || [])) {
     if (d.agent && d.agent.startsWith('temp-') && !seen.has(d.agent)) {
@@ -793,7 +795,7 @@ function getAgents(config) {
     const inboxFiles = allInboxFiles.filter(f => f.includes(a.id));
     let steeringInboxFiles = [];
     try { steeringInboxFiles = steering.listUnreadSteeringMessages(a.id); } catch { steeringInboxFiles = []; }
-    const s = getAgentStatus(a.id); // derives from dispatch state
+    const s = getAgentStatus(a.id, { dispatch, config, workItems: leanWorkItems });
 
     let lastAction = 'Waiting for assignment';
     let lastActionPrefix = null;
@@ -2157,7 +2159,7 @@ function getPrdInfo(config) {
   // funnel each PRD through this one processor so the consumed shape
   // (existingPrds / verifyPrsByPlan / allPrdItems) is identical by construction.
   const processPrd = (pf, archived, plan, mtimeMs) => {
-    if (!plan || !plan.missing_features) return;
+    if (!plan || !Array.isArray(plan.missing_features)) return;
     // Phase 10 step 4.2: archived-ness is the FLAG, not the directory. `archived`
     // is the physical-location signal (prd/ vs prd/archive/); a PRD archived
     // IN PLACE (stays in prd/ with archived:true / status:'archived') must still

package/engine/restart-health.js

@@ -32,6 +32,14 @@ function readEngineControl(minionsHome) {
   }
 }
 
+function readSupervisorPid(minionsHome) {
+  try {
+    return normalizePid(fs.readFileSync(path.join(minionsHome, 'engine', 'supervisor.pid'), 'utf8').trim());
+  } catch {
+    return null;
+  }
+}
+
 function normalizePid(pid) {
   const n = Number(pid);
   return Number.isInteger(n) && n > 0 ? n : null;
@@ -122,7 +130,10 @@ async function checkRestartHealth(options = {}) {
     dashboardUrl,
     dashboardPid,
     dashboardPort = 7331,
+    expectedEnginePid,
+    supervisorPid,
     readControl = readEngineControl,
+    readSupervisorPid: readSupPid = readSupervisorPid,
     isProcessAlive: isAlive = isProcessAlive,
     isPortListening: portCheck = isPortListening,
     httpGetJson: getJson = httpGetJson,
@@ -130,8 +141,10 @@ async function checkRestartHealth(options = {}) {
 
   const control = readControl(minionsHome);
   const pid = normalizePid(control && control.pid);
+  const expectedEngine = normalizePid(expectedEnginePid);
   const engineAlive = pid ? isAlive(pid) : false;
-  const engineOk = control && control.state === 'running' && engineAlive;
+  const engineOwned = expectedEngine == null || pid === expectedEngine;
+  const engineOk = control && control.state === 'running' && engineAlive && engineOwned;
 
   // Two strategies for the dashboard check:
   //   1) Process + port-listening (preferred from `minions restart` since
@@ -196,11 +209,54 @@ async function checkRestartHealth(options = {}) {
     dashboardSnapshot = { kind: 'http', url, ok: !!(dashboard && dashboard.ok), statusCode: dashboard && dashboard.statusCode, status: dashboardStatus };
   }
 
+  let supervisorOk = true;
+  let supervisorSnapshot = null;
+  if (supervisorPid != null) {
+    const expectedSupervisor = normalizePid(supervisorPid);
+    const recordedSupervisor = normalizePid(readSupPid(minionsHome));
+    const supervisorAlive = expectedSupervisor ? isAlive(expectedSupervisor) : false;
+    supervisorOk = !!(expectedSupervisor && supervisorAlive && recordedSupervisor === expectedSupervisor);
+    supervisorSnapshot = {
+      pid: expectedSupervisor,
+      alive: supervisorAlive,
+      recordedPid: recordedSupervisor,
+      owned: recordedSupervisor === expectedSupervisor,
+    };
+  }
+
+  let topologyOk = true;
+  let topologySnapshot = null;
+  if (engineOk && dashboardOk && supervisorOk && options.requireExactTopology) {
+    const listPids = options.listProcessPids;
+    const scripts = options.topologyScripts || {};
+    if (typeof listPids !== 'function') {
+      topologyOk = false;
+      topologySnapshot = { error: 'process enumerator unavailable' };
+    } else {
+      const expected = {
+        engine: expectedEngine,
+        dashboard: normalizePid(dashboardPid),
+        supervisor: normalizePid(supervisorPid),
+      };
+      const actual = {};
+      for (const kind of ['engine', 'dashboard', 'supervisor']) {
+        try {
+          actual[kind] = [...new Set((listPids(scripts[kind]) || []).map(normalizePid).filter(Boolean))];
+        } catch {
+          actual[kind] = [];
+        }
+      }
+      topologyOk = Object.keys(expected).every(kind =>
+        expected[kind] != null && actual[kind].length === 1 && actual[kind][0] === expected[kind]);
+      topologySnapshot = { expected, actual };
+    }
+  }
+
   const errors = [];
   if (!engineOk) {
     const state = control && control.state ? control.state : 'unknown';
     const pidLabel = pid || 'none';
-    errors.push(`Engine is not healthy (state=${state}, pid=${pidLabel}, alive=${engineAlive ? 'yes' : 'no'})`);
+    errors.push(`Engine is not healthy (state=${state}, pid=${pidLabel}, alive=${engineAlive ? 'yes' : 'no'}, owned=${engineOwned ? 'yes' : 'no'})`);
   }
   if (!dashboardOk) {
     const where = dashboardKind === 'http'
@@ -208,11 +264,19 @@ async function checkRestartHealth(options = {}) {
       : `dashboard pid=${normalizePid(dashboardPid) || 'none'} port=${dashboardPort}`;
     errors.push(`Dashboard failed health check at ${where} (${dashboardDetail})`);
   }
+  if (!supervisorOk) {
+    errors.push(`Supervisor is not healthy (pid=${supervisorSnapshot.pid || 'none'}, alive=${supervisorSnapshot.alive ? 'yes' : 'no'}, recordedPid=${supervisorSnapshot.recordedPid || 'none'}, owned=${supervisorSnapshot.owned ? 'yes' : 'no'})`);
+  }
+  if (!topologyOk) {
+    errors.push(`Minions process topology is not exclusive (${JSON.stringify(topologySnapshot)})`);
+  }
 
   return {
-    ok: engineOk && dashboardOk,
-    engine: { state: control && control.state, pid, alive: engineAlive },
+    ok: engineOk && dashboardOk && supervisorOk && topologyOk,
+    engine: { state: control && control.state, pid, alive: engineAlive, owned: engineOwned },
     dashboard: dashboardSnapshot,
+    supervisor: supervisorSnapshot,
+    topology: topologySnapshot,
     errors,
   };
 }
@@ -310,6 +374,7 @@ module.exports = {
     isProcessAlive,
     isPortListening,
     readEngineControl,
+    readSupervisorPid,
     normalizePid,
   },
 };

package/engine/routing.js

@@ -118,7 +118,7 @@ function getTempBudget() { return _tempBudget; }
 function normalizeWorkType(workType, fallback = WORK_TYPE.IMPLEMENT) {
   const type = String(workType || fallback || '').trim();
   if (!type) return fallback;
-  return type;
+  return shared.normalizeLiveValidationWorkType(type);
 }
 
 function routeForWorkType(workType) {