@yemi33/minions 0.1.1816 → 0.1.1818

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1818 (2026-05-09)
+
+### Fixes
+- write [process-exit] sentinel directly to live-output.log instead of bouncing it through stdout (#2266)
+
 ## 0.1.1816 (2026-05-09)
 
 ### Features

package/dashboard.js

@@ -2163,7 +2163,8 @@ function _ccFallbackMissingTargetError(intent) {
 
 function _actionsWithIntentFallback(actions, opts = {}) {
   const { message = '', intentMetadata = null, source = 'command-center', filePath = null, title: docTitle = null, answerText = '', toolUses = [] } = opts;
-  const existing = Array.isArray(actions) ? actions.map(normalizeCCAction) : [];
+  const existing = (Array.isArray(actions) ? actions.map(normalizeCCAction) : [])
+    .filter(action => !_ccShouldSuppressAnsweredAskDispatch(action, { message, source, answerText, toolUses }));
   if (_messageRequestsDirectHandling(message)) return existing.filter(a => normalizeCCAction(a)?.type !== 'dispatch');
   if (existing.some(a => normalizeCCAction(a)?.type === 'dispatch')) return existing;
   if (existing.length > 0) return existing;
@@ -2199,6 +2200,7 @@ function _actionsWithIntentFallback(actions, opts = {}) {
     ...common,
   };
   if (!hasTarget) action._intentFallbackError = _ccFallbackMissingTargetError(intent);
+  if (_ccShouldSuppressAnsweredAskDispatch(action, { message, source, answerText, toolUses })) return existing;
   return [action];
 }
 
@@ -2286,6 +2288,18 @@ function parseCCActions(text) {
 }
 
 const DELEGATION_ACTION_TERMS = ['dispatch', 'delegate', 'assign', 'queue', 'enqueue'];
+const DELEGATION_REQUEST_PREFIX_TERMS = ['please', 'can', 'could', 'would', 'will', 'should', 'you', 'cc', 'minions', 'minion'];
+const DELEGATION_PERSON_ACTION_TERMS = ['ask', 'tell', 'have'];
+// Subset of delegation action terms that double as common nouns in status
+// questions (e.g. "queue status", "dispatch contents"). When followed by a
+// status-noun follow-on these are noun usage, not imperative delegation.
+const DELEGATION_AMBIGUOUS_NOUN_TERMS = new Set(['dispatch', 'queue']);
+const DELEGATION_NON_VERB_FOLLOW_ONS = new Set([
+  'status', 'contents', 'content', 'state', 'count', 'list', 'items', 'item',
+  'size', 'length', 'depth', 'health', 'info', 'order', 'queue', 'history',
+  'log', 'logs', 'summary', 'overview', 'report', 'is', 'was', 'are', 'were',
+  'has', 'have', 'looks', 'shows',
+]);
 const DELEGATION_MINIONS_PHRASES = ['have minions', 'ask minions', 'tell minions', 'hand off', 'hand it off', 'hand this off', 'send to agent', 'send it to agent', 'send this to agent'];
 const MEDIUM_INVESTIGATION_TERMS = ['audit', 'investigate', 'research', 'explore', 'analyze', 'analyse'];
 const MEDIUM_INVESTIGATION_PHRASES = ['deep dive', 'root cause'];
@@ -2316,6 +2330,15 @@ const DIRECT_HANDLING_PHRASES = [
   'no dispatch', 'no delegate', 'no delegation', 'no work item',
   'without dispatching', 'without delegating', 'without creating work item',
 ];
+const ANSWERED_ASK_MIN_CHARS = 80;
+const ANSWERED_ASK_INCOMPLETE_PHRASES = [
+  'i will dispatch', 'ill dispatch', 'i will delegate', 'ill delegate',
+  'i will ask', 'ill ask', 'need to dispatch', 'needs to dispatch',
+  'need to delegate', 'needs to delegate', 'need an agent', 'needs an agent',
+  'hand off', 'hand this off', 'deeper investigation', 'further investigation',
+  'cannot answer', 'cant answer', 'could not answer', 'couldnt answer',
+  'not enough information',
+];
 
 function _isIntentWordChar(ch) {
   const code = ch.charCodeAt(0);
@@ -2401,6 +2424,37 @@ function _messageHasDelegationIntent(message) {
   return _intentHasAnyPhrase(normalized, DELEGATION_MINIONS_PHRASES);
 }
 
+function _delegationTokenIsImperativeVerb(tokens, idx) {
+  const term = tokens[idx];
+  if (!term) return false;
+  if (!DELEGATION_AMBIGUOUS_NOUN_TERMS.has(term)) return true;
+  const next = tokens[idx + 1];
+  if (!next) return true;
+  return !DELEGATION_NON_VERB_FOLLOW_ONS.has(next);
+}
+
+function _messageExplicitlyRequestsDelegation(message) {
+  const normalized = _normalizeIntentText(message);
+  const tokens = _intentTokens(normalized);
+  if (!tokens.length) return false;
+  if (_intentHasAnyPhrase(normalized, DELEGATION_MINIONS_PHRASES)) return true;
+  if (_intentHasPhrase(normalized, 'work item') && _intentHasAnyToken(normalized, ['create', 'open', 'add'])) return true;
+
+  let i = 0;
+  while (DELEGATION_REQUEST_PREFIX_TERMS.includes(tokens[i])) i++;
+  if (DELEGATION_ACTION_TERMS.includes(tokens[i]) && _delegationTokenIsImperativeVerb(tokens, i)) return true;
+  if (DELEGATION_PERSON_ACTION_TERMS.includes(tokens[i])) {
+    return tokens.slice(i + 1, i + 7).includes('to');
+  }
+  for (let j = 0; j < tokens.length && j <= 6; j++) {
+    if (!DELEGATION_ACTION_TERMS.includes(tokens[j])) continue;
+    if (!_delegationTokenIsImperativeVerb(tokens, j)) continue;
+    const prefix = tokens.slice(0, j);
+    if (prefix.includes('you') || prefix.includes('minions') || prefix.includes('minion')) return true;
+  }
+  return false;
+}
+
 function _messageRequestsDirectHandling(message) {
   const normalized = _normalizeIntentText(message);
   if (!normalized.trim()) return false;
@@ -2440,6 +2494,24 @@ function _inferDelegatedWorkType(message) {
   return 'ask';
 }
 
+function _ccAnswerLooksCompleteForAsk(answerText, toolUses = []) {
+  if (!Array.isArray(toolUses) || toolUses.length === 0) return false;
+  const answer = _collapseWhitespace(stripCCActionSyntax(answerText || ''));
+  if (answer.length < ANSWERED_ASK_MIN_CHARS) return false;
+  const normalized = _normalizeIntentText(answer);
+  if (_intentHasAnyPhrase(normalized, ANSWERED_ASK_INCOMPLETE_PHRASES)) return false;
+  if (_intentHasVerbObject(normalized, ['need', 'needs', 'require', 'requires'], ['agent', 'delegation', 'investigation', 'research'])) return false;
+  return true;
+}
+
+function _ccShouldSuppressAnsweredAskDispatch(action, opts = {}) {
+  const normalized = normalizeCCAction(action);
+  if (normalized?.type !== 'dispatch') return false;
+  if (String(normalized.workType || '').trim().toLowerCase() !== 'ask') return false;
+  if (_messageExplicitlyRequestsDelegation(opts.message)) return false;
+  return _ccAnswerLooksCompleteForAsk(opts.answerText, opts.toolUses);
+}
+
 function _collapseWhitespace(text) {
   let out = '';
   let lastWasSpace = true;
@@ -2532,11 +2604,13 @@ function _inferDelegationActionFromMessage(message, { source = 'command-center',
 }
 
 function _ensureDelegationForIntent(actions, opts = {}) {
-  const list = Array.isArray(actions) ? actions.map(normalizeCCAction) : [];
+  const list = (Array.isArray(actions) ? actions.map(normalizeCCAction) : [])
+    .filter(action => !_ccShouldSuppressAnsweredAskDispatch(action, opts));
   if (_messageRequestsDirectHandling(opts.message)) return list.filter(a => normalizeCCAction(a)?.type !== 'dispatch');
   if (list.some(a => normalizeCCAction(a)?.type === 'dispatch')) return list;
   if (list.length > 0) return list;
   const inferred = _inferDelegationActionFromMessage(opts.message, opts);
+  if (_ccShouldSuppressAnsweredAskDispatch(inferred, opts)) return list;
   return inferred ? [...list, inferred] : list;
 }
 

package/engine/cli.js

@@ -1531,4 +1531,10 @@ module.exports = {
   _controlBelongsToOwner: controlBelongsToOwner,
   _markControlStoppingForOwner: markControlStoppingForOwner,
   _markControlStoppedForOwner: markControlStoppedForOwner,
+  _isPidAlive: isPidAlive,
+  _summarizeActiveDispatchPids: summarizeActiveDispatchPids,
+  _dispatchSafeId: dispatchSafeId,
+  _readDispatchPid: readDispatchPid,
+  _normalizeSessionBranch: normalizeSessionBranch,
+  _dispatchSessionBranch: dispatchSessionBranch,
 };

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-09T15:27:55.877Z"
+  "cachedAt": "2026-05-09T15:59:07.682Z"
 }

package/engine/shared.js

@@ -3451,6 +3451,10 @@ module.exports = {
   legacyProjectStatePath,
   ensureProjectStateFiles,
   sameResolvedPath,
+  projectStateRecordKey, // exported for testing
+  mergeProjectStateArrays, // exported for testing
+  realPathForComparison, // exported for testing
+  prPathComparisonCandidates, // exported for testing
   resolveProjectForPrPath, // exported for testing
   getPrLinks,
   addPrLink,

package/engine/spawn-agent.js

@@ -158,55 +158,32 @@ function injectAdoTokenEnvForRepoHost(env, opts) {
   return injectAdoTokenEnv(env, opts);
 }
 
-const PROCESS_EXIT_SENTINEL_FLUSH_TIMEOUT_MS = 2000;
-
 function formatProcessExitSentinel(exitCode, signal) {
   return `\n[process-exit] code=${exitCode}${signal ? ` signal=${signal}` : ''}\n`;
 }
 
-function _appendSentinelFallback(outputPath, sentinel) {
-  if (!outputPath) return false;
-  try {
-    fs.appendFileSync(outputPath, sentinel);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function _writeStdoutWithTimeout(stdout, sentinel, timeoutMs) {
-  return new Promise((resolve) => {
-    let settled = false;
-    const finish = (flushed) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(flushed);
-    };
-    const timer = setTimeout(() => finish(false), Math.max(0, timeoutMs));
-    try {
-      if (!stdout || typeof stdout.write !== 'function') {
-        finish(false);
-        return;
-      }
-      stdout.write(sentinel, () => finish(true));
-    } catch {
-      finish(false);
-    }
-  });
-}
-
-async function writeProcessExitSentinel({
+// The orphan reaper recovers an agent's exit code by scanning live-output.log for
+// `[process-exit] code=N`. The previous design wrote the sentinel to stdout, hoping
+// the engine's stdout consumer (engine.js) would copy it into the file — but when
+// the engine was force-killed during a restart on Windows, the broken pipe
+// silently swallowed the sentinel and the recovery never happened (see #2265 for
+// the read-side recovery; this is the upstream fix). The orphan reaper only reads
+// the file, so the simplest correct thing is to write the file directly. No
+// stdout, no timeouts, no callbacks — one synchronous append.
+function writeProcessExitSentinel({
   exitCode,
   signal = null,
-  stdout = process.stdout,
   outputPath = process.env.MINIONS_LIVE_OUTPUT_PATH,
-  timeoutMs = PROCESS_EXIT_SENTINEL_FLUSH_TIMEOUT_MS,
 } = {}) {
   const sentinel = formatProcessExitSentinel(exitCode, signal);
-  const stdoutFlushed = await _writeStdoutWithTimeout(stdout, sentinel, timeoutMs);
-  const outputPathWritten = stdoutFlushed ? false : _appendSentinelFallback(outputPath, sentinel);
-  return { sentinel, stdoutFlushed, outputPathWritten };
+  let fileWritten = false;
+  if (outputPath) {
+    try {
+      fs.appendFileSync(outputPath, sentinel);
+      fileWritten = true;
+    } catch { /* file unavailable; orphan reaper falls back to runtime result event (#2265) */ }
+  }
+  return { sentinel, fileWritten };
 }
 
 function _appendOutputFallback(outputPath, chunk, prefix = '') {
@@ -432,19 +409,19 @@ function main() {
   }, MCP_STARTUP_TIMEOUT);
   proc.stdout.once('data', () => { gotFirstOutput = true; clearTimeout(startupTimer); });
 
-  proc.on('close', async (code, signal) => {
+  proc.on('close', (code, signal) => {
     clearTimeout(startupTimer);
     const exitCode = normalizeRuntimeExit(code, signal);
-    const sentinelResult = await writeProcessExitSentinel({ exitCode, signal });
+    const sentinelResult = writeProcessExitSentinel({ exitCode, signal });
     fs.appendFileSync(debugPath, `EXIT: code=${exitCode}${signal ? ` signal=${signal}` : ''}\nSTDERR: ${stderrBuf.slice(0, 500)}\n`);
-    if (!sentinelResult.stdoutFlushed && sentinelResult.outputPathWritten) {
-      fs.appendFileSync(debugPath, `EXIT SENTINEL FALLBACK: ${process.env.MINIONS_LIVE_OUTPUT_PATH}\n`);
+    if (!sentinelResult.fileWritten) {
+      fs.appendFileSync(debugPath, `EXIT SENTINEL: file write failed for ${process.env.MINIONS_LIVE_OUTPUT_PATH}\n`);
     }
     process.exit(exitCode);
   });
-  proc.on('error', async (err) => {
+  proc.on('error', (err) => {
     fs.appendFileSync(debugPath, `ERROR: ${err.message}\n`);
-    await writeProcessExitSentinel({ exitCode: 1 });
+    writeProcessExitSentinel({ exitCode: 1 });
     process.exit(1);
   });
 }

package/package.json

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

@@ -98,6 +98,7 @@ I'll dispatch dallas to fix that bug.
 Core action types:
 - **dispatch**: title (REQUIRED), workType, priority (low/medium/high), agents[] or agent (optional — both shapes accepted), project (REQUIRED when multi-project unless `pr` resolves to a tracked PR), description, pr (optional PR number/id/url for work that targets an existing PR), scope (`"fan-out"` only when the user explicitly asks to fan out to all agents). Do not emit `type:"fix"` or `type:"implement"`; emit `type:"dispatch"` with `workType:"fix"` or emit `type:"dispatch"` with `workType:"implement"`.
   workTypes: `explore` (research/report only, NO PR), `ask` (answer/report, NO PR), `implement` (new code, PR REQUIRED), `fix` (standalone bug fix creates a PR; include `pr` when fixing review comments/build failures on an existing PR), `review` (code review, NO PR), `test` (tests, PR if new), `verify` (merge/build/maintenance, NO PR)
+  Do not dispatch an `ask` work item for a question you already answered inline in the same turn, especially after using tools. If the answer needs deeper investigation, give a brief handoff note and dispatch; do not both provide a complete answer and queue an agent to repeat it.
   If the user wants a design/architecture artifact committed through a PR, dispatch `implement` or `docs` rather than `explore`.
   When the user names a specific agent ("assign this to lambert"), put exactly that one name in `agents` (e.g. `"agents": ["lambert"]`). A single-agent assignment is hard-pinned by the server — it will queue for that agent only and skip the routing table. If the user explicitly asks for fan-out/all agents, set `scope: "fan-out"`.
   After emitting a dispatch-like action, return immediately; do not poll, monitor, watch, wait, or check until completion, and do not add follow-up status actions. Only create a watch, monitor, poll, or periodically check when the human explicitly asks for monitoring, watching, periodic checks, or notification on completion.