@yemi33/minions 0.1.2381 → 0.1.2382

package/engine/lifecycle.js

@@ -4578,8 +4578,8 @@ function parseCompletionBoolean(value) {
 // detected, or null otherwise. The status must be a successful terminal state
 // — a failed/partial/in-progress completion that also claims `noop` is a
 // contradiction and falls through to the normal contract.
-function parseCompletionNoop(completion) {
-  if (!completion || typeof completion !== 'object') return null;
+function completionDeclaresNoop(completion) {
+  if (!completion || typeof completion !== 'object') return false;
   const explicit = parseCompletionBoolean(completion.noop);
   let resultIsNoop = false;
   if (typeof completion.result === 'string') {
@@ -4587,7 +4587,11 @@ function parseCompletionNoop(completion) {
   } else if (completion.result && typeof completion.result === 'object') {
     resultIsNoop = String(completion.result.type || '').trim().toLowerCase() === 'noop';
   }
-  if (explicit !== true && !resultIsNoop) return null;
+  return explicit === true || resultIsNoop;
+}
+
+function parseCompletionNoop(completion) {
+  if (!completionDeclaresNoop(completion)) return null;
   const status = normalizeCompletionStatus(completion.status);
   if (status && status !== 'success' && status !== 'done' && status !== 'complete') return null;
   const reason = String(
@@ -4600,6 +4604,53 @@ function parseCompletionNoop(completion) {
   return reason || 'no-op completion';
 }
 
+function classifyBenignZeroTargetOutcome(dispatchItem, completion, resultSummary) {
+  const item = dispatchItem?.meta?.item;
+  if (!item?._scheduleId || item.createdBy !== 'scheduler') return null;
+  const type = dispatchItem?.type || item.type;
+  if (![WORK_TYPE.SETUP, WORK_TYPE.EXPLORE, WORK_TYPE.REVIEW].includes(type)) return null;
+  if (!completionDeclaresNoop(completion)) return null;
+  if (parseCompletionBoolean(completion?.needs_rerun ?? completion?.needsRerun) === true) return null;
+  if (parseCompletionBoolean(completion?.retryable) === true) return null;
+  if (completion?.securityFlags?.injectionAttempt === true) return null;
+  const failureClass = String(completion?.failure_class || '').trim().toLowerCase();
+  const nonceUnavailable = failureClass === 'completion-nonce-unavailable'
+    || failureClass === 'nonce-unavailable';
+  if (hasActionableFailureClass(failureClass) && !nonceUnavailable) return null;
+  const status = normalizeCompletionStatus(completion?.status);
+  const successfulStatus = status === 'success' || status === 'done' || status === 'complete';
+  const nonceTransportFailure = nonceUnavailable && (status.startsWith('fail') || status === 'error');
+  if (!successfulStatus && !nonceTransportFailure) return null;
+
+  const evidence = [...new Set([
+    completion?.summary,
+    completion?.noopReason,
+    completion?.noop_reason,
+    resultSummary,
+  ].filter(Boolean).map(value => String(value).trim()))].join(' ').trim();
+  if (!evidence) return null;
+
+  const mutationOccurred = [
+    /\b(?:a|one|[1-9]\d*)\s+(?:new\s+)?(?:work items?|reviews?|pull requests?|prs?|issues?)\s+(?:(?:was|were)\s+)?(?:created|enrolled|dispatched|posted|deleted|removed)\b/i,
+    /\b(?:created|enrolled|dispatched|posted|deleted|removed)\s+[1-9]\d*\b/i,
+  ].some(pattern => pattern.test(evidence));
+  if (mutationOccurred) return null;
+
+  const zeroTargets = [
+    /\bno\s+[^.!?\n]{0,120}\b(?:needed|required|eligible|qualif(?:y|ied)|found|remain(?:ed|ing)?|to\s+(?:review|remove|dispatch|enroll|process|merge|fix))\b/i,
+    /\bno\s+(?:open\s+issues?|eligible|qualifying|matching|context-only|merged|abandoned)\b/i,
+    /\b(?:0|zero)\s+(?:eligible|qualifying|matching|context-only|open)\b/i,
+  ].some(pattern => pattern.test(evidence));
+  if (!zeroTargets) return null;
+
+  const noMutation = [
+    /\bno\s+(?:api\s+)?(?:post|mutations?|writes?|actions?|changes?|modifications?|updates?|delete requests?|work items?|review work items?)\s+(?:(?:was|were)\s+)?(?:made|performed|taken|sent|created)?\b/i,
+    /\b(?:0|zero)\s+(?:were\s+)?(?:created|enrolled|dispatched|posted|deleted|removed)\b/i,
+    /\b(?:created|enrolled|dispatched|posted|deleted|removed)\s+(?:0|zero)\b/i,
+  ].some(pattern => pattern.test(evidence));
+  return noMutation ? evidence : null;
+}
+
 function normalizeReviewVerdict(verdict) {
   const value = String(verdict || '').trim().toLowerCase().replace(/[\s-]+/g, '_');
   if (value === 'approve' || value === 'approved') return REVIEW_STATUS.APPROVED;
@@ -5482,11 +5533,15 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // P-d2a8f6c1: a nonce mismatch always counts as an agent-reported failure
   // (regardless of what the discarded report claimed). This forces both the
   // effectiveSuccess gate below and the dispatch result in engine.js to ERROR.
-  const agentReportedFailure = !!nonceMismatch
-    || completionStatus.startsWith('fail')
+  const benignNoop = nonceMismatch
+    ? null
+    : classifyBenignZeroTargetOutcome(dispatchItem, structuredCompletion, completionGateSummary);
+  const agentReportedFailure = !!nonceMismatch || (!benignNoop && (
+    completionStatus.startsWith('fail')
     || completionStatus === 'error'
     || hasActionableFailureClass(structuredCompletion?.failure_class)
-    || agentNeedsRerun;
+    || agentNeedsRerun
+  ));
   // Untrusted completions cannot be honored as "retryable" by the agent — its
   // retryable claim was discarded with the rest of the report. Force false.
   const agentRetryable = nonceMismatch ? false : parseCompletionBoolean(structuredCompletion?.retryable);
@@ -5499,7 +5554,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   if (autoRecovered) {
     log('info', `Auto-recovery: agent failed but created ${prsCreatedCount} PR(s) — upgrading ${meta.item.id} to done`);
   }
-  const effectiveSuccess = !nonceMismatch && ((isSuccess && !agentReportedFailure) || autoRecovered);
+  const effectiveSuccess = !nonceMismatch && (benignNoop || (isSuccess && !agentReportedFailure) || autoRecovered);
   if (!nonceMismatch) {
     const episodeOutcome = effectiveSuccess
       ? (autoRecovered || completionStatus.startsWith('partial') ? 'partial' : 'success')
@@ -5571,7 +5626,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // Without this, the second run produces no VERDICT, _retryCount increments,
   // and after 3 such bailouts the WI flips to status=failed even though the
   // original review was posted on the first run.
-  if (effectiveSuccess && type === WORK_TYPE.REVIEW && meta?.item?.id) {
+  if (effectiveSuccess && type === WORK_TYPE.REVIEW && meta?.item?.id && !benignNoop) {
     const verdict = reviewVerdictFromCompletion(structuredCompletion) || parseReviewVerdict(resultSummary);
     if (!verdict && isReviewBailout(resultSummary)) {
       log('info', `Review ${meta.item.id} bailed out (review already posted) — treating as DONE without retry`);
@@ -5721,7 +5776,9 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
 
   let completionContractFailure = null;
   if (effectiveSuccess && meta?.item?.id && !skipDoneStatus) {
-    const nonTerminalCompletion = detectNonTerminalResultSummary(completionGateSummary, structuredCompletion, reportCompletion, { detectPhantom });
+    const nonTerminalCompletion = benignNoop
+      ? null
+      : detectNonTerminalResultSummary(completionGateSummary, structuredCompletion, reportCompletion, { detectPhantom });
     if (nonTerminalCompletion) {
       const isPhantomDetection = nonTerminalCompletion.phrase === 'phantom-completion';
       // P-e0b4f7a5 — before deferring a phantom retry, attempt to recover
@@ -5753,7 +5810,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // shipped, dispatch premise wrong, self-authored review, etc.). Skip the PR
   // attachment contract — a missing PR is intentional, not a silent failure.
   const noopRationale = (effectiveSuccess && meta?.item?.id && !skipDoneStatus)
-    ? parseCompletionNoop(structuredCompletion)
+    ? (parseCompletionNoop(structuredCompletion) || benignNoop)
     : null;
   if (noopRationale) {
     log('info', `No-op completion for ${meta.item.id}: ${noopRationale.slice(0, 200)}`);
@@ -6133,7 +6190,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   const hardContractFail = completionContractFailure?.severity === 'hard'
     || completionContractFailure?.nonTerminal === true;
   const finalResult = hardContractFail ? DISPATCH_RESULT.ERROR : (effectiveSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR);
-  if (type === WORK_TYPE.REVIEW && finalResult === DISPATCH_RESULT.SUCCESS && !skipDoneStatus) {
+  if (type === WORK_TYPE.REVIEW && finalResult === DISPATCH_RESULT.SUCCESS && !skipDoneStatus && !benignNoop) {
     await updatePrAfterReview(agentId, meta?.pr, meta?.project, config, resultSummary, structuredCompletion, dispatchItem);
   } else if (type === WORK_TYPE.REVIEW) {
     log('warn', `Skipping PR review metadata update for ${meta?.pr?.id || meta?.pr?.url || '(unknown PR)'} because review dispatch ${dispatchItem.id} did not complete cleanly`);
@@ -6232,7 +6289,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   const metricsResult = isAutoRetry ? 'retry' : finalResult;
   updateMetrics(agentId, dispatchItem, metricsResult, taskUsage, prsCreatedCount, model);
 
-  return { resultSummary, taskUsage, autoRecovered, structuredCompletion, completionContractFailure, agentReportedFailure, agentRetryable, nonceMismatch };
+  return { resultSummary, taskUsage, autoRecovered, structuredCompletion, completionContractFailure, agentReportedFailure, agentRetryable, nonceMismatch, benignNoop };
 }
 
 // ─── PR → PRD Status Sync ─────────────────────────────────────────────────────
@@ -6986,6 +7043,7 @@ module.exports = {
   parseReviewVerdict,
   isReviewBailout,
   parseCompletionNoop,
+  classifyBenignZeroTargetOutcome, // exported for testing
   detectNonTerminalResultSummary,
   deferNonTerminalCompletion,
   deferPhantomCompletion,

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

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