@yemi33/minions 0.1.2244 → 0.1.2246

package/dashboard/slim/js/command-send.js

@@ -4,7 +4,7 @@
     var label = action.title || action.id || action.file || action.agent || '';
     return label ? t + ': ' + label : t;
   }
-  function renderActionResults(actions, results) {
+  function renderActionResults(turnTabId, actions, results) {
     if (!actions || !actions.length) return;
     for (var i = 0; i < actions.length; i++) {
       var action = actions[i];
@@ -17,22 +17,22 @@
       else if (r && r.warning) { severity = 'warn'; symbol = 'ℹ'; detail = ' — ' + r.warning; }
       else if (r && r.duplicate) { severity = 'warn'; symbol = '↺'; detail = ' (already exists)'; }
       var text = symbol + ' ' + label + detail;
-      appendActionStatus(severity, text);
-      messages.push({ role: 'action', severity: severity, text: text });
+      if (turnTabId === tabId) appendActionStatus(severity, text);
+      recordTabMessage(turnTabId, { role: 'action', severity: severity, text: text });
     }
-    saveState();
   }
 
   // Public entry point for the Send button / Enter key. While a turn is in
-  // flight the composer stays interactive (setSending no longer disables it),
-  // so a second submit QUEUES the message instead of dropping it or racing the
-  // active stream. The queue drains FIFO, one turn at a time (W-mqayw3x6).
+  // flight the composer stays interactive (the per-tab sending flag no longer
+  // disables it), so a second submit QUEUES the message instead of dropping it
+  // or racing the active stream. The queue drains FIFO, one turn at a time
+  // per tab (W-mqayw3x6).
   function sendMessage() {
     var text = inputEl.value.trim();
     if (!text) return;
     inputEl.value = '';
     inputEl.style.height = 'auto';
-    if (sending) {
+    if (_isTabSending(tabId)) {
       _enqueue(text);
       inputEl.focus();
       return;
@@ -46,57 +46,74 @@
     renderQueue();
   }
 
-  // Promote the next queued message for the active tab, one at a time. No-op
-  // while a turn is in flight or the queue is suspended (after abort/error).
-  function _drainQueue() {
-    if (sending || queueSuspended[tabId]) return;
-    var q = _getQueue();
-    if (!q.length) return;
+  // Promote the next queued message for the active tab.
+  function _drainQueue() { _drainQueueFor(tabId); }
+
+  // Promote the next queued message for a SPECIFIC tab, one at a time. No-op
+  // while that tab's turn is in flight or its queue is suspended (after an
+  // abort/error). Background tabs (W-mqqvba66) drain into their OWN turn, so a
+  // tab you switched away from keeps working through its queue.
+  function _drainQueueFor(id) {
+    if (_isTabSending(id) || queueSuspended[id]) return;
+    var q = queues[id];
+    if (!q || !q.length) return;
     var next = q.shift();
-    renderQueue();
-    _performSend(next);
+    if (id === tabId) renderQueue();
+    _performSend(next, id);
   }
 
   // Called from a finished turn's `finally`. On clean completion auto-fire the
-  // next queued message; on abort or error suspend auto-drain and leave the
-  // queue visible so the user can resend or dismiss explicitly (W-mqayw3x6 #5/#6).
+  // next queued message FOR THAT TAB; on abort or error suspend auto-drain and
+  // leave the queue visible so the user can resend or dismiss explicitly
+  // (W-mqayw3x6 #5/#6).
   function _afterTurn(turnTabId, outcome) {
     var q = queues[turnTabId];
     if (!q || !q.length) return;
-    if (outcome === 'done' && turnTabId === tabId) {
-      _drainQueue();
+    if (outcome === 'done') {
+      _drainQueueFor(turnTabId);
     } else {
       queueSuspended[turnTabId] = true;
       if (turnTabId === tabId) renderQueue();
     }
   }
 
-  async function _performSend(text) {
-    // Bind this turn to the tab it started on so a mid-turn tab switch (which
-    // aborts the stream) settles the queue against the right tab, not the one
-    // the user navigated to.
-    var turnTabId = tabId;
+  async function _performSend(text, sendTabId) {
+    // Bind this turn to the tab it started on (W-mqqvba66). EVERY append /
+    // saveState targets `turnTabId` — never the live-global `tabId`/`messages`
+    // — so a mid-turn tab switch keeps the stream running in the background and
+    // its partial is recorded on the originating tab, never mis-attributed to
+    // whatever tab the user navigated to. `live` is whether that tab is the
+    // currently-visible pane (only then do we touch the DOM directly).
+    var turnTabId = sendTabId || tabId;
+    var st = _streamState(turnTabId);
     var turnOutcome = 'done';
+    var live = (turnTabId === tabId);
 
     // The tab title is derived from the first user message; only that message
     // changes the chip, so re-render the bar once instead of on every send.
-    var wasFirstUser = !messages.some(function(m) { return m && m.role === 'user'; });
-    appendBubble('user', text);
-    messages.push({ role: 'user', text: text });
-    saveState();
+    var wasFirstUser = !_tabHasUserMessage(turnTabId);
+    if (live) appendBubble('user', text);
+    recordTabMessage(turnTabId, { role: 'user', text: text });
     if (wasFirstUser) renderTabBar();
 
-    setSending(true);
+    setSendingFor(turnTabId, true);
 
-    var stream = buildStreamBubble();
-    var streamedText = '';
-    abortController = new AbortController();
-    var userAborted = false;
+    st.streamedText = '';
+    st.toolList = [];
+    st.userAborted = false;
+    // The live bubble exists only while this tab is visible; a background turn
+    // accumulates into st.streamedText / st.toolList and re-attaches its bubble
+    // on switch-back (_restoreStreamFor). Share st.toolList by reference so
+    // restore replays already-streamed tools.
+    st.stream = live ? buildStreamBubble(st.streamedText, st.toolList) : null;
+    st.abortController = new AbortController();
     var timeoutSignal = null;
     try { timeoutSignal = AbortSignal.timeout(STREAM_TIMEOUT_MS); } catch (_e) { /* old browsers */ }
     var signal = timeoutSignal && AbortSignal.any
-      ? AbortSignal.any([abortController.signal, timeoutSignal])
-      : abortController.signal;
+      ? AbortSignal.any([st.abortController.signal, timeoutSignal])
+      : st.abortController.signal;
+
+    var turnSessionId = _getTabSessionId(turnTabId);
 
     try {
       var res = await fetch('/api/command-center/stream', {
@@ -106,7 +123,7 @@
         // when the indicator reads "Select project"). noProjectSelected lets the
         // server inject a "no project — ask the user" CC preamble instead of
         // silently defaulting; only the slim composer sends it (W-mqayzsj3).
-        body: JSON.stringify({ message: text, tabId: tabId, sessionId: sessionId, currentProject: currentProject || undefined, noProjectSelected: currentProject ? undefined : true }),
+        body: JSON.stringify({ message: text, tabId: turnTabId, sessionId: turnSessionId, currentProject: currentProject || undefined, noProjectSelected: currentProject ? undefined : true }),
         signal: signal,
       });
       if (!res.ok) {
@@ -135,10 +152,14 @@
           var evt;
           try { evt = JSON.parse(line.slice(6)); } catch (_e) { continue; }
           if (evt.type === 'chunk') {
-            streamedText = mergeStreamText(streamedText, evt.text || '');
-            stream.setText(streamedText);
+            st.streamedText = mergeStreamText(st.streamedText, evt.text || '');
+            if (st.stream) st.stream.setText(st.streamedText);
           } else if (evt.type === 'tool') {
-            stream.addTool(evt.name, evt.input || {});
+            // st.stream.addTool pushes into the shared st.toolList; when the tab
+            // is backgrounded (no bubble) accumulate directly so the tool set is
+            // intact for restore / the final message.
+            if (st.stream) st.stream.addTool(evt.name, evt.input || {});
+            else st.toolList.push({ name: evt.name, input: evt.input || {} });
           } else if (evt.type === 'heartbeat') {
             /* server keep-alive — ignored on purpose */
           } else if (evt.type === 'done') {
@@ -150,81 +171,82 @@
       }
 
       if (errorEvt) {
-        stream.replaceWithError(errorEvt.error || 'Error');
-        messages.push({ role: 'error', text: errorEvt.error || 'Error' });
-        saveState();
+        if (st.stream) st.stream.replaceWithError(errorEvt.error || 'Error');
+        recordTabMessage(turnTabId, { role: 'error', text: errorEvt.error || 'Error' });
         turnOutcome = 'error';
         return;
       }
 
       if (doneEvt) {
-        var finalText = mergeStreamText(streamedText, doneEvt.text || '');
-        stream.finalize(finalText || '(no response)');
-        messages.push({ role: 'assistant', text: finalText || '(no response)', toolCalls: stream.getToolList() });
-        if (doneEvt.sessionId !== undefined) sessionId = doneEvt.sessionId || null;
-        saveState();
+        var finalText = mergeStreamText(st.streamedText, doneEvt.text || '');
+        if (st.stream) st.stream.finalize(finalText || '(no response)');
+        recordTabMessage(turnTabId, { role: 'assistant', text: finalText || '(no response)', toolCalls: st.toolList });
+        if (doneEvt.sessionId !== undefined) _setTabSessionId(turnTabId, doneEvt.sessionId || null);
         if (doneEvt.actionParseError) {
           var pe = '⚠️ Actions block emitted but JSON could not be parsed — no actions executed.';
-          appendActionStatus('err', pe);
-          messages.push({ role: 'action', severity: 'err', text: pe });
-          saveState();
+          if (turnTabId === tabId) appendActionStatus('err', pe);
+          recordTabMessage(turnTabId, { role: 'action', severity: 'err', text: pe });
         }
         if (doneEvt.actions && doneEvt.actions.length > 0) {
-          renderActionResults(doneEvt.actions, doneEvt.actionResults || []);
+          renderActionResults(turnTabId, doneEvt.actions, doneEvt.actionResults || []);
         }
         // Refresh status + history opportunistically — actions probably
         // changed something.
         scheduleStatusRefresh(800);
       } else {
-        stream.finalize(streamedText || '(stream ended before completion)');
-        messages.push({ role: 'assistant', text: streamedText || '(stream ended before completion)', toolCalls: stream.getToolList() });
-        saveState();
+        if (st.stream) st.stream.finalize(st.streamedText || '(stream ended before completion)');
+        recordTabMessage(turnTabId, { role: 'assistant', text: st.streamedText || '(stream ended before completion)', toolCalls: st.toolList });
       }
     } catch (e) {
       if (e && (e.name === 'AbortError' || /aborted/i.test(String(e.message || '')))) {
-        userAborted = true;
+        st.userAborted = true;
         turnOutcome = 'aborted';
-        if (streamedText) {
-          stream.finalize(streamedText);
-          messages.push({ role: 'assistant', text: streamedText, toolCalls: stream.getToolList() });
+        if (st.streamedText) {
+          if (st.stream) st.stream.finalize(st.streamedText);
+          recordTabMessage(turnTabId, { role: 'assistant', text: st.streamedText, toolCalls: st.toolList });
         } else {
-          stream.replaceWithError('Stopped.');
-          messages.push({ role: 'error', text: 'Stopped.' });
+          if (st.stream) st.stream.replaceWithError('Stopped.');
+          recordTabMessage(turnTabId, { role: 'error', text: 'Stopped.' });
         }
-        saveState();
       } else {
         turnOutcome = 'error';
         var msg = 'Send failed: ' + (e && e.message ? e.message : e);
-        stream.replaceWithError(msg);
-        messages.push({ role: 'error', text: msg });
-        saveState();
+        if (st.stream) st.stream.replaceWithError(msg);
+        recordTabMessage(turnTabId, { role: 'error', text: msg });
       }
     } finally {
-      setSending(false);
-      abortController = null;
-      if (turnTabId === tabId && !userAborted) inputEl.focus();
+      setSendingFor(turnTabId, false);
+      st.abortController = null;
+      st.stream = null;
+      if (turnTabId === tabId && !st.userAborted) inputEl.focus();
       _afterTurn(turnTabId, turnOutcome);
     }
   }
 
-  function abortInFlight() {
-    if (!sending || !abortController) return;
+  // Abort a SPECIFIC tab's in-flight turn — kills the server turn AND aborts the
+  // fetch. Wired to ONLY two callers (W-mqqvba66): the explicit Stop button
+  // (abortInFlight → active tab) and closeSlimTab (closing a streaming tab).
+  // A plain tab SWITCH never calls this.
+  function abortTab(id) {
+    var st = tabStreams[id];
+    if (!st || !st.sending || !st.abortController) return;
     try {
       fetch('/api/command-center/abort', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ tabId: tabId }),
+        body: JSON.stringify({ tabId: id }),
       }).catch(function() {});
     } catch (_e) { /* ignore */ }
-    try { abortController.abort(); } catch (_e) { /* ignore */ }
+    try { st.abortController.abort(); } catch (_e) { /* ignore */ }
   }
+  function abortInFlight() { abortTab(tabId); }
 
   async function slimChatNew() {
-    if (sending) abortInFlight();
-    // New chat = fresh session: drop the leaving tab's pending queue (#7). The
-    // aborted in-flight turn's _afterTurn then finds an empty queue and no-ops.
-    delete queues[tabId];
-    queueSuspended[tabId] = false;
+    // New chat creates a fresh tab and switches to it. Like switchSlimTab, it
+    // does NOT abort the leaving tab's in-flight stream (W-mqqvba66) — that turn
+    // keeps streaming + draining its queue in the background. Detach its live
+    // bubble first since the transcript is about to be wiped.
+    _detachActiveStream();
     // Register a fresh tab in the shared cc-tabs store and switch slim onto
     // it — classic's other tabs are left intact, and the previous session
     // keeps its own server-side cc-sessions.json entry (no DELETE).
@@ -241,6 +263,7 @@
     saveState();
     rerenderHistory();
     renderTabBar();
+    _refreshComposerUI();
     inputEl.focus();
   }
 

package/dashboard/slim/js/modals-tiles.js

@@ -17,6 +17,7 @@
   bindModalClose('slim-agent-modal', 'slim-agent-close', _stopAgentDetailRuntime);
   bindModalClose('slim-tools-modal', 'slim-tools-close');
   bindModalClose('slim-tile-modal', 'slim-tile-close');
+  bindModalClose('slim-plans-modal', 'slim-plans-close');
 
   function tileEmpty(body, text) {
     var d = document.createElement('div');
@@ -320,6 +321,9 @@
     // The Knowledge tile opens the unified Knowledge control panel (Pinned
     // Context + Notes + KB tabs) rather than the read-only tile detail view.
     if (key === 'knowledge') { openKnowledgeModal(); return; }
+    // The Plans tile opens the tabbed Plans/PRD control panel (rendered by
+    // dashboard/slim/js/plans.js) rather than the read-only tile detail view.
+    if (key === 'plans') { openPlansModal(); return; }
     var view = TILE_VIEWS[key];
     if (!view) return;
     var modal = document.getElementById('slim-tile-modal');
@@ -356,3 +360,22 @@
     }
   })();
 
+  // ── Plans control-panel wiring ─────────────────────────────────────
+  // The Plans tile opens #slim-plans-modal (routed in openTileModal above).
+  // plans.js is the renderer only; the tab-switch + lazy tile-count wiring
+  // lives here, mirroring knowledge.js#bindKnowledgeUi. The plan/PRD count is
+  // not part of the /api/status poll, so it is fetched lazily from /api/plans
+  // shortly after first paint (and refreshed on each modal open by the renderer).
+  (function bindPlansUi() {
+    var tabBar = document.getElementById('slim-plans-tabs');
+    if (tabBar) {
+      tabBar.addEventListener('click', function(ev) {
+        var btn = ev.target && ev.target.closest ? ev.target.closest('.kn-tab') : null;
+        if (!btn) return;
+        var tab = btn.getAttribute('data-plans-tab');
+        if (tab && typeof setPlansTab === 'function') setPlansTab(tab);
+      });
+    }
+    if (typeof loadPlansCounts === 'function') setTimeout(loadPlansCounts, 1500);
+  })();
+