@yemi33/minions 0.1.2438 → 0.1.2440

package/dashboard/js/command-center.js

@@ -760,6 +760,8 @@ function ccSwitchTab(id) {
   ccRenderTabBar();
   ccUpdateSessionIndicator();
   ccSaveState();
+  _ccRestoreQueue(tab);       // load persisted queue once (W-ms4o3gtm005z91c9)
+  _renderQueueIndicator();    // surface any in-memory queued bubbles for this tab
   var input = document.getElementById('cc-input');
   if (input) input.focus();
 }
@@ -914,6 +916,7 @@ function ccRestoreMessages() {
   var el = document.getElementById('cc-messages');
   var tab = _ccActiveTab();
   if (!tab) return;
+  _ccRestoreQueue(tab);
   if (el.children.length > 0) return;
   if (tab.messages.length === 0) {
     _ccRenderSuggestedPrompts();
@@ -1072,6 +1075,7 @@ async function ccSend(options) {
   if (tab._sending) {
     tab._queue.push({ message: message, intentMetadata: intentMetadata });
     _renderQueueIndicator();
+    ccQueueSave(originTabId, tab._queue);   // persist so the queue survives a refresh (W-ms4o3gtm005z91c9)
     return;
   }
   var wasAborted = await _ccDoSend(message, false, originTabId, intentMetadata);
@@ -1085,6 +1089,7 @@ async function ccSend(options) {
     var nextMessage = typeof next === 'string' ? next : next.message;
     var nextIntentMetadata = typeof next === 'string' ? null : (next.intentMetadata || null);
     _renderQueueIndicator();
+    ccQueueSave(originTabId, tab._queue);   // persist the post-drain remainder (W-ms4o3gtm005z91c9)
     wasAborted = await _ccDoSend(nextMessage, false, originTabId, nextIntentMetadata);
   }
 }
@@ -1107,6 +1112,24 @@ function _renderQueueIndicator() {
   if (msgs.scrollHeight - msgs.scrollTop - msgs.clientHeight < 150) msgs.scrollTop = msgs.scrollHeight;
 }
 
+// Restore a tab's persisted queued messages after a hard refresh / new session
+// (W-ms4o3gtm005z91c9). Loaded once per tab (guarded by _queueRestored). The
+// queue is restored as greyed 'queued' bubbles but is NOT auto-drained on load:
+// the existing drain loop only runs off the user's next ccSend, so restored
+// bubbles sit idle until the user acts (never silently auto-firing on reload).
+// No-op when the tab already has an in-memory queue (a live session).
+function _ccRestoreQueue(tab) {
+  if (!tab || !tab.id || tab._queueRestored) return;
+  tab._queueRestored = true;
+  ccQueueLoad(tab.id).then(function(loaded) {
+    if (!loaded || !loaded.length) return;
+    if (!tab._queue) tab._queue = [];
+    if (tab._queue.length) return;
+    for (var i = 0; i < loaded.length; i++) tab._queue.push(loaded[i]);
+    if (tab.id === _ccActiveTabId) _renderQueueIndicator();
+  });
+}
+
 async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
   // Client-side /pin and /unpin — no LLM round-trip needed
   var pinMatch = message.match(/^\/(pin|unpin)\s+(.+)/i);
@@ -1618,7 +1641,10 @@ function ccRetryLast(tabId, retryId) {
     while (retryTab && retryTab._queue && retryTab._queue.length > 0) {
       var next = retryTab._queue.shift();
       _renderQueueIndicator();
-      await _ccDoSend(next, false, retryTab.id);
+      ccQueueSave(retryTab.id, retryTab._queue);   // persist the post-drain remainder (W-ms4o3gtm005z91c9)
+      var retryMsg = typeof next === 'string' ? next : next.message;
+      var retryMeta = typeof next === 'string' ? null : (next.intentMetadata || null);
+      await _ccDoSend(retryMsg, false, retryTab.id, retryMeta);
     }
   });
 }

package/dashboard/js/command-input.js

@@ -74,7 +74,7 @@ function cmdKeyDown(e) {
       items[cmdMentionIdx]?.scrollIntoView({ block: 'nearest' });
       return;
     }
-    if (e.key === 'Enter' && !e.ctrlKey) {
+    if (e.key === 'Enter' && !isSendShortcutEvent(e)) {
       e.preventDefault();
       e.stopPropagation();
       const active = items[cmdMentionIdx >= 0 ? cmdMentionIdx : 0];
@@ -124,13 +124,30 @@ function cmdKeyDown(e) {
     }
   }
 
-  // Ctrl+Enter to submit
-  if (e.key === 'Enter' && e.ctrlKey) {
+  // Platform submit chord — Command+Enter on macOS, Ctrl+Enter elsewhere
+  if (isSendShortcutEvent(e)) {
     e.preventDefault();
     cmdSubmit();
   }
 }
 
+// Paint the send button's visible hint + accessible name with the platform
+// chord. The markup ships the Ctrl+Enter default so non-JS/pre-boot renders
+// still read correctly; this only rewrites it on macOS.
+function cmdApplySendShortcutHint() {
+  const btn = document.getElementById('cmd-send-btn');
+  if (!btn) return;
+  const kbd = document.getElementById('cmd-send-kbd');
+  if (kbd) kbd.textContent = sendShortcutLabel();
+  btn.setAttribute('aria-label', 'Send (' + sendShortcutAriaLabel() + ')');
+  btn.setAttribute('aria-keyshortcuts', sendShortcutAriaKeys());
+}
+
+if (typeof document !== 'undefined' && document.addEventListener) {
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', cmdApplySendShortcutHint);
+  else cmdApplySendShortcutHint();
+}
+
 async function cmdSubmit() {
   const input = document.getElementById('cmd-input');
   const raw = input.value.trim();

package/dashboard/js/render-work-items.js

@@ -432,30 +432,59 @@ async function archiveWorkItem(id, source) {
   } catch (e) { clearDeleted('wi:' + id); showToast('cmd-toast', 'Archive error: ' + e.message, false); refresh(); }
 }
 
+// The dashboard is an app-shell layout: html/body/.page-layout are all
+// overflow:hidden at a fixed height, so window.scrollY never moves and the only
+// scrollable ancestor is #page-content. "See Archive" therefore used to reveal a
+// panel that, on any work list taller than the fold, landed outside the scroll
+// viewport (measured at 1440x900: panel top 1072 in a 900px viewport) while the
+// trigger label stayed "See Archive". The handler ran, the API returned 200 and
+// the DOM really did change — but nothing a human could perceive did, so the
+// control looked dead.
+//
+// The repair is the disclosure contract itself, not a special case: the trigger
+// reports its own state, and revealing the panel brings it into view.
+function _setWiArchiveToggleState(expanded) {
+  const btn = document.getElementById('work-archive-toggle');
+  if (!btn) return;
+  btn.setAttribute('aria-expanded', expanded ? 'true' : 'false');
+  btn.textContent = expanded ? 'Hide Archive' : 'See Archive';
+}
+
 let wiArchiveVisible = false;
 async function toggleWorkItemArchive() {
   const el = document.getElementById('work-items-archive');
+  if (!el) return;
   wiArchiveVisible = !wiArchiveVisible;
+  _setWiArchiveToggleState(wiArchiveVisible);
   if (!wiArchiveVisible) { el.style.display = 'none'; return; }
   el.style.display = 'block';
   el.innerHTML = '<p class="empty">Loading archive...</p>';
   try {
     const items = await fetch('/api/work-items/archive').then(r => r.json());
-    if (!items.length) { el.innerHTML = '<p class="empty">No archived work items.</p>'; return; }
-    // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; all user data wrapped in escapeHtml() (fields: archived work item id/title/type/status/agent)
-    el.innerHTML = '<div style="font-size:var(--text-sm);color:var(--muted);margin-bottom:6px;font-weight:600;text-transform:uppercase;letter-spacing:0.5px">Archived (' + items.length + ')</div>' +
-      '<div class="pr-table-wrap"><table class="pr-table"><thead><tr><th>ID</th><th>Title</th><th>Type</th><th>Status</th><th>Agent</th><th>Archived</th></tr></thead><tbody>' +
-      items.map(function(i) {
-        return '<tr style="opacity:0.6">' +
-          '<td><span class="pr-id">' + escapeHtml(i.id || '') + '</span></td>' +
-          '<td style="min-width:240px;max-width:280px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' + escapeHtml(i.title || '') + '</td>' +
-          '<td><span class="dispatch-type ' + (i.type || '') + '">' + escapeHtml(i.type || '') + '</span></td>' +
-          '<td style="color:' + (i.status === 'done' ? 'var(--green)' : 'var(--red)') + '">' + escapeHtml(i.status || '') + '</td>' +
-          '<td>' + escapeHtml(i.dispatched_to || '—') + '</td>' +
-          '<td class="pr-date">' + shortTime(i.archivedAt) + '</td>' +
-        '</tr>';
-      }).join('') + '</tbody></table></div>';
+    if (!items.length) {
+      el.innerHTML = '<p class="empty">No archived work items.</p>';
+    } else {
+      // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; all user data wrapped in escapeHtml() (fields: archived work item id/title/type/status/agent)
+      el.innerHTML = '<div style="font-size:var(--text-sm);color:var(--muted);margin-bottom:6px;font-weight:600;text-transform:uppercase;letter-spacing:0.5px">Archived (' + items.length + ')</div>' +
+        '<div class="pr-table-wrap"><table class="pr-table"><thead><tr><th>ID</th><th>Title</th><th>Type</th><th>Status</th><th>Agent</th><th>Archived</th></tr></thead><tbody>' +
+        items.map(function(i) {
+          return '<tr style="opacity:0.6">' +
+            '<td><span class="pr-id">' + escapeHtml(i.id || '') + '</span></td>' +
+            '<td style="min-width:240px;max-width:280px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' + escapeHtml(i.title || '') + '</td>' +
+            '<td><span class="dispatch-type ' + (i.type || '') + '">' + escapeHtml(i.type || '') + '</span></td>' +
+            '<td style="color:' + (i.status === 'done' ? 'var(--green)' : 'var(--red)') + '">' + escapeHtml(i.status || '') + '</td>' +
+            '<td>' + escapeHtml(i.dispatched_to || '—') + '</td>' +
+            '<td class="pr-date">' + shortTime(i.archivedAt) + '</td>' +
+          '</tr>';
+        }).join('') + '</tbody></table></div>';
+    }
   } catch (e) { el.innerHTML = '<p class="empty">Failed to load archive.</p>'; }
+  // Scroll only after the panel has its final height, so a tall archive lands
+  // properly instead of being nudged into view while still showing "Loading".
+  // block:'nearest' scrolls the nearest scrollable ancestor (#page-content here)
+  // and is a no-op when the panel is already on screen, so tall viewports and
+  // short work lists are unaffected.
+  try { el.scrollIntoView({ block: 'nearest' }); } catch { /* older browsers */ }
 }
 
 async function retryWorkItem(id, source) {

package/dashboard/js/settings.js

@@ -1960,4 +1960,25 @@ window.MinionsSettings = { openSettings, saveSettings, addProject, removeProject
   } else {
     setTimeout(openWhenReady, 0);
   }
+  // FRESHNESS ON REOPEN (W-ms4ogdc800aa6931): the slim parent now CACHES this
+  // embedded /settings frame (created once, shown/hidden) instead of cold-booting
+  // it per open, so the iframe `load` — and thus the one-shot openSettings() boot
+  // above — fires only ONCE. Re-pull /api/settings + /api/features whenever the
+  // parent re-shows us (visible:true) so a value changed elsewhere isn't stale. A
+  // full openSettings() re-render is cheap here (the SPA is already booted — just
+  // two localhost fetches + a DOM render, no cold boot), so we prefer it over
+  // ad-hoc partial refresh. Reuses the SAME {source:'minions-slim-embed',
+  // type:'visibility'} channel refresh.js already honors (no second postMessage
+  // bus). Embed-mode gated by the isSettingsPath+isEmbed early return above, so a
+  // standalone /settings visit is completely unaffected.
+  try {
+    window.addEventListener('message', function(ev) {
+      if (!ev || ev.origin !== window.location.origin) return;
+      var d = ev.data;
+      if (!d || d.source !== 'minions-slim-embed' || d.type !== 'visibility') return;
+      if (d.visible && typeof openSettings === 'function') {
+        try { openSettings(); } catch (e) { /* transient — next show retries */ }
+      }
+    });
+  } catch (e) { /* defensive — never block the embed boot on this hook */ }
 })();

package/dashboard/js/utils.js

@@ -902,4 +902,32 @@ async function submitBugReport() {
   }
 }
 
-window.MinionsUtils = { wakeEngine, markDeleted, clearDeleted, escapeHtml, escHtml, renderMd, normalizePlanFile, timeAgo, statusColor, shouldIgnoreSelectionClick, llmCopyBtn, copyLlmText, openBugReport, submitBugReport };
+// ── Send-shortcut helpers (Classic UX) ──────────────────────────────────
+// macOS submits with Command+Enter; Windows/Linux keep Control+Enter. These are
+// the single source of truth for both the key handler and the visible hint so
+// the two can never drift apart.
+
+function isMacPlatform() {
+  try {
+    if (typeof navigator === 'undefined' || !navigator) return false;
+    var uaData = navigator.userAgentData;
+    var platform = String((uaData && uaData.platform) || navigator.platform || '');
+    if (/mac/i.test(platform)) return true;
+    return /Mac OS X|Macintosh/i.test(String(navigator.userAgent || ''));
+  } catch { return false; }
+}
+
+// True only for the platform submit chord. Shift/Alt and the non-platform
+// modifier are rejected so unrelated combinations never trigger a send.
+function isSendShortcutEvent(e) {
+  if (!e || e.key !== 'Enter') return false;
+  if (e.shiftKey || e.altKey) return false;
+  return isMacPlatform() ? (!!e.metaKey && !e.ctrlKey) : (!!e.ctrlKey && !e.metaKey);
+}
+
+function sendShortcutLabel() { return isMacPlatform() ? '⌘+Enter' : 'Ctrl+Enter'; }
+function sendShortcutAriaLabel() { return isMacPlatform() ? 'Command+Enter' : 'Control+Enter'; }
+// aria-keyshortcuts uses the DOM modifier names, so macOS reports "Meta".
+function sendShortcutAriaKeys() { return isMacPlatform() ? 'Meta+Enter' : 'Control+Enter'; }
+
+window.MinionsUtils = { wakeEngine, markDeleted, clearDeleted, escapeHtml, escHtml, renderMd, normalizePlanFile, timeAgo, statusColor, shouldIgnoreSelectionClick, llmCopyBtn, copyLlmText, openBugReport, submitBugReport, isMacPlatform, isSendShortcutEvent, sendShortcutLabel, sendShortcutAriaLabel, sendShortcutAriaKeys };

package/dashboard/pages/home.html

@@ -4,7 +4,7 @@
           <div class="cmd-highlight-layer" id="cmd-highlight" aria-hidden="true"></div>
           <textarea id="cmd-input" rows="1" placeholder='What do you need? e.g. "Fix the auth bug @dallas", "explain the dispatch flow", or "/note always use feature flags"'
             oninput="cmdInputChanged()" onkeydown="cmdKeyDown(event)" onscroll="syncHighlightScroll()" onpaste="cmdHandlePaste(event)"></textarea>
-          <button class="cmd-send-btn" id="cmd-send-btn" onclick="cmdSubmit()">Send <kbd>Ctrl+Enter</kbd></button>
+          <button class="cmd-send-btn" id="cmd-send-btn" onclick="cmdSubmit()" aria-label="Send (Control+Enter)" aria-keyshortcuts="Control+Enter">Send <kbd id="cmd-send-kbd">Ctrl+Enter</kbd></button>
         </div>
         <div class="cmd-mention-popup" id="cmd-mention-popup"></div>
         <div class="cmd-meta" id="cmd-meta" style="display:none"></div>

package/dashboard/pages/work.html

@@ -1,7 +1,7 @@
       <section id="work-items-section" style="overflow:visible">
         <h2>Work Items <span class="count" id="wi-count">0</span>
           <button class="btn-add" style="margin-left:8px" onclick="openCreateWorkItemModal()">+ New</button>
-          <button class="pr-pager-btn" style="font-size:var(--text-sm);padding:2px 8px;margin-left:4px" onclick="toggleWorkItemArchive()">See Archive</button>
+          <button id="work-archive-toggle" type="button" class="pr-pager-btn" style="font-size:var(--text-sm);padding:2px 8px;margin-left:4px" onclick="toggleWorkItemArchive()" aria-expanded="false" aria-controls="work-items-archive">See Archive</button>
           <span style="font-size:var(--text-sm);color:var(--muted);font-weight:400;text-transform:none;letter-spacing:0">tasks dispatched to agents — auto-created from PRDs or added manually</span>
         </h2>
         <div id="work-items-content"><p class="empty">No work items yet.</p></div>

package/dashboard/shared/cc-queue-store.js

@@ -0,0 +1,71 @@
+// dashboard/shared/cc-queue-store.js
+//
+// Shared client helper to persist a Command Center tab's undrained queued
+// (follow-up) messages to SQLite so they survive a hard refresh / new browser
+// session (W-ms4o3gtm005z91c9). Used by BOTH the classic dashboard
+// (dashboard/js/command-center.js) and Slim (dashboard/slim/js/chat.js +
+// command-send.js) — do not fork this logic.
+//
+// The in-memory queue differs per surface: classic stores
+// { message, intentMetadata } objects on tab._queue; slim stores plain message
+// strings in queues[tabId]. Both normalize to { message, intentMetadata } for
+// the wire, and ccQueueLoad always hands back that object shape so each surface
+// can re-hydrate its own representation.
+//
+// Every helper is fire-and-forget and never throws: persistence is a
+// best-effort convenience, so a failed request must never break the live queue.
+
+function _ccQueueNormalizeEntry(entry) {
+  if (typeof entry === 'string') {
+    return entry ? { message: entry, intentMetadata: null } : null;
+  }
+  if (entry && typeof entry === 'object' && typeof entry.message === 'string' && entry.message) {
+    var meta = (entry.intentMetadata && typeof entry.intentMetadata === 'object'
+      && !Array.isArray(entry.intentMetadata)) ? entry.intentMetadata : null;
+    return { message: entry.message, intentMetadata: meta };
+  }
+  return null;
+}
+
+function _ccQueueUrl(tabId) {
+  return '/api/cc-sessions/' + encodeURIComponent(tabId) + '/queue';
+}
+
+// Replace the persisted queue for a tab with the current in-memory queue.
+// Accepts an array of strings and/or { message, intentMetadata } objects.
+function ccQueueSave(tabId, queue) {
+  if (!tabId) return Promise.resolve();
+  var messages = (Array.isArray(queue) ? queue : [])
+    .map(_ccQueueNormalizeEntry)
+    .filter(Boolean);
+  try {
+    return fetch(_ccQueueUrl(tabId), {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ messages: messages }),
+    }).catch(function() {});
+  } catch (_e) { return Promise.resolve(); }
+}
+
+// Load the persisted queue for a tab. Resolves to an array of
+// { message, intentMetadata } objects (empty array on any failure).
+function ccQueueLoad(tabId) {
+  if (!tabId) return Promise.resolve([]);
+  try {
+    return fetch(_ccQueueUrl(tabId))
+      .then(function(res) { return (res && res.ok) ? res.json() : null; })
+      .then(function(data) {
+        var arr = data && Array.isArray(data.messages) ? data.messages : [];
+        return arr.map(_ccQueueNormalizeEntry).filter(Boolean);
+      })
+      .catch(function() { return []; });
+  } catch (_e) { return Promise.resolve([]); }
+}
+
+// Clear the persisted queue for a tab.
+function ccQueueClear(tabId) {
+  if (!tabId) return Promise.resolve();
+  try {
+    return fetch(_ccQueueUrl(tabId), { method: 'DELETE' }).catch(function() {});
+  } catch (_e) { return Promise.resolve(); }
+}

package/dashboard/slim/js/chat.js

@@ -435,6 +435,7 @@
         var qq = _getQueue();
         qq.splice(i, 1);
         renderQueue();
+        ccQueueSave(tabId, qq);   // persist the shrunk queue (W-ms4o3gtm005z91c9)
       });
       row.appendChild(dismiss);
       queueEl.appendChild(row);
@@ -442,7 +443,23 @@
     scrollToBottom();
   }
 
-  // Render a tool invocation as a one-line string. `full` keeps the complete
+  // Restore a tab's persisted queued messages after a hard refresh / new
+  // session (W-ms4o3gtm005z91c9). The queue is restored as greyed 'queued'
+  // bubbles but auto-drain is SUSPENDED — the user resumes explicitly via the
+  // "Send queued (N)" control (mirrors the post-abort state), so a restored
+  // queue never silently auto-fires on page load. No-op when the tab already
+  // has an in-memory queue (a live session we must not clobber or duplicate).
+  function _restoreQueueFor(id) {
+    if (!id) return;
+    ccQueueLoad(id).then(function(loaded) {
+      if (!loaded || !loaded.length) return;
+      var q = queues[id] || (queues[id] = []);
+      if (q.length) return;
+      loaded.forEach(function(entry) { q.push(entry.message); });
+      queueSuspended[id] = true;
+      if (id === tabId) renderQueue();
+    });
+  }
   // command/args (used by the tool-calls modal); otherwise long values are
   // clipped for the collapsed 3-line panel.
   function formatTool(name, input, full) {
@@ -723,6 +740,7 @@
     renderTabBar();
     _refreshComposerUI();
     inputEl.focus();
+    _restoreQueueFor(id);
   }
 
   function closeSlimTab(id) {
@@ -755,3 +773,4 @@
   loadState();
   rerenderHistory();
   renderTabBar();
+  _restoreQueueFor(tabId);

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

@@ -44,6 +44,7 @@
   function _enqueue(text) {
     _getQueue().push(text);
     renderQueue();
+    ccQueueSave(tabId, _getQueue());   // persist so the queue survives a refresh (W-ms4o3gtm005z91c9)
   }
 
   // Promote the next queued message for the active tab.
@@ -58,6 +59,7 @@
     var q = queues[id];
     if (!q || !q.length) return;
     var next = q.shift();
+    ccQueueSave(id, q);   // persist the post-drain remainder (W-ms4o3gtm005z91c9)
     if (id === tabId) renderQueue();
     _performSend(next, id);
   }

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

@@ -19,6 +19,9 @@
     // card container. Guarded with typeof so the source-extracted unit-test copy
     // of this fn (which lacks the embed helpers/host) stays a safe no-op.
     if (typeof _pauseActiveEmbed === 'function') _pauseActiveEmbed();
+    // The Automation composite is likewise cached + kept mounted (W-ms4r1t5q…);
+    // hide it and suspend its tab iframes' pollers rather than tearing it down.
+    if (typeof _hideAutomationComposite === 'function') _hideAutomationComposite();
     var transient = document.getElementById('slim-tile-transient');
     if (transient) transient.textContent = '';
   }
@@ -133,6 +136,22 @@
     } catch (e) { /* defensive — same-origin means this should never throw */ }
   }
 
+  // Re-post a cached embed iframe's LIVE visibility once it has actually
+  // loaded. A visibility message posted BEFORE the iframe navigates lands on
+  // its throwaway about:blank document and is dropped when the real document
+  // replaces it — and the embedded classic SPA boots with its poll UNSUSPENDED
+  // (refresh.js `_embedPollSuspended = false`), so a frame that was hidden
+  // while still loading would poll /api/status every 4s forever in the
+  // background. `isVisible` is evaluated at LOAD time, not bind time, so the
+  // frame lands in whatever state the tile is in by then. Shared by every
+  // cached-iframe path (single-iframe embed tiles + Automation tabs).
+  function _bindEmbedVisibilityOnLoad(frame, isVisible) {
+    if (!frame || typeof frame.addEventListener !== 'function') return;
+    frame.addEventListener('load', function() {
+      _postEmbedVisibility(frame, !!isVisible());
+    });
+  }
+
   // Ensure the persistent host + transient containers exist inside the tile
   // modal body (created once, never wiped). Returns { host, transient }.
   function _ensureTileContainers() {
@@ -170,9 +189,7 @@
     frame.src = spec[0];
     frame.title = spec[1];
     frame.hidden = true;
-    frame.addEventListener('load', function() {
-      _postEmbedVisibility(frame, _activeEmbedKey === key);
-    });
+    _bindEmbedVisibilityOnLoad(frame, function() { return _activeEmbedKey === key; });
     containers.host.appendChild(frame);
     _embedFrames[key] = frame;
     return frame;
@@ -295,22 +312,58 @@
     _showReusableEmbed('prs');
   }
 
-  // Automation tile body — a tabbed composite (Watches · Schedules · Pipelines)
-  // that reuses the LITERAL classic dashboard screens (/watches, /schedule,
-  // /pipelines) instead of a slim-specific list, so there is one Automation UI,
-  // not two (W-mrz0x2a400030f90 / "reuse, don't fork" — mirrors renderPlansBody
-  // for the Plans tile and renderPrsBody for the PRs tile). Each tab embeds the
-  // real classic screen in an iframe with the chrome-off ?embed=1 mode; the
-  // iframed page IS the classic screen — full create/edit/pause/run + row
-  // actions, backed by the same /api/{watches,schedules,pipelines} endpoints —
-  // with zero duplicated rendering logic. Classic is reachable at each route
-  // even with slim-ux ON (only / is taken over). Iframes are LAZY: each tab's
-  // frame is mounted only on first activation (default Watches), so opening the
-  // modal never triple-loads all three screens. Built with createElement (no
+  // Persistent Automation composite (W-ms4r1t5q003h341a): the tabbed
+  // Watches·Schedules·Pipelines composite + its lazy iframes are built ONCE into
+  // #slim-tile-automation-host and shown/hidden across opens — mirroring the
+  // _embedFrames cache used by the single-iframe tiles — so reopening the
+  // Automation tile is an instant show, NOT a rebuild that cold-reloads all three
+  // classic screens into the wiped transient container. { activate, frames,
+  // activeKey } or null until first open.
+  var _automationComposite = null;
+
+  // Ensure the persistent Automation composite host exists inside the tile modal
+  // body (created once, never wiped). Sibling of #slim-tile-embed-host and
+  // #slim-tile-transient; shown only while the Automation tile is open.
+  function _ensureAutomationHost() {
+    var body = document.getElementById('slim-tile-body');
+    if (!body) return null;
+    var host = document.getElementById('slim-tile-automation-host');
+    if (!host) {
+      host = document.createElement('div');
+      host.id = 'slim-tile-automation-host';
+      host.className = 'slim-tile-automation-host';
+      host.hidden = true;
+      body.appendChild(host);
+    }
+    return host;
+  }
+
+  // Hide the cached Automation composite and suspend all its embedded tab
+  // pollers. A hidden (display:none) iframe still reports visibilityState
+  // 'visible', so without this the cached /watches·/schedule·/pipelines screens
+  // would keep polling /api/status in the background forever (refresh.js honors
+  // the visibility message). Called when another tile opens and on modal close.
+  // Guarded/no-op before the composite is built.
+  function _hideAutomationComposite() {
+    var host = document.getElementById('slim-tile-automation-host');
+    if (host) host.hidden = true;
+    if (_automationComposite && _automationComposite.frames) {
+      Object.keys(_automationComposite.frames).forEach(function(k) {
+        if (typeof _postEmbedVisibility === 'function') _postEmbedVisibility(_automationComposite.frames[k], false);
+      });
+    }
+  }
+
+  // Build the tabbed Watches·Schedules·Pipelines composite ONCE into the
+  // persistent host. Returns { activate, frames, activeKey }. Each tab's iframe
+  // is LAZY (mounted only on first activation) and CACHED (kept mounted so
+  // reopening never rebuilds/reloads it). Hidden tabs' pollers are suspended via
+  // the same visibility message the single-iframe embeds use, so a cached-but-
+  // inactive tab isn't polling in the background. Built with createElement (no
   // innerHTML) to satisfy the dashboard no-unsanitized lint gate; tab buttons
   // reuse the shared .kn-tab pill primitive and carry role="tab"/aria-selected
   // for keyboard/AT parity with the Knowledge modal tabs.
-  function renderAutomationTileBody(body) {
+  function _buildAutomationComposite(host) {
     var TABS = [
       { key: 'watches',   label: 'Watches',   src: '/watches?embed=1' },
       { key: 'schedule',  label: 'Schedules', src: '/schedule?embed=1' },
@@ -327,6 +380,7 @@
     var btns = {};
     var panels = {};
     var frames = {};
+    var composite = { activate: null, frames: frames, activeKey: null };
 
     function activate(key) {
       TABS.forEach(function(t) {
@@ -343,11 +397,24 @@
           frame.className = 'slim-automation-embed';
           frame.src = t.src;
           frame.title = t.label;
+          // A visibility message posted before this frame navigates is dropped
+          // on about:blank, so re-post the live state once it has loaded —
+          // otherwise a tab hidden mid-load becomes a permanent background
+          // /api/status poller. Same contract as _getOrCreateEmbedFrame.
+          _bindEmbedVisibilityOnLoad(frame, function() {
+            return composite.activeKey === t.key && !host.hidden;
+          });
           panel.appendChild(frame);
           frames[t.key] = frame;
         }
+        // Suspend hidden cached frames' pollers; resume the shown one.
+        if (frames[t.key] && typeof _postEmbedVisibility === 'function') {
+          _postEmbedVisibility(frames[t.key], isActive);
+        }
       });
+      composite.activeKey = key;
     }
+    composite.activate = activate;
 
     TABS.forEach(function(t) {
       var btn = document.createElement('button');
@@ -371,9 +438,36 @@
       panes.appendChild(panel);
     });
 
-    body.appendChild(tablist);
-    body.appendChild(panes);
-    activate('watches');   // default to the Watches tab
+    host.appendChild(tablist);
+    host.appendChild(panes);
+    return composite;
+  }
+
+  // Automation tile body — a tabbed composite (Watches · Schedules · Pipelines)
+  // that reuses the LITERAL classic dashboard screens (/watches, /schedule,
+  // /pipelines) instead of a slim-specific list, so there is one Automation UI,
+  // not two (W-mrz0x2a400030f90 / "reuse, don't fork" — mirrors renderPlansBody
+  // for the Plans tile and renderPrsBody for the PRs tile). Each tab embeds the
+  // real classic screen in an iframe with the chrome-off ?embed=1 mode; the
+  // iframed page IS the classic screen — full create/edit/pause/run + row
+  // actions, backed by the same /api/{watches,schedules,pipelines} endpoints —
+  // with zero duplicated rendering logic. Classic is reachable at each route even
+  // with slim-ux ON (only / is taken over). The composite + its lazy iframes are
+  // CACHED in the persistent #slim-tile-automation-host and SHOWN/HIDDEN across
+  // opens (W-ms4r1t5q003h341a) rather than rebuilt into the wiped transient
+  // container — so reopening the tile is an instant show, not a rebuild that
+  // cold-reloads all three classic screens. Mirrors the _embedFrames reuse the
+  // single-iframe tiles already use. The `body` arg (transient) is intentionally
+  // ignored; the composite lives in its own persistent host.
+  function renderAutomationTileBody(/* body */) {
+    var host = _ensureAutomationHost();
+    if (!host) return;
+    if (!_automationComposite) {
+      _automationComposite = _buildAutomationComposite(host);
+    }
+    host.hidden = false;
+    // Reopen on the last-active tab (default Watches on first open).
+    _automationComposite.activate(_automationComposite.activeKey || 'watches');
   }
 
   // tile key -> { title, render }. Adding a tile is a one-line table edit.
@@ -423,6 +517,10 @@
     // into the transient container, so pause/hide any shown embed behind them.
     var isReusableEmbed = Object.prototype.hasOwnProperty.call(_EMBED_TILES, key);
     if (!isReusableEmbed) _pauseActiveEmbed();
+    // The Automation composite lives in its own persistent, cached host; hide it
+    // (suspending its tab iframes' pollers) whenever a different tile is shown.
+    // renderAutomationTileBody unhides + reactivates it when Automation opens.
+    if (key !== 'automation') _hideAutomationComposite();
     view.render(target, lastStatusData || {});
     modal.classList.add('open');
   }

package/dashboard/slim/js/settings.js

@@ -18,16 +18,44 @@
   // — two stacked "Settings" bars was the duplicate-menu-bar bug
   // (W-mrpbzke4000ie609). Closing is driven from the embedded modal's own close
   // X (wired below to the parent), plus backdrop-click and Escape.
-  function openSlimSettings() {
-    var modal = document.getElementById('slim-settings-modal');
+  // CACHED settings iframe (W-ms4ogdc800aa6931). The old code discarded the
+  // frame on close and appended a BRAND-NEW `/settings?embed=1` iframe on every
+  // open, so each open cold-booted the entire classic SPA + full Settings render
+  // (/api/settings + /api/features + per-agent runtime dropdowns + projects +
+  // routing, plus the SPA's 4s /api/status poll) — the multi-second stall. We
+  // now mirror the cockpit-tile reuse contract (modals-tiles.js
+  // #_getOrCreateEmbedFrame / _showReusableEmbed): create the frame ONCE, keep
+  // it mounted (hidden), and show/hide it. A single background boot replaces N
+  // per-open cold boots; while hidden the embedded SPA's poll is suspended via
+  // the shared {source:'minions-slim-embed',type:'visibility'} message
+  // (refresh.js honors it in embed mode) so the cached frame doesn't poll
+  // /api/status forever off-screen.
+  var _slimSettingsFrame = null;
+
+  // Create (once) the cached settings iframe and return it. Built with
+  // createElement (no innerHTML) to satisfy the dashboard no-unsanitized lint
+  // gate. Starts hidden; a load-time visibility message suspends its poll until
+  // it is shown. Because the frame is cached, its `load` handler fires exactly
+  // ONCE — so the close/Escape wiring is installed here and persists across all
+  // hide/show cycles.
+  function _getOrCreateSettingsFrame() {
+    if (_slimSettingsFrame) return _slimSettingsFrame;
     var body = document.getElementById('slim-settings-body');
-    if (!modal || !body) return;
-    body.textContent = '';
+    if (!body) return null;
+    body.textContent = '';   // drop the "Loading settings…" placeholder (once)
     var frame = document.createElement('iframe');
     frame.className = 'slim-settings-embed';
     frame.src = '/settings?embed=1';
     frame.title = 'Settings';
+    frame.hidden = true;
     frame.addEventListener('load', function() {
+      // Suspend/resume the embedded SPA poll to match current visibility. On a
+      // visible:true the embedded classic Settings also re-pulls /api/settings +
+      // /api/features (see dashboard/js/settings.js#bootSettingsEmbed) — the
+      // same single postMessage channel, no second bus.
+      var modal = document.getElementById('slim-settings-modal');
+      var shown = !!(modal && modal.classList.contains('open'));
+      if (typeof _postEmbedVisibility === 'function') _postEmbedVisibility(frame, shown);
       var frameDocument = frame.contentDocument;
       if (!frameDocument) return;
       // Capture before the classic modal handler so only the parent modal closes.
@@ -53,20 +81,50 @@
       }
     });
     body.appendChild(frame);
+    _slimSettingsFrame = frame;
+    return frame;
+  }
+
+  function openSlimSettings() {
+    var modal = document.getElementById('slim-settings-modal');
+    var frame = _getOrCreateSettingsFrame();
+    if (!modal || !frame) return;
+    frame.hidden = false;
+    // Resume the embedded SPA poll + trigger a fresh /api/settings+/api/features
+    // re-pull (freshness on reopen — the cached frame's `load` fired only once,
+    // so without this a value changed elsewhere would show stale).
+    if (typeof _postEmbedVisibility === 'function') _postEmbedVisibility(frame, true);
     modal.classList.add('open');
   }
 
   function closeSlimSettings() {
-    document.getElementById('slim-settings-modal').classList.remove('open');
+    var modal = document.getElementById('slim-settings-modal');
+    if (!modal) return;
+    // Keep the frame MOUNTED for an instant reopen; just hide it and suspend its
+    // poll (so the cached frame stops polling /api/status in the background).
+    if (_slimSettingsFrame) {
+      if (typeof _postEmbedVisibility === 'function') _postEmbedVisibility(_slimSettingsFrame, false);
+      _slimSettingsFrame.hidden = true;
+    }
+    modal.classList.remove('open');
   }
 
   (function bindSettingsUi() {
     var btn = document.getElementById('slim-settings-btn');
     var backdrop = document.getElementById('slim-settings-modal');
-    if (btn) btn.addEventListener('click', openSlimSettings);
+    if (btn) {
+      btn.addEventListener('click', openSlimSettings);
+      // PREDICTIVE prewarm: the first hover / focus / press of the gear boots the
+      // cached settings frame before the click lands, so the open is an instant
+      // show. Fires at most once (the frame is cached thereafter).
+      var predictivePrewarm = function() { _getOrCreateSettingsFrame(); };
+      btn.addEventListener('pointerenter', predictivePrewarm, { once: true });
+      btn.addEventListener('pointerdown', predictivePrewarm, { once: true });
+      btn.addEventListener('focus', predictivePrewarm, { once: true });
+    }
     // No outer close button: the embedded classic Settings modal's own close X
-    // (wired to the parent in openSlimSettings) is the single close affordance,
-    // alongside backdrop-click and Escape below (W-mrpbzke4000ie609).
+    // (wired to the parent in _getOrCreateSettingsFrame) is the single close
+    // affordance, alongside backdrop-click and Escape below (W-mrpbzke4000ie609).
     if (backdrop) {
       backdrop.addEventListener('click', function(ev) {
         if (ev.target === backdrop) closeSlimSettings();
@@ -78,6 +136,22 @@
     });
   })();
 
+  // Deferred prewarm: boot the cached settings frame AFTER the cockpit's own hot
+  // embed prewarm (modals-tiles.js schedules that at ~800ms) so it never competes
+  // with slim cockpit initial paint. Idle-callback when available, else a delayed
+  // timeout — either way it runs well after first paint. First open then becomes
+  // an instant show instead of a cold boot.
+  (function scheduleSettingsPrewarm() {
+    var warm = function() { try { _getOrCreateSettingsFrame(); } catch (e) { /* skip prewarm */ } };
+    try {
+      if (typeof requestIdleCallback === 'function') {
+        requestIdleCallback(function() { setTimeout(warm, 1200); }, { timeout: 4000 });
+      } else {
+        setTimeout(warm, 1600);
+      }
+    } catch (e) { /* no timers available — skip prewarm, first open cold-boots */ }
+  })();
+
   // POST a feature-flag toggle; throws on a non-2xx so callers can branch on
   // failure. Used by the one-click returnToClassicDashboard().
   async function postFeatureToggle(id, enabled) {

package/dashboard/slim/js/status.js

@@ -21,6 +21,10 @@
   // — only deltas from a previously-seen number trigger the fade, so opening
   // the dashboard doesn't animate every tile.
   var lastTileValues = Object.create(null);
+  // Last (count|detail|lit) signature painted onto the Automation cockpit tile,
+  // so applyStatus can skip a redundant updateTile on every 5s status poll when
+  // nothing changed (W-ms4r1t5q003h341a).
+  var _automationTileSig = null;
 
   // Apply lit-state and value/detail text to a tile.
   function updateTile(key, value, detail, lit) {
@@ -230,14 +234,19 @@
     // counts are not carried by the status poll, and the task explicitly
     // says not to invent new API calls just for the tile count. The detail
     // modal (renderAutomationTileBody) embeds all three classic screens.
+    // This runs on EVERY 5s status poll, so gate the updateTile DOM work
+    // (querySelectors + textContent + classList churn) behind a change-check —
+    // repaint only when the count / detail / lit-state actually changed
+    // (render-cache-busting parity with the classic dashboard's _changed()).
     var watches = Array.isArray(data.watches) ? data.watches : [];
     var activeWatches = watches.filter(function(w) { return w && w.status === 'active'; });
-    updateTile(
-      'automation',
-      activeWatches.length,
-      activeWatches.length ? 'monitoring' : 'no automation set',
-      activeWatches.length ? 'blue' : null
-    );
+    var autoDetail = activeWatches.length ? 'monitoring' : 'no automation set';
+    var autoLit = activeWatches.length ? 'blue' : null;
+    var autoSig = activeWatches.length + '|' + autoDetail + '|' + (autoLit || '');
+    if (_automationTileSig !== autoSig) {
+      _automationTileSig = autoSig;
+      updateTile('automation', activeWatches.length, autoDetail, autoLit);
+    }
 
     // ── Knowledge tile (Pinned Context + Notes + KB) ──────────────
     // Pinned count is live from the poll; notes/KB counts are fetched lazily

package/dashboard/slim/styles.css

@@ -797,11 +797,24 @@
        outranks the class rules (no !important needed). */
     .slim-tile-embed-host, .slim-tile-transient { display: block; }
     #slim-tile-embed-host iframe[hidden] { display: none; }
+    /* Cached slim Settings frame (W-ms4ogdc800aa6931): like the tile embeds it is
+       created once and shown/hidden rather than cold-booted per open. The
+       .slim-settings-embed class rule above sets display:block, which outranks
+       [hidden]'s UA display:none — so a hidden cached frame must be forced back
+       to none. The id+attr selector outranks the class rule (no !important). */
+    #slim-settings-body iframe[hidden] { display: none; }
     /* Automation tile (Watches · Schedules · Pipelines) — a tabbed composite
        inside the shared wide tile-modal. The tab bar sits above the embedded
        classic screen, so the iframe height leaves room for it (vs the padless
        full-height embeds above). Reuses the .kn-tab pill primitive. */
     .slim-automation-tabs { padding: 12px 16px 0; }
+    /* Persistent Automation composite host (W-ms4r1t5q003h341a): like the single-
+       iframe embed host above, the tabbed Watches·Schedules·Pipelines composite +
+       its lazy iframes are built once and shown/hidden across opens rather than
+       rebuilt (which would cold-reload all three classic screens on every open).
+       Hidden via the [hidden] attribute when another tile is shown. */
+    #slim-tile-automation-host[hidden] { display: none; }
+    #slim-tile-automation-host .slim-automation-panel[hidden] { display: none; }
     .slim-automation-embed {
       display: block; width: 100%; height: calc(100vh - 148px); min-height: 320px;
       border: 0; background: var(--bg);

package/dashboard-build.js

@@ -8,7 +8,7 @@ const shared = require('./engine/shared');
 const { safeRead } = shared;
 
 const MINIONS_DIR = __dirname;
-const DASHBOARD_SHARED_JS = ['pr-merge-state', 'pr-filters', 'cc-suggestions', 'model-display', 'watches-source', 'project-git-summary', 'welcome-popup'];
+const DASHBOARD_SHARED_JS = ['pr-merge-state', 'pr-filters', 'cc-suggestions', 'cc-queue-store', 'model-display', 'watches-source', 'project-git-summary', 'welcome-popup'];
 
 // ── Canonical classic-dashboard assembly manifest ──────────────────────────
 // Single source of truth, consumed by BOTH assemblers: buildDashboardHtml()

package/dashboard.js

@@ -11087,6 +11087,9 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const sessions = _filterCcTabSessions(raw);
       return sessions.filter(s => s.id !== id);
     });
+    // Evict any persisted queued messages for the closed tab (mirrors the
+    // in-memory tab._queue / queues[id] cleanup on both surfaces).
+    try { smallStateStore.clearCcQueue(id); } catch { /* SQL unavailable — best effort */ }
     // Sub-task C of W-mp2w003600196c51: tear down the persistent ACP worker
     // for this tab so we don't leak a Copilot process after the user closes
     // the tab. closeTab is a no-op when the pool has no entry for the tabId,
@@ -11095,6 +11098,56 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     return jsonReply(res, 200, { ok: true });
   }
 
+  // GET /api/cc-sessions/:id/queue — load a tab's persisted queued messages so
+  // the greyed-out 'queued' bubbles can be restored after a hard refresh
+  // (W-ms4o3gtm005z91c9). Read-only; returns { messages: [{message, intentMetadata}] }.
+  async function handleCCSessionQueueGet(req, res, match) {
+    const id = match?.[1];
+    if (!id) return jsonReply(res, 400, { error: 'id required' });
+    try {
+      ccApiValidation.validateCcSessionPathId(id);
+      const messages = smallStateStore.readCcQueue(id);
+      return jsonReply(res, 200, { messages });
+    } catch (e) {
+      if (apiValidation.isApiInputError(e)) return apiErrorReply(res, e, req);
+      return jsonReply(res, e.statusCode || 500, { error: e.message });
+    }
+  }
+
+  // PUT /api/cc-sessions/:id/queue — replace a tab's persisted queued messages.
+  // The client re-sends the full queue on every mutation (enqueue, dismiss,
+  // drain) so the persisted state always mirrors the live in-memory queue.
+  async function handleCCSessionQueuePut(req, res, match) {
+    const id = match?.[1];
+    if (!id) return jsonReply(res, 400, { error: 'id required' });
+    try {
+      ccApiValidation.validateCcSessionPathId(id);
+      const body = await readBody(req, { maxBytes: CC_IMAGE_REQUEST_MAX_BYTES });
+      ccApiValidation.validateCcQueueReplaceRequest(body);
+      const result = smallStateStore.replaceCcQueue(id, body.messages);
+      return jsonReply(res, 200, { ok: true, count: result.count });
+    } catch (e) {
+      if (apiValidation.isApiInputError(e)) return apiErrorReply(res, e, req);
+      return jsonReply(res, e.statusCode || 500, { error: e.message });
+    }
+  }
+
+  // DELETE /api/cc-sessions/:id/queue — clear a tab's persisted queued messages
+  // (e.g. after the queue fully drains). Bodyless.
+  async function handleCCSessionQueueDelete(req, res, match) {
+    const id = match?.[1];
+    if (!id) return jsonReply(res, 400, { error: 'id required' });
+    try {
+      ccApiValidation.validateCcSessionPathId(id);
+      ccApiValidation.validateNoRequestBody(req?.[REQUEST_BODY_CACHE]?.value);
+      smallStateStore.clearCcQueue(id);
+      return jsonReply(res, 200, { ok: true });
+    } catch (e) {
+      if (apiValidation.isApiInputError(e)) return apiErrorReply(res, e, req);
+      return jsonReply(res, e.statusCode || 500, { error: e.message });
+    }
+  }
+
   // Trigger a process-spawn + initialize + session/new (including MCP init)
   // in the background so the user's first message skips the ~18-21 s Copilot
   // cold-spawn. Runtime-gated: a no-op (200 skipped) when the pool is off, so
@@ -15931,6 +15984,9 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'GET', path: '/api/cc-sessions', desc: 'List CC session metadata for all tabs', handler: handleCCSessionsList },
     { method: 'POST', path: '/api/cc-sessions/warm', desc: 'Pre-warm the worker pool for a CC tab (process + MCP init, no LLM call). No-op when pool is off.', params: 'tabId', handler: handleCcSessionWarm },
     { method: 'DELETE', path: /^\/api\/cc-sessions\/([\w-]+)$/, template: '/api/cc-sessions/:id', desc: 'Delete a CC session by tab ID', handler: handleCCSessionDelete },
+    { method: 'GET', path: /^\/api\/cc-sessions\/([\w-]+)\/queue$/, template: '/api/cc-sessions/:id/queue', desc: 'Load a CC tab\'s persisted queued (undrained) messages', handler: handleCCSessionQueueGet },
+    { method: 'PUT', path: /^\/api\/cc-sessions\/([\w-]+)\/queue$/, template: '/api/cc-sessions/:id/queue', desc: 'Replace a CC tab\'s persisted queued (undrained) messages', params: 'messages[]', handler: handleCCSessionQueuePut },
+    { method: 'DELETE', path: /^\/api\/cc-sessions\/([\w-]+)\/queue$/, template: '/api/cc-sessions/:id/queue', desc: 'Clear a CC tab\'s persisted queued (undrained) messages', handler: handleCCSessionQueueDelete },
 
     // Schedules
     { method: 'POST', path: '/api/schedules/parse-natural', desc: 'Parse natural language schedule text into cron expression', params: 'text', handler: handleSchedulesParseNatural },

package/engine/api-contracts/cc-ops.js

@@ -98,10 +98,14 @@ module.exports = {
     'GET /api/cc-sessions',
     'POST /api/cc-sessions/warm',
     'DELETE /api/cc-sessions/<id>',
+    'GET /api/cc-sessions/<id>/queue',
+    'PUT /api/cc-sessions/<id>/queue',
+    'DELETE /api/cc-sessions/<id>/queue',
   ],
   bodyless: [
     'POST /api/command-center/new-session',
     'DELETE /api/cc-sessions/<id>',
+    'DELETE /api/cc-sessions/<id>/queue',
   ],
   overrides: {
     'GET /api/cc-sessions': { noInput: true },
@@ -215,5 +219,57 @@ module.exports = {
         { strategy: 'send-unexpected-body', expectedStatus: 400 },
       ],
     },
+    'GET /api/cc-sessions/<id>/queue': {
+      audit: 'audited',
+      path: {
+        policy: 'required',
+        fields: [
+          { name: 'id', type: 'string', required: true, maxLength: CC_API_LIMITS.tabIdMaxChars },
+        ],
+      },
+      query: { policy: 'none', fields: [] },
+      headers: { policy: 'none', fields: [] },
+    },
+    'PUT /api/cc-sessions/<id>/queue': {
+      audit: 'audited',
+      path: {
+        policy: 'required',
+        fields: [
+          { name: 'id', type: 'string', required: true, maxLength: CC_API_LIMITS.tabIdMaxChars },
+        ],
+      },
+      body: {
+        policy: 'required',
+        fields: [
+          {
+            name: 'messages',
+            type: 'array',
+            required: true,
+            maxItems: CC_API_LIMITS.queueMaxMessages,
+            itemType: {
+              type: 'object',
+              fields: [
+                { name: 'message', type: 'string', required: true, maxLength: CC_API_LIMITS.messageMaxChars },
+                { name: 'intentMetadata', type: 'object', required: false, maxBytes: CC_API_LIMITS.metadataMaxBytes },
+              ],
+            },
+          },
+        ],
+      },
+      negativeTests: commonNegativeTests,
+    },
+    'DELETE /api/cc-sessions/<id>/queue': {
+      audit: 'audited',
+      path: {
+        policy: 'required',
+        fields: [
+          { name: 'id', type: 'string', required: true, maxLength: CC_API_LIMITS.tabIdMaxChars },
+        ],
+      },
+      negativeTests: [
+        { strategy: 'use-oversized-path-id', expectedStatus: 400 },
+        { strategy: 'send-unexpected-body', expectedStatus: 400 },
+      ],
+    },
   },
 };

package/engine/cc-api-validation.js

@@ -26,6 +26,7 @@ const CC_API_LIMITS = Object.freeze({
   imageFilenameMaxChars: 255,
   imageMaxCount: 4,
   imageMaxDecodedBytes: 5 * 1024 * 1024,
+  queueMaxMessages: 50,
 });
 
 const TRANSCRIPT_ROLES = Object.freeze(['user', 'assistant', 'action', 'system']);
@@ -346,6 +347,58 @@ function validateCcSessionPathId(id) {
   return validateTabId(id, { required: true, path: ['path', 'id'] });
 }
 
+// PUT /api/cc-sessions/:id/queue — replace a tab's persisted queued messages.
+// Body shape: { messages: [{ message: string, intentMetadata?: object }, ...] }.
+// The queue is bounded so a client cannot persist an unbounded blob.
+function validateCcQueueReplaceRequest(body) {
+  validateBody(body);
+  apiValidation.validateArray(body.messages, {
+    field: 'messages',
+    path: ['body', 'messages'],
+    maxLength: CC_API_LIMITS.queueMaxMessages,
+  });
+  body.messages.forEach((entry, index) => {
+    const entryPath = ['body', 'messages', index];
+    apiValidation.validatePlainObject(entry, {
+      field: 'messages',
+      path: entryPath,
+    });
+    validateNonBlankString(entry.message, {
+      field: 'message',
+      path: [...entryPath, 'message'],
+      maxLength: CC_API_LIMITS.messageMaxChars,
+    });
+    if (entry.intentMetadata !== undefined && entry.intentMetadata !== null) {
+      apiValidation.validatePlainObject(entry.intentMetadata, {
+        field: 'intentMetadata',
+        path: [...entryPath, 'intentMetadata'],
+      });
+      let encoded;
+      try {
+        encoded = JSON.stringify(entry.intentMetadata);
+      } catch {
+        throwConstraint('intentMetadata must be JSON-serializable', {
+          field: 'intentMetadata',
+          path: [...entryPath, 'intentMetadata'],
+          rejectedValue: entry.intentMetadata,
+          expected: 'JSON-serializable plain object',
+        });
+      }
+      if (Object.keys(entry.intentMetadata).length > CC_API_LIMITS.metadataMaxKeys
+          || Buffer.byteLength(encoded || '', 'utf8') > CC_API_LIMITS.metadataMaxBytes) {
+        throwConstraint('intentMetadata is too large', {
+          field: 'intentMetadata',
+          path: [...entryPath, 'intentMetadata'],
+          rejectedValue: entry.intentMetadata,
+          expected: `plain object with at most ${CC_API_LIMITS.metadataMaxKeys} keys and ${CC_API_LIMITS.metadataMaxBytes} encoded bytes`,
+          extra: { max: CC_API_LIMITS.metadataMaxBytes },
+        });
+      }
+    }
+  });
+  return body;
+}
+
 function realPath(targetPath) {
   return fs.realpathSync.native ? fs.realpathSync.native(targetPath) : fs.realpathSync(targetPath);
 }
@@ -577,6 +630,7 @@ module.exports = {
   validateAbortRequest,
   validateCcWarmRequest,
   validateCcSessionPathId,
+  validateCcQueueReplaceRequest,
   validateDocChatRequest,
   validateDocChatWarmRequest,
   validateBrowserPresenceRequest,

package/engine/db/migrations/028-cc-queued-messages.js

@@ -0,0 +1,29 @@
+// engine/db/migrations/028-cc-queued-messages.js
+//
+// Persist each Command Center tab's undrained queued messages so they survive a
+// hard refresh / new browser session (W-ms4o3gtm005z91c9). The queue was
+// previously in-memory only (classic tab._queue, slim `queues[tabId]`).
+//
+// One row per queued message, keyed by (tab_id, position). `position` preserves
+// FIFO order; `intent_metadata` carries the optional classic {intentMetadata}
+// blob (slim entries are plain strings and store NULL). No backfill — there is
+// no legacy on-disk source for an in-memory-only queue.
+
+module.exports = {
+  version: 28,
+  description: 'cc_queued_messages — persist per-tab CC queued messages',
+  up(db) {
+    db.exec(`
+      CREATE TABLE cc_queued_messages (
+        tab_id           TEXT    NOT NULL,
+        position         INTEGER NOT NULL,
+        message          TEXT    NOT NULL,
+        intent_metadata  TEXT,
+        created_at       INTEGER NOT NULL,
+        PRIMARY KEY (tab_id, position)
+      );
+
+      CREATE INDEX idx_cc_queued_messages_tab ON cc_queued_messages(tab_id);
+    `);
+  },
+};

package/engine/small-state-store.js

@@ -746,6 +746,90 @@ function applyCcGlobalSessionMutation(mutator) {
   });
 }
 
+// ─── cc_queued_messages ──────────────────────────────────────────────────────
+// Persist a CC tab's undrained queued follow-up messages so they survive a hard
+// refresh (W-ms4o3gtm005z91c9). One row per message keyed by (tab_id, position);
+// `position` preserves FIFO order. Entry shape: { message, intentMetadata }
+// (slim enqueues plain strings → intentMetadata null).
+
+function _normalizeCcQueueEntry(entry) {
+  if (typeof entry === 'string') {
+    const message = entry;
+    return message ? { message, intentMetadata: null } : null;
+  }
+  if (entry && typeof entry === 'object' && typeof entry.message === 'string' && entry.message) {
+    const intentMetadata = (entry.intentMetadata && typeof entry.intentMetadata === 'object'
+      && !Array.isArray(entry.intentMetadata))
+      ? entry.intentMetadata
+      : null;
+    return { message: entry.message, intentMetadata };
+  }
+  return null;
+}
+
+function readCcQueue(tabId) {
+  if (!tabId) return [];
+  const { getDb } = require('./db');
+  const rows = getDb()
+    .prepare('SELECT message, intent_metadata FROM cc_queued_messages WHERE tab_id = ? ORDER BY position')
+    .all(String(tabId));
+  const out = [];
+  for (const row of rows) {
+    let intentMetadata = null;
+    if (row.intent_metadata != null) {
+      try {
+        const parsed = JSON.parse(row.intent_metadata);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) intentMetadata = parsed;
+      } catch { /* malformed — drop metadata, keep message */ }
+    }
+    out.push({ message: row.message, intentMetadata });
+  }
+  return out;
+}
+
+function replaceCcQueue(tabId, messages) {
+  if (!tabId) return { wrote: false, count: 0 };
+  const { getDb, withTransaction } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`small-state-store: SQLite unavailable (${e.message})`); }
+
+  const normalized = (Array.isArray(messages) ? messages : [])
+    .map(_normalizeCcQueueEntry)
+    .filter(Boolean);
+
+  return withTransaction(db, () => {
+    db.prepare('DELETE FROM cc_queued_messages WHERE tab_id = ?').run(String(tabId));
+    const ins = db.prepare(`
+      INSERT INTO cc_queued_messages (tab_id, position, message, intent_metadata, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    const now = Date.now();
+    normalized.forEach((entry, position) => {
+      ins.run(
+        String(tabId),
+        position,
+        entry.message,
+        entry.intentMetadata ? JSON.stringify(entry.intentMetadata) : null,
+        now,
+      );
+    });
+    return { wrote: true, count: normalized.length };
+  });
+}
+
+function clearCcQueue(tabId) {
+  if (!tabId) return { wrote: false };
+  const { getDb, withTransaction } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`small-state-store: SQLite unavailable (${e.message})`); }
+  return withTransaction(db, () => {
+    const info = db.prepare('DELETE FROM cc_queued_messages WHERE tab_id = ?').run(String(tabId));
+    return { wrote: (info && info.changes > 0) || false };
+  });
+}
+
 // ─── doc_sessions ──────────────────────────────────────────────────────────
 // Shape: { [filePath]: { sessionId, lastActiveAt, turnCount, ... } }
 // SQL:   row per filePath key.
@@ -837,6 +921,10 @@ module.exports = {
   applyCcSessionsMutation,
   readCcGlobalSession,
   applyCcGlobalSessionMutation,
+  // cc_queued_messages
+  readCcQueue,
+  replaceCcQueue,
+  clearCcQueue,
   // doc_sessions
   readDocSessions,
   applyDocSessionsMutation,

package/package.json

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

package/playbooks/_pr-description-audit.md

@@ -73,6 +73,20 @@ on the OPG `Visual evidence capture` CI bot (that bot stays as-is; this is
 additive PR-body evidence). When the existing description already embeds
 `![alt](url)` refs for a view this dispatch touched, refresh them the same way.
 
+**MANDATORY GATE — UI-surface diffs REQUIRE screenshots.** Screenshot capture +
+embed is a **required completion gate**, not a nicety, for any dispatch whose diff
+modifies a **rendered UI surface** — e.g. files under `dashboard/`,
+`dashboard/slim/`, `dashboard/pages/`, `dashboard/js/`, `dashboard/styles.css`, or
+ANY change that alters what a dashboard page/route renders
+(layout/CSS/markup/new UI). For such a diff you **MUST** capture and embed AFTER
+screenshots (BEFORE/AFTER for visual FIXES, AFTER-only for NEW UI) for the PR to be
+considered complete. Omitting screenshots on a UI-surface diff **without a recorded
+hard-failure reason makes the PR incomplete** — "I judged it not visual enough" is
+**NOT** a valid skip when the diff touches those paths. The ONLY legitimate skips are
+genuine hard failures: the dev server will not start after a real attempt, Playwright
+MCP is unavailable, the route 404s, or upload/attachment auth fails. Record any such
+skip in `meta.descriptionAudit.result` as `screenshots-skipped (<specific-reason>)`.
+
 **Scope guard — which changes get screenshots.** Only meaningful visual/UI
 changes: dashboard pages, slim-ux, Settings, work-item/PR/plan views, badges,
 layout/CSS. Skip backend-only, engine-logic, text/prose-only, analysis, and

package/playbooks/build-fix-complex.md

@@ -135,7 +135,7 @@ After you push commits to the PR's source branch and BEFORE you mark the work it
 
 **Out-of-scope guardrails**
 
-- Only screenshot **meaningful visual/UI changes** (dashboard pages, slim-ux, Settings, work-item/PR/plan views, badges, layout/CSS); skip backend/engine/text/analysis/docs changes. When a build fix does touch a visual surface, proactively capture + embed via the release-asset recipe in `_pr-description-audit.md` (BEFORE/AFTER for fixes, AFTER-only for new UI).
+- Only screenshot **meaningful visual/UI changes** (dashboard pages, slim-ux, Settings, work-item/PR/plan views, badges, layout/CSS); skip backend/engine/text/analysis/docs changes. **MANDATORY GATE:** when a build fix's diff touches a **rendered UI surface** (files under `dashboard/`, `dashboard/slim/`, `dashboard/pages/`, `dashboard/js/`, `dashboard/styles.css`, or anything that alters what a dashboard page/route renders), you **MUST** capture + embed AFTER screenshots (BEFORE/AFTER for fixes, AFTER-only for new UI) via the release-asset recipe in `_pr-description-audit.md` for the PR to be complete — "not visual enough" is NOT a valid skip on those paths; only a recorded hard failure (dev server won't start, Playwright MCP unavailable, route 404s, upload auth fails) justifies skipping, recorded in `meta.descriptionAudit.result` as `screenshots-skipped (<specific-reason>)`.
 - Don't rewrite description prose beyond the targeted stale edits.
 - Don't modify the PR title; don't toggle draft state, close/reopen the PR.
 - Don't post a separate PR comment summarizing the description change.

package/playbooks/fix.md

@@ -172,6 +172,8 @@ After you push commits to the PR's source branch and BEFORE you mark the work it
 
 For a PR that contains a **meaningful visual/UI change**, proactively CAPTURE screenshots and EMBED them directly in the PR description — do NOT rely only on the OPG `Visual evidence capture` CI bot (it stays as-is; this is additive PR-body evidence). When the description already embeds `![alt](url)` refs for a view this dispatch touched, refresh them the same way.
 
+**MANDATORY GATE — UI-surface diffs REQUIRE screenshots.** Screenshot capture + embed is a **required completion gate**, not a nicety, for any dispatch whose diff modifies a **rendered UI surface** — e.g. files under `dashboard/`, `dashboard/slim/`, `dashboard/pages/`, `dashboard/js/`, `dashboard/styles.css`, or ANY change that alters what a dashboard page/route renders (layout/CSS/markup/new UI). For such a diff you **MUST** capture and embed AFTER screenshots (BEFORE/AFTER for visual FIXES, AFTER-only for NEW UI) for the PR to be considered complete. Omitting screenshots on a UI-surface diff **without a recorded hard-failure reason makes the PR incomplete** — "I judged it not visual enough" is **NOT** a valid skip when the diff touches those paths. The ONLY legitimate skips are genuine hard failures: the dev server will not start after a real attempt, Playwright MCP is unavailable, the route 404s, or upload/attachment auth fails. Record any such skip in `meta.descriptionAudit.result` as `screenshots-skipped (<specific-reason>)`.
+
 **Scope guard — which changes get screenshots.** Only meaningful visual/UI changes: dashboard pages, slim-ux, Settings, work-item/PR/plan views, badges, layout/CSS. Skip backend-only, engine-logic, text/prose-only, analysis, and docs changes — those get NO screenshots (they add no signal). BEFORE/AFTER pair for layout/visual FIXES; AFTER-only for NEW UI.
 
 1. If the project has a runnable dev server (detect via `package.json` scripts named `dev`, `start`, or `serve`) AND Playwright MCP is available, spin it up with a detached handoff per `shared-rules.md` → "Long-Running Commands" (record PID + log path + URL + stop command).

package/playbooks/implement.md

@@ -144,6 +144,8 @@ After you push commits to the PR's source branch and BEFORE you mark the work it
 
 For a PR that contains a **meaningful visual/UI change**, proactively CAPTURE screenshots and EMBED them directly in the PR description — do NOT rely only on the OPG `Visual evidence capture` CI bot (it stays as-is; this is additive PR-body evidence). When the description already embeds `![alt](url)` refs for a view this dispatch touched, refresh them the same way.
 
+**MANDATORY GATE — UI-surface diffs REQUIRE screenshots.** Screenshot capture + embed is a **required completion gate**, not a nicety, for any dispatch whose diff modifies a **rendered UI surface** — e.g. files under `dashboard/`, `dashboard/slim/`, `dashboard/pages/`, `dashboard/js/`, `dashboard/styles.css`, or ANY change that alters what a dashboard page/route renders (layout/CSS/markup/new UI). For such a diff you **MUST** capture and embed AFTER screenshots (BEFORE/AFTER for visual FIXES, AFTER-only for NEW UI) for the PR to be considered complete. Omitting screenshots on a UI-surface diff **without a recorded hard-failure reason makes the PR incomplete** — "I judged it not visual enough" is **NOT** a valid skip when the diff touches those paths. The ONLY legitimate skips are genuine hard failures: the dev server will not start after a real attempt, Playwright MCP is unavailable, the route 404s, or upload/attachment auth fails. Record any such skip in `meta.descriptionAudit.result` as `screenshots-skipped (<specific-reason>)`.
+
 **Scope guard — which changes get screenshots.** Only meaningful visual/UI changes: dashboard pages, slim-ux, Settings, work-item/PR/plan views, badges, layout/CSS. Skip backend-only, engine-logic, text/prose-only, analysis, and docs changes — those get NO screenshots (they add no signal). BEFORE/AFTER pair for layout/visual FIXES; AFTER-only for NEW UI.
 
 1. If the project has a runnable dev server (detect via `package.json` scripts named `dev`, `start`, or `serve`) AND Playwright MCP is available, spin it up with a detached handoff per `shared-rules.md` → "Long-Running Commands" (record PID + log path + URL + stop command).

package/playbooks/shared-rules.md

@@ -208,6 +208,7 @@ Concretely:
 - Do not sleep or busy-wait for `mergeStatus`, `buildStatus`, or any ADO/GitHub API to flip from `running` to `passing`.
 - If you skipped local validation, say so in the completion JSON (e.g. `tests: skipped — relying on PR pipeline`) and still exit.
 - Holding a slot to watch a pipeline is wasted capacity; the engine has its own pipeline-monitoring path.
+- **Screenshots are a MANDATORY completion gate for UI-surface diffs.** Any PR whose diff changes a rendered dashboard/UI surface (files under `dashboard/`, `dashboard/slim/`, `dashboard/pages/`, `dashboard/js/`, `dashboard/styles.css`, or anything that alters what a page/route renders) MUST embed AFTER screenshots in the PR description (full recipe: `_pr-description-audit.md`) — skips are allowed only on a recorded hard failure (dev server won't start, Playwright MCP unavailable, route 404s, upload auth fails). Backend/engine/text/analysis/docs diffs get NO screenshots.
 
 ## Resolving Review Threads — No Silent Closures