@yemi33/minions 0.1.1578 → 0.1.1579

package/CHANGELOG.md

@@ -1,10 +1,13 @@
 # Changelog
 
-## 0.1.1578 (2026-04-28)
+## 0.1.1579 (2026-04-28)
 
 ### Features
 - hash-dedup, compress+normalize pass, dynamic stale-guard, rich result
 
+### Other
+- Keep CC streams reconnectable
+
 ## 0.1.1577 (2026-04-27)
 
 ### Fixes

package/dashboard/js/command-center.js

@@ -94,6 +94,13 @@ function _ccFindPinTarget(query) {
 function ccAbort() {
   var tab = _ccActiveTab();
   if (tab && tab._abortController) {
+    try {
+      fetch('/api/command-center/abort', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ tabId: tab.id })
+      }).catch(function() {});
+    } catch {}
     tab._abortController.abort();
     tab._abortController = null;
   }
@@ -211,6 +218,13 @@ function ccCloseTab(id) {
   var closingTab = _ccTabs.find(function(t) { return t.id === id; });
   if (closingTab && closingTab._sending) {
     if (!confirm('This tab has an active request. Close anyway?')) return;
+    try {
+      fetch('/api/command-center/abort', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ tabId: id })
+      }).catch(function() {});
+    } catch {}
     if (closingTab._abortController) { closingTab._abortController.abort(); closingTab._abortController = null; }
     closingTab._sending = false;
     closingTab._queue = [];
@@ -445,6 +459,8 @@ async function _ccDoSend(message, skipUserMsg, forceTabId) {
   if (existingQueueEl) existingQueueEl.remove();
 
   var ccStartTime = Date.now();
+  var reconnectAttempts = 0;
+  var streamStatusNote = '';
   var phases = [
     [0, 'Thinking...'],
     [3000, 'Reading minions context...'],
@@ -511,6 +527,9 @@ async function _ccDoSend(message, skipUserMsg, forceTabId) {
       if (streamedText) {
         html += renderMd(streamedText);
       }
+      if (streamStatusNote) {
+        html += '<div style="margin-top:6px;font-size:10px;color:var(--muted)">' + escHtml(streamStatusNote) + '</div>';
+      }
       html += '<div style="margin-top:' + (streamedText ? '6px' : '0') + '">' + _getThinkingHtml() + '</div>';
       streamDiv.innerHTML = html;
       // Re-append queue indicators so they stay below the streaming content
@@ -531,35 +550,70 @@ async function _ccDoSend(message, skipUserMsg, forceTabId) {
     var phaseTimer = setInterval(updateStreamDiv, 1000);
     updateStreamDiv(); // render proper layout immediately (not raw "Thinking..." text)
 
-  try {
-    // Stream response via SSE — shows text as it arrives
+  async function _ccConsumeStream(requestBody, isReconnect) {
     var res = await fetch('/api/command-center/stream', {
       method: 'POST', headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ message: message, tabId: activeTabId, sessionId: activeTab.sessionId || null }),
+      body: JSON.stringify(requestBody),
       signal: activeTab._abortController ? activeTab._abortController.signal : AbortSignal.timeout(960000)
     });
 
     if (!res.ok) {
-      // 429 = server still releasing previous request (abort race) — retry silently up to 3 times
-      if (res.status === 429 && (!activeTab._429retries || activeTab._429retries < 3)) {
+      if (!isReconnect && res.status === 429 && (!activeTab._429retries || activeTab._429retries < 3)) {
         activeTab._429retries = (activeTab._429retries || 0) + 1;
-        _cleanupStreamDiv(); // remove current thinking div — prevents stacking on each retry
         await new Promise(function(r) { setTimeout(r, 1500); });
-        return await _ccDoSend(message, true, forceTabId || activeTabId); // retry — pass tabId so timer closures don't fight
+        return await _ccConsumeStream({ message: message, tabId: activeTabId, sessionId: activeTab.sessionId || null }, false);
       }
       activeTab._429retries = 0;
-      _cleanupStreamDiv();
       var errText = await res.text();
-      addMsg('assistant', '<span style="color:var(--red)">' + escHtml(errText || 'CC error') + '</span>' +
-        (errText.includes('busy') ? ' <button onclick="ccNewTab()" style="margin-top:4px;padding:3px 10px;background:var(--surface2);border:1px solid var(--border);border-radius:4px;color:var(--blue);cursor:pointer;font-size:10px">Reset CC</button>' : ''));
-      return;
+      if (isReconnect && res.status === 409) return { interrupted: true, reconnectable: false, reason: errText || 'No live stream' };
+      throw new Error(errText || 'CC error');
     }
 
+    activeTab._429retries = 0;
+    streamStatusNote = '';
+    updateStreamDiv();
+
     var reader = res.body.getReader();
     var decoder = new TextDecoder();
     var buf = '';
     var terminalEventSeen = false;
 
+    async function _handleEvent(evt) {
+      if (evt.type === 'chunk') {
+        streamedText = evt.text;
+        if (activeTab) activeTab._streamedText = streamedText;
+        updateStreamDiv();
+      } else if (evt.type === 'heartbeat') {
+        return;
+      } else if (evt.type === 'tool') {
+        toolsUsed.push({ name: evt.name, input: evt.input || {} });
+        if (activeTab) activeTab._toolsUsed = toolsUsed.slice();
+        updateStreamDiv();
+        if (msgs.scrollHeight - msgs.scrollTop - msgs.clientHeight < 150) msgs.scrollTop = msgs.scrollHeight;
+      } else if (evt.type === 'done') {
+        terminalEventSeen = true;
+        _cleanupStreamDiv();
+        if (evt.sessionReset) {
+          addMsg('system', '<div style="text-align:center;padding:6px 12px;font-size:11px;color:var(--muted);background:var(--surface2);border-radius:6px;margin:4px 0">Minions was updated — started a fresh session with latest context.</div>', false, activeTabId);
+        }
+        var rendered = renderMd(evt.text || streamedText || '');
+        addMsg('assistant', rendered + _ccElapsedFooter('{seconds}s'));
+        if (evt.sessionId !== undefined) {
+          var originTab = _ccTabs.find(function(t) { return t.id === activeTabId; });
+          if (originTab) { originTab.sessionId = evt.sessionId || null; }
+          ccSaveState(); ccUpdateSessionIndicator();
+        }
+        if (evt.actions && evt.actions.length > 0) {
+          _tagServerExecuted(evt.actions, evt.actionResults);
+          for (var ai = 0; ai < evt.actions.length; ai++) { await ccExecuteAction(evt.actions[ai], activeTabId); }
+        }
+      } else if (evt.type === 'error') {
+        terminalEventSeen = true;
+        _cleanupStreamDiv();
+        addMsg('assistant', '<span style="color:var(--red)">' + escHtml(evt.error) + '</span>');
+      }
+    }
+
     while (true) {
       var readResult = await reader.read();
       if (readResult.done) break;
@@ -569,93 +623,55 @@ async function _ccDoSend(message, skipUserMsg, forceTabId) {
       for (var li = 0; li < lines.length; li++) {
         var line = lines[li];
         if (!line.startsWith('data: ')) continue;
-        try {
-          var evt = JSON.parse(line.slice(6));
-          if (evt.type === 'chunk') {
-            streamedText = evt.text;
-            if (activeTab) activeTab._streamedText = streamedText;
-            updateStreamDiv();
-          } else if (evt.type === 'heartbeat') {
-            continue;
-          } else if (evt.type === 'tool') {
-            toolsUsed.push({ name: evt.name, input: evt.input || {} });
-            if (activeTab) activeTab._toolsUsed = toolsUsed.slice();
-            updateStreamDiv();
-            if (msgs.scrollHeight - msgs.scrollTop - msgs.clientHeight < 150) msgs.scrollTop = msgs.scrollHeight;
-          } else if (evt.type === 'done') {
-            terminalEventSeen = true;
-            _cleanupStreamDiv();
-            // If system prompt changed, show a notice before the response
-            if (evt.sessionReset) {
-              addMsg('system', '<div style="text-align:center;padding:6px 12px;font-size:11px;color:var(--muted);background:var(--surface2);border-radius:6px;margin:4px 0">Minions was updated — started a fresh session with latest context.</div>', false, activeTabId);
-            }
-            // placeholder was added with skipSave=true — nothing to pop
-            var rendered = renderMd(evt.text || streamedText || '');
-            addMsg('assistant', rendered + _ccElapsedFooter('{seconds}s'));
-            if (evt.sessionId !== undefined) {
-              // Save session to the originating tab, not whichever tab is active now
-              var originTab = _ccTabs.find(function(t) { return t.id === activeTabId; });
-              if (originTab) { originTab.sessionId = evt.sessionId || null; }
-              ccSaveState(); ccUpdateSessionIndicator();
-            }
-            if (evt.actions && evt.actions.length > 0) {
-              _tagServerExecuted(evt.actions, evt.actionResults);
-              for (var ai = 0; ai < evt.actions.length; ai++) { await ccExecuteAction(evt.actions[ai], activeTabId); }
-            }
-          } else if (evt.type === 'error') {
-            terminalEventSeen = true;
-            _cleanupStreamDiv();
-            // placeholder was skipSave — no pop needed
-            addMsg('assistant', '<span style="color:var(--red)">' + escHtml(evt.error) + '</span>');
-          }
-        } catch { /* incomplete JSON */ }
+        try { await _handleEvent(JSON.parse(line.slice(6))); } catch {}
       }
     }
-    // Process any remaining buffered data after stream ends
     if (buf.trim()) {
       var remainingLines = buf.split('\n');
       for (var ri = 0; ri < remainingLines.length; ri++) {
         var rline = remainingLines[ri];
         if (!rline.startsWith('data: ')) continue;
-        try {
-          var revt = JSON.parse(rline.slice(6));
-          if (revt.type === 'done') {
-            terminalEventSeen = true;
-            _cleanupStreamDiv();
-            // placeholder was skipSave — no pop needed
-            var rendered2 = renderMd(revt.text || streamedText || '');
-            addMsg('assistant', rendered2 + _ccElapsedFooter('{seconds}s'));
-            if (revt.sessionId !== undefined) {
-              var originTab2 = _ccTabs.find(function(t) { return t.id === activeTabId; });
-              if (originTab2) { originTab2.sessionId = revt.sessionId || null; }
-              ccSaveState(); ccUpdateSessionIndicator();
-            }
-            if (revt.actions && revt.actions.length > 0) {
-              _tagServerExecuted(revt.actions, revt.actionResults);
-              for (var ai2 = 0; ai2 < revt.actions.length; ai2++) { await ccExecuteAction(revt.actions[ai2], activeTabId); }
-            }
-          } else if (revt.type === 'heartbeat') {
-            continue;
-          } else if (revt.type === 'error') {
-            terminalEventSeen = true;
-            _cleanupStreamDiv();
-            addMsg('assistant', '<span style="color:var(--red)">' + escHtml(revt.error) + '</span>');
-          } else if (revt.type === 'chunk') {
-            streamedText = revt.text;
-            updateStreamDiv();
-          }
-        } catch {}
+        try { await _handleEvent(JSON.parse(rline.slice(6))); } catch {}
       }
     }
-    // If stream ended without a 'done' event, finalize with whatever we have
-    if (!terminalEventSeen && (streamDiv.parentNode || document.getElementById('cc-restore-thinking') || document.querySelector('[data-stream-tab="' + activeTabId + '"]'))) {
-      _cleanupStreamDiv();
-      var streamEndedHint = '<div style="font-size:10px;color:var(--muted);margin-top:4px">The response stream ended before completion. Retry to continue from the last user message.</div>';
-      if (streamedText) {
-        addMsg('assistant', renderMd(streamedText) + _ccElapsedFooter('Stream interrupted after {seconds}s') + _ccRetryControls(streamEndedHint, false));
-      } else {
-        addMsg('assistant', '<span style="color:var(--red)">The response stream ended before completion.</span>' + _ccRetryControls(streamEndedHint, false));
+    return { interrupted: !terminalEventSeen, reconnectable: true };
+  }
+
+  try {
+    while (true) {
+      var consume = await _ccConsumeStream(
+        reconnectAttempts === 0
+          ? { message: message, tabId: activeTabId, sessionId: activeTab.sessionId || null }
+          : { tabId: activeTabId, sessionId: activeTab.sessionId || null, reconnect: true },
+        reconnectAttempts > 0
+      );
+      if (!consume.interrupted) break;
+      if (!consume.reconnectable || reconnectAttempts >= 2) {
+        _cleanupStreamDiv();
+        var streamEndedHint = '<div style="font-size:10px;color:var(--muted);margin-top:4px">The response stream ended before completion. Retry to continue from the last user message.</div>';
+        if (streamedText) {
+          addMsg('assistant', renderMd(streamedText) + _ccElapsedFooter('Stream interrupted after {seconds}s') + _ccRetryControls(streamEndedHint, false));
+        } else {
+          addMsg('assistant', '<span style="color:var(--red)">The response stream ended before completion.</span>' + _ccRetryControls(streamEndedHint, false));
+        }
+        break;
+      }
+      var reconnectHealth = await _ccDashboardHealth();
+      if (!reconnectHealth.reachable || reconnectHealth.restarted) {
+        _cleanupStreamDiv();
+        var reconnectHint = reconnectHealth.restarted
+          ? '<div style="font-size:10px;color:var(--muted);margin-top:4px">Dashboard restarted while this response was streaming. Reload the page to reconnect to the new instance.</div>'
+          : '<div style="font-size:10px;color:var(--muted);margin-top:4px">The request stream was interrupted, but the dashboard is still reachable. Retry or start a new session.</div>';
+        addMsg('assistant', (streamedText ? renderMd(streamedText) + _ccElapsedFooter('Stream interrupted after {seconds}s') : '') +
+          _ccRetryControls(reconnectHint, reconnectHealth.restarted));
+        break;
       }
+      reconnectAttempts++;
+      toolsUsed = [];
+      if (activeTab) activeTab._toolsUsed = [];
+      streamStatusNote = 'Connection interrupted — reattaching to the live response...';
+      updateStreamDiv();
+      await new Promise(function(r) { setTimeout(r, 1000 * reconnectAttempts); });
     }
   } catch (e) {
     _cleanupStreamDiv();

package/dashboard.js

@@ -544,10 +544,86 @@ const CC_SESSION_TTL_MS = shared.ENGINE_DEFAULTS.ccSessionTtlMs;
 let ccSession = { sessionId: null, createdAt: null, lastActiveAt: null, turnCount: 0 };
 const ccInFlightTabs = new Map(); // tabId → timestamp — per-tab in-flight tracking for parallel CC requests
 const ccInFlightAborts = new Map(); // tabId → abortFn — lets a new request kill the stale LLM
+const ccLiveStreams = new Map(); // tabId → buffered live stream state for reconnect-after-disconnect
 const CC_INFLIGHT_TIMEOUT_MS = 2 * 60 * 1000; // 2 minutes — auto-release if request hangs
 const CC_LOCK_WAIT_MS = 200; // grace period for previous handler's finally to release lock
 const CC_STREAM_HEARTBEAT_MS = 15000; // keep streaming responses alive across proxies/restart races
+const CC_STREAM_REATTACH_GRACE_MS = 60000; // keep CC job alive briefly after disconnect so the UI can reattach
+const CC_STREAM_DONE_RETENTION_MS = 30000; // retain final payload briefly so reconnect can still receive it
 function _releaseCCTab(tabId) { ccInFlightTabs.delete(tabId); ccInFlightAborts.delete(tabId); }
+function _getCcLiveStream(tabId) {
+  return ccLiveStreams.get(tabId) || null;
+}
+function _clearCcLiveTimers(tabId) {
+  const state = _getCcLiveStream(tabId);
+  if (!state) return;
+  if (state.abortTimer) {
+    clearTimeout(state.abortTimer);
+    state.abortTimer = null;
+  }
+  if (state.cleanupTimer) {
+    clearTimeout(state.cleanupTimer);
+    state.cleanupTimer = null;
+  }
+}
+function _clearCcLiveStream(tabId) {
+  const state = _getCcLiveStream(tabId);
+  if (!state) return;
+  _clearCcLiveTimers(tabId);
+  ccLiveStreams.delete(tabId);
+}
+function _ensureCcLiveStream(tabId) {
+  let state = _getCcLiveStream(tabId);
+  if (state) return state;
+  state = {
+    tabId,
+    text: '',
+    tools: [],
+    donePayload: null,
+    writer: null,
+    endResponse: null,
+    abortFn: null,
+    abortTimer: null,
+    cleanupTimer: null,
+  };
+  ccLiveStreams.set(tabId, state);
+  return state;
+}
+function _attachCcLiveStream(tabId, writer, endResponse) {
+  const state = _ensureCcLiveStream(tabId);
+  _clearCcLiveTimers(tabId);
+  state.writer = writer;
+  state.endResponse = endResponse;
+  return state;
+}
+function _detachCcLiveStream(tabId, writer) {
+  const state = _getCcLiveStream(tabId);
+  if (!state) return;
+  if (!writer || state.writer === writer) {
+    state.writer = null;
+    state.endResponse = null;
+  }
+}
+function _scheduleCcLiveAbort(tabId) {
+  const state = _getCcLiveStream(tabId);
+  if (!state || state.donePayload) return;
+  _clearCcLiveTimers(tabId);
+  state.abortTimer = setTimeout(() => {
+    const live = _getCcLiveStream(tabId);
+    if (!live || live.donePayload || live.writer) return;
+    try { if (live.abortFn) live.abortFn(); } catch {}
+  }, CC_STREAM_REATTACH_GRACE_MS);
+}
+function _scheduleCcLiveCleanup(tabId, delayMs = CC_STREAM_DONE_RETENTION_MS) {
+  const state = _getCcLiveStream(tabId);
+  if (!state) return;
+  if (state.cleanupTimer) clearTimeout(state.cleanupTimer);
+  state.cleanupTimer = setTimeout(() => {
+    const live = _getCcLiveStream(tabId);
+    if (!live || live.writer) return;
+    _clearCcLiveStream(tabId);
+  }, delayMs);
+}
 function _ccTabIsInFlight(tabId) {
   if (!ccInFlightTabs.has(tabId)) return false;
   // Auto-release stale locks — if a request has been in-flight longer than CC_INFLIGHT_TIMEOUT_MS,
@@ -3900,10 +3976,31 @@ What would you like to discuss or change? When you're happy, say "approve" and I
   async function handleCommandCenterNewSession(req, res) {
     ccSession = { sessionId: null, createdAt: null, lastActiveAt: null, turnCount: 0 };
     ccInFlightTabs.clear(); // Reset all in-flight guards
+    for (const [tabId, live] of ccLiveStreams.entries()) {
+      try { if (live.abortFn) live.abortFn(); } catch {}
+      _clearCcLiveStream(tabId);
+    }
     safeWrite(path.join(ENGINE_DIR, 'cc-session.json'), ccSession);
     return jsonReply(res, 200, { ok: true });
   }
 
+  async function handleCommandCenterAbort(req, res) {
+    try {
+      const body = await readBody(req);
+      const tabId = body.tabId || 'default';
+      const live = _getCcLiveStream(tabId);
+      if (live?.abortFn) {
+        try { live.abortFn(); } catch {}
+      } else {
+        const abort = ccInFlightAborts.get(tabId);
+        if (abort) { try { abort(); } catch {} }
+      }
+      _clearCcLiveStream(tabId);
+      _releaseCCTab(tabId);
+      return jsonReply(res, 200, { ok: true });
+    } catch (e) { return jsonReply(res, 400, { error: e.message }); }
+  }
+
   async function handleCCSessionsList(req, res) {
     const sessions = _readCcTabSessions();
     return jsonReply(res, 200, { sessions });
@@ -4037,8 +4134,51 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     };
     try {
       const body = await readBody(req);
-      if (!body.message) { res.statusCode = 400; res.end('message required'); return; }
+      if (!body.message && !body.reconnect) { res.statusCode = 400; res.end('message required'); return; }
       tabId = body.tabId || 'default';
+      if (body.reconnect) {
+        const live = _getCcLiveStream(tabId);
+        if (!live) { res.statusCode = 409; res.end('No live command-center response to reconnect'); return; }
+        res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
+        writeCcEvent({ type: 'heartbeat' });
+        _ccHeartbeatTimer = setInterval(() => {
+          if (_ccStreamEnded) {
+            stopCcHeartbeat();
+            return;
+          }
+          if (!writeCcEvent({ type: 'heartbeat' })) stopCcHeartbeat();
+        }, CC_STREAM_HEARTBEAT_MS);
+        let reconnectDone;
+        const reconnectDonePromise = new Promise(resolve => { reconnectDone = resolve; });
+        _attachCcLiveStream(tabId, writeCcEvent, () => {
+          if (_ccStreamEnded) return;
+          _ccStreamEnded = true;
+          stopCcHeartbeat();
+          try { res.end(); } catch {}
+          reconnectDone();
+        });
+        req.on('close', () => {
+          if (_ccStreamEnded) return;
+          stopCcHeartbeat();
+          _detachCcLiveStream(tabId, writeCcEvent);
+          _scheduleCcLiveAbort(tabId);
+          reconnectDone();
+        });
+        for (const tool of live.tools || []) {
+          writeCcEvent({ type: 'tool', name: tool.name, input: _lightToolInput(tool.input) });
+        }
+        if (live.text) writeCcEvent({ type: 'chunk', text: live.text });
+        if (live.donePayload) {
+          writeCcEvent(live.donePayload);
+          _ccStreamEnded = true;
+          stopCcHeartbeat();
+          try { res.end(); } catch {}
+          _scheduleCcLiveCleanup(tabId);
+          return;
+        }
+        await reconnectDonePromise;
+        return;
+      }
       if (_ccTabIsInFlight(tabId)) {
         // Previous request still in-flight — abort its LLM (handles keep-alive abort where close event didn't fire)
         const prevAbort = ccInFlightAborts.get(tabId);
@@ -4049,6 +4189,13 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         }
       }
       ccInFlightTabs.set(tabId, Date.now());
+      _clearCcLiveStream(tabId);
+      const liveState = _attachCcLiveStream(tabId, writeCcEvent, () => {
+        if (_ccStreamEnded) return;
+        _ccStreamEnded = true;
+        stopCcHeartbeat();
+        try { res.end(); } catch {}
+      });
 
       res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
       writeCcEvent({ type: 'heartbeat' }); // flush headers quickly and keep intermediaries from idling out
@@ -4059,17 +4206,12 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         }
         if (!writeCcEvent({ type: 'heartbeat' })) stopCcHeartbeat();
       }, CC_STREAM_HEARTBEAT_MS);
-      // Kill LLM process immediately if client disconnects mid-stream.
-      // Guard with !_ccStreamEnded: when the stream ends normally, finally already released the lock;
-      // without the guard, this close event (which fires after res.end) could wipe a new request's lock.
+      // Keep the LLM alive briefly after disconnect so the UI can reattach to the same in-flight turn.
       req.on('close', () => {
         if (!_ccStreamEnded) {
           stopCcHeartbeat();
-          _releaseCCTab(tabId);
-          if (_ccStreamAbort) {
-            console.log(`[CC-stream] Client disconnected for tab ${tabId} — aborting LLM`);
-            _ccStreamAbort();
-          }
+          _detachCcLiveStream(tabId, writeCcEvent);
+          _scheduleCcLiveAbort(tabId);
         }
       });
 
@@ -4106,14 +4248,17 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           onChunk: (text) => {
             const actIdx = findCCActionsDelimiter(text);
             const display = actIdx >= 0 ? text.slice(0, actIdx).trim() : text;
-            writeCcEvent({ type: 'chunk', text: display });
+            liveState.text = display;
+            if (liveState.writer) liveState.writer({ type: 'chunk', text: display });
           },
           onToolUse: (name, input) => {
             toolUses.push({ name, input: input || {} });
-            writeCcEvent({ type: 'tool', name, input: _lightToolInput(input) });
+            liveState.tools.push({ name, input: input || {} });
+            if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(input) });
           }
         });
         _ccStreamAbort = llmPromise.abort;
+        liveState.abortFn = _ccStreamAbort;
         ccInFlightAborts.set(tabId, _ccStreamAbort);
         const result = await llmPromise;
         trackUsage('command-center', result.usage);
@@ -4127,21 +4272,24 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           toolUses = []; // discard stale metadata from the failed resume attempt
           const retryPromise = callLLMStreaming(freshPrompt, CC_STATIC_SYSTEM_PROMPT, {
             timeout: 900000, label: 'command-center', model: streamModel, maxTurns: ccMaxTurns,
-            allowedTools: 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch',
-            effort: streamEffort, direct: true,
-            onChunk: (text) => {
-              const actIdx = findCCActionsDelimiter(text);
-              const display = actIdx >= 0 ? text.slice(0, actIdx).trim() : text;
-              writeCcEvent({ type: 'chunk', text: display });
-            },
-            onToolUse: (name, input) => {
-              toolUses.push({ name, input: input || {} });
-              writeCcEvent({ type: 'tool', name, input: _lightToolInput(input) });
-            }
-          });
-          _ccStreamAbort = retryPromise.abort;
-          ccInFlightAborts.set(tabId, _ccStreamAbort);
-          const retryResult = await retryPromise;
+              allowedTools: 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch',
+              effort: streamEffort, direct: true,
+              onChunk: (text) => {
+                const actIdx = findCCActionsDelimiter(text);
+                const display = actIdx >= 0 ? text.slice(0, actIdx).trim() : text;
+                liveState.text = display;
+                if (liveState.writer) liveState.writer({ type: 'chunk', text: display });
+              },
+              onToolUse: (name, input) => {
+                toolUses.push({ name, input: input || {} });
+                liveState.tools.push({ name, input: input || {} });
+                if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(input) });
+              }
+            });
+            _ccStreamAbort = retryPromise.abort;
+            liveState.abortFn = _ccStreamAbort;
+            ccInFlightAborts.set(tabId, _ccStreamAbort);
+            const retryResult = await retryPromise;
           trackUsage('command-center', retryResult.usage);
           if (retryResult.text) {
             // Fresh session succeeded — use retryResult from here
@@ -4154,8 +4302,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           const stderrTail = (result.stderr || '').trim().split('\n').filter(Boolean).slice(-3).join(' | ');
           console.error(`[CC-stream] Failed: code=${result.code}, stderr=${(result.stderr || '').slice(0, 500)}, stdout_tail=${(result.raw || '').slice(-500)}`);
           const retryHint = 'Send your message again to retry.';
-          writeCcEvent({ type: 'done', text: `I had trouble processing that ${debugInfo}. ${stderrTail ? 'Detail: ' + stderrTail : ''}\n\n${retryHint}`, actions: [], sessionId: null });
-          _ccStreamEnded = true; res.end();
+          liveState.donePayload = { type: 'done', text: `I had trouble processing that ${debugInfo}. ${stderrTail ? 'Detail: ' + stderrTail : ''}\n\n${retryHint}`, actions: [], sessionId: null };
+          if (liveState.writer) liveState.writer(liveState.donePayload);
+          if (liveState.endResponse) liveState.endResponse();
+          _scheduleCcLiveCleanup(tabId);
           return;
         }
 
@@ -4197,7 +4347,8 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         }
         const donePayload = { type: 'done', text: displayText, actions, actionResults, sessionId: responseSessionId, newSession: !wasResume };
         if (sessionReset) donePayload.sessionReset = true;
-        writeCcEvent(donePayload);
+        liveState.donePayload = donePayload;
+        if (liveState.writer) liveState.writer(donePayload);
 
         // Mirror CC response to Teams (non-blocking, skip Teams-originated)
         const _streamTabId = body.tabId || 'default';
@@ -4205,7 +4356,8 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           teams.teamsPostCCResponse(body.message, result.text).catch(() => {});
         }
 
-        _ccStreamEnded = true; res.end();
+        if (liveState.endResponse) liveState.endResponse();
+        _scheduleCcLiveCleanup(tabId);
       } finally {
         stopCcHeartbeat();
         _releaseCCTab(tabId);
@@ -5099,6 +5251,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
     // Command Center
     { method: 'POST', path: '/api/command-center/new-session', desc: 'Clear active CC session', handler: handleCommandCenterNewSession },
+    { method: 'POST', path: '/api/command-center/abort', desc: 'Abort an in-flight CC request for a tab', params: 'tabId?', handler: handleCommandCenterAbort },
     { method: 'POST', path: '/api/command-center', desc: 'Conversational command center with full minions context', params: 'message, sessionId?', handler: handleCommandCenter },
     { method: 'POST', path: '/api/command-center/stream', desc: 'Streaming CC — SSE with text chunks as they arrive', params: 'message, tabId?', handler: handleCommandCenterStream },
     { method: 'GET', path: '/api/cc-sessions', desc: 'List CC session metadata for all tabs', handler: handleCCSessionsList },

package/package.json

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