@yemi33/minions 0.1.2172 → 0.1.2173

package/dashboard/slim/body.html

@@ -24,6 +24,7 @@
       <span class="panel-sub">Command Center &amp; quick triggers</span>
     </div>
     <div class="actions-chat">
+      <div class="chat-tabs" id="chat-tabs"></div>
       <div class="chat-messages" id="chat-messages">
         <div class="chat-empty">No messages yet — say hi to Command Center.</div>
       </div>

package/dashboard/slim/js/chat.js

@@ -1,8 +1,26 @@
   // ── Chatbox wired to /api/command-center/stream ──────────────
   // Mirrors the full dashboard's command center: SSE streaming, tool-call
   // progress, abort, and per-tab session continuity.
-  var SLIM_STORAGE_KEY = 'slim-cc-state-v1';
-  var SLIM_TAB_KEY     = 'slim-cc-tabid-v1';
+  // ── Shared Command-Center store (carry-over with the classic dashboard) ──
+  // Slim used to persist a private single-chat blob under its own slim-only
+  // localStorage key with its own slim-prefixed tab id. That siloed it from
+  // the classic dashboard:
+  // switching views lost the conversation AND started a fresh server-side CC
+  // session (cc-sessions.json is keyed by tabId). To honor the welcome
+  // popup's promise — "multi-tab conversations that carry over from the
+  // classic dashboard" — slim now reads/writes the SAME localStorage the
+  // classic command center owns:
+  //   cc-tabs       — [{id, title, sessionId, messages:[{role, html, ...}]}]
+  //   cc-active-tab — id of the focused tab
+  // Slim is a single-pane chat, so it mirrors the *active* tab bidirectionally
+  // and reuses its `cc-*` id as the server session key, so the same backend
+  // session continues across either view. Messages are stored in the classic
+  // shape ({role, html}) so the classic dashboard renders them, with slim's
+  // extra fields ({text, toolCalls, severity}) carried alongside — classic
+  // ignores them, slim re-hydrates from them losslessly.
+  var CC_TABS_KEY      = 'cc-tabs';
+  var CC_ACTIVE_KEY    = 'cc-active-tab';
+  var SLIM_MAX_TABS    = 20;   // matches the classic dashboard's CC_MAX_TABS
   var SLIM_PROJECT_KEY = 'slim-current-project-v1';
   var SLIM_MAX_MESSAGES = 30;
   var STREAM_TIMEOUT_MS = (60 * 60 * 1000) + 60000;
@@ -14,30 +32,115 @@
   var currentProject = null;
   try { currentProject = localStorage.getItem(SLIM_PROJECT_KEY) || null; } catch (_e) { /* private mode */ }
 
-  var tabId = (function() {
+  function _readCcTabs() {
     try {
-      var t = sessionStorage.getItem(SLIM_TAB_KEY);
-      if (t) return t;
-      t = 'slim-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
-      sessionStorage.setItem(SLIM_TAB_KEY, t);
-      return t;
-    } catch (_e) {
-      return 'slim-' + Date.now().toString(36);
+      var raw = localStorage.getItem(CC_TABS_KEY);
+      var arr = raw ? JSON.parse(raw) : [];
+      return Array.isArray(arr) ? arr : [];
+    } catch (_e) { return []; }
+  }
+  // Persist the FULL array — never trim here. Trimming on every write would
+  // silently evict the oldest tabs (and could orphan cc-active-tab) the moment
+  // slim saves a message, dropping tabs the classic dashboard still owns. Like
+  // classic, the cap is enforced at tab-CREATION time (see _pushCappedTab).
+  function _writeCcTabs(tabs) {
+    try { localStorage.setItem(CC_TABS_KEY, JSON.stringify(tabs)); } catch (_e) { /* full */ }
+  }
+  function _findTabIdx(tabs, id) {
+    return tabs.findIndex(function(t) { return t && t.id === id; });
+  }
+  function _newTabId() {
+    return 'cc-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+  }
+  // Append a new tab, evicting the oldest to stay within the cap (classic
+  // parity). Clears cc-active-tab if the evicted tab was the active one.
+  function _pushCappedTab(tabs, tab) {
+    while (tabs.length >= SLIM_MAX_TABS) {
+      var dropped = tabs.shift();
+      try {
+        if (dropped && dropped.id === localStorage.getItem(CC_ACTIVE_KEY)) localStorage.removeItem(CC_ACTIVE_KEY);
+      } catch (_e) { /* private mode */ }
+    }
+    tabs.push(tab);
+    return tab;
+  }
+  // Single source of truth for a fresh tab's shape — used wherever a tab is
+  // created or has to be reconstructed (load, save, new-chat).
+  function _newTab(id) {
+    return { id: id || _newTabId(), title: 'New chat', sessionId: null, messages: [] };
+  }
+  // Resolve the tab slim should mirror: the classic active tab if present,
+  // else the most-recent existing tab, else a fresh one registered into the
+  // shared store so the classic dashboard immediately sees it.
+  function _ensureActiveTab() {
+    var tabs = _readCcTabs();
+    var activeId = null;
+    try { activeId = localStorage.getItem(CC_ACTIVE_KEY); } catch (_e) { /* private mode */ }
+    var ai = activeId ? _findTabIdx(tabs, activeId) : -1;
+    var tab = ai >= 0 ? tabs[ai] : null;
+    if (!tab && tabs.length) tab = tabs[tabs.length - 1];
+    if (!tab) {
+      tab = _newTab();
+      tabs.push(tab);
+      _writeCcTabs(tabs);
     }
-  })();
+    try { localStorage.setItem(CC_ACTIVE_KEY, tab.id); } catch (_e) { /* private mode */ }
+    return tab;
+  }
+
+  var tabId = _ensureActiveTab().id;
 
   var msgsEl  = document.getElementById('chat-messages');
   var inputEl = document.getElementById('chat-input');
   var sendBtn = document.getElementById('chat-send');
   var stopBtn = document.getElementById('chat-stop');
 
+  // Extract plain text from classic-authored message HTML (no slim `text`).
+  function _htmlToText(html) {
+    if (!html) return '';
+    var tmp = document.createElement('div');
+    // eslint-disable-next-line no-unsanitized/property -- reason: html is read back from our own persisted store (renderMarkdown/escHtml produced it); only textContent is extracted, never re-inserted into the live DOM here
+    tmp.innerHTML = String(html);
+    return (tmp.textContent || tmp.innerText || '').trim();
+  }
+  // Stored ({role, html, ...}) → slim in-memory ({role, text, toolCalls, severity}).
+  function _storedToSlim(m) {
+    if (!m || typeof m !== 'object') return null;
+    var text = (typeof m.text === 'string') ? m.text : _htmlToText(m.html);
+    var out = { role: m.role || 'assistant', text: text };
+    if (Array.isArray(m.toolCalls)) out.toolCalls = m.toolCalls;
+    if (m.severity) out.severity = m.severity;
+    return out;
+  }
+  // Slim in-memory → stored. Keep slim fields AND a classic-renderable `html`
+  // so both dashboards display it. User/action/error text is escaped; the
+  // assistant body is markdown-rendered (renderMarkdown escapes first).
+  function _slimToStored(m) {
+    var role = m.role || 'assistant';
+    var html = (role === 'assistant') ? renderMarkdown(m.text || '') : escHtmlChat(m.text || '');
+    var out = { role: role, html: html, text: m.text || '' };
+    if (Array.isArray(m.toolCalls)) out.toolCalls = m.toolCalls;
+    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);
+      }
+    }
+    return 'New chat';
+  }
+
   function loadState() {
     try {
-      var raw = localStorage.getItem(SLIM_STORAGE_KEY);
-      if (!raw) return;
-      var data = JSON.parse(raw) || {};
-      sessionId = data.sessionId || null;
-      messages = Array.isArray(data.messages) ? data.messages.slice(-SLIM_MAX_MESSAGES) : [];
+      var tabs = _readCcTabs();
+      var idx = _findTabIdx(tabs, tabId);
+      if (idx < 0) return;
+      var tab = tabs[idx];
+      sessionId = tab.sessionId || null;
+      var msgs = Array.isArray(tab.messages) ? tab.messages.slice(-SLIM_MAX_MESSAGES) : [];
+      messages = msgs.map(_storedToSlim).filter(Boolean);
     } catch (_e) { /* ignore */ }
   }
   var saveDebounce = null;
@@ -46,10 +149,15 @@
     saveDebounce = setTimeout(function() {
       saveDebounce = null;
       try {
-        localStorage.setItem(SLIM_STORAGE_KEY, JSON.stringify({
-          sessionId: sessionId,
-          messages: messages.slice(-SLIM_MAX_MESSAGES),
-        }));
+        var tabs = _readCcTabs();
+        var idx = _findTabIdx(tabs, tabId);
+        var tab = (idx >= 0) ? tabs[idx] : _newTab(tabId);
+        tab.sessionId = sessionId;
+        tab.title = _deriveTitle();
+        tab.messages = messages.slice(-SLIM_MAX_MESSAGES).map(_slimToStored);
+        if (idx >= 0) tabs[idx] = tab; else tabs.push(tab);
+        _writeCcTabs(tabs);
+        try { localStorage.setItem(CC_ACTIVE_KEY, tabId); } catch (_e) { /* private mode */ }
       } catch (_e) { /* localStorage full */ }
     }, 300);
   }
@@ -324,6 +432,89 @@
       else appendBubble(m.role, m.text || '', m.toolCalls);
     }
   }
+  // ── Command Center tab bar (shared with the classic dashboard) ──
+  // One chip per shared cc-tabs entry, so the same conversations are visible
+  // and switchable in either view. Slim shows a single pane at a time; this
+  // bar is how you move between the tabs the classic dashboard also shows.
+  var tabsEl = document.getElementById('chat-tabs');
+
+  function _tabChipLabel(t) {
+    var s = (t && t.title) ? String(t.title) : 'New chat';
+    return s.length > 24 ? s.slice(0, 24) + '…' : s;
+  }
+
+  function renderTabBar() {
+    if (!tabsEl) return;
+    var tabs = _readCcTabs();
+    tabsEl.textContent = '';
+    tabs.forEach(function(t) {
+      if (!t || !t.id) return;
+      var chip = document.createElement('div');
+      chip.className = 'chat-tab' + (t.id === tabId ? ' active' : '');
+      chip.title = t.title || 'New chat';
+      var label = document.createElement('span');
+      label.className = 'chat-tab-label';
+      label.textContent = _tabChipLabel(t);
+      label.addEventListener('click', function() { switchSlimTab(t.id); });
+      chip.appendChild(label);
+      var close = document.createElement('button');
+      close.className = 'chat-tab-close';
+      close.type = 'button';
+      close.textContent = '×';
+      close.title = 'Close chat';
+      close.addEventListener('click', function(ev) { ev.stopPropagation(); closeSlimTab(t.id); });
+      chip.appendChild(close);
+      tabsEl.appendChild(chip);
+    });
+    var add = document.createElement('button');
+    add.className = 'chat-tab-new';
+    add.type = 'button';
+    add.textContent = '+';
+    add.title = 'New chat';
+    add.addEventListener('click', function() { slimChatNew(); });
+    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.
+  function switchSlimTab(id) {
+    if (!id || id === tabId) return;
+    if (sending) abortInFlight();
+    tabId = id;
+    try { localStorage.setItem(CC_ACTIVE_KEY, id); } catch (_e) { /* private mode */ }
+    sessionId = null;
+    messages = [];
+    loadState();
+    rerenderHistory();
+    renderTabBar();
+    inputEl.focus();
+  }
+
+  function closeSlimTab(id) {
+    if (!id) return;
+    if (id === tabId && sending) abortInFlight();
+    var tabs = _readCcTabs();
+    var idx = _findTabIdx(tabs, id);
+    if (idx < 0) return;
+    tabs.splice(idx, 1);
+    _writeCcTabs(tabs);
+    // 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; }
+    if (tabs.length) {
+      switchSlimTab(tabs[Math.min(idx, tabs.length - 1)].id);
+    } else {
+      slimChatNew();   // never leave the user with zero tabs
+    }
+  }
+
+  // Surface tabs created/closed by the classic dashboard in another window.
+  window.addEventListener('storage', function(ev) {
+    if (!ev || ev.key === CC_TABS_KEY || ev.key === CC_ACTIVE_KEY || ev.key === null) renderTabBar();
+  });
+
   loadState();
   rerenderHistory();
+  renderTabBar();
 

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

@@ -28,9 +28,13 @@
     var text = inputEl.value.trim();
     if (!text) return;
 
+    // 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();
+    if (wasFirstUser) renderTabBar();
 
     inputEl.value = '';
     inputEl.style.height = 'auto';
@@ -161,13 +165,22 @@
 
   async function slimChatNew() {
     if (sending) abortInFlight();
+    // 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).
+    try {
+      var tabs = _readCcTabs();
+      var fresh = _newTab();
+      _pushCappedTab(tabs, fresh);   // enforce the tab cap at creation (classic parity)
+      _writeCcTabs(tabs);
+      tabId = fresh.id;
+      try { localStorage.setItem(CC_ACTIVE_KEY, fresh.id); } catch (_e) { /* private mode */ }
+    } catch (_e) { /* fall through to in-memory reset */ }
     sessionId = null;
     messages = [];
     saveState();
     rerenderHistory();
-    try {
-      fetch('/api/cc-sessions/' + encodeURIComponent(tabId), { method: 'DELETE' }).catch(function() {});
-    } catch (_e) { /* ignore */ }
+    renderTabBar();
     inputEl.focus();
   }
 

package/dashboard/slim/js/history.js

@@ -484,11 +484,43 @@
     listEl.replaceChildren(frag);
   }
 
+  // /api/status was slimmed to the small engine/throttle/version envelope
+  // (issue #2949) — the heavy slices the cockpit needs (dispatch, agents,
+  // pull requests, pinned, watches) moved to dedicated endpoints. The slim
+  // poll therefore has to gather those alongside /api/status and merge them
+  // into one snapshot before applyStatus(), or every tile reads `undefined`
+  // and the dashboard never reflects work in flight.
+  async function _slimFetchJson(url) {
+    var res = await fetch(url, { headers: { 'Accept': 'application/json' } });
+    if (!res.ok) throw new Error('HTTP ' + res.status);
+    return res.json();
+  }
+  // Resolve to `fallback` instead of rejecting, so one transient endpoint
+  // error doesn't blank the whole cockpit — we keep the last-known slice.
+  function _slimSettle(url, fallback) {
+    return _slimFetchJson(url).then(function(v) { return v; }, function() { return fallback; });
+  }
+
   async function pollStatusOnce() {
+    var prev = lastStatusData || {};
     try {
-      var res = await fetch('/api/status', { headers: { 'Accept': 'application/json' } });
-      if (!res.ok) throw new Error('HTTP ' + res.status);
-      var data = await res.json();
+      // /api/status is the only required fetch (drives the engine tile +
+      // timestamp); its rejection rejects the batch and we keep prior values.
+      // The slice endpoints fail soft to their previous value.
+      var results = await Promise.all([
+        _slimFetchJson('/api/status'),
+        _slimSettle('/api/dispatch', prev.dispatch),
+        _slimSettle('/api/agents', prev.agents),
+        _slimSettle('/api/pull-requests', prev.pullRequests),
+        _slimSettle('/api/pinned', prev.pinned),
+        _slimSettle('/state/engine/watches.json', prev.watches),
+      ]);
+      var data = results[0] || {};
+      data.dispatch = (results[1] && typeof results[1] === 'object') ? results[1] : {};
+      data.agents = Array.isArray(results[2]) ? results[2] : [];
+      data.pullRequests = Array.isArray(results[3]) ? results[3] : [];
+      data.pinned = Array.isArray(results[4]) ? results[4] : [];
+      data.watches = Array.isArray(results[5]) ? results[5] : [];
       applyStatus(data);
     } catch (e) {
       // Soft failure — leave previous values, surface in stamp

package/dashboard/slim/styles.css

@@ -247,6 +247,66 @@
       flex-direction: column;
       min-height: 0;
     }
+    /* Command Center tab bar — shared cc-tabs surfaced for parity with the
+       classic dashboard. Sits above the message pane. */
+    .chat-tabs {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      flex-wrap: wrap;
+      padding: 8px 12px 0;
+      width: 100%;
+      max-width: 800px;
+      margin-left: auto;
+      margin-right: auto;
+    }
+    .chat-tab {
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      max-width: 220px;
+      padding: 4px 6px 4px 10px;
+      border: 1px solid var(--border);
+      border-radius: 999px;
+      background: var(--surface2);
+      color: var(--muted);
+      font-size: var(--text-sm);
+      cursor: pointer;
+      white-space: nowrap;
+    }
+    .chat-tab.active {
+      color: var(--text);
+      border-color: var(--blue);
+      background: color-mix(in srgb, var(--blue) 14%, var(--surface2));
+    }
+    .chat-tab-label {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .chat-tab-close {
+      border: none;
+      background: transparent;
+      color: var(--muted);
+      cursor: pointer;
+      font-size: var(--text-md);
+      line-height: 1;
+      padding: 0 2px;
+      border-radius: 4px;
+    }
+    .chat-tab-close:hover { color: var(--red); background: var(--surface); }
+    .chat-tab-new {
+      border: 1px dashed var(--border);
+      background: transparent;
+      color: var(--muted);
+      cursor: pointer;
+      border-radius: 999px;
+      width: 26px;
+      height: 26px;
+      font-size: var(--text-md);
+      line-height: 1;
+    }
+    .chat-tab-new:hover { color: var(--text); border-color: var(--blue); }
     .chat-messages {
       flex: 1;
       overflow-y: auto;

package/package.json

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