@yemi33/minions 0.1.2044 → 0.1.2046

package/README.md

@@ -11,8 +11,8 @@ Inspired by and initially scaffolded from [Brady Gaster's Squad](https://bradyga
 ## Prerequisites
 
 - **Node.js** 18+ (LTS recommended)
-- **Claude Code CLI** — install with `npm install -g @anthropic-ai/claude-code`
-- **Anthropic API key** or Claude Max subscription (agents spawn Claude Code sessions)
+- **A supported runtime CLI** — Minions defaults to GitHub Copilot CLI (`npm install -g @github/copilot`). Claude Code CLI (`npm install -g @anthropic-ai/claude-code`) is also supported; switch with `minions config set-cli claude` or per-agent `cli` overrides.
+- **Auth for your runtime** — GitHub Copilot subscription (Copilot CLI handles its own auth) or an Anthropic API key / Claude Max subscription
 - **Git** — agents create worktrees for all code changes
 
 > **Note:** you do **not** need to configure your CLI for "autopilot" / "bypass permissions" / "dangerous mode". Minions passes the right bypass flag per spawn (`--dangerously-skip-permissions` for Claude; `--autopilot --allow-all --no-ask-user` for Copilot), independent of your global CLI config. Run `minions doctor` to verify your installed CLI accepts those flags.

package/dashboard/js/command-center.js

@@ -194,6 +194,35 @@ function _ccIsNewDashboardInstance(preRestartDashId, newDashId, clickTimeMs) {
   return Number.isFinite(parsed) && parsed > clickTimeMs;
 }
 
+// Shown when ccRestartMinions's POST to /api/dashboard/restart can't be
+// delivered — i.e. the dashboard process itself is dead, not just stale. In
+// that state the in-browser button cannot bring anything back up: a detached
+// `minions restart` child is only spawned if the POST reaches the dashboard.
+// The recovery path lives outside the browser. Surface that fact explicitly
+// instead of polling for a new dashboardStartedAt that never arrives.
+function _ccShowDashboardDeadFallback(btn, reason) {
+  var humanReason = reason || 'connection refused';
+  var msg = 'The dashboard process appears to be down — the Restart button can\'t reach it (' + humanReason + ').\n\nRun this in your terminal to recover:\n\n    minions restart';
+  if (btn) {
+    try {
+      btn.disabled = false;
+      btn.textContent = 'Run `minions restart` in terminal';
+    } catch {}
+  }
+  var copyOk = function() {
+    if (typeof showToast === 'function') showToast('cmd-toast', '`minions restart` copied — paste in your terminal', true);
+  };
+  var copyFail = function() {
+    try { window.prompt('Copy this command, then run it in your terminal:', 'minions restart'); }
+    catch { try { alert(msg); } catch {} }
+  };
+  try {
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+      navigator.clipboard.writeText('minions restart').then(copyOk).catch(copyFail);
+    } else { copyFail(); }
+  } catch { copyFail(); }
+}
+
 // Triggered by the CC "Restart Minions" recovery button when a stale dashboard
 // connection is killing CC streams with "Failed to fetch". Spawns the same
 // `minions restart` flow as the CLI command (kills + respawns engine AND
@@ -242,14 +271,42 @@ async function ccRestartMinions(btn) {
     } catch { /* best-effort — clickTime fallback inside helper still covers us */ }
   }
 
-  // Fire-and-forget the restart POST. We do NOT await it — the dashboard often
-  // kills its own process before the response is flushed, so the fetch throws
-  // even though the restart child (a detached `minions restart`) is happily
-  // running. The polling loop is the source of truth for completion.
+  // Briefly await the POST so we can distinguish two failure shapes that look
+  // identical from a fire-and-forget callsite:
+  //
+  //   (a) Dashboard alive when POST landed but died mid-response. The spawned
+  //       restart child is running — polling /api/status WILL eventually see
+  //       a new dashboardStartedAt and the existing reload path works.
+  //
+  //   (b) Dashboard already dead when the user clicked. ECONNREFUSED before
+  //       any byte hits the wire. No restart child was spawned, polling would
+  //       wait the full 90 s and time out into a doomed reload (browser
+  //       lands on a port-not-listening error). This is the case operators
+  //       most often hit — the user just witnessed it today.
+  //
+  // 4 s is enough for the POST to deliver headers on a healthy box. If we
+  // saw EITHER res.ok OR a delayed-disconnect-with-headers-seen, assume the
+  // spawned child is on its way and start the polling loop. Otherwise fall
+  // back to the terminal-runnable command.
+  var postCtl = new AbortController();
+  var postTimer = setTimeout(function() { postCtl.abort(); }, 4000);
+  var postDelivered = false;
+  var postError = null;
   try {
-    fetch('/api/dashboard/restart', { method: 'POST', headers: { 'Content-Type': 'application/json' } })
-      .catch(function() { /* dashboard process likely killed mid-response — expected */ });
-  } catch { /* network layer threw before fetch even queued — also expected */ }
+    var postRes = await fetch('/api/dashboard/restart', { method: 'POST', headers: { 'Content-Type': 'application/json' }, signal: postCtl.signal });
+    if (postRes && postRes.ok) postDelivered = true;
+    else postError = 'HTTP ' + (postRes ? postRes.status : '?');
+  } catch (e) {
+    postError = String((e && e.message) || e);
+  } finally {
+    clearTimeout(postTimer);
+  }
+
+  if (!postDelivered) {
+    _ccShowDashboardDeadFallback(btn, postError);
+    return;
+  }
+
   if (btn) { try { btn.textContent = 'Restarting Minions — waiting for new dashboard...'; } catch {} }
 
   var startedAt = Date.now();

package/dashboard/js/fre.js

@@ -80,9 +80,10 @@ function renderFre(statusOrProjects) {
 
   // Resolve the currently-configured runtime CLI for the explainer copy.
   // /api/status surfaces this as autoMode.defaultCli (resolveAgentCli(null, engine)).
-  // Fall back to autoMode.ccCli (also defaultCli-derived when ccCli unset) then 'claude'.
+  // Fall back to autoMode.ccCli (also defaultCli-derived when ccCli unset) then 'copilot'
+  // (matches ENGINE_DEFAULTS.defaultCli — W-mpmwxkk40007c995).
   const auto = (status && status.autoMode) || {};
-  const runtimeCli = String(auto.defaultCli || auto.ccCli || 'claude');
+  const runtimeCli = String(auto.defaultCli || auto.ccCli || 'copilot');
 
   const cardStyle = [
     'margin:12px 24px',

package/dashboard/js/refresh.js

@@ -71,7 +71,7 @@ const RENDER_VERSIONS = {
   projects: 1,
   notes: 1,
   prd: 1,
-  prs: 1,
+  prs: 2,
   archivedPrds: 1,
   engine: 2,
   version: 1,
@@ -206,7 +206,16 @@ function _processStatusUpdate(data) {
 
 
   // Render only changed sections
-  if (_changed('agents', data.agents)) { renderAgents(data.agents); cmdUpdateAgentList(data.agents); }
+  // Agents is exempt from the _changed gate: real-time status correctness on
+  // the Minions Members grid (status badge, running timer, Last-run line)
+  // beats the cost of re-rendering 5 cards every poll tick. The gate was
+  // causing visible staleness when the ref-eq / JSON-stringify short-circuit
+  // falsely matched across ticks (W-mpn7keq9000302c9). Still call _changed
+  // here so the _lastChangedFlags diag ring-buffer keeps recording whether
+  // the agents payload actually moved this tick.
+  _changed('agents', data.agents);
+  renderAgents(data.agents);
+  cmdUpdateAgentList(data.agents);
   if (_changed('prdProgress', data.prdProgress) || _changed('prdPrs', data.pullRequests?.length)) { renderPrdProgress(data.prdProgress); _cachePrdItems(data.prdProgress); }
   if (_changed('inbox', data.inbox)) renderInbox(data.inbox || []);
   if (_changed('projects', data.projects)) { cmdUpdateProjectList(data.projects || []); renderProjects(data.projects || []); }
@@ -343,6 +352,116 @@ let _lastStatusData = null;
 // fresh state anyway.
 let _refreshInFlight = false;
 
+// ── 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
+// last successful snapshot. Operators have reported the resulting symptom
+// many times: badge says "running", CC POST throws "Failed to fetch", and
+// it's not obvious the dashboard itself is dead (vs. wedged, vs. the
+// engine being down).
+//
+// Trip conditions: 2 consecutive failed polls OR >12 s since the last
+// success (3× the 4 s poll cadence, so a single flaky tick doesn't fire).
+// 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
+//      itself fails)
+//   2. "Copy minions restart" → terminal fallback for the dashboard-is-
+//      truly-dead case the in-browser button can't fix on its own
+// Also overrides the engine badge to UNKNOWN/muted so the misleading
+// "RUNNING" pill stops showing while data is frozen.
+let _lastStatusOkAt = Date.now();
+let _consecutiveStatusFails = 0;
+let _unreachableSince = 0; // 0 = currently reachable
+let _unreachableAgeTimer = null;
+const _UNREACHABLE_FAIL_THRESHOLD = 2;
+const _UNREACHABLE_AGE_MS = 12000;
+
+function _formatAge(ms) {
+  if (ms < 1000) return 'just now';
+  const s = Math.round(ms / 1000);
+  if (s < 60) return s + 's ago';
+  const m = Math.floor(s / 60);
+  const rem = s % 60;
+  return rem ? m + 'm ' + rem + 's ago' : m + 'm ago';
+}
+
+function _refreshUnreachableAgeText() {
+  if (!_unreachableSince) return;
+  // The age span is rendered into the shared #engine-alert element by
+  // _markDashboardUnreachable; lookup by ID survives any inner-HTML rebuild
+  // as long as the markup keeps the span around (it does — single source).
+  const el = document.getElementById('dashboard-unreachable-age');
+  if (el) el.textContent = _formatAge(Date.now() - _lastStatusOkAt);
+}
+
+function _markDashboardUnreachable(err) {
+  if (_unreachableSince) {
+    _refreshUnreachableAgeText();
+    return;
+  }
+  _unreachableSince = Date.now();
+  window._dashboardUnreachable = {
+    since: _unreachableSince,
+    lastSuccessAt: _lastStatusOkAt,
+    lastError: String(err && err.message || err || 'unknown'),
+  };
+  // Reuse the existing #engine-alert surface (red-tinted banner already wired
+  // for engine-stale, ado-throttle, gh-throttle) instead of introducing a
+  // second red banner. Engine-stale and dashboard-unreachable are mutually
+  // exclusive in practice: engine-stale needs a fresh heartbeat from a
+  // successful poll, and a successful poll means the dashboard IS reachable.
+  // When the dashboard recovers, _markDashboardReachable hides this element
+  // explicitly; the next renderEngineAlert pass (driven by the recovered
+  // poll's engine state) then takes over normally.
+  const el = document.getElementById('engine-alert');
+  if (el) {
+    el.innerHTML =
+      '<span class="engine-alert-msg">&#x26A0;&#xFE0F; Dashboard unreachable &mdash; stale <span id="dashboard-unreachable-age">just now</span></span>' +
+      '<span class="engine-alert-action" onclick="ccRestartMinions(this)">Restart Minions</span>';
+    el.style.display = 'flex';
+  }
+  _refreshUnreachableAgeText();
+  if (_unreachableAgeTimer) clearInterval(_unreachableAgeTimer);
+  _unreachableAgeTimer = setInterval(_refreshUnreachableAgeText, 1000);
+  // Override engine badge so the cached "RUNNING" doesn't keep misleading
+  // the user. renderEngineStatus reads engine state from the next
+  // successful poll — when reachable recovers, the override clears.
+  const badge = document.getElementById('engine-badge');
+  if (badge) {
+    badge.className = 'engine-badge stopped';
+    badge.textContent = 'UNKNOWN';
+    badge.title = 'Dashboard unreachable — engine state is unknown. UI data is stale.';
+  }
+  console.warn('Dashboard unreachable:', window._dashboardUnreachable.lastError);
+}
+
+function _markDashboardReachable() {
+  if (!_unreachableSince) return;
+  const downForMs = Date.now() - _unreachableSince;
+  _unreachableSince = 0;
+  delete window._dashboardUnreachable;
+  if (_unreachableAgeTimer) { clearInterval(_unreachableAgeTimer); _unreachableAgeTimer = null; }
+  // 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
+  // shifted, our stale banner would persist past recovery.
+  const el = document.getElementById('engine-alert');
+  if (el) { el.style.display = 'none'; el.innerHTML = ''; }
+  console.log('Dashboard recovered after', _formatAge(downForMs).replace(' ago', ''));
+  // Badge restoration happens automatically on the next renderEngineStatus
+  // call (triggered by the successful refresh that brought us here).
+}
+
+// Test seam — reset detector state between scenarios.
+window._resetDashboardUnreachableForTest = function() {
+  _lastStatusOkAt = Date.now();
+  _consecutiveStatusFails = 0;
+  _unreachableSince = 0;
+  if (_unreachableAgeTimer) { clearInterval(_unreachableAgeTimer); _unreachableAgeTimer = null; }
+  delete window._dashboardUnreachable;
+};
+
 // ── Refresh diagnostics (W-mphejzx100081972) ─────────────────────────────
 // Ring buffer capturing the last 50 /api/status poll cycles so a user
 // reporting "the dashboard didn't auto-update when X changed" can paste
@@ -418,6 +537,11 @@ async function refresh() {
     const headers = {};
     if (_lastStatusEtag) headers['If-None-Match'] = _lastStatusEtag;
     const res = await safeFetch('/api/status', { headers });
+    if (!res || (!res.ok && res.status !== 304)) {
+      // Dashboard responded but with an error status. Treat as a fail tick so
+      // a 5xx-storm trips the unreachable banner just like a network error.
+      throw new Error('HTTP ' + (res ? res.status : '?'));
+    }
     let data;
     if (res.status === 304 && _lastStatusData) {
       // Cache hit — reuse last payload, skip parsing entirely.
@@ -425,6 +549,12 @@ async function refresh() {
       if (_diagEntry) {
         _diagEntry.response_status = '304';
         _diagEntry.bytes_received = 0;
+        // D2: capture etag on 304 so the diag table can show whether the
+        // server's ETag advanced even when we're reusing the cached body.
+        // Without this the "etag↓" column is blank on every 304 row and the
+        // operator can't tell server-side advancement from a pinned cache.
+        const etag304 = res.headers && (res.headers.get ? res.headers.get('etag') : null);
+        if (etag304) _diagEntry.etag_received = etag304;
       }
     } else {
       data = await res.json();
@@ -458,6 +588,12 @@ async function refresh() {
       return;
     }
     if (buildId) _knownDashboardBuildId = buildId;
+    // Successful poll — clear unreachable state. Placed AFTER the reload
+    // guards above so a dashboard restart still triggers location.reload()
+    // instead of just dismissing the banner.
+    _lastStatusOkAt = Date.now();
+    _consecutiveStatusFails = 0;
+    if (_unreachableSince) _markDashboardReachable();
     const _renderStart = _diagOn ? Date.now() : 0;
     let _diagChanges = null;
     if (_diagOn) {
@@ -484,6 +620,11 @@ async function refresh() {
       _diagEntry.response_status = (e && e.name === 'AbortError') ? 'abort' : 'error';
       _diagEntry.error_message = String((e && e.message) || e);
     }
+    _consecutiveStatusFails++;
+    const ageMs = Date.now() - _lastStatusOkAt;
+    if (_consecutiveStatusFails >= _UNREACHABLE_FAIL_THRESHOLD || ageMs > _UNREACHABLE_AGE_MS) {
+      _markDashboardUnreachable(e);
+    }
   }
   finally {
     _refreshInFlight = false;

package/dashboard/js/render-prs.js

@@ -51,22 +51,56 @@ function prRow(pr) {
   var followupChip = followupCount > 0
     ? ' <span class="pr-badge draft" style="font-size:8px" title="' + followupCount + ' follow-up work item(s) dispatched from comments on this PR">+' + followupCount + ' follow-up' + (followupCount === 1 ? '' : 's') + '</span>'
     : '';
+  const titleText = pr.title || 'Untitled';
+  const agentText = pr.agent || '—';
+  const reviewerCell = sq.reviewer && sq.status !== 'waiting'
+    ? '<span class="pr-agent" title="' + escapeHtml(sq.note || sq.reviewer) + '">' + escapeHtml(sq.reviewer) + '</span>'
+    : sq.reviewer && sq.status === 'waiting'
+      ? '<span class="pr-agent" style="color:var(--muted)" title="Vote pending confirmation">' + escapeHtml(sq.reviewer) + '…</span>'
+      : pr.reviewedBy && pr.reviewedBy.length
+        ? '<span class="pr-agent" title="' + escapeHtml(pr.reviewedBy.join(', ')) + '">' + escapeHtml(pr.reviewedBy.join(', ')) + '</span>'
+        : '<span style="color:var(--muted);font-size:11px">—</span>';
+  const createdLabel = (pr.created || '—').slice(0, 16).replace('T', ' ');
+  // Title attrs live on the inner element (link/span/badge) so hovering the
+  // ellipsis-truncated content reveals the full text. Cell tags stay bare so
+  // the header-to-cell count assertion in test/unit.test.js continues to
+  // balance.
   return '<tr>' +
-    '<td><span class="pr-id">' + escapeHtml(String(prId)) + '</span></td>' +
-    '<td><a class="pr-title" href="' + escapeHtml(safeUrl(url)) + '" target="_blank" rel="noopener">' + escapeHtml(pr.title || 'Untitled') + '</a>' + followupChip + (pr.description ? '<div class="pr-desc">' + escapeHtml(pr.description.length > 120 ? pr.description.slice(0, 120) + '...' : pr.description) + '</div>' : '') + '</td>' +
-    '<td><span class="pr-agent">' + escapeHtml(pr.agent || '—') + '</span></td>' +
+    '<td><span class="pr-id" title="' + escapeHtml(String(prId)) + '">' + escapeHtml(String(prId)) + '</span></td>' +
+    '<td><a class="pr-title" title="' + escapeHtml(titleText) + '" href="' + escapeHtml(safeUrl(url)) + '" target="_blank" rel="noopener">' + escapeHtml(titleText) + '</a>' + followupChip + (pr.description ? '<div class="pr-desc" title="' + escapeHtml(pr.description) + '">' + escapeHtml(pr.description.length > 120 ? pr.description.slice(0, 120) + '...' : pr.description) + '</div>' : '') + '</td>' +
+    '<td><span class="pr-agent" title="' + escapeHtml(agentText) + '">' + escapeHtml(agentText) + '</span></td>' +
     '<td><span class="' + branchClass + '" title="' + escapeHtml(branchError || branchLabel) + '">' + escapeHtml(branchLabel) + '</span>' + pendingReasonHtml + '</td>' +
-    '<td><span class="pr-badge ' + reviewClass + '"' + (reviewTitle ? ' title="' + escapeHtml(reviewTitle) + '"' : '') + '>' + escapeHtml(reviewLabel) + '</span></td>' +
-    '<td>' + (sq.reviewer && sq.status !== 'waiting' ? '<span class="pr-agent" title="' + escapeHtml(sq.note || '') + '">' + escapeHtml(sq.reviewer) + '</span>' : sq.reviewer && sq.status === 'waiting' ? '<span class="pr-agent" style="color:var(--muted)" title="Vote pending confirmation">' + escapeHtml(sq.reviewer) + '…</span>' : pr.reviewedBy && pr.reviewedBy.length ? '<span class="pr-agent">' + escapeHtml(pr.reviewedBy.join(', ')) + '</span>' : '<span style="color:var(--muted);font-size:11px">—</span>') + '</td>' +
-    '<td><span class="pr-badge ' + buildClass + '"' + (buildTitle ? ' title="' + escapeHtml(buildTitle) + '"' : '') + '>' + escapeHtml(buildLabel) + '</span></td>' +
-    '<td><span class="pr-badge ' + statusClass + '">' + escapeHtml(statusLabel) + '</span></td>' +
-    '<td><span class="pr-date">' + escapeHtml((pr.created || '—').slice(0, 16).replace('T', ' ')) + '</span></td>' +
+    '<td><span class="pr-badge ' + reviewClass + '" title="' + escapeHtml(reviewTitle || reviewLabel) + '">' + escapeHtml(reviewLabel) + '</span></td>' +
+    '<td>' + reviewerCell + '</td>' +
+    '<td><span class="pr-badge ' + buildClass + '" title="' + escapeHtml(buildTitle || buildLabel) + '">' + escapeHtml(buildLabel) + '</span></td>' +
+    '<td><span class="pr-badge ' + statusClass + '" title="' + escapeHtml(statusLabel) + '">' + escapeHtml(statusLabel) + '</span></td>' +
+    '<td><span class="pr-date" title="' + escapeHtml(createdLabel) + '">' + escapeHtml(createdLabel) + '</span></td>' +
     '<td><button class="pr-pager-btn" style="font-size:9px;padding:1px 5px;color:var(--red);border-color:var(--red)" data-pr-id="' + escapeHtml(String(prId)) + '" onclick="event.stopPropagation();unlinkPr(this.dataset.prId)" title="Remove from tracking">x</button></td>' +
     '</tr>';
 }
 
+// Explicit per-column widths keep the PR table from ballooning when titles or
+// branches are long. Total ≈1420px → table grows past viewport on narrow
+// windows and the .pr-table-wrap--prs container scrolls horizontally inside
+// the viewport (sticky scrollbar — see styles.css).
+const PRS_COLGROUP =
+  '<colgroup>' +
+    '<col style="width:75px">' +    // PR id
+    '<col style="width:320px">' +   // Title
+    '<col style="width:140px">' +   // Agent
+    '<col style="width:200px">' +   // Branch
+    '<col style="width:130px">' +   // Review
+    '<col style="width:140px">' +   // Signed Off By
+    '<col style="width:130px">' +   // Build
+    '<col style="width:110px">' +   // Status
+    '<col style="width:130px">' +   // Created
+    '<col style="width:50px">' +    // Actions
+  '</colgroup>';
+
 function prTableHtml(rows) {
-  return '<div class="pr-table-wrap"><table class="pr-table"><thead><tr>' +
+  return '<div class="pr-table-wrap pr-table-wrap--prs"><table class="pr-table pr-table--prs">' +
+    PRS_COLGROUP +
+    '<thead><tr>' +
     '<th>PR</th><th>Title</th><th>Agent</th><th>Branch</th><th>Review</th><th>Signed Off By</th><th>Build</th><th>Status</th><th>Created</th><th></th>' +
     '</tr></thead><tbody>' + rows + '</tbody></table></div>';
 }

package/dashboard/js/settings.js

@@ -49,7 +49,7 @@ async function openSettings() {
   // Per-agent override placeholders surface the inherited fleet defaults as
   // muted text — operators see exactly what each agent will resolve to without
   // chasing config files. Empty input clears the override → re-inherit fleet.
-  const fleetCliLabel = e.defaultCli || 'claude';
+  const fleetCliLabel = e.defaultCli || 'copilot';
   const fleetModelLabel = e.defaultModel ? String(e.defaultModel) : 'CLI default';
   const agentRows = Object.entries(agents).map(function([id, a]) {
     return '<tr>' +
@@ -98,6 +98,7 @@ async function openSettings() {
       settingsToggle('Auto-decompose', 'set-autoDecompose', e.autoDecompose !== false, 'Large implement items are auto-split into sub-tasks') +
       settingsToggle('Allow Temp Agents', 'set-allowTempAgents', !!e.allowTempAgents, 'Spawn ephemeral agents when all permanent agents are busy') +
       settingsToggle('Auto-archive Plans', 'set-autoArchive', !!e.autoArchive, 'Automatically archive plans after verify completes (off = manual archive via dashboard)') +
+      settingsToggle('Auto-consolidate Memory', 'set-autoConsolidateMemory', !!e.autoConsolidateMemory, 'Periodically spawn the KB sweep (dedup + compress + normalize knowledge/) from the engine tick on a 4h cadence. Inbox→notes consolidation already runs every tick (gated by the Consolidation Threshold above); this toggle controls only the KB sweep that was previously dashboard-button-only.') +
       settingsToggle('Auto-complete PRs', 'set-autoCompletePrs', !!e.autoCompletePrs, 'Auto-merge PRs when builds pass and review is approved (opt-in)') +
       settingsToggle('CC Worker Pool', 'set-ccUseWorkerPool', (e.ccUseWorkerPool === undefined ? ((e.ccCli || e.defaultCli) === 'copilot') : !!e.ccUseWorkerPool), 'Route Command Center / doc-chat through a persistent copilot --acp worker per tab instead of spawning a fresh CLI per turn. Copilot-only (Agent Client Protocol transport); Claude does not implement ACP, so this toggle has no effect when CC runtime is Claude. Default ON for copilot (cold-spawn ~20s on Windows); forced OFF for non-copilot CC runtimes regardless of this toggle.') +
     '</div>' +
@@ -127,6 +128,7 @@ async function openSettings() {
     '<div style="display:grid;grid-template-columns:1fr 1fr;gap:8px;margin-bottom:16px">' +
       settingsField('Eval Max Cost', 'set-evalMaxCost', e.evalMaxCost === null || e.evalMaxCost === undefined ? '' : e.evalMaxCost, '$', 'USD ceiling per work item across all eval iterations (blank = no limit)') +
       settingsField('Agent Busy Reassign', 'set-agentBusyReassignMs', e.agentBusyReassignMs || 600000, 'ms', 'Reassign work to another agent after it waits this long on a busy agent') +
+      settingsField('Max Retries Per Agent', 'set-maxRetriesPerAgent', e.maxRetriesPerAgent ?? 2, '', 'After the same agent fails the same work item this many times, the next retry reassigns to a different eligible agent (consults routing.md + availability). Falls back to the same agent only when no alternate is available. Counted separately from total maxRetries (which still caps overall retries).') +
       settingsField('Version Check Interval', 'set-versionCheckInterval', e.versionCheckInterval || 3600000, 'ms', 'How often to check npm for updates (default: 1 hour)') +
       settingsField('Ignored Comment Authors', 'set-ignoredCommentAuthors', (e.ignoredCommentAuthors || []).join(', '), '', 'Comma-separated usernames — comments auto-closed, never trigger fixes') +
     '</div>' +
@@ -404,10 +406,10 @@ async function initRuntimeFleetUI(engineCfg, agentsCfg) {
     runtimes = Array.isArray(d.runtimes) ? d.runtimes : [];
   } catch { /* ignore — we'll surface a free-text-only path below */ }
 
-  // Always include 'claude' as a fallback option even if /api/runtimes is empty;
+  // Always include 'copilot' as a fallback option even if /api/runtimes is empty;
   // legacy installs without the registry endpoint should still see something pickable.
-  const names = runtimes.length ? runtimes.map(rt => rt.name) : ['claude'];
-  const currentDefault = engineCfg.defaultCli || 'claude';
+  const names = runtimes.length ? runtimes.map(rt => rt.name) : ['copilot'];
+  const currentDefault = engineCfg.defaultCli || 'copilot';
   const currentCc = engineCfg.ccCli || '';
   cliSelect.innerHTML = names.map(n =>
     '<option value="' + escHtml(n) + '"' + (n === currentDefault ? ' selected' : '') + '>' + escHtml(n) + '</option>'
@@ -438,7 +440,7 @@ async function initRuntimeFleetUI(engineCfg, agentsCfg) {
   // this the input was free-text and a user could (and did) save an agent
   // with cli=claude + model=<some gpt> — invalid combination that crashed
   // dispatch. Refreshing on CLI change clears stale model values.
-  const fleetDefaultCli = engineCfg.defaultCli || 'claude';
+  const fleetDefaultCli = engineCfg.defaultCli || 'copilot';
   for (const cell of cliCells) {
     const agentId = cell.getAttribute('data-runtime-cli');
     const agent = (agentsCfg || {})[agentId] || {};
@@ -606,6 +608,7 @@ async function saveSettings() {
       autoDecompose: document.getElementById('set-autoDecompose').checked,
       allowTempAgents: document.getElementById('set-allowTempAgents').checked,
       autoArchive: document.getElementById('set-autoArchive').checked,
+      autoConsolidateMemory: document.getElementById('set-autoConsolidateMemory').checked,
       autoApplyReviewVote: document.getElementById('set-autoApplyReviewVote').checked,
       autoFixBuilds: document.getElementById('set-autoFixBuilds').checked,
       autoFixConflicts: document.getElementById('set-autoFixConflicts').checked,
@@ -621,6 +624,7 @@ async function saveSettings() {
       prPollCommentsEvery: document.getElementById('set-prPollCommentsEvery').value,
       evalMaxCost: document.getElementById('set-evalMaxCost').value || null,
       agentBusyReassignMs: document.getElementById('set-agentBusyReassignMs').value,
+      maxRetriesPerAgent: document.getElementById('set-maxRetriesPerAgent').value,
       ignoredCommentAuthors: document.getElementById('set-ignoredCommentAuthors').value,
       versionCheckInterval: document.getElementById('set-versionCheckInterval').value,
       // Runtime fleet (P-7a5c1f8e). Empty strings are intentional — they signal

package/dashboard/styles.css

@@ -260,6 +260,27 @@
   .pr-table-wrap { overflow-x: auto; }
   .pr-table { width: 100%; border-collapse: collapse; font-size: var(--text-md); table-layout: auto; }
   .pr-table th:last-child, .pr-table td:last-child { width: 36px; min-width: 36px; text-align: center; }
+
+  /* PR-page table variant (W-mpmwxn9h000bd2c2): fixed column widths with
+     ellipsis overflow, and the horizontal scrollbar is pinned inside the
+     viewport via a bounded-height container on the standalone /prs page so
+     it stays reachable without scrolling to the bottom of a tall table. */
+  .pr-table--prs { table-layout: fixed; width: 100%; min-width: 1420px; }
+  .pr-table--prs th, .pr-table--prs td { overflow: hidden; text-overflow: ellipsis; }
+  .pr-table--prs th:last-child, .pr-table--prs td:last-child { width: auto; min-width: 0; }
+  .pr-table--prs .pr-title { display: block; max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .pr-table--prs .pr-agent { display: inline-block; max-width: 100%; overflow: hidden; text-overflow: ellipsis; vertical-align: middle; white-space: nowrap; }
+  .pr-table--prs .pr-branch { max-width: 100%; }
+  .pr-table--prs .pr-desc { max-width: 100%; }
+  .pr-table--prs .pr-date { display: inline-block; max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; vertical-align: middle; }
+
+  /* Standalone /prs page only: bound the table-wrap height so the horizontal
+     scrollbar (bottom of the wrap) and the table header (sticky inside the
+     wrap) stay visible while the user is on this page. The modal "see all"
+     view uses the same colgroup but is unaffected — modal-body handles its
+     own scrolling. */
+  #pr-content .pr-table-wrap--prs { max-height: calc(100vh - 200px); overflow: auto; }
+  #pr-content .pr-table--prs thead th { position: sticky; top: 0; background: var(--surface); z-index: 1; }
   .pr-table th { text-align: left; color: var(--muted); font-weight: 500; font-size: var(--text-base); text-transform: uppercase; letter-spacing: 0.5px; padding: var(--space-4) var(--space-5); border-bottom: 1px solid var(--border); }
   .pr-table td { padding: var(--space-5); border-bottom: 1px solid var(--border); vertical-align: middle; white-space: nowrap; }
   .pr-table tr:last-child td { border-bottom: none; }