@yemi33/minions 0.1.2213 → 0.1.2214

package/dashboard.js

@@ -4672,6 +4672,7 @@ async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext
       engineConfig: CONFIG.engine,
       onChunk,
       onToolUse,
+      onToolUpdate,
     });
     if (onAbortReady) onAbortReady(p1.abort);
     result = await p1;
@@ -4710,6 +4711,7 @@ async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext
     engineConfig: CONFIG.engine,
     onChunk,
     onToolUse,
+    onToolUpdate,
   });
   if (onAbortReady) onAbortReady(p2.abort);
   result = await p2;
@@ -4730,6 +4732,7 @@ async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext
     engineConfig: CONFIG.engine,
     onChunk,
     onToolUse,
+    onToolUpdate,
   });
   if (onAbortReady) onAbortReady(p3.abort);
   result = await p3;
@@ -9255,12 +9258,22 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         liveState.text = text;
         if (liveState.writer) liveState.writer({ type: 'chunk', text, segmentId });
       },
-      onToolUse: (name, input) => {
+      onToolUse: (name, input, id) => {
         _touchCcLiveStream(liveState);
-        const entry = { name, input: input || {}, id: null, status: null };
+        // Claude (direct) now threads a tool_use id; with an id the chip starts
+        // 'pending' and can be flipped to completed/failed by onToolUpdate.
+        const entry = { name, input: input || {}, id: id || null, status: id ? 'pending' : null };
         toolUses.push(entry);
         liveState.tools.push(entry);
-        if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(input), id: null });
+        if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(input), id: id || null });
+      },
+      onToolUpdate: (id, status) => {
+        _touchCcLiveStream(liveState);
+        // toolUses and liveState.tools share entry references — patch once so a
+        // reconnect replays the resolved (green/red) state, not just pending.
+        const entry = toolUses.find((e) => e && e.id === id);
+        if (entry) entry.status = status;
+        if (liveState.writer) liveState.writer({ type: 'tool-update', id, status });
       },
     });
   }
@@ -9673,7 +9686,12 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           reconnectDone();
         });
         for (const tool of live.tools || []) {
-          writeCcEvent({ type: 'tool', name: tool.name, input: _lightToolInput(tool.input) });
+          writeCcEvent({ type: 'tool', name: tool.name, input: _lightToolInput(tool.input), id: tool.id || null });
+          // Replay the resolved chip state (green check / red X) for tools that
+          // already finished, so a reconnect doesn't stick on the pending dot.
+          if (tool.id && tool.status && tool.status !== 'pending') {
+            writeCcEvent({ type: 'tool-update', id: tool.id, status: tool.status });
+          }
         }
         if (live.text) writeCcEvent({ type: 'chunk', text: live.text });
         if (live.donePayload) {

package/engine/llm.js

@@ -507,6 +507,7 @@ function _createStreamAccumulator({
   maxTextLength = 0,
   onChunk = null,
   onToolUse = null,
+  onToolUpdate = null,
   onTaskComplete = null,
   onTerminalResult = null,
   onThinking = null,
@@ -574,12 +575,21 @@ function _createStreamAccumulator({
         onTerminalResult();
       }
     },
-    pushToolUse(name, input) {
+    pushToolUse(name, input, id = null) {
       if (!name) return;
-      const toolUse = { name, input: input || {} };
+      const toolUse = { name, input: input || {}, id: id || null };
       toolUses.push(toolUse);
       sawToolSinceText = true;
-      if (onToolUse) onToolUse(toolUse.name, toolUse.input);
+      if (onToolUse) onToolUse(toolUse.name, toolUse.input, toolUse.id);
+    },
+    updateToolUse(id, status) {
+      // Runtime-agnostic tool-completion signal. Adapters whose stream carries
+      // a per-tool result event (Claude's tool_result, Copilot's
+      // tool_call_update) call this to flip a previously-pushed chip from the
+      // neutral pending dot to a green check / red X. Adapters without such a
+      // signal simply never call it and the chip stays pending.
+      if (!id || !onToolUpdate) return;
+      onToolUpdate(id, status);
     },
     toolUseAlreadySeen(name, input) {
       if (!name) return false;
@@ -869,7 +879,7 @@ function callLLM(promptText, sysPromptText, opts = {}) {
 function callLLMStreaming(promptText, sysPromptText, opts = {}) {
   const {
     timeout = 120000, label = 'llm', maxTurns = 1, allowedTools = '',
-    sessionId = null, onChunk = () => {}, onToolUse = null,
+    sessionId = null, onChunk = () => {}, onToolUse = null, onToolUpdate = null,
     effort = null, direct = false,
     model: modelOverride, cli: cliOverride, engineConfig,
     maxBudget, bare, fallbackModel,
@@ -911,6 +921,7 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
       maxLineBufferBytes: ENGINE_DEFAULTS.maxLlmLineBufferBytes,
       onChunk,
       onToolUse,
+      onToolUpdate,
       // Terminal text from the runtime adapter signals the LLM has logically
       // completed — kick the drain timer so we don't block on a delayed
       // 'exit'/'close' when an inherited pipe keeps the parent's FDs open.

package/engine/runtimes/claude.js

@@ -636,8 +636,9 @@ function parseError(rawOutput) {
 // tracking) and translates Claude event shapes into ctx callbacks.
 //
 // `ctx` shape (provided by accumulator):
-//   maxTextLength, pushText(value), pushToolUse(name, input),
-//   notifyThinking(), notifyTaskComplete(summary, success),
+//   maxTextLength, pushText(value), pushToolUse(name, input, id),
+//   updateToolUse(id, status), notifyThinking(),
+//   notifyTaskComplete(summary, success),
 //   setUsage(usage), setSessionId(id), setText(value),
 //   toolUseAlreadySeen(name, input)
 
@@ -743,11 +744,27 @@ function createStreamConsumer(ctx) {
         } else if (THINKING_BLOCK_TYPES.has(block?.type)) {
           ctx.notifyThinking();
         } else if (block?.type === 'tool_use' && block.name) {
-          ctx.pushToolUse(block.name, block.input || {});
+          // Thread the tool_use id so the dashboard can flip this chip from
+          // pending → completed/failed when the matching tool_result lands.
+          ctx.pushToolUse(block.name, block.input || {}, block.id);
         }
       }
       if (assistantText) ctx.pushText(assistantText);
     }
+
+    if (obj.type === 'user' && Array.isArray(obj.message?.content)) {
+      // Claude reports tool execution results in a subsequent `user` turn:
+      // each block is {type:'tool_result', tool_use_id, is_error, content}.
+      // Flip the previously-pushed chip to completed (success) or failed
+      // (is_error). This is the Claude-direct analogue of Copilot's ACP
+      // tool_call_update; engine/llm.js stays runtime-agnostic — the chip
+      // turns green/red only because this adapter calls ctx.updateToolUse.
+      for (const block of obj.message.content) {
+        if (block?.type === 'tool_result' && block.tool_use_id) {
+          ctx.updateToolUse(block.tool_use_id, block.is_error ? 'failed' : 'completed');
+        }
+      }
+    }
   }
 
   function reset() {

package/package.json

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