@yemi33/minions 0.1.2304 → 0.1.2306

package/dashboard/js/refresh.js

@@ -134,7 +134,8 @@ const RENDER_VERSIONS = {
   prdProgress: 2,
   prdPrs: 1,
   inbox: 2,
-  projects: 4,
+  // Bumped 4→5 for the clickable checkout-mode pill + picker (W-mr1b67zi0006b788).
+  projects: 5,
   notes: 1,
   prd: 3,
   prs: 3,
@@ -147,7 +148,7 @@ const RENDER_VERSIONS = {
   dispatch: 2,
   engineLog: 2,
   metrics: 1,
-  workItems: 5,
+  workItems: 7,
   skills: 1,
   commands: 1,
   mcpServers: 1,
@@ -1066,8 +1067,17 @@ let _refreshInFlight = false;
 // 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).
+// Trip conditions (2026-06-30): SUSTAINED failure only — the banner must never
+// flash while the dashboard is merely slow. 3 consecutive failed polls
+// (timeout/abort or 5xx). At the 4s cadence a wedged dashboard aborts each poll
+// at safeFetch's 15s timeout, so 3 in a row is ~45s of continuous
+// unresponsiveness — well beyond the legitimate 15-25s cold getStatus() rebuild
+// documented in restart-health.js. A truly-dead dashboard still trips promptly
+// (~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.
 // 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
@@ -1080,14 +1090,7 @@ let _lastStatusOkAt = Date.now();
 let _consecutiveStatusFails = 0;
 let _unreachableSince = 0; // 0 = currently reachable
 let _unreachableAgeTimer = null;
-// 3 + 20s (was 2 + 12s) — the prior thresholds tripped a banner on a single
-// safeFetch abort (timeout 15s in state.js) because the OR'd age side was
-// already satisfied. With safeFetch=15s, the age budget needs >15s to avoid
-// the trip-on-first-slow-response footgun. 3 consecutive fails ≈ 12s of real
-// outage at the 4s poll cadence, which still surfaces the banner promptly
-// during a real dashboard crash but tolerates one slow rebuild + retry.
 const _UNREACHABLE_FAIL_THRESHOLD = 3;
-const _UNREACHABLE_AGE_MS = 20000;
 // 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;
@@ -1345,8 +1348,9 @@ async function refresh(opts) {
       _diagEntry.error_message = String((e && e.message) || e);
     }
     _consecutiveStatusFails++;
-    const ageMs = Date.now() - _lastStatusOkAt;
-    if (_consecutiveStatusFails >= _UNREACHABLE_FAIL_THRESHOLD || ageMs > _UNREACHABLE_AGE_MS) {
+    // 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) {
       _markDashboardUnreachable(e);
     }
     // Backoff: once we've tripped the banner, throttle subsequent polls

package/dashboard/js/render-other.js

@@ -96,18 +96,266 @@ function _renderProjectBranch(p) {
 // is set, coding WIs author in isolated worktrees and only the named validation
 // type runs in-place on the live checkout. This is a materially different
 // dispatch profile from full-live, so it gets its own pill.
+// W-mr1b67zi0006b788: the pill is clickable — opens an inline picker (see
+// _openCheckoutModeMenu below) to switch between Worktrees / Live checkout /
+// Hybrid dispatch modes without leaving the Projects view. Shared
+// data-checkout-pill / role="button" / tabindex / aria-haspopup attributes
+// are attached to all three pill variants; the delegated listener wired at
+// the bottom of this file reads data-checkout-pill to know which project to
+// open the menu for.
 function _renderWorktreeModePill(p) {
   if (!p) return '';
+  const name = escHtml(p.name);
+  const common = ' data-checkout-pill="' + name + '" role="button" tabindex="0" aria-haspopup="true" aria-label="Change checkout mode"';
   if (p.checkoutMode === 'live') {
     if (p.liveValidationType) {
       const vt = escapeHtml(p.liveValidationType);
-      return ' <span class="project-mode-pill project-mode-hybrid" title="Hybrid live-validation — coding work items author in isolated worktrees; only the &quot;' + vt + '&quot; validation type runs in-place on the live checkout (capped to one mutating dispatch, refused on a dirty tree)">⚡ Hybrid · ' + vt + '</span>';
+      return ' <span class="project-mode-pill project-mode-hybrid project-mode-pill-clickable"' + common + ' title="Hybrid live-validation — coding work items author in isolated worktrees; only the &quot;' + vt + '&quot; validation type runs in-place on the live checkout (capped to one mutating dispatch, refused on a dirty tree). Click to change.">⚡ Hybrid · ' + vt + '</span>';
     }
-    return ' <span class="project-mode-pill project-mode-live" title="Live-checkout dispatch mode — agents run in-place inside the project working tree (no isolated worktree); capped to one mutating dispatch and refused on a dirty tree">⚡ Live checkout</span>';
+    return ' <span class="project-mode-pill project-mode-live project-mode-pill-clickable"' + common + ' title="Live-checkout dispatch mode — agents run in-place inside the project working tree (no isolated worktree); capped to one mutating dispatch and refused on a dirty tree. Click to change.">⚡ Live checkout</span>';
   }
-  return ' <span class="project-mode-pill project-mode-isolated" title="Worktree dispatch mode (default) — each agent runs in its own git worktree">Worktrees</span>';
+  return ' <span class="project-mode-pill project-mode-isolated project-mode-pill-clickable"' + common + ' title="Worktree dispatch mode (default) — each agent runs in its own git worktree. Click to change.">Worktrees</span>';
 }
 
+// Work-item types eligible for hybrid live-validation (W-mr1b67zi0006b788).
+// Mirrors the set the server documents for project.liveValidation.type;
+// intentionally excludes the illustrative "build-and-test" example from the
+// server comments since that isn't a real WORK_TYPE value.
+const CHECKOUT_MODE_HYBRID_TYPES = ['implement', 'fix', 'docs', 'decompose', 'explore', 'ask', 'review', 'test', 'verify', 'setup'];
+const CHECKOUT_MODE_HYBRID_DEFAULT_TYPE = 'test';
+
+function _findProjectInLastStatus(name) {
+  const projects = window._lastStatus && window._lastStatus.projects;
+  if (!Array.isArray(projects)) return null;
+  return projects.find(function(p) { return p.name === name; }) || null;
+}
+
+function _closeCheckoutModeMenu() {
+  const existing = document.getElementById('checkout-mode-menu');
+  if (existing) existing.remove();
+  document.removeEventListener('mousedown', _checkoutModeMenuOutsideClick, true);
+  document.removeEventListener('keydown', _checkoutModeMenuKeydown, true);
+}
+
+function _checkoutModeMenuOutsideClick(e) {
+  const menu = document.getElementById('checkout-mode-menu');
+  if (!menu) return;
+  if (menu.contains(e.target)) return;
+  if (e.target.closest && e.target.closest('[data-checkout-pill]')) return;
+  _closeCheckoutModeMenu();
+}
+
+function _checkoutModeMenuKeydown(e) {
+  if (e.key === 'Escape') _closeCheckoutModeMenu();
+}
+
+// Builds and positions the checkout-mode picker popover beneath the clicked
+// pill. No innerHTML is used here (createElement/textContent throughout) to
+// stay clear of the innerHTML lint gate (npm run lint).
+function _openCheckoutModeMenu(projectName, anchorEl) {
+  _closeCheckoutModeMenu();
+  const project = _findProjectInLastStatus(projectName);
+  if (!project) return;
+
+  const menu = document.createElement('div');
+  menu.id = 'checkout-mode-menu';
+  menu.className = 'checkout-mode-menu';
+  menu.setAttribute('role', 'menu');
+
+  const title = document.createElement('div');
+  title.className = 'checkout-mode-menu-title';
+  title.textContent = 'Checkout mode — ' + projectName;
+  menu.appendChild(title);
+
+  function addItem(labelText, mode, descText) {
+    const item = document.createElement('div');
+    item.className = 'checkout-mode-menu-item';
+    item.setAttribute('role', 'menuitemradio');
+    item.tabIndex = 0;
+    const label = document.createElement('div');
+    label.className = 'checkout-mode-menu-item-label';
+    label.textContent = labelText;
+    item.appendChild(label);
+    if (descText) {
+      const desc = document.createElement('div');
+      desc.className = 'checkout-mode-menu-item-desc';
+      desc.textContent = descText;
+      item.appendChild(desc);
+    }
+    const isActive = (mode === 'worktree' && project.checkoutMode !== 'live')
+      || (mode === 'live' && project.checkoutMode === 'live' && !project.liveValidationType)
+      || (mode === 'hybrid' && project.checkoutMode === 'live' && !!project.liveValidationType);
+    if (isActive) {
+      item.setAttribute('aria-checked', 'true');
+      item.classList.add('checkout-mode-menu-item-active');
+    } else {
+      item.setAttribute('aria-checked', 'false');
+    }
+    item.addEventListener('click', function() {
+      if (mode === 'hybrid') {
+        _renderCheckoutModeHybridStep(menu, projectName);
+        return;
+      }
+      _closeCheckoutModeMenu();
+      _applyCheckoutModeChange(projectName, mode === 'live' ? 'live' : 'worktree', null);
+    });
+    item.addEventListener('keydown', function(e) {
+      if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); item.click(); }
+    });
+    menu.appendChild(item);
+  }
+
+  addItem('Worktrees (default)', 'worktree', 'Each dispatch runs in its own isolated git worktree. Fully parallel, never touches your working directory.');
+  addItem('Live checkout', 'live', 'Agents run in-place in the project folder. One mutating dispatch at a time; refuses to run on a dirty tree.');
+  addItem('Hybrid dispatch…', 'hybrid', 'Coding work authors in isolated worktrees; only a chosen validation step (e.g. build-and-test) runs on the real checkout.');
+
+  document.body.appendChild(menu);
+  const rect = anchorEl.getBoundingClientRect();
+  menu.style.position = 'absolute';
+  menu.style.top = (window.scrollY + rect.bottom + 4) + 'px';
+  menu.style.left = (window.scrollX + rect.left) + 'px';
+
+  document.addEventListener('mousedown', _checkoutModeMenuOutsideClick, true);
+  document.addEventListener('keydown', _checkoutModeMenuKeydown, true);
+  const first = menu.querySelector('.checkout-mode-menu-item');
+  if (first) first.focus();
+}
+
+// Second step of the picker for hybrid mode: pick which work-item type runs
+// in-place on the live checkout while everything else authors in isolated
+// worktrees. Renders a <select> + Back/Apply into the existing menu element.
+function _renderCheckoutModeHybridStep(menu, projectName) {
+  const project = _findProjectInLastStatus(projectName);
+  while (menu.firstChild) menu.removeChild(menu.firstChild);
+
+  const title = document.createElement('div');
+  title.className = 'checkout-mode-menu-title';
+  title.textContent = 'Hybrid dispatch — ' + projectName;
+  menu.appendChild(title);
+
+  const label = document.createElement('div');
+  label.className = 'checkout-mode-menu-item';
+  label.textContent = 'Work-item type to validate live:';
+  menu.appendChild(label);
+
+  const select = document.createElement('select');
+  select.className = 'checkout-mode-menu-select';
+  CHECKOUT_MODE_HYBRID_TYPES.forEach(function(t) {
+    const opt = document.createElement('option');
+    opt.value = t;
+    opt.textContent = t;
+    select.appendChild(opt);
+  });
+  select.value = (project && project.liveValidationType && CHECKOUT_MODE_HYBRID_TYPES.includes(project.liveValidationType))
+    ? project.liveValidationType
+    : CHECKOUT_MODE_HYBRID_DEFAULT_TYPE;
+  menu.appendChild(select);
+
+  const actions = document.createElement('div');
+  actions.className = 'checkout-mode-menu-actions';
+
+  const backBtn = document.createElement('button');
+  backBtn.type = 'button';
+  backBtn.className = 'checkout-mode-menu-btn';
+  backBtn.textContent = 'Back';
+  backBtn.addEventListener('click', function() {
+    const anchor = document.querySelector('[data-checkout-pill="' + CSS.escape(projectName) + '"]');
+    _closeCheckoutModeMenu();
+    if (anchor) _openCheckoutModeMenu(projectName, anchor);
+  });
+  actions.appendChild(backBtn);
+
+  const applyBtn = document.createElement('button');
+  applyBtn.type = 'button';
+  applyBtn.className = 'checkout-mode-menu-btn checkout-mode-menu-btn-primary';
+  applyBtn.textContent = 'Apply';
+  applyBtn.addEventListener('click', function() {
+    const type = select.value;
+    _closeCheckoutModeMenu();
+    _applyCheckoutModeChange(projectName, 'live', type);
+  });
+  actions.appendChild(applyBtn);
+
+  menu.appendChild(actions);
+}
+
+// Applies a checkout-mode change: confirms via confirmDialog(), optimistically
+// flips the cached project entry and re-renders BEFORE awaiting the network
+// call (mirrors projectChipRemove / removePinnedNote), then POSTs to
+// /api/settings. On failure, reverts the optimistic flip, re-renders, and
+// shows an error toast.
+async function _applyCheckoutModeChange(projectName, newMode, liveValidationType) {
+  const project = _findProjectInLastStatus(projectName);
+  if (!project) return;
+  const label = newMode === 'worktree'
+    ? 'Worktrees'
+    : (liveValidationType ? ('Hybrid (' + liveValidationType + ')') : 'Live checkout');
+  const ok = await confirmDialog({
+    title: 'Change checkout mode?',
+    message: 'Switch "' + projectName + '" to ' + label + '? This changes how every future dispatch on this project runs.',
+    confirmLabel: 'Change mode',
+    cancelLabel: 'Cancel',
+    danger: newMode !== 'worktree',
+  });
+  if (!ok) return;
+
+  const prevMode = project.checkoutMode;
+  const prevType = project.liveValidationType;
+  const nextType = (newMode === 'live' && liveValidationType) ? liveValidationType : null;
+  // Optimistic flip BEFORE awaiting the API call (per dashboard convention —
+  // see projectChipRemove / removePinnedNote); reverted in the catch below.
+  project.checkoutMode = newMode;
+  project.liveValidationType = nextType;
+  if (window._lastStatus && Array.isArray(window._lastStatus.projects)) renderProjects(window._lastStatus.projects);
+
+  try {
+    const res = await safeFetch('/api/settings', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        projects: [{
+          name: projectName,
+          checkoutMode: newMode,
+          liveValidation: nextType ? { type: nextType } : null,
+        }],
+      }),
+    });
+    const result = await res.json().catch(function() { return {}; });
+    if (!res.ok) throw new Error((result && result.error) || ('HTTP ' + res.status));
+    showToast('cmd-toast', 'Checkout mode updated for "' + projectName + '".', true);
+  } catch (err) {
+    project.checkoutMode = prevMode;
+    project.liveValidationType = prevType;
+    if (window._lastStatus && Array.isArray(window._lastStatus.projects)) renderProjects(window._lastStatus.projects);
+    showToast('cmd-toast', 'Failed to update checkout mode: ' + (err && err.message || err), false);
+  }
+}
+
+// Delegated click/keydown on the persistent #projects-list container (its
+// children are replaced wholesale on every renderProjects() call, but the
+// container itself survives re-renders — see the Long-Running Commands /
+// event-delegation convention referenced in the playbook).
+(function _wireCheckoutModePillDelegation() {
+  const list = document.getElementById('projects-list');
+  if (!list) return;
+  list.addEventListener('click', function(e) {
+    const pill = e.target.closest('[data-checkout-pill]');
+    if (!pill) return;
+    e.stopPropagation();
+    const name = pill.getAttribute('data-checkout-pill');
+    _openCheckoutModeMenu(name, pill);
+  });
+  list.addEventListener('keydown', function(e) {
+    if (e.key !== 'Enter' && e.key !== ' ') return;
+    const pill = e.target.closest('[data-checkout-pill]');
+    if (!pill) return;
+    e.preventDefault();
+    e.stopPropagation();
+    const name = pill.getAttribute('data-checkout-pill');
+    _openCheckoutModeMenu(name, pill);
+  });
+})();
+
 function _projectCachePath(project) {
   return String((project && (project.localPath || project.path)) || '').replace(/\\/g, '/');
 }

package/dashboard/js/render-plans.js

@@ -371,7 +371,7 @@ function renderPlans(plans) {
       'onclick="event.stopPropagation();planDelete(\'' + escapeHtml(p.file) + '\')">Delete</button>' : '';
 
     const versionBadge = p.version ? ' <span style="font-size:var(--text-xs);font-weight:700;padding:1px 5px;border-radius:3px;background:rgba(56,139,253,0.15);color:var(--blue);vertical-align:middle">v' + p.version + '</span>' : '';
-    const statusColors = { 'completed': 'var(--green)', 'dispatched': 'var(--blue)', 'converting': 'var(--yellow)', 'paused': 'var(--muted)', 'awaiting-approval': 'var(--yellow)', 'approved': 'var(--green)', 'rejected': 'var(--red)', 'has-failures': 'var(--red)', 'revision-requested': 'var(--purple,#a855f7)', 'active': 'var(--muted)', 'draft': 'var(--muted)' };
+    const statusColors = { 'completed': 'var(--green)', 'dispatched': 'var(--blue)', 'converting': 'var(--yellow)', 'paused': 'var(--muted)', 'awaiting-approval': 'var(--yellow)', 'approved': 'var(--purple,#a855f7)', 'rejected': 'var(--red)', 'has-failures': 'var(--red)', 'revision-requested': 'var(--purple,#a855f7)', 'active': 'var(--muted)', 'draft': 'var(--muted)' };
     const cardClass = effectiveStatus === 'dispatched' || effectiveStatus === 'converting' ? 'working' : effectiveStatus === 'awaiting-approval' || effectiveStatus === 'paused' ? 'awaiting' : effectiveStatus;
     // P-e8d49105 — cross-repo plans surface every touched project as its
     // own badge. Single-project plans (and old PRDs without _projects)

package/dashboard/js/render-prs.js

@@ -646,7 +646,10 @@ async function togglePrObserve(btn) {
   try {
     const res = await fetch('/api/pull-requests/observe', {
       method: 'POST', headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ host, slug, number, observe: next })
+      // Canonical contextOnly is the primary payload (P-2b6e4d81); the
+      // legacy `observe` body param remains a server-side back-compat
+      // fallback for any other caller, so the client no longer sends it.
+      body: JSON.stringify({ host, slug, number, contextOnly: !next })
     });
     if (!res.ok) {
       const d = await res.json().catch(() => ({}));

package/dashboard/js/render-utils.js

@@ -114,6 +114,19 @@ function ccSegmentsApplyChunk(segments, text, segmentId) {
   var last = segments.length ? segments[segments.length - 1] : null;
   if (hasId) {
     if (last && last.kind === 'text' && last.id === segmentId) { last.text = text; return segments; }
+    // W-mr1bgfyr — a reconnect replay (or any other id-less push, see the
+    // heuristic branch below) leaves the trailing text segment with `id:
+    // null` even though the resumed live stream now carries a real
+    // segmentId for that SAME logical block. Without this, the id
+    // mismatch (null !== segmentId) opened a brand-new duplicate text
+    // segment on every following chunk, rendering as a second bubble/block
+    // stacked under the first with a little more text each time instead of
+    // updating in place. Adopt the id and merge into the existing segment.
+    if (last && last.kind === 'text' && last.id === null) {
+      last.text = _ccSegMergeText(last.text, text);
+      last.id = segmentId;
+      return segments;
+    }
     segments.push({ kind: 'text', id: segmentId, text: text });
     return segments;
   }

package/dashboard/js/render-work-items.js

@@ -42,6 +42,7 @@ const _WI_ENRICHMENT_FIELDS = [
 //   * already_dispatched — engine reconciles on next tick
 //   * branch_locked — wait for the holding dispatch
 //   * dependency_unmet — auto-clears when upstream dep finishes (engine discovery loop + DEPENDENCY_MET watch)
+//   * live_checkout_busy — one live-mode dispatch at a time; clears when running dispatch finishes
 //
 // Returns { kind, short, full } when the item needs attention, else null.
 // Pure helper (no DOM / escapeHtml deps) so it can be unit-tested in Node.
@@ -219,7 +220,7 @@ function wiRow(item) {
             + escapeHtml(((item._managedSpawnPartial.healthy || []).length) + '/' + (((item._managedSpawnPartial.healthy || []).length) + item._managedSpawnPartial.failed.length))
             + ' healthy</span>'
         : '') +
-      (item._skipReason && item.status === 'pending' ? ' <span style="font-size:var(--text-xs);color:var(--yellow);margin-left:4px" title="Dispatch blocked: ' + escapeHtml(item._skipReason) + (item._blockedBy ? ' (by ' + escapeHtml(item._blockedBy) + ')' : '') + '">' + escapeHtml(item._skipReason.replace(/_/g, ' ')) + (item._blockedBy ? ' <span style="color:var(--muted)">(' + escapeHtml(item._blockedBy) + ')</span>' : '') + '</span>' : '') +
+      (item._skipReason && item.status === 'pending' && item._skipReason !== 'live_checkout_busy' ? ' <span style="font-size:var(--text-xs);color:var(--yellow);margin-left:4px" title="Dispatch blocked: ' + escapeHtml(item._skipReason) + (item._blockedBy ? ' (by ' + escapeHtml(item._blockedBy) + ')' : '') + '">' + escapeHtml(item._skipReason.replace(/_/g, ' ')) + (item._blockedBy ? ' <span style="color:var(--muted)">(' + escapeHtml(item._blockedBy) + ')</span>' : '') + '</span>' : '') +
       (item.status === 'failed' ? ' ' + wiRetryBtn(item) : '') +
     '</td>' +
     '<td>' +
@@ -875,10 +876,17 @@ function _wiRenderDetail(item) {
   // Artifacts — branch (non-navigation) + navigation chips routed through
   // renderArtifactLink so chip click → openArtifact() → modal-stack push +
   // URL hash + browser-Back integration come for free (P-e265cd31).
-  // P-79b47b0c — also surface item._source (the WI's raw source file) as a
-  // dedicated chip when it isn't already covered by arts.plan / arts.prd /
-  // arts.sourcePlan. Chip type is inferred from the file extension (.md →
-  // plan, .json → prd).
+  // NOTE (issue #603): item._source is the WI's *project name* (stamped by
+  // fetchWorkItemsFromDisk above / used by every action button to route
+  // retry/cancel/delete/etc.), NOT a plan/PRD file id. A prior "Source" chip
+  // here treated item._source as if it held a genuine source-plan/PRD
+  // filename, which rendered a bogus chip labeled with the project name on
+  // nearly every work item and 404'd when clicked (there is no plan/PRD
+  // named e.g. "src"). The genuine source-plan/PRD case is already fully
+  // covered by arts.plan / arts.prd / arts.sourcePlan below, which are
+  // populated server-side from the WI's real sourcePlan/_planFileName/
+  // planFile fields (engine/queries.js) — no separate item._source-based
+  // chip is needed.
   var arts = item._artifacts || {};
   var artPills = '';
   var branchStyle = 'display:inline-flex;align-items:center;gap:3px;padding:2px 8px;border-radius:10px;font-size:var(--text-sm);background:var(--surface2);border:1px solid var(--border);color:var(--text);cursor:default';
@@ -886,15 +894,6 @@ function _wiRenderDetail(item) {
   if (arts.plan) artPills += renderArtifactLink({ type: 'plan', id: arts.plan, label: 'Plan' }) + ' ';
   if (arts.prd) artPills += renderArtifactLink({ type: 'prd', id: arts.prd, label: 'PRD' }) + ' ';
   if (arts.sourcePlan) artPills += renderArtifactLink({ type: 'plan', id: arts.sourcePlan, label: 'Source Plan' }) + ' ';
-  // Source chip (item._source) — render when it's a file path that isn't
-  // already represented in arts.plan / arts.prd / arts.sourcePlan.
-  if (item._source && typeof item._source === 'string' && item._source !== 'central') {
-    var sourceAlreadyShown = arts.plan === item._source || arts.prd === item._source || arts.sourcePlan === item._source;
-    if (!sourceAlreadyShown) {
-      var sourceType = item._source.endsWith('.json') ? 'prd' : 'plan';
-      artPills += renderArtifactLink({ type: sourceType, id: item._source, label: 'Source', title: item._source }) + ' ';
-    }
-  }
   if (arts.notes && arts.notes.length > 0) {
     arts.notes.forEach(function(n) {
       var noteFile = (n && typeof n === 'object') ? (n.file || n) : String(n || '');

package/dashboard/js/settings.js

@@ -282,8 +282,8 @@ async function openSettings() {
       '<div data-search="' + escHtml(wtModeSearch) + '" style="margin-bottom:6px">' +
         '<label style="font-size:var(--text-sm);color:var(--muted);display:block;margin-bottom:2px">Checkout mode</label>' +
         '<select id="set-checkoutMode-' + escHtml(p.name) + '" data-checkout-mode-select="' + escHtml(p.name) + '" style="width:100%;padding:4px 6px;background:var(--surface);border:1px solid var(--border);border-radius:4px;color:var(--text);font-size:var(--text-md)">' +
-          '<option value="worktree"' + (currentWtMode === 'worktree' ? ' selected' : '') + '>Worktree (default)</option>' +
-          '<option value="live"' + (currentWtMode === 'live' ? ' selected' : '') + '>Live checkout</option>' +
+          '<option value="worktree" title="Each dispatch runs in its own isolated git worktree. Fully parallel, never touches your working directory."' + (currentWtMode === 'worktree' ? ' selected' : '') + '>Worktree (default)</option>' +
+          '<option value="live" title="Agents run in-place in the project folder. One mutating dispatch at a time; refuses to run on a dirty tree."' + (currentWtMode === 'live' ? ' selected' : '') + '>Live checkout</option>' +
         '</select>' +
         '<div data-checkout-mode-chip="' + escHtml(p.name) + '" style="' + (currentWtMode === 'live' ? '' : 'display:none;') + 'margin-top:6px;padding:6px 8px;background:rgba(234,179,8,0.12);border:1px solid var(--yellow);border-radius:4px;color:var(--yellow);font-size:var(--text-xs);line-height:1.4">' +
           '⚠ Live mode: dispatches run directly in this repo\'s checkout. Only one mutating dispatch runs at a time. Dirty working trees block dispatch — commit or stash before running.' +
@@ -384,7 +384,7 @@ async function openSettings() {
       settingsToggle('Auto-reap orphan worktree holders', 'set-autoReapOrphanWorktreeHolders', !!e.autoReapOrphanWorktreeHolders,
         'When ON, the periodic orphan-worktree sweep automatically kills unambiguous orphan `spawn-agent.js` processes holding a stuck worktree\'s cwd (Windows file-lock pattern, e.g. W-mq1k8z6o003acd89 / PID 16828). Safe-reap criteria: cmdline must match spawn-agent.js, reference the worktree basename, AND process age must exceed `engine.agentTimeout * 2`. Default OFF because killing a foreign process is destructive. The holder SCAN runs either way and is appended to the escalation inbox note.') +
       settingsToggle('Live-checkout auto-reset (fleet-wide)', 'set-liveCheckoutAutoReset', !!e.liveCheckoutAutoReset,
-        'When ON, a dirty or broken live-checkout (in-place) tree is force-recovered before dispatch via `git fetch origin` + `git reset --hard origin/<branch>` instead of failing the dispatch with non-retryable LIVE_CHECKOUT_DIRTY. This is the FLEET-WIDE fallback; a per-project `liveCheckoutAutoReset` in config.json overrides it. Default OFF because the reset is DESTRUCTIVE — it discards the operator\'s uncommitted changes in the live checkout (a `live-checkout-autoreset-<workItem>` inbox note records exactly what was discarded for reflog recovery). Only affects projects running in live/in-place checkout mode.') +
+        'When ON, a dirty or broken live-checkout (in-place) tree is force-recovered before dispatch via `git fetch origin` + `git reset --hard origin/<branch>` instead of failing the dispatch with non-retryable LIVE_CHECKOUT_DIRTY. This is the FLEET-WIDE fallback; a per-project `liveCheckoutAutoReset` in config.json overrides it. Default ON — discarding disposable dirt keeps live-checkout branches aligned with origin instead of accumulating auto-save WIP commits; the reset is DESTRUCTIVE (it discards the operator\'s uncommitted changes in the live checkout, and a `live-checkout-autoreset-<workItem>` inbox note records exactly what was discarded for reflog recovery), so set it OFF for live checkouts whose local drift you want preserved. Only affects projects running in live/in-place checkout mode.') +
     '</div>' +
     '<div class="settings-grid-2">' +
       settingsField('CC Session Idle Timeout', 'set-ccWorkerIdleTimeoutMs', Math.round((e.ccWorkerIdleTimeoutMs || 1800000) / 60000), 'minutes', 'How long a persistent `copilot --acp` CC worker stays warm with no activity before the idle reaper kills it. After a reap the next message cold-spawns a FRESH session with no memory of prior turns and CC shows a "context cleared after inactivity" notice. Shorter = less idle memory/process footprint; longer = more context durability across gaps between messages. Only affects the Copilot worker-pool path (CC Worker Pool ON). Clamped 1–480 minutes.') +

package/dashboard/layout.html

@@ -17,6 +17,19 @@
       document.documentElement.setAttribute('data-font-size', (v && valid[v]) ? v : 'small');
     } catch (e) { /* private mode / disabled storage — fall through to default */ }
   })();
+  // W-mqrdggys000f94a4 — chrome-off "embed" mode. When the SPA is loaded with
+  // ?embed=1 (e.g. inside the slim cockpit's Queued-work iframe pointed at
+  // /work?embed=1), tag <html> so the embed CSS hides the global chrome
+  // (header, sidebar, projects bar, banners) and the iframed page renders as
+  // just its panel. Applied in <head> so the first paint already omits the
+  // chrome (no flash of the full layout).
+  (function() {
+    try {
+      if (/[?&]embed=1(?:&|$)/.test(window.location.search)) {
+        document.documentElement.classList.add('embed');
+      }
+    } catch (e) { /* defensive — never block boot on a URL parse quirk */ }
+  })();
 </script>
 <style>/* __CSS__ */</style>
 </head>