@yemi33/minions 0.1.2431 → 0.1.2433

package/dashboard/js/refresh.js

@@ -1153,6 +1153,34 @@ let _lastStatusData = null;
 // fresh state anyway.
 let _refreshInFlight = false;
 
+// ── Embedded-in-slim polling suspend (W-ms3bbzry000i6612) ────────────────
+// The slim cockpit's Queued-work / Active-PRs (and engine/plans) tiles embed
+// this classic SPA in a chrome-off ?embed=1 iframe that is now CACHED and
+// kept mounted (shown/hidden) instead of cold-booted on every open. A hidden
+// (display:none) iframe still reports document.visibilityState === 'visible',
+// so without an explicit signal this embedded SPA would keep polling
+// /api/status every 4s in the background forever — trading a per-open cold
+// boot for N permanent background pollers. The slim parent posts
+// {source:'minions-slim-embed', type:'visibility', visible} whenever it
+// shows/hides the iframe; we suspend the poll while hidden and resume (with an
+// immediate refresh for freshness) on show. Installed ONLY in embed mode, so
+// standalone /work, /prs, /engine, /plans, /settings are 100% unaffected.
+let _embedPollSuspended = false;
+(function _installSlimEmbedVisibilityBridge() {
+  try {
+    if (!document.documentElement.classList.contains('embed')) return;
+    window.addEventListener('message', function (ev) {
+      // Same-origin only — reject cross-origin/foreign frames.
+      if (!ev || ev.origin !== window.location.origin) return;
+      const d = ev.data;
+      if (!d || d.source !== 'minions-slim-embed' || d.type !== 'visibility') return;
+      _embedPollSuspended = !d.visible;
+      if (d.visible) { try { refresh(); } catch (e) { /* refresh not yet defined / transient */ } }
+    });
+  } catch (e) { /* defensive — never block boot on this bridge */ }
+})();
+
+
 // ── Dashboard-unreachable detector ───────────────────────────────────────
 // When the dashboard process dies, /api/status throws or 5xxs and the
 // existing catch block just console.errors — the page keeps painting the
@@ -1340,6 +1368,8 @@ async function refresh(opts) {
   // dashboard isn't hammered at the steady 4s cadence (which produces
   // console-spam and adds load to whatever's wedged).
   if (_nextPollAllowedAt && Date.now() < _nextPollAllowedAt) return;
+  // Embedded + hidden in the slim cockpit: skip polling (see the bridge above).
+  if (_embedPollSuspended) return;
   _refreshInFlight = true;
   const _t0 = Date.now();
   const _gap = _prevRefreshTs ? _t0 - _prevRefreshTs : null;

package/dashboard/js/render-other.js

@@ -33,6 +33,13 @@ function renderProjects(projects) {
 // a warning chip when branchMismatch (configured ≠ origin/HEAD) OR when the
 // local branch is behind main, and a compact "↑N ↓M" chip when ahead/behind
 // counts are non-zero.
+//
+// SEMANTICS SOURCE OF TRUTH: the branch/ahead-behind/dirty/main-drift semantics
+// below are mirrored (data-only, no HTML) in dashboard/shared/project-git-summary.js
+// so the Slim UX project-pill hover can render the SAME facts without forking
+// this HTML renderer (CLAUDE.md "no duplicate solutions"). Keep the two in sync;
+// this function stays the canonical HTML renderer (its unit tests extract it
+// standalone, so it deliberately does not call the shared helper).
 function _renderProjectBranch(p) {
   if (!p) return '';
   if (p.gitState === 'missing') return '<span class="project-warn" title="Project localPath does not exist on disk">(path not found)</span>';

package/dashboard/js/settings.js

@@ -272,15 +272,20 @@ async function openSettings() {
   const slimUxEnabled = slimUxFeature
     ? (slimUxFeature.enabled != null ? !!slimUxFeature.enabled : !!slimUxFeature.default)
     : false;
+  // W-ms25rsk2 — mirror the Font Size cell's vertical rhythm so the two
+  // Appearance controls read as a coherent pair: lead with an equivalent small
+  // muted label heading ('Slim UX'), then the checkbox row, then a matching
+  // muted description below. Previously this cell led straight with the flex
+  // checkbox row, so its title sat above the Font Size <label> and the toggle
+  // looked misaligned within the grid.
   const slimUxControl = slimUxFeature
     ? '<div data-search="slim ux appearance experimental cockpit">' +
-        '<label style="display:flex;align-items:flex-start;gap:8px;cursor:pointer">' +
-          '<input type="checkbox" data-feature-toggle="slim-ux"' + (slimUxEnabled ? ' checked' : '') + ' style="margin-top:3px;accent-color:var(--blue);width:16px;height:16px;cursor:pointer;flex-shrink:0">' +
-          '<span style="flex:1">' +
-            '<span style="font-size:var(--text-md);color:var(--text);display:block">Slim UX</span>' +
-            '<span style="font-size:var(--text-xs);color:var(--muted);display:block;margin-top:1px">Experimental focused single-screen cockpit. Persists immediately.</span>' +
-          '</span>' +
+        '<label style="font-size:var(--text-sm);color:var(--muted);display:block;margin-bottom:2px">Slim UX</label>' +
+        '<label style="display:flex;align-items:center;gap:8px;cursor:pointer">' +
+          '<input type="checkbox" data-feature-toggle="slim-ux"' + (slimUxEnabled ? ' checked' : '') + ' style="accent-color:var(--blue);width:16px;height:16px;cursor:pointer;flex-shrink:0">' +
+          '<span style="font-size:var(--text-md);color:var(--text)">Enable slim cockpit</span>' +
         '</label>' +
+        '<div style="font-size:var(--text-sm);color:var(--muted);margin-top:1px">Experimental focused single-screen cockpit. Persists immediately.</div>' +
       '</div>'
     : '';
   const paneAppearance =

package/dashboard/shared/project-git-summary.js

@@ -0,0 +1,239 @@
+// dashboard/shared/project-git-summary.js
+//
+// Pure, DOM-free summarizer of a /api/status project object's git + dispatch
+// state. This is the SINGLE source of truth for the *semantics* that the
+// classic Projects bar renders as HTML chips in dashboard/js/render-other.js
+// (_renderProjectBranch / _renderWorktreeModePill / _liveValidationTypesArray).
+// Slim UX loads this helper (it does NOT load render-other.js) to build the
+// project-pill hover panel without forking the classic branching logic
+// (CLAUDE.md "no duplicate solutions — reuse before re-implementing").
+//
+// It intentionally returns plain data only — no HTML, no escaping, no DOM — so
+// each surface renders it its own way (classic keeps its HTML chips; slim renders
+// a hover popover + a title-attribute fallback). Keep the field semantics in
+// lock-step with render-other.js; that file remains the canonical HTML renderer
+// and its unit tests (ahead-behind-badge-comparator-label.test.js,
+// dashboard-worktree-mode-pill.test.js) extract those functions standalone, so
+// they are deliberately NOT refactored to call this helper.
+
+// Mirrors render-other.js#_liveValidationTypesArray: normalize the single-string
+// legacy shape OR an array of strings into an array of non-empty strings.
+function _projectLiveValidationTypes(p) {
+  var raw = p && p.liveValidationType;
+  if (!raw) return [];
+  var arr = Array.isArray(raw) ? raw : [raw];
+  return arr.filter(function (t) { return typeof t === 'string' && t.length > 0; });
+}
+
+// Mirrors the checkout-mode classification in render-other.js#_renderWorktreeModePill.
+// Returns { kind, label, types, autoValidate, detail } where kind is one of
+// 'worktree' | 'live' | 'hybrid' | 'hybrid-invalid'.
+function _projectCheckoutMode(p) {
+  if (p && p.checkoutMode === 'live') {
+    var types = _projectLiveValidationTypes(p);
+    if (p.liveValidationInvalid) {
+      var effective = types.length > 0 ? types.join(', ') : 'none';
+      return {
+        kind: 'hybrid-invalid',
+        label: 'Hybrid · invalid',
+        types: types,
+        autoValidate: false,
+        detail: 'Invalid hybrid configuration — unsupported settings are ignored. '
+          + 'Effective live work-item types: ' + effective + '.',
+      };
+    }
+    if (types.length > 0) {
+      var typesText = types.join(', ');
+      var autoDispatch = p.liveValidationAutoDispatch === true;
+      return {
+        kind: 'hybrid',
+        label: 'Hybrid · ' + typesText + (autoDispatch ? ' · auto-validate' : ''),
+        types: types,
+        autoValidate: autoDispatch,
+        detail: 'Hybrid dispatch — only the "' + typesText + '" work-item type(s) run '
+          + 'in-place; all others use isolated worktrees. '
+          + (autoDispatch
+            ? 'A validation work item is dispatched automatically after each eligible coding work item.'
+            : 'Auto-validation is OFF — validation must be dispatched manually.'),
+      };
+    }
+    return {
+      kind: 'live',
+      label: 'Live checkout',
+      types: [],
+      autoValidate: false,
+      detail: 'Live-checkout dispatch — agents run in-place inside the project working '
+        + 'tree (no isolated worktree); capped to one mutating dispatch.',
+    };
+  }
+  return {
+    kind: 'worktree',
+    label: 'Worktrees',
+    types: [],
+    autoValidate: false,
+    detail: 'Worktree dispatch mode (default) — each agent runs in its own git worktree.',
+  };
+}
+
+// Summarize a single project object from GET /api/status.
+// Returns a plain object:
+//   {
+//     state,                 // 'missing'|'non-git'|'probe-timeout'|'stale'|'unknown'|'ok'
+//     available,             // true only when git branch data is present + fresh
+//     refreshing,            // true when the cached branch data is known-stale
+//     message,               // short label for non-ok/unavailable states (or null)
+//     branch, mainBranch, remoteDefaultBranch,
+//     detached, dirty,
+//     branchDiffersFromMain,
+//     ahead, behind, comparator, branchDiffersFromComparator, showAheadBehind,
+//     warn,                  // null | { kind:'main-drift'|'behind', text, detail }
+//     mode,                  // { kind, label, types, autoValidate, detail }
+//     lines,                 // [{ label, value }] ready-to-render rows
+//     warnings,              // [string] visible warning chips
+//     titleText,             // multi-fact "•"-joined string for a title= fallback
+//   }
+function summarizeProjectGit(p) {
+  var mode = _projectCheckoutMode(p || {});
+  var base = {
+    state: 'unknown',
+    available: false,
+    refreshing: false,
+    message: null,
+    branch: null,
+    mainBranch: null,
+    remoteDefaultBranch: null,
+    detached: false,
+    dirty: false,
+    branchDiffersFromMain: false,
+    ahead: null,
+    behind: null,
+    comparator: null,
+    branchDiffersFromComparator: false,
+    showAheadBehind: false,
+    warn: null,
+    mode: mode,
+    lines: [],
+    warnings: [],
+    titleText: '',
+  };
+
+  if (!p) return base;
+
+  // Non-ok git states — mirror the early returns of _renderProjectBranch.
+  if (p.gitState === 'missing') {
+    base.state = 'missing';
+    base.message = '(path not found)';
+    base.titleText = 'Project localPath does not exist on disk';
+    return base;
+  }
+  if (p.gitState === 'non-git') {
+    base.state = 'non-git';
+    base.message = '(not a git repo)';
+    base.titleText = 'Project path exists but is not a git repository';
+    return base;
+  }
+  if (p.gitState === 'probe-timeout') {
+    base.state = 'probe-timeout';
+    base.message = '(checking git…)';
+    base.titleText = 'Git status probe timed out (slow filesystem). The repository is valid and will refresh.';
+    return base;
+  }
+  if (p.gitState !== 'ok' || !p.gitBranch) {
+    // Nothing to show (classic returns an empty string here).
+    base.state = 'unknown';
+    return base;
+  }
+  if (p.gitStale) {
+    // Cached branch/dirty is known-stale — show a neutral refreshing state
+    // rather than a possibly-wrong branch name (parity with classic).
+    base.state = 'stale';
+    base.refreshing = true;
+    base.message = '(refreshing…)';
+    base.titleText = 'Branch changed outside the dashboard — refreshing…';
+    return base;
+  }
+
+  var branch = p.gitBranch;
+  var mainBranch = p.mainBranch || '';
+  var remoteDefault = p.remoteDefaultBranch || '';
+  var ahead = Number.isFinite(p.ahead) ? p.ahead : null;
+  var behind = Number.isFinite(p.behind) ? p.behind : null;
+  var branchDiffersFromMain = !!(mainBranch && branch !== mainBranch);
+  var comparator = mainBranch || remoteDefault;
+  // Comparator for ahead/behind is origin/<mainBranch || remoteDefaultBranch>
+  // (engine/queries.js _probeProjectGitStatus), never the branch's own upstream.
+  var comparatorRef = mainBranch || remoteDefault;
+  var branchDiffersFromComparator = !!(comparator && branch !== comparatorRef);
+  var showAheadBehind = ahead !== null && behind !== null && (ahead > 0 || behind > 0);
+
+  base.state = 'ok';
+  base.available = true;
+  base.branch = branch;
+  base.mainBranch = mainBranch || null;
+  base.remoteDefaultBranch = remoteDefault || null;
+  base.detached = !!p.gitDetached;
+  base.dirty = !!p.gitDirty;
+  base.branchDiffersFromMain = branchDiffersFromMain;
+  base.ahead = ahead;
+  base.behind = behind;
+  base.comparator = comparator || null;
+  base.branchDiffersFromComparator = branchDiffersFromComparator;
+  base.showAheadBehind = showAheadBehind;
+
+  // Warning chip — mirror _renderProjectBranch precedence: main drift wins over
+  // "behind".
+  if (p.branchMismatch) {
+    base.warn = {
+      kind: 'main-drift',
+      text: '⚠ main drift',
+      detail: 'Configured mainBranch (' + mainBranch + ') differs from origin/HEAD ('
+        + remoteDefault + ') — config is likely stale',
+    };
+  } else if (behind !== null && behind > 0) {
+    base.warn = {
+      kind: 'behind',
+      text: '⚠ behind',
+      detail: 'Local branch is ' + behind + ' commits behind origin/' + comparatorRef,
+    };
+  }
+
+  // Ready-to-render rows for a hover panel.
+  var branchValue = 'on: ' + branch
+    + (branchDiffersFromMain ? ' → ' + mainBranch : '')
+    + (base.detached ? ' (detached)' : '');
+  base.lines.push({ label: 'Branch', value: branchValue });
+  if (showAheadBehind) {
+    base.lines.push({
+      label: 'Ahead / behind',
+      value: '↑' + ahead + ' ↓' + behind
+        + (branchDiffersFromComparator ? ' vs ' + comparator : ''),
+    });
+  }
+  if (base.dirty) {
+    base.lines.push({ label: 'Working tree', value: '● uncommitted changes' });
+  }
+  base.lines.push({ label: 'Checkout', value: mode.label });
+  if (base.warn) base.warnings.push(base.warn.detail);
+
+  // "•"-joined multi-fact string for a title= attribute fallback. Mirrors the
+  // titleBits composition in _renderProjectBranch, then appends checkout mode.
+  var titleBits = ['on: ' + branch];
+  if (mainBranch) titleBits.push('configured main: ' + mainBranch);
+  if (remoteDefault) titleBits.push('origin/HEAD: ' + remoteDefault);
+  if (ahead !== null && behind !== null) titleBits.push('↑' + ahead + ' ↓' + behind + ' vs origin/' + comparatorRef);
+  if (base.detached) titleBits.push('(detached)');
+  if (base.dirty) titleBits.push('(dirty)');
+  titleBits.push('checkout: ' + mode.label);
+  if (base.warn) titleBits.push(base.warn.detail);
+  base.titleText = titleBits.join(' • ');
+
+  return base;
+}
+
+var MinionsProjectGitSummary = {
+  summarize: summarizeProjectGit,
+  liveValidationTypes: _projectLiveValidationTypes,
+  checkoutMode: _projectCheckoutMode,
+};
+
+if (typeof window !== 'undefined') window.MinionsProjectGitSummary = MinionsProjectGitSummary;

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

@@ -13,8 +13,14 @@
     });
   }
   function clearTileModalBody() {
-    var body = document.getElementById('slim-tile-body');
-    if (body) body.textContent = '';
+    // Reuse contract (W-ms3bbzry000i6612): the embed tiles' iframes are cached
+    // and kept mounted for an instant reopen, so we DON'T wipe the modal body.
+    // Instead pause + hide the active embed iframe and clear only the transient
+    // 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();
+    var transient = document.getElementById('slim-tile-transient');
+    if (transient) transient.textContent = '';
   }
   // Stop the agent-detail "Working for" ticker on every dismiss path so the
   // 1s interval started in openAgentDetail can't leak after the modal closes.
@@ -85,6 +91,131 @@
     return card;
   }
 
+  // ── Reusable embed machinery (W-ms3bbzry000i6612) ──────────────────
+  // Each single-iframe embed tile (engine · queued · plans · prs) gets ONE
+  // cached iframe that is created on first use and thereafter shown/hidden —
+  // NEVER reparented or removed (reparenting/removing an <iframe> discards and
+  // reloads its browsing context, which would re-cold-boot the whole embedded
+  // SPA and defeat the point). Reopening a tile becomes an instant show instead
+  // of a full SPA cold-boot + first full fetch/render.
+  //
+  // A kept-alive hidden iframe would otherwise keep polling /api/status every 4s
+  // in the background: a display:none iframe still reports
+  // document.visibilityState === 'visible', so the embedded classic refresh loop
+  // has no idea it is off-screen. We tell it explicitly with a postMessage the
+  // classic SPA listens for (refresh.js, embed-mode only) — suspend while hidden,
+  // resume (with an immediate refresh for freshness) on show. So we trade a
+  // per-open cold-boot for a single background boot, not N permanent pollers.
+  //
+  // The cached iframes live in a persistent #slim-tile-embed-host inside the
+  // tile modal body that openTileModal/clearTileModalBody never wipe; transient
+  // card content (the dispatches tile) lives in a sibling #slim-tile-transient.
+  var _embedFrames = {};       // key -> iframe (cached; never removed/reparented)
+  var _activeEmbedKey = null;  // key of the currently-shown embed iframe (or null)
+  // Single-iframe embed tiles (excludes 'automation', which is its own tabbed,
+  // already-lazy composite). key -> [src, title, className].
+  var _EMBED_TILES = {
+    engine: ['/engine?embed=1', 'Engine',         'slim-engine-embed'],
+    queued: ['/work?embed=1',   'Work Items',     'slim-work-embed'],
+    plans:  ['/plans?embed=1',  'Plans',          'slim-plans-embed'],
+    prs:    ['/prs?embed=1',     'Pull Requests', 'slim-prs-embed'],
+  };
+
+  // Tell an embedded classic SPA whether its iframe is currently visible so it
+  // can suspend/resume its 4s poll. Same-origin, so contentWindow is reachable;
+  // guarded defensively. No-op before the iframe has a live contentWindow.
+  function _postEmbedVisibility(frame, visible) {
+    try {
+      if (frame && frame.contentWindow) {
+        frame.contentWindow.postMessage(
+          { source: 'minions-slim-embed', type: 'visibility', visible: !!visible }, '*');
+      }
+    } catch (e) { /* defensive — same-origin means this should never throw */ }
+  }
+
+  // Ensure the persistent host + transient containers exist inside the tile
+  // modal body (created once, never wiped). Returns { host, transient }.
+  function _ensureTileContainers() {
+    var body = document.getElementById('slim-tile-body');
+    if (!body) return null;
+    var host = document.getElementById('slim-tile-embed-host');
+    if (!host) {
+      host = document.createElement('div');
+      host.id = 'slim-tile-embed-host';
+      host.className = 'slim-tile-embed-host';
+      body.appendChild(host);
+    }
+    var transient = document.getElementById('slim-tile-transient');
+    if (!transient) {
+      transient = document.createElement('div');
+      transient.id = 'slim-tile-transient';
+      transient.className = 'slim-tile-transient';
+      body.appendChild(transient);
+    }
+    return { host: host, transient: transient };
+  }
+
+  // Create (once) the cached iframe for an embed tile and return it. Built with
+  // createElement (no innerHTML) to satisfy the dashboard no-unsanitized lint
+  // gate. Starts hidden; a load-time visibility message pauses its poll until
+  // the tile is actually shown.
+  function _getOrCreateEmbedFrame(key) {
+    if (_embedFrames[key]) return _embedFrames[key];
+    var spec = _EMBED_TILES[key];
+    if (!spec) return null;
+    var containers = _ensureTileContainers();
+    if (!containers) return null;
+    var frame = document.createElement('iframe');
+    frame.className = spec[2];
+    frame.src = spec[0];
+    frame.title = spec[1];
+    frame.hidden = true;
+    frame.addEventListener('load', function() {
+      _postEmbedVisibility(frame, _activeEmbedKey === key);
+    });
+    containers.host.appendChild(frame);
+    _embedFrames[key] = frame;
+    return frame;
+  }
+
+  // Show one embed tile's cached iframe and hide the rest, pausing/resuming
+  // each one's embedded poll to match. Reused by every single-iframe embed tile.
+  function _showReusableEmbed(key) {
+    _getOrCreateEmbedFrame(key);
+    Object.keys(_embedFrames).forEach(function(k) {
+      var f = _embedFrames[k];
+      if (!f) return;
+      var on = (k === key);
+      f.hidden = !on;
+      _postEmbedVisibility(f, on);
+    });
+    _activeEmbedKey = key;
+  }
+
+  // Hide + pause whichever embed iframe is currently shown (kept mounted for an
+  // instant reopen). Called on modal close and when switching to a card tile.
+  function _pauseActiveEmbed() {
+    Object.keys(_embedFrames).forEach(function(k) {
+      var f = _embedFrames[k];
+      if (!f) return;
+      if (!f.hidden) _postEmbedVisibility(f, false);
+      f.hidden = true;
+    });
+    _activeEmbedKey = null;
+  }
+
+  // Prewarm the two hot embed tiles (Queued work + Active PRs) shortly after the
+  // slim cockpit paints, so their first open is an instant show rather than a
+  // cold boot. Deferred so it doesn't compete with initial paint; engine/plans
+  // are created lazily on first open (and cached/reused thereafter).
+  function prewarmHotEmbeds() {
+    _getOrCreateEmbedFrame('queued');
+    _getOrCreateEmbedFrame('prs');
+  }
+  (function schedulePrewarm() {
+    try { setTimeout(prewarmHotEmbeds, 800); } catch (e) { /* no timers — skip prewarm */ }
+  })();
+
   // Per-tile body renderers for the detail modal. Each reads the latest status
   // snapshot and fills the modal body; openTileModal looks them up by key.
   // Engine tile body — reuses the LITERAL classic dashboard /engine screen
@@ -100,11 +231,7 @@
   // /engine even with slim-ux ON (only / is taken over). Built with createElement
   // (no innerHTML) to satisfy the dashboard no-unsanitized lint gate.
   function renderEngineBody(body) {
-    var frame = document.createElement('iframe');
-    frame.className = 'slim-engine-embed';
-    frame.src = '/engine?embed=1';
-    frame.title = 'Engine';
-    body.appendChild(frame);
+    _showReusableEmbed('engine');
   }
 
   function renderDispatchTileBody(body, data, isActive) {
@@ -135,11 +262,7 @@
   // with slim-ux ON (only / is taken over). Built with createElement (no
   // innerHTML) to satisfy the dashboard no-unsanitized lint gate.
   function renderQueuedWorkBody(body) {
-    var frame = document.createElement('iframe');
-    frame.className = 'slim-work-embed';
-    frame.src = '/work?embed=1';
-    frame.title = 'Work Items';
-    body.appendChild(frame);
+    _showReusableEmbed('queued');
   }
 
   // Plans tile body — reuses the LITERAL classic dashboard /plans screen instead
@@ -154,11 +277,7 @@
   // reachable at /plans even with slim-ux ON (only / is taken over). Built with
   // createElement (no innerHTML) to satisfy the dashboard no-unsanitized lint gate.
   function renderPlansBody(body) {
-    var frame = document.createElement('iframe');
-    frame.className = 'slim-plans-embed';
-    frame.src = '/plans?embed=1';
-    frame.title = 'Plans';
-    body.appendChild(frame);
+    _showReusableEmbed('plans');
   }
 
   // Pull-requests tile body — reuses the LITERAL classic dashboard /prs screen
@@ -173,11 +292,7 @@
   // at /prs even with slim-ux ON (only / is taken over). Built with createElement
   // (no innerHTML) to satisfy the dashboard no-unsanitized lint gate.
   function renderPrsBody(body) {
-    var frame = document.createElement('iframe');
-    frame.className = 'slim-prs-embed';
-    frame.src = '/prs?embed=1';
-    frame.title = 'Pull Requests';
-    body.appendChild(frame);
+    _showReusableEmbed('prs');
   }
 
   // Automation tile body — a tabbed composite (Watches · Schedules · Pipelines)
@@ -283,7 +398,12 @@
     var titleEl = document.getElementById('slim-tile-title');
     var body = document.getElementById('slim-tile-body');
     if (!modal || !body) return;
-    body.textContent = '';
+    // Reuse contract: never wipe the whole body (that would destroy the cached,
+    // kept-alive embed iframes). Ensure the persistent host + transient
+    // containers, then clear ONLY the transient card container.
+    var containers = _ensureTileContainers();
+    var target = (containers && containers.transient) || body;
+    if (containers) containers.transient.textContent = '';
     if (titleEl) titleEl.textContent = view.title;
     // The "+ Link PR" header chip only applies to the PR list.
     var headerChip = document.getElementById('slim-tile-modal-linkpr');
@@ -298,7 +418,12 @@
     modal.classList.toggle('tile-modal--plans', key === 'plans');
     modal.classList.toggle('tile-modal--prs', key === 'prs');
     modal.classList.toggle('tile-modal--automation', key === 'automation');
-    view.render(body, lastStatusData || {});
+    // Single-iframe embed tiles show their cached iframe (via _showReusableEmbed
+    // inside their render fn) and ignore `target`. Card + automation tiles render
+    // into the transient container, so pause/hide any shown embed behind them.
+    var isReusableEmbed = Object.prototype.hasOwnProperty.call(_EMBED_TILES, key);
+    if (!isReusableEmbed) _pauseActiveEmbed();
+    view.render(target, lastStatusData || {});
     modal.classList.add('open');
   }
 

package/dashboard/slim/js/projects.js

@@ -25,6 +25,113 @@
     empty.textContent = 'No projects linked yet.';
     return empty;
   }
+  // ── Project-pill hover detail popover ────────────────────────
+  // Parity with the CLASSIC Projects bar (dashboard/js/render-other.js
+  // _renderProjectBranch / _renderWorktreeModePill): on hover/focus a pill shows
+  // the per-project git + dispatch detail — current branch, "→ main" drift,
+  // ahead/behind vs origin/main, dirty working tree, main-drift/behind warnings,
+  // and the checkout mode (Worktrees / Live checkout / Hybrid + validation types).
+  // All the semantics come from the SHARED, DOM-free summarizer
+  // window.MinionsProjectGitSummary.summarize (dashboard/shared/project-git-summary.js)
+  // so we don't fork the classic branching logic. Content is built with
+  // textContent/createElement only (no innerHTML — SEC-03 ratchet).
+  var _pillPopoverEl = null;
+  var _pillPopoverEscBound = false;
+
+  function _ensurePillPopover() {
+    if (_pillPopoverEl && document.body.contains(_pillPopoverEl)) return _pillPopoverEl;
+    var el = document.createElement('div');
+    el.className = 'slim-pill-popover';
+    el.id = 'slim-project-pill-popover';
+    el.setAttribute('role', 'tooltip');
+    el.hidden = true;
+    document.body.appendChild(el);
+    _pillPopoverEl = el;
+    if (!_pillPopoverEscBound) {
+      // Escape dismisses the popover (accessible non-blocking tooltip).
+      document.addEventListener('keydown', function(ev) {
+        if (ev.key === 'Escape' && _pillPopoverEl && !_pillPopoverEl.hidden) hidePillPopover();
+      });
+      _pillPopoverEscBound = true;
+    }
+    return el;
+  }
+
+  function _appendPopoverRow(parent, label, value, cls) {
+    var row = document.createElement('div');
+    row.className = 'slim-pill-popover-row' + (cls ? ' ' + cls : '');
+    if (label) {
+      var l = document.createElement('span');
+      l.className = 'slim-pill-popover-label';
+      l.textContent = label;
+      row.appendChild(l);
+    }
+    var v = document.createElement('span');
+    v.className = 'slim-pill-popover-value';
+    v.textContent = value;
+    row.appendChild(v);
+    parent.appendChild(row);
+  }
+
+  // Populate + position the popover under `pill` for the given status project
+  // object. No-op (and hides any open popover) when there is nothing to show.
+  function showPillPopover(pill, project) {
+    if (!pill || !project) return;
+    var summ = (window.MinionsProjectGitSummary && window.MinionsProjectGitSummary.summarize)
+      ? window.MinionsProjectGitSummary.summarize(project)
+      : null;
+    if (!summ) return;
+    var el = _ensurePillPopover();
+    el.textContent = '';
+
+    var header = document.createElement('div');
+    header.className = 'slim-pill-popover-header';
+    header.textContent = String(project.displayName || project.name || '');
+    el.appendChild(header);
+
+    if (summ.available) {
+      summ.lines.forEach(function(line) {
+        _appendPopoverRow(el, line.label, line.value);
+      });
+      if (summ.warn) {
+        _appendPopoverRow(el, '', summ.warn.text + ' — ' + summ.warn.detail, 'slim-pill-popover-warn');
+      }
+    } else if (summ.refreshing) {
+      _appendPopoverRow(el, '', summ.message || 'Refreshing…', 'slim-pill-popover-muted');
+    } else if (summ.message) {
+      _appendPopoverRow(el, '', summ.message, 'slim-pill-popover-muted');
+      _appendPopoverRow(el, 'Checkout', summ.mode.label);
+    } else {
+      // No git branch data (e.g. non-project path) — still show checkout mode.
+      _appendPopoverRow(el, 'Checkout', summ.mode.label);
+    }
+
+    // Link the pill to the popover for assistive tech while it's visible.
+    pill.setAttribute('aria-describedby', el.id);
+    el.hidden = false;
+
+    // Position below the pill, clamped to the viewport.
+    var r = pill.getBoundingClientRect();
+    var top = r.bottom + 6;
+    var left = r.left;
+    var maxLeft = window.innerWidth - el.offsetWidth - 8;
+    if (left > maxLeft) left = Math.max(8, maxLeft);
+    if (left < 8) left = 8;
+    el.style.top = top + 'px';
+    el.style.left = left + 'px';
+  }
+
+  function hidePillPopover() {
+    if (!_pillPopoverEl) return;
+    _pillPopoverEl.hidden = true;
+    // Drop stale aria-describedby links on all pills.
+    var group = document.getElementById('chat-context-pills');
+    if (group) {
+      var pills = group.querySelectorAll('.context-pill[aria-describedby]');
+      for (var i = 0; i < pills.length; i++) pills[i].removeAttribute('aria-describedby');
+    }
+  }
+
   // Strip variant: project pills. One selectable pill per project, single-select.
   // No auto-default: when nothing is explicitly chosen, no pill is active and the
   // indicator stays in the "Select project" state, so the picker never silently
@@ -32,7 +139,11 @@
   // choice back off. Returns a container of pill buttons built as real DOM nodes
   // (no innerHTML — SEC-03 ratchet, see test/unit.test.js DYNAMIC_INNERHTML_BASELINE);
   // the caller attaches a click listener via event delegation.
-  function makeContextPills(projects, selected, displayByName) {
+  //
+  // `projectByName` maps project name → the full /api/status project object so
+  // each pill can surface its git + checkout detail on hover/focus (see
+  // showPillPopover). It is optional — pills still render name-only without it.
+  function makeContextPills(projects, selected, displayByName, projectByName) {
     var group = document.createElement('span');
     group.id = 'chat-context-pills';
     group.className = 'context-pills';
@@ -49,15 +160,37 @@
       var isActive = p === selected;
       pill.classList.toggle('active', isActive);
       pill.setAttribute('aria-checked', isActive ? 'true' : 'false');
+      var proj = projectByName && projectByName[p];
+      if (proj) {
+        // title= is the graceful fallback (works with no JS / reduced-motion);
+        // the richer popover is layered on via hover/focus below.
+        var summ = (window.MinionsProjectGitSummary && window.MinionsProjectGitSummary.summarize)
+          ? window.MinionsProjectGitSummary.summarize(proj)
+          : null;
+        if (summ && summ.titleText) pill.title = summ.titleText;
+        _wirePillHover(pill, proj);
+      }
       group.appendChild(pill);
     }
     return group;
   }
+
+  // Bind hover + keyboard-focus reveal of the detail popover for one pill.
+  // Kept in a helper so the closure captures the correct project object per
+  // iteration (the loop uses `var`).
+  function _wirePillHover(pill, proj) {
+    pill.addEventListener('mouseenter', function() { showPillPopover(pill, proj); });
+    pill.addEventListener('mouseleave', hidePillPopover);
+    pill.addEventListener('focus', function() { showPillPopover(pill, proj); });
+    pill.addEventListener('blur', hidePillPopover);
+  }
   async function loadProjectsAndRenderContext(opts) {
     var stripEl = document.getElementById('chat-context-strip');
     var controlsEl = document.getElementById('chat-context-controls');
     if (!stripEl || !controlsEl) return;
     var preferProject = (opts && opts.preferProject) || null;
+    // Any prior hover popover belongs to pills we're about to replace.
+    if (typeof hidePillPopover === 'function') hidePillPopover();
     try {
       var res = await fetch('/api/status');
       if (!res.ok) throw new Error('HTTP ' + res.status);
@@ -66,7 +199,12 @@
         .filter(function(p) { return p && p.name; });
       var projects = projectList.map(function(p) { return String(p.name); });
       var displayByName = {};
-      projectList.forEach(function(p) { displayByName[String(p.name)] = String(p.displayName || p.name); });
+      var projectByName = {};
+      projectList.forEach(function(p) {
+        var key = String(p.name);
+        displayByName[key] = String(p.displayName || p.name);
+        projectByName[key] = p;
+      });
       if (projects.length === 0) {
         stripEl.style.display = '';
         controlsEl.replaceChildren(makeContextEmptyNode(), makeContextAddBtn());
@@ -84,7 +222,7 @@
         // deliberately do NOT fall back to projects[0] here (W-mqayzsj3) so CC
         // turns and project-scoped actions don't silently target the wrong
         // project.
-        var pills = makeContextPills(projects, currentProject, displayByName);
+        var pills = makeContextPills(projects, currentProject, displayByName, projectByName);
         stripEl.style.display = '';
         controlsEl.replaceChildren(pills, makeContextAddBtn());
         pills.addEventListener('click', function(ev) {

package/dashboard/slim/styles.css

@@ -576,6 +576,48 @@
     .chat-context-strip .context-pill.active:hover {
       background: var(--blue);
     }
+    /* Project-pill hover detail popover (parity with the classic Projects bar).
+       Fixed-position, pointer-events:none so it never traps the pointer or
+       focus — it's a passive tooltip dismissed on mouseleave/blur/Escape. */
+    .slim-pill-popover {
+      position: fixed;
+      z-index: 1200;
+      max-width: 320px;
+      pointer-events: none;
+      background: var(--surface2);
+      border: 1px solid var(--border);
+      border-radius: var(--radius, 8px);
+      box-shadow: 0 6px 20px rgba(0, 0, 0, 0.28);
+      padding: var(--space-2) var(--space-3);
+      font-size: var(--text-sm, 12px);
+      line-height: 1.4;
+      color: var(--text);
+    }
+    .slim-pill-popover[hidden] { display: none; }
+    .slim-pill-popover-header {
+      font-weight: 700;
+      color: var(--blue);
+      margin-bottom: 4px;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .slim-pill-popover-row {
+      display: flex;
+      gap: var(--space-2);
+      align-items: baseline;
+    }
+    .slim-pill-popover-label {
+      color: var(--muted);
+      flex: 0 0 auto;
+      min-width: 84px;
+    }
+    .slim-pill-popover-value {
+      color: var(--text);
+      word-break: break-word;
+    }
+    .slim-pill-popover-muted .slim-pill-popover-value { color: var(--muted); font-style: italic; }
+    .slim-pill-popover-warn .slim-pill-popover-value { color: var(--red); }
     .chat-context-strip .context-static {
       color: var(--text);
       font-weight: 500;
@@ -747,6 +789,14 @@
       display: block; width: 100%; height: calc(100vh - 96px); min-height: 420px;
       border: 0; background: var(--bg);
     }
+    /* Reusable embed host (W-ms3bbzry000i6612): the engine/queued/plans/prs
+       embed iframes are cached and kept mounted for an instant reopen, then
+       shown/hidden via the [hidden] attribute. The class rules above set
+       display:block, which outranks [hidden]'s UA display:none — so hidden
+       cached frames must be forced back to none. The id+type+attr selector
+       outranks the class rules (no !important needed). */
+    .slim-tile-embed-host, .slim-tile-transient { display: block; }
+    #slim-tile-embed-host 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

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', 'welcome-popup'];
+const DASHBOARD_SHARED_JS = ['pr-merge-state', 'pr-filters', 'cc-suggestions', 'model-display', 'watches-source', 'project-git-summary', 'welcome-popup'];
 
 function buildDashboardHtml() {
   const dashDir = path.join(MINIONS_DIR, 'dashboard');

package/dashboard.js

@@ -3370,10 +3370,56 @@ async function _maxInputMtimeMs(inputs) {
     throw err;
   }
 }
+// ── Optional list pagination (W-ms3bbzry000i6612) ────────────────────────
+// Progressive-load foundation for large list endpoints (/api/work-items,
+// /api/pull-requests). Reads optional `limit`/`offset` query params; when
+// NEITHER is present the endpoint stays byte-identical to its legacy full-array
+// response (so /api/status count derivations and the classic 4s refresh loop
+// are unaffected). When present, the endpoint slices the SAME deterministically
+// -ordered, already-enriched+cached full list (guaranteeing `total` matches the
+// full response and pages never overlap or skip) and returns a paged envelope.
+//
+// Design note: we slice the cached enriched list at the endpoint rather than
+// pushing LIMIT/OFFSET into the per-scope stores because (a) the enriched list
+// is built once per ~1s and shared with /api/status, so store-level paging
+// would duplicate enrichment and risk diverging from the status counts, (b) the
+// cross-scope display order is post-enrichment (central + every project by
+// rowid), which per-scope SQL LIMIT/OFFSET cannot compose, and (c) slicing the
+// deterministic cached array is O(page) to serialize — the real transfer win.
+const _LIST_PAGE_MAX = 1000;
+function _parsePageParams(req) {
+  const params = new URL((req && req.url) || '/', 'http://localhost').searchParams;
+  const hasLimit = params.has('limit');
+  const hasOffset = params.has('offset');
+  if (!hasLimit && !hasOffset) return null; // legacy full-list path
+  const rawLimit = Number(params.get('limit'));
+  const rawOffset = Number(params.get('offset'));
+  const limit = hasLimit && Number.isFinite(rawLimit)
+    ? Math.max(1, Math.min(_LIST_PAGE_MAX, Math.floor(rawLimit)))
+    : 50;
+  const offset = hasOffset && Number.isFinite(rawOffset) ? Math.max(0, Math.floor(rawOffset)) : 0;
+  return { limit, offset };
+}
+function _paginateList(list, page) {
+  const arr = Array.isArray(list) ? list : [];
+  const total = arr.length;
+  const offset = Math.max(0, page.offset | 0);
+  const limit = Math.max(1, page.limit | 0);
+  const items = arr.slice(offset, offset + limit);
+  return { items, total, offset, limit, hasMore: offset + items.length < total };
+}
+
 async function serveFreshJson(req, res, opts) {
   const inputs = Array.isArray(opts && opts.inputs) ? opts.inputs : [];
   const builder = opts && typeof opts.builder === 'function' ? opts.builder : null;
   const tag = opts && opts.tag ? String(opts.tag) : 'v';
+  // Optional response variant discriminator (e.g. pagination window). Folded
+  // into the ETag so a paged request never gets served the full-list cache and
+  // vice versa. Empty string keeps the ETag byte-identical to the legacy value,
+  // so no-variant callers are unaffected (W-ms3bbzry000i6612).
+  const variant = opts && opts.variant ? String(opts.variant) : '';
+  // Optional post-builder transform (e.g. slice a page out of the full list).
+  const transform = opts && typeof opts.transform === 'function' ? opts.transform : null;
   if (!builder) {
     res.statusCode = 500;
     res.setHeader('Content-Type', 'application/json');
@@ -3382,7 +3428,7 @@ async function serveFreshJson(req, res, opts) {
   }
   const mtime = await _maxInputMtimeMs(inputs);
   const eventVersion = _getCurrentEventVersion();
-  const etag = '"' + tag + '-' + mtime + '-' + eventVersion + '"';
+  const etag = '"' + tag + (variant ? '-' + variant : '') + '-' + mtime + '-' + eventVersion + '"';
   res.setHeader('ETag', etag);
   res.setHeader('Cache-Control', 'private, max-age=0, must-revalidate');
   if (req && req.headers && req.headers['if-none-match'] === etag) {
@@ -3393,6 +3439,7 @@ async function serveFreshJson(req, res, opts) {
   let payload;
   try {
     payload = builder();
+    if (transform) payload = transform(payload);
   } catch (e) {
     res.statusCode = 500;
     res.setHeader('Content-Type', 'application/json');
@@ -14568,22 +14615,28 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         builder: () => getAgents(),
       });
     }},
-    { method: 'GET', path: '/api/work-items', desc: 'Fully-enriched SQL-backed work items joined with dispatch/PR state — fresh on every request; description hard-capped + acceptanceCriteria/references replaced with *Count integers (W-mq5xg5e9000nec0e); detail modal lazy-loads the full record via GET /api/work-items/<id>', handler: (req, res) => {
+    { method: 'GET', path: '/api/work-items', desc: 'Fully-enriched SQL-backed work items joined with dispatch/PR state — fresh on every request; description hard-capped + acceptanceCriteria/references replaced with *Count integers (W-mq5xg5e9000nec0e); detail modal lazy-loads the full record via GET /api/work-items/<id>. Optional ?limit=&offset= returns a { items, total, hasMore, offset, limit } page (progressive load, W-ms3bbzry000i6612); with no paging params the full array is byte-identical to legacy.', handler: (req, res) => {
+      const page = _parsePageParams(req);
       return serveFreshJson(req, res, {
         tag: 'work-items',
         inputs: [CONFIG_PATH],
+        variant: page ? ('p' + page.offset + '.' + page.limit) : '',
         // W-mq5xg5e9000nec0e — Slim every item before stringify so the polled
         // refresh-loop payload stays < ~300 KB even when description fields
         // include 100+ KB transcripts. slimWorkItemForList shallow-copies so
         // queries.getWorkItems()'s in-memory cache is never mutated.
         builder: () => getWorkItems().map(slimWorkItemForList),
+        transform: page ? (list) => _paginateList(list, page) : null,
       });
     }},
-    { method: 'GET', path: '/api/pull-requests', desc: 'Fully-enriched SQL-backed pull requests with URL backfill and project stamps', handler: (req, res) => {
+    { method: 'GET', path: '/api/pull-requests', desc: 'Fully-enriched SQL-backed pull requests with URL backfill and project stamps. Optional ?limit=&offset= returns a { items, total, hasMore, offset, limit } page (progressive load, W-ms3bbzry000i6612); with no paging params the full array is byte-identical to legacy.', handler: (req, res) => {
+      const page = _parsePageParams(req);
       return serveFreshJson(req, res, {
         tag: 'pull-requests',
         inputs: [CONFIG_PATH],
+        variant: page ? ('p' + page.offset + '.' + page.limit) : '',
         builder: () => queries.getPullRequests(),
+        transform: page ? (list) => _paginateList(list, page) : null,
       });
     }},
     // GET /api/prs/<id> — single fully-enriched PR record by canonical id

package/package.json

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