@yemi33/minions 0.1.2447 → 0.1.2449

package/dashboard/docs/typography.md

@@ -57,7 +57,7 @@ two stay in lockstep.
 > token that breaks the "all px" rule and is explicitly allowlisted in
 > the tripwire.
 
-### 12px readability floor (W-mr3xgejt0008d3a5, W-mryzdch9000f069c)
+### 12px readability floor (W-mr3xgejt0008d3a5, W-mryzdch9000f069c, W-ms9bjrvu002gaf64)
 
 `--text-sm` was raised from an 11px base to **12px** so it clears the 12px
 readability floor in both stylesheets: classic renders it at `12 × 1.05 =
@@ -70,21 +70,74 @@ from `--text-xs` to `--text-sm`. **W-mryzdch9000f069c then bumped the
 remaining ~190 `--text-xs` *usages* across `dashboard/**`** (CSS rules,
 inline `style="font-size:var(--text-xs)"`, and JS template strings) to
 `--text-sm`, so almost all dashboard text now renders at or above the floor.
-The `--text-xs` token declaration itself is unchanged (still
-`calc(10px * var(--minions-text-scale))` in both stylesheets) — this was a
-usage migration, not a value change.
+**W-ms9bjrvu002gaf64 swept the six callsites that had drifted back in** (see
+"Why this list drifts" below). The `--text-xs` token declaration itself is
+unchanged (still `calc(10px * var(--minions-text-scale))` in both
+stylesheets) — every pass was a usage migration, not a value change.
 
-`--text-xs` is now retained at only these genuinely-dense chrome callsites,
-where 12px would clip or misalign a fixed-size component:
+#### Retention test
 
-- `.token-chart-labels span` — token-usage chart axis labels squeezed into
-  fixed `min-width:8px; max-width:24px` columns with `overflow:hidden`; 12px
-  would clip the labels.
-- `.qa-phase-arrow` — the decorative `→` separator glyph between QA phase
-  chips (a micro-glyph, not readable text).
+A callsite may keep `--text-xs` only when it is **not readable text**:
+
+1. a purely decorative glyph the user never reads — typically drawn from
+   CSS `content:` and/or marked `aria-hidden="true"`; or
+2. text inside a fixed-size box where 12px would clip or misalign it.
+
+Anything a user actually reads — labels, help prose, counts, state
+readouts — goes to `--text-sm`, even when it is small chrome.
+
+#### Retained callsites
+
+Verified against `dashboard/**` at W-ms9bjrvu002gaf64:
+
+| Callsite | Why it keeps `--text-xs` |
+| -------- | ------------------------ |
+| `.token-chart-labels span` (`styles.css:196`) | Rule 2 — token-usage chart axis labels squeezed into fixed `min-width:8px; max-width:24px` columns with `overflow:hidden`; 12px clips them. |
+| `.settings-rail-fold .fold-chevron::before` (`styles.css:1333`) | Rule 1 — the `▸` fold-disclosure glyph, drawn from CSS `content: '\25B8'` onto an `aria-hidden="true"` span. |
+| `.qa-phase-arrow` (`styles.css:1835`) | Rule 1 — the decorative `→` separator between QA phase chips (a micro-glyph, not readable text). |
+
+That is the complete list. Re-derive it at any time with:
+
+```bash
+git grep -n 'var(--text-xs)' -- dashboard/
+```
+
+Expect exactly four hits: the three rows above plus the `.text-xs` utility
+class declaration. (The `--text-xs:` *token* declarations in
+`dashboard/styles.css` and `dashboard/slim/styles.css` don't match
+`var(--text-xs)`, so they don't show up.) Any other hit is drift — either
+justify it against the retention test and add a row here, or move it to
+`--text-sm`.
 
 The `.text-xs` utility class (`.text-xs { font-size: var(--text-xs); }`)
-stays declared as the token's escape hatch but currently has no callsites.
+stays declared as the token's escape hatch and still has **no callsites** —
+re-verified repo-wide at W-ms9bjrvu002gaf64 (no `class="text-xs"`,
+`classList`, or `className` reference in any `.css` / `.html` / `.js`).
+`dashboard/slim/` declares `--text-xs` but never uses it.
+
+#### Why this list drifts
+
+The tripwire (`test/unit/dashboard-font-size-tokens.test.js`) enforces "no
+raw `Npx` font-size" — it does **not** enforce *which* token a selector
+picks. So `--text-xs` silently re-enters `dashboard/**` whenever new UI
+copies a nearby rule, and nothing fails CI. W-ms9bjrvu002gaf64 found six
+such callsites: three merged in parallel with the W-mryzdch9000f069c sweep
+and so were never in its diff (#916, #944, #982), and three landed after it
+(#979, #1027, #1066). All six failed the retention test and moved to
+`--text-sm`:
+
+| Callsite | Arrived in | Why it moved |
+| -------- | ---------- | ------------ |
+| `.model-combo-label` | #916 | The model label a user reads in the Command Center / Settings model picker. |
+| `.settings-rail-fold .match-count` | #982 | Its own sibling `.settings-rail-btn .match-count` was already `--text-sm` with otherwise identical declarations. |
+| `.settings-tile-state` | #979 | The visible `ON` / `OFF` readout on the auto-fix gate tiles. |
+| `.settings-section-head .settings-section-num` | #1066 | Step numerals in the "Plan & PR Workflow" badges; the 22px circle has room for 12px. |
+| Per-project "Create PRs as draft" help `<div>` (`js/settings.js`) | #944 | Multi-sentence help prose — and it rendered smaller than its own `--text-sm` label. |
+| Codex "CC sandbox" security help `<div>` (`js/settings.js`) | #1027 | Same pattern: explanatory prose below a `--text-sm` label. |
+
+When adding dense chrome, reach for `--text-sm` first. `--text-xs` is a
+last resort that needs a retention-test justification and a row in the
+table above.
 
 The `--text-sm` selectors already on the token (`.table th`, `.pr-table th`,
 `.token-agent-table th`, `.status-badge`, `.sidebar-link`, slim

package/dashboard/js/command-center.js

@@ -271,7 +271,14 @@ function _ccBuildTranscript(tab) {
     // eslint-disable-next-line no-unsanitized/property -- reason: renderMd()/escHtml() produced persisted message HTML before this transcript text extraction (see dashboard/js/utils.js)
     tmp.innerHTML = html;
     var text = (tmp.textContent || tmp.innerText || '').trim();
-    if (text) out.push({ role: m.role, text: text });
+    if (text) {
+      // Bound each entry to the server's transcriptTextMaxChars so a
+      // previously-persisted oversized message (legacy history from before the
+      // client guard, or a cross-surface Slim write) cannot poison future sends
+      // as `body.transcript[N].text has an invalid length` (W-mscjjqdh).
+      if (window.MinionsCcLimits) text = window.MinionsCcLimits.boundTranscriptText(text);
+      out.push({ role: m.role, text: text });
+    }
   }
   return out.slice(-CC_TRANSCRIPT_MAX_TURNS);
 }
@@ -321,10 +328,19 @@ async function _ccDashboardHealth() {
   var controller = new AbortController();
   var timer = setTimeout(function() { controller.abort(); }, 3000);
   try {
-    var res = await fetch('/api/status', { signal: controller.signal, cache: 'no-store' });
+    // Probe the lightweight /api/health endpoint — NOT /api/status. During a
+    // long-running Command Center turn the ~2 KB /api/status snapshot rebuild
+    // competes for the event loop and can time out (or abort at our 3s budget)
+    // even though the dashboard process is perfectly alive and this very stream
+    // is still flowing. Reading a status timeout as "dashboard unreachable" is
+    // exactly the false "Dashboard connection lost — restart Minions" bug this
+    // guards against. /api/health does no status-cache rebuild and no per-agent
+    // file IO, so a fast 200 proves the process is live and able to service
+    // requests; it also carries dashboardStartedAt for restart detection.
+    var res = await fetch('/api/health', { signal: controller.signal, cache: 'no-store' });
     if (!(res && res.ok)) return { reachable: false, restarted: false };
     var data = await res.json().catch(function() { return null; });
-    var currentDashId = data && data.version ? data.version.dashboardStartedAt : null;
+    var currentDashId = data ? data.dashboardStartedAt : null;
     var knownDashId = window._lastStatus && window._lastStatus.version ? window._lastStatus.version.dashboardStartedAt : null;
     return {
       reachable: true,
@@ -1059,11 +1075,36 @@ function ccAddMessage(role, html, skipSave, targetTabId, meta) {
   return messageId;
 }
 
+// Show an actionable "message too long" validation notice for the given tab
+// WITHOUT persisting it (skipSave) — the notice is transient UI, not a turn, so
+// it never enters tab.messages and cannot itself poison the transcript. Renders
+// a centered system bubble in the active tab and always fires a toast so a
+// background-tab rejection is still surfaced (W-mscjjqdh).
+function _ccNotifyMessageTooLong(length, limit, tabId) {
+  var text = window.MinionsCcLimits
+    ? window.MinionsCcLimits.messageTooLongText(length, limit)
+    : 'Message is too long. Shorten it and send again — your text is still in the box.';
+  ccAddMessage('system', '<span style="color:var(--red)">' + escHtml(text) + '</span>', true, tabId || _ccActiveTabId);
+  showToast('cmd-toast', 'Message too long', false);
+}
+
 async function ccSend(options) {
   var intentMetadata = options && options.intentMetadata ? options.intentMetadata : null;
   var input = document.getElementById('cc-input');
   var message = input.value.trim();
   if (!message) return;
+
+  // Length guard BEFORE clearing the composer / queueing / rendering / persisting
+  // (W-mscjjqdh). An oversized message fails server validation as
+  // `body.message has an invalid length`, and — if persisted first — poisons
+  // every later send through the carried transcript. Reject it here and keep the
+  // rejected text in the composer so the user can trim and resend.
+  var lenCheck = window.MinionsCcLimits ? window.MinionsCcLimits.checkMessage(message) : { ok: true };
+  if (!lenCheck.ok) {
+    _ccNotifyMessageTooLong(lenCheck.length, lenCheck.limit, _ccActiveTabId);
+    return; // composer intentionally NOT cleared — text preserved for editing
+  }
+
   input.value = '';
 
   var tab = _ccActiveTab();
@@ -1155,6 +1196,19 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
   var activeTabId = forceTabId || _ccActiveTabId;
   var activeTab = _ccTabs.find(function(t) { return t.id === activeTabId; }) || _ccActiveTab();
   if (!activeTab) return;
+
+  // Defensive length guard for every path that reaches here bypassing the
+  // ccSend() composer check: queue drain, retry (ccRetryLast), programmatic
+  // sends, and a restored-localStorage queue (W-mscjjqdh). Never render, persist
+  // (addMsg → tab.messages), or POST an oversized message — it fails server
+  // validation and poisons the transcript for all later sends. Drop it with an
+  // actionable notice instead of looping on a message that can never succeed.
+  var guard = window.MinionsCcLimits ? window.MinionsCcLimits.checkMessage(message) : { ok: true };
+  if (!guard.ok) {
+    _ccNotifyMessageTooLong(guard.length, guard.limit, activeTabId);
+    return;
+  }
+
   // P-2a6d8e74 — snapshot + clear pending image attachments for this turn.
   // Only fresh user sends carry images (retries/programmatic sends set
   // skipUserMsg and reuse the already-dispatched text). v1 = current turn only.
@@ -1175,9 +1229,14 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
 
   if (!skipUserMsg) addMsg('user', escHtml(message) + _ccAttachmentBadge(sendImages.length));
 
-  // Remove queue indicator before processing (it'll be re-added if more queued)
-  var existingQueueEl = document.getElementById('cc-queue-indicator');
-  if (existingQueueEl) existingQueueEl.remove();
+  // NOTE: no queue-indicator teardown here on purpose. This used to remove a
+  // single `#cc-queue-indicator` element, a vestige of an older one-node design;
+  // that id has not existed since indicators became one `.cc-queue-item` node per
+  // queued message, so the call was a silent no-op. _renderQueueIndicator() clears
+  // every `.cc-queue-item` before re-rendering, so it solely owns their lifecycle.
+  // Re-adding a removal here would wipe the indicators the drain loop and retry
+  // path render for STILL-queued messages immediately before calling this
+  // function, hiding them for the whole in-flight request.
 
   var ccStartTime = Date.now();
   var reconnectAttempts = 0;
@@ -1343,7 +1402,7 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
         _ccReplayPending = false;
       }
       if (evt.type === 'chunk') {
-        // evt.segmentId (from engine/llm.js) marks distinct assistant text
+        // evt.segmentId (from engine/agents/llm.js) marks distinct assistant text
         // blocks; ccSegmentsApplyChunk falls back to a heuristic when it's
         // absent (Copilot pool path / live replay).
         ccSegmentsApplyChunk(segments, evt.text || '', evt.segmentId);

package/dashboard/js/detail-panel.js

@@ -10,6 +10,42 @@ function closeDetail() {
   stopLiveStream();
 }
 
+// Shared predicate: Escape must NOT dismiss the panel while the user is typing
+// in an editable field, matching the deliberate exemption in dashboard/js/modal.js
+// (INPUT / TEXTAREA / contentEditable). The panel hosts editable fields — the
+// charter <textarea> (renderCharterEditor, scope 'detail') and the
+// <input id="live-steer-input"> — so without this guard Escape would discard an
+// unsaved charter draft or a typed steering message unrecoverably. Declared as a
+// function declaration so it hoists across the concatenated global dashboard
+// script and is reachable from the slim twin handler in
+// dashboard/slim/panel-bootstrap.js (single source of truth, no forked copy).
+function isEditableEventTarget(ev) {
+  var t = ev && ev.target;
+  if (t && t.tagName) {
+    var tag = String(t.tagName).toUpperCase();
+    if (tag === 'INPUT' || tag === 'TEXTAREA' || t.isContentEditable) return true;
+  }
+  return false;
+}
+
+// W-ms24qw0n — Esc closes the bespoke agent detail slide-in panel. The panel is
+// NOT part of the #modal stack, so modal.js's Escape handler never reaches it.
+// Only act when #detail-panel is open, so a closed panel is a no-op and the
+// modal.js handler (and any other Escape listener) still runs. Registered once
+// at module load with a double-registration guard. Mirrors the slim-UX parity
+// handler in dashboard/slim/panel-bootstrap.js.
+if (typeof document !== 'undefined' && typeof document.addEventListener === 'function' && !window.__minionsDetailEscBound) {
+  window.__minionsDetailEscBound = true;
+  document.addEventListener('keydown', function(ev) {
+    if (ev.key !== 'Escape' && ev.keyCode !== 27) return;
+    if (isEditableEventTarget(ev)) return;
+    var panel = document.getElementById('detail-panel');
+    if (panel && panel.classList.contains('open')) {
+      closeDetail();
+    }
+  });
+}
+
 function renderDetailTabs(detail) {
   const isWorking = detail.statusData?.status === 'working';
   const tabs = [

package/dashboard/js/memory-panel.js

@@ -26,6 +26,36 @@ const MEMORY_SPARKLINE_WINDOW_MS = 60 * 60 * 1000; // 1 hour
 let _memoryPanelLiveInterval = null;
 let _memoryPanelHistoryInterval = null;
 let _memoryPanelMounted = false;
+// Embed-mode suspend (W-ms4odb8h009a5d16). When the /engine screen is embedded
+// in the slim cockpit's Engine tile (?embed=1) its iframe is kept mounted but
+// hidden; without an explicit signal these two diagnostics pollers would run
+// forever in the background, contending with the slim cockpit's own polling.
+// The slim visibility bridge (dashboard/js/refresh.js) calls suspend/resume as
+// the iframe is hidden/shown. A normal classic /engine visit is NOT embed mode,
+// so it eager-mounts and never suspends — behavior there is unchanged.
+let _memoryPanelSuspended = false;
+
+function _memIsEmbed() {
+  try { return document.documentElement.classList.contains('embed'); } catch (e) { return false; }
+}
+
+function _memStartIntervals() {
+  _memRefreshLive();
+  _memRefreshHistory();
+  _memoryPanelLiveInterval = setInterval(_memRefreshLive, MEMORY_POLL_LIVE_MS);
+  _memoryPanelHistoryInterval = setInterval(_memRefreshHistory, MEMORY_POLL_HISTORY_MS);
+}
+
+function _memStopIntervals() {
+  if (_memoryPanelLiveInterval) {
+    clearInterval(_memoryPanelLiveInterval);
+    _memoryPanelLiveInterval = null;
+  }
+  if (_memoryPanelHistoryInterval) {
+    clearInterval(_memoryPanelHistoryInterval);
+    _memoryPanelHistoryInterval = null;
+  }
+}
 
 function _memFmtBytes(n) {
   if (!Number.isFinite(n)) return '—';
@@ -278,24 +308,39 @@ function mountMemoryPanel() {
   // against partial DOM states during test harnesses).
   if (!document.getElementById('memory-panel-content')) return;
   _memoryPanelMounted = true;
-  _memRefreshLive();
-  _memRefreshHistory();
-  _memoryPanelLiveInterval = setInterval(_memRefreshLive, MEMORY_POLL_LIVE_MS);
-  _memoryPanelHistoryInterval = setInterval(_memRefreshHistory, MEMORY_POLL_HISTORY_MS);
   _memWireHeapSnapshotButton();
+  // Embed mode (slim Engine tile): defer the heavy pollers until the iframe is
+  // first SHOWN. The slim visibility bridge calls resumeMemoryPanel() on
+  // visibility:true, so even the cold boot inside the hidden iframe stays light.
+  // Classic direct /engine visits eager-mount below (unchanged).
+  if (_memIsEmbed()) {
+    _memoryPanelSuspended = true;
+    return;
+  }
+  _memStartIntervals();
 }
 
 function unmountMemoryPanel() {
   if (!_memoryPanelMounted) return;
   _memoryPanelMounted = false;
-  if (_memoryPanelLiveInterval) {
-    clearInterval(_memoryPanelLiveInterval);
-    _memoryPanelLiveInterval = null;
-  }
-  if (_memoryPanelHistoryInterval) {
-    clearInterval(_memoryPanelHistoryInterval);
-    _memoryPanelHistoryInterval = null;
-  }
+  _memoryPanelSuspended = false;
+  _memStopIntervals();
+}
+
+// Suspend/resume the diagnostics pollers without unmounting (embed-mode only).
+// Wired through the SAME slim→embed visibility message the /api/status poll
+// suspend uses (dashboard/js/refresh.js), so there is one visibility protocol,
+// not two. Idempotent and safe to call before mount.
+function suspendMemoryPanel() {
+  if (!_memoryPanelMounted || _memoryPanelSuspended) return;
+  _memoryPanelSuspended = true;
+  _memStopIntervals();
+}
+
+function resumeMemoryPanel() {
+  if (!_memoryPanelMounted || !_memoryPanelSuspended) return;
+  _memoryPanelSuspended = false;
+  _memStartIntervals();
 }
 
 // Register the lifecycle hooks against the canonical maps in state.js.
@@ -319,6 +364,8 @@ try {
 window.MinionsMemoryPanel = {
   mountMemoryPanel,
   unmountMemoryPanel,
+  suspendMemoryPanel,
+  resumeMemoryPanel,
   _buildSparkline: _memBuildSparkline,
   _captureHeapSnapshot: _memCaptureHeapSnapshot,
 };