@yemi33/minions 0.1.2381 → 0.1.2383

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

@@ -784,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
@@ -1179,12 +1214,10 @@ function formatPrContextSuffix(pr) {
 // ─── Work Discovery Helpers ──────────────────────────────────────────────────
 
 function buildBaseVars(agentId, config, project) {
-  // W-mq15r0cx — surface the LLM model id alongside the agent name so PR
-  // comment sign-offs can stamp `<agent> · <model>` and humans can tell
-  // which agent + which model authored the comment. Falls through to
-  // 'unknown' (defensive only) rather than crashing or omitting the
-  // field when neither agent.model nor engine.defaultModel resolves —
-  // omitting would leave a dangling `· ` in the rendered sign-off.
+  // This is the provisional requested model used in prompt examples. The
+  // `minions pr comment` path replaces it with runtime/session evidence from
+  // the active dispatch before posting; `unknown` survives only when neither
+  // runtime nor requested-model evidence exists.
   const resolvedModel = shared.resolveAgentModel(
     config?.agents?.[agentId] || null,
     config?.engine || null

package/engine/pooled-agent-process.js

@@ -15,30 +15,23 @@
  * completely unmodified whether `proc` is a real child_process or a pooled
  * ACP lease.
  *
- * Output translation (parity, not full fidelity): ACP `session/update` text
- * chunks are re-encoded as the SAME Copilot JSONL event shape
- * `engine/runtimes/copilot.js#parseOutput` already parses from a real
- * `copilot` CLI stdout stream — `{"type":"assistant.message_delta","data":
- * {"deltaContent":"..."}}` per chunk, plus a terminal `{"type":"result",
- * "sessionId":...,"usage":{...}}` line once the turn completes. This is the
- * minimum subset `parseOutput` needs to recover an equivalent `{text,
- * sessionId, usage}` to the cold-spawn path (deltas alone populate its
- * `pendingDeltaContent` accumulator; no `assistant.message`/`session.
- * tools_updated`/`tool.execution_*` events are required for that recovery).
- * Tool-call and model-announcement events are intentionally NOT synthesized
- * — a deliberate, documented scope limit, not an oversight: the live-output
- * log still gets the real text in real time either way, and `usage`'s
- * cost/token fields are already null-for-copilot on the cold path (see
- * `runtimes/copilot.js#parseOutput`), so nothing measurable is lost.
+ * Output translation (parity, not full fidelity) is adapter-owned through
+ * `encodePooledOutput()`. The facade only forwards semantic chunk/result
+ * events, so a harness can change its JSONL schema without changing this file.
  */
 
 const { EventEmitter } = require('events');
 const { PassThrough } = require('stream');
+const {
+  resolveRuntimeByCapability,
+  encodePooledOutput,
+} = require('./runtimes');
 
 class PooledAgentProcess extends EventEmitter {
   /**
    * @param {object} opts
    * @param {object} opts.pool - engine/agent-worker-pool.js module (or a test double)
+   * @param {object} opts.runtime - resolved runtime adapter
    * @param {string} opts.dispatchId
    * @param {string} opts.cwd
    * @param {string} [opts.model]
@@ -51,7 +44,7 @@ class PooledAgentProcess extends EventEmitter {
    * @param {string} opts.promptText - task/user prompt only
    */
   constructor({
-    pool, dispatchId, cwd, model, effort, mcpServers, hermeticDirs,
+    pool, runtime, dispatchId, cwd, model, effort, mcpServers, hermeticDirs,
     processEnv, sessionContext, systemPromptText, promptText,
   }) {
     super();
@@ -61,10 +54,12 @@ class PooledAgentProcess extends EventEmitter {
     this.stdout = new PassThrough();
     this.stderr = new PassThrough();
     this._pool = pool;
+    this._runtime = runtime || resolveRuntimeByCapability('acpWorkerPool');
     this._dispatchId = dispatchId;
     this._handle = null;
     this._closed = false;
     this._startedAt = Date.now();
+    this._runtimeOutputError = null;
 
     // Fire-and-forget, mirroring child_process.spawn()'s async nature — the
     // facade is usable (event listeners can be attached) immediately, before
@@ -82,6 +77,7 @@ class PooledAgentProcess extends EventEmitter {
     let handle;
     try {
       handle = await this._pool.acquireWorker({
+        runtime: this._runtime,
         dispatchId: this._dispatchId, cwd, model, effort, mcpServers, hermeticDirs,
         processEnv, sessionContext,
       });
@@ -102,6 +98,9 @@ class PooledAgentProcess extends EventEmitter {
 
     this._handle = handle;
     this.pid = typeof handle.pid === 'number' ? handle.pid : null;
+    if (handle.currentModel) {
+      this._writeRuntimeEvent({ kind: 'model', model: handle.currentModel });
+    }
     // Lets engine.js write the PID-file equivalent (spawn-agent.js normally
     // does this itself, from inside the child process) as soon as a real OS
     // PID is known — see engine.js's pooled branch in spawnAgent().
@@ -113,16 +112,14 @@ class PooledAgentProcess extends EventEmitter {
         systemPromptText,
         onChunk: (text) => {
           if (!text) return;
-          this._writeStdoutEvent({ type: 'assistant.message_delta', data: { deltaContent: text } });
+          this._writeRuntimeEvent({ kind: 'chunk', text });
         },
         onDone: (result) => {
-          this._writeStdoutEvent({
-            type: 'result',
+          this._writeRuntimeEvent({
+            kind: 'result',
             sessionId: handle.sessionId || null,
-            usage: {
-              totalApiDurationMs: Date.now() - this._startedAt,
-              stopReason: (result && result.stopReason) || null,
-            },
+            durationMs: Date.now() - this._startedAt,
+            stopReason: (result && result.stopReason) || null,
           });
         },
         onError: (err) => {
@@ -137,11 +134,16 @@ class PooledAgentProcess extends EventEmitter {
       try { handle.release(); } catch { /* best-effort */ }
       this._handle = null;
     }
-    this._finish(sawError ? 1 : 0);
+    this._finish(sawError || this._runtimeOutputError ? 1 : 0);
   }
 
-  _writeStdoutEvent(obj) {
-    try { this.stdout.write(JSON.stringify(obj) + '\n'); } catch { /* best-effort */ }
+  _writeRuntimeEvent(event) {
+    try {
+      this.stdout.write(encodePooledOutput(this._runtime, event));
+    } catch (err) {
+      this._runtimeOutputError = err;
+      try { this.stderr.write(`Runtime output encoding failed: ${err.message}\n`); } catch {}
+    }
   }
 
   _finish(code) {

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