@yemi33/minions 0.1.1931 → 0.1.1932

package/dashboard.js

@@ -2480,8 +2480,10 @@ async function _preflightModelCheck({ runtime: cliOverride, model: modelOverride
  *     contract SSE consumers depend on).
  *   - `usage` is `{}` because ACP `session/update` notifications don't
  *     surface token counts; trackEngineUsage is a no-op on `{}`.
- *   - Tool calls are not surfaced (sub-task B/C don't plumb `tool_call`
- *     notifications into a callback). Matches CC's pool trade-off.
+ *   - Tool calls are surfaced via the optional `onToolUse(name, input)`
+ *     callback (ACP `tool_call` notification, mapped to Claude-style
+ *     {name, input}). `tool_call_update` (results) is ignored to avoid
+ *     double chips.
  *   - Honors `timeoutMs`. On timeout: cancels the prompt, closes the tab
  *     (so the next call rebuilds against a clean process), resolves with
  *     `{ code: 1, stderr: 'doc-chat-pool: timeout after Xms' }`. The
@@ -2496,7 +2498,7 @@ async function _preflightModelCheck({ runtime: cliOverride, model: modelOverride
  * document body. Always re-sending extraContext is correctness-safe; the
  * pool's warm-process saving is preserved regardless.
  */
-function _invokeDocChatViaPool({ prompt, model, effort, engineConfig, systemPrompt, sessionKey, freshSession, timeoutMs, onChunk }) {
+function _invokeDocChatViaPool({ prompt, model, effort, engineConfig, systemPrompt, sessionKey, freshSession, timeoutMs, onChunk, onToolUse }) {
   const oneShot = !!freshSession;
   const tabKey = oneShot
     ? 'doc-chat:fresh:' + shared.uid()
@@ -2574,6 +2576,11 @@ function _invokeDocChatViaPool({ prompt, model, effort, engineConfig, systemProm
           try { onChunk(accumulated); } catch { /* swallow */ }
         }
       },
+      onToolUse: (name, input) => {
+        if (onToolUse) {
+          try { onToolUse(name, input || {}); } catch { /* swallow */ }
+        }
+      },
       onDone: () => {
         finalize({ text: accumulated, sessionId: sessionHandle.sessionId, code: 0, usage: {}, raw: accumulated, stderr: '' });
       },
@@ -2786,7 +2793,7 @@ async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext
     const p = _invokeDocChatViaPool({
       prompt: poolPrompt, sessionKey, model, effort: ccEffort,
       engineConfig: CONFIG.engine, systemPrompt,
-      onChunk,
+      onChunk, onToolUse,
       freshSession, timeoutMs: timeout,
     });
     if (onAbortReady) onAbortReady(p.abort);
@@ -6311,7 +6318,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
    */
   function _invokeCcStream({ prompt, sessionId, liveState, toolUses, model, effort, maxTurns, engineConfig, systemPrompt = CC_STATIC_SYSTEM_PROMPT, tabId }) {
     if (shared.resolveCcUseWorkerPool(engineConfig)) {
-      return _invokeCcStreamViaPool({ prompt, liveState, model, effort, engineConfig, systemPrompt, tabId });
+      return _invokeCcStreamViaPool({ prompt, liveState, toolUses, model, effort, engineConfig, systemPrompt, tabId });
     }
     const { callLLMStreaming } = require('./engine/llm');
     return callLLMStreaming(prompt, systemPrompt, {
@@ -6345,16 +6352,17 @@ What would you like to discuss or change? When you're happy, say "approve" and I
    *     callLLMStreaming's contract is "full accumulated text"; we accumulate
    *     here so `liveState.text` and downstream chunk events keep the same
    *     semantics consumers already depend on.
-   *   - Tool calls are not surfaced in sub-task B (the pool ignores
-   *     `tool_call` notifications). `toolUses` stays empty on this path; if
-   *     sub-task C/D adds tool_call surfacing in the pool we'll plumb a
-   *     callback here too.
+   *   - Tool calls are surfaced via the pool's `onToolUse` callback (ACP
+   *     `tool_call` notification, mapped to Claude-style {name, input} so the
+   *     dashboard's existing formatToolSummary chips render unchanged).
+   *     `tool_call_update` events (status: completed) are intentionally
+   *     ignored — surfacing results too would double the chip count.
    *   - `usage` is reported as an empty object — ACP doesn't expose token
    *     counts in the in-flight session/update notifications, and the pool's
    *     long-lived process makes per-turn usage attribution non-trivial.
    *     trackEngineUsage is a no-op on `{}`.
    */
-  function _invokeCcStreamViaPool({ prompt, liveState, model, effort, engineConfig, systemPrompt, tabId }) {
+  function _invokeCcStreamViaPool({ prompt, liveState, toolUses, model, effort, engineConfig, systemPrompt, tabId }) {
     const resolvedTabId = tabId || 'default';
     let cancelled = false;
     let accumulated = '';
@@ -6396,6 +6404,13 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           liveState.text = accumulated;
           if (liveState.writer) liveState.writer({ type: 'chunk', text: accumulated });
         },
+        onToolUse: (name, input) => {
+          _touchCcLiveStream(liveState);
+          const safeInput = input || {};
+          if (Array.isArray(toolUses)) toolUses.push({ name, input: safeInput });
+          if (Array.isArray(liveState.tools)) liveState.tools.push({ name, input: safeInput });
+          if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(safeInput) });
+        },
         onDone: () => {
           resolveResult({ text: accumulated, sessionId: sessionHandle.sessionId, code: 0, usage: {}, raw: accumulated, stderr: '' });
         },

package/engine/cc-worker-pool.js

@@ -251,10 +251,21 @@ class Worker {
         if (text && this.inflight.onChunk) {
           try { this.inflight.onChunk(text); } catch { /* swallow */ }
         }
+      } else if (update.sessionUpdate === 'tool_call' && this.inflight.onToolUse) {
+        // ACP `tool_call` (status: pending, fired at invocation time) is the
+        // pool's equivalent of Claude's tool_use event. We map kinds to
+        // Claude-style tool names so the dashboard's existing
+        // formatToolSummary (Bash → "$ <cmd>", Read → "Reading <path>", etc.)
+        // works unchanged. Status updates (`tool_call_update`, status:
+        // completed) carry the result and are ignored here — surfacing
+        // results too would double the chip count without adding info the
+        // user can act on.
+        const mapped = _mapAcpToolCallToToolUse(update);
+        if (mapped) {
+          try { this.inflight.onToolUse(mapped.name, mapped.input); }
+          catch { /* swallow */ }
+        }
       }
-      // Other update kinds (available_commands_update, tool_call, ...) are
-      // ignored in sub-task B. Sub-task C/D will surface tool_call to the
-      // dashboard's onToolUse callback.
     }
   }
 
@@ -279,7 +290,7 @@ class Worker {
 
   // ── Stream a single turn ───────────────────────────────────────────────
   stream(promptText, opts = {}) {
-    const { onChunk, onDone, onError, signal, systemPromptText } = opts;
+    const { onChunk, onToolUse, onDone, onError, signal, systemPromptText } = opts;
     if (this.killed) {
       const err = new Error('cc-worker-pool: tab is closed');
       if (onError) try { onError(err); } catch { /* swallow */ }
@@ -307,6 +318,7 @@ class Worker {
       id,
       sessionId: this.sessionId,
       onChunk,
+      onToolUse,
       onDone,
       onError,
       signal,
@@ -425,6 +437,46 @@ function _extractChunkText(content) {
   return '';
 }
 
+// Map an ACP `tool_call` session/update notification to the {name, input} shape
+// the dashboard's formatToolSummary already understands. ACP's `kind` is a
+// coarse category (execute|read|edit|search|fetch|think|other); we translate to
+// the closest Claude tool name so the existing chip formatters keep working
+// (Bash → "$ <cmd>", Read → "Reading <path>", etc.). Unknown kinds fall back
+// to ACP's human-readable `title` with the raw input attached, which renders
+// through the default `<title>(<key>: <val>)` formatter.
+function _mapAcpToolCallToToolUse(update) {
+  if (!update || update.sessionUpdate !== 'tool_call') return null;
+  const rawInput = (update.rawInput && typeof update.rawInput === 'object') ? update.rawInput : {};
+  const kind = String(update.kind || '').toLowerCase();
+  const title = update.title || '';
+  // For kinds with a clear Claude-tool equivalent, use that name + raw input.
+  switch (kind) {
+    case 'execute':
+      return { name: 'Bash', input: rawInput };
+    case 'read':
+      return { name: 'Read', input: rawInput };
+    case 'edit':
+      return { name: 'Edit', input: rawInput };
+    case 'search': {
+      // Heuristic: Grep needs a pattern; Glob needs a glob pattern.
+      // ACP doesn't distinguish, so prefer Grep when a `path` hint is present
+      // (matches the dashboard's Grep formatter "Searching <pat> in <path>").
+      const isGrep = typeof rawInput.path === 'string' || typeof rawInput.regex === 'string';
+      return { name: isGrep ? 'Grep' : 'Glob', input: rawInput };
+    }
+    case 'fetch':
+      return { name: 'WebFetch', input: rawInput };
+    case 'think':
+      // No equivalent Claude tool; show the title so the user sees Copilot's
+      // own description of what it's thinking about.
+      return { name: title || 'Think', input: rawInput };
+    default:
+      // Fallback: show ACP's title and pass rawInput through. The dashboard's
+      // default formatter renders this as `<title>(<key>: <val>)`.
+      return { name: title || kind || 'Tool', input: rawInput };
+  }
+}
+
 // ── Public API ────────────────────────────────────────────────────────────
 
 async function getSession({ tabId, model, effort, mcpServers, systemPromptHash, cwd } = {}) {

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-14T03:32:45.485Z"
+  "cachedAt": "2026-05-14T03:48:55.090Z"
 }

package/package.json

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