@yemi33/minions 0.1.1936 → 0.1.1937

package/dashboard/js/command-center.js

@@ -397,13 +397,7 @@ function ccSwitchTab(id) {
       var html = '';
       var tools = tab._toolsUsed || [];
       if (tools.length > 0) {
-        html += '<div style="margin-bottom:6px">';
-        tools.forEach(function(t) {
-          var name = typeof t === 'string' ? t : t.name;
-          var input = typeof t === 'string' ? {} : (t.input || {});
-          html += '<div style="color:var(--muted);font-size:10px;font-family:monospace"><span style="flex-shrink:0">&#9679;</span> ' + formatToolSummary(name, input) + '</div>';
-        });
-        html += '</div>';
+        html += '<div style="margin-bottom:6px">' + tools.map(renderToolChip).join('') + '</div>';
       }
       var text = tab._streamedText || '';
       if (text) html += renderMd(text);
@@ -779,13 +773,7 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
       }
       var html = '';
       if (toolsUsed.length > 0) {
-        html += '<div style="margin-bottom:6px">';
-        toolsUsed.forEach(function(t) {
-          var name = typeof t === 'string' ? t : t.name;
-          var input = typeof t === 'string' ? {} : (t.input || {});
-          html += '<div style="color:var(--muted);font-size:10px;font-family:monospace"><span style="flex-shrink:0">&#9679;</span> ' + formatToolSummary(name, input) + '</div>';
-        });
-        html += '</div>';
+        html += '<div style="margin-bottom:6px">' + toolsUsed.map(renderToolChip).join('') + '</div>';
       }
       if (streamedText) {
         html += renderMd(streamedText);
@@ -851,10 +839,19 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
       } else if (evt.type === 'heartbeat') {
         return;
       } else if (evt.type === 'tool') {
-        toolsUsed.push({ name: evt.name, input: evt.input || {} });
+        toolsUsed.push({ name: evt.name, input: evt.input || {}, id: evt.id || null, status: evt.id ? 'pending' : null });
         if (activeTab) activeTab._toolsUsed = toolsUsed.slice();
         updateStreamDiv();
         if (msgs.scrollHeight - msgs.scrollTop - msgs.clientHeight < 150) msgs.scrollTop = msgs.scrollHeight;
+      } else if (evt.type === 'tool-update') {
+        for (var ti = 0; ti < toolsUsed.length; ti++) {
+          if (toolsUsed[ti] && toolsUsed[ti].id === evt.id) {
+            toolsUsed[ti].status = evt.status;
+            break;
+          }
+        }
+        if (activeTab) activeTab._toolsUsed = toolsUsed.slice();
+        updateStreamDiv();
       } else if (evt.type === 'done') {
         terminalEventSeen = true;
         _cleanupStreamDiv();

package/dashboard/js/render-utils.js

@@ -1,6 +1,26 @@
 // dashboard/js/render-utils.js — Shared formatting helpers for agent output rendering
 // Depends on: escHtml() and renderMd() from utils.js (loaded before this file)
 
+// marker + color per tool-call status. ACP `tool_call_update` flips chips from
+// pending → completed/failed mid-stream so the user sees real progress; the
+// non-pool (Claude direct) path emits status=null and stays on the neutral dot.
+var _CC_TOOL_CHIP_STYLE = {
+  pending:   { marker: '●', color: 'var(--muted)' },
+  completed: { marker: '✓', color: 'var(--green, #4ade80)' },
+  failed:    { marker: '✕', color: 'var(--red, #ef4444)' },
+};
+
+function renderToolChip(t) {
+  var name = typeof t === 'string' ? t : t.name;
+  var input = typeof t === 'string' ? {} : (t.input || {});
+  var status = typeof t === 'string' ? null : (t.status || null);
+  var style = _CC_TOOL_CHIP_STYLE[status] || _CC_TOOL_CHIP_STYLE.pending;
+  return '<div style="color:' + style.color + ';font-size:10px;font-family:monospace">'
+    + '<span style="flex-shrink:0">' + style.marker + '</span> '
+    + formatToolSummary(name, input)
+    + '</div>';
+}
+
 /**
  * Returns a one-line human-readable summary for a Claude tool call.
  * @param {string} name - Tool name (e.g. 'Bash', 'Read', 'Edit')

package/dashboard.js

@@ -2498,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, onToolUse }) {
+function _invokeDocChatViaPool({ prompt, model, effort, engineConfig, systemPrompt, sessionKey, freshSession, timeoutMs, onChunk, onToolUse, onToolUpdate }) {
   const oneShot = !!freshSession;
   const tabKey = oneShot
     ? 'doc-chat:fresh:' + shared.uid()
@@ -2576,9 +2576,14 @@ function _invokeDocChatViaPool({ prompt, model, effort, engineConfig, systemProm
           try { onChunk(accumulated); } catch { /* swallow */ }
         }
       },
-      onToolUse: (name, input) => {
+      onToolUse: (name, input, toolCallId) => {
         if (onToolUse) {
-          try { onToolUse(name, input || {}); } catch { /* swallow */ }
+          try { onToolUse(name, input || {}, toolCallId); } catch { /* swallow */ }
+        }
+      },
+      onToolUpdate: (toolCallId, status) => {
+        if (onToolUpdate) {
+          try { onToolUpdate(toolCallId, status); } catch { /* swallow */ }
         }
       },
       onDone: () => {
@@ -2762,7 +2767,7 @@ async function ccCall(message, { store = 'cc', sessionKey, extraContext, label =
   return result;
 }
 
-async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext, label = 'command-center', timeout = CC_CALL_TIMEOUT_MS, maxTurns, allowedTools = 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch', skipStatePreamble = false, skipPreflight = false, model, onAbortReady, onChunk, onToolUse, onRetry, systemPrompt = CC_STATIC_SYSTEM_PROMPT, transcript, turnId, freshSession = false } = {}) {
+async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext, label = 'command-center', timeout = CC_CALL_TIMEOUT_MS, maxTurns, allowedTools = 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch', skipStatePreamble = false, skipPreflight = false, model, onAbortReady, onChunk, onToolUse, onToolUpdate, onRetry, systemPrompt = CC_STATIC_SYSTEM_PROMPT, transcript, turnId, freshSession = false } = {}) {
   if (!maxTurns) maxTurns = CONFIG.engine?.ccMaxTurns || shared.ENGINE_DEFAULTS.ccMaxTurns;
   if (!model) model = CONFIG.engine?.ccModel || shared.ENGINE_DEFAULTS.ccModel;
   const ccEffort = CONFIG.engine?.ccEffort || shared.ENGINE_DEFAULTS.ccEffort;
@@ -2793,7 +2798,7 @@ async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext
     const p = _invokeDocChatViaPool({
       prompt: poolPrompt, sessionKey, model, effort: ccEffort,
       engineConfig: CONFIG.engine, systemPrompt,
-      onChunk, onToolUse,
+      onChunk, onToolUse, onToolUpdate,
       freshSession, timeoutMs: timeout,
     });
     if (onAbortReady) onAbortReady(p.abort);
@@ -6163,17 +6168,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         const abort = ccInFlightAborts.get(tabId);
         if (abort) { try { abort(); } catch {} }
       }
-      // Sub-task C of W-mp2w003600196c51: when the worker pool is on, abort
-      // must also fire `session/cancel` on the persistent ACP process so the
-      // remote daemon stops generating into a torn-down session. The pool
-      // exposes cancellation via the SessionHandle returned from getSession;
-      // we don't keep that handle around here, so route through closeTab to
-      // both cancel inflight and tear down the worker (cheaper than tracking
-      // per-tab handles in dashboard state, and matches "tab close" semantics
-      // — if the user explicitly aborted, we don't owe them a warm process).
-      // Off when the flag is off so legacy SIGTERM-only behavior is preserved.
+      // Cancel the inflight ACP turn but keep the warm worker; closing the
+      // tab here would force the next turn to pay the ~7-8 s cold-spawn.
       if (shared.resolveCcUseWorkerPool(CONFIG.engine)) {
-        try { ccWorkerPool.closeTab(tabId); } catch { /* swallow */ }
+        try { ccWorkerPool.cancelInflight(tabId); } catch { /* swallow */ }
       }
       _clearCcLiveStream(tabId);
       _releaseCCTab(tabId);
@@ -6333,9 +6331,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       },
       onToolUse: (name, input) => {
         _touchCcLiveStream(liveState);
-        toolUses.push({ name, input: input || {} });
-        liveState.tools.push({ name, input: input || {} });
-        if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(input) });
+        const entry = { name, input: input || {}, id: null, status: null };
+        toolUses.push(entry);
+        liveState.tools.push(entry);
+        if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(input), id: null });
       },
     });
   }
@@ -6431,14 +6430,26 @@ 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) => {
+        onToolUse: (name, input, toolCallId) => {
           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) });
+          const entry = { name, input: safeInput, id: toolCallId || null, status: toolCallId ? 'pending' : null };
+          if (Array.isArray(toolUses)) toolUses.push(entry);
+          if (Array.isArray(liveState.tools)) liveState.tools.push(entry);
+          if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(safeInput), id: toolCallId || null });
+        },
+        onToolUpdate: (toolCallId, status) => {
+          _touchCcLiveStream(liveState);
+          // toolUses and liveState.tools hold the same entry references (both
+          // populated via onToolUse above), so mutating in one side reflects
+          // in the other. Patch once.
+          if (Array.isArray(toolUses)) {
+            const entry = toolUses.find((e) => e && e.id === toolCallId);
+            if (entry) entry.status = status;
+          }
+          if (liveState.writer) liveState.writer({ type: 'tool-update', id: toolCallId, status });
         },
         onDone: () => {
           _emitTimingLog(_lifecycle, _tSessionReady, Date.now(), 'done');

package/engine/cc-worker-pool.js

@@ -252,17 +252,19 @@ class Worker {
           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.
+        // ACP `tool_call` (pending) → Claude-style {name, input} via
+        // _mapAcpToolCallToToolUse so the dashboard's formatToolSummary
+        // formatters (Bash → "$ <cmd>", etc.) work unchanged.
         const mapped = _mapAcpToolCallToToolUse(update);
         if (mapped) {
-          try { this.inflight.onToolUse(mapped.name, mapped.input); }
+          try { this.inflight.onToolUse(mapped.name, mapped.input, update.toolCallId); }
+          catch { /* swallow */ }
+        }
+      } else if (update.sessionUpdate === 'tool_call_update' && this.inflight.onToolUpdate) {
+        // Terminal-state updates only (completed/failed). In-progress updates
+        // exist in the ACP spec but add chip churn without actionable info.
+        if (update.status === 'completed' || update.status === 'failed') {
+          try { this.inflight.onToolUpdate(update.toolCallId, update.status); }
           catch { /* swallow */ }
         }
       }
@@ -290,7 +292,7 @@ class Worker {
 
   // ── Stream a single turn ───────────────────────────────────────────────
   stream(promptText, opts = {}) {
-    const { onChunk, onToolUse, onDone, onError, signal, systemPromptText } = opts;
+    const { onChunk, onToolUse, onToolUpdate, 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 */ }
@@ -319,6 +321,7 @@ class Worker {
       sessionId: this.sessionId,
       onChunk,
       onToolUse,
+      onToolUpdate,
       onDone,
       onError,
       signal,
@@ -449,31 +452,44 @@ function _mapAcpToolCallToToolUse(update) {
   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.
+
+  // Field-name normalization: Copilot ACP and Claude tool_use use different
+  // keys for the same concept (Copilot `path`, Claude `file_path`). Normalize
+  // here so the dashboard's formatToolSummary — written against Claude's
+  // names — produces the same chip text on both runtimes.
+  const filePath = rawInput.file_path || rawInput.path || rawInput.filePath || '';
+
+  // Pattern (Grep) — Copilot uses `paths` (plural) for the search scope where
+  // Claude's Grep takes `path`.
+  if (typeof rawInput.pattern === 'string') {
+    return {
+      name: 'Grep',
+      input: { pattern: rawInput.pattern, path: rawInput.paths || rawInput.path || '.' },
+    };
+  }
+
   switch (kind) {
     case 'execute':
       return { name: 'Bash', input: rawInput };
     case 'read':
-      return { name: 'Read', input: rawInput };
+      // ACP overloads `read` for both file-view and grep — the pattern check
+      // above already handled grep, so this branch is the file-view case.
+      return { name: 'Read', input: { file_path: filePath } };
     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 };
-    }
+      return { name: 'Edit', input: { file_path: filePath } };
+    case 'search':
+      // Pattern check above handled the grep case; arriving here means glob.
+      return { name: '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 };
+      // Unknown kind — use ACP's human-readable title as the chip label and
+      // drop rawInput so formatToolSummary's default branch shows just the
+      // title (avoids `<title>(<key>: <val>)` clutter when the input shape
+      // is unfamiliar).
+      return { name: title || kind || 'Tool', input: {} };
   }
 }
 
@@ -552,6 +568,18 @@ function closeTab(tabId) {
   worker.close();
 }
 
+// Cancel the currently in-flight prompt on this tab without killing the
+// worker. Sends ACP `session/cancel` so the remote daemon stops generating;
+// the warm process + initialized MCP servers + session state are preserved
+// so the next prompt skips the ~7-8 s cold-spawn cost. No-op if the tab has
+// no worker or no inflight prompt.
+function cancelInflight(tabId) {
+  const worker = _tabs.get(tabId);
+  if (!worker || worker.killed || !worker.inflight) return false;
+  try { worker.cancel(); } catch { /* swallow */ }
+  return true;
+}
+
 function shutdown() {
   for (const worker of _tabs.values()) {
     try { worker.close(); } catch { /* swallow */ }
@@ -583,6 +611,7 @@ function _reapIdleTabs() {
 module.exports = {
   getSession,
   closeTab,
+  cancelInflight,
   shutdown,
   // Exposed for unit tests; engine code MUST go through the public API.
   _internals,

package/package.json

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