@yemi33/minions 0.1.2303 → 0.1.2305

package/dashboard/js/command-center.js

@@ -1300,7 +1300,9 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
         _cleanupStreamDiv();
         if (evt.sessionReset) {
           var resetText;
-          if (evt.sessionResetReason === 'runtimeChanged' && evt.previousRuntime && evt.currentRuntime) {
+          if (evt.sessionResetReason === 'idleReap') {
+            resetText = 'Context window cleared after inactivity — fresh session started.';
+          } else if (evt.sessionResetReason === 'runtimeChanged' && evt.previousRuntime && evt.currentRuntime) {
             resetText = 'Runtime switched (' + escHtml(evt.previousRuntime) + ' → ' + escHtml(evt.currentRuntime) + ') — started a fresh session and carried over recent history.';
           } else if (evt.sessionResetReason === 'promptChanged') {
             resetText = 'Minions was updated — started a fresh session and carried over recent history.';

package/dashboard/js/refresh.js

@@ -147,7 +147,7 @@ const RENDER_VERSIONS = {
   dispatch: 2,
   engineLog: 2,
   metrics: 1,
-  workItems: 5,
+  workItems: 6,
   skills: 1,
   commands: 1,
   mcpServers: 1,
@@ -166,7 +166,8 @@ const RENDER_VERSIONS = {
   // Bumped to 2 by W-mpmwxkcn000646cc (left-rail tabbed Settings layout).
   // Bumped to 3 by W-mqk2s8q1 (Advanced → Diagnostics: relocated the diag button).
   // Bumped to 4 by W-mqrdavob (Agents table: per-agent charter editor column).
-  settings: 4,
+  // Bumped to 5 by W-mr0qs0vw (Worker Pool: CC session idle-timeout field).
+  settings: 5,
 };
 const _sectionCache = {};
 const _lastValueByKey = {};

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>' +

package/dashboard/js/settings.js

@@ -387,6 +387,7 @@ async function openSettings() {
         '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.') +
     '</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.') +
       settingsField('Worktree Create Timeout', 'set-worktreeCreateTimeout', e.worktreeCreateTimeout || 300000, 'ms', 'Timeout for git worktree add (increase for large repos/Windows)') +
       settingsField('Worktree Create Retries', 'set-worktreeCreateRetries', e.worktreeCreateRetries || 1, '', 'Retry count for transient worktree add failures (0-3)') +
       settingsField('Worktree Root', 'set-worktreeRoot', e.worktreeRoot || '../worktrees', '', 'Relative or absolute path for git worktrees; on Windows prefer a short path like C:\\wt') +
@@ -1091,6 +1092,14 @@ async function saveSettings() {
       ccModel: (document.getElementById('set-ccModel')?.value ?? '').trim(),
       ccEffort: document.getElementById('set-ccEffort').value || null,
       ccTurnTimeoutMs: document.getElementById('set-ccTurnTimeoutMs')?.value,
+      // Settings UI presents the idle timeout in minutes for readability; the
+      // engine stores ms (ENGINE_DEFAULTS.ccWorkerIdleTimeoutMs). Convert here;
+      // the server clamps to [60000, 28800000] ms. undefined when blank so the
+      // server keeps the prior value rather than zeroing it.
+      ccWorkerIdleTimeoutMs: (function () {
+        var m = Number(document.getElementById('set-ccWorkerIdleTimeoutMs')?.value);
+        return (Number.isFinite(m) && m > 0) ? Math.round(m * 60000) : undefined;
+      })(),
       claudeBareMode: !!document.getElementById('set-claudeBareMode')?.checked,
       claudeFallbackModel: (document.getElementById('set-claudeFallbackModel')?.value ?? '').trim(),
       copilotFallbackModel: (document.getElementById('set-copilotFallbackModel')?.value ?? '').trim(),

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>

package/dashboard/slim/js/chat.js

@@ -347,6 +347,24 @@
     scrollToBottom();
     return div;
   }
+  // W-mr0qs0vw — centered, muted system notice row (e.g. a session reset after
+  // the CC worker pool's idle reaper fires). Mirrors the classic dashboard's
+  // session-reset banner so both surfaces read identically. Used live from
+  // command-send.js and replayed on restore via rerenderHistory.
+  function _sessionResetNoticeText(reason) {
+    if (reason === 'idleReap') return 'Context window cleared after inactivity — fresh session started.';
+    if (reason === 'promptChanged') return 'Minions was updated — fresh session started.';
+    if (reason === 'runtimeChanged') return 'Runtime switched — fresh session started.';
+    return 'Session reset — fresh session started.';
+  }
+  function appendSystemNotice(text) {
+    var div = document.createElement('div');
+    div.className = 'chat-system-notice';
+    div.textContent = text;
+    _appendMsgEl(div);
+    scrollToBottom();
+    return div;
+  }
 
   // ── Queued-message rendering (W-mqayw3x6) ──────────────────────────
   function _getQueue() {
@@ -617,6 +635,7 @@
       for (var i = 0; i < messages.length; i++) {
         var m = messages[i];
         if (m.role === 'action') appendActionStatus(m.severity || '', m.text || '');
+        else if (m.role === 'system') appendSystemNotice(m.text || '');
         else appendBubble(m.role, m.text || '', m.toolCalls);
       }
     }

package/dashboard/slim/js/command-send.js

@@ -190,6 +190,16 @@
         if (doneEvt.actions && doneEvt.actions.length > 0) {
           renderActionResults(turnTabId, doneEvt.actions, doneEvt.actionResults || []);
         }
+        // W-mr0qs0vw — the CC worker pool's idle reaper (or a prompt/runtime
+        // change) can reset the session between turns. Surface the same centered
+        // system notice the classic dashboard shows so slim users aren't left
+        // silently losing context. Persist it (role:'system') so it replays on
+        // restore; render live only when this turn's tab is the visible one.
+        if (doneEvt.sessionReset) {
+          var resetMsg = _sessionResetNoticeText(doneEvt.sessionResetReason);
+          if (turnTabId === tabId) appendSystemNotice(resetMsg);
+          recordTabMessage(turnTabId, { role: 'system', text: resetMsg });
+        }
         // Refresh status + history opportunistically — actions probably
         // changed something.
         scheduleStatusRefresh(800);

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

@@ -123,135 +123,23 @@
     });
   }
 
-  // Collapsible "Completed work" section appended to the queued popout (only).
-  // Collapsed by DEFAULT; clicking (or Enter/Space on) the header toggles the
-  // list. Sources data.dispatch.completed — the same recent window the slim
-  // History feed reads (capped to the last 20 by the /api/status snapshot) —
-  // so it adds no new API calls. Status semantics reuse completionStatus /
-  // completionTitle for parity with the History feed.
-  function renderCompletedSection(body, data) {
-    var dispatch = data.dispatch || {};
-    // Snapshot delivers completed oldest→newest; reverse for most-recent-first.
-    var completed = Array.isArray(dispatch.completed) ? dispatch.completed.slice().reverse() : [];
-
-    var section = document.createElement('div');
-    section.className = 'tile-completed-section collapsed';
-
-    var head = document.createElement('div');
-    head.className = 'tile-completed-section-head';
-    head.setAttribute('role', 'button');
-    head.setAttribute('tabindex', '0');
-    head.setAttribute('aria-expanded', 'false');
-    var caret = document.createElement('span');
-    caret.className = 'tile-caret';
-    caret.textContent = '▸';
-    var label = document.createElement('span');
-    label.className = 'tile-completed-section-title';
-    label.textContent = 'Completed work (' + completed.length + ')';
-    head.appendChild(caret);
-    head.appendChild(label);
-
-    var listWrap = document.createElement('div');
-    listWrap.className = 'tile-completed-section-body';
-    listWrap.hidden = true;
-
-    if (!completed.length) {
-      tileEmpty(listWrap, 'No completed work yet.');
-    } else {
-      completed.forEach(function(c) {
-        var who = c.agentName || c.agent || c.dispatched_to || '—';
-        var when = c.completed_at || c.completedAt || c.endedAt || c.started_at || c.startedAt;
-        var status = completionStatus(c);
-        var chip = status === 'ok' ? { text: 'done', cls: 'green' }
-                 : status === 'warn' ? { text: 'partial', cls: 'amber' }
-                 : { text: 'failed', cls: 'red' };
-        listWrap.appendChild(tileCard({
-          title: completionTitle(c),
-          meta: who + (when ? ' · completed ' + relTime(when) : ''),
-          chip: chip,
-        }));
-      });
-    }
-
-    function toggle() {
-      var open = !section.classList.toggle('collapsed');
-      head.setAttribute('aria-expanded', open ? 'true' : 'false');
-      caret.textContent = open ? '▾' : '▸';
-      listWrap.hidden = !open;
-    }
-    head.addEventListener('click', toggle);
-    head.addEventListener('keydown', function(ev) {
-      if (ev.key === 'Enter' || ev.key === ' ') { ev.preventDefault(); toggle(); }
-    });
-
-    section.appendChild(head);
-    section.appendChild(listWrap);
-    body.appendChild(section);
-  }
-
-  // Collapsible "Pending work items" section appended to the queued popout
-  // (W-mqv1xbcm). Sources data.workItems filtered to status === 'pending' — the
-  // same /api/work-items slice the slim poll merges onto the snapshot — so it
-  // adds no new API calls and refreshes whenever the popout is re-opened.
-  // Expanded by DEFAULT (more prominent than the collapsed Completed section)
-  // since these are the queued WIs the operator most wants to scan. Mirrors
-  // renderCompletedSection's structure + tileCard usage; all text via
-  // textContent (no innerHTML) to keep the SEC-03 baseline clean. Each card
-  // shows title, id, project (project || _source), type, and the engine's
-  // _pendingReason as a chip when set.
-  function renderPendingSection(body, data) {
-    var pending = (Array.isArray(data.workItems) ? data.workItems : []).filter(function(w) {
-      return w && w.status === 'pending';
-    });
-
-    var section = document.createElement('div');
-    section.className = 'tile-completed-section';
-
-    var head = document.createElement('div');
-    head.className = 'tile-completed-section-head';
-    head.setAttribute('role', 'button');
-    head.setAttribute('tabindex', '0');
-    head.setAttribute('aria-expanded', 'true');
-    var caret = document.createElement('span');
-    caret.className = 'tile-caret';
-    caret.textContent = '▾';
-    var label = document.createElement('span');
-    label.className = 'tile-completed-section-title';
-    label.textContent = 'Pending work items (' + pending.length + ')';
-    head.appendChild(caret);
-    head.appendChild(label);
-
-    var listWrap = document.createElement('div');
-    listWrap.className = 'tile-completed-section-body';
-
-    if (!pending.length) {
-      tileEmpty(listWrap, 'No pending work items.');
-    } else {
-      pending.forEach(function(w) {
-        var project = w.project || w._source;
-        var meta = [w.id || null, project || null, w.type || null].filter(Boolean).join(' · ');
-        var card = { title: w.title || w.id || '(untitled)', meta: meta };
-        if (w._pendingReason) {
-          card.chip = { text: String(w._pendingReason).replace(/_/g, ' '), cls: 'amber' };
-        }
-        listWrap.appendChild(tileCard(card));
-      });
-    }
-
-    function toggle() {
-      var open = !section.classList.toggle('collapsed');
-      head.setAttribute('aria-expanded', open ? 'true' : 'false');
-      caret.textContent = open ? '▾' : '▸';
-      listWrap.hidden = !open;
-    }
-    head.addEventListener('click', toggle);
-    head.addEventListener('keydown', function(ev) {
-      if (ev.key === 'Enter' || ev.key === ' ') { ev.preventDefault(); toggle(); }
-    });
-
-    section.appendChild(head);
-    section.appendChild(listWrap);
-    body.appendChild(section);
+  // Queued-work tile body — reuses the LITERAL classic dashboard Work Items
+  // screen instead of a slim-specific list, so there is one work-items UI, not
+  // two (W-mqrdggys000f94a4 / "reuse, don't fork"). Slim and classic are two
+  // separate IIFE bundles with no shared scope, so we can't call the classic
+  // renderWorkItems() in-process; instead we embed the real /work screen in an
+  // iframe with the chrome-off ?embed=1 mode. The iframed page IS the classic
+  // screen — full filter/sort + every row action (edit/cancel/retry/archive/
+  // delete/feedback), backed by the same /api/work-items data + endpoints —
+  // with zero duplicated rendering logic. Classic is reachable at /work even
+  // with slim-ux ON (only / is taken over). Built with createElement (no
+  // innerHTML) to satisfy the dashboard no-unsanitized lint gate.
+  function renderQueuedWorkBody(body) {
+    var frame = document.createElement('iframe');
+    frame.className = 'slim-work-embed';
+    frame.src = '/work?embed=1';
+    frame.title = 'Work Items';
+    body.appendChild(frame);
   }
 
   function renderPrTileBody(body, data) {
@@ -375,7 +263,7 @@
   var TILE_VIEWS = {
     engine:     { title: 'Engine',            render: renderEngineTileBody },
     dispatches: { title: 'Active dispatches', render: function(body, data) { renderDispatchTileBody(body, data, true); } },
-    queued:     { title: 'Queued work',       render: function(body, data) { renderDispatchTileBody(body, data, false); renderPendingSection(body, data); renderCompletedSection(body, data); } },
+    queued:     { title: 'Queued work',       render: function(body) { renderQueuedWorkBody(body); } },
     prs:        { title: 'Pull requests',     render: renderPrTileBody },
     watches:    { title: 'Watches',           render: renderWatchTileBody },
   };
@@ -400,6 +288,9 @@
     // The "+ Link PR" header chip only applies to the PR list.
     var headerChip = document.getElementById('slim-tile-modal-linkpr');
     if (headerChip) headerChip.style.display = (key === 'prs') ? '' : 'none';
+    // The queued tile embeds the full classic /work screen in an iframe — widen
+    // the modal + drop the body padding so the embedded table gets real estate.
+    modal.classList.toggle('tile-modal--work', key === 'queued');
     view.render(body, lastStatusData || {});
     modal.classList.add('open');
   }

package/dashboard/slim/styles.css

@@ -680,6 +680,15 @@
     /* Cockpit-tile detail modal: list of dispatches / PRs / watches, or a
        key/value engine readout (reuses .agent-detail-row). */
     #slim-tile-modal .modal { width: 720px; max-width: calc(100vw - 32px); }
+    /* W-mqrdggys000f94a4 — the Queued-work tile embeds the full classic /work
+       screen in an iframe; widen the modal + remove body padding so the
+       embedded work-items table gets the full width/height. */
+    #slim-tile-modal.tile-modal--work .modal { width: 1180px; }
+    #slim-tile-modal.tile-modal--work .modal-body { padding: 0; }
+    .slim-work-embed {
+      display: block; width: 100%; height: calc(100vh - 160px); min-height: 360px;
+      border: 0; background: var(--bg);
+    }
     .tile-item {
       display: block;
       text-decoration: none;
@@ -712,20 +721,6 @@
     .tile-chip.blue  { background: rgba(88, 166, 255, 0.12); color: var(--blue);  border-color: var(--blue); }
     .tile-empty { color: var(--muted); font-style: italic; font-size: var(--text-md); }
 
-    /* Collapsible "Completed work" section in the queued popout. Collapsed by
-       default; the caret rotates and the body unhides on toggle. */
-    .tile-completed-section { margin-top: 12px; border-top: 1px solid var(--border); padding-top: 10px; }
-    .tile-completed-section-head {
-      display: flex; align-items: center; gap: 6px;
-      cursor: pointer; user-select: none;
-      font-size: var(--text-md); font-weight: 600; color: var(--text);
-      padding: 2px 0;
-    }
-    .tile-completed-section-head:hover { color: var(--blue); }
-    .tile-completed-section-head:focus-visible { outline: 1px solid var(--blue); outline-offset: 2px; border-radius: var(--radius); }
-    .tile-caret { font-size: var(--text-sm); color: var(--muted); width: 12px; display: inline-block; text-align: center; }
-    .tile-completed-section-body { margin-top: 8px; }
-
     /* Collapsible PR sections (Active / Merged-Completed / Abandoned). Uses
        native <details>/<summary> — no JS wiring needed for the toggle. */
     .tile-section { margin-bottom: 10px; }
@@ -898,6 +893,18 @@
     .chat-action.ok    { color: var(--green); }
     .chat-action.warn  { color: var(--amber); }
     .chat-action.err   { color: var(--red); }
+    /* W-mr0qs0vw — centered, muted session-reset notice (idle-reap / prompt /
+       runtime change). Mirrors the classic dashboard's surface2 banner. */
+    .chat-system-notice {
+      align-self: center;
+      max-width: 90%;
+      text-align: center;
+      padding: var(--space-1) var(--space-3);
+      border-radius: 6px;
+      font-size: var(--text-base);
+      background: var(--surface2);
+      color: var(--muted);
+    }
 
     /* Lightweight markdown styling inside assistant bubbles. */
     .chat-msg.assistant code,

package/dashboard/styles.css

@@ -1547,3 +1547,24 @@
   .cc-error strong { color: var(--red); }
   .cc-error code { font-family: monospace; font-size: var(--text-xs);
     color: var(--muted); }
+
+  /* W-mqrdggys000f94a4 — chrome-off "embed" mode (?embed=1). Strips the global
+     dashboard chrome so a single page (e.g. /work?embed=1) can be iframed inside
+     the slim cockpit's Queued-work modal and render as just its panel. The
+     html.embed class is applied in layout.html's head before first paint. */
+  html.embed body > header,
+  html.embed #projects-bar,
+  html.embed #setup-banner,
+  html.embed #fre-banner,
+  html.embed .engine-alert,
+  html.embed .paused-banner,
+  html.embed .sidebar,
+  html.embed #cc-drawer,
+  html.embed #cc-overlay { display: none !important; }
+  /* Do NOT override .page-layout to display:block here — that detaches
+     .page-content from its bounded-height flex parent, so it grows to full
+     content height and the fixed-height iframe clips it with no scrollbar (the
+     Queued-work popup "doesn't scroll"). The sidebar is hidden above, so the
+     base .page-layout flex row already gives .page-content full width plus a
+     bounded height to scroll within. */
+  html.embed .page-content { padding: 12px 16px; overflow-y: auto; }

package/dashboard.js

@@ -254,6 +254,14 @@ function reloadConfig() {
   CONFIG = queries.getConfig();
   PROJECTS = _getProjects(CONFIG);
   ensureConfiguredProjectStateFiles();
+  // Keep the ACP worker pool's idle-reaper window in sync with config so a
+  // Settings change takes effect without a dashboard restart (W-mr0qs0vw). The
+  // pool stays dependency-free at load and relies on this push.
+  try {
+    const idleMs = Number(CONFIG.engine?.ccWorkerIdleTimeoutMs)
+      || shared.ENGINE_DEFAULTS.ccWorkerIdleTimeoutMs;
+    ccWorkerPool.setIdleTimeoutMs(idleMs);
+  } catch { /* invalid value or pool unavailable — keep prior window */ }
 }
 ensureConfiguredProjectStateFiles();
 
@@ -4676,7 +4684,7 @@ async function _preflightModelCheck({ runtime: cliOverride, model: modelOverride
  * Why we deliberately skip `docSessions` updates on this path: pool ACP
  * session IDs are valid only inside the live worker process. Persisting
  * them risks the next call seeing a "session unchanged + _docHash
- * matches → skip document content" path after the idle reaper (10 min)
+ * matches → skip document content" path after the idle reaper (30 min)
  * kills the worker, silently starving the new ACP session of the
  * document body. Always re-sending extraContext is correctness-safe; the
  * pool's warm-process saving is preserved regardless.
@@ -5275,7 +5283,7 @@ function _docChatResultLooksSuccessful(result) {
 // usePool: when true (caller is on the worker-pool path), force `existing=null`
 // so the docUnchanged optimization never fires. Pool ACP session IDs are valid
 // only inside the live worker process; when the idle reaper kills the worker
-// (10 min), the server restarts, or the operator flips ccUseWorkerPool with
+// (30 min), the server restarts, or the operator flips ccUseWorkerPool with
 // prior legacy history on disk, a stale docSessions._docHash matching the
 // current doc would otherwise emit docUnchanged:true → _formatDocChatContext
 // replaces the doc body with "unchanged from the previous turn" → the fresh
@@ -10326,6 +10334,20 @@ What would you like to discuss or change? When you're happy, say "approve" and I
             tabSessionId = tabEntry.sessionId;
           }
         }
+        // W-mr0qs0vw — if the persistent ACP worker for this tab was killed by
+        // the idle reaper since the last turn, the next message cold-spawns a
+        // fresh session with NO memory of prior turns. Drain the pool's one-shot
+        // reap flag and classify as 'idleReap' so CC surfaces a "context
+        // cleared after inactivity" notice. A stronger reset reason already set
+        // this turn (prompt/runtime change) wins; we still drain so the flag
+        // never lingers into a later turn.
+        let _wasIdleReaped = false;
+        try { _wasIdleReaped = ccWorkerPool.consumeIdleReapNotice(body.tabId || 'default'); } catch { /* pool optional */ }
+        if (_wasIdleReaped && !sessionResetReason) {
+          tabSessionId = null;
+          sessionReset = true;
+          sessionResetReason = 'idleReap';
+        }
         const wasResume = !!tabSessionId;
         const sessionId = tabSessionId || null;
         const resumeNeedsCarryover = wasResume && _ccRuntimeNeedsResumeCarryover(currentRuntime);
@@ -11019,6 +11041,12 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           // larger models); max 1h (matches CC_CALL_TIMEOUT_MS so the watchdog
           // never outlives the outer abort).
           ccTurnTimeoutMs: [10000, 3600000],
+          // W-mr0qs0vw — ACP worker idle-reaper window. 1min floor (anything
+          // shorter would reap a warm worker between a user's own messages and
+          // thrash cold-spawns); 8h ceiling (a config typo shouldn't pin a warm
+          // copilot process in memory indefinitely). Stored in ms; the Settings
+          // UI presents minutes and converts.
+          ccWorkerIdleTimeoutMs: [60000, 28800000],
           // W-mq9acoo800177bcb — bounded-concurrency for pre-dispatch validator.
           // 1 floor (sequential fallback) and 20 ceiling (above this the LLM
           // provider's per-second rate limits dominate; throughput gains taper).
@@ -14435,6 +14463,15 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     "img-src 'self' data:; " +
     "connect-src 'self'"
   );
+  // The Slim UX "Queued work" tile (W-mqrdggys000f94a4) embeds this classic SPA
+  // at /work?embed=1 in a SAME-ORIGIN iframe. buildSecurityHeaders() stamped
+  // X-Frame-Options: DENY on every response above, which makes the browser
+  // refuse to render the iframe ("localhost refused to connect"). Relax to
+  // SAMEORIGIN for the chrome-off embed request only — the standalone classic
+  // dashboard keeps DENY. Mirrors serveSlimUx's embeddable relaxation for /slim.
+  if (/[?&]embed=1(?:&|$)/.test(req.url)) {
+    res.setHeader('X-Frame-Options', 'SAMEORIGIN');
+  }
   if (req.headers['if-none-match'] === HTML_ETAG) {
     res.statusCode = 304;
     res.end();

package/docs/command-center.md

@@ -31,6 +31,8 @@ Canonical envelope (`_buildCcErrorEnvelope` in `dashboard.js`):
 
 **No auto-retry policy.** The backend never re-spawns the LLM after an error envelope. The client never silently resends the user's turn. Retry is a single-click manual action — guards against silent budget burn on `budget-exceeded`, infinite loops on `auth-failure`, and accidental re-charges on `context-limit`. The 429 + reconnect paths (rate-limited fetch retry, SSE reconnect-after-disconnect) remain — those are transport-level, not error-envelope-level.
 
+**Session-reset notices (`sessionReset` / `sessionResetReason`).** The streaming `done` event can carry `sessionReset: true` with a `sessionResetReason` of `promptChanged` (Minions updated its CC prompt template), `runtimeChanged` (CC runtime switched), or `idleReap` (W-mr0qs0vw — the persistent `copilot --acp` worker was killed by the idle reaper after `engine.ccWorkerIdleTimeoutMs` of inactivity, so the next message cold-spawns a fresh session with no memory). Both classic (`dashboard/js/command-center.js`) and slim (`dashboard/slim/js/command-send.js` + `chat.js#appendSystemNotice`) render a centered, muted system notice; for `idleReap` the text is "Context window cleared after inactivity — fresh session started." The idle-reap flag is a one-shot drained per turn via `ccWorkerPool.consumeIdleReapNotice(tabId)`.
+
 ## Image attachments (PL-cc-image-attachments)
 
 Command Center accepts image attachments alongside the text turn. The dashboard paste/drag-drop UI (`dashboard/js/command-center.js`, fed by `command-input.js`) base64-encodes each file and adds an `images` array to the request body. (Doc-Chat does **not** accept images yet — `dashboard/js/modal-qa.js` never sends an `images` array and `handleDocChat`/`ccDocCall` never read one; wiring it is a possible follow-up.)

package/engine/cc-worker-pool.js

@@ -36,7 +36,9 @@
  *   - systemPromptHash change → keep proc, send a fresh `session/new`
  *   - model / effort change   → no eviction (state updated in place)
  *   - closeTab                → `session/cancel` if inflight, then kill proc
- *   - Idle > 10 min           → kill proc (reaper sweep every 60 s)
+ *   - Idle > timeout       → kill proc (reaper sweep every 60 s; window is
+ *                            ENGINE_DEFAULTS.ccWorkerIdleTimeoutMs, default
+ *                            30 min, pushed in via setIdleTimeoutMs())
  *
  * Auth precheck: when `copilot --acp` exits before the initialize handshake
  * completes, surface
@@ -93,8 +95,14 @@ function _typedError(message, code, retriable = true) {
   return err;
 }
 
-// 10 minutes — matches the work-item spec.
-const IDLE_REAPER_MS = 10 * 60 * 1000;
+// 30 minutes default — matches ENGINE_DEFAULTS.ccWorkerIdleTimeoutMs. This is
+// now a runtime-configurable knob (W-mr0qs0vw): the pool stays dependency-free
+// at module load (no static `require('./shared')`), so the dashboard pushes the
+// configured value in via `setIdleTimeoutMs()` on every reloadConfig(). Shorter
+// = less idle memory/process footprint; longer = more context durability across
+// gaps between messages.
+const DEFAULT_IDLE_REAPER_MS = 30 * 60 * 1000;
+let _idleReaperMs = DEFAULT_IDLE_REAPER_MS;
 // Reaper sweep cadence. Not exposed as ENGINE_DEFAULTS to keep the pool
 // dependency-free; sub-task C/D can plumb a config knob if needed.
 const REAPER_INTERVAL_MS = 60 * 1000;
@@ -152,6 +160,40 @@ const _internals = {
 const _tabs = new Map();
 let _reaperTimer = null;
 
+// W-mr0qs0vw — idle-reap notice tracking. When `_reapIdleTabs` kills a warm
+// worker for inactivity it records the tabId here (tabId → reapedAt epoch ms).
+// The dashboard's per-turn session-reset detection drains this via
+// `consumeIdleReapNotice(tabId)` so the next message after a reap is classified
+// `sessionResetReason: 'idleReap'` and CC surfaces a "context cleared" notice
+// exactly once. Cleared on explicit closeTab so a deliberate close never
+// masquerades as an idle reap. Survives the subsequent cold-spawn (the user
+// still lost context) — only the consume call or a closeTab clears it.
+const _reapedTabs = new Map();
+
+// Update the idle-reaper window at runtime. Called by dashboard.js on every
+// reloadConfig() with `engine.ccWorkerIdleTimeoutMs`. Ignores non-finite /
+// non-positive values so a config typo can't disable reaping or set a negative
+// window; the floor of 1000ms keeps a misconfigured tiny value from thrashing.
+function setIdleTimeoutMs(ms) {
+  const n = Number(ms);
+  if (!Number.isFinite(n) || n <= 0) return _idleReaperMs;
+  _idleReaperMs = Math.max(1000, n);
+  return _idleReaperMs;
+}
+
+function getIdleTimeoutMs() {
+  return _idleReaperMs;
+}
+
+// Returns true (and clears the notice) if `tabId`'s warm worker was killed by
+// the idle reaper since the last consume. One-shot: the dashboard calls this
+// once per turn while resolving session-reset state.
+function consumeIdleReapNotice(tabId) {
+  if (!_reapedTabs.has(tabId)) return false;
+  _reapedTabs.delete(tabId);
+  return true;
+}
+
 // CC_POOL_TRACE-gated structured trace logger. Off by default; enable via
 // `CC_POOL_TRACE=1 minions restart` to dump every getSession lifecycle
 // transition, stream sessionId capture, and session/update notification
@@ -759,6 +801,10 @@ async function getSession({ tabId, model, effort, mcpServers, systemPromptHash,
 }
 
 function closeTab(tabId) {
+  // An explicit close is not an idle reap — drop any pending reap notice so the
+  // next turn doesn't spuriously show the "context cleared after inactivity"
+  // banner (W-mr0qs0vw).
+  _reapedTabs.delete(tabId);
   const worker = _tabs.get(tabId);
   if (!worker) return;
   _tabs.delete(tabId);
@@ -816,6 +862,7 @@ function shutdown() {
     try { worker.close(); } catch { /* swallow */ }
   }
   _tabs.clear();
+  _reapedTabs.clear();
   if (_reaperTimer) {
     clearInterval(_reaperTimer);
     _reaperTimer = null;
@@ -832,8 +879,11 @@ function _reapIdleTabs() {
   const now = _internals.now();
   for (const [tabId, worker] of [..._tabs]) {
     if (worker.inflight) continue;
-    if (now - worker.lastUsedAt > IDLE_REAPER_MS) {
+    if (now - worker.lastUsedAt > _idleReaperMs) {
       _tabs.delete(tabId);
+      // Record the reap so the next turn on this tab can surface a
+      // "context cleared after inactivity" notice (W-mr0qs0vw).
+      _reapedTabs.set(tabId, now);
       try { worker.close(); } catch { /* already torn down */ }
     }
   }
@@ -845,12 +895,17 @@ module.exports = {
   closeTab,
   cancelInflight,
   shutdown,
+  // W-mr0qs0vw — configurable idle-reaper window + idle-reap notice plumbing.
+  setIdleTimeoutMs,
+  getIdleTimeoutMs,
+  consumeIdleReapNotice,
   // Exposed for unit tests; engine code MUST go through the public API.
   _internals,
   _tabs,
+  _reapedTabs,
   _reapIdleTabs,
   _buildSessionNewParams,
-  IDLE_REAPER_MS,
+  DEFAULT_IDLE_REAPER_MS,
   REAPER_INTERVAL_MS,
   WARM_MAX_CONCURRENT,
   // W-mpmwxni2000c25c7-c — typed-error envelope contract. Exported so the

package/engine/live-checkout.js

@@ -132,6 +132,62 @@ function _isPartialCloneBlobError(message = '') {
   );
 }
 
+// W-mqva907q — auto-clean safe untracked build artifacts before a live-checkout
+// dirty bail. A `git status --porcelain` line for a stray `__pycache__/` (or
+// other regenerable cache) should NOT block dispatch the way a real edit does.
+// These patterns describe untracked-only paths that are always safe to delete
+// because the build/test toolchain regenerates them. Matching is intentionally
+// implemented with plain string checks (no glob dep — Minions ships zero runtime
+// deps). dist/ and build/ are deliberately EXCLUDED: they can hold real,
+// non-regenerable output, so auto-deleting them would be unsafe.
+const LIVE_CHECKOUT_AUTO_CLEAN_PATTERNS = Object.freeze([
+  '**/__pycache__/',
+  '**/*.pyc',
+  '**/*.pyo',
+  '**/.pytest_cache/',
+  '**/node_modules/.cache/',
+  '**/*.egg-info/',
+  '.tox/',
+]);
+
+// Returns true when a single untracked path (relative, git-porcelain form) is a
+// known regenerable build artifact safe to delete. Normalizes separators and a
+// trailing slash, and conservatively unquotes git's C-style quoting for paths
+// with special chars. Directory artifacts match on their final path segment so
+// nested copies (e.g. a/b/__pycache__/) are covered like the `**/` globs above.
+function _isAutoCleanableArtifact(rawPath) {
+  if (!rawPath || typeof rawPath !== 'string') return false;
+  let p = rawPath.trim();
+  if (p.length >= 2 && p.startsWith('"') && p.endsWith('"')) {
+    try { p = JSON.parse(p); } catch { /* keep raw on parse failure */ }
+  }
+  p = p.replace(/\\/g, '/').replace(/\/+$/, '');
+  if (!p) return false;
+  if (p.endsWith('.pyc') || p.endsWith('.pyo')) return true;
+  if (p.endsWith('.egg-info')) return true;
+  if (p === 'node_modules/.cache' || p.endsWith('/node_modules/.cache')) return true;
+  const seg = p.split('/').pop();
+  if (seg === '__pycache__' || seg === '.pytest_cache' || seg === '.tox') return true;
+  return false;
+}
+
+// Classifies the porcelain dirty lines for auto-clean. Returns the list of
+// untracked artifact paths ONLY when EVERY dirty entry is an untracked (`?? `)
+// line matching a safe artifact pattern; returns null otherwise (a tracked
+// modification, a staged/deleted change, or any untracked path that is NOT a
+// known artifact). Null means "do not auto-clean — fail dirty as before", which
+// enforces the all-or-nothing contract: partial dirt is never silently cleaned.
+function _collectAutoCleanablePaths(dirtyFiles) {
+  const cleanable = [];
+  for (const line of dirtyFiles) {
+    if (!line.startsWith('?? ')) return null;
+    const p = line.slice(3);
+    if (!_isAutoCleanableArtifact(p)) return null;
+    cleanable.push(p);
+  }
+  return cleanable.length > 0 ? cleanable : null;
+}
+
 // W-mqvejug6000eeb20 — production default for resolving the live-checkout
 // auto-reset decision when the caller (engine.js spawnAgent) does not pass an
 // explicit `autoReset` boolean. engine.js is intentionally not threading the
@@ -178,6 +234,7 @@ async function prepareLiveCheckout(opts = {}) {
                 // defers to `_resolveAutoReset`.
     _git,       // private injection for testing — defaults to shared.shellSafeGit
     _exists,    // private injection for testing — defaults to fs.existsSync
+    _rm,        // private injection for testing — defaults to fs.rmSync (recursive, force)
     _resolveAutoReset, // private injection for testing — defaults to config-based resolver
     _writeInboxNote,   // private injection for testing — defaults to dispatch.writeInboxAlert
   } = opts;
@@ -206,6 +263,8 @@ async function prepareLiveCheckout(opts = {}) {
 
   const git = (typeof _git === 'function') ? _git : shared.shellSafeGit;
   const exists = (typeof _exists === 'function') ? _exists : fs.existsSync;
+  const rm = (typeof _rm === 'function') ? _rm : ((absPath) => fs.rmSync(absPath, { recursive: true, force: true }));
+  const logFn = (typeof log === 'function') ? log : () => {};
   // W-mqvejug6000eeb20 — default maxBuffer (50 MB) so a large `git status
   // --porcelain` never overflows execFile's 1 MB ceiling. A caller-supplied
   // gitOpts.maxBuffer still wins (spread after the default).
@@ -230,91 +289,114 @@ async function prepareLiveCheckout(opts = {}) {
   // before the dirtyFiles check so callers receive it as `branchInfo`.
   if (!skipDirtyCheck) {
     const statusRaw = await git(['status', '--porcelain=v1', '-b'], baseOpts);
-    const statusStr = typeof statusRaw === 'string' ? statusRaw : '';
-    const statusLines = statusStr
-      .split(/\r?\n/)
-      .map((line) => line.replace(/\s+$/, ''))
-      .filter((line) => line.length > 0);
-    const branchInfo = statusLines.find((line) => line.startsWith('## ')) || '';
-    const dirtyFiles = statusLines.filter((line) => !line.startsWith('## '));
+    const parsePorcelain = (raw) => {
+      const lines = (typeof raw === 'string' ? raw : '')
+        .split(/\r?\n/)
+        .map((line) => line.replace(/\s+$/, ''))
+        .filter((line) => line.length > 0);
+      return {
+        branchInfo: lines.find((line) => line.startsWith('## ')) || '',
+        dirtyFiles: lines.filter((line) => !line.startsWith('## ')),
+      };
+    };
+    let { branchInfo, dirtyFiles } = parsePorcelain(statusRaw);
     if (dirtyFiles.length > 0) {
-      // W-mqvejug6000eeb20 — opt-in auto-reset. Default behavior is to bail with
-      // reason:'dirty' (spawnAgent translates to non-retryable LIVE_CHECKOUT_DIRTY
-      // and alerts the operator). When auto-reset is enabled — either the caller
-      // passed an explicit `autoReset` boolean, or the config-based resolver says
-      // so — we DISCARD the dirty state via `git fetch origin` + `git reset --hard
-      // origin/<branch>` and continue. This is destructive (the operator's
-      // uncommitted work is gone), which is why it is strictly opt-in.
-      let wantAutoReset = false;
-      if (typeof autoReset === 'boolean') {
-        wantAutoReset = autoReset;
-      } else {
-        const resolver = (typeof _resolveAutoReset === 'function') ? _resolveAutoReset : _defaultResolveAutoReset;
-        try { wantAutoReset = !!resolver(localPath); } catch { wantAutoReset = false; }
-      }
-
-      if (!wantAutoReset) {
-        return { ok: false, reason: 'dirty', dirtyFiles, branchInfo };
+      // W-mqva907q — auto-clean safe untracked build artifacts BEFORE bailing. This
+      // runs unconditionally (no config flag — deleting regenerable caches is always
+      // safe) and BEFORE the spawnAgent auto-stash path. Only fires when EVERY dirty
+      // entry is an untracked artifact (all-or-nothing); a single tracked edit or
+      // non-artifact untracked file means zero cleaning and the original dirty bail.
+      const cleanablePaths = _collectAutoCleanablePaths(dirtyFiles);
+      if (cleanablePaths) {
+        for (const rel of cleanablePaths) {
+          const abs = path.isAbsolute(rel) ? rel : path.join(localPath, rel);
+          rm(abs);
+        }
+        logFn(`[live-checkout] auto-cleaned ${cleanablePaths.length} artifact path(s) before dirty check: ${cleanablePaths.join(', ')}`, 'debug');
+        // Re-run the dirty check. If cleaning fully resolved the tree we fall
+        // through and proceed; if anything remains (e.g. a race re-created a file)
+        // we still bail dirty with the post-clean snapshot.
+        const reRaw = await git(['status', '--porcelain=v1', '-b'], baseOpts);
+        ({ branchInfo, dirtyFiles } = parsePorcelain(reRaw));
       }
+      if (dirtyFiles.length > 0) {
+        // W-mqvejug6000eeb20 — opt-in auto-reset. Default behavior is to bail with
+        // reason:'dirty' (spawnAgent translates to non-retryable LIVE_CHECKOUT_DIRTY
+        // and alerts the operator). When auto-reset is enabled — either the caller
+        // passed an explicit `autoReset` boolean, or the config-based resolver says
+        // so — we DISCARD the dirty state via `git fetch origin` + `git reset --hard
+        // origin/<branch>` and continue. This is destructive (the operator’s
+        // uncommitted work is gone), which is why it is strictly opt-in.
+        let wantAutoReset = false;
+        if (typeof autoReset === 'boolean') {
+          wantAutoReset = autoReset;
+        } else {
+          const resolver = (typeof _resolveAutoReset === 'function') ? _resolveAutoReset : _defaultResolveAutoReset;
+          try { wantAutoReset = !!resolver(localPath); } catch { wantAutoReset = false; }
+        }
+        if (!wantAutoReset) {
+          return { ok: false, reason: 'dirty', dirtyFiles, branchInfo };
+        }
 
-      if (typeof log === 'function') {
-        log(`live-checkout auto-reset: discarding ${dirtyFiles.length} dirty path(s) on '${branchName}' via fetch + reset --hard origin/${branchName}`);
-      }
-      let resetOk = true;
-      try {
-        await git(['fetch', 'origin'], baseOpts);
-        await git(['reset', '--hard', `origin/${branchName}`], baseOpts);
-      } catch (e) {
-        resetOk = false;
         if (typeof log === 'function') {
-          log(`live-checkout auto-reset FAILED (fetch/reset): ${e && e.message ? e.message : e}`);
+          log(`live-checkout auto-reset: discarding ${dirtyFiles.length} dirty path(s) on '${branchName}' via fetch + reset --hard origin/${branchName}`);
         }
-      }
-
-      // Re-run the porcelain preflight once. If the tree is now clean we proceed;
-      // otherwise (reset failed, or something is still dirty) we fall back to the
-      // safe dirty refusal so we never dispatch onto an unexpected tree.
-      let stillDirty = dirtyFiles;
-      if (resetOk) {
+        let resetOk = true;
         try {
-          const recheckRaw = await git(['status', '--porcelain=v1', '-b'], baseOpts);
-          const recheckStr = typeof recheckRaw === 'string' ? recheckRaw : '';
-          stillDirty = recheckStr
-            .split(/\r?\n/)
-            .map((line) => line.replace(/\s+$/, ''))
-            .filter((line) => line.length > 0 && !line.startsWith('## '));
+          await git(['fetch', 'origin'], baseOpts);
+          await git(['reset', '--hard', `origin/${branchName}`], baseOpts);
         } catch (e) {
           resetOk = false;
           if (typeof log === 'function') {
-            log(`live-checkout auto-reset re-check FAILED: ${e && e.message ? e.message : e}`);
+            log(`live-checkout auto-reset FAILED (fetch/reset): ${e && e.message ? e.message : e}`);
           }
         }
-      }
 
-      if (!resetOk || stillDirty.length > 0) {
-        return { ok: false, reason: 'dirty', dirtyFiles: stillDirty, branchInfo };
-      }
+        // Re-run the porcelain preflight once. If the tree is now clean we proceed;
+        // otherwise (reset failed, or something is still dirty) we fall back to the
+        // safe dirty refusal so we never dispatch onto an unexpected tree.
+        let stillDirty = dirtyFiles;
+        if (resetOk) {
+          try {
+            const recheckRaw = await git(['status', '--porcelain=v1', '-b'], baseOpts);
+            const recheckStr = typeof recheckRaw === 'string' ? recheckRaw : '';
+            stillDirty = recheckStr
+              .split(/\r?\n/)
+              .map((line) => line.replace(/\s+$/, ''))
+              .filter((line) => line.length > 0 && !line.startsWith('## '));
+          } catch (e) {
+            resetOk = false;
+            if (typeof log === 'function') {
+              log(`live-checkout auto-reset re-check FAILED: ${e && e.message ? e.message : e}`);
+            }
+          }
+        }
 
-      // Audit trail: record the discarded paths so the operator can recover from
-      // reflog / understand why their tree changed. Best-effort, never throws.
-      try {
-        const writeNote = (typeof _writeInboxNote === 'function') ? _writeInboxNote : _defaultWriteInboxNote;
-        const slug = `live-checkout-autoreset-${wiId || dispatchId || 'unknown'}`;
-        const body = [
-          `# Live-checkout auto-reset on '${branchName}'`,
-          '',
-          `⚠️ The live-checkout tree at \`${localPath}\` was dirty at dispatch time and`,
-          '`liveCheckoutAutoReset` is enabled, so it was force-reset to',
-          `\`origin/${branchName}\`. **The following uncommitted changes were DISCARDED**`,
-          '(recover from `git reflog` / `git fsck --lost-found` if needed):',
-          '',
-          '```',
-          ...dirtyFiles,
-          '```',
-        ].join('\n');
-        writeNote(slug, body);
-      } catch { /* best-effort audit note */ }
-      // Fall through — tree is now clean, continue with normal preparation.
+        if (!resetOk || stillDirty.length > 0) {
+          return { ok: false, reason: 'dirty', dirtyFiles: stillDirty, branchInfo };
+        }
+
+        // Audit trail: record the discarded paths so the operator can recover from
+        // reflog / understand why their tree changed. Best-effort, never throws.
+        try {
+          const writeNote = (typeof _writeInboxNote === 'function') ? _writeInboxNote : _defaultWriteInboxNote;
+          const slug = `live-checkout-autoreset-${wiId || dispatchId || 'unknown'}`;
+          const body = [
+            `# Live-checkout auto-reset on '${branchName}'`,
+            '',
+            `⚠️ The live-checkout tree at \`${localPath}\` was dirty at dispatch time and`,
+            '`liveCheckoutAutoReset` is enabled, so it was force-reset to',
+            `\`origin/${branchName}\`. **The following uncommitted changes were DISCARDED**`,
+            '(recover from `git reflog` / `git fsck --lost-found` if needed):',
+            '',
+            '```',
+            ...dirtyFiles,
+            '```',
+          ].join('\n');
+          writeNote(slug, body);
+        } catch { /* best-effort audit note */ }
+        // Fall through — tree is now clean, continue with normal preparation.
+      }
     }
   }
 
@@ -817,4 +899,12 @@ async function maybeRestoreLiveCheckoutFromRecord(opts = {}) {
   }
 }
 
-module.exports = { prepareLiveCheckout, restoreLiveCheckoutAtDispatchEnd, maybeRestoreLiveCheckoutFromRecord, _isPartialCloneBlobError };
+module.exports = {
+  prepareLiveCheckout,
+  restoreLiveCheckoutAtDispatchEnd,
+  maybeRestoreLiveCheckoutFromRecord,
+  _isPartialCloneBlobError,
+  _isAutoCleanableArtifact,
+  _collectAutoCleanablePaths,
+  LIVE_CHECKOUT_AUTO_CLEAN_PATTERNS,
+};

package/engine/shared.js

@@ -3261,6 +3261,7 @@ const ENGINE_DEFAULTS = {
   liveCheckoutAutoReset: false,
   orphanHolderScanTimeoutMs: 5000,          // 5s ceiling for the cross-platform holder scan (PowerShell / /proc walk / lsof)
   ccMaxTurns: 50, // max tool-use turns per CC/doc-chat call before CLI stops (per response, not per session)
+  ccWorkerIdleTimeoutMs: 30 * 60 * 1000, // W-mr0qs0vw: idle-reaper window for the persistent `copilot --acp` worker pool (engine/cc-worker-pool.js). After this much inactivity with no in-flight turn the warm ACP process is killed; the next message cold-spawns a fresh session with NO memory of prior turns (CC shows a "context cleared after inactivity" notice). Tradeoff: shorter = less idle memory/process footprint, longer = more context durability across gaps between messages. Wired into the pool via ccWorkerPool.setIdleTimeoutMs() on every reloadConfig(); clamped to [60000, 28800000] (1min–8h) in the settings POST handler.
   ccTurnTimeoutMs: 300000, // W-mpmwxni2000c25c7-b/-d: 5min per-turn no-progress watchdog. The window resets on every liveness signal — token chunk, tool-call notification, tool-update — so an actively-streaming CC/doc-chat turn (long shell command, deep search, sub-agent loop) survives indefinitely up to the outer CC_CALL_TIMEOUT_MS (~1h) ceiling. Only true silence past this window with no progress fires the cancel: the in-flight LLM call is aborted and the handler surfaces `{code:'cc-turn-timeout', retryable:true}` via the typed error envelope so the UI can stop the spinner and offer Retry. Clamped to [10000, 3600000] in the settings POST handler. Independent of CC_CALL_TIMEOUT_MS. Non-streaming doc-chat is the lone wall-clock exception (no progress hooks); see _raceCcDocChatTimeout in dashboard.js for the dual factory/promise shape.
   docSessionMaxEntries: 200, // cap doc-chat session map/disk store by least-recent activity (LRU; sessions are non-expiring otherwise)
   ccLiveStreamMaxAgeMs: 30 * 60 * 1000, // hard cap reconnect buffers if abort/cleanup stalls

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2303",
+  "version": "0.1.2305",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"