@yemi33/minions 0.1.1578 → 0.1.1580

package/CHANGELOG.md

@@ -1,10 +1,14 @@
 # Changelog
 
-## 0.1.1578 (2026-04-28)
+## 0.1.1580 (2026-04-28)
 
 ### Features
+-  stream doc chat progress
 - 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/modal-qa.js

@@ -191,9 +191,36 @@ function _qaBuildAssistantHtml(text, opts) {
   const pad = opts?.isError ? '' : 'padding-right:24px;';
   return '<div class="modal-qa-a" style="' + style + '">' +
     (opts?.isError ? '' : llmCopyBtn()) +
-    body +
-    '<div style="font-size:9px;color:var(--muted);margin-top:4px;text-align:right;' + pad + '">' + opts.elapsed + 's</div>' +
+     body +
+     '<div style="font-size:9px;color:var(--muted);margin-top:4px;text-align:right;' + pad + '">' + opts.elapsed + 's</div>' +
+     '</div>';
+}
+
+function _qaBuildLiveProgressHtml(loadingId, label, elapsedSeconds, streamedText, toolsUsed, queueCount) {
+  const qaQueueBadge = queueCount > 0 ? ' <span style="font-size:9px;color:var(--muted);background:var(--surface);padding:1px 5px;border-radius:8px;border:1px solid var(--border)">+' + queueCount + ' queued</span>' : '';
+  let html = '';
+  if (toolsUsed && toolsUsed.length > 0) {
+    html += '<div style="margin-bottom:6px">';
+    toolsUsed.forEach(function(t) {
+      const name = typeof t === 'string' ? t : t.name;
+      const 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>';
+  }
+  if (streamedText) html += '<div style="margin-bottom:6px">' + renderMd(streamedText) + '</div>';
+  html += '<div style="display:flex;flex-direction:column;align-items:flex-start;gap:6px">' +
+    '<div style="display:flex;align-items:center;gap:6px;flex-wrap:wrap">' +
+      '<span class="dot-pulse"><span></span><span></span><span></span></span> ' +
+      '<span id="' + loadingId + '-text">' + escHtml(label) + '</span>' +
+    '</div>' +
+    '<div style="display:flex;align-items:center;gap:6px;flex-wrap:wrap">' +
+      '<span id="' + loadingId + '-time" style="font-size:10px;color:var(--muted)">' + elapsedSeconds + 's</span>' +
+      '<button onclick="qaAbort()" style="font-size:9px;padding:2px 8px;background:var(--surface2);border:1px solid var(--border);border-radius:4px;color:var(--red);cursor:pointer">Stop</button>' +
+      qaQueueBadge +
+    '</div>' +
     '</div>';
+  return html;
 }
 
 function _qaMutateThreadHtml(key, mutate) {
@@ -401,23 +428,49 @@ async function _processQaMessage(message, selection, opts) {
   const qaPhases = isPlanEdit
     ? [[0,'Reading plan...'],[3000,'Analyzing structure...'],[8000,'Researching context...'],[15000,'Drafting revisions...'],[30000,'Writing updated plan...'],[60000,'Still working (large document)...'],[120000,'Deep edit in progress...'],[300000,'Almost there...']]
     : [[0,'Thinking...'],[3000,'Reading document...'],[8000,'Analyzing...'],[20000,'Still working...'],[60000,'Taking a while...']];
-  const qaTimer = setInterval(() => {
-    const elapsed = Date.now() - qaStartTime;
-    const timeEl = _qaIsActiveSession(sessionKey) ? document.getElementById(loadingId + '-time') : null;
-    const textEl = _qaIsActiveSession(sessionKey) ? document.getElementById(loadingId + '-text') : null;
-    if (timeEl) timeEl.textContent = Math.floor(elapsed / 1000) + 's';
-    if (textEl) {
-      for (let i = qaPhases.length - 1; i >= 0; i--) {
-        if (elapsed >= qaPhases[i][0]) {
-          textEl.textContent = qaPhases[i][1];
-          break;
-        }
+  let streamedText = '';
+  let toolsUsed = [];
+  function _qaProgressLabel(elapsed) {
+    let label = qaPhases[0][1];
+    for (let i = qaPhases.length - 1; i >= 0; i--) {
+      if (elapsed >= qaPhases[i][0]) {
+        label = qaPhases[i][1];
+        break;
       }
     }
+    return label;
+  }
+  function _qaRenderProgress(persist) {
+    const elapsed = Date.now() - qaStartTime;
+    const updatedThreadHtml = _qaMutateThreadHtml(sessionKey, tmp => {
+      const loadingEl = tmp.querySelector('#' + loadingId);
+      if (!loadingEl) return;
+      loadingEl.innerHTML = _qaBuildLiveProgressHtml(
+        loadingId,
+        _qaProgressLabel(elapsed),
+        Math.floor(elapsed / 1000),
+        streamedText,
+        toolsUsed,
+        runtime.queue.length
+      );
+    });
+    if (persist) {
+      _qaPersistSession(sessionKey, {
+        threadHtml: updatedThreadHtml,
+        docContext: capturedDocContext,
+        filePath: capturedFilePath,
+        history: runtime.history,
+        queue: runtime.queue,
+      });
+    }
+  }
+  const qaTimer = setInterval(() => {
+    _qaRenderProgress(false);
   }, 500);
+  _qaRenderProgress(false);
 
   try {
-    const res = await fetch('/api/doc-chat', {
+    const res = await fetch('/api/doc-chat/stream', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       signal: abortController.signal,
@@ -431,76 +484,118 @@ async function _processQaMessage(message, selection, opts) {
         contentHash: capturedDocContext.content ? capturedDocContext.content.length + ':' + capturedDocContext.content.charCodeAt(0) + ':' + capturedDocContext.content.charCodeAt(capturedDocContext.content.length - 1) : undefined,
       }),
     });
-    const data = await res.json();
-    clearInterval(qaTimer);
-    const qaElapsed = Math.round((Date.now() - qaStartTime) / 1000);
     let sessionDocContext = { ...capturedDocContext };
+    if (!res.ok) {
+      const errText = await res.text();
+      let errMsg = errText || 'Failed';
+      try {
+        const parsed = JSON.parse(errText);
+        errMsg = parsed.error || errMsg;
+      } catch { /* text/plain fallback */ }
+      throw new Error(errMsg);
+    }
 
-    if (data.ok) {
-      const borderColor = data.edited ? 'var(--green)' : 'var(--blue)';
-      const suffix = data.edited ? '\n\n\u2713 Document saved.' : '';
-      const answerHtml = _qaBuildAssistantHtml(data.answer + suffix, { borderColor, elapsed: qaElapsed });
-      const updatedThreadHtml = _qaMutateThreadHtml(sessionKey, tmp => {
-        const loadingEl = tmp.querySelector('#' + loadingId);
-        if (loadingEl) loadingEl.remove();
-        tmp.insertAdjacentHTML('beforeend', answerHtml);
-      });
-
-      runtime.history.push({ role: 'user', text: message });
-      runtime.history.push({ role: 'assistant', text: data.answer });
-      if (_qaIsActiveSession(sessionKey)) _qaHistory = runtime.history.slice();
-
-      _qaNotifySidebar(capturedFilePath);
-      if (data.actions && data.actions.length > 0) {
-        for (const action of data.actions) await ccExecuteAction(action);
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = '';
+    let terminalEventSeen = false;
+
+    async function _qaHandleStreamEvent(evt) {
+      if (!evt || !evt.type) return;
+      if (evt.type === 'heartbeat') return;
+      if (evt.type === 'chunk') {
+        streamedText = evt.text || '';
+        _qaRenderProgress(true);
+        return;
+      }
+      if (evt.type === 'tool') {
+        toolsUsed.push({ name: evt.name, input: evt.input || {} });
+        _qaRenderProgress(true);
+        return;
       }
+      if (evt.type === 'done') {
+        terminalEventSeen = true;
+        clearInterval(qaTimer);
+        const qaElapsed = Math.round((Date.now() - qaStartTime) / 1000);
+        const borderColor = evt.edited ? 'var(--green)' : 'var(--blue)';
+        const suffix = evt.edited ? '\n\n\u2713 Document saved.' : '';
+        const answerHtml = _qaBuildAssistantHtml((evt.text || '') + suffix, { borderColor, elapsed: qaElapsed });
+        const updatedThreadHtml = _qaMutateThreadHtml(sessionKey, tmp => {
+          const loadingEl = tmp.querySelector('#' + loadingId);
+          if (loadingEl) loadingEl.remove();
+          tmp.insertAdjacentHTML('beforeend', answerHtml);
+        });
+
+        runtime.history.push({ role: 'user', text: message });
+        runtime.history.push({ role: 'assistant', text: evt.text || '' });
+        if (_qaIsActiveSession(sessionKey)) _qaHistory = runtime.history.slice();
+
+        _qaNotifySidebar(capturedFilePath);
+        if (evt.actions && evt.actions.length > 0) {
+          for (const action of evt.actions) await ccExecuteAction(action);
+        }
 
-      if (data.edited && data.content) {
-        const display = data.content.replace(/^---[\s\S]*?---\n*/m, '');
-        const isJson = capturedFilePath && capturedFilePath.endsWith('.json');
-        sessionDocContext.content = display;
-        sessionDocContext.selection = '';
-        if (_qaIsActiveSession(sessionKey)) {
-          const body = document.getElementById('modal-body');
-          if (isJson) {
-            body.textContent = display;
-          } else {
-            body.innerHTML = renderMd(display);
-            body.style.fontFamily = "'Segoe UI', system-ui, sans-serif";
-            body.style.whiteSpace = 'normal';
+        if (evt.edited && evt.content) {
+          const display = evt.content.replace(/^---[\s\S]*?---\n*/m, '');
+          const isJson = capturedFilePath && capturedFilePath.endsWith('.json');
+          sessionDocContext.content = display;
+          sessionDocContext.selection = '';
+          if (_qaIsActiveSession(sessionKey)) {
+            const body = document.getElementById('modal-body');
+            if (isJson) {
+              body.textContent = display;
+            } else {
+              body.innerHTML = renderMd(display);
+              body.style.fontFamily = "'Segoe UI', system-ui, sans-serif";
+              body.style.whiteSpace = 'normal';
+            }
+            _modalDocContext.content = display;
           }
-          _modalDocContext.content = display;
         }
+
+        _qaPersistSession(sessionKey, {
+          threadHtml: updatedThreadHtml,
+          docContext: sessionDocContext,
+          filePath: capturedFilePath,
+          history: runtime.history,
+          queue: runtime.queue,
+        });
+        return;
       }
+      if (evt.type === 'error') throw new Error(evt.error || 'Failed');
+    }
 
-      _qaPersistSession(sessionKey, {
-        threadHtml: updatedThreadHtml,
-        docContext: sessionDocContext,
-        filePath: capturedFilePath,
-        history: runtime.history,
-        queue: runtime.queue,
-      });
-    } else {
-      const errorHtml = _qaBuildAssistantHtml('Error: ' + (data.error || 'Failed'), { color: 'var(--red)', isError: true, elapsed: qaElapsed });
-      const updatedThreadHtml = _qaMutateThreadHtml(sessionKey, tmp => {
-        const loadingEl = tmp.querySelector('#' + loadingId);
-        if (loadingEl) loadingEl.remove();
-        tmp.insertAdjacentHTML('beforeend', errorHtml);
-      });
-      _qaPersistSession(sessionKey, {
-        threadHtml: updatedThreadHtml,
-        docContext: sessionDocContext,
-        filePath: capturedFilePath,
-        history: runtime.history,
-        queue: runtime.queue,
-      });
+    while (true) {
+      const readResult = await reader.read();
+      if (readResult.done) break;
+      buf += decoder.decode(readResult.value, { stream: true });
+      const lines = buf.split('\n');
+      buf = lines.pop();
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.startsWith('data: ')) continue;
+        await _qaHandleStreamEvent(JSON.parse(line.slice(6)));
+      }
+    }
+    if (buf.trim()) {
+      const trailing = buf.split('\n');
+      for (let i = 0; i < trailing.length; i++) {
+        const line = trailing[i];
+        if (!line.startsWith('data: ')) continue;
+        await _qaHandleStreamEvent(JSON.parse(line.slice(6)));
+      }
     }
+    if (!terminalEventSeen) throw new Error('The response stream ended before completion.');
   } catch (e) {
     clearInterval(qaTimer);
     const qaElapsedExc = Math.round((Date.now() - qaStartTime) / 1000);
     const messageHtml = e.name === 'AbortError'
-      ? _qaBuildAssistantHtml('Stopped', { color: 'var(--muted)', isError: true, elapsed: qaElapsedExc })
-      : _qaBuildAssistantHtml('Error: ' + e.message, { color: 'var(--red)', isError: true, elapsed: qaElapsedExc });
+      ? (streamedText
+          ? _qaBuildAssistantHtml(streamedText + '\n\n_Stopped._', { borderColor: 'var(--muted)', elapsed: qaElapsedExc })
+          : _qaBuildAssistantHtml('Stopped', { color: 'var(--muted)', isError: true, elapsed: qaElapsedExc }))
+      : (streamedText
+          ? _qaBuildAssistantHtml(streamedText + '\n\nError: ' + e.message, { borderColor: 'var(--red)', elapsed: qaElapsedExc })
+          : _qaBuildAssistantHtml('Error: ' + e.message, { color: 'var(--red)', isError: true, elapsed: qaElapsedExc }));
     const updatedThreadHtml = _qaMutateThreadHtml(sessionKey, tmp => {
       const loadingEl = tmp.querySelector('#' + loadingId);
       if (loadingEl) loadingEl.remove();

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,
@@ -1215,12 +1291,111 @@ async function ccCall(message, { store = 'cc', sessionKey, extraContext, label =
   return result;
 }
 
+async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext, label = 'command-center', timeout = 900000, maxTurns, allowedTools = 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch', skipStatePreamble = false, model, onAbortReady, onChunk, onToolUse } = {}) {
+  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;
+  const existing = resolveSession(store, sessionKey);
+  let sessionId = existing ? existing.sessionId : null;
+
+  function buildPrompt({ includePreamble = true } = {}) {
+    const parts = (!skipStatePreamble && includePreamble) ? [`## Current Minions State (${new Date().toISOString().slice(0, 16)})\n\n${buildCCStatePreamble()}`] : [];
+    if (extraContext) parts.push(extraContext);
+    parts.push(message);
+    return parts.join('\n\n---\n\n');
+  }
+
+  let result;
+
+  if (sessionId && maxTurns > 1) {
+    const p1 = llm.callLLMStreaming(buildPrompt({ includePreamble: false }), '', {
+      timeout, label, model, maxTurns, allowedTools, sessionId, effort: ccEffort, direct: true,
+      onChunk,
+      onToolUse,
+    });
+    if (onAbortReady) onAbortReady(p1.abort);
+    result = await p1;
+    llm.trackEngineUsage(label, result.usage);
+
+    if (result.text) {
+      updateSession(store, sessionKey, result.sessionId || sessionId, true);
+      return result;
+    }
+
+    const sessionStillValid = llm.isResumeSessionStillValid(result);
+    if (sessionStillValid) {
+      console.log(`[${label}] Resume call failed (code=${result.code}, empty=${!result.text}) but session is still valid — preserving session for retry`);
+      updateSession(store, sessionKey, result.sessionId || sessionId, true);
+      return result;
+    }
+
+    console.log(`[${label}] Resume failed — session appears dead (code=${result.code}, empty=${!result.text}), retrying fresh...`);
+    sessionId = null;
+    if (store === 'cc') {
+      ccSession = { sessionId: null, createdAt: null, lastActiveAt: null, turnCount: 0 };
+      safeWrite(path.join(ENGINE_DIR, 'cc-session.json'), ccSession);
+    } else if (sessionKey) {
+      docSessions.delete(sessionKey);
+      schedulePersistDocSessions();
+    }
+  }
+
+  const freshPrompt = buildPrompt();
+  const p2 = llm.callLLMStreaming(freshPrompt, CC_STATIC_SYSTEM_PROMPT, {
+    timeout, label, model, maxTurns, allowedTools, effort: ccEffort, direct: true,
+    onChunk,
+    onToolUse,
+  });
+  if (onAbortReady) onAbortReady(p2.abort);
+  result = await p2;
+  llm.trackEngineUsage(label, result.usage);
+
+  if (result.text) {
+    updateSession(store, sessionKey, result.sessionId, false);
+    return result;
+  }
+
+  if (maxTurns <= 1) return result;
+  console.log(`[${label}] Fresh call also failed (code=${result.code}, empty=${!result.text}), retrying once more...`);
+  await new Promise(r => setTimeout(r, 2000));
+  const p3 = llm.callLLMStreaming(freshPrompt, CC_STATIC_SYSTEM_PROMPT, {
+    timeout, label, model, maxTurns, allowedTools, effort: ccEffort, direct: true,
+    onChunk,
+    onToolUse,
+  });
+  if (onAbortReady) onAbortReady(p3.abort);
+  result = await p3;
+  llm.trackEngineUsage(label, result.usage);
+
+  if (result.text) {
+    updateSession(store, sessionKey, result.sessionId, false);
+  }
+  return result;
+}
+
 // Lightweight content fingerprint — same algorithm used browser-side (no crypto needed)
 function contentFingerprint(str) {
   if (!str) return '';
   return str.length + ':' + str.charCodeAt(0) + ':' + str.charCodeAt(str.length - 1);
 }
 
+function _parseDocChatResultText(text) {
+  const delimIdx = text.indexOf('---DOCUMENT---');
+  if (delimIdx >= 0) {
+    const answerPart = text.slice(0, delimIdx).trim();
+    const { text: answer, actions } = parseCCActions(answerPart);
+    let content = text.slice(delimIdx + '---DOCUMENT---'.length).trim();
+    content = content.replace(/^```\w*\n?/, '').replace(/\n?```$/, '').trim();
+    return { answer, content, actions };
+  }
+  const { text: stripped, actions } = parseCCActions(text);
+  return { answer: stripped, content: null, actions };
+}
+
+function _docChatDisplayText(text) {
+  return _parseDocChatResultText(text).answer;
+}
+
 // Doc-specific wrapper — adds document context, parses ---DOCUMENT---
 async function ccDocCall({ message, document, title, filePath, selection, canEdit, isJson, model, freshSession, onAbortReady }) {
   const sessionKey = filePath || title;
@@ -1273,18 +1448,54 @@ async function ccDocCall({ message, document, title, filePath, selection, canEdi
     return { answer: 'Failed to process request. Try again.', content: null, actions: [] };
   }
 
-  // Parse ---DOCUMENT--- BEFORE actions — document content may contain ===ACTIONS=== literally
-  const delimIdx = result.text.indexOf('---DOCUMENT---');
-  if (delimIdx >= 0) {
-    const answerPart = result.text.slice(0, delimIdx).trim();
-    const { text: answer, actions } = parseCCActions(answerPart);
-    let content = result.text.slice(delimIdx + '---DOCUMENT---'.length).trim();
-    content = content.replace(/^```\w*\n?/, '').replace(/\n?```$/, '').trim();
-    return { answer, content, actions };
+  return _parseDocChatResultText(result.text);
+}
+
+async function ccDocCallStreaming({ message, document, title, filePath, selection, canEdit, isJson, model, freshSession, onAbortReady, onChunk, onToolUse }) {
+  const sessionKey = filePath || title;
+  const docSlice = document.slice(0, 20000);
+
+  if (freshSession && sessionKey) {
+    docSessions.delete(sessionKey);
   }
 
-  const { text: stripped, actions } = parseCCActions(result.text);
-  return { answer: stripped, content: null, actions };
+  const docHash = require('crypto').createHash('md5').update(docSlice).digest('hex').slice(0, 8);
+  const existing = freshSession ? null : resolveSession('doc', sessionKey);
+  const docUnchanged = existing?.sessionId && existing._docHash === docHash;
+
+  let docContext;
+  if (docUnchanged) {
+    docContext = `## Document: ${title || 'Document'}${filePath ? ' (`' + filePath + '`)' : ''}${selection ? '\n**Selected text:**\n> ' + selection.slice(0, 1500) : ''}${canEdit ? '\nIf editing: respond with your explanation, then \`---DOCUMENT---\` on its own line, then the COMPLETE updated file.' : ''}`;
+  } else {
+    docContext = `## Document Context\n**${title || 'Document'}**${filePath ? ' (`' + filePath + '`)' : ''}${isJson ? ' (JSON)' : ''}\n${selection ? '\n**Selected text:**\n> ' + selection.slice(0, 1500) + '\n' : ''}\n\`\`\`\n${docSlice}\n\`\`\`\n${canEdit ? '\nIf editing: respond with your explanation, then \`---DOCUMENT---\` on its own line, then the COMPLETE updated file.' : '\n(Read-only — answer questions only.)'}`;
+  }
+
+  const result = await ccCallStreaming(message, {
+    store: 'doc', sessionKey,
+    extraContext: docContext, label: 'doc-chat',
+    allowedTools: canEdit ? 'Read,Write,Edit,Glob,Grep' : 'Read,Glob,Grep',
+    maxTurns: canEdit ? 25 : 10,
+    skipStatePreamble: true,
+    ...(model ? { model } : {}),
+    onAbortReady,
+    onChunk: (text) => { if (onChunk) onChunk(_docChatDisplayText(text)); },
+    onToolUse,
+  });
+
+  if (freshSession && sessionKey) {
+    docSessions.delete(sessionKey);
+    schedulePersistDocSessions();
+  } else if (result.code === 0 && result.sessionId) {
+    const session = resolveSession('doc', sessionKey);
+    if (session) session._docHash = docHash;
+  }
+
+  if (result.code !== 0 || !result.text) {
+    console.error(`[doc-chat-stream] Failed: code=${result.code}, empty=${!result.text}, filePath=${filePath}, stderr=${(result.stderr || '').slice(0, 200)}`);
+    return { answer: 'Failed to process request. Try again.', content: null, actions: [] };
+  }
+
+  return _parseDocChatResultText(result.text);
 }
 
 // -- POST helpers --
@@ -3353,7 +3564,8 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       docChatInFlight.add(docKey);
       // Kill LLM process + release guard if client disconnects (abort/navigation)
       let _docAbort = null;
-      req.on('close', () => { docChatInFlight.delete(docKey); if (_docAbort) _docAbort(); });
+      let _docDone = false;
+      req.on('close', () => { if (!_docDone) { docChatInFlight.delete(docKey); if (_docAbort) _docAbort(); } });
 
       try {
       const canEdit = !!body.filePath;
@@ -3402,13 +3614,152 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
         safeWrite(fullPath, content);
 
+        _docDone = true;
         return jsonReply(res, 200, { ok: true, answer, edited: true, content, actions });
       }
+      _docDone = true;
       return jsonReply(res, 200, { ok: true, answer: answer + '\n\n(Read-only — changes not saved)', edited: false, actions });
-      } finally { _docAbort = null; docChatInFlight.delete(docKey); }
+      } finally { _docAbort = null; _docDone = true; docChatInFlight.delete(docKey); }
     } catch (e) { return jsonReply(res, e.statusCode || 500, { error: e.message }); }
   }
 
+  async function handleDocChatStream(req, res) {
+    let docKey = null;
+    let _docAbort = null;
+    let _docStreamEnded = false;
+    let _docHeartbeatTimer = null;
+    const writeDocEvent = (payload) => {
+      try {
+        res.write('data: ' + JSON.stringify(payload) + '\n\n');
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    const stopDocHeartbeat = () => {
+      if (_docHeartbeatTimer) {
+        clearInterval(_docHeartbeatTimer);
+        _docHeartbeatTimer = null;
+      }
+    };
+    try {
+      const body = await readBody(req);
+      if (!body.message) { res.statusCode = 400; res.setHeader('Content-Type', 'application/json'); res.end(JSON.stringify({ error: 'message required' })); return; }
+      if (!body.document) { res.statusCode = 400; res.setHeader('Content-Type', 'application/json'); res.end(JSON.stringify({ error: 'document required' })); return; }
+
+      docKey = body.filePath || body.title || 'default';
+      if (docChatInFlight.has(docKey)) {
+        res.statusCode = 429;
+        res.setHeader('Content-Type', 'application/json');
+        res.end(JSON.stringify({ error: 'This document is already being processed — wait for the current response.' }));
+        return;
+      }
+      docChatInFlight.add(docKey);
+
+      const canEdit = !!body.filePath;
+      const isJson = body.filePath?.endsWith('.json');
+      let currentContent = body.document;
+      let fullPath = null;
+      if (canEdit) {
+        try { shared.sanitizePath(body.filePath, MINIONS_DIR); }
+        catch { docChatInFlight.delete(docKey); res.statusCode = 400; res.setHeader('Content-Type', 'application/json'); res.end(JSON.stringify({ error: 'path must be under minions directory' })); return; }
+        fullPath = path.resolve(MINIONS_DIR, body.filePath);
+        const diskContent = safeRead(fullPath);
+        if (diskContent !== null) {
+          if (!(body.contentHash && contentFingerprint(diskContent) === body.contentHash)) {
+            currentContent = diskContent;
+          }
+        }
+      }
+
+      res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
+      writeDocEvent({ type: 'heartbeat' });
+      _docHeartbeatTimer = setInterval(() => {
+        if (_docStreamEnded) {
+          stopDocHeartbeat();
+          return;
+        }
+        if (!writeDocEvent({ type: 'heartbeat' })) stopDocHeartbeat();
+      }, CC_STREAM_HEARTBEAT_MS);
+
+      req.on('close', () => {
+        if (!_docStreamEnded) {
+          stopDocHeartbeat();
+          docChatInFlight.delete(docKey);
+          if (_docAbort) _docAbort();
+        }
+      });
+
+      try {
+
+        const { answer, content, actions } = await ccDocCallStreaming({
+          message: body.message, document: currentContent, title: body.title,
+          filePath: body.filePath, selection: body.selection, canEdit, isJson,
+          model: body.model || undefined,
+          freshSession: !!body.freshSession,
+          onAbortReady: (abort) => { _docAbort = abort; },
+          onChunk: (text) => { writeDocEvent({ type: 'chunk', text }); },
+          onToolUse: (name, input) => { writeDocEvent({ type: 'tool', name, input: _lightToolInput(input) }); },
+        });
+
+        if (!content) {
+          writeDocEvent({ type: 'done', text: answer, edited: false, actions });
+          _docStreamEnded = true;
+          res.end();
+          return;
+        }
+
+        if (isJson) {
+          try { JSON.parse(content); } catch (e) {
+            writeDocEvent({ type: 'done', text: answer + '\n\n(JSON invalid — not saved: ' + e.message + ')', edited: false, actions });
+            _docStreamEnded = true;
+            res.end();
+            return;
+          }
+        }
+
+        if (canEdit && fullPath) {
+          if (body.filePath && /^meetings\//.test(body.filePath) && isJson) {
+            try {
+              const mtg = safeJson(fullPath);
+              if (mtg && (mtg.status === 'completed' || mtg.status === 'archived')) {
+                writeDocEvent({ type: 'done', text: answer, edited: false, actions });
+                _docStreamEnded = true;
+                res.end();
+                return;
+              }
+            } catch { /* proceed with write if can't read */ }
+          }
+
+          safeWrite(fullPath, content);
+          writeDocEvent({ type: 'done', text: answer, edited: true, content, actions });
+          _docStreamEnded = true;
+          res.end();
+          return;
+        }
+
+        writeDocEvent({ type: 'done', text: answer + '\n\n(Read-only — changes not saved)', edited: false, actions });
+        _docStreamEnded = true;
+        res.end();
+      } finally {
+        stopDocHeartbeat();
+        docChatInFlight.delete(docKey);
+      }
+    } catch (e) {
+      stopDocHeartbeat();
+      if (docKey) docChatInFlight.delete(docKey);
+      if (!res.headersSent) {
+        res.statusCode = e.statusCode || 500;
+        res.setHeader('Content-Type', 'application/json');
+        try { res.end(JSON.stringify({ error: e.message })); } catch {}
+      } else {
+        writeDocEvent({ type: 'error', error: e.message });
+        _docStreamEnded = true;
+        try { res.end(); } catch {}
+      }
+    }
+  }
+
   async function handleInboxPersist(req, res) {
     try {
       const body = await readBody(req);
@@ -3900,10 +4251,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 +4409,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 +4464,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
@@ -4060,16 +4482,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 +4524,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 +4548,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 +4578,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 +4623,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 +4632,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);
@@ -5077,6 +5505,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
     // Doc chat
     { method: 'POST', path: '/api/doc-chat', desc: 'Minions-aware doc Q&A + editing via CC session', params: 'message, document, title?, filePath?, selection?, contentHash?', handler: handleDocChat },
+    { method: 'POST', path: '/api/doc-chat/stream', desc: 'Streaming doc chat — SSE with text chunks and tool progress', params: 'message, document, title?, filePath?, selection?, contentHash?', handler: handleDocChatStream },
 
     // Inbox
     { method: 'POST', path: '/api/inbox/persist', desc: 'Promote an inbox item to team notes', params: 'name', handler: handleInboxPersist },
@@ -5099,6 +5528,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.1580",
   "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"