@yemi33/minions 0.1.1621 → 0.1.1622

package/CHANGELOG.md

@@ -1,10 +1,13 @@
 # Changelog
 
-## 0.1.1621 (2026-04-29)
+## 0.1.1622 (2026-04-29)
 
 ### Features
 - harden action block parsing (#1863)
 
+### Other
+- refactor: move stream-event handling into runtime adapters
+
 ## 0.1.1620 (2026-04-29)
 
 ### Features

package/dashboard.js

@@ -584,7 +584,7 @@ function _ensureCcLiveStream(tabId) {
     tabId,
     text: '',
     tools: [],
-    thinking: false,
+    thinkingSent: false,
     donePayload: null,
     writer: null,
     endResponse: null,
@@ -4635,6 +4635,40 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     return out;
   }
 
+  /**
+   * Build the callLLMStreaming invocation for the SSE Command Center path.
+   * Both the initial call and the post-resume-fail retry share the same
+   * onChunk/onToolUse/onThinking shape — only `sessionId` differs (set on
+   * initial call, undefined on retry). Hoisted to keep the two call sites
+   * in lock-step.
+   */
+  function _invokeCcStream({ prompt, sessionId, liveState, toolUses, model, effort, maxTurns, engineConfig }) {
+    const { callLLMStreaming } = require('./engine/llm');
+    return callLLMStreaming(prompt, CC_STATIC_SYSTEM_PROMPT, {
+      timeout: 900000, label: 'command-center', model, maxTurns,
+      allowedTools: 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch',
+      sessionId, effort, direct: true,
+      engineConfig,
+      onChunk: (text) => {
+        const display = stripCCActionsForStream(text);
+        liveState.text = display;
+        // Once text is flowing, the SSE-replay branch (live.thinkingSent &&
+        // !live.text) shouldn't show stale "Thinking…" on reconnect.
+        if (liveState.thinkingSent) liveState.thinkingSent = false;
+        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) });
+      },
+      onThinking: () => {
+        liveState.thinkingSent = true;
+        if (liveState.writer) liveState.writer({ type: 'thinking', text: 'Thinking...' });
+      },
+    });
+  }
+
   async function handleCommandCenterStream(req, res) {
     // SSE Origin gate (belt-and-suspenders: the top-level dispatcher has
     // already rejected disallowed origins on POST, but validate again here
@@ -4702,7 +4736,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.thinkingSent && !live.text) writeCcEvent({ type: 'thinking', text: 'Thinking...' });
         if (live.text) writeCcEvent({ type: 'chunk', text: live.text });
         if (live.donePayload) {
           writeCcEvent(live.donePayload);
@@ -4773,33 +4807,15 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         const preamble = wasResume ? '' : buildCCStatePreamble();
         const prompt = (preamble ? preamble + '\n\n---\n\n' : '') + body.message;
 
-        const { callLLMStreaming, trackEngineUsage: trackUsage } = require('./engine/llm');
+        const { trackEngineUsage: trackUsage } = require('./engine/llm');
         const streamModel = CONFIG.engine?.ccModel || shared.ENGINE_DEFAULTS.ccModel;
         const streamEffort = CONFIG.engine?.ccEffort || shared.ENGINE_DEFAULTS.ccEffort;
         const ccMaxTurns = CONFIG.engine?.ccMaxTurns || shared.ENGINE_DEFAULTS.ccMaxTurns;
         let toolUses = [];
-        const llmPromise = callLLMStreaming(prompt, CC_STATIC_SYSTEM_PROMPT, {
-          timeout: 900000, label: 'command-center', model: streamModel, maxTurns: ccMaxTurns,
-          allowedTools: 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch',
-          sessionId, effort: streamEffort, direct: true,
+        const llmPromise = _invokeCcStream({
+          prompt, sessionId, liveState, toolUses,
+          model: streamModel, effort: streamEffort, maxTurns: ccMaxTurns,
           engineConfig: CONFIG.engine,
-          onChunk: (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;
         liveState.abortFn = _ccStreamAbort;
@@ -4814,33 +4830,15 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           const freshPreamble = buildCCStatePreamble();
           const freshPrompt = (freshPreamble ? freshPreamble + '\n\n---\n\n' : '') + body.message;
           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,
+          const retryPromise = _invokeCcStream({
+            prompt: freshPrompt, sessionId: undefined, liveState, toolUses,
+            model: streamModel, effort: streamEffort, maxTurns: ccMaxTurns,
             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;
-            ccInFlightAborts.set(tabId, _ccStreamAbort);
-            const retryResult = await retryPromise;
+          });
+          _ccStreamAbort = retryPromise.abort;
+          liveState.abortFn = _ccStreamAbort;
+          ccInFlightAborts.set(tabId, _ccStreamAbort);
+          const retryResult = await retryPromise;
           trackUsage('command-center', retryResult.usage);
           if (retryResult.text) {
             // Fresh session succeeded — use retryResult from here

package/engine/copilot-models.json

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

package/engine/llm.js

@@ -24,10 +24,6 @@ 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) {
@@ -246,12 +242,12 @@ function _spawnProcess(promptText, sysPromptText, callOpts) {
 // ─── Streaming Accumulator ───────────────────────────────────────────────────
 //
 // Reads JSONL events as they stream in. JSON parsing is delegated to
-// `runtime.parseStreamChunk()` — that gives us the runtime's defensive
-// guarantees (e.g. Copilot rewrapping unknown event types as type:'ignore').
+// `runtime.parseStreamChunk()` and event-shape interpretation is delegated to
+// `runtime.createStreamConsumer(ctx)`. This file stays runtime-agnostic — it
+// owns the global accumulator state (stdout/stderr/text dedup/toolUses) and
+// exposes a `ctx` callback API the adapter calls when it sees Claude- or
+// Copilot-shaped events.
 //
-// Text / tool extraction branches on event SHAPE rather than runtime identity.
-// Both Claude and Copilot events flow through here; for any given object only
-// one branch matches because the event type strings don't collide.
 // Final reconciliation calls `runtime.parseOutput(stdout)` so per-runtime
 // finalization quirks (Copilot's premiumRequests, Claude's session_id) stay
 // inside the adapter.
@@ -267,6 +263,10 @@ function _createStreamAccumulator({
   onTaskComplete = null,
   onThinking = null,
 }) {
+  if (!runtime?.capabilities?.streamConsumer || typeof runtime.createStreamConsumer !== 'function') {
+    throw new Error(`runtime ${runtime?.name || '<unknown>'} missing createStreamConsumer (capabilities.streamConsumer)`);
+  }
+
   let stdout = '';
   let stderr = '';
   let lineBuf = '';
@@ -274,217 +274,76 @@ function _createStreamAccumulator({
   let usage = null;
   let sessionId = null;
   let lastTextSent = '';
-  const toolUses = [];
-
-  // Copilot streams `assistant.message_delta` with `data.deltaContent` chunks
-  // before emitting `assistant.message`. Tool-request messages can include
-  // narration ("I'll inspect...") that is only progress text, so terminal text
-  // comes from non-tool assistant messages or trailing deltas.
-  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;
+  let taskCompleteFired = false;
+  let lastTaskCompleteSummary = '';
+  const toolUses = [];
 
   function _streamText(value) {
     return (maxTextLength && value.length > maxTextLength) ? value.slice(-maxTextLength) : value;
   }
 
-  function _copilotAssistantMessageHasTools(obj) {
-    const requests = obj?.data?.toolRequests;
-    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);
-    const alreadySeen = copilotTaskCompleteSeen && copilotTaskCompleteSummary === finalSummary;
-    copilotTaskCompleteSeen = true;
-    copilotTaskCompleteSummary = finalSummary;
-    const hadText = !!text;
-    if (!hadText) {
-      text = finalSummary;
-      if (onChunk && finalSummary !== lastTextSent) {
-        lastTextSent = finalSummary;
-        onChunk(finalSummary);
+  // ── ctx surface — the only API the runtime stream consumer sees ─────────
+  const ctx = {
+    maxTextLength,
+    pushText(value) {
+      if (typeof value !== 'string' || !value) return;
+      const next = _streamText(value);
+      text = next;
+      if (onChunk && next !== lastTextSent) {
+        lastTextSent = next;
+        onChunk(next);
       }
-    }
-    copilotMessageBuffer = '';
-    if (!alreadySeen && onTaskComplete) onTaskComplete({ summary: finalSummary, success: success !== false });
-  }
-
-  function captureEvent(obj) {
-    if (!obj || typeof obj !== 'object') return;
-
-    // ── 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;
-      if (obj.total_cost_usd || obj.usage) {
-        usage = {
-          costUsd: obj.total_cost_usd || 0,
-          inputTokens: obj.usage?.input_tokens || 0,
-          outputTokens: obj.usage?.output_tokens || 0,
-          cacheRead: obj.usage?.cache_read_input_tokens || obj.usage?.cacheReadInputTokens || 0,
-          cacheCreation: obj.usage?.cache_creation_input_tokens || obj.usage?.cacheCreationInputTokens || 0,
-          durationMs: obj.duration_ms || 0,
-          numTurns: obj.num_turns || 0,
-        };
-      }
-    }
-    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) {
-          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 ───────────────────────────────────────────────────────
-    if (obj.type === 'result' && typeof obj.sessionId === 'string') sessionId = obj.sessionId;
-    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;
-      if (onChunk && copilotMessageBuffer !== lastTextSent) {
-        lastTextSent = copilotMessageBuffer;
-        onChunk(copilotMessageBuffer);
-      }
-    }
-    if (obj.type === 'assistant.message' && typeof obj.data?.content === 'string') {
-      // Tool-request narration ("I'll look into this...") is progress text, not
-      // the final answer. Keep streaming it live, but don't let it become the
-      // terminal result if the process exits before a final answer message.
-      const content = obj.data.content;
-      if (content && !_copilotAssistantMessageHasTools(obj)) text = _streamText(content);
-      copilotMessageBuffer = '';
-      if (Array.isArray(obj.data.toolRequests)) {
-        for (const tr of obj.data.toolRequests) {
-          if (tr && tr.name) {
-            if (tr.name === 'task_complete') {
-              _captureCopilotTaskComplete(tr.arguments?.summary || tr.intentionSummary);
-              continue;
-            }
-            const toolUse = { name: tr.name, input: tr.arguments || {} };
-            toolUses.push(toolUse);
-            if (onToolUse) onToolUse(toolUse.name, toolUse.input);
-          }
+    },
+    setText(value) {
+      // Hard-set text bypassing dedup — for terminal events that should
+      // override any streamed text (Claude's `result`, Copilot's final
+      // assistant.message). onChunk is NOT fired here; this is the
+      // authoritative final-text path, not a streaming chunk.
+      if (typeof value !== 'string') return;
+      text = _streamText(value);
+    },
+    pushToolUse(name, input) {
+      if (!name) return;
+      const toolUse = { name, input: input || {} };
+      toolUses.push(toolUse);
+      if (onToolUse) onToolUse(toolUse.name, toolUse.input);
+    },
+    toolUseAlreadySeen(name, input) {
+      if (!name) return false;
+      const stringified = JSON.stringify(input || {});
+      return toolUses.some(t => t.name === name && JSON.stringify(t.input) === stringified);
+    },
+    notifyThinking() {
+      if (!onThinking || thinkingSent) return;
+      thinkingSent = true;
+      onThinking();
+    },
+    notifyTaskComplete(summary, success = true) {
+      if (typeof summary !== 'string' || !summary) return;
+      const finalSummary = _streamText(summary);
+      const alreadySeen = taskCompleteFired && lastTaskCompleteSummary === finalSummary;
+      lastTaskCompleteSummary = finalSummary;
+      // Surface as terminal text only if nothing streamed yet.
+      if (!text) {
+        text = finalSummary;
+        if (onChunk && finalSummary !== lastTextSent) {
+          lastTextSent = finalSummary;
+          onChunk(finalSummary);
         }
       }
-    }
-    if (obj.type === 'tool.execution_start' && obj.data?.toolName) {
-      if (obj.data.toolName === 'task_complete') {
-        _captureCopilotTaskComplete(obj.data.arguments?.summary);
-        return;
-      }
-      const toolUse = { name: obj.data.toolName, input: obj.data.arguments || {} };
-      // Dedup: assistant.message.toolRequests already adds this — only push if
-      // we haven't seen it yet (toolCallId would be the unique key, but we
-      // compare by name+input shape since not every consumer cares).
-      if (!toolUses.some(t => t.name === toolUse.name && JSON.stringify(t.input) === JSON.stringify(toolUse.input))) {
-        toolUses.push(toolUse);
-        if (onToolUse) onToolUse(toolUse.name, toolUse.input);
+      if (!alreadySeen && onTaskComplete) {
+        taskCompleteFired = true;
+        onTaskComplete({ summary: finalSummary, success: success !== false });
+      } else {
+        taskCompleteFired = true;
       }
-    }
-  }
+    },
+    setUsage(u) { if (u) usage = u; },
+    setSessionId(id) { if (typeof id === 'string' && id) sessionId = id; },
+  };
+
+  const consumer = runtime.createStreamConsumer(ctx);
 
   function ingestStdout(chunk) {
     const str = chunk == null ? '' : chunk.toString();
@@ -494,7 +353,7 @@ function _createStreamAccumulator({
     lineBuf = lines.pop() || '';
     for (const line of lines) {
       const ev = runtime.parseStreamChunk(line);
-      if (ev) captureEvent(ev);
+      if (ev) consumer.consume(ev);
     }
   }
 
@@ -506,12 +365,9 @@ function _createStreamAccumulator({
     const trimmed = lineBuf.trim();
     if (trimmed) {
       const ev = runtime.parseStreamChunk(trimmed);
-      if (ev) captureEvent(ev);
-    }
-    if (copilotMessageBuffer && !copilotTaskCompleteSeen) {
-      text = _streamText(copilotMessageBuffer);
+      if (ev) consumer.consume(ev);
     }
-    if (!text && copilotTaskCompleteSummary) text = copilotTaskCompleteSummary;
+    if (!text && lastTaskCompleteSummary) text = lastTaskCompleteSummary;
     // Reconciliation: if any field is still missing, ask the runtime adapter
     // to re-parse the whole stdout. parseOutput() may catch a result event
     // that was malformed when streamed in chunks.

package/engine/routing.js

@@ -156,7 +156,8 @@ function normalizeAgentHints(agentHints, authorAgent = null, agents = null) {
   return normalized;
 }
 
-function resolveAgent(workType, config, authorAgent = null, agentHints = null) {
+function resolveAgent(workType, config, opts = {}) {
+  const { authorAgent = null, agentHints = null } = opts || {};
   const routes = getRoutingTableCached();
   const route = routes[workType] || routes['implement'] || { preferred: '_any_', fallback: '_any_' };
   const agents = config.agents || {};

package/engine/runtimes/claude.js

@@ -360,6 +360,137 @@ function parseError(rawOutput) {
   return { message: '', code: null, retriable: true };
 }
 
+// ── Stream Consumer ─────────────────────────────────────────────────────────
+//
+// Per-stream consumer factory invoked by engine/llm.js's accumulator. The
+// accumulator owns global stream state (stdout/stderr/text dedup/tool dedup)
+// and exposes the `ctx` API below; the consumer owns Claude-specific per-stream
+// state (joined-text accumulator, content-block Map for tool/thinking
+// tracking) and translates Claude event shapes into ctx callbacks.
+//
+// `ctx` shape (provided by accumulator):
+//   maxTextLength, pushText(value), pushToolUse(name, input),
+//   notifyThinking(), notifyTaskComplete(summary, success),
+//   setUsage(usage), setSessionId(id), setText(value),
+//   toolUseAlreadySeen(name, input)
+
+const THINKING_BLOCK_TYPES = new Set(['thinking', 'redacted_thinking']);
+
+function createStreamConsumer(ctx) {
+  // Per-stream local state. `claudeStreamBlocks` is kept for Map-based
+  // bookkeeping (tool-use blocks, thinking events, out-of-order text-block
+  // reassembly). The incremental `claudeJoinedText` string is the hot-path
+  // accumulator — appending one delta at a time keeps the stream loop O(n).
+  let claudeJoinedText = '';
+  const claudeStreamBlocks = new Map();
+
+  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 _consumeStreamEvent(obj) {
+    const event = obj?.event;
+    if (!event || typeof event !== 'object') return;
+    if (event.type === 'message_start') {
+      claudeStreamBlocks.clear();
+      claudeJoinedText = '';
+      return;
+    }
+    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)) ctx.notifyThinking();
+      // Out-of-order block landing: rebuild from the Map. Common case is
+      // monotonic in-order arrival, where the trailing-append branch wins.
+      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) ctx.pushText(claudeJoinedText);
+      return;
+    }
+    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') ctx.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 — append directly.
+        claudeJoinedText += delta.text;
+        ctx.pushText(claudeJoinedText);
+      }
+      return;
+    }
+    // content_block_stop / message_delta / message_stop are observed but the
+    // accumulator doesn't need to act on them — terminal text comes via the
+    // result event below.
+  }
+
+  function consume(obj) {
+    if (!obj || typeof obj !== 'object') return;
+
+    if (obj.session_id) ctx.setSessionId(obj.session_id);
+
+    if (obj.type === 'stream_event') {
+      _consumeStreamEvent(obj);
+      return;
+    }
+
+    if (obj.type === 'result' && typeof obj.result === 'string') {
+      // Claude result event: terminal text + usage. Override any previously
+      // streamed text — this is the authoritative final answer.
+      ctx.setText(obj.result);
+      if (obj.total_cost_usd || obj.usage) {
+        ctx.setUsage({
+          costUsd: obj.total_cost_usd || 0,
+          inputTokens: obj.usage?.input_tokens || 0,
+          outputTokens: obj.usage?.output_tokens || 0,
+          cacheRead: obj.usage?.cache_read_input_tokens || obj.usage?.cacheReadInputTokens || 0,
+          cacheCreation: obj.usage?.cache_creation_input_tokens || obj.usage?.cacheCreationInputTokens || 0,
+          durationMs: obj.duration_ms || 0,
+          numTurns: obj.num_turns || 0,
+        });
+      }
+      return;
+    }
+
+    if (obj.type === 'assistant' && Array.isArray(obj.message?.content)) {
+      // Claude assistant turn: content blocks (text + tool_use).
+      // Multi-text-block messages (with --include-partial-messages) need their
+      // text JOINED before pushText, otherwise each block overwrites the prior.
+      let assistantText = '';
+      for (const block of obj.message.content) {
+        if (block?.type === 'text' && block.text) {
+          assistantText += block.text;
+        } else if (THINKING_BLOCK_TYPES.has(block?.type)) {
+          ctx.notifyThinking();
+        } else if (block?.type === 'tool_use' && block.name) {
+          ctx.pushToolUse(block.name, block.input || {});
+        }
+      }
+      if (assistantText) ctx.pushText(assistantText);
+    }
+  }
+
+  function reset() {
+    claudeJoinedText = '';
+    claudeStreamBlocks.clear();
+  }
+
+  return { consume, reset };
+}
+
 // ── Capability Block ────────────────────────────────────────────────────────
 
 const capabilities = {
@@ -387,6 +518,8 @@ const capabilities = {
   fallbackModel: true,
   // Engine controls session persistence (writes session.json on completion)
   sessionPersistenceControl: true,
+  // Adapter implements createStreamConsumer(ctx) — required by llm.js accumulator
+  streamConsumer: true,
 };
 
 // Install hint surfaced when `resolveBinary()` returns null. Consumed by
@@ -409,6 +542,8 @@ module.exports = {
   parseOutput,
   parseStreamChunk,
   parseError,
+  createStreamConsumer,
   // Exposed for unit tests — never imported by engine code
   _CLAUDE_SHORTHANDS,
+  THINKING_BLOCK_TYPES,
 };

package/engine/runtimes/copilot.js

@@ -529,6 +529,112 @@ async function listModels({ env = process.env, timeoutMs = 10000 } = {}) {
   return models;
 }
 
+// ── Stream Consumer ─────────────────────────────────────────────────────────
+//
+// Per-stream consumer factory invoked by engine/llm.js's accumulator. Owns
+// Copilot-specific per-stream state (delta-content buffer, task_complete
+// signal). Translates Copilot event shapes into ctx callbacks.
+//
+// `ctx` shape (provided by accumulator):
+//   maxTextLength, pushText(value), pushToolUse(name, input),
+//   notifyThinking(), notifyTaskComplete(summary, success),
+//   setUsage(usage), setSessionId(id), setText(value),
+//   toolUseAlreadySeen(name, input)
+
+function _copilotAssistantMessageHasTools(obj) {
+  const requests = obj?.data?.toolRequests;
+  return Array.isArray(requests) && requests.length > 0;
+}
+
+function createStreamConsumer(ctx) {
+  // Copilot streams `assistant.message_delta` with `data.deltaContent` chunks
+  // before emitting `assistant.message`. Tool-request narration ("I'll
+  // inspect...") is progress text only — terminal text comes from non-tool
+  // assistant messages or trailing deltas.
+  let copilotMessageBuffer = '';
+  let copilotTaskCompleteSeen = false;
+
+  function _captureTaskComplete(summary, success = true) {
+    if (typeof summary !== 'string' || !summary) return;
+    copilotTaskCompleteSeen = true;
+    copilotMessageBuffer = '';
+    ctx.notifyTaskComplete(summary, success !== false);
+  }
+
+  function consume(obj) {
+    if (!obj || typeof obj !== 'object') return;
+
+    if (obj.type === 'result' && typeof obj.sessionId === 'string') {
+      ctx.setSessionId(obj.sessionId);
+    }
+
+    if (obj.type === 'session.task_complete') {
+      _captureTaskComplete(obj.data?.summary, obj.data?.success);
+      return;
+    }
+
+    if (obj.type === 'assistant.reasoning' || obj.type === 'assistant.reasoning_delta') {
+      ctx.notifyThinking();
+      return;
+    }
+
+    if (obj.type === 'assistant.message_delta' && typeof obj.data?.deltaContent === 'string') {
+      if (copilotTaskCompleteSeen) return;
+      copilotMessageBuffer += obj.data.deltaContent;
+      ctx.pushText(copilotMessageBuffer);
+      return;
+    }
+
+    if (obj.type === 'assistant.message') {
+      // Process toolRequests EVEN WHEN data.content is undefined — tool-only
+      // assistant messages would otherwise be dropped (earlier review bug:
+      // the `typeof data.content === 'string'` gate skipped them entirely).
+      const data = obj.data || {};
+      const content = data.content;
+      const hasTools = _copilotAssistantMessageHasTools(obj);
+      if (typeof content === 'string') {
+        // Tool-request narration is progress text only — don't let it become
+        // the terminal answer. A non-tool assistant.message overrides any
+        // streamed deltas (Copilot's authoritative final text for the turn).
+        if (content && !hasTools) ctx.setText(content);
+        copilotMessageBuffer = '';
+      }
+      if (Array.isArray(data.toolRequests)) {
+        for (const tr of data.toolRequests) {
+          if (!tr || !tr.name) continue;
+          if (tr.name === 'task_complete') {
+            _captureTaskComplete(tr.arguments?.summary || tr.intentionSummary);
+            continue;
+          }
+          ctx.pushToolUse(tr.name, tr.arguments || {});
+        }
+      }
+      return;
+    }
+
+    if (obj.type === 'tool.execution_start' && obj.data?.toolName) {
+      if (obj.data.toolName === 'task_complete') {
+        _captureTaskComplete(obj.data.arguments?.summary);
+        return;
+      }
+      const name = obj.data.toolName;
+      const input = obj.data.arguments || {};
+      // Dedup against assistant.message.toolRequests — accumulator tracks
+      // the toolUses array and exposes a same-name+input check.
+      if (!ctx.toolUseAlreadySeen(name, input)) {
+        ctx.pushToolUse(name, input);
+      }
+    }
+  }
+
+  function reset() {
+    copilotMessageBuffer = '';
+    copilotTaskCompleteSeen = false;
+  }
+
+  return { consume, reset };
+}
+
 // ── Capability Block ────────────────────────────────────────────────────────
 
 const capabilities = {
@@ -556,6 +662,8 @@ const capabilities = {
   fallbackModel: false,
   // Copilot manages session state internally in ~/.copilot/session-state/
   sessionPersistenceControl: false,
+  // Adapter implements createStreamConsumer(ctx) — required by llm.js accumulator
+  streamConsumer: true,
 };
 
 // Install hint surfaced when `resolveBinary()` returns null. Covers all
@@ -582,10 +690,12 @@ module.exports = {
   parseOutput,
   parseStreamChunk,
   parseError,
+  createStreamConsumer,
   // Exposed for unit tests — engine code MUST go through resolveRuntime + the
   // adapter contract; never reach into these helpers directly.
   _CLAUDE_SHORTHANDS,
   _resetShorthandWarning,
   _mapEffort,
+  _copilotAssistantMessageHasTools,
   KNOWN_EVENT_TYPES,
 };

package/engine.js

@@ -2171,7 +2171,7 @@ async function discoverFromPrs(config, project) {
     if (evalLoopEnabled && reviewStatus === 'changes-requested' && !awaitingReReview && !evalEscalated) {
       const key = `fix-${project?.name || 'default'}-${prDisplayId}`;
       if (isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) continue;
-      const agentId = resolveAgent('fix', config, pr.agent);
+      const agentId = resolveAgent('fix', config, { authorAgent: pr.agent });
       if (!agentId) continue;
 
       const item = buildPrDispatch(agentId, config, project, pr, 'fix', {
@@ -2210,7 +2210,7 @@ async function discoverFromPrs(config, project) {
         }
         continue;
       }
-      const agentId = resolveAgent('fix', config, pr.agent);
+      const agentId = resolveAgent('fix', config, { authorAgent: pr.agent });
       if (!agentId) continue;
 
       const coalesced = [...staleCoalesced, ...getCoalescedContexts(key)];
@@ -2290,7 +2290,7 @@ async function discoverFromPrs(config, project) {
         }
       } catch (e) { log('warn', `Pre-dispatch build check for ${pr.id}: ${e.message} — skipping dispatch`); continue; }
 
-      const agentId = resolveAgent('fix', config, pr.agent);
+      const agentId = resolveAgent('fix', config, { authorAgent: pr.agent });
       if (!agentId) continue;
 
       let reviewNote = `Build is failing: ${pr.buildFailReason || 'Check CI pipeline for details'}. Fix the build errors and push.`;
@@ -2365,7 +2365,7 @@ async function discoverFromPrs(config, project) {
         } catch (e) { log('warn', `Pre-dispatch conflict check for ${pr.id}: ${e.message} — skipping dispatch`); liveSkip = true; }
 
         if (!liveSkip) {
-          const agentId = resolveAgent('fix', config, pr.agent);
+          const agentId = resolveAgent('fix', config, { authorAgent: pr.agent });
           if (agentId) {
             const item = buildPrDispatch(agentId, config, project, pr, 'fix', {
               pr_id: pr.id, pr_branch: pr.branch || '',
@@ -2502,7 +2502,7 @@ function discoverFromWorkItems(config, project) {
       needsWrite = true;
     }
     const agentHints = routing.extractAgentHints(item);
-    const agentId = item.agent || resolveAgent(workType, config, null, agentHints);
+    const agentId = item.agent || resolveAgent(workType, config, { agentHints });
     if (!agentId) {
       // Check if reason is budget
       const cfgAgents = config.agents || {};
@@ -3022,7 +3022,7 @@ function discoverCentralWorkItems(config) {
     } else {
       // ─── Normal: single agent dispatch ──────────────────────────────
       const agentHints = routing.extractAgentHints(item);
-      const agentId = item.agent || resolveAgent(workType, config, null, agentHints);
+      const agentId = item.agent || resolveAgent(workType, config, { agentHints });
       if (!agentId) continue;
 
       const agentName = config.agents[agentId]?.name || agentId;
@@ -3664,7 +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 fallback = resolveAgent(item.type || WORK_TYPE.FIX, config, null, routing.extractAgentHints(item.meta?.item));
+      const fallback = resolveAgent(item.type || WORK_TYPE.FIX, config, { agentHints: routing.extractAgentHints(item.meta?.item) });
       if (!fallback) {
         log('warn', `Pending dispatch ${item.id} has no agent and routing returned no fallback — skipping`);
         continue;

package/package.json

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