@yemi33/minions 0.1.668 → 0.1.670

package/CHANGELOG.md

@@ -1,8 +1,10 @@
 # Changelog
 
-## 0.1.668 (2026-04-09)
+## 0.1.670 (2026-04-09)
 
 ### Fixes
+- surface blocking tool call state in dashboard (closes #619) (#634)
+- interrupt blocking tool calls immediately on steering (closes #627) (#632)
 - reduce Bash blocking grace and errored task dedup window (closes #593) (#630)
 
 ## 0.1.667 (2026-04-09)

package/dashboard/js/render-agents.js

@@ -11,6 +11,7 @@ function renderAgents(agents) {
       </div>
       <div class="agent-role">${escHtml(a.role)}</div>
       <div class="agent-action" title="${escHtml(a.lastAction)}">${escHtml(a.lastAction)}</div>
+      ${a._blockingToolCall ? `<div style="margin-top:4px;padding:4px 8px;background:rgba(130,160,210,0.13);border:1px solid rgba(130,160,210,0.3);border-radius:4px;font-size:10px;color:var(--muted)">&#x23F3; Blocking tool call (${escHtml(a._blockingToolCall.tool)}) &mdash; silent ${Math.round(a._blockingToolCall.silentMs/60000)}min, timeout in ${Math.round(a._blockingToolCall.remainingMs/60000)}min</div>` : ''}
       ${a._warning ? `<div style="margin-top:4px;padding:4px 8px;background:rgba(210,153,34,0.15);border:1px solid rgba(210,153,34,0.3);border-radius:4px;font-size:10px;color:var(--yellow)">&#x26A0; ${escHtml(a._warning)}</div>` : ''}
       ${a._permissionMode && a._permissionMode !== 'bypassPermissions' && !a._warning ? `<div style="margin-top:4px;font-size:9px;color:var(--muted)">Permission mode: ${escHtml(a._permissionMode)}</div>` : ''}
       ${a.resultSummary ? `<div class="agent-result" title="${escHtml(a.resultSummary)}">${renderMd(a.resultSummary.slice(0, 200))}${a.resultSummary.length > 200 ? '...' : ''}</div>` : ''}
@@ -31,6 +32,7 @@ async function openAgentDetail(id) {
   document.getElementById('detail-status-line').innerHTML =
     '<span class="status-badge ' + badgeClass + '">' + agent.status.toUpperCase() + '</span> ' +
     '<span style="color:var(--muted)">' + escHtml(agent.lastAction) + '</span>' +
+    (agent._blockingToolCall ? '<div style="margin-top:4px;padding:4px 8px;background:rgba(130,160,210,0.13);border:1px solid rgba(130,160,210,0.3);border-radius:4px;font-size:11px;color:var(--muted)">&#x23F3; Blocking tool call (' + escHtml(agent._blockingToolCall.tool) + ') &mdash; silent ' + Math.round(agent._blockingToolCall.silentMs/60000) + 'min, timeout in ' + Math.round(agent._blockingToolCall.remainingMs/60000) + 'min</div>' : '') +
     (agent.resultSummary ? '<div style="margin-top:4px;font-size:11px;color:var(--text);line-height:1.4">' + renderMd(agent.resultSummary.slice(0, 300)) + '</div>' : '');
 
   // Show panel immediately with loading state — don't wait for API

package/engine/queries.js

@@ -216,6 +216,10 @@ function getAgentStatus(agentId) {
       branch: active.meta?.branch || '',
       started_at: active.started_at || active.created_at || null,
     };
+    // Surface blocking tool call state from dispatch annotation (set by timeout.js)
+    if (active._blockingToolCall) {
+      result._blockingToolCall = active._blockingToolCall;
+    }
     // Detect permission-waiting: read only head+tail of live-output.log (max 2KB total)
     try {
       const liveLogPath = path.join(AGENTS_DIR, agentId, 'live-output.log');
@@ -330,6 +334,7 @@ function getAgents(config) {
       ...a, status: s.status, lastAction,
       currentTask: (s.task || '').slice(0, 200),
       resultSummary: (s.resultSummary || '').slice(0, 500),
+      _blockingToolCall: s._blockingToolCall || null,
       _warning: s._warning || null,
       _permissionMode: s._permissionMode || null,
       chartered, inboxCount: inboxFiles.length

package/engine/timeout.js

@@ -54,9 +54,28 @@ function checkIdleThreshold(config) {
 
 // ─── Steering Checker ────────────────────────────────────────────────────────
 
+// How long to wait for a steered agent to exit before retrying the kill
+const STEERING_KILL_RETRY_MS = 30000;
+
 function checkSteering(config) {
   const activeProcesses = engine().activeProcesses;
   for (const [id, info] of activeProcesses) {
+    // Recovery: if steering kill hasn't resulted in process exit within 30s, force-retry.
+    // This catches cases where killImmediate silently failed (e.g., orphaned subprocess
+    // on Unix where SIGKILL only hit spawn-agent.js, not the Claude CLI tree).
+    if (info._steeringAt && Date.now() - info._steeringAt > STEERING_KILL_RETRY_MS) {
+      if (!info._steeringRetried) {
+        log('warn', `Steering: ${info.agentId} (${id}) didn't exit ${STEERING_KILL_RETRY_MS / 1000}s after kill — retrying`);
+        shared.killImmediate(info.proc);
+        // On Unix, also try to kill children that may have been orphaned
+        if (process.platform !== 'win32' && info.proc?.pid) {
+          try { shared.exec(`pkill -KILL -P ${info.proc.pid}`, { timeout: 3000 }); } catch { /* children may already be dead */ }
+        }
+        info._steeringRetried = true;
+      }
+      continue;
+    }
+
     // Skip if already being steered (prevents double-kill race)
     if (info._steeringMessage || info._steeringAt) continue;
 
@@ -64,19 +83,34 @@ function checkSteering(config) {
     let steerMtime;
     try { steerMtime = fs.statSync(steerPath).mtimeMs; } catch { continue; } // ENOENT = no steering message
 
+    // Read and consume the message immediately — always delete to prevent stale messages
+    const message = safeRead(steerPath);
+    try { fs.unlinkSync(steerPath); } catch { /* cleanup */ }
+    if (!message) continue;
+
     const sessionId = info.sessionId;
     if (!sessionId) {
-      if (Date.now() - steerMtime > 300000) {
-        log('warn', `Steering: no sessionId for ${info.agentId} after 5m — deleting stale message`);
-        try { fs.unlinkSync(steerPath); } catch {}
-      }
+      // No session to resume — kill agent and deliver message via inbox for retry.
+      // Previously this silently skipped for up to 5m then deleted the message (#627).
+      log('info', `Steering: no sessionId for ${info.agentId} (${id}) — killing and forwarding message to inbox`);
+
+      // Write steering message to agent inbox so it survives the retry
+      const inboxDir = path.join(AGENTS_DIR, info.agentId, 'inbox');
+      try { fs.mkdirSync(inboxDir, { recursive: true }); } catch {}
+      safeWrite(path.join(inboxDir, `steering-${Date.now()}.md`), `# Steering Message (Forwarded)\n\nOriginal steering from human:\n\n${message}\n`);
+
+      // Append to live output so user sees confirmation in the dashboard
+      try {
+        const liveLogPath = path.join(AGENTS_DIR, info.agentId, 'live-output.log');
+        fs.appendFileSync(liveLogPath, `\n[steering] Message received but no session to resume. Killing agent — your message will be delivered on retry.\n`);
+      } catch { /* optional */ }
+
+      shared.killImmediate(info.proc);
+      info._steeringAt = Date.now();
+      info._steeringNoSession = true;
       continue;
     }
 
-    const message = safeRead(steerPath);
-    try { fs.unlinkSync(steerPath); } catch { /* cleanup */ }
-    if (!message) continue;
-
     log('info', `Steering: killing ${info.agentId} (${id}) for session resume with human message`);
 
     shared.killImmediate(info.proc);
@@ -112,6 +146,7 @@ function checkTimeouts(config) {
   //    Uses live-output.log mtime as heartbeat. If no output for heartbeatTimeout, agent is dead.
   const dispatchData = getDispatch();
   const deadItems = [];
+  const blockingAnnotations = new Map(); // id → { tool, silentMs, remainingMs } or null (clear)
 
   for (const item of (dispatchData.active || [])) {
     if (!item.agent) continue;
@@ -164,6 +199,7 @@ function checkTimeouts(config) {
     // Check for BOTH tracked and untracked processes (orphan case after engine restart)
     let isBlocking = false;
     let blockingTimeout = heartbeatTimeout;
+    let blockingTool = '';
     if (silentMs > heartbeatTimeout) {
       try {
         const liveLog = safeRead(liveLogPath);
@@ -184,6 +220,7 @@ function checkTimeouts(config) {
                 const taskTimeout = input.timeout || 600000; // default 10min
                 blockingTimeout = Math.max(heartbeatTimeout, taskTimeout + 60000); // task timeout + 1min grace
                 isBlocking = true;
+                blockingTool = 'TaskOutput';
               }
               // Bash tool call — may be running a long build/install with no stdout
               if (name === 'Bash') {
@@ -191,21 +228,35 @@ function checkTimeouts(config) {
                 const bashTimeout = input.timeout || 120000;
                 blockingTimeout = Math.max(heartbeatTimeout, bashTimeout + 60000);
                 isBlocking = true;
+                blockingTool = 'Bash';
               }
               // Agent (subagent) tool call — parent waits silently for child to complete
               if (name === 'Agent') {
                 blockingTimeout = Math.max(heartbeatTimeout, 1800000); // 30min for subagents
                 isBlocking = true;
+                blockingTool = 'Agent';
               }
               break; // only check the most recent tool_use
             } catch { /* JSON parse — line may not be valid JSON */ }
           }
           if (isBlocking) {
-            log('info', `Agent ${item.agent} (${item.id}) is in a blocking tool call — extended timeout to ${Math.round(blockingTimeout / 1000)}s (silent for ${silentSec}s)`);
+            // Only log on transition — avoid spamming every tick while blocking persists
+            if (!item._blockingToolCall) {
+              log('info', `Agent ${item.agent} (${item.id}) is in a blocking tool call (${blockingTool}) — extended timeout to ${Math.round(blockingTimeout / 1000)}s (silent for ${silentSec}s)`, { event: 'blocking_tool_call_detected' });
+            }
+            blockingAnnotations.set(item.id, {
+              tool: blockingTool,
+              silentMs,
+              remainingMs: Math.max(0, blockingTimeout - silentMs),
+            });
           }
         }
       } catch (e) { log('warn', 'blocking tool detection: ' + e.message); }
     }
+    // Agent recovered from blocking state — clear annotation
+    if (!isBlocking && item._blockingToolCall) {
+      blockingAnnotations.set(item.id, null);
+    }
 
     const effectiveTimeout = isBlocking ? blockingTimeout : heartbeatTimeout;
 
@@ -239,6 +290,23 @@ function checkTimeouts(config) {
     completeDispatch(item.id, DISPATCH_RESULT.ERROR, reason);
   }
 
+  // Batch-write blocking tool call annotations to dispatch entries.
+  // This surfaces blocking state via GET /api/status → dashboard badges.
+  if (blockingAnnotations.size > 0) {
+    const { mutateDispatch: mutateDispatchFn } = dispatch();
+    mutateDispatchFn((dp) => {
+      for (const activeItem of dp.active) {
+        if (!blockingAnnotations.has(activeItem.id)) continue;
+        const ann = blockingAnnotations.get(activeItem.id);
+        if (ann) {
+          activeItem._blockingToolCall = ann;
+        } else {
+          delete activeItem._blockingToolCall;
+        }
+      }
+    });
+  }
+
   // Agent status is now derived from dispatch.json at read time (getAgentStatus).
   // No reconcile sweep needed — dispatch IS the source of truth.
 

package/package.json

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