@yemi33/minions 0.1.2447 → 0.1.2449

package/dashboard/js/qa.js

@@ -7,8 +7,8 @@
 // happening and exposes per-row operational controls.
 //
 // Sections (top → bottom):
-//  1. Active QA Sessions — non-terminal sessions only, with a CC-pitch card
-//     at the top and a collapsed disclosure for terminal sessions (last 10).
+//  1. Active QA Sessions — non-terminal sessions only, opening straight on the
+//     session list, with a collapsed disclosure for terminal sessions (last 10).
 //     Per-card controls: approve / edit / cancel / dismiss / kill.
 //  2. Live Targets — slim dedup'd list of /api/managed-processes +
 //     /api/keep-processes with a health badge and a link to /engine
@@ -17,8 +17,11 @@
 //     while the QA page is active. Each row links to the live agent stream
 //     and renders inline artifact previews via /api/qa/artifacts/<runId>/<file>
 //     (screenshots as <img>, videos as <video>, logs as 40-line text preview
-//     with a "View full" link). No direct filesystem paths are exposed —
-//     artifact URLs always go through /api/qa/artifacts/.
+//     with a "View full" link). For a run in a terminal state only the
+//     screenshots + video stay inline; every other artifact collapses behind a
+//     "Show all artifacts (N)" disclosure (W-ms9p62od00kt5b58). No direct
+//     filesystem paths are exposed — artifact URLs always go through
+//     /api/qa/artifacts/.
 //  4. Validation Runbooks — collapsed disclosure with a small CC-pitch and
 //     the runbook list. Each row has a Run + Delete button.
 //
@@ -28,9 +31,29 @@
 // navigates.
 
 let _qaRunsPollInterval = null;
-let _qaTargetsCache = [];
 let _qaRunbooksCache = [];
 
+// W-ms9p62od00kt5b58 — state that must survive loadQaRuns()'s 5s
+// replaceChildren() of the whole runs list.
+//   - _qaOpenArtifactGroups: run ids whose "Show all artifacts" disclosure the
+//     user opened. Without it the re-render would snap every group shut.
+//   - _qaLogPreviewCache: fetched preview text keyed by artifact URL. The
+//     per-element `__qaLoaded` flag dies with the node on every poll, so an
+//     opened group would otherwise refetch its previews every 5 seconds.
+const _qaOpenArtifactGroups = new Set();
+const QA_LOG_PREVIEW_CACHE_MAX = 200;
+const _qaLogPreviewCache = new Map();
+
+function _qaCacheLogPreview(url, text) {
+  if (!url) return;
+  // Re-insert so the Map's insertion order doubles as an LRU queue.
+  if (_qaLogPreviewCache.has(url)) _qaLogPreviewCache.delete(url);
+  _qaLogPreviewCache.set(url, text);
+  while (_qaLogPreviewCache.size > QA_LOG_PREVIEW_CACHE_MAX) {
+    _qaLogPreviewCache.delete(_qaLogPreviewCache.keys().next().value);
+  }
+}
+
 function _stopQaRunsPoll() {
   if (_qaRunsPollInterval) {
     clearInterval(_qaRunsPollInterval);
@@ -84,8 +107,6 @@ async function loadQaTargets() {
       '<p class="empty" style="color:var(--red)">Failed to load targets: ' + escHtml(err.message || String(err)) + '</p>'
     );
     root.replaceChildren(frag);
-    _qaTargetsCache = [];
-    _qaPopulateTargetDropdown();
     return;
   }
 
@@ -130,9 +151,6 @@ async function loadQaTargets() {
     });
   }
 
-  _qaTargetsCache = targets;
-  _qaPopulateTargetDropdown();
-
   if (!targets.length) {
     const frag = document.createRange().createContextualFragment(
       '<p class="empty">No live targets. Spawn a service via <code>meta.managed_spawn</code> or <code>meta.keep_processes</code> to populate this list. Full inventory on <a href="/engine">/engine</a>.</p>'
@@ -163,25 +181,13 @@ async function loadQaTargets() {
   root.replaceChildren(frag);
 }
 
-function _qaPopulateTargetDropdown() {
-  const sel = document.getElementById('qa-runbook-target');
-  if (!sel) return;
-  const current = sel.value;
-  // Build option nodes via DOM API — no innerHTML.
-  while (sel.firstChild) sel.removeChild(sel.firstChild);
-  const placeholder = document.createElement('option');
-  placeholder.value = '';
-  placeholder.textContent = '— select a target —';
-  sel.appendChild(placeholder);
-  for (const t of _qaTargetsCache) {
-    const opt = document.createElement('option');
-    opt.value = t.name;
-    const projLabel = t.project ? ' (' + t.project + ')' : '';
-    opt.textContent = t.name + projLabel + ' [' + t.source + ']';
-    sel.appendChild(opt);
-  }
-  if (current) sel.value = current;
-}
+// W-mpxp7a3e000g0a49 removed the inline "Start QA Session" / runbook form from
+// dashboard/pages/qa.html, taking the `qa-runbook-target` <select> with it
+// (asserted absent by test/unit/qa-tab-ui.test.js). The _qaPopulateTargetDropdown
+// helper that filled it was left behind as an unreachable no-op and has been
+// deleted (W-ms5dlone012i457a-b), along with the `_qaTargetsCache` module state
+// that existed only to feed it — loadQaTargets renders its rows directly.
+// Runbook targets are chosen via Command Center.
 
 // ── Section 2: Runbooks ────────────────────────────────────────────────────
 async function loadQaRunbooks() {
@@ -324,7 +330,7 @@ async function loadQaRuns() {
     return;
   }
   const rows = items.map(_qaRenderRunRow).join('');
-  // eslint-disable-next-line no-unsanitized/method -- reason: structural HTML is a string literal; all user data wrapped in escHtml() (fields: run id, status, runbook, target, timestamp, workItemId, agentId, artifact file names)
+  // eslint-disable-next-line no-unsanitized/method -- reason: structural HTML is a string literal; all user data wrapped in escHtml() (fields: run id, status, runbook, target, timestamp, workItemId, agentId, artifact file names); the secondary-artifact count is a computed number
   const frag = document.createRange().createContextualFragment(rows);
   root.replaceChildren(frag);
 }
@@ -364,8 +370,8 @@ function _qaRenderRunRow(run) {
   const actionsHtml = (liveLink || deleteBtn)
     ? '<span class="qa-run-actions">' + liveLink + deleteBtn + '</span>'
     : '';
-  const artifactsHtml = _qaRenderArtifactPreviews(id, run.artifacts || []);
-  return '<div class="qa-run-row" data-run-id="' + escHtml(id) + '">' +
+  const artifactsHtml = _qaRenderArtifactPreviews(id, run.artifacts || [], status);
+  return '<div class="qa-run-row" id="qa-run-' + escHtml(id) + '" data-run-id="' + escHtml(id) + '">' +
     '<div class="qa-run-head">' +
       '<span class="qa-run-status ' + escHtml(statusClass) + '">' + escHtml(status) + '</span>' +
       '<span class="qa-run-name">' + escHtml(runbook) + '</span>' +
@@ -378,7 +384,7 @@ function _qaRenderRunRow(run) {
 }
 
 // W-mpxp90xs000i5732 — terminal status set kept in sync with
-// engine/qa-runs.js#TERMINAL_STATUSES. The Delete button only renders for
+// engine/qa/runs.js#TERMINAL_STATUSES. The Delete button only renders for
 // runs in one of these states; the engine's deleteQaRun returns 409 for
 // anything else (defense in depth).
 function _qaIsTerminalStatus(status) {
@@ -426,9 +432,30 @@ async function qaDeleteRun(id) {
   }
 }
 
-function _qaRenderArtifactPreviews(runId, artifacts) {
+// W-ms9p62od00kt5b58 — artifact triage.
+//
+// A COMPLETED run used to render every artifact inline at equal weight:
+// screenshots and video next to .json blobs, .md reports, and a binary
+// trace.zip garbled into a <pre> by the text-preview fetcher. The final
+// screenshots + video ARE the result of a QA run; everything else is
+// supporting material.
+//
+// So for a run in a terminal state (see _qaIsTerminalStatus) primary artifacts
+// render inline as before and the rest collapse behind one native <details>.
+// A non-terminal run keeps the old flat layout on purpose — while a run is
+// still going the logs are the signal, so hiding them would be a regression.
+function _qaRenderArtifactPreviews(runId, artifacts, status) {
   if (!runId || !Array.isArray(artifacts) || !artifacts.length) return '';
-  const parts = [];
+  const IMAGE_EXTS = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg'];
+  const VIDEO_EXTS = ['mp4', 'webm', 'ogg', 'mov'];
+  // Extensions whose bytes are NOT text. Fetching these into a <pre> is what
+  // rendered trace.zip as mojibake; they get a download link and no preview
+  // fetch at all. An artifact with no extension is treated the same way —
+  // unknown content is not assumed to be safe to inline as text.
+  const BINARY_EXTS = ['zip', 'gz', 'tgz', 'tar', 'bz2', 'xz', 'zst', 'br', '7z', 'rar',
+    'pdf', 'wasm', 'exe', 'dll', 'so', 'dylib', 'bin', 'db', 'sqlite', 'ico'];
+  const primary = [];
+  const secondary = [];
   for (const a of artifacts) {
     // Canonical records use { path, type }; retain the retired { file, kind }
     // shape for older persisted runs.
@@ -446,25 +473,36 @@ function _qaRenderArtifactPreviews(runId, artifacts) {
     const typeHint = String(typeRaw).toLowerCase();
     const ext = (file.match(/\.([a-z0-9]+)$/i) || ['', ''])[1].toLowerCase();
     const url = '/api/qa/artifacts/' + encodeURIComponent(runId) + '/' + encodeURIComponent(artifactPath);
-    if (typeHint === 'screenshot' || ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg'].includes(ext)) {
-      parts.push(
+    if (typeHint === 'screenshot' || IMAGE_EXTS.includes(ext)) {
+      primary.push(
         '<div class="qa-artifact qa-artifact-image">' +
           '<img src="' + escHtml(url) + '" alt="' + escHtml(artifactPath) + '" loading="lazy">' +
           '<div class="qa-artifact-caption">' + escHtml(artifactPath) + '</div>' +
         '</div>'
       );
-    } else if (typeHint === 'video' || ['mp4', 'webm', 'ogg', 'mov'].includes(ext)) {
-      parts.push(
+    } else if (typeHint === 'video' || VIDEO_EXTS.includes(ext)) {
+      primary.push(
         '<div class="qa-artifact qa-artifact-video">' +
           '<video controls src="' + escHtml(url) + '"></video>' +
           '<div class="qa-artifact-caption">' + escHtml(artifactPath) + '</div>' +
         '</div>'
       );
+    } else if (!ext || BINARY_EXTS.includes(ext)) {
+      // Binary / unknown — link only. Deliberately carries no data-qa-log-url,
+      // so _qaFillLogPreviews never fetches it.
+      secondary.push(
+        '<div class="qa-artifact qa-artifact-binary">' +
+          '<div class="qa-artifact-caption">' +
+            escHtml(artifactPath) + ' ' +
+            '<a href="' + escHtml(url) + '" target="_blank" rel="noopener" download class="qa-artifact-fulllink">View full</a>' +
+          '</div>' +
+        '</div>'
+      );
     } else {
       // Log / text — render an asynchronously-filled <pre>; first 40 lines
       // fetched lazily so we don't N+1-flood the network on every poll.
       const blockId = 'qa-log-' + runId + '-' + artifactPath.replace(/[^a-zA-Z0-9_-]/g, '_');
-      parts.push(
+      secondary.push(
         '<div class="qa-artifact qa-artifact-log">' +
           '<div class="qa-artifact-caption">' +
             escHtml(artifactPath) + ' ' +
@@ -475,26 +513,89 @@ function _qaRenderArtifactPreviews(runId, artifacts) {
       );
     }
   }
-  return parts.join('');
+  const primaryHtml = primary.join('');
+  if (!secondary.length) return primaryHtml;
+  if (!_qaIsTerminalStatus(status)) return primaryHtml + secondary.join('');
+  // Open-state is tracked outside the DOM because loadQaRuns() replaces the
+  // whole list every 5s. Resolved defensively so the renderer stays usable in
+  // isolation (same pattern as qaFocusCommandCenter's _ccOpen lookup).
+  const openGroups = (typeof _qaOpenArtifactGroups !== 'undefined') ? _qaOpenArtifactGroups : null;
+  const isOpen = !!(openGroups && openGroups.has(runId));
+  return primaryHtml +
+    '<details class="qa-artifact-secondary" data-run-id="' + escHtml(runId) + '"' + (isOpen ? ' open' : '') + '>' +
+      '<summary class="qa-artifact-secondary-summary">Show all artifacts (' + secondary.length + ')</summary>' +
+      '<div class="qa-artifact-secondary-body">' + secondary.join('') + '</div>' +
+    '</details>';
 }
 
 // Lazily fetch log previews after the runs DOM is in place. Runs every time
 // loadQaRuns finishes; cheap because the `data-qa-log-url` lookup short-
 // circuits on already-loaded blocks.
+//
+// W-ms9p62od00kt5b58 — two rules now bound the fetching:
+//   1. Previews inside a COLLAPSED <details> are not fetched. A completed run
+//      hides its logs/json behind one disclosure, and filling them eagerly
+//      would fire N background requests for content nobody is looking at.
+//      Each group is instead wired once to fill on its first open (`toggle`).
+//   2. Preview text is memoized by URL, so re-opening a group — or the 5s
+//      poll re-rendering an already-open one — reuses the fetched text
+//      instead of refetching it.
 function _qaFillLogPreviews() {
-  const blocks = document.querySelectorAll('#qa-runs-content .qa-artifact-log-preview[data-qa-log-url]');
-  blocks.forEach(function (el) {
+  const fill = function (el) {
     const url = el.getAttribute('data-qa-log-url');
     if (!url || el.__qaLoaded) return;
     el.__qaLoaded = true;
+    if (_qaLogPreviewCache.has(url)) {
+      el.textContent = _qaLogPreviewCache.get(url);
+      return;
+    }
     fetch(url)
       .then(function (r) { return r.ok ? r.text() : ''; })
       .then(function (txt) {
         const head = (txt || '').split(/\r?\n/).slice(0, 40).join('\n');
+        _qaCacheLogPreview(url, head || '(empty)');
         el.textContent = head || '(empty)';
       })
       .catch(function () { el.textContent = '(failed to load)'; });
+  };
+  const groups = document.querySelectorAll('#qa-runs-content details.qa-artifact-secondary');
+  groups.forEach(function (d) {
+    if (d.__qaToggleWired) return;
+    d.__qaToggleWired = true;
+    d.addEventListener('toggle', function () {
+      const runId = d.getAttribute ? d.getAttribute('data-run-id') : '';
+      if (runId) {
+        if (d.open) _qaOpenArtifactGroups.add(runId);
+        else _qaOpenArtifactGroups.delete(runId);
+      }
+      if (!d.open) return;
+      d.querySelectorAll('.qa-artifact-log-preview[data-qa-log-url]').forEach(fill);
+    });
   });
+  const blocks = document.querySelectorAll('#qa-runs-content .qa-artifact-log-preview[data-qa-log-url]');
+  blocks.forEach(function (el) {
+    // Collapsed group → defer to the toggle handler wired above.
+    const group = el.closest ? el.closest('details.qa-artifact-secondary') : null;
+    if (group && !group.open) return;
+    fill(el);
+  });
+}
+
+// W-msb9kgs402813a97-d — a session card's run chip scrolls the matching Recent
+// Runs row into view instead of navigating. The default fragment jump is
+// suppressed by the chip's onclick because the URL hash is owned by the
+// modal-stack router (state.js#getModalStackFromUrl); the href stays as the
+// no-JS fallback and as the accessible link target.
+function qaScrollToRun(runId) {
+  if (!runId) return;
+  const sel = (window.CSS && CSS.escape) ? CSS.escape(runId) : runId.replace(/"/g, '\\"');
+  const row = document.querySelector('.qa-run-row[data-run-id="' + sel + '"]');
+  if (!row) return;
+  try { row.scrollIntoView({ behavior: 'smooth', block: 'center' }); }
+  catch { row.scrollIntoView(); }
+  // Brief highlight so the eye lands on the right row after the scroll.
+  row.classList.add('qa-run-row--flash');
+  setTimeout(function () { row.classList.remove('qa-run-row--flash'); }, 1600);
 }
 
 function qaOpenRunAgent(workItemId, agentId) {
@@ -688,7 +789,7 @@ async function loadQaSessions() {
   } else {
     let html = '';
     for (const s of active) html += _qaRenderSessionCard(s);
-    // eslint-disable-next-line no-unsanitized/method -- reason: structural HTML is a string literal; all user data wrapped in escHtml() (fields: session id, state, target sub-fields, mode, runner, error/summary/failureClass)
+    // eslint-disable-next-line no-unsanitized/method -- reason: structural HTML is a string literal; all user data wrapped in escHtml() (fields: session id, state, target sub-fields, mode, runner, error/summary/failureClass, linked run id + run status)
     const frag = document.createRange().createContextualFragment(html);
     activeRoot.replaceChildren(frag);
   }
@@ -702,7 +803,7 @@ async function loadQaSessions() {
     } else {
       let html = '';
       for (const s of terminal) html += _qaRenderSessionCard(s);
-      // eslint-disable-next-line no-unsanitized/method -- reason: structural HTML is a string literal; all user data wrapped in escHtml() (fields: session id, state, target sub-fields, mode, runner, error/summary/failureClass)
+      // eslint-disable-next-line no-unsanitized/method -- reason: structural HTML is a string literal; all user data wrapped in escHtml() (fields: session id, state, target sub-fields, mode, runner, error/summary/failureClass, linked run id + run status + artifact file names via _qaRenderArtifactPreviews)
       const frag = document.createRange().createContextualFragment(html);
       recentRoot.replaceChildren(frag);
     }
@@ -746,6 +847,15 @@ function _qaRenderSessionCard(s) {
   const summary = s && s.summary || '';
   const createdAt = s && s.createdAt ? String(s.createdAt).slice(0, 19).replace('T', ' ') : '';
   const isTerminal = QA_SESSION_TERMINAL_STATES.has(state);
+  // W-msb9kgs402813a97-d — `linkedRun` is the bounded read-side projection the
+  // sessions endpoint attaches (engine/qa/sessions.js#listSessions with
+  // includeLinkedRun): { id, status, artifacts:[{type,path,label}] }, primary
+  // (image/video) artifacts only. It is absent when the run was deleted or the
+  // runs store was unreadable, so every read below is defensive.
+  const qaRunId = (s && s.qaRunId) || '';
+  const linkedRun = (s && s.linkedRun) || null;
+  const linkedRunStatus = (linkedRun && linkedRun.status) || '';
+  const linkedArtifacts = (linkedRun && Array.isArray(linkedRun.artifacts)) ? linkedRun.artifacts : [];
 
   const phases = _qaRenderPhaseChips(state);
 
@@ -770,6 +880,20 @@ function _qaRenderSessionCard(s) {
   meta += '<span class="qa-session-meta-item">target: <code>' + escHtml(targetSummary) + '</code></span>';
   meta += '<span class="qa-session-meta-item">mode: <code>' + escHtml(mode) + '</code></span>';
   meta += '<span class="qa-session-meta-item">runner: <code>' + escHtml(runner) + '</code></span>';
+  // W-msb9kgs402813a97-d — the linked qa-run. Without it a session that DID
+  // capture screenshots reads as if it produced nothing, because the run (and
+  // its artifacts) only ever appeared in the separate Recent Runs list. The
+  // anchor is the run row's id (see _qaRenderRunRow); the click is intercepted
+  // so the URL hash stays owned by the modal-stack router in state.js.
+  if (qaRunId) {
+    meta += '<span class="qa-session-meta-item">run: ' +
+      '<a class="qa-session-run-link" href="#qa-run-' + escHtml(qaRunId) + '"' +
+      ' data-run-id="' + escHtml(qaRunId) + '"' +
+      ' onclick="event.preventDefault();qaScrollToRun(this.dataset.runId);">' +
+      '<code>' + escHtml(qaRunId) + '</code></a>' +
+      (linkedRunStatus ? ' <span class="qa-session-run-status">' + escHtml(linkedRunStatus) + '</span>' : '') +
+      '</span>';
+  }
   if (createdAt) meta += '<span class="qa-session-meta-item qa-session-meta-ts">' + escHtml(createdAt) + '</span>';
 
   let body = '';
@@ -793,6 +917,23 @@ function _qaRenderSessionCard(s) {
   } else if (summary) {
     body += '<div class="qa-session-summary">' + escHtml(summary) + '</div>';
   }
+  // W-msb9kgs402813a97-d — evidence for a finished session. Only terminal
+  // sessions get this block: a still-executing run has not finished capturing,
+  // so "none captured" would be a lie. The screenshots/video render through the
+  // SAME helper the Recent Runs strip uses, so artifact URLs keep going through
+  // /api/qa/artifacts/<runId>/<path> and no filesystem path is ever exposed.
+  // The empty case is stated out loud — silence is what made a terminal session
+  // that captured nothing indistinguishable from one that captured plenty.
+  if (isTerminal && qaRunId) {
+    const previews = (linkedArtifacts.length && typeof _qaRenderArtifactPreviews === 'function')
+      ? _qaRenderArtifactPreviews(linkedRun.id || qaRunId, linkedArtifacts, linkedRunStatus)
+      : '';
+    if (previews) {
+      body += '<div class="qa-session-artifacts">' + previews + '</div>';
+    } else if (!linkedArtifacts.length) {
+      body += '<div class="qa-session-artifacts-empty">No screenshots or video captured for this run.</div>';
+    }
+  }
 
   const stateClass = 'qa-session-state-' + escHtml(state);
   return (

package/dashboard/js/refresh.js

@@ -138,7 +138,10 @@ const RENDER_VERSIONS = {
   // Bumped 2→3 for client-ticked relative last-action timestamps.
   // Bumped 3→4 to show the runtime-reported model when no model is pinned.
   agents: 4,
-  prdProgress: 2,
+  // Bumped 3→4: `missing` no longer counts as active, so the group summary
+  // reports only genuinely in-progress items and surfaces "to do" separately
+  // (W-msa2tagf01cse21c).
+  prdProgress: 4,
   prdPrs: 1,
   inbox: 2,
   // Bumped 4→5 for the clickable checkout-mode pill + picker (W-mr1b67zi0006b788).
@@ -146,11 +149,23 @@ const RENDER_VERSIONS = {
   // Bumped 6→7 for the liveValidation.autoDispatch toggle + pill "· auto-validate" suffix (W-mr2q361a00097e5c).
   projects: 9,
   notes: 1,
-  prd: 3,
+  // Bumped 3→4: an approved all-missing PRD no longer derives as
+  // dispatched/"In Progress" in the header badge (W-msa2tagf01cse21c).
+  prd: 4,
   // Bumped 4→5 for shared author/lifecycle/project/review/build filters.
-  prs: 5,
+  // Bumped 5→6 for draft/ready pill + Merge column removal (W-ms8z6l8z).
+  // Bumped 6→7 for the dedicated Project column (W-ms90po5j).
+  // Bumped 8→9 for independent Auto Fix and Auto Review row controls.
+  // Bumped 9→10: Status cell badges moved into a .pr-status-badges flex
+  // container so a wrapped conflict badge no longer overlaps the lifecycle
+  // badge (W-msakop2o).
+  // Bumped 10→11: Agent column replaced by Author (real PR author identity,
+  // separate from the Minions agent) + Author/Minions-agent split in PR detail
+  // (W-mscibegy005e8b74).
+  prs: 11,
   archivedPrds: 1,
-  engine: 4,
+  // Bumped 4→5 for the lifecycle-owned worktree count + foreign suffix (W-ms9q3dql00vxd4a8).
+  engine: 5,
   version: 1,
   adoThrottle: 1,
   ghThrottle: 1,
@@ -175,7 +190,19 @@ const RENDER_VERSIONS = {
   // a client reload past both.
   // Bumped 17→18: WI detail modal shows the effective model (persisted dispatch
   // evidence, else the current-config projection) — W-ms0ytfdd000d5a26.
-  workItems: 18,
+  // Bumped 18→19 (main via #1092): merge of dependency-conflict needs-attention
+  // renderer change with main's row-render changes — both touch the row render.
+  // Bumped 19→20 (#1092): Work Items filter bar (project/type/status).
+  // Bumped 20→21 (#1100): Work Items table gains the richer filter + sort controls
+  // and an Updated column (supersedes the #1092 filter bar); row/table markup
+  // changed for byte-identical input — W-ms7kutzv003q17ad.
+  // Bumped 21→22: default sort is now lifecycle-grouped (active → pending →
+  // failed → terminal, last-updated desc inside each group), so row ORDER
+  // changes for byte-identical input — W-ms9bmp8k003if9cf.
+  // Bumped 22→23: 'paused' joins the lifecycle order between failed and the
+  // terminal tail (it was unranked, so it sorted behind every done row in both
+  // directions) — row ORDER changes again for byte-identical input.
+  workItems: 23,
   skills: 1,
   commands: 1,
   mcpServers: 1,
@@ -190,6 +217,16 @@ const RENDER_VERSIONS = {
   pipelines: 2,
   pinned: 1,
   kbPayload: 2,
+  // The QA runs list renders on its own 5s poll (loadQaRuns → replaceChildren)
+  // rather than through the tick-driven _changed() cache, so — like `settings`
+  // above — this entry is the section's cache-bust knob rather than a live
+  // cache key today. Registered by W-ms9p62od00kt5b58, which changed
+  // _qaRenderArtifactPreviews' output for byte-identical input (terminal runs
+  // now collapse non-screenshot artifacts behind a <details>).
+  // Bumped 1→2 by W-msb9kgs402813a97-d: the session card now renders the linked
+  // qa-run chip and (for terminal sessions) its primary artifacts, so the card
+  // output changed for byte-identical session input.
+  qa: 2,
   // settings is a modal-driven section, not a tick-driven render — but the
   // cache-bust entry exists so future tick-driven code (or feature-flag-aware
   // renderers) can call `_changed('settings', …)` and bump on visual revamps.
@@ -200,7 +237,9 @@ const RENDER_VERSIONS = {
   // Bumped to 6 for the fleet ACP pool opt-in default and warning copy.
   // Bumped to 7 on origin/main.
   // Bumped to 8 for the Auto-fix pane tile-grid revamp (W-mryyzhug000454b7).
-  settings: 8,
+  // Bumped to 11 for the Cloud dispatch control in Agents Runtime & Models
+  // (registry-populated provider selector, disabled when none are registered).
+  settings: 11,
 };
 const _sectionCache = {};
 const _lastValueByKey = {};
@@ -772,6 +811,14 @@ function _processStatusUpdate(data, opts) {
     var qs = document.getElementById('engine-quick-stats');
     if (qs && data.engine) {
       var wt = data.engine.worktreeCount != null ? data.engine.worktreeCount : '-';
+      // W-ms9q3dql00vxd4a8 — `worktreeCount` counts only lifecycle-owned
+      // worktrees. Operator-created scratch checkouts arrive separately as
+      // `worktreeForeignCount` and are shown as a dimmed suffix so they stay
+      // visible without being presented as active Minions worktrees.
+      var foreignWt = Number(data.engine.worktreeForeignCount) || 0;
+      var foreignChip = foreignWt > 0
+        ? ' <span style="opacity:.65" title="Operator-created or unclassifiable directories under the worktree root. Minions never auto-removes these.">+' + foreignWt + ' foreign</span>'
+        : '';
       var pid = data.engine.pid || '-';
       // W-mpnc4u8c001d9d6c — replace the dead "Tick: -" chip (control.json
       // never carried a `tick` field) with a live "Next tick in Xs" countdown
@@ -788,7 +835,7 @@ function _processStatusUpdate(data, opts) {
       // eslint-disable-next-line no-unsanitized/property -- reason: composed from internal engine metrics (pid, lastTickAt/tickInterval, worktreeCount) and a literal id; no user data flows in
       qs.innerHTML = '<span>PID: <b>' + pid + '</b></span>' +
         '<span>Next tick in: <b id="engine-next-tick">' + _formatNextTickText() + '</b></span>' +
-        '<span>Worktrees: <b>' + wt + '</b></span>';
+        '<span>Worktrees: <b>' + wt + '</b>' + foreignChip + '</span>';
       _startNextTickTicker();
     }
   });
@@ -1010,7 +1057,7 @@ function _processStatusUpdate(data, opts) {
       });
   });
   // Watches come from GET /api/watches — the canonical SQL-backed read
-  // surface (engine/watches-store.js). The retired engine/watches.json mirror
+  // surface (engine/watches/store.js). The retired engine/watches.json mirror
   // is never written, so /state/ has nothing to serve.
   _safeRender('watches', function() {
     // Seq guard — the watches table is mutated every 3 ticks by
@@ -1109,7 +1156,7 @@ function _processStatusUpdate(data, opts) {
   //     (dashboard.js _plansCache / invalidatePlansCache) — back-to-back polls
   //     hit the cache; external file edits surface within 5s.
   //   - /api/knowledge: 30s in-memory TTL + invalidation on POST /api/knowledge
-  //     and after every kb-sweep (engine/queries.js _kbCache / kb-sweep.js).
+  //     and after every kb-sweep (engine/core/queries.js _kbCache / kb-sweep.js).
   // Previously throttled to every 3rd cycle (~12s) — see W-mphfb6ss000a3b9e
   // for the cadence audit + Playwright coverage.
   _safeRender('refreshKnowledgeBase', function() { refreshKnowledgeBase(); });
@@ -1175,6 +1222,18 @@ let _embedPollSuspended = false;
       const d = ev.data;
       if (!d || d.source !== 'minions-slim-embed' || d.type !== 'visibility') return;
       _embedPollSuspended = !d.visible;
+      // Also pause/resume the /engine screen's heavy diagnostics pollers
+      // (memory-panel.js: 10s /api/diagnostics/memory + 60s memory/history)
+      // through the SAME message — a hidden engine embed must not keep those
+      // running forever (W-ms4odb8h009a5d16). Guarded: the panel is only present
+      // on the /engine page, and its hooks are no-ops before mount.
+      try {
+        const mp = window.MinionsMemoryPanel;
+        if (mp) {
+          if (d.visible) { if (typeof mp.resumeMemoryPanel === 'function') mp.resumeMemoryPanel(); }
+          else if (typeof mp.suspendMemoryPanel === 'function') { mp.suspendMemoryPanel(); }
+        }
+      } catch (e) { /* memory panel not on this embedded page — ignore */ }
       if (d.visible) { try { refresh(); } catch (e) { /* refresh not yet defined / transient */ } }
     });
   } catch (e) { /* defensive — never block boot on this bridge */ }
@@ -1198,8 +1257,19 @@ let _embedPollSuspended = false;
 // (~12s) because connection-refused rejects fast rather than waiting out the
 // 15s timeout. The old "> N seconds since last success" OR side was REMOVED:
 // aborts during a healthy cold rebuild pushed elapsed-time past the budget and
-// surfaced the banner while the dashboard was alive-but-busy. Consecutive
-// failures are the only reliable "actually unreachable" signal.
+// surfaced the banner while the dashboard was alive-but-busy.
+//
+// Liveness confirmation (W-ms95wh14): consecutive /api/status failures alone are
+// still NOT proof the process is gone. During a long-running Command Center turn
+// the status-cache rebuild is starved on the event loop, so every /api/status
+// poll aborts even though the dashboard is alive and the CC stream is flowing —
+// reading that as "unreachable" is the false "Dashboard connection lost" bug.
+// So on the 3rd consecutive status failure we CONFIRM with a lightweight
+// /api/health probe (no status-cache rebuild, no per-agent file IO): if health
+// answers we treat the dashboard as alive-but-slow (reset counter, no banner, no
+// backoff); only a health-probe failure trips the banner. While the banner is up
+// an independent /api/health recovery probe (fixed 3s cadence, NOT gated by the
+// status-poll backoff) clears it the instant the process answers again.
 // On trip we show a sticky red banner with two recovery actions:
 //   1. "Restart Minions"  → ccRestartMinions (works when dashboard is
 //      alive-but-stale; falls through to copy-to-clipboard when the POST
@@ -1216,6 +1286,48 @@ const _UNREACHABLE_FAIL_THRESHOLD = 3;
 // Once the banner is up we throttle polls (exponential, capped at 30s) to
 // avoid hammering a struggling dashboard / network. Reset on recovery.
 let _nextPollAllowedAt = 0;
+// Recovery probe — a short, fixed-cadence /api/health poll that runs ONLY while
+// the unreachable banner is up. It is deliberately independent of the status
+// backoff above: once the dashboard process answers /api/health again we clear
+// the banner immediately and resume steady status polling, instead of waiting
+// out the (up to 30s) exponential status-poll backoff. /api/health does no
+// status-cache rebuild, so it recovers the instant the process is reachable.
+let _recoveryProbeTimer = null;
+const _RECOVERY_PROBE_INTERVAL_MS = 3000;
+const _LIVENESS_PROBE_TIMEOUT_MS = 4000;
+
+// Lightweight liveness probe. A /api/status timeout/abort is NOT proof the
+// dashboard process is down — the status-cache rebuild can be starved on the
+// event loop by a long-running Command Center turn. /api/health rebuilds no
+// status cache and does no per-agent file IO, so a fast 200 proves the process
+// is alive and servicing requests. Resolves true only on an ok response.
+function _probeDashboardAlive() {
+  return safeFetch('/api/health', { timeout: _LIVENESS_PROBE_TIMEOUT_MS })
+    .then(function(r) { return !!(r && r.ok); })
+    .catch(function() { return false; });
+}
+
+function _startRecoveryProbe() {
+  if (_recoveryProbeTimer) return;
+  _recoveryProbeTimer = setInterval(function() {
+    _probeDashboardAlive().then(function(alive) {
+      if (!alive) return;
+      _stopRecoveryProbe();
+      // Process is reachable again. Snap back to steady status polling (no
+      // backoff) and kick an immediate refresh so the frozen UI repopulates
+      // and the badge/banner restore on the next successful poll — don't wait
+      // for the status cache to warm to CLEAR the "unreachable" state.
+      _consecutiveStatusFails = 0;
+      _nextPollAllowedAt = 0;
+      _markDashboardReachable();
+      try { refresh(); } catch (e) { /* transient — next tick retries */ }
+    });
+  }, _RECOVERY_PROBE_INTERVAL_MS);
+}
+
+function _stopRecoveryProbe() {
+  if (_recoveryProbeTimer) { clearInterval(_recoveryProbeTimer); _recoveryProbeTimer = null; }
+}
 
 function _formatAge(ms) {
   if (ms < 1000) return 'just now';
@@ -1282,6 +1394,7 @@ function _markDashboardReachable() {
   _unreachableSince = 0;
   delete window._dashboardUnreachable;
   if (_unreachableAgeTimer) { clearInterval(_unreachableAgeTimer); _unreachableAgeTimer = null; }
+  _stopRecoveryProbe();
   // Hand #engine-alert back to renderEngineAlert. We can't leave our content
   // sitting in there because the next renderEngineAlert call only runs when
   // `_changed('engine', data.engine)` returns true — if engine state hasn't
@@ -1300,6 +1413,7 @@ window._resetDashboardUnreachableForTest = function() {
   _unreachableSince = 0;
   _nextPollAllowedAt = 0;
   if (_unreachableAgeTimer) { clearInterval(_unreachableAgeTimer); _unreachableAgeTimer = null; }
+  _stopRecoveryProbe();
   delete window._dashboardUnreachable;
 };
 
@@ -1474,8 +1588,30 @@ async function refresh(opts) {
     _consecutiveStatusFails++;
     // Sustained failure only — see the detector header for why elapsed time
     // alone must not trip (it flashed the banner on healthy-but-slow rebuilds).
-    if (_consecutiveStatusFails >= _UNREACHABLE_FAIL_THRESHOLD) {
+    // But a sustained run of /api/status timeouts is STILL not proof the
+    // process is gone: the ~2 KB status snapshot rebuild can be starved on the
+    // event loop by a long-running Command Center turn, so every poll aborts at
+    // safeFetch's 15s budget while the dashboard is perfectly alive. Before
+    // tripping the banner, confirm true unreachability with a lightweight
+    // /api/health probe that rebuilds no status cache. If health answers, the
+    // dashboard is alive-but-slow — reset to steady polling (no banner, no
+    // backoff) so we recover the instant the cache warms; only a health-probe
+    // failure is treated as "actually unreachable".
+    let _statusFailConfirmedDead = false;
+    if (_consecutiveStatusFails >= _UNREACHABLE_FAIL_THRESHOLD && !_unreachableSince) {
+      const _aliveViaHealth = await _probeDashboardAlive();
+      if (_aliveViaHealth) {
+        _consecutiveStatusFails = 0;
+        _nextPollAllowedAt = 0;
+      } else {
+        _statusFailConfirmedDead = true;
+      }
+    }
+    if (_consecutiveStatusFails >= _UNREACHABLE_FAIL_THRESHOLD && _statusFailConfirmedDead) {
       _markDashboardUnreachable(e);
+      // Start the independent /api/health recovery probe so we clear the banner
+      // promptly on recovery instead of waiting out the status-poll backoff.
+      _startRecoveryProbe();
     }
     // Backoff: once we've tripped the banner, throttle subsequent polls
     // (4s → 8s → 16s → 30s cap). Reset to 0 in the success path below so