@yemi33/minions 0.1.2245 → 0.1.2247

package/dashboard/slim/body.html

@@ -112,6 +112,11 @@
             <div class="cockpit-value dim">0</div>
             <div class="cockpit-detail">pinned context, notes &amp; KB</div>
           </div>
+          <div class="cockpit-tile" data-tile="plans">
+            <div class="cockpit-label"><span class="cockpit-dot"></span> Plans</div>
+            <div class="cockpit-value dim">0</div>
+            <div class="cockpit-detail">drafts &amp; materialized PRDs</div>
+          </div>
         </div>
       </div>
     </div>
@@ -212,6 +217,29 @@
   </div>
 </div>
 
+<!-- Plans + PRD control panel — opened from the "Plans" status tile. Two tabs:
+     Plans (.md plan drafts) and PRD (materialized PRDs). Each tab is rendered
+     lazily by dashboard/slim/js/plans.js into #slim-plans-body. Backed by the
+     existing endpoints (no new server routes):
+       Plans — /api/plans (list), /api/plans/:file (read), and the lifecycle
+               POSTs (/api/plans/{approve,execute,reject,pause,regenerate,
+               archive,delete,unarchive}).
+       PRD   — the .json entries from /api/plans plus /api/prd and the
+               read-only subset of /api/prd-items. -->
+<div class="modal-bg" id="slim-plans-modal">
+  <div class="modal slim-plans-modal-inner">
+    <div class="modal-header">
+      <h3>Plans</h3>
+      <div class="kn-tabs" id="slim-plans-tabs" role="tablist">
+        <button class="kn-tab active" id="slim-plans-tab-plans" data-plans-tab="plans" type="button" role="tab" aria-selected="true" aria-controls="slim-plans-body">Plans</button>
+        <button class="kn-tab" id="slim-plans-tab-prd" data-plans-tab="prd" type="button" role="tab" aria-selected="false" aria-controls="slim-plans-body">PRD</button>
+      </div>
+      <button id="slim-plans-close" class="icon-btn" title="Close" style="margin-left:auto">&times;</button>
+    </div>
+    <div class="modal-body" id="slim-plans-body" role="tabpanel" tabindex="0" aria-labelledby="slim-plans-tab-plans"></div>
+  </div>
+</div>
+
 <!-- Pin editor — create (Pin Content action / "+ Pin") or edit an existing
      note. Submits to POST /api/pinned (create) or /api/pinned/update (edit). -->
 <div class="modal-bg" id="slim-pin-edit-modal">

package/dashboard/slim/js/chat.js

@@ -27,8 +27,27 @@
 
   var sessionId = null;
   var messages = [];
-  var sending = false;
-  var abortController = null;
+  // Per-tab streaming runtime (W-mqqvba66). Stream state lives here, keyed by
+  // tabId, so an in-flight turn keeps running AND accumulating when the user
+  // switches to another tab — mirroring the classic dashboard's per-tab
+  // tab._sending / _abortController / _segments model (command-center.js). The
+  // old module-global `sending` / `abortController` (one turn at a time) caused
+  // a mid-stream tab switch to abort the server turn and push the captured
+  // partial onto the wrong (now-active) tab. Each entry:
+  //   { sending, abortController, streamedText, toolList, stream, userAborted }
+  // `stream` is the live DOM bubble handle — only set while that tab is the
+  // visible pane (null on background tabs; re-created on switch-back).
+  var tabStreams = {};
+  function _streamState(id) {
+    return tabStreams[id] || (tabStreams[id] = {
+      sending: false, abortController: null, streamedText: '',
+      toolList: [], stream: null, userAborted: false,
+    });
+  }
+  function _isTabSending(id) {
+    var st = tabStreams[id];
+    return !!(st && st.sending);
+  }
   // Per-tab queue of follow-up messages submitted while a turn is streaming
   // (W-mqayw3x6). Keyed by tabId so each chat tab keeps its own queue across
   // tab switches. In-memory only — a hard refresh drops the queue by design.
@@ -129,14 +148,19 @@
     if (m.severity) out.severity = m.severity;
     return out;
   }
-  function _deriveTitle() {
-    for (var i = 0; i < messages.length; i++) {
-      if (messages[i] && messages[i].role === 'user' && messages[i].text) {
-        return messages[i].text.slice(0, 40);
+  function _deriveTitleFrom(msgs) {
+    for (var i = 0; i < (msgs || []).length; i++) {
+      var m = msgs[i];
+      if (m && m.role === 'user') {
+        var t = (typeof m.text === 'string') ? m.text : _htmlToText(m.html);
+        if (t) return t.slice(0, 40);
       }
     }
     return 'New chat';
   }
+  function _deriveTitle() {
+    return _deriveTitleFrom(messages);
+  }
 
   function loadState() {
     try {
@@ -168,6 +192,70 @@
     }, 300);
   }
 
+  // Append a message to a SPECIFIC tab (W-mqqvba66). For the active (visible)
+  // tab we reuse the in-memory `messages` array + debounced saveState; for a
+  // background tab — one whose turn is still streaming while the user views a
+  // different tab — we write straight through to the shared cc-tabs store so the
+  // response is recorded on its OWN tab and never mis-attributed to the live
+  // `messages`/`tabId`. The originating tabId is captured at send time and
+  // threaded through every append (see command-send.js _performSend).
+  function recordTabMessage(id, msg) {
+    if (id === tabId) {
+      messages.push(msg);
+      saveState();
+    } else {
+      _persistBackgroundMessage(id, msg);
+    }
+  }
+  function _persistBackgroundMessage(id, msg) {
+    try {
+      var tabs = _readCcTabs();
+      var idx = _findTabIdx(tabs, id);
+      if (idx < 0) return;   // tab was closed/removed — drop rather than resurrect it
+      var tab = tabs[idx];
+      var msgs = Array.isArray(tab.messages) ? tab.messages : [];
+      msgs.push(_slimToStored(msg));
+      tab.messages = msgs.slice(-SLIM_MAX_MESSAGES);
+      tab.title = _deriveTitleFrom(tab.messages);
+      tabs[idx] = tab;
+      _writeCcTabs(tabs);
+    } catch (_e) { /* localStorage full */ }
+  }
+  // Resolve / persist a tab's server session id, targeting the right store entry
+  // regardless of which tab is currently visible.
+  function _getTabSessionId(id) {
+    if (id === tabId) return sessionId;
+    try {
+      var tabs = _readCcTabs();
+      var idx = _findTabIdx(tabs, id);
+      return idx >= 0 ? (tabs[idx].sessionId || null) : null;
+    } catch (_e) { return null; }
+  }
+  function _setTabSessionId(id, sid) {
+    if (id === tabId) { sessionId = sid; saveState(); return; }
+    try {
+      var tabs = _readCcTabs();
+      var idx = _findTabIdx(tabs, id);
+      if (idx < 0) return;
+      tabs[idx].sessionId = sid;
+      _writeCcTabs(tabs);
+    } catch (_e) { /* localStorage full */ }
+  }
+  // True if a given tab already has at least one user message (drives the
+  // first-message title-chip refresh), targeting the active in-memory array or
+  // the persisted store for a background tab.
+  function _tabHasUserMessage(id) {
+    if (id === tabId) {
+      return messages.some(function(m) { return m && m.role === 'user'; });
+    }
+    try {
+      var tabs = _readCcTabs();
+      var idx = _findTabIdx(tabs, id);
+      if (idx < 0) return false;
+      return (tabs[idx].messages || []).some(function(m) { return m && m.role === 'user'; });
+    } catch (_e) { return false; }
+  }
+
   function escHtmlChat(s) {
     return String(s == null ? '' : s)
       .replace(/&/g, '&amp;')
@@ -425,7 +513,7 @@
     return { panel: panel, scroll: scroll };
   }
 
-  function buildStreamBubble() {
+  function buildStreamBubble(initialText, initialTools) {
     clearEmpty();
     var div = document.createElement('div');
     div.className = 'chat-msg assistant streaming';
@@ -445,11 +533,20 @@
     thinking.innerHTML = 'Thinking<span class="chat-thinking-dots"><span></span><span></span><span></span></span>';
     toolbar.appendChild(thinking);
 
-    var toolList = [];
+    // Reuse the caller's backing tool list (shared by reference) when restoring
+    // a live bubble after a tab switch, so already-streamed tools replay and new
+    // ones keep appending into the SAME per-tab array (W-mqqvba66).
+    var toolList = Array.isArray(initialTools) ? initialTools : [];
     var tp = buildToolsPanel(toolList);
-    tp.panel.style.display = 'none';
+    tp.panel.style.display = toolList.length ? '' : 'none';
     toolbar.appendChild(tp.panel);
 
+    // Seed the partial text accumulated so far (restore-on-switch-back path).
+    if (initialText) {
+      // eslint-disable-next-line no-unsanitized/property -- reason: renderMarkdown() escapes input via escHtmlChat() first; later substitutions only re-insert pre-escaped <pre><code>/<a>/<strong>/<em> spans with scheme-validated hrefs
+      body.innerHTML = renderMarkdown(initialText);
+    }
+
     _appendMsgEl(div);
     scrollToBottom();
 
@@ -489,8 +586,15 @@
     };
   }
 
-  function setSending(on) {
-    sending = on;
+  // Stream state is per-tab now (W-mqqvba66): toggle the originating tab's
+  // sending flag, and only refresh the composer chrome when that tab is the
+  // visible one (the Send/Stop buttons always reflect the ACTIVE tab).
+  function setSendingFor(id, on) {
+    _streamState(id).sending = on;
+    if (id === tabId) _refreshComposerUI();
+  }
+  function _refreshComposerUI() {
+    var on = _isTabSending(tabId);
     // Composer stays interactive while a turn streams so the user can keep
     // typing and queue follow-up messages (W-mqayw3x6 #1). The Send button
     // stays enabled — submitting mid-turn enqueues — and only its label
@@ -561,30 +665,56 @@
     tabsEl.appendChild(add);
   }
 
-  // Switch the visible pane to another shared tab. Aborts an in-flight stream
-  // first (the SSE is bound to the current tabId), then re-hydrates from the
-  // target tab's persisted state.
+  // Detach the active tab's live stream-bubble handle before its transcript DOM
+  // is wiped (rerenderHistory). The background fetch loop checks `st.stream`
+  // every chunk, so nulling it makes the still-running turn stop touching the
+  // DOM while keeping its partial accumulating into st.streamedText / saveState.
+  function _detachActiveStream() {
+    var st = tabStreams[tabId];
+    if (st) st.stream = null;
+  }
+  // Re-attach a live streaming bubble for a tab the user is switching BACK to
+  // while its turn is still in flight, seeded from the tab's accumulated partial
+  // + tool list (mirror classic's _restoreStreamHtml). The running fetch loop
+  // resumes updating st.stream as new chunks arrive; slim has no elapsed-timer
+  // chrome, so unlike classic no 1s restore interval is needed.
+  function _restoreStreamFor(id) {
+    var st = tabStreams[id];
+    if (!st || !st.sending) return;
+    st.stream = buildStreamBubble(st.streamedText, st.toolList);
+  }
+
+  // Switch the visible pane to another shared tab. The previous tab's in-flight
+  // stream is KEPT RUNNING in the background (W-mqqvba66) — we never abort on a
+  // switch — and the target tab is re-hydrated from its own persisted state,
+  // restoring its live streaming bubble if it is mid-turn.
   function switchSlimTab(id) {
     if (!id || id === tabId) return;
-    if (sending) abortInFlight();
+    _detachActiveStream();
     tabId = id;
     try { localStorage.setItem(CC_ACTIVE_KEY, id); } catch (_e) { /* private mode */ }
     sessionId = null;
     messages = [];
     loadState();
     rerenderHistory();
+    _restoreStreamFor(id);
     renderTabBar();
+    _refreshComposerUI();
     inputEl.focus();
   }
 
   function closeSlimTab(id) {
     if (!id) return;
-    if (id === tabId && sending) abortInFlight();
+    // Closing a streaming tab DOES abort + delete its server session (one of the
+    // only two abort paths left, alongside the explicit Stop button).
+    if (_isTabSending(id)) abortTab(id);
     var tabs = _readCcTabs();
     var idx = _findTabIdx(tabs, id);
     if (idx < 0) return;
     tabs.splice(idx, 1);
     _writeCcTabs(tabs);
+    delete queues[id];
+    delete queueSuspended[id];
     // Evict the server-side session for the closed tab (mirrors classic).
     try { fetch('/api/cc-sessions/' + encodeURIComponent(id), { method: 'DELETE' }).catch(function() {}); } catch (_e) { /* ignore */ }
     if (id !== tabId) { renderTabBar(); return; }

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);
+  })();
+