@yemi33/minions 0.1.24 → 0.1.26

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.1.26 (2026-03-28)
+
+### Engine
+- engine.js
+
+### Dashboard
+- dashboard.js
+- dashboard/js/detail-panel.js
+- dashboard/js/live-stream.js
+
+## 0.1.25 (2026-03-28)
+
+### Engine
+- engine.js
+- engine/lifecycle.js
+
+### Other
+- test/unit.test.js
+
 ## 0.1.24 (2026-03-28)
 
 ### Engine

package/dashboard/js/detail-panel.js

@@ -63,10 +63,19 @@ function renderDetailContent(detail, tab) {
 
     el.innerHTML = html;
   } else if (tab === 'live') {
-    el.innerHTML = '<div class="section" id="live-output" style="max-height:60vh;overflow-y:auto;font-size:11px;line-height:1.6">Loading live output...</div>' +
-      '<div style="margin-top:8px;display:flex;gap:8px;align-items:center">' +
-        '<span class="pulse"></span><span id="live-status-label" style="font-size:11px;color:var(--green)">Streaming live</span>' +
-        '<button class="pr-pager-btn" onclick="refreshLiveOutput()" style="font-size:10px">Refresh now</button>' +
+    el.innerHTML =
+      '<div id="live-chat" style="display:flex;flex-direction:column;height:60vh">' +
+        '<div id="live-messages" style="flex:1;overflow-y:auto;padding:8px;font-size:11px;line-height:1.6"></div>' +
+        '<div id="live-status-bar" style="padding:4px 8px;display:flex;align-items:center;gap:8px;border-top:1px solid var(--border)">' +
+          '<span class="pulse"></span><span id="live-status-label" style="font-size:11px;color:var(--green)">Streaming live</span>' +
+          '<button class="pr-pager-btn" onclick="refreshLiveOutput()" style="font-size:10px">Refresh</button>' +
+        '</div>' +
+        '<div id="live-steer-bar" style="display:flex;gap:8px;padding:8px;border-top:1px solid var(--border)">' +
+          '<input id="live-steer-input" type="text" placeholder="Steer this agent... (give additional context or redirect)" ' +
+            'style="flex:1;padding:6px 10px;background:var(--bg);border:1px solid var(--border);border-radius:var(--radius-sm);color:var(--text);font-size:12px;font-family:inherit" ' +
+            'onkeydown="if(event.key===\'Enter\')sendSteering()" />' +
+          '<button onclick="sendSteering()" style="padding:6px 12px;background:var(--blue);color:#fff;border:none;border-radius:var(--radius-sm);cursor:pointer;font-size:11px">Send</button>' +
+        '</div>' +
       '</div>';
     startLiveStream(currentAgentId);
   } else if (tab === 'charter') {

package/dashboard/js/live-stream.js

@@ -3,29 +3,100 @@
 let livePollingInterval = null;
 let liveEventSource = null;
 
+function renderLiveChatMessage(raw) {
+  const el = document.getElementById('live-messages');
+  if (!el) return;
+
+  const lines = raw.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    // Human steering messages
+    if (trimmed.startsWith('[human-steering]')) {
+      const msg = trimmed.replace('[human-steering] ', '');
+      el.innerHTML += '<div style="align-self:flex-end;background:var(--blue);color:#fff;padding:6px 12px;border-radius:12px 12px 2px 12px;max-width:80%;margin:4px 0;font-size:12px">' + escHtml(msg) + '</div>';
+      continue;
+    }
+
+    // Heartbeat lines
+    if (trimmed.startsWith('[heartbeat]')) {
+      continue;
+    }
+
+    // Try to parse as JSON (stream-json format)
+    if (trimmed.startsWith('{')) {
+      try {
+        const obj = JSON.parse(trimmed);
+
+        // Assistant text message
+        if (obj.type === 'assistant' && obj.message?.content) {
+          for (const block of obj.message.content) {
+            if (block.type === 'text' && block.text) {
+              el.innerHTML += '<div style="background:var(--surface2);padding:8px 12px;border-radius:12px 12px 12px 2px;max-width:90%;margin:4px 0;font-size:12px;white-space:pre-wrap;word-break:break-word">' + escHtml(block.text) + '</div>';
+            }
+            if (block.type === 'tool_use') {
+              el.innerHTML += '<div style="background:var(--surface);border:1px solid var(--border);padding:4px 8px;border-radius:4px;margin:2px 0;font-size:10px;color:var(--muted);cursor:pointer" onclick="this.nextElementSibling.style.display=this.nextElementSibling.style.display===\'none\'?\'block\':\'none\'">' +
+                '🔧 ' + escHtml(block.name || 'tool') + '</div>' +
+                '<div style="display:none;background:var(--bg);padding:4px 8px;border-radius:4px;margin:0 0 4px;font-size:10px;font-family:monospace;white-space:pre-wrap;max-height:200px;overflow-y:auto;color:var(--muted)">' + escHtml(JSON.stringify(block.input, null, 2).slice(0, 500)) + '</div>';
+            }
+          }
+        }
+
+        // Tool result
+        if (obj.type === 'tool_result' || (obj.type === 'user' && obj.message?.content?.[0]?.type === 'tool_result')) {
+          const content = obj.message?.content?.[0]?.content || obj.content || '';
+          const text = typeof content === 'string' ? content : JSON.stringify(content);
+          if (text.length > 10) {
+            el.innerHTML += '<div style="background:var(--bg);border-left:2px solid var(--border);padding:2px 8px;margin:0 0 2px 16px;font-size:9px;font-family:monospace;color:var(--muted);max-height:100px;overflow-y:auto;white-space:pre-wrap;cursor:pointer" onclick="this.style.maxHeight=this.style.maxHeight===\'100px\'?\'none\':\'100px\'">' + escHtml(text.slice(0, 1000)) + (text.length > 1000 ? '...' : '') + '</div>';
+          }
+        }
+
+        // Result (final)
+        if (obj.type === 'result') {
+          el.innerHTML += '<div style="background:rgba(63,185,80,0.1);border:1px solid var(--green);padding:8px 12px;border-radius:8px;margin:8px 0;font-size:12px;color:var(--green)">✓ Task complete</div>';
+        }
+
+        continue;
+      } catch {}
+    }
+
+    // Fallback: raw text (stderr, non-JSON lines)
+    if (trimmed.startsWith('[stderr]')) {
+      el.innerHTML += '<div style="font-size:9px;color:var(--red);font-family:monospace;padding:1px 4px">' + escHtml(trimmed) + '</div>';
+    } else {
+      el.innerHTML += '<div style="font-size:10px;color:var(--muted);font-family:monospace;padding:1px 4px">' + escHtml(trimmed) + '</div>';
+    }
+  }
+
+  // Auto-scroll
+  if (el.scrollHeight - el.scrollTop - el.clientHeight < 150) {
+    el.scrollTop = el.scrollHeight;
+  }
+}
+
 function startLiveStream(agentId) {
   stopLiveStream();
   if (!agentId) return;
 
-  const outputEl = document.getElementById('live-output');
-  if (outputEl) outputEl.textContent = '';
+  const msgEl = document.getElementById('live-messages');
+  if (msgEl) msgEl.innerHTML = '';
 
   liveEventSource = new EventSource('/api/agent/' + agentId + '/live-stream');
 
   liveEventSource.onmessage = function(e) {
     try {
       const chunk = JSON.parse(e.data);
-      const el = document.getElementById('live-output');
-      if (el) {
-        const wasAtBottom = el.scrollHeight - el.scrollTop - el.clientHeight < 100;
-        el.textContent += chunk;
-        if (wasAtBottom) el.scrollTop = el.scrollHeight;
-      }
+      renderLiveChatMessage(chunk);
     } catch {}
   };
 
   liveEventSource.addEventListener('done', function() {
     stopLiveStream();
+    const steerBar = document.getElementById('live-steer-bar');
+    if (steerBar) steerBar.style.display = 'none';
+    const statusLabel = document.getElementById('live-status-label');
+    if (statusLabel) { statusLabel.textContent = 'Completed'; statusLabel.style.color = 'var(--muted)'; }
   });
 
   liveEventSource.onerror = function() {
@@ -59,11 +130,30 @@ async function refreshLiveOutput() {
   if (!currentAgentId || currentTab !== 'live') { stopLivePolling(); return; }
   try {
     const text = await fetch('/api/agent/' + currentAgentId + '/live?tail=16384').then(r => r.text());
-    const el = document.getElementById('live-output');
+    const el = document.getElementById('live-messages');
     if (el) {
-      const wasAtBottom = el.scrollHeight - el.scrollTop - el.clientHeight < 50;
-      el.textContent = text;
+      const wasAtBottom = el.scrollHeight - el.scrollTop - el.clientHeight < 150;
+      el.innerHTML = '';
+      renderLiveChatMessage(text);
       if (wasAtBottom) el.scrollTop = el.scrollHeight;
     }
   } catch {}
 }
+
+async function sendSteering() {
+  const input = document.getElementById('live-steer-input');
+  if (!input || !input.value.trim() || !currentAgentId) return;
+  const message = input.value.trim();
+  input.value = '';
+
+  try {
+    const res = await fetch('/api/agents/steer', {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ agent: currentAgentId, message })
+    });
+    if (!res.ok) {
+      const d = await res.json().catch(() => ({}));
+      alert('Steering failed: ' + (d.error || 'unknown'));
+    }
+  } catch (e) { alert('Error: ' + e.message); }
+}

package/dashboard.js

@@ -2850,6 +2850,24 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'POST', path: '/api/prd/regenerate', desc: 'Regenerate PRD from revised source plan', params: 'file', handler: handlePrdRegenerate },
 
     // Agents
+    { method: 'POST', path: '/api/agents/steer', desc: 'Inject steering message into a running agent', params: 'agent, message', handler: async (req, res) => {
+      const body = await readBody(req);
+      const { agent: agentId, message } = body;
+      if (!agentId || !message) return jsonReply(res, 400, { error: 'agent and message required' });
+
+      const steerPath = path.join(MINIONS_DIR, 'agents', agentId, 'steer.md');
+      const agentDir = path.join(MINIONS_DIR, 'agents', agentId);
+      if (!fs.existsSync(agentDir)) return jsonReply(res, 404, { error: 'Agent not found' });
+
+      // Write steering file — engine picks it up on next tick
+      safeWrite(steerPath, message);
+
+      // Also append to live-output.log so it shows in the chat view
+      const liveLogPath = path.join(agentDir, 'live-output.log');
+      try { fs.appendFileSync(liveLogPath, '\n[human-steering] ' + message + '\n'); } catch {}
+
+      return jsonReply(res, 200, { ok: true, message: 'Steering message sent' });
+    }},
     { method: 'POST', path: '/api/agents/cancel', desc: 'Cancel an active agent by ID or task substring', params: 'agent?, task?', handler: handleAgentsCancel },
     { method: 'GET', path: /^\/api\/agent\/([\w-]+)\/live-stream(?:\?.*)?$/, desc: 'SSE real-time live output streaming', handler: handleAgentLiveStream },
     { method: 'GET', path: /^\/api\/agent\/([\w-]+)\/live(?:\?.*)?$/, desc: 'Tail live output for a working agent', params: 'tail? (bytes, default 8192)', handler: handleAgentLive },

package/engine/lifecycle.js

@@ -1011,7 +1011,8 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
   if (isSuccess && sessionId && agentId && !agentId.startsWith('temp-')) {
     try {
       shared.safeWrite(path.join(AGENTS_DIR, agentId, 'session.json'), {
-        sessionId, dispatchId: dispatchItem.id, savedAt: new Date().toISOString()
+        sessionId, dispatchId: dispatchItem.id, savedAt: new Date().toISOString(),
+        branch: dispatchItem.meta?.branch || null,
       });
     } catch {}
   }

package/engine.js

@@ -939,15 +939,18 @@ function spawnAgent(dispatchItem, config) {
     args.push('--allowedTools', claudeConfig.allowedTools);
   }
 
-  // Session resume: reuse last session if recent enough (< 2 hours)
+  // Session resume: reuse last session if same branch and recent enough (< 2 hours)
+  // Only resume when the context is relevant — same branch means the agent is
+  // continuing work on the same PR/feature (e.g., author fixing their own build failure)
   if (!agentId.startsWith('temp-')) {
     try {
       const sessionFile = safeJson(path.join(AGENTS_DIR, agentId, 'session.json'));
       if (sessionFile?.sessionId && sessionFile.savedAt) {
         const sessionAge = Date.now() - new Date(sessionFile.savedAt).getTime();
-        if (sessionAge < 2 * 60 * 60 * 1000) { // 2 hour TTL
+        const sameBranch = branchName && sessionFile.branch && sessionFile.branch === branchName;
+        if (sessionAge < 2 * 60 * 60 * 1000 && sameBranch) {
           args.push('--resume', sessionFile.sessionId);
-          log('info', `Resuming session ${sessionFile.sessionId} for ${agentId} (age: ${Math.round(sessionAge / 60000)}min)`);
+          log('info', `Resuming session ${sessionFile.sessionId} for ${agentId} on branch ${branchName} (age: ${Math.round(sessionAge / 60000)}min)`);
         }
       }
     } catch {}
@@ -999,6 +1002,24 @@ function spawnAgent(dispatchItem, config) {
     lastOutputAt = Date.now();
     if (stdout.length < MAX_OUTPUT) stdout += chunk.slice(0, MAX_OUTPUT - stdout.length);
     try { fs.appendFileSync(liveOutputPath, chunk); } catch {}
+
+    // Capture sessionId early for mid-session steering
+    const procInfo = activeProcesses.get(id);
+    if (procInfo && !procInfo.sessionId && chunk.includes('session_id')) {
+      try {
+        for (const line of chunk.split('\n')) {
+          if (!line.trim() || !line.startsWith('{')) continue;
+          const obj = JSON.parse(line);
+          if (obj.session_id) {
+            procInfo.sessionId = obj.session_id;
+            safeWrite(path.join(AGENTS_DIR, agentId, 'session.json'), {
+              sessionId: obj.session_id, dispatchId: id, savedAt: new Date().toISOString(), branch: branchName
+            });
+            break;
+          }
+        }
+      } catch {}
+    }
   });
 
   proc.stderr.on('data', (data) => {
@@ -1008,9 +1029,72 @@ function spawnAgent(dispatchItem, config) {
     try { fs.appendFileSync(liveOutputPath, '[stderr] ' + chunk); } catch {}
   });
 
-  proc.on('close', (code) => {
+  function onAgentClose(code) {
     if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
     log('info', `Agent ${agentId} (${id}) exited with code ${code}`);
+
+    // Check if this was a steering kill — re-spawn with resume
+    const procInfo = activeProcesses.get(id);
+    if (procInfo?._steeringMessage) {
+      const steerMsg = procInfo._steeringMessage;
+      const steerSessionId = procInfo._steeringSessionId;
+      delete procInfo._steeringMessage;
+      delete procInfo._steeringSessionId;
+
+      log('info', `Steering: re-spawning ${agentId} with --resume ${steerSessionId}`);
+
+      // Write new prompt with steering message
+      const steerPrompt = `HUMAN STEERING MESSAGE:\n\n${steerMsg}\n\nPlease acknowledge this update and adjust your approach accordingly. Continue working on your current task with this new context.`;
+      const steerPromptPath = path.join(ENGINE_DIR, 'tmp', `prompt-steer-${id}.md`);
+      safeWrite(steerPromptPath, steerPrompt);
+
+      // Build resume args
+      const resumeArgs = [
+        '--output-format', claudeConfig?.outputFormat || 'stream-json',
+        '--max-turns', String(engineConfig?.maxTurns || DEFAULTS.maxTurns),
+        '--verbose',
+        '--permission-mode', claudeConfig?.permissionMode || 'bypassPermissions',
+        '--resume', steerSessionId,
+      ];
+      if (claudeConfig?.allowedTools) resumeArgs.push('--allowedTools', claudeConfig.allowedTools);
+
+      const spawnScript = path.join(ENGINE_DIR, 'spawn-agent.js');
+      const childEnv = shared.cleanChildEnv();
+      const resumeProc = runFile(process.execPath, [spawnScript, steerPromptPath, steerPromptPath, ...resumeArgs], {
+        cwd,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: childEnv,
+      });
+
+      // Re-attach to existing tracking
+      activeProcesses.set(id, { proc: resumeProc, agentId, startedAt: procInfo.startedAt, sessionId: steerSessionId });
+
+      // Re-wire stdout/stderr handlers (same as original)
+      resumeProc.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        lastOutputAt = Date.now();
+        if (stdout.length < MAX_OUTPUT) stdout += chunk.slice(0, MAX_OUTPUT - stdout.length);
+        try { fs.appendFileSync(liveOutputPath, chunk); } catch {}
+      });
+      resumeProc.stderr.on('data', (data) => {
+        const chunk = data.toString();
+        lastOutputAt = Date.now();
+        if (stderr.length < MAX_OUTPUT) stderr += chunk.slice(0, MAX_OUTPUT - stderr.length);
+        try { fs.appendFileSync(liveOutputPath, '[stderr] ' + chunk); } catch {}
+      });
+
+      // Re-wire close handler for the resumed process
+      resumeProc.on('close', onAgentClose);
+      resumeProc.on('error', (err) => {
+        log('error', `Steering re-spawn failed for ${agentId}: ${err.message}`);
+        activeProcesses.delete(id);
+        completeDispatch(id, 'error', `Steering re-spawn error: ${err.message}`);
+      });
+
+      // Don't run completion hooks — agent is still working
+      return;
+    }
+
     activeProcesses.delete(id);
 
     // If timeout checker already finalized this dispatch, don't overwrite work-item status again.
@@ -1066,7 +1150,9 @@ function spawnAgent(dispatchItem, config) {
         log('info', `Temp agent ${agentId} cleaned up`);
       } catch {}
     }
-  });
+  }
+
+  proc.on('close', onAgentClose);
 
   proc.on('error', (err) => {
     if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
@@ -1429,6 +1515,34 @@ function checkIdleThreshold(config) {
   }
 }
 
+// ─── Steering Checker ────────────────────────────────────────────────────────
+
+function checkSteering(config) {
+  for (const [id, info] of activeProcesses) {
+    const steerPath = path.join(AGENTS_DIR, info.agentId, 'steer.md');
+    if (!fs.existsSync(steerPath)) continue;
+
+    const message = safeRead(steerPath);
+    try { fs.unlinkSync(steerPath); } catch {}
+    if (!message) continue;
+
+    const sessionId = info.sessionId;
+    if (!sessionId) {
+      log('warn', `Steering: no sessionId for ${info.agentId} — cannot resume. Message dropped.`);
+      continue;
+    }
+
+    log('info', `Steering: killing ${info.agentId} (${id}) for session resume with human message`);
+
+    // Kill current process
+    try { info.proc.kill('SIGTERM'); } catch {}
+
+    // Store steering context for re-spawn on close
+    info._steeringMessage = message;
+    info._steeringSessionId = sessionId;
+  }
+}
+
 // ─── Timeout Checker ────────────────────────────────────────────────────────
 
 function checkTimeouts(config) {
@@ -3257,8 +3371,9 @@ async function tickInner() {
   const config = getConfig();
   tickCount++;
 
-  // 1. Check for timed-out agents and idle threshold
+  // 1. Check for timed-out agents, steering messages, and idle threshold
   checkTimeouts(config);
+  checkSteering(config);
   checkIdleThreshold(config);
 
   // In stopping state, only track agent completions — skip discovery and dispatch

package/package.json

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