@yemi33/minions 0.1.2432 → 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/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/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/styles.css

@@ -789,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.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.2432",
+  "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"