@yemi33/minions 0.1.1645 → 0.1.1646

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.1.1646 (2026-05-01)
+
+### Fixes
+- scope syncPrsFromOutput inbox fallback to empty stdout
+- execAsync no longer unref's child, fixes silent test exit
+
+### Other
+- Prevent CLI dispatch from orphaning agents
+- Harden eval loop gating audit
+- chore: gitignore agent runtime state and stray repo-root artifacts
+- revert: remove CC hallucination detector — too many false positives
+
 ## 0.1.1645 (2026-04-30)
 
 ### Other

package/README.md

@@ -545,7 +545,7 @@ Engine behavior is controlled via `config.json`. Key settings:
 | `autoDecompose` | true | Auto-decompose `implement:large` items into sub-tasks before dispatch |
 | `autoApprovePlans` | false | Auto-approve PRDs without waiting for human approval |
 | `evalLoop` | true | Auto-dispatch review → fix cycles after implementation completes |
-| `evalMaxIterations` | 3 | Max review → fix cycles before escalating to human |
+| `evalMaxIterations` | 3 | Max minion review → fix cycles before pausing minion review automation; human feedback, build fixes, and conflict fixes continue |
 | `evalMaxCost` | null | USD ceiling per work item across all eval iterations (null = no limit) |
 | `meetingRoundTimeout` | 600000 (10min) | Timeout per meeting round before auto-advance |
 | `ccModel` | `sonnet` | Model for Command Center and doc-chat (sonnet/haiku/opus) |

package/dashboard/js/command-center.js

@@ -706,10 +706,6 @@ async function _ccDoSend(message, skipUserMsg, forceTabId) {
           // Surface as an inline warning so the user knows actions were dropped
           // (was previously silent — appeared as "actions failed" with no signal).
           addMsg('system', '<div style="padding:6px 12px;font-size:11px;color:var(--red);background:var(--surface2);border-radius:6px;margin:4px 0">⚠️ Actions block emitted but JSON could not be parsed — no actions were executed. Resend or rephrase. (' + escHtml(String(evt.actionParseError).slice(0, 200)) + ')</div>', false, activeTabId);
-        } else if (evt.hallucinationWarning) {
-          // CC said it dispatched/queued/assigned something but emitted no actions block —
-          // surface the false-claim guard so the user knows nothing actually ran.
-          addMsg('system', '<div style="padding:6px 12px;font-size:11px;color:var(--orange);background:var(--surface2);border-radius:6px;margin:4px 0">⚠️ ' + escHtml(evt.hallucinationWarning) + '</div>', false, activeTabId);
         }
       } else if (evt.type === 'error') {
         terminalEventSeen = true;

package/dashboard.js

@@ -1345,16 +1345,6 @@ function _ccValidateAction(action) {
   }
 }
 
-// Hallucination guard: detect prose like "I dispatched ..." when no ===ACTIONS=== block was emitted.
-// The regex is intentionally narrow — we only want affirmative claims about completed work, not
-// hypotheticals like "I would dispatch this" or "consider dispatching X".
-function _detectClaimedActionWithoutBlock(displayText, actions) {
-  if (Array.isArray(actions) && actions.length > 0) return null; // there are actions, no false claim
-  const triggers = /\b(dispatched|enqueued|queued|created (?:a |the )?work item|assigned (?:this |it )?(?:to|for)|spun up|kicked off|i'?ll dispatch|i (?:have )?(?:just )?dispatched)\b/i;
-  if (!triggers.test(displayText || '')) return null;
-  return 'CC described an action ("dispatched", "assigned", etc.) but no ===ACTIONS=== block was emitted. No work was actually queued. Resend or rephrase the request.';
-}
-
 async function executeCCActions(actions) {
   const results = [];
   for (const action of actions) {
@@ -4864,8 +4854,6 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         const { _actionParseError, ...parsedReply } = parsed;
         const reply = { ...parsedReply, sessionId: ccSession.sessionId, newSession: !wasResume };
         if (_actionParseError) reply.actionParseError = _actionParseError;
-        const hallucinationWarning = _detectClaimedActionWithoutBlock(parsed.text, parsed.actions);
-        if (hallucinationWarning) reply.hallucinationWarning = hallucinationWarning;
         if (sessionReset) reply.sessionReset = true;
         return jsonReply(res, 200, reply);
       } finally {
@@ -5149,8 +5137,6 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         // Issue #1834: surface action JSON parse failures so the UI can warn
         // instead of silently dropping. Client renders this as a small notice.
         if (_actionParseError) donePayload.actionParseError = _actionParseError;
-        const hallucinationWarning = _detectClaimedActionWithoutBlock(displayText, actions);
-        if (hallucinationWarning) donePayload.hallucinationWarning = hallucinationWarning;
         if (sessionReset) donePayload.sessionReset = true;
         liveState.donePayload = donePayload;
         if (liveState.writer) liveState.writer(donePayload);
@@ -6550,7 +6536,6 @@ module.exports = {
   _resolveSkillReadPath,
   DOC_CHAT_DOCUMENT_DELIMITER,
   _ccValidateAction,
-  _detectClaimedActionWithoutBlock,
   executeCCActions,
 };
 

package/docs/auto-discovery.md

@@ -37,7 +37,7 @@ Before scanning, the engine materializes plans and specs into project work items
 | `_mergeConflict: true` | Route to author for conflict resolution | `fix` |
 Skips PRs where `status !== "active"`.
 
-PR fix triggers are evaluated in this source order inside `discoverFromPrs()`: review feedback first (`engine.js:2166-2180`), human feedback second (`engine.js:2191-2226`), build failure third (`engine.js:2229-2271`), and merge conflict fourth (`engine.js:2299-2317`). Conflict fixes are additionally gated by `!fixDispatched` (`engine.js:2301`), so any earlier successful fix dispatch in the same PR discovery pass suppresses the conflict fix until a later pass.
+Inside `discoverFromPrs()`, `evalLoop` / `evalMaxIterations` only gate the minion review loop: initial minion reviews, minion re-reviews, and minion review-feedback fixes. Human-feedback fixes are evaluated outside that gate, build failures use the separate `maxBuildFixAttempts` cap, and merge conflicts use the separate `autoFixConflicts` gate. Conflict fixes are additionally gated by `!fixDispatched`, so an earlier successful human/review/build fix dispatch in the same PR discovery pass suppresses the conflict fix until a later pass.
 
 ### Source 2: PRD Gap Analysis (via `materializePlansAsWorkItems`)
 

package/docs/pr-review-fix-loop.md

@@ -23,30 +23,34 @@ How the engine manages the lifecycle of a PR from creation through review, fix,
 
 ## 4. Fix dispatch trigger order
 
-`discoverFromPrs()` evaluates PR auto-fix triggers in a fixed order during each discovery pass:
+`discoverFromPrs()` evaluates PR review/fix triggers in a fixed order during each discovery pass:
 
-1. Review feedback (`changes-requested`) — `engine.js:2166-2180`
-2. Human feedback (`humanFeedback.pendingFix` or coalesced feedback) — `engine.js:2191-2226`
-3. Build failure (`buildStatus === 'failing'`) — `engine.js:2229-2271`
-4. Merge conflict (`_mergeConflict`) — `engine.js:2299-2317`
+1. Initial minion review (`reviewStatus === 'pending'`)
+2. Human feedback (`humanFeedback.pendingFix` or coalesced feedback)
+3. Minion re-review (`reviewStatus === 'waiting'` after a fix)
+4. Minion review feedback (`changes-requested`)
+5. Build failure (`buildStatus === 'failing'`)
+6. Merge conflict (`_mergeConflict`)
 
-When multiple problems coexist, earlier triggers get the first chance to enqueue work. The local `fixDispatched` flag is declared before the fix triggers (`engine.js:2168`) and set after review-feedback, human-feedback, and build-failure dispatches (`engine.js:2180`, `engine.js:2226`, `engine.js:2271`). Conflict fixes run last and explicitly require `!fixDispatched` (`engine.js:2301`), so any earlier successful fix dispatch suppresses the conflict fix for that PR in the same discovery pass. Build fixes are evaluated after review and human feedback, but the build-fix condition itself is not gated by `!fixDispatched` (`engine.js:2238`).
+When multiple problems coexist, earlier triggers get the first chance to enqueue work. The local `fixDispatched` flag is declared before the fix triggers and set after human-feedback, review-feedback, and build-failure dispatches. Conflict fixes run last and explicitly require `!fixDispatched`, so any earlier successful fix dispatch suppresses the conflict fix for that PR in the same discovery pass. Build fixes are evaluated after human and minion review feedback, but the build-fix condition itself is not gated by `!fixDispatched`.
 
-### A. Review feedback (`changes-requested`)
+`evalMaxIterations` only applies to the minion review loop: initial minion review, minion re-review, and minion review-feedback fixes. It does not gate human-feedback fixes, build-failure fixes, or merge-conflict fixes.
 
-- Gate: `reviewStatus === 'changes-requested'` + `!awaitingReReview` + `!evalEscalated` + not dispatched + not on cooldown
-- Routes to PR author via `_author_` routing token
-- `review_note` = reviewer's feedback
-- Sets `fixDispatched = true` — prevents human-feedback and conflict fixes from also firing this pass
-- **Review-loop escalation**: after `evalMaxIterations` review→fix cycles (default 3), `_evalEscalated` is set on the PR and *only this trigger plus review/re-review* stop. Triggers B (human comments), C (build failures), and the merge-conflict fix path keep running. The dashboard PR row distinguishes the two states with separate badges (review badge `review-escalated` vs. build badge `build-escalated`).
+### A. Human comments (`humanFeedback.pendingFix`)
 
-### B. Human comments (`humanFeedback.pendingFix`)
-
-- Gate: `pendingFix || coalescedFeedback` + `!awaitingReReview` + `!fixDispatched`
+- Gate: `pendingFix || coalescedFeedback` + not already dispatched/on cooldown
 - Agent comments filtered out via `/\bMinions\s*\(/i` regex on comment body
 - Coalesces multiple comments arriving during cooldown into single fix
 - Routes to author
-- Not gated by `_evalEscalated` — humans can always force more fixes via PR comments even after the review loop escalates.
+- Not gated by `_evalEscalated` — humans can always force more fixes via PR comments even after the minion review loop escalates.
+
+### B. Review feedback (`changes-requested`)
+
+- Gate: `reviewStatus === 'changes-requested'` + `!awaitingReReview` + `!evalEscalated` + not dispatched + not on cooldown
+- Routes to PR author via `_author_` routing token
+- `review_note` = reviewer's feedback
+- Sets `fixDispatched = true` — prevents the later conflict fix from also firing this pass
+- **Review-loop escalation**: after `evalMaxIterations` review→fix cycles (default 3), `_evalEscalated` is set on the PR and *only this trigger plus minion review/re-review* stop. Triggers A (human comments), C (build failures), and D (merge conflicts) keep running. The dashboard PR row distinguishes the two states with separate badges (review badge `review-escalated` vs. build badge `build-escalated`).
 
 ### C. Build failures (`buildStatus === 'failing'`)
 
@@ -90,7 +94,7 @@ When multiple problems coexist, earlier triggers get the first chance to enqueue
 | Scenario | Guard |
 |---|---|
 | Simultaneous review + fix | `activePrIds` — skip PR if any dispatch in-flight |
-| Duplicate fix (review + human + conflict) | `fixDispatched` flag — later human/conflict triggers skip after earlier fix dispatches in the same PR pass |
+| Duplicate fix (human/review/build + conflict) | `fixDispatched` flag — conflict triggers skip after earlier fix dispatches in the same PR pass |
 | Branch write conflict | `isBranchActive()` mutex |
 | Fix while awaiting re-review | `awaitingReReview` (waiting + fixedAt) |
 | Build fix before CI runs | `_buildFixPushedAt` grace period (10min) |

package/engine/cli.js

@@ -21,6 +21,26 @@ function engine() {
 let _dispatchModule = null;
 function dispatchModule() { if (!_dispatchModule) _dispatchModule = require('./dispatch'); return _dispatchModule; }
 
+function isEngineProcessAlive(control) {
+  if (!control?.pid) return false;
+  if (control.pid === process.pid) return true;
+  try {
+    if (process.platform === 'win32') {
+      const { execSync } = require('child_process');
+      const out = execSync(`tasklist /FI "PID eq ${control.pid}" /NH`, {
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: 3000,
+      });
+      return new RegExp(`\\b${control.pid}\\b`).test(out) && out.toLowerCase().includes('node');
+    }
+    process.kill(control.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function handleCommand(cmd, args) {
   if (!cmd) {
     return commands.start();
@@ -910,16 +930,22 @@ const commands = {
   },
 
   dispatch() {
-    const e = engine();
-    console.log('Forcing dispatch cycle...');
     const control = getControl();
-    const prevState = control.state;
-    safeWrite(CONTROL_PATH, { ...control, state: 'running' });
-    e.tick();
-    if (prevState !== 'running') {
-      safeWrite(CONTROL_PATH, { ...control, state: prevState });
+    if (control.state === 'running' && isEngineProcessAlive(control)) {
+      safeWrite(CONTROL_PATH, { ...control, _wakeupAt: Date.now() });
+      console.log(`Dispatch wakeup requested from running engine (PID ${control.pid}).`);
+      return;
     }
-    console.log('Dispatch cycle complete.');
+
+    const activeCount = (getDispatch().active || []).length;
+    if (activeCount > 0) {
+      console.log(`Engine is not running, but ${activeCount} dispatch(es) are active.`);
+      console.log('Refusing to run a local dispatch tick because it cannot track live agent processes.');
+      console.log('Start the engine to re-attach or recover: node engine.js start');
+      return;
+    }
+
+    console.log('Engine is not running. Start it to dispatch work: node engine.js start');
   },
 
   spawn(agentId, ...promptParts) {

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-04-30T21:17:34.210Z"
+  "cachedAt": "2026-05-01T00:51:54.243Z"
 }

package/engine/dispatch.js

@@ -200,6 +200,36 @@ function readLiveWorkItem(meta) {
   return Array.isArray(items) ? items.find(i => i.id === itemId) || null : null;
 }
 
+function writeFailedAgentReport(item, reason, resultSummary, failureClass) {
+  if (!item?.id) {
+    log('warn', 'Cannot write failed agent report without dispatch id');
+    return;
+  }
+  const agentId = item.agent || 'engine';
+  const itemId = item.meta?.item?.id || '';
+  const title = item.meta?.item?.title || item.task || item.id;
+  const metadata = {
+    dispatchId: item.id,
+    sourceItem: itemId || null,
+    result: DISPATCH_RESULT.ERROR,
+    failureClass: failureClass || null,
+  };
+  const content = [
+    `# Agent Failed: ${title}`,
+    '',
+    `**Agent:** ${agentId}`,
+    `**Dispatch:** \`${item.id}\``,
+    itemId ? `**Work Item:** \`${itemId}\`` : '',
+    `**Type:** ${item.type || 'unknown'}`,
+    `**Result:** ${DISPATCH_RESULT.ERROR}`,
+    failureClass ? `**Failure Class:** ${failureClass}` : '',
+    reason ? `**Reason:** ${reason}` : '',
+    '',
+    resultSummary ? `## Summary\n${resultSummary}` : '## Summary\n(no agent summary captured)',
+  ].filter(Boolean).join('\n');
+  shared.writeToInbox(agentId, `agent-failure-${item.id}`, content, null, metadata);
+}
+
 // ─── Complete Dispatch ───────────────────────────────────────────────────────
 
 function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', resultSummary = '', opts = {}) {
@@ -238,6 +268,9 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
 
   if (item) {
     log('info', `Completed dispatch: ${id} (${result}${reason ? ': ' + reason : ''})`);
+    if (result === DISPATCH_RESULT.ERROR) {
+      writeFailedAgentReport(item, reason, resultSummary, failureClass);
+    }
 
     // Update source work item status on failure + auto-retry with backoff
     const retryableFailure = isRetryableFailureReason(reason, failureClass);

package/engine/lifecycle.js

@@ -778,16 +778,22 @@ function syncPrsFromOutput(output, agentId, meta, config) {
     }
   } catch {}
 
-  // Accept inbox fallback only when the agent wrote the explicit PR-created
-  // protocol line; generic PR mentions in findings/review notes are not evidence.
-  const today = dateStamp();
-  const inboxFiles = getInboxFiles().filter(f => f.includes(agentId) && f.includes(today));
-  for (const f of inboxFiles) {
-    const content = safeRead(path.join(INBOX_DIR, f));
-    if (!content) continue;
-    const prHeaderPattern = /(?:^|\n)\s*\*{0,2}(?:PR|Pull\s+Request|E2E\s+PR)\s+(?:created|opened|submitted)\*{0,2}\s*[:\-]\s*([^\n]+)/gi;
-    while ((match = prHeaderPattern.exec(content)) !== null) {
-      addPrUrlEvidence(match[1]);
+  // Accept inbox fallback ONLY when the agent's stdout is empty (rotated/lost).
+  // The inbox note is the durable artifact for the "gh pr create ran in a sibling
+  // dispatch whose stdout was rotated" case. When stdout has actual content (even
+  // without PR evidence — e.g. the agent ran gh issue view but didn't create a PR),
+  // we must NOT pull in PR URLs from leftover inbox files of prior dispatches —
+  // those would falsely attribute unrelated PRs to this run.
+  if (!output || !String(output).trim()) {
+    const today = dateStamp();
+    const inboxFiles = getInboxFiles().filter(f => f.includes(agentId) && f.includes(today));
+    for (const f of inboxFiles) {
+      const content = safeRead(path.join(INBOX_DIR, f));
+      if (!content) continue;
+      const prHeaderPattern = /(?:^|\n)\s*\*{0,2}(?:PR|Pull\s+Request|E2E\s+PR)\s+(?:created|opened|submitted)\*{0,2}\s*[:\-]\s*([^\n]+)/gi;
+      while ((match = prHeaderPattern.exec(content)) !== null) {
+        addPrUrlEvidence(match[1]);
+      }
     }
   }
 
@@ -1688,6 +1694,44 @@ function parseStructuredCompletion(stdout, runtimeName) {
   return result;
 }
 
+function normalizeCompletionStatus(status) {
+  return String(status || '').trim().toLowerCase().replace(/[\s_]+/g, '-');
+}
+
+function writeNonCleanAgentReport(dispatchItem, agentId, outcome, structuredCompletion, resultSummary, exitCode) {
+  if (!dispatchItem?.id || !outcome) {
+    log('warn', 'Cannot write non-clean agent report without dispatch id and outcome');
+    return;
+  }
+  const itemId = dispatchItem.meta?.item?.id || '';
+  const title = dispatchItem.meta?.item?.title || dispatchItem.task || dispatchItem.id;
+  const metadata = {
+    dispatchId: dispatchItem.id,
+    sourceItem: itemId || null,
+    result: outcome,
+    completionStatus: structuredCompletion?.status || null,
+  };
+  const structuredLines = structuredCompletion
+    ? Object.entries(structuredCompletion).map(([key, value]) => `- ${key}: ${value}`).join('\n')
+    : '- none';
+  const content = [
+    `# Agent ${outcome === 'partial' ? 'Partially Completed' : 'Reported Failure'}: ${title}`,
+    '',
+    `**Agent:** ${agentId}`,
+    `**Dispatch:** \`${dispatchItem.id}\``,
+    itemId ? `**Work Item:** \`${itemId}\`` : '',
+    `**Type:** ${dispatchItem.type || 'unknown'}`,
+    `**Exit Code:** ${exitCode}`,
+    `**Outcome:** ${outcome}`,
+    '',
+    `## Structured Completion`,
+    structuredLines,
+    '',
+    resultSummary ? `## Summary\n${resultSummary}` : '## Summary\n(no agent summary captured)',
+  ].filter(Boolean).join('\n');
+  shared.writeToInbox(agentId || 'engine', `agent-${outcome}-${dispatchItem.id}`, content, null, metadata);
+}
+
 /**
  * Handle decomposition result — parse sub-items from agent output and create child work items.
  * Called from runPostCompletionHooks when type === 'decompose'.
@@ -1827,6 +1871,12 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   }
   const effectiveSuccess = isSuccess || autoRecovered;
 
+  const completionStatus = normalizeCompletionStatus(structuredCompletion?.status);
+  if (completionStatus.startsWith('partial') || autoRecovered || (completionStatus.startsWith('fail') && isSuccess)) {
+    const outcome = completionStatus.startsWith('fail') ? 'failure' : 'partial';
+    writeNonCleanAgentReport(dispatchItem, agentId, outcome, structuredCompletion, resultSummary, code);
+  }
+
   // Handle decomposition results — create sub-items from decompose agent output
   let skipDoneStatus = false;
   if (type === WORK_TYPE.DECOMPOSE && effectiveSuccess && meta?.item?.id) {

package/engine/shared.js

@@ -563,7 +563,7 @@ function execSilent(cmd, opts = {}) {
 function execAsync(cmd, opts = {}) {
   const { timeout, ...rest } = opts;
   return new Promise((resolve, reject) => {
-    const child = _cbExec(cmd, { windowsHide: true, encoding: 'utf8', ...rest, timeout: timeout || 30000 }, (err, stdout, stderr) => {
+    _cbExec(cmd, { windowsHide: true, encoding: 'utf8', ...rest, timeout: timeout || 30000 }, (err, stdout, stderr) => {
       if (err) {
         err.stderr = stderr;
         err.stdout = stdout;
@@ -571,8 +571,6 @@ function execAsync(cmd, opts = {}) {
       }
       resolve(stdout);
     });
-    // Safety: ensure child is killed if parent process exits
-    child.unref && child.unref();
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1645",
+  "version": "0.1.1646",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"

package/prompts/cc-system.md

@@ -79,8 +79,6 @@ I'll dispatch dallas to fix that bug.
 - `note`: `title` and `content` (or `description`) REQUIRED.
 - `knowledge`: `title`, `content`, and `category` REQUIRED. Valid categories: architecture, conventions, project-notes, build-reports, reviews.
 
-If you describe an action in prose ("I'll dispatch this..."), you MUST emit a matching `===ACTIONS===` block. The server detects prose claims without action blocks and surfaces a warning to the user — i.e., your false claim becomes visible. Either dispatch or don't promise to.
-
 Core action types:
 - **dispatch**: title (REQUIRED), workType, priority (low/medium/high), agents[] or agent (optional — both shapes accepted), project (REQUIRED when multi-project), description
   workTypes: `explore` (research/report only, NO PR), `ask` (answer/report, NO PR), `implement` (new code, PR REQUIRED), `fix` (bug fix, PR REQUIRED), `review` (code review, NO PR), `test` (tests, PR if new), `verify` (merge/build/maintenance, NO PR)