@yemi33/minions 0.1.2303 → 0.1.2304

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

@@ -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/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/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/styles.css

@@ -898,6 +898,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.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).

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/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.2304",
   "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"