@yemi33/minions 0.1.2189 → 0.1.2191

package/dashboard/js/command-center.js

@@ -549,12 +549,12 @@ function ccSwitchTab(id) {
     var phases = [[0,'Thinking...'],[3000,'Reading minions context...'],[8000,'Analyzing...'],[15000,'Using tools to dig deeper...'],[30000,'Still working (multi-turn)...'],[60000,'Deep research in progress...']];
     function _restoreStreamHtml() {
       var html = '';
-      var tools = tab._toolsUsed || [];
-      if (tools.length > 0) {
-        html += '<div style="margin-bottom:6px">' + tools.map(renderToolChip).join('') + '</div>';
-      }
-      var text = tab._streamedText || '';
-      if (text) html += renderMd(text);
+      // Restore the same interleaved text↔tool layout the live stream renders,
+      // so chips and partial text keep their chronological order (and chip
+      // status styling) after a tab switch / reload. renderToolChip is reached
+      // via ccSegmentsRender.
+      var text = ccSegmentsText(tab._segments || []);
+      html += ccSegmentsRender(tab._segments || [], { keyPrefix: tab.id });
       var ms = Date.now() - restoreStart;
       var label = 'Thinking...';
       for (var pi = phases.length - 1; pi >= 0; pi--) { if (ms >= phases[pi][0]) { label = phases[pi][1]; break; } }
@@ -633,7 +633,7 @@ function ccRenderTabBar() {
     var isActive = t.id === _ccActiveTabId;
     // draggable="true" + DnD handlers enable click-and-drag reorder of tabs.
     // The handlers below splice _ccTabs in place (preserving per-tab in-flight
-    // state: _sending, _queue, _abortController, _streamedText, _toolsUsed)
+    // state: _sending, _queue, _abortController, _segments)
     // and persist via ccSaveState. The close X / new-tab + opt out of drag
     // with draggable="false" + ondragstart preventDefault so the affordances
     // don't accidentally start a drag.
@@ -709,7 +709,7 @@ function ccTabDrop(ev, targetId) {
   var toIdx = _ccTabs.findIndex(function(t) { return t.id === targetId; });
   if (fromIdx === -1 || toIdx === -1) return;
   // Splice the existing tab reference so per-tab in-flight state survives
-  // (_sending, _queue, _abortController, _streamedText, _toolsUsed,
+  // (_sending, _queue, _abortController, _segments,
   // _retryRequests, _sendStartedAt, etc.). Do NOT clone/replace the object.
   var moved = _ccTabs.splice(fromIdx, 1)[0];
   _ccTabs.splice(toIdx, 0, moved);
@@ -979,9 +979,12 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
 
   // Streaming state — declared before try so updateStreamDiv works during fetch
   // Also saved on tab for restore when switching back
-  var streamedText = '';
-  var toolsUsed = [];
-  if (activeTab) { activeTab._streamedText = ''; activeTab._toolsUsed = []; }
+  // Ordered text↔tool segments for this turn (replaces the old flat
+  // streamedText + toolsUsed buckets). Rendered in arrival order so prose and
+  // tool activity stay interleaved instead of welded into one blob. See
+  // render-utils.js ccSegments* helpers.
+  var segments = [];
+  if (activeTab) activeTab._segments = segments;
 
   // Get active tab's sessionId to send with request
   var tabSessionId = activeTab ? activeTab.sessionId : null;
@@ -1020,16 +1023,15 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
         if (re) { streamDiv = re; re.removeAttribute('id'); } else return;
       }
       var html = '';
-      if (toolsUsed.length > 0) {
-        html += '<div style="margin-bottom:6px">' + toolsUsed.map(renderToolChip).join('') + '</div>';
-      }
-      if (streamedText) {
-        html += renderMd(streamedText);
-      }
+      // ccSegmentsRender interleaves tool chips and text blocks in arrival order
+      // (delegates each chip to renderToolChip). keyPrefix=tab id keeps any
+      // expanded tool group open across the per-frame re-render.
+      var bodyHtml = ccSegmentsRender(segments, { keyPrefix: activeTabId });
+      if (bodyHtml) html += bodyHtml;
       if (streamStatusNote) {
         html += '<div style="margin-top:6px;font-size:var(--text-sm);color:var(--muted)">' + escHtml(streamStatusNote) + '</div>';
       }
-      html += '<div style="margin-top:' + (streamedText ? '6px' : '0') + '">' + _getThinkingHtml() + '</div>';
+      html += '<div style="margin-top:' + (bodyHtml ? '6px' : '0') + '">' + _getThinkingHtml() + '</div>';
       // eslint-disable-next-line no-unsanitized/property -- reason: renderMd() and renderToolChip() escape streamed text/tool fields before assembling live stream HTML
       streamDiv.innerHTML = html;
       // Re-append queue indicators so they stay below the streaming content
@@ -1098,24 +1100,22 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
 
     async function _handleEvent(evt) {
       if (evt.type === 'chunk') {
-        streamedText = _ccMergeStreamText(streamedText, evt.text || '');
-        if (activeTab) activeTab._streamedText = streamedText;
+        // evt.segmentId (from engine/llm.js) marks distinct assistant text
+        // blocks; ccSegmentsApplyChunk falls back to a heuristic when it's
+        // absent (Copilot pool path / live replay).
+        ccSegmentsApplyChunk(segments, evt.text || '', evt.segmentId);
+        if (activeTab) activeTab._segments = segments;
         updateStreamDiv();
       } else if (evt.type === 'heartbeat') {
         return;
       } else if (evt.type === 'tool') {
-        toolsUsed.push({ name: evt.name, input: evt.input || {}, id: evt.id || null, status: evt.id ? 'pending' : null });
-        if (activeTab) activeTab._toolsUsed = toolsUsed.slice();
+        ccSegmentsApplyTool(segments, { name: evt.name, input: evt.input || {}, id: evt.id || null });
+        if (activeTab) activeTab._segments = segments;
         updateStreamDiv();
         if (msgs.scrollHeight - msgs.scrollTop - msgs.clientHeight < 150) msgs.scrollTop = msgs.scrollHeight;
       } else if (evt.type === 'tool-update') {
-        for (var ti = 0; ti < toolsUsed.length; ti++) {
-          if (toolsUsed[ti] && toolsUsed[ti].id === evt.id) {
-            toolsUsed[ti].status = evt.status;
-            break;
-          }
-        }
-        if (activeTab) activeTab._toolsUsed = toolsUsed.slice();
+        ccSegmentsApplyToolUpdate(segments, evt.id, evt.status);
+        if (activeTab) activeTab._segments = segments;
         updateStreamDiv();
       } else if (evt.type === 'done') {
         terminalEventSeen = true;
@@ -1131,10 +1131,13 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
           }
           addMsg('system', '<div style="text-align:center;padding:6px 12px;font-size:var(--text-base);color:var(--muted);background:var(--surface2);border-radius:6px;margin:4px 0">' + resetText + '</div>', false, activeTabId);
         }
-        var finalText = _ccMergeStreamText(streamedText, evt.text || '');
+        // Reconcile streamed segments with the authoritative terminal text
+        // (Claude's `result` — the last assistant message), preserving earlier
+        // interleaved text/tool segments, then render the whole turn in order.
+        ccSegmentsFinalize(segments, evt.text || '');
         if (evt.actions && evt.actions.length > 0) _tagServerExecuted(evt.actions, evt.actionResults);
-        var rendered = renderMd(finalText || streamedText || '');
         var assistantMessageId = _ccNewMessageId('cc-turn');
+        var rendered = ccSegmentsRender(segments, { keyPrefix: assistantMessageId });
         addMsg('assistant', rendered + _ccElapsedFooter('{seconds}s'), false, { messageId: assistantMessageId });
         // Surface each server-executed action as a standalone chip OUTSIDE the
         // assistant bubble — matches the pattern used by ccExecuteAction for
@@ -1267,8 +1270,9 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
         _cleanupStreamDiv();
         var streamEndedHint = '<div style="font-size:var(--text-sm);color:var(--muted);margin-top:4px">The response stream ended before completion. Retry to resend the interrupted message.</div>';
         var streamEndedRetry = _ccStoreRetryRequest(activeTab, activeTabId, message);
-        if (streamedText) {
-          addMsg('assistant', renderMd(streamedText) + _ccElapsedFooter('Stream interrupted after {seconds}s') + _ccRetryControls(streamEndedRetry, streamEndedHint, false), false, { retryId: streamEndedRetry.id });
+        var streamEndedPartial = ccSegmentsRender(segments, { keyPrefix: activeTabId });
+        if (streamEndedPartial) {
+          addMsg('assistant', streamEndedPartial + _ccElapsedFooter('Stream interrupted after {seconds}s') + _ccRetryControls(streamEndedRetry, streamEndedHint, false), false, { retryId: streamEndedRetry.id });
         } else {
           addMsg('assistant', '<span style="color:var(--red)">The response stream ended before completion.</span>' + _ccRetryControls(streamEndedRetry, streamEndedHint, false), false, { retryId: streamEndedRetry.id });
         }
@@ -1281,14 +1285,14 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
           ? '<div style="font-size:var(--text-sm);color:var(--muted);margin-top:4px">Dashboard restarted while this response was streaming. Restart Minions to reconnect to the new instance.</div>'
           : '<div style="font-size:var(--text-sm);color:var(--muted);margin-top:4px">The request stream was interrupted, but the dashboard is still reachable. Retry or start a new session.</div>';
         var reconnectRetry = _ccStoreRetryRequest(activeTab, activeTabId, message);
-        addMsg('assistant', (streamedText ? renderMd(streamedText) + _ccElapsedFooter('Stream interrupted after {seconds}s') : '') +
+        var reconnectPartial = ccSegmentsRender(segments, { keyPrefix: activeTabId });
+        addMsg('assistant', (reconnectPartial ? reconnectPartial + _ccElapsedFooter('Stream interrupted after {seconds}s') : '') +
           _ccRetryControls(reconnectRetry, reconnectHint, reconnectHealth.restarted), false, { retryId: reconnectRetry.id });
         break;
       }
       reconnectAttempts++;
-      streamedText = '';
-      toolsUsed = [];
-      if (activeTab) { activeTab._streamedText = ''; activeTab._toolsUsed = []; }
+      segments = [];
+      if (activeTab) activeTab._segments = segments;
       streamStatusNote = 'Connection interrupted — reattaching to the live response...';
       updateStreamDiv();
       await new Promise(function(r) { setTimeout(r, 1000 * reconnectAttempts); });
@@ -1297,8 +1301,9 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
     _cleanupStreamDiv();
     if (activeTab && activeTab._userAborted) {
       _wasAborted = true;
-      if (streamedText) {
-        addMsg('assistant', renderMd(streamedText) + _ccElapsedFooter('Stopped after {seconds}s'));
+      var abortedPartial = ccSegmentsRender(segments, { keyPrefix: activeTabId });
+      if (abortedPartial) {
+        addMsg('assistant', abortedPartial + _ccElapsedFooter('Stopped after {seconds}s'));
       } else {
         addMsg('assistant', '<span style="color:var(--red);font-size:var(--text-base)">Stopped</span>');
       }
@@ -1332,12 +1337,13 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
       } else {
         errorRendered = '<span style="color:var(--red)">Error: ' + escHtml(e.message) + '</span>';
       }
-      addMsg('assistant', (streamedText ? renderMd(streamedText) + _ccElapsedFooter('Stream interrupted after {seconds}s') : '') +
+      var errorPartial = ccSegmentsRender(segments, { keyPrefix: activeTabId });
+      addMsg('assistant', (errorPartial ? errorPartial + _ccElapsedFooter('Stream interrupted after {seconds}s') : '') +
         errorRendered +
         _ccRetryControls(errorRetry, connectionHint, isNetworkError && (!dashboardHealth.reachable || dashboardHealth.restarted)), false, { retryId: errorRetry.id });
     }
   } finally {
-    if (activeTab) { activeTab._sending = false; activeTab._abortController = null; activeTab._429retries = 0; delete activeTab._streamedText; delete activeTab._toolsUsed; delete activeTab._sendStartedAt; delete activeTab._userAborted; }
+    if (activeTab) { activeTab._sending = false; activeTab._abortController = null; activeTab._429retries = 0; delete activeTab._segments; delete activeTab._sendStartedAt; delete activeTab._userAborted; }
     _ccSending = (_ccTabs.some(function(t) { return t._sending; }));
     // Mark tab unread if response completed on a background tab or while drawer is closed
     if (activeTab && !_wasAborted && (activeTab.id !== _ccActiveTabId || !_ccOpen)) activeTab._unread = true;

package/dashboard/js/modal-qa.js

@@ -378,23 +378,16 @@ function _qaBuildActionFeedbackHtml(actionFeedback) {
   }).join('');
 }
 
-function _qaBuildLiveProgressHtml(loadingId, label, elapsedSeconds, streamedText, toolsUsed, queueCount) {
+function _qaBuildLiveProgressHtml(loadingId, label, elapsedSeconds, segments, queueCount) {
   const qaQueueBadge = queueCount > 0 ? ' <span style="font-size:var(--text-xs);color:var(--muted);background:var(--surface);padding:1px 5px;border-radius:8px;border:1px solid var(--border)">+' + queueCount + ' queued</span>' : '';
-  // Wrap in a column-flex container so chain-of-thought (tool calls) stack
-  // vertically on top and the progress block sits at the bottom. Overrides the
-  // parent .modal-qa-loading row-flex (which is right for the simple
-  // "Thinking..." initial state but wrong once tools/streamed text appear).
+  // Wrap in a column-flex container so the interleaved chain-of-thought (tool
+  // calls + partial text in arrival order, via ccSegmentsRender) stacks on top
+  // and the progress block sits at the bottom. Overrides the parent
+  // .modal-qa-loading row-flex (right for the simple "Thinking..." state but
+  // wrong once tools/streamed text appear).
   let html = '<div style="display:flex;flex-direction:column;align-items:stretch;gap:6px;width:100%">';
-  if (toolsUsed && toolsUsed.length > 0) {
-    html += '<div style="display:flex;flex-direction:column;gap:2px">';
-    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:var(--text-sm);font-family:monospace;display:flex;align-items:flex-start;gap:6px"><span style="flex-shrink:0">&#9679;</span><span style="word-break:break-all">' + formatToolSummary(name, input) + '</span></div>';
-    });
-    html += '</div>';
-  }
-  if (streamedText) html += '<div>' + renderMd(streamedText) + '</div>';
+  const bodyHtml = ccSegmentsRender(segments || [], { keyPrefix: loadingId });
+  if (bodyHtml) html += bodyHtml;
   html += '<div style="display:flex;align-items:center;gap:8px;flex-wrap:wrap">' +
     '<span class="dot-pulse"><span></span><span></span><span></span></span>' +
     '<span id="' + loadingId + '-text">' + escHtml(label) + '</span>' +
@@ -629,8 +622,11 @@ 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...']];
-  let streamedText = '';
-  let toolsUsed = [];
+  // Ordered text↔tool segments for the live progress view (replaces the old
+  // flat streamedText + toolsUsed buckets). Rendered interleaved via
+  // ccSegmentsRender; see render-utils.js. The final answer bubble still
+  // collapses to the authoritative evt.text (doc-chat returns one answer).
+  let segments = [];
   let _qaStreamStalled = false;
   let _qaStallTimer = null;
   function _clearQaStreamWatchdog() {
@@ -666,8 +662,7 @@ async function _processQaMessage(message, selection, opts) {
         loadingId,
         _qaProgressLabel(elapsed),
         Math.floor(elapsed / 1000),
-        streamedText,
-        toolsUsed,
+        segments,
         runtime.queue.length
       );
     });
@@ -730,13 +725,19 @@ async function _processQaMessage(message, selection, opts) {
       }
       if (evt.type === 'chunk') {
         _resetQaStreamWatchdog();
-        streamedText = evt.text || '';
+        ccSegmentsApplyChunk(segments, evt.text || '', evt.segmentId);
         _qaRenderProgress(true);
         return;
       }
       if (evt.type === 'tool') {
         _resetQaStreamWatchdog();
-        toolsUsed.push({ name: evt.name, input: evt.input || {} });
+        ccSegmentsApplyTool(segments, { name: evt.name, input: evt.input || {}, id: evt.id || null });
+        _qaRenderProgress(true);
+        return;
+      }
+      if (evt.type === 'tool-update') {
+        _resetQaStreamWatchdog();
+        ccSegmentsApplyToolUpdate(segments, evt.id, evt.status);
         _qaRenderProgress(true);
         return;
       }
@@ -760,7 +761,7 @@ async function _processQaMessage(message, selection, opts) {
         const suffix = evt.edited ? '\n\n\u2713 Document saved.' : '';
         // Fall back to the live-streamed text when the backend produced no final
         // answer \u2014 covers the "stream had visible chunks then returned empty" case.
-        const finalText = (evt.text && evt.text.trim()) ? evt.text : (streamedText || '');
+        const finalText = (evt.text && evt.text.trim()) ? evt.text : ccSegmentsText(segments);
         let bodyText = finalText + suffix;
         if (evt.partial && evt.warning) {
           bodyText += '\n\n_' + evt.warning + '_';
@@ -872,23 +873,24 @@ async function _processQaMessage(message, selection, opts) {
     _clearQaStreamWatchdog();
     const qaElapsedExc = Math.round((Date.now() - qaStartTime) / 1000);
     const stallMessage = 'Doc chat stalled with no tool or text progress for 6 minutes.';
+    const qaPartialText = ccSegmentsText(segments);
     const messageHtml = _qaStreamStalled
-      ? (streamedText
-          ? _qaBuildAssistantHtml(streamedText + '\n\nError: ' + stallMessage, { borderColor: 'var(--red)', elapsed: qaElapsedExc })
+      ? (qaPartialText
+          ? _qaBuildAssistantHtml(qaPartialText + '\n\nError: ' + stallMessage, { borderColor: 'var(--red)', elapsed: qaElapsedExc })
           : _qaBuildAssistantHtml('Error: ' + stallMessage, { color: 'var(--red)', isError: true, elapsed: qaElapsedExc }))
       : e.name === 'AbortError'
-      ? (streamedText
-          ? _qaBuildAssistantHtml(streamedText + '\n\n_Stopped._', { borderColor: 'var(--muted)', elapsed: qaElapsedExc })
+      ? (qaPartialText
+          ? _qaBuildAssistantHtml(qaPartialText + '\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 })
+      : (qaPartialText
+          ? _qaBuildAssistantHtml(qaPartialText + '\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();
       _qaInsertBeforeQueued(tmp, messageHtml);
     });
-    if (e.name === 'AbortError' && _qaRecordAbortedPartial(runtime, message, streamedText) && _qaIsActiveSession(sessionKey)) {
+    if (e.name === 'AbortError' && _qaRecordAbortedPartial(runtime, message, qaPartialText) && _qaIsActiveSession(sessionKey)) {
       _qaHistory = runtime.history.slice();
     }
     _qaFlushPersistDebounce(sessionKey);

package/dashboard/js/render-utils.js

@@ -71,6 +71,144 @@ function formatToolSummary(name, input) {
   }
 }
 
+// ─── Ordered text↔tool segments (CC + doc-chat live streams) ───────────────
+//
+// A single assistant turn can interleave many text blocks with tool calls
+// (text → tool → text → tool → final text, up to ccMaxTurns). The old model
+// flattened that into "all tool chips first, then one merged text blob", which
+// destroyed the chronological structure and welded back-to-back assistant
+// messages together. The segment model preserves arrival order: each entry is
+// a { kind:'text', id, text } or { kind:'tool', id, name, input, status }
+// record, rendered in sequence so prose and tool activity stay interleaved.
+//
+// Text-segment boundaries come from the server `segmentId` on chunk events
+// (engine/llm.js increments it on a tool boundary or a non-extending text
+// push). When segmentId is absent (Copilot pool path, live-stream replay,
+// older engine) ccSegmentsApplyChunk falls back to a heuristic: a chunk that
+// arrives after a tool starts a new text segment; a chunk that extends the
+// current text segment updates it in place. Boundaries are never inferred from
+// character overlap, so unrelated chunks can never weld (cf. W-mq1jwwqo).
+
+function _ccSegMergeText(prev, next) {
+  if (!prev) return next || '';
+  if (!next) return prev;
+  if (next === prev) return prev;
+  if (next.indexOf(prev) === 0) return next; // accumulated buffer grew
+  if (prev.indexOf(next) === 0) return prev; // stale/short repaint of same text
+  return prev + '\n\n' + next;               // distinct text — separate, never weld
+}
+
+// The trailing text segment of the current run, or null if a tool closed the
+// run (so the next text belongs to a fresh segment).
+function ccSegmentsLastText(segments) {
+  for (var i = segments.length - 1; i >= 0; i--) {
+    if (segments[i].kind === 'text') return segments[i];
+    if (segments[i].kind === 'tool') return null;
+  }
+  return null;
+}
+
+function ccSegmentsApplyChunk(segments, text, segmentId) {
+  if (!text) return segments;
+  var hasId = segmentId !== undefined && segmentId !== null;
+  var last = segments.length ? segments[segments.length - 1] : null;
+  if (hasId) {
+    if (last && last.kind === 'text' && last.id === segmentId) { last.text = text; return segments; }
+    segments.push({ kind: 'text', id: segmentId, text: text });
+    return segments;
+  }
+  // Heuristic fallback: extend the open text segment, else open a new one.
+  if (last && last.kind === 'text') { last.text = _ccSegMergeText(last.text, text); return segments; }
+  segments.push({ kind: 'text', id: null, text: text });
+  return segments;
+}
+
+function ccSegmentsApplyTool(segments, tool) {
+  segments.push({
+    kind: 'tool',
+    id: (tool && tool.id) || null,
+    name: tool && tool.name,
+    input: (tool && tool.input) || {},
+    status: tool && (tool.id ? (tool.status || 'pending') : (tool.status || null)),
+  });
+  return segments;
+}
+
+function ccSegmentsApplyToolUpdate(segments, id, status) {
+  for (var i = segments.length - 1; i >= 0; i--) {
+    if (segments[i].kind === 'tool' && segments[i].id === id) { segments[i].status = status; break; }
+  }
+  return segments;
+}
+
+// Reconcile streamed segments with the authoritative final text (Claude's
+// `result` event carries the LAST assistant message and arrives via setText
+// with no chunk). Ensures the trailing text segment matches the final answer
+// without discarding earlier interleaved segments.
+function ccSegmentsFinalize(segments, finalText) {
+  if (!finalText) return segments;
+  var last = ccSegmentsLastText(segments);
+  if (last) last.text = _ccSegMergeText(last.text, finalText);
+  else segments.push({ kind: 'text', id: null, text: finalText });
+  return segments;
+}
+
+// Expanded-state for collapsible tool groups, keyed by a caller-supplied stable
+// key (tab id / message id + group ordinal). Persisted here — outside the DOM —
+// so the live stream's full re-render every frame doesn't reset a group the user
+// expanded mid-stream. Native <details> drives the toggle; this just remembers.
+var _ccToolGroupOpen = Object.create(null);
+function ccToolGroupToggle(el, key) {
+  if (!el) return;
+  if (el.open) _ccToolGroupOpen[key] = true; else delete _ccToolGroupOpen[key];
+}
+
+// Render segments in chronological order. Each text segment becomes its own
+// markdown block. A run of >1 tool chips collapses into a <details> showing only
+// the first chip (+ "N more"); expanding reveals the rest. opts.keyPrefix gives
+// each group a stable key so the expanded state survives live-stream re-renders.
+function ccSegmentsRender(segments, opts) {
+  if (!segments || !segments.length) return '';
+  var keyPrefix = (opts && opts.keyPrefix) || '';
+  var html = '';
+  var i = 0;
+  var groupOrdinal = 0;
+  while (i < segments.length) {
+    if (segments[i].kind === 'tool') {
+      var chips = [];
+      while (i < segments.length && segments[i].kind === 'tool') { chips.push(renderToolChip(segments[i])); i++; }
+      if (chips.length <= 1) {
+        html += '<div class="cc-tool-group">' + chips.join('') + '</div>';
+      } else {
+        var groupKey = keyPrefix + ':tg' + groupOrdinal;
+        var openAttr = _ccToolGroupOpen[groupKey] ? ' open' : '';
+        html += '<details class="cc-tool-group cc-tool-collapsible"' + openAttr +
+            ' ontoggle="ccToolGroupToggle(this,\'' + groupKey + '\')">' +
+          '<summary class="cc-tool-summary">' + chips[0] +
+            '<span class="cc-tool-more">+' + (chips.length - 1) + ' more</span>' +
+            '<span class="cc-tool-less">show less</span></summary>' +
+          '<div class="cc-tool-rest">' + chips.slice(1).join('') + '</div>' +
+          '</details>';
+      }
+      groupOrdinal++;
+    } else {
+      if (segments[i].text) html += '<div class="cc-text-segment">' + renderMd(segments[i].text) + '</div>';
+      i++;
+    }
+  }
+  return html;
+}
+
+// Plain-text join of all text segments — for tab titles, copy, transcripts.
+function ccSegmentsText(segments) {
+  if (!segments || !segments.length) return '';
+  var parts = [];
+  for (var i = 0; i < segments.length; i++) {
+    if (segments[i].kind === 'text' && segments[i].text) parts.push(segments[i].text);
+  }
+  return parts.join('\n\n');
+}
+
 /**
  * Internal helper: renders a single parsed JSON object into an HTML fragment.
  * @param {object} obj - Parsed JSON object from agent JSONL output

package/dashboard/js/utils.js

@@ -301,10 +301,47 @@ function _renderMdCore(s) {
   // 3. Block-level processing (line by line)
   var lines = html.split('\n');
   var out = [];
-  var inList = false;
-  var listType = '';
-
-  function closeList() { if (inList) { out.push(listType === 'ol' ? '</ol>' : '</ul>'); inList = false; } }
+  // Nested-list state: a stack of { tag:'ul'|'ol', indent } frames, each owning
+  // one currently-open <li>. Deeper-indented items nest inside the parent <li>;
+  // shallower items pop levels. Single-level lists behave exactly as before.
+  var listStack = [];
+  // Paragraph buffer: consecutive plain-text lines coalesce into one <p>-style
+  // block (soft line breaks via <br>) so paragraphs get real vertical spacing
+  // instead of each wrapped line becoming its own gap-less <div>.
+  var paraBuf = [];
+
+  function flushPara() {
+    if (!paraBuf.length) return;
+    out.push('<div class="md-p">' + paraBuf.join('<br>') + '</div>');
+    paraBuf = [];
+  }
+  function closeLevel() {
+    var top = listStack.pop();
+    out.push('</li>');
+    out.push(top.tag === 'ol' ? '</ol>' : '</ul>');
+  }
+  function closeList() { while (listStack.length) closeLevel(); }
+  function _openListTag(tag, isCb) {
+    var style = tag === 'ol'
+      ? 'margin:2px 0 2px 20px;padding:0'
+      : (isCb ? 'margin:2px 0 2px 16px;padding:0;list-style:none' : 'margin:2px 0 2px 16px;padding:0');
+    return '<' + tag + ' style="' + style + '">';
+  }
+  // Append a list item at the given indent, opening/closing/nesting lists as
+  // needed. `isCb` only affects styling of a freshly opened <ul>.
+  function pushListItem(indent, tag, liInner, isCb) {
+    flushPara();
+    while (listStack.length && listStack[listStack.length - 1].indent > indent) closeLevel();
+    if (listStack.length && listStack[listStack.length - 1].indent === indent) {
+      if (listStack[listStack.length - 1].tag === tag) {
+        out.push('</li>'); out.push('<li>' + liInner); return;
+      }
+      closeLevel(); // same indent, different list type → switch
+    }
+    out.push(_openListTag(tag, isCb));
+    listStack.push({ tag: tag, indent: indent });
+    out.push('<li>' + liInner);
+  }
   function nextNonEmptyLine(startIdx) {
     for (var ni = startIdx; ni < lines.length; ni++) {
       if (lines[ni].trim()) return lines[ni];
@@ -312,28 +349,22 @@ function _renderMdCore(s) {
     return '';
   }
   function continuesCurrentList(nextLine) {
-    if (!inList || !nextLine) return false;
-    if (listType === 'ol') return /^(\s*)\d+\.\s+(.+)/.test(nextLine);
-    return /^(\s*)[-*]\s+(.+)/.test(nextLine);
-  }
-  function openList(type) {
-    if (inList && listType !== type) closeList();
-    if (!inList) {
-      var style = type === 'ol' ? 'margin:2px 0 2px 20px;padding:0' : type === 'cb' ? 'margin:2px 0 2px 16px;padding:0;list-style:none' : 'margin:2px 0 2px 16px;padding:0';
-      out.push('<' + (type === 'ol' ? 'ol' : 'ul') + ' style="' + style + '">');
-      inList = true; listType = type === 'cb' ? 'ul' : type;
-    }
+    if (!listStack.length || !nextLine) return false;
+    // Any list item (of any type/indent) keeps the list region open across a
+    // blank line; the item handler manages level transitions.
+    return /^(\s*)\d+\.\s+(.+)/.test(nextLine) || /^(\s*)[-*]\s+(.+)/.test(nextLine);
   }
 
   for (var i = 0; i < lines.length; i++) {
     var line = lines[i];
 
     // Code block placeholder — pass through as-is
-    if (line.match(/^\x00CB\d+\x00$/)) { closeList(); out.push(line); continue; }
+    if (line.match(/^\x00CB\d+\x00$/)) { flushPara(); closeList(); out.push(line); continue; }
 
     // Headings
     var headMatch = line.match(/^(#{1,4})\s+(.+)/);
     if (headMatch) {
+      flushPara();
       closeList();
       var sizes = { 1: '16px', 2: '14px', 3: '13px', 4: '12px' };
       out.push('<div style="font-weight:600;font-size:' + sizes[headMatch[1].length] + ';margin:8px 0 4px">' + headMatch[2] + '</div>');
@@ -342,6 +373,7 @@ function _renderMdCore(s) {
 
     // Horizontal rule (only bare ---, ***, ___ lines)
     if (/^[-*_]{3,}\s*$/.test(line) && !/\S/.test(line.replace(/[-*_]/g, ''))) {
+      flushPara();
       closeList();
       out.push('<hr style="border:none;border-top:1px solid var(--border);margin:8px 0">');
       continue;
@@ -349,6 +381,7 @@ function _renderMdCore(s) {
 
     // Blockquote
     if (line.match(/^&gt;\s?/)) {
+      flushPara();
       closeList();
       out.push('<div style="border-left:3px solid var(--border);padding-left:8px;color:var(--muted);margin:2px 0">' + line.replace(/^(&gt;\s?)+/, '') + '</div>');
       continue;
@@ -356,6 +389,7 @@ function _renderMdCore(s) {
 
     // Table: detect | col | col | rows, consume until non-table line
     if (line.match(/^\|.+\|/)) {
+      flushPara();
       closeList();
       var tableRows = [];
       var sepIdx = -1;
@@ -384,40 +418,39 @@ function _renderMdCore(s) {
     // Checkbox list (must come before UL — both start with - )
     var cbMatch = line.match(/^(\s*)[-*]\s\[([ xX])\]\s(.+)/);
     if (cbMatch) {
-      openList('cb');
-      out.push('<li>' + (cbMatch[2] !== ' ' ? '\u2611' : '\u2610') + ' ' + cbMatch[3] + '</li>');
+      pushListItem(cbMatch[1].length, 'ul', (cbMatch[2] !== ' ' ? '\u2611' : '\u2610') + ' ' + cbMatch[3], true);
       continue;
     }
 
     // Unordered list (- or * followed by space and content, not bare --- or ***)
     var ulMatch = line.match(/^(\s*)[-*]\s+(.+)/);
     if (ulMatch) {
-      openList('ul');
-      out.push('<li>' + ulMatch[2] + '</li>');
+      pushListItem(ulMatch[1].length, 'ul', ulMatch[2], false);
       continue;
     }
 
     // Ordered list
     var olMatch = line.match(/^(\s*)\d+\.\s+(.+)/);
     if (olMatch) {
-      openList('ol');
-      out.push('<li>' + olMatch[2] + '</li>');
+      pushListItem(olMatch[1].length, 'ol', olMatch[2], false);
       continue;
     }
 
     // Blank line → spacer
     if (!line.trim()) {
+      flushPara();
       if (continuesCurrentList(nextNonEmptyLine(i + 1))) continue;
       closeList();
       out.push('<div style="height:4px"></div>');
       continue;
     }
 
-    // Non-list line — close any open list
+    // Non-list text line — close any open list, then buffer into the current
+    // paragraph (flushed at the next block boundary / blank line).
     closeList();
-
-    out.push('<div>' + line + '</div>');
+    paraBuf.push(line);
   }
+  flushPara();
   closeList();
   html = out.join('\n');
 

package/dashboard/styles.css

@@ -995,6 +995,35 @@
   .md-content th, .md-content td { padding: 4px 8px; border: 1px solid var(--border); text-align: left; font-size: var(--text-base); white-space: nowrap; }
   .md-content td { white-space: normal; min-width: 60px; }
   .md-content th { background: var(--surface); font-weight: 600; }
+  /* Real paragraph spacing (md-p groups consecutive text lines) + tightened
+     nested-list margins so multi-level lists read cleanly in the narrow drawer. */
+  .md-content .md-p { margin: 0 0 6px; }
+  .md-content .md-p:last-child { margin-bottom: 0; }
+  .md-content li { margin: 1px 0; }
+  .md-content ul ul, .md-content ul ol, .md-content ol ul, .md-content ol ol { margin-top: 2px; margin-bottom: 2px; }
+  .md-content pre { max-width: 100%; }
+  /* Interleaved CC / doc-chat segments: prose is the primary content; tool
+     activity is grouped, dimmed and indented behind a rule so it recedes. */
+  .cc-tool-group { margin: 4px 0; padding-left: 8px; border-left: 2px solid var(--border); opacity: 0.85; display: flex; flex-direction: column; gap: 2px; }
+  .cc-tool-group > div { line-height: 1.4; }
+  /* Collapsible tool group: <details> shows only the first chip; expanding
+     reveals the rest. Native <details> drives the toggle so the final (static)
+     message needs no JS; the live stream persists open state via ccToolGroupToggle. */
+  details.cc-tool-group { display: block; }
+  .cc-tool-summary { list-style: none; cursor: pointer; display: flex; align-items: center; gap: 8px; line-height: 1.4; padding: 5px 6px; margin: -3px -6px; border-radius: 6px; min-height: 28px; -webkit-tap-highlight-color: transparent; }
+  .cc-tool-summary:hover { background: var(--surface2); }
+  .cc-tool-summary::-webkit-details-marker { display: none; }
+  /* Bigger tap targets — the hints are small text, so pad them into pill-sized
+     hit areas (the whole summary row is clickable too). */
+  .cc-tool-more, .cc-tool-less { font-size: var(--text-sm); white-space: nowrap; padding: 3px 9px; border-radius: 11px; border: 1px solid var(--border); background: var(--surface2); }
+  .cc-tool-more { color: var(--muted); }
+  .cc-tool-less { display: none; color: var(--blue); }
+  details.cc-tool-group[open] .cc-tool-more { display: none; }
+  details.cc-tool-group[open] .cc-tool-less { display: inline-block; }
+  .cc-tool-rest { display: flex; flex-direction: column; gap: 2px; margin-top: 2px; }
+  .cc-text-segment { margin: 2px 0; }
+  .cc-text-segment:first-child { margin-top: 0; }
+  .cc-text-segment + .cc-tool-group, .cc-tool-group + .cc-text-segment { margin-top: 6px; }
   .status-line { display: flex; align-items: center; gap: var(--space-5); padding: var(--space-5) var(--space-7); background: var(--bg); border-bottom: 1px solid var(--border); font-size: var(--text-md); }
 
   /* Modal for inbox detail */

package/dashboard.js

@@ -1269,6 +1269,12 @@ function _scanProjectLocalHarnessFootgun(project) {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
       timeout: 10000,
+      // W-mqecdoot — MUST set windowsHide. This runs per-project on every
+      // GET /api/harness/diagnostics hit (Tools/Harness page, polled), and a
+      // detached dashboard has no console — so without this each call pops a
+      // visible git.exe console window per project ("infinite git windows").
+      // This was the only git spawn in the codebase missing windowsHide.
+      windowsHide: true,
     });
   } catch { return out; }
   if (!raw) return out;
@@ -5058,10 +5064,10 @@ function _finalizeDocChatEdit({ filePath, fullPath, isJson, canEdit, originalCon
 function _makeDocChatStreamStripper(onChunk) {
   if (!onChunk) return undefined;
   let lastSent;
-  return (text) => {
+  return (text, segmentId) => {
     if (text === lastSent) return;
     lastSent = text;
-    onChunk(text);
+    onChunk(text, segmentId);
   };
 }
 
@@ -8160,12 +8166,14 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       }
       let wire;
       try {
-        // W-mpmwxni2000c25c7-d — terminal error frames go out as `event: error`
-        // so SSE consumers using addEventListener('error', …) can target them.
-        // The JSON payload still carries `type: 'error'` for the data-line
-        // parser in modal-qa.js.
-        const eventLine = (type === 'error') ? 'event: error\n' : '';
-        wire = eventLine + 'data: ' + JSON.stringify(payload) + '\n\n';
+        // W-mpmwxni2000c25c7-d / W-mqevl09s000i9989 — terminal error frames go
+        // out as a named SSE `event: error` frame so consumers using
+        // addEventListener('error', …) can target them, mirroring the
+        // handleCommandCenterStream contract. The JSON payload still carries
+        // `type: 'error'` for the data-line parser in modal-qa.js.
+        wire = (type === 'error')
+          ? `event: error\ndata: ${JSON.stringify(payload)}\n\n`
+          : `data: ${JSON.stringify(payload)}\n\n`;
       } catch {
         _logFail('json-serialize-failed');
         return false;
@@ -8286,7 +8294,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           freshSession: !!body.freshSession,
           transcript: body.transcript,
           onAbortReady: (abort) => { _docAbort = abort; },
-          onChunk: (text) => { bumpTimer(); writeDocEvent({ type: 'chunk', text }); },
+          onChunk: (text, segmentId) => { bumpTimer(); writeDocEvent({ type: 'chunk', text, segmentId }); },
           onToolUse: (name, input) => { bumpTimer(); writeDocEvent({ type: 'tool', name, input: _lightToolInput(input) }); },
           onRetry: (attempt) => { bumpTimer(); writeDocEvent({ type: 'progress', attempt }); },
           systemPrompt: turnSystemPrompt,
@@ -9063,10 +9071,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       allowedTools: 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch',
       sessionId, effort, direct: true,
       engineConfig,
-      onChunk: (text) => {
+      onChunk: (text, segmentId) => {
         _touchCcLiveStream(liveState);
         liveState.text = text;
-        if (liveState.writer) liveState.writer({ type: 'chunk', text });
+        if (liveState.writer) liveState.writer({ type: 'chunk', text, segmentId });
       },
       onToolUse: (name, input) => {
         _touchCcLiveStream(liveState);

package/engine/cleanup.js

@@ -637,7 +637,30 @@ async function runCleanup(config, verbose = false) {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const full = path.resolve(wtRoot, entry.name);
+        // Defensive boundary: only ever delete strictly inside the worktree
+        // root we enumerated. readdirSync never yields `..`, so this is always
+        // true today — but it makes the "never escape wtRoot" invariant
+        // explicit and immune to a future refactor of how `full` is derived.
+        if (full !== wtRoot && !full.startsWith(wtRoot + path.sep)) continue;
         if (registered.has(full)) continue;
+        // W-mqecdoot — ownership gate, parity with the out-of-root worktree GC
+        // (worktree-gc.pruneOrphanWorktreesFromGitRegistry). Only ever reap a
+        // dir the engine positively created (carries the `.minions-worktree`
+        // marker stamped right after `git worktree add`). A dir with NO marker
+        // is a human's hand-made worktree (`git worktree add ../worktrees/mine`)
+        // or some unrelated folder dropped into the worktree root — KEEP it,
+        // never delete. Fail-open: leak a husk rather than nuke someone's
+        // unpushed work. This closes the same data-loss class the marker fixed
+        // for the registry sweep, for this on-disk-dir sweep too. The cost is
+        // that empty leftover husks whose marker was already removed leak
+        // instead of being reaped — an acceptable trade for "absolutely never
+        // delete foreign data".
+        let owned = false;
+        try { owned = !!shared.hasWorktreeOwnerMarker(full); } catch { owned = false; }
+        if (!owned) {
+          log('debug', `Cleanup: keeping orphan worktree dir ${full} — no engine ownership marker (foreign/hand-made worktree)`);
+          continue;
+        }
         let stat; try { stat = fs.statSync(full); } catch { continue; }
         if (stat.mtimeMs >= _twoHoursAgo) continue;
         // W-mq5rwwss000f30a7 — even an "orphan" dir (one git doesn't know

package/engine/llm.js

@@ -478,6 +478,14 @@ function _createStreamAccumulator({
   let taskCompleteFired = false;
   let terminalResultFired = false;
   let lastTaskCompleteSummary = '';
+  // Ordered text-segment index threaded to onChunk so the client can interleave
+  // distinct assistant text blocks with tool calls instead of welding them into
+  // one bubble. Bumped when a tool ran since the last text push (text after a
+  // tool is a new block) or when a push doesn't extend the current segment
+  // (a fresh assistant message after a stream reset). Consumed by the CC /
+  // doc-chat segment renderer (dashboard/js/render-utils.js ccSegments*).
+  let segmentSeq = 0;
+  let sawToolSinceText = false;
   const toolUses = [];
 
   function _streamText(value) {
@@ -492,8 +500,12 @@ function _createStreamAccumulator({
       const next = _streamText(value);
       text = next;
       if (onChunk && next !== lastTextSent) {
+        // New segment when a tool ran since the last text, or this push is not a
+        // continuation of the current segment (a fresh message after a reset).
+        if (lastTextSent && (sawToolSinceText || !next.startsWith(lastTextSent))) segmentSeq++;
+        sawToolSinceText = false;
         lastTextSent = next;
-        onChunk(next);
+        onChunk(next, segmentSeq);
       }
     },
     setText(value) {
@@ -518,6 +530,7 @@ function _createStreamAccumulator({
       if (!name) return;
       const toolUse = { name, input: input || {} };
       toolUses.push(toolUse);
+      sawToolSinceText = true;
       if (onToolUse) onToolUse(toolUse.name, toolUse.input);
     },
     toolUseAlreadySeen(name, input) {
@@ -539,8 +552,10 @@ function _createStreamAccumulator({
       if (!text) {
         text = finalSummary;
         if (onChunk && finalSummary !== lastTextSent) {
+          if (lastTextSent && (sawToolSinceText || !finalSummary.startsWith(lastTextSent))) segmentSeq++;
+          sawToolSinceText = false;
           lastTextSent = finalSummary;
-          onChunk(finalSummary);
+          onChunk(finalSummary, segmentSeq);
         }
       }
       if (!alreadySeen && onTaskComplete) {
@@ -795,7 +810,9 @@ function callLLM(promptText, sysPromptText, opts = {}) {
 /**
  * Streaming variant of callLLM — emits text chunks via onChunk callback.
  * Returns the same result object as callLLM when the process completes.
- * onChunk(text) is called for each assistant text block as it arrives.
+ * onChunk(text, segmentIndex) is called for each assistant text block as it
+ * arrives; segmentIndex increments across distinct text blocks so consumers can
+ * keep them visually separate instead of welding them together.
  */
 function callLLMStreaming(promptText, sysPromptText, opts = {}) {
   const {

package/engine/operator-identity.js

@@ -27,6 +27,7 @@ function _execImpl(cmd) {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
       timeout: 5000,
+      windowsHide: true,
     })).trim();
   } catch {
     return '';

package/engine/shared.js

@@ -7715,6 +7715,37 @@ function removeWorktree(wtPath, gitRoot, worktreeRoot, opts = {}) {
     log('warn', `removeWorktree: refusing to remove ${wtPath} — not under ${worktreeRoot}`);
     return false;
   }
+  // ── Data-loss hardening (W-mqecdoot) — NEVER recursively delete a real git
+  //    main repository. ──────────────────────────────────────────────────────
+  // The containment check above only proves `resolved` is *under* the
+  // caller-supplied `worktreeRoot`. Several callers derive that root from
+  // `config.engine.worktreeRoot` (default '../worktrees') — e.g. the cleanup
+  // orphan-reaper and projects.removeProject §3 readdir the root and call us on
+  // every child. A misconfigured `worktreeRoot` like '..' (or a project
+  // localPath placed one level too high) makes a sibling REAL repo pass
+  // containment; `git worktree remove --force` then FAILS (it isn't a linked
+  // worktree) and we fall through to fs.rmSync / `rd /s /q`, nuking the repo
+  // and its history. This is the reported incident (.git + repo dir gone). Two
+  // refusals below, both with zero false positives for legitimate linked-
+  // worktree removal:
+  //   1. The target IS the git root we were handed (deleting the repo itself).
+  //   2. The target carries its own `.git` DIRECTORY. A linked worktree's
+  //      `.git` is ALWAYS a FILE (a `gitdir:` pointer); only a main checkout
+  //      has a `.git` directory — so this can never block a real worktree wipe.
+  try {
+    if (gitRoot && resolved === path.resolve(String(gitRoot))) {
+      log('warn', `removeWorktree: refusing to remove ${wtPath} — it is the project git root, not a worktree`);
+      return false;
+    }
+  } catch { /* bad gitRoot — fall through to the .git probe */ }
+  try {
+    const st = fs.lstatSync(path.join(resolved, '.git'));
+    if (st && st.isDirectory()) {
+      log('warn', `removeWorktree: refusing to remove ${wtPath} — it is a real git repo (.git is a directory, not a linked-worktree pointer)`);
+      try { bumpWorktreeGcMetric('refusedRealRepo'); } catch { /* metric optional */ }
+      return false;
+    }
+  } catch { /* no .git, or unreadable — normal worktree husk; continue */ }
   // W-mq5rwwss000f30a7 — never wipe a worktree while an agent is actively
   // dispatched inside it. isWorktreePathLive fails OPEN (returns true) when
   // the dispatches table is unreachable, so we err on the side of leaking

package/package.json

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