@yemi33/minions 0.1.1931 → 0.1.1933

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,22 +6352,44 @@ 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 = '';
     let sessionHandle = null;
     let resolveResult;
+    // Per-turn phase timing — emitted as one structured [cc-timing] log line
+    // so we can attribute Copilot CC slowness (e.g. 36s) to spawn vs first-byte
+    // vs streaming vs trailing inference. Parallels engine.js's [spawn-timing].
+    const _tStart = Date.now();
+    let _tFirstByte = null;
+    let _tFirstTool = null;
+    let _chunkCount = 0;
+    let _toolUseCount = 0;
     const promise = new Promise((resolve) => { resolveResult = resolve; });
+    const _emitTimingLog = (lifecycle, sessionReady, streamEnd, outcome) => {
+      try {
+        const _diff = (a, b) => (a != null && b != null) ? (b - a) : null;
+        const timings = {
+          get_session: _diff(_tStart, sessionReady),
+          first_byte: _diff(sessionReady, _tFirstByte),
+          first_tool: _diff(sessionReady, _tFirstTool),
+          stream: _diff(sessionReady, streamEnd),
+          total: _diff(_tStart, streamEnd),
+        };
+        shared.log('info', `[cc-timing] tab=${resolvedTabId} lifecycle=${lifecycle || 'unknown'} outcome=${outcome} chunks=${_chunkCount} tools=${_toolUseCount} ${JSON.stringify(timings)}`);
+      } catch { /* telemetry is best-effort */ }
+    };
     promise.abort = () => {
       cancelled = true;
       try { sessionHandle && sessionHandle.cancel(); } catch { /* swallow */ }
@@ -6375,6 +6404,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           systemPromptHash: _ccPromptHash,
         });
       } catch (err) {
+        _emitTimingLog(null, null, Date.now(), 'spawn-failed');
         return resolveResult({
           text: '',
           sessionId: null,
@@ -6384,22 +6414,38 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           stderr: String((err && err.message) || err || 'cc-worker-pool spawn failed'),
         });
       }
+      const _tSessionReady = Date.now();
+      const _lifecycle = sessionHandle.lifecycle || 'unknown';
       if (cancelled) {
         try { sessionHandle.cancel(); } catch { /* swallow */ }
+        _emitTimingLog(_lifecycle, _tSessionReady, Date.now(), 'cancelled-pre-stream');
         return resolveResult({ text: accumulated, sessionId: sessionHandle.sessionId, code: 0, usage: {}, raw: accumulated, stderr: '' });
       }
       await sessionHandle.stream(prompt, {
         systemPromptText: systemPrompt,
         onChunk: (delta) => {
+          if (_tFirstByte == null) _tFirstByte = Date.now();
+          _chunkCount += 1;
           accumulated += delta;
           _touchCcLiveStream(liveState);
           liveState.text = accumulated;
           if (liveState.writer) liveState.writer({ type: 'chunk', text: accumulated });
         },
+        onToolUse: (name, input) => {
+          if (_tFirstTool == null) _tFirstTool = Date.now();
+          _toolUseCount += 1;
+          _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: () => {
+          _emitTimingLog(_lifecycle, _tSessionReady, Date.now(), 'done');
           resolveResult({ text: accumulated, sessionId: sessionHandle.sessionId, code: 0, usage: {}, raw: accumulated, stderr: '' });
         },
         onError: (err) => {
+          _emitTimingLog(_lifecycle, _tSessionReady, Date.now(), cancelled ? 'cancelled' : 'error');
           resolveResult({
             text: accumulated,
             sessionId: sessionHandle.sessionId,

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,12 +437,58 @@ 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 } = {}) {
   if (!tabId) throw new Error('cc-worker-pool.getSession: tabId is required');
   const mcpServersHash = _hashMcpServers(mcpServers);
   let worker = _tabs.get(tabId);
+  // Track which lifecycle path we took so the dashboard's [cc-timing] log can
+  // attribute warm-reuse vs new-session vs cold-spawn. One of:
+  //   'warm-reuse'  — proc + session both reused (no spawn, no session/new)
+  //   'new-session' — proc reused, fresh session/new (sysprompt hash changed)
+  //   'cold-spawn'  — fresh proc + initialize + session/new
+  let lifecycle = 'warm-reuse';
 
   if (worker) {
     if (worker.killed) {
@@ -449,6 +507,7 @@ async function getSession({ tabId, model, effort, mcpServers, systemPromptHash,
       // caller has rotated in (Bug B / issue #2479).
       await worker.newSession({ mcpServers, systemPromptHash, model, effort });
       worker.lastUsedAt = _internals.now();
+      lifecycle = 'new-session';
     } else {
       // Warm reuse — only update bookkeeping. model/effort changes on a
       // warm session are tracked here but not pushed via configOptions in
@@ -472,12 +531,14 @@ async function getSession({ tabId, model, effort, mcpServers, systemPromptHash,
       try { worker.close(); } catch { /* already torn down */ }
       throw err;
     }
+    lifecycle = 'cold-spawn';
   }
 
   _ensureReaper();
 
   return {
     sessionId: worker.sessionId,
+    lifecycle,
     stream: (promptText, opts) => worker.stream(promptText, opts),
     cancel: () => worker.cancel(),
     close: () => closeTab(tabId),

package/engine/copilot-models.json

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

package/package.json

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