@yemi33/minions 0.1.1619 → 0.1.1621

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1621 (2026-04-29)
+
+### Features
+- harden action block parsing (#1863)
+
+## 0.1.1620 (2026-04-29)
+
+### Features
+- progressive Claude token streaming + simplify-pass cleanup
+
 ## 0.1.1619 (2026-04-29)
 
 ### Features

package/dashboard/js/command-center.js

@@ -14,6 +14,22 @@ var _ccSending = false; // true if active tab is sending (UI indicator only)
 // Clear stale sending state on page load — SSE streams don't survive refresh
 try { localStorage.removeItem('cc-sending'); } catch {}
 
+function _ccStripActionBlockFromText(value) {
+  var text = value || '';
+  if (!text) return text;
+  var full = /(?:^|\r?\n)===ACTIONS={0,3}[ \t]*(?=\r?\n|$)/m.exec(text);
+  if (full) return text.slice(0, full.index + full[0].indexOf('===ACTIONS')).trim();
+  var block = /(?:^|\r?\n)===ACTIONS\b[^\r\n]*(?=\r?\n|$)/m.exec(text);
+  if (block) return text.slice(0, block.index + block[0].indexOf('===ACTIONS')).trim();
+  var delimiter = '===ACTIONS===';
+  var lineStart = Math.max(text.lastIndexOf('\n'), text.lastIndexOf('\r')) + 1;
+  var trailingLine = text.slice(lineStart).trimEnd();
+  if (trailingLine.length >= 3 && trailingLine.length < delimiter.length && delimiter.indexOf(trailingLine) === 0) {
+    return text.slice(0, lineStart).trimEnd();
+  }
+  return text;
+}
+
 // ── Migration from legacy single-session format ─────────────────────────────
 (function _ccMigrateLegacy() {
   try {
@@ -55,8 +71,12 @@ function _ccActiveTab() {
 }
 
 function _ccMergeStreamText(prev, incoming) {
+  // `prev` is already merged-clean from prior frames (server strips actions
+  // before SSE emission, and any leaked partial was sanitized by the previous
+  // _ccMergeStreamText call). Only strip `incoming` defensively — re-stripping
+  // `prev` every frame is O(n²) over the response length for nothing.
   var current = prev || '';
-  var next = incoming || '';
+  var next = _ccStripActionBlockFromText(incoming || '');
   if (!current) return next;
   if (!next) return current;
   if (next === current) return current;
@@ -601,6 +621,10 @@ async function _ccDoSend(message, skipUserMsg, forceTabId) {
         updateStreamDiv();
       } else if (evt.type === 'heartbeat') {
         return;
+      } else if (evt.type === 'thinking') {
+        streamStatusNote = evt.text || 'Thinking...';
+        if (activeTab) activeTab._streamStatusNote = streamStatusNote;
+        updateStreamDiv();
       } else if (evt.type === 'tool') {
         toolsUsed.push({ name: evt.name, input: evt.input || {} });
         if (activeTab) activeTab._toolsUsed = toolsUsed.slice();

package/dashboard.js

@@ -584,6 +584,7 @@ function _ensureCcLiveStream(tabId) {
     tabId,
     text: '',
     tools: [],
+    thinking: false,
     donePayload: null,
     writer: null,
     endResponse: null,
@@ -766,10 +767,67 @@ For all state files, look under \`${MINIONS_DIR}\`.`;
 }
 
 function findCCActionsDelimiter(text) {
+  const header = findCCActionsHeader(text);
+  return header && header.parseable ? header.index : -1;
+}
+
+// Single helper that handles both the strict (well-formed) and loose forms of
+// the ===ACTIONS=== delimiter. `parseable` is true only for the strict form
+// that parseCCActions can JSON.parse; loose matches still split display text
+// but are not parsed (they shouldn't reach the user as actions).
+function findCCActionsHeader(text) {
+  if (!text) return null;
+  // Strict: ===ACTIONS={0,3} on its own line, optional trailing whitespace.
+  const strict = /(?:^|\r?\n)===ACTIONS={0,3}[ \t]*(?=\r?\n|$)/m.exec(text);
+  if (strict) {
+    const headerStart = strict.index + strict[0].indexOf('===ACTIONS');
+    const headerMatch = text.slice(headerStart).match(/^===ACTIONS={0,3}[ \t]*/);
+    return {
+      index: headerStart,
+      headerLength: headerMatch ? headerMatch[0].length : '===ACTIONS==='.length,
+      parseable: true,
+    };
+  }
+  // Loose: sentinel-looking malformed delimiters such as ===ACTIONS -> should
+  // still be hidden, but prose like "===ACTIONS are documented" must render.
+  const loose = /(?:^|\r?\n)===ACTIONS(?:[ \t]*(?:[-=]>?|={1,}|$)|[^A-Za-z0-9_\s\r\n][^\r\n]*)(?=\r?\n|$)/m.exec(text);
+  if (loose) {
+    const headerStart = loose.index + loose[0].indexOf('===ACTIONS');
+    return { index: headerStart, headerLength: 0, parseable: false };
+  }
+  return null;
+}
+
+function findCCActionsPartialDelimiter(text) {
   if (!text) return -1;
-  const match = /(?:^|\r?\n)===ACTIONS===[ \t]*(?=\r?\n|$)/m.exec(text);
-  if (!match) return -1;
-  return match.index + match[0].indexOf('===ACTIONS===');
+  const delimiter = '===ACTIONS===';
+  const lineStart = Math.max(text.lastIndexOf('\n'), text.lastIndexOf('\r')) + 1;
+  const trailingLine = text.slice(lineStart).trimEnd();
+  if (trailingLine.length >= 3 && trailingLine.length < delimiter.length && delimiter.startsWith(trailingLine)) {
+    return lineStart;
+  }
+  return -1;
+}
+
+function stripCCActionsForStream(text) {
+  if (!text) return '';
+  // Fast path: 95% of streamed chunks contain no '=' before any actions block
+  // appears. Skip all regex work in that case.
+  if (text.indexOf('===') < 0) return text;
+  const header = findCCActionsHeader(text);
+  if (header) return text.slice(0, header.index).trim();
+  const partialIdx = findCCActionsPartialDelimiter(text);
+  if (partialIdx >= 0) return text.slice(0, partialIdx).trimEnd();
+  return text;
+}
+
+function stripCCActionsForDisplay(text) {
+  if (!text) return '';
+  const header = findCCActionsHeader(text);
+  if (header) return text.slice(0, header.index).trim();
+  const partialIdx = findCCActionsPartialDelimiter(text);
+  if (partialIdx >= 0) return text.slice(0, partialIdx).trimEnd();
+  return text;
 }
 
 // Issue #1834: non-Claude runtimes (Copilot/GPT) routinely wrap the action JSON
@@ -817,22 +875,25 @@ function _extractActionsJson(segment) {
 
 function parseCCActions(text) {
   let actions = [];
-  let displayText = text;
+  let displayText = stripCCActionsForDisplay(text);
   let parseError = null;
-  const delimIdx = findCCActionsDelimiter(text);
-  if (delimIdx >= 0) {
-    displayText = text.slice(0, delimIdx).trim();
-    const segment = text.slice(delimIdx + '===ACTIONS==='.length);
-    const jsonStr = _extractActionsJson(segment);
-    if (jsonStr) {
-      try {
-        const parsed = JSON.parse(jsonStr);
-        actions = Array.isArray(parsed) ? parsed : [parsed];
-      } catch (e) {
-        parseError = e.message || 'invalid JSON';
+  const header = findCCActionsHeader(text);
+  let segment = '';
+  if (header) {
+    displayText = text.slice(0, header.index).trim();
+    if (header.parseable) {
+      segment = text.slice(header.index + header.headerLength);
+      const jsonStr = _extractActionsJson(segment);
+      if (jsonStr) {
+        try {
+          const parsed = JSON.parse(jsonStr);
+          actions = Array.isArray(parsed) ? parsed : [parsed];
+        } catch (e) {
+          parseError = e.message || 'invalid JSON';
+        }
+      } else if (segment.trim()) {
+        parseError = 'no JSON value found after ===ACTIONS=== delimiter';
       }
-    } else if (segment.trim()) {
-      parseError = 'no JSON value found after ===ACTIONS=== delimiter';
     }
   }
   if (actions.length === 0) {
@@ -851,7 +912,7 @@ function parseCCActions(text) {
     result._actionParseError = parseError;
     // Visibility for the engine log — silent failure here previously masked issue #1834.
     try {
-      const snippet = (text.slice(delimIdx + '===ACTIONS==='.length).trim() || '').slice(0, 200);
+      const snippet = (segment.trim() || '').slice(0, 200);
       console.warn(`[CC] action JSON parse failed (${parseError}); raw segment: ${snippet}`);
       if (typeof shared !== 'undefined' && shared && typeof shared.log === 'function') {
         shared.log('warn', `CC action JSON parse failed: ${parseError} — segment: ${snippet}`);
@@ -864,8 +925,8 @@ function parseCCActions(text) {
 function stripCCActionSyntax(text) {
   if (!text) return '';
   let displayText = text;
-  const delimIdx = findCCActionsDelimiter(text);
-  if (delimIdx >= 0) displayText = text.slice(0, delimIdx).trim();
+  const header = findCCActionsHeader(text);
+  if (header) displayText = text.slice(0, header.index).trim();
   return displayText.replace(/`{3,}\s*action\s*\r?\n[\s\S]*?`{3,}\n?/g, '').trim();
 }
 
@@ -4532,11 +4593,6 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           });
         }
 
-        // Mirror CC response to Teams (non-blocking, skip Teams-originated)
-        if (!tabId.startsWith('teams-')) {
-          teams.teamsPostCCResponse(body.message, result.text).catch(() => {});
-        }
-
         const parsed = parseCCActions(result.text);
         const toolUses = Array.isArray(result.toolUses) ? result.toolUses : _extractToolUsesFromRaw(result.raw);
         // Safety net: detect /loop invocation and convert to create-watch
@@ -4549,6 +4605,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         if (parsed.actions.length > 0) {
           parsed.actionResults = await executeCCActions(parsed.actions);
         }
+        // Mirror only user-facing text to Teams; never send the internal action block.
+        if (!tabId.startsWith('teams-')) {
+          teams.teamsPostCCResponse(body.message, parsed.text).catch(() => {});
+        }
         // Issue #1834: rename _actionParseError → actionParseError (public field)
         // so the client can surface a warning when the model emitted ===ACTIONS===
         // but the JSON couldn't be recovered.
@@ -4642,6 +4702,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         for (const tool of live.tools || []) {
           writeCcEvent({ type: 'tool', name: tool.name, input: _lightToolInput(tool.input) });
         }
+        if (live.thinking && !live.text) writeCcEvent({ type: 'thinking', text: 'Thinking...' });
         if (live.text) writeCcEvent({ type: 'chunk', text: live.text });
         if (live.donePayload) {
           writeCcEvent(live.donePayload);
@@ -4723,15 +4784,21 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           sessionId, effort: streamEffort, direct: true,
           engineConfig: CONFIG.engine,
           onChunk: (text) => {
-            const actIdx = findCCActionsDelimiter(text);
-            const display = actIdx >= 0 ? text.slice(0, actIdx).trim() : text;
+            const display = stripCCActionsForStream(text);
             liveState.text = display;
             if (liveState.writer) liveState.writer({ type: 'chunk', text: display });
+            // Once text is flowing, the SSE-replay branch (live.thinking &&
+            // !live.text) shouldn't show stale "Thinking…" on reconnect.
+            if (liveState.thinking) liveState.thinking = false;
           },
           onToolUse: (name, input) => {
             toolUses.push({ name, input: input || {} });
             liveState.tools.push({ name, input: input || {} });
             if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(input) });
+          },
+          onThinking: () => {
+            liveState.thinking = true;
+            if (liveState.writer) liveState.writer({ type: 'thinking', text: 'Thinking...' });
           }
         });
         _ccStreamAbort = llmPromise.abort;
@@ -4749,20 +4816,26 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           toolUses = []; // discard stale metadata from the failed resume attempt
           const retryPromise = callLLMStreaming(freshPrompt, CC_STATIC_SYSTEM_PROMPT, {
             timeout: 900000, label: 'command-center', model: streamModel, maxTurns: ccMaxTurns,
-              allowedTools: 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch',
-              effort: streamEffort, direct: true,
-              engineConfig: CONFIG.engine,
-              onChunk: (text) => {
-                const actIdx = findCCActionsDelimiter(text);
-                const display = actIdx >= 0 ? text.slice(0, actIdx).trim() : text;
-                liveState.text = display;
-                if (liveState.writer) liveState.writer({ type: 'chunk', text: display });
-              },
-              onToolUse: (name, input) => {
-                toolUses.push({ name, input: input || {} });
-                liveState.tools.push({ name, input: input || {} });
-                if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(input) });
-              }
+            allowedTools: 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch',
+            effort: streamEffort, direct: true,
+            engineConfig: CONFIG.engine,
+            onChunk: (text) => {
+              const display = stripCCActionsForStream(text);
+              liveState.text = display;
+              if (liveState.writer) liveState.writer({ type: 'chunk', text: display });
+              // Same reset as the initial path so resume-fail retries don't
+              // leave a stale "Thinking…" frame visible on SSE reconnect.
+              if (liveState.thinking) liveState.thinking = false;
+            },
+            onToolUse: (name, input) => {
+              toolUses.push({ name, input: input || {} });
+              liveState.tools.push({ name, input: input || {} });
+              if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(input) });
+            },
+            onThinking: () => {
+              liveState.thinking = true;
+              if (liveState.writer) liveState.writer({ type: 'thinking', text: 'Thinking...' });
+            }
             });
             _ccStreamAbort = retryPromise.abort;
             liveState.abortFn = _ccStreamAbort;
@@ -4834,7 +4907,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         // Mirror CC response to Teams (non-blocking, skip Teams-originated)
         const _streamTabId = body.tabId || 'default';
         if (!_streamTabId.startsWith('teams-')) {
-          teams.teamsPostCCResponse(body.message, result.text).catch(() => {});
+          teams.teamsPostCCResponse(body.message, displayText).catch(() => {});
         }
 
         if (liveState.endResponse) liveState.endResponse();

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-04-29T01:13:06.848Z"
+  "cachedAt": "2026-04-29T11:01:36.483Z"
 }

package/engine/llm.js

@@ -24,6 +24,10 @@ const MINIONS_DIR = shared.MINIONS_DIR;
 const ENGINE_DIR = path.join(MINIONS_DIR, 'engine');
 const COPILOT_TASK_COMPLETE_GRACE_MS = 3000;
 
+// Claude content blocks come in two thinking variants; hoisted to module scope
+// so the streaming accumulator's hot path doesn't recreate the set per event.
+const THINKING_BLOCK_TYPES = new Set(['thinking', 'redacted_thinking']);
+
 // ─── Engine-Usage Metrics ────────────────────────────────────────────────────
 
 function trackEngineUsage(category, usage) {
@@ -261,6 +265,7 @@ function _createStreamAccumulator({
   onChunk = null,
   onToolUse = null,
   onTaskComplete = null,
+  onThinking = null,
 }) {
   let stdout = '';
   let stderr = '';
@@ -278,9 +283,15 @@ function _createStreamAccumulator({
   let copilotMessageBuffer = '';
   let copilotTaskCompleteSeen = false;
   let copilotTaskCompleteSummary = '';
+  const claudeStreamBlocks = new Map();
+  // Maintained accumulator of Claude text — incrementally appended on each
+  // text_delta so the hot path doesn't rebuild from the Map every chunk
+  // (rebuild was O(n) per delta → O(n²) over the response).
+  let claudeJoinedText = '';
+  let thinkingSent = false;
 
   function _streamText(value) {
-    return maxTextLength ? value.slice(-maxTextLength) : value;
+    return (maxTextLength && value.length > maxTextLength) ? value.slice(-maxTextLength) : value;
   }
 
   function _copilotAssistantMessageHasTools(obj) {
@@ -288,6 +299,79 @@ function _createStreamAccumulator({
     return Array.isArray(requests) && requests.length > 0;
   }
 
+  function _notifyThinking() {
+    if (!onThinking || thinkingSent) return;
+    thinkingSent = true;
+    onThinking();
+  }
+
+  // Rebuild the joined text from the Map. Only used as a safety net when
+  // content blocks arrive out of order (a non-trailing index lands after a
+  // later one — rare but possible if events get reordered upstream).
+  function _rebuildClaudeJoinedText() {
+    claudeJoinedText = Array.from(claudeStreamBlocks.keys()).sort((a, b) => a - b)
+      .map(index => claudeStreamBlocks.get(index))
+      .filter(block => block && block.type === 'text' && block.text)
+      .map(block => block.text)
+      .join('');
+  }
+
+  function _captureClaudeText(value) {
+    if (typeof value !== 'string' || !value) return;
+    const nextText = _streamText(value);
+    text = nextText;
+    if (onChunk && nextText !== lastTextSent) {
+      lastTextSent = nextText;
+      onChunk(nextText);
+    }
+  }
+
+  function _captureClaudeStreamEvent(obj) {
+    const event = obj?.event;
+    if (!event || typeof event !== 'object') return false;
+    if (event.type === 'message_start') {
+      claudeStreamBlocks.clear();
+      claudeJoinedText = '';
+      thinkingSent = false;
+      return true;
+    }
+    if (event.type === 'content_block_start') {
+      const index = Number.isInteger(event.index) ? event.index : Number(event.index) || 0;
+      const block = event.content_block || {};
+      claudeStreamBlocks.set(index, { type: block.type || '', text: block.text || '' });
+      if (THINKING_BLOCK_TYPES.has(block.type)) _notifyThinking();
+      // If a block lands at a non-trailing index (out-of-order delivery), the
+      // monotonic-append path can't reconstruct the joined text — rebuild as
+      // a safety net. The common case is in-order arrival; rebuild is rare.
+      const indices = Array.from(claudeStreamBlocks.keys());
+      const isTrailing = indices.every(i => i <= index);
+      if (!isTrailing) {
+        _rebuildClaudeJoinedText();
+      } else if (block.type === 'text' && block.text) {
+        claudeJoinedText += block.text;
+      }
+      if (claudeJoinedText) _captureClaudeText(claudeJoinedText);
+      return true;
+    }
+    if (event.type === 'content_block_delta') {
+      const index = Number.isInteger(event.index) ? event.index : Number(event.index) || 0;
+      const delta = event.delta || {};
+      if (delta.type === 'thinking_delta' || typeof delta.thinking === 'string') _notifyThinking();
+      if (delta.type === 'text_delta' && typeof delta.text === 'string' && delta.text) {
+        const block = claudeStreamBlocks.get(index) || { type: 'text', text: '' };
+        block.type = 'text';
+        block.text = (block.text || '') + delta.text;
+        claudeStreamBlocks.set(index, block);
+        // Common case: deltas arrive monotonically per index, so appending to
+        // the joined accumulator directly is correct.
+        claudeJoinedText += delta.text;
+        _captureClaudeText(claudeJoinedText);
+      }
+      return true;
+    }
+    return event.type === 'content_block_stop' || event.type === 'message_delta' || event.type === 'message_stop';
+  }
+
   function _captureCopilotTaskComplete(summary, success = true) {
     if (typeof summary !== 'string' || !summary) return;
     const finalSummary = _streamText(summary);
@@ -311,6 +395,9 @@ function _createStreamAccumulator({
 
     // ── Claude shape ────────────────────────────────────────────────────────
     if (obj.session_id) sessionId = obj.session_id;
+    if (obj.type === 'stream_event') {
+      _captureClaudeStreamEvent(obj);
+    }
     if (obj.type === 'result' && typeof obj.result === 'string') {
       // Claude result event: terminal text + usage.
       text = maxTextLength ? obj.result.slice(-maxTextLength) : obj.result;
@@ -328,19 +415,22 @@ function _createStreamAccumulator({
     }
     if (obj.type === 'assistant' && Array.isArray(obj.message?.content)) {
       // Claude assistant turn: content blocks (text + tool_use).
+      // Multi-text-block messages (common with --include-partial-messages) need
+      // their text joined before _captureClaudeText, otherwise each block
+      // overwrites the prior one.
+      let assistantText = '';
       for (const block of obj.message.content) {
         if (block?.type === 'text' && block.text) {
-          text = maxTextLength ? block.text.slice(-maxTextLength) : block.text;
-          if (onChunk && block.text !== lastTextSent) {
-            lastTextSent = block.text;
-            onChunk(block.text);
-          }
+          assistantText += block.text;
+        } else if (THINKING_BLOCK_TYPES.has(block?.type)) {
+          _notifyThinking();
         } else if (block?.type === 'tool_use' && block.name) {
           const toolUse = { name: block.name, input: block.input || {} };
           toolUses.push(toolUse);
           if (onToolUse) onToolUse(toolUse.name, toolUse.input);
         }
       }
+      if (assistantText) _captureClaudeText(assistantText);
     }
 
     // ── Copilot shape ───────────────────────────────────────────────────────
@@ -348,6 +438,9 @@ function _createStreamAccumulator({
     if (obj.type === 'session.task_complete') {
       _captureCopilotTaskComplete(obj.data?.summary, obj.data?.success);
     }
+    if (obj.type === 'assistant.reasoning' || obj.type === 'assistant.reasoning_delta') {
+      _notifyThinking();
+    }
     if (obj.type === 'assistant.message_delta' && typeof obj.data?.deltaContent === 'string') {
       if (copilotTaskCompleteSeen) return;
       copilotMessageBuffer += obj.data.deltaContent;
@@ -611,6 +704,7 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
       onChunk,
       onToolUse,
       onTaskComplete: scheduleTaskCompleteClose,
+      onThinking: opts.onThinking || null,
     });
 
     _abort = () => { shared.killImmediate(proc); };

package/engine/routing.js

@@ -28,7 +28,7 @@ let _routingCache = null;
 let _routingCacheMtime = 0;
 
 function parseRoutingTable() {
-  const content = getRouting();
+  const content = getRouting() || '';
   const routes = {};
   const lines = content.split('\n');
   let inTable = false;
@@ -116,12 +116,44 @@ function setTempBudget(n) {
 }
 function getTempBudget() { return _tempBudget; }
 
-function normalizeAgentHints(agentHints, authorAgent = null) {
-  const raw = Array.isArray(agentHints) ? agentHints : (agentHints ? String(agentHints).split(',') : []);
-  return raw
-    .map(id => String(id).trim().toLowerCase())
-    .map(id => id === '_author_' && authorAgent ? String(authorAgent).trim().toLowerCase() : id)
+// Centralizes the work-item shape used to derive routing hints. Engine code
+// previously inlined `item.preferred_agent || item.agents || null` at four
+// call sites; hoisting keeps the contract in one place.
+function extractAgentHints(item) {
+  if (!item || typeof item !== 'object') return null;
+  return item.preferred_agent || item.agents || null;
+}
+
+// Normalize a list of agent-hint inputs. Accepts:
+//   - Comma-separated string ("dallas,ripley")
+//   - Array of strings
+//   - Single string
+// Resolves the `_author_` token to authorAgent (when provided), validates
+// each hint against the configured agents map (case-insensitive lookup,
+// returning the canonical ID), dedups, and drops anything unknown.
+function normalizeAgentHints(agentHints, authorAgent = null, agents = null) {
+  const raw = Array.isArray(agentHints)
+    ? agentHints
+    : (agentHints ? String(agentHints).split(',') : []);
+  const expanded = raw
+    .map(id => String(id).trim())
+    .map(id => id.toLowerCase() === '_author_' && authorAgent ? String(authorAgent).trim() : id)
     .filter(Boolean);
+  // When no agents map is supplied, return lowercased IDs (legacy behaviour
+  // used by tests and pre-validation callers).
+  if (!agents || typeof agents !== 'object') {
+    return expanded.map(id => id.toLowerCase());
+  }
+  const byLower = new Map(Object.keys(agents).map(id => [id.toLowerCase(), id]));
+  const seen = new Set();
+  const normalized = [];
+  for (const hint of expanded) {
+    const id = byLower.get(hint.toLowerCase());
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    normalized.push(id);
+  }
+  return normalized;
 }
 
 function resolveAgent(workType, config, authorAgent = null, agentHints = null) {
@@ -153,7 +185,7 @@ function resolveAgent(workType, config, authorAgent = null, agentHints = null) {
     return null;
   };
 
-  const hintedAgents = normalizeAgentHints(agentHints, authorAgent);
+  const hintedAgents = normalizeAgentHints(agentHints, authorAgent, agents);
   if (hintedAgents.length > 0) {
     for (const id of hintedAgents) {
       if (isAvailable(id)) { _claimedAgents.add(id); return id; }
@@ -203,10 +235,11 @@ module.exports = {
   getMonthlySpend,
   getAgentErrorRate,
   isAgentIdle,
+  normalizeAgentHints,
+  extractAgentHints,
   _claimedAgents,
   resetClaimedAgents,
   resolveAgent,
   setTempBudget,
   getTempBudget,
-  normalizeAgentHints,
 };

package/engine/runtimes/claude.js

@@ -209,6 +209,7 @@ function buildArgs(opts = {}) {
   } = opts;
 
   const args = ['-p', '--output-format', outputFormat];
+  if (outputFormat === 'stream-json') args.push('--include-partial-messages');
   if (maxTurns != null) args.push('--max-turns', String(maxTurns));
   if (model) args.push('--model', String(model));
   if (verbose) args.push('--verbose');

package/engine.js

@@ -121,9 +121,10 @@ const { getConfig, getControl, getDispatch, getNotes,
 
 // ─── Routing (extracted to engine/routing.js) ───────────────────────────────
 
+const routing = require('./engine/routing');
 const { getRouting, parseRoutingTable, getRoutingTableCached, getMonthlySpend,
   getAgentErrorRate, isAgentIdle, resolveAgent, resetClaimedAgents,
-  setTempBudget, tempAgents } = require('./engine/routing');
+  setTempBudget, tempAgents } = routing;
 
 // ─── Playbook, system prompt, agent context (extracted to engine/playbook.js) ─
 
@@ -2500,7 +2501,7 @@ function discoverFromWorkItems(config, project) {
       item._decomposing = true;
       needsWrite = true;
     }
-    const agentHints = item.preferred_agent || item.agents || null;
+    const agentHints = routing.extractAgentHints(item);
     const agentId = item.agent || resolveAgent(workType, config, null, agentHints);
     if (!agentId) {
       // Check if reason is budget
@@ -3020,7 +3021,7 @@ function discoverCentralWorkItems(config) {
 
     } else {
       // ─── Normal: single agent dispatch ──────────────────────────────
-      const agentHints = item.preferred_agent || item.agents || null;
+      const agentHints = routing.extractAgentHints(item);
       const agentId = item.agent || resolveAgent(workType, config, null, agentHints);
       if (!agentId) continue;
 
@@ -3663,8 +3664,7 @@ async function tickInner() {
     // be of type string. Received undefined` and re-queues — every tick. Try to
     // resolve a fallback via routing; if none is available, skip this tick.
     if (!item.agent || typeof item.agent !== 'string') {
-      const agentHints = item.meta?.item?.preferred_agent || item.meta?.item?.agents || null;
-      const fallback = resolveAgent(item.type || WORK_TYPE.FIX, config, null, agentHints);
+      const fallback = resolveAgent(item.type || WORK_TYPE.FIX, config, null, routing.extractAgentHints(item.meta?.item));
       if (!fallback) {
         log('warn', `Pending dispatch ${item.id} has no agent and routing returned no fallback — skipping`);
         continue;
@@ -3722,7 +3722,7 @@ async function tickInner() {
       // Agent busy reassignment: if item has been waiting on a busy agent past the threshold,
       // try to find an alternative agent via routing. Skip explicitly assigned items.
       const reassignMs = config.engine?.agentBusyReassignMs ?? ENGINE_DEFAULTS.agentBusyReassignMs;
-      const isExplicitReassign = !!(item.meta?.item?.agent || item.meta?.item?.preferred_agent || item.meta?.item?.agents?.length);
+      const isExplicitReassign = !!(item.meta?.item?.agent || routing.extractAgentHints(item.meta?.item));
       if (!isExplicitReassign && reassignMs > 0 && item._agentBusySince) {
         const busySinceMs = new Date(item._agentBusySince).getTime();
         if (Date.now() - busySinceMs > reassignMs) {

package/package.json

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