@yemi33/minions 0.1.1737 → 0.1.1739

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.1.1739 (2026-05-06)
+
+### Features
+- make Command Center chat sessions non-expiring (#2100)
+
+## 0.1.1738 (2026-05-06)
+
+### Features
+- add feature-flag registry for experimental UX gates
+- graceful runtime-switch reset with transcript carryover
+
+### Fixes
+- prevent hung callLLM Promises when child stdio doesn't drain
+
+### Other
+- chore(gitignore): ignore root-level config.json.backup sidecar
+
 ## 0.1.1737 (2026-05-05)
 
 ### Other

package/dashboard/js/command-center.js

@@ -101,6 +101,26 @@ function _ccActiveTab() {
   return _ccTabs.find(function(t) { return t.id === _ccActiveTabId; }) || null;
 }
 
+// Build a plain-text transcript from a tab's stored messages — sent on every
+// initial request so the server can carry it over if the session has to reset
+// (runtime switch, system-prompt change). Last 20 user/assistant turns only;
+// system/action rows are skipped because they're UI artifacts, not dialog.
+var CC_TRANSCRIPT_MAX_TURNS = 20;
+function _ccBuildTranscript(tab) {
+  if (!tab || !Array.isArray(tab.messages) || tab.messages.length === 0) return [];
+  var out = [];
+  for (var i = 0; i < tab.messages.length; i++) {
+    var m = tab.messages[i];
+    if (!m || (m.role !== 'user' && m.role !== 'assistant')) continue;
+    var html = typeof m.html === 'string' ? m.html : '';
+    var tmp = document.createElement('div');
+    tmp.innerHTML = html;
+    var text = (tmp.textContent || tmp.innerText || '').trim();
+    if (text) out.push({ role: m.role, text: text });
+  }
+  return out.slice(-CC_TRANSCRIPT_MAX_TURNS);
+}
+
 function _ccMergeStreamText(prev, incoming) {
   // `prev` is already merged-clean from prior frames (server strips actions
   // before SSE emission, and any leaked partial was sanitized by the previous
@@ -372,6 +392,12 @@ function ccCloseTab(id) {
     closingTab._queue = [];
     _ccSending = (_ccTabs.some(function(t) { return t._sending; }));
   }
+  // Tabs are non-expiring on the server — explicit close is the only path that
+  // removes the persisted session. Fire-and-forget DELETE so closing a tab
+  // also evicts the server-side cc-sessions.json entry.
+  try {
+    fetch('/api/cc-sessions/' + encodeURIComponent(id), { method: 'DELETE' }).catch(function() {});
+  } catch {}
   _ccTabs.splice(idx, 1);
   if (_ccActiveTabId === id) {
     // Switch to adjacent tab or create new
@@ -756,7 +782,15 @@ async function _ccDoSend(message, skipUserMsg, forceTabId) {
         terminalEventSeen = true;
         _cleanupStreamDiv();
         if (evt.sessionReset) {
-          addMsg('system', '<div style="text-align:center;padding:6px 12px;font-size:11px;color:var(--muted);background:var(--surface2);border-radius:6px;margin:4px 0">Minions was updated — started a fresh session with latest context.</div>', false, activeTabId);
+          var resetText;
+          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.';
+          } else {
+            resetText = 'Minions was updated — started a fresh session with latest context.';
+          }
+          addMsg('system', '<div style="text-align:center;padding:6px 12px;font-size:11px;color:var(--muted);background:var(--surface2);border-radius:6px;margin:4px 0">' + resetText + '</div>', false, activeTabId);
         }
         var finalText = _ccMergeStreamText(streamedText, evt.text || '');
         var rendered = renderMd(finalText || streamedText || '');
@@ -824,7 +858,7 @@ async function _ccDoSend(message, skipUserMsg, forceTabId) {
     while (true) {
       var consume = await _ccConsumeStream(
         reconnectAttempts === 0
-          ? { message: message, tabId: activeTabId, sessionId: activeTab.sessionId || null }
+          ? { message: message, tabId: activeTabId, sessionId: activeTab.sessionId || null, transcript: _ccBuildTranscript(activeTab) }
           : { tabId: activeTabId, sessionId: activeTab.sessionId || null, reconnect: true },
         reconnectAttempts > 0
       );

package/dashboard/js/features-client.js

@@ -0,0 +1,16 @@
+// features-client.js — Client-side feature flag accessor.
+// Reads `window.MINIONS_FEATURES` (data injected at HTML build time:
+// { flags: {id: bool}, defaults: {id: bool} }) and exposes synchronous
+// `MinionsFeatures.isOn(id)` so gated render code can branch without async.
+
+window.MinionsFeatures = {
+  isOn: function(id) {
+    var f = window.MINIONS_FEATURES || { flags: {}, defaults: {} };
+    if (Object.prototype.hasOwnProperty.call(f.flags, id)) return f.flags[id] === true;
+    return f.defaults && f.defaults[id] === true;
+  },
+  _setLocal: function(id, enabled) {
+    if (!window.MINIONS_FEATURES) window.MINIONS_FEATURES = { flags: {}, defaults: {} };
+    window.MINIONS_FEATURES.flags[id] = enabled === true;
+  },
+};

package/dashboard/js/settings.js

@@ -28,10 +28,18 @@ async function openSettings() {
 
   _settingsData = null;
   let data;
+  let featuresList = [];
   try {
-    const res = await fetch('/api/settings');
-    data = await res.json();
+    const [settingsRes, featuresRes] = await Promise.all([
+      fetch('/api/settings'),
+      fetch('/api/features').catch(() => null),
+    ]);
+    data = await settingsRes.json();
     _settingsData = data;
+    if (featuresRes && featuresRes.ok) {
+      const fjson = await featuresRes.json().catch(() => null);
+      if (fjson && Array.isArray(fjson.features)) featuresList = fjson.features;
+    }
   } catch (e) { showToast('cmd-toast', 'Failed to load settings: ' + e.message, false); return; }
 
   const e = data.engine || {};
@@ -276,6 +284,36 @@ async function openSettings() {
     '<h3 style="font-size:13px;color:var(--blue);margin-bottom:8px">Routing Table</h3>' +
     '<textarea id="set-routing" rows="12" style="width:100%;padding:8px;background:var(--surface);border:1px solid var(--border);border-radius:4px;color:var(--text);font-family:monospace;font-size:11px;resize:vertical">' + escHtml(data.routing || '') + '</textarea>' +
 
+    // Toggles persist immediately via POST /api/features/toggle — no Save needed.
+    '<details id="settings-features-details" style="margin-top:16px;border-top:1px solid var(--border);padding-top:12px">' +
+      '<summary style="cursor:pointer;font-size:13px;color:var(--blue);user-select:none">Show experimental flags ' +
+        '<span style="font-size:10px;color:var(--muted)">(' + featuresList.length + ' registered)</span>' +
+      '</summary>' +
+      '<div style="font-size:10px;color:var(--muted);margin:8px 0 10px">In-progress UX or behavior gates. Toggles persist immediately. Registry: <code>engine/features.js</code>. Env override: <code>MINIONS_FEATURE_&lt;NAME&gt;=1</code>.</div>' +
+      (featuresList.length === 0
+        ? '<div style="font-size:11px;color:var(--muted);padding:12px;border:1px dashed var(--border);border-radius:4px;text-align:center">No experimental features registered. Add entries to <code>engine/features.js</code> to gate new work.</div>'
+        : '<div style="display:flex;flex-direction:column;gap:8px">' +
+          featuresList.map(function(f) {
+            const checked = f.enabled ? ' checked' : '';
+            const expiredBadge = f.expired
+              ? ' <span style="font-size:9px;padding:1px 5px;background:rgba(220,80,80,0.15);color:var(--red);border-radius:3px;margin-left:4px">EXPIRED</span>'
+              : '';
+            const meta = [];
+            if (f.addedIn) meta.push('added in ' + escHtml(f.addedIn));
+            if (f.expires) meta.push('expires ' + escHtml(f.expires));
+            meta.push(f.default ? 'default: on' : 'default: off');
+            return '<label data-feature-id="' + escHtml(f.id) + '" style="display:flex;align-items:flex-start;gap:8px;padding:8px;border:1px solid var(--border);border-radius:4px;cursor:pointer">' +
+              '<input type="checkbox" data-feature-toggle="' + escHtml(f.id) + '"' + checked + ' style="margin-top:3px;cursor:pointer">' +
+              '<div style="flex:1">' +
+                '<div style="font-size:11px;font-weight:600;color:var(--text)">' + escHtml(f.id) + expiredBadge + '</div>' +
+                (f.description ? '<div style="font-size:10px;color:var(--muted);margin-top:2px">' + escHtml(f.description) + '</div>' : '') +
+                '<div style="font-size:9px;color:var(--muted);margin-top:3px">' + meta.join(' · ') + '</div>' +
+              '</div>' +
+            '</label>';
+          }).join('') +
+        '</div>') +
+    '</details>' +
+
   '</div>';
 
   document.getElementById('modal-title').textContent = 'Settings';
@@ -312,6 +350,34 @@ async function openSettings() {
   // 3. On defaultCli change → re-fetch models so the input never shows stale list.
   // The same pattern wires ccCli → ccModel; ccCli inherits defaultCli when unset.
   initRuntimeFleetUI(e, agents);
+
+  document.querySelectorAll('input[data-feature-toggle]').forEach(function(input) {
+    input.addEventListener('change', async function() {
+      const id = input.getAttribute('data-feature-toggle');
+      const enabled = input.checked;
+      if (window.MinionsFeatures && typeof window.MinionsFeatures._setLocal === 'function') {
+        window.MinionsFeatures._setLocal(id, enabled);
+      }
+      try {
+        const r = await fetch('/api/features/toggle', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ id, enabled }),
+        });
+        if (!r.ok) {
+          const j = await r.json().catch(() => ({}));
+          throw new Error(j.error || ('HTTP ' + r.status));
+        }
+        showToast('cmd-toast', 'Feature "' + id + '" ' + (enabled ? 'enabled' : 'disabled'), true);
+      } catch (err) {
+        input.checked = !enabled;
+        if (window.MinionsFeatures && typeof window.MinionsFeatures._setLocal === 'function') {
+          window.MinionsFeatures._setLocal(id, !enabled);
+        }
+        showToast('cmd-toast', 'Failed to toggle "' + id + '": ' + err.message, false);
+      }
+    });
+  });
 }
 
 async function initRuntimeFleetUI(engineCfg, agentsCfg) {

package/dashboard-build.js

@@ -29,7 +29,7 @@ function buildDashboardHtml() {
   }
 
   const jsFiles = [
-    'utils', 'state', 'detail-panel', 'live-stream',
+    'utils', 'state', 'features-client', 'detail-panel', 'live-stream',
     'render-agents', 'render-dispatch', 'render-work-items', 'render-prd',
     'render-prs', 'render-plans', 'render-inbox', 'render-kb', 'render-skills',
     'render-other', 'render-schedules', 'render-watches', 'render-pipelines', 'render-meetings', 'render-pinned',

package/dashboard.js

@@ -30,6 +30,7 @@ const playbook = require('./engine/playbook');
 const dispatchMod = require('./engine/dispatch');
 const steering = require('./engine/steering');
 const projectDiscovery = require('./engine/project-discovery');
+const features = require('./engine/features');
 const os = require('os');
 
 const { safeRead, safeReadDir, safeWrite, safeJson, safeJsonObj, safeJsonArr, safeUnlink, mutateJsonFileLocked, mutateControl, mutateCooldowns, mutateWorkItems, getProjects: _getProjects, DONE_STATUSES, WI_STATUS, WORK_TYPE, reopenWorkItem } = shared;
@@ -448,7 +449,7 @@ function buildDashboardHtml() {
 
   // Assemble JS modules (order matters: utils → state → renderers → commands → refresh)
   const jsFiles = [
-    'utils', 'state', 'render-utils', 'detail-panel', 'live-stream',
+    'utils', 'state', 'features-client', 'render-utils', 'detail-panel', 'live-stream',
     'render-agents', 'render-dispatch', 'render-work-items', 'render-prd',
     'render-prs', 'render-plans', 'render-inbox', 'render-kb', 'render-skills',
     'render-other', 'render-schedules', 'render-watches', 'render-pipelines', 'render-meetings', 'render-pinned',
@@ -461,10 +462,23 @@ function buildDashboardHtml() {
     jsHtml += `\n// ─── ${f}.js ────────────────────────────────────────\n${content}\n`;
   }
 
+  // Snapshot feature-flag state at build time so the client renders synchronously
+  // without an extra /api/features round-trip. Helper itself lives in
+  // dashboard/js/features-client.js (auto-concatenated below).
+  let featuresBoot = { flags: {}, defaults: {} };
+  try {
+    for (const f of features.listFeatures(queries.getConfig())) {
+      featuresBoot.flags[f.id] = f.enabled;
+      featuresBoot.defaults[f.id] = f.default;
+    }
+  } catch { /* registry empty or config unreadable — ship empty boot state */ }
+
+  const featuresBootstrap = `window.MINIONS_FEATURES = ${JSON.stringify(featuresBoot)};\n`;
+
   return layout
     .replace('/* __CSS__ */', () => css)
     .replace('<!-- __PAGES__ -->', () => pageHtml)
-    .replace('/* __JS__ */', () => `window.__MINIONS_HOME = ${JSON.stringify(os.homedir())};\n${jsHtml}`);
+    .replace('/* __JS__ */', () => `window.__MINIONS_HOME = ${JSON.stringify(os.homedir())};\n${featuresBootstrap}${jsHtml}`);
 }
 
 let HTML_RAW = buildDashboardHtml();
@@ -918,9 +932,14 @@ setInterval(() => {
 
 // ── Command Center: session state + helpers ─────────────────────────────────
 
-// Bound resumed session growth so stale conversations do not accumulate unbounded context.
+// CC chat sessions do NOT auto-expire. A tab is removed only via explicit user
+// deletion (DELETE /api/cc-sessions/:id, wired from ccCloseTab). Doc-chat
+// sessions keep their own TTL (DOC_SESSION_TTL_MS) — that's a separate store.
+//
+// CC_SESSION_MAX_TURNS is reused by the doc-chat session pruner to cap
+// per-session turn growth there; CC chat sessions are not capped because
+// users are expected to keep long-running tabs alive indefinitely.
 const CC_SESSION_MAX_TURNS = shared.ENGINE_DEFAULTS.ccMaxTurns;
-const CC_SESSION_TTL_MS = shared.ENGINE_DEFAULTS.ccSessionTtlMs;
 let ccSession = { sessionId: null, createdAt: null, lastActiveAt: null, turnCount: 0 };
 const ccInFlightTabs = new Map(); // tabId → timestamp — per-tab in-flight tracking for parallel CC requests
 const ccInFlightAborts = new Map(); // tabId → abortFn — lets a new request kill the stale LLM
@@ -1056,18 +1075,17 @@ function _ccTabIsInFlight(tabId) {
 
 function ccSessionValid() {
   if (!ccSession.sessionId) return false;
-  // Invalidate session if system prompt changed (e.g. after code update + restart)
+  // Invalidate session if system prompt changed (e.g. after code update + restart).
+  // This is correctness-driven, not expiration-driven: a session created against
+  // a stale system prompt would carry the old persona/rules into resume turns.
   if (ccSession._promptHash && ccSession._promptHash !== _ccPromptHash) {
     console.log('[CC] System prompt changed — invalidating stale session');
     ccSession = { sessionId: null, createdAt: null, lastActiveAt: null, turnCount: 0 };
     return false;
   }
-  if (_sessionExpired(ccSession.lastActiveAt || ccSession.createdAt, CC_SESSION_TTL_MS)) {
-    console.log('[CC] Session expired by TTL — starting fresh');
-    ccSession = { sessionId: null, createdAt: null, lastActiveAt: null, turnCount: 0 };
-    return false;
-  }
-  return ccSession.turnCount < CC_SESSION_MAX_TURNS;
+  // No TTL or turn-count cap — CC chat sessions live until the user explicitly
+  // closes the tab (which calls DELETE /api/cc-sessions/:id).
+  return true;
 }
 
 // Static system prompt — baked into session on creation, never changes
@@ -1106,11 +1124,13 @@ function _sessionExpired(lastActiveAt, ttlMs) {
   return Date.now() - at > ttlMs;
 }
 
+// CC tab sessions never auto-expire — only invalid records (missing id /
+// sessionId) and prompt-hash mismatches are filtered out. Tabs are removed
+// from disk only when the user explicitly closes them via DELETE
+// /api/cc-sessions/:id.
 function _filterCcTabSessions(sessions) {
   return (Array.isArray(sessions) ? sessions : []).filter(s =>
     s && s.id && s.sessionId &&
-    (s.turnCount || 0) < CC_SESSION_MAX_TURNS &&
-    !_sessionExpired(s.lastActiveAt || s.createdAt, CC_SESSION_TTL_MS) &&
     (!s._promptHash || s._promptHash === _ccPromptHash)
   );
 }
@@ -1121,10 +1141,34 @@ function _readCcTabSessions({ prune = true } = {}) {
   return sessions;
 }
 
-// Load persisted CC session on startup
+const CC_CARRYOVER_MAX_TURNS = 20;
+const CC_CARRYOVER_PER_MSG_CHARS = 2000;
+
+function _buildTranscriptCarryover(transcript, { previousRuntime } = {}) {
+  if (!Array.isArray(transcript) || transcript.length === 0) return '';
+  const filtered = transcript.filter(m => m && (m.role === 'user' || m.role === 'assistant') && typeof m.text === 'string' && m.text.trim());
+  if (filtered.length === 0) return '';
+  const recent = filtered.slice(-CC_CARRYOVER_MAX_TURNS);
+  const truncated = filtered.length > recent.length;
+  const header = previousRuntime
+    ? `--- Previous conversation (carried over from ${previousRuntime} session) ---`
+    : `--- Previous conversation (carried over) ---`;
+  const lines = recent.map(m => {
+    const who = m.role === 'user' ? 'User' : 'Assistant';
+    let text = m.text.trim();
+    if (text.length > CC_CARRYOVER_PER_MSG_CHARS) text = text.slice(0, CC_CARRYOVER_PER_MSG_CHARS) + '… [truncated]';
+    return `${who}: ${text}`;
+  });
+  const truncationNote = truncated ? `[earlier messages truncated — showing last ${recent.length} of ${filtered.length}]\n\n` : '';
+  return `${header}\n\n${truncationNote}${lines.join('\n\n')}\n\n--- Current message follows ---`;
+}
+
+// Load persisted CC session on startup. CC chat sessions are non-expiring;
+// only restore-time validity checks here are sessionId presence (anything
+// else would auto-expire the user's chat without their consent).
 try {
   const saved = safeJson(path.join(ENGINE_DIR, 'cc-session.json'));
-  if (saved && saved.sessionId && !_sessionExpired(saved.lastActiveAt || saved.createdAt, CC_SESSION_TTL_MS)) ccSession = saved;
+  if (saved && saved.sessionId) ccSession = saved;
 } catch { /* optional */ }
 
 let _preambleCache = null;
@@ -5513,7 +5557,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         // Session management — per-tab: use sessionId from request, don't mutate global ccSession
         let tabSessionId = body.sessionId || null;
         let sessionReset = false;
-        // If system prompt changed since this session was created, force a fresh session
+        let sessionResetReason = null;
+        let previousRuntime = null;
+        const currentRuntime = shared.resolveCcCli(CONFIG.engine);
+        // If system prompt or runtime changed since this session was created, force a fresh session
         if (tabSessionId) {
           const sessions = _readCcTabSessions();
           const tabEntry = sessions.find(s => s.id === (body.tabId || 'default'));
@@ -5523,12 +5570,19 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           } else if (tabEntry._promptHash && tabEntry._promptHash !== _ccPromptHash) {
             tabSessionId = null;
             sessionReset = true;
+            sessionResetReason = 'promptChanged';
+          } else if (tabEntry.runtime && tabEntry.runtime !== currentRuntime) {
+            tabSessionId = null;
+            sessionReset = true;
+            sessionResetReason = 'runtimeChanged';
+            previousRuntime = tabEntry.runtime;
           }
         }
         const wasResume = !!tabSessionId;
         const sessionId = tabSessionId || null;
         const preamble = wasResume ? '' : buildCCStatePreamble();
-        const prompt = (preamble ? preamble + '\n\n---\n\n' : '') + body.message;
+        const carryover = sessionReset ? _buildTranscriptCarryover(body.transcript, { previousRuntime }) : '';
+        const prompt = (preamble ? preamble + '\n\n---\n\n' : '') + (carryover ? carryover + '\n\n---\n\n' : '') + body.message;
 
         const { trackEngineUsage: trackUsage } = require('./engine/llm');
         const streamModel = CONFIG.engine?.ccModel || shared.ENGINE_DEFAULTS.ccModel;
@@ -5606,8 +5660,9 @@ What would you like to discuss or change? When you're happy, say "approve" and I
               existing.turnCount = sessionReset ? 1 : (existing.turnCount || 0) + 1;
               existing.preview = preview;
               existing._promptHash = _ccPromptHash;
+              existing.runtime = currentRuntime;
             } else {
-              sessions.push({ id: _persistTabId, title: (body.message || 'New chat').slice(0, 40), sessionId: responseSessionId, createdAt: new Date(now).toISOString(), lastActiveAt: new Date(now).toISOString(), turnCount: 1, preview, _promptHash: _ccPromptHash });
+              sessions.push({ id: _persistTabId, title: (body.message || 'New chat').slice(0, 40), sessionId: responseSessionId, createdAt: new Date(now).toISOString(), lastActiveAt: new Date(now).toISOString(), turnCount: 1, preview, _promptHash: _ccPromptHash, runtime: currentRuntime });
             }
             safeWrite(CC_SESSIONS_PATH, sessions);
           } catch { /* non-critical */ }
@@ -5630,7 +5685,12 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         // Issue #1834: surface action JSON parse failures so the UI can warn
         // instead of silently dropping. Client renders this as a small notice.
         if (_actionParseError) donePayload.actionParseError = _actionParseError;
-        if (sessionReset) donePayload.sessionReset = true;
+        if (sessionReset) {
+          donePayload.sessionReset = true;
+          if (sessionResetReason) donePayload.sessionResetReason = sessionResetReason;
+          if (previousRuntime) donePayload.previousRuntime = previousRuntime;
+          donePayload.currentRuntime = currentRuntime;
+        }
         liveState.donePayload = donePayload;
         if (liveState.writer) liveState.writer(donePayload);
 
@@ -6253,6 +6313,33 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     } catch (e) { return jsonReply(res, e.statusCode || 500, { error: e.message }); }
   }
 
+  async function handleFeaturesList(req, res) {
+    try {
+      return jsonReply(res, 200, { features: features.listFeatures(CONFIG) });
+    } catch (e) { return jsonReply(res, e.statusCode || 500, { error: e.message }); }
+  }
+
+  async function handleFeaturesToggle(req, res) {
+    try {
+      const body = await readBody(req);
+      const id = body && typeof body.id === 'string' ? body.id.trim() : '';
+      if (!id) return jsonReply(res, 400, { error: 'id required' });
+      if (!features.hasFeature(id)) {
+        return jsonReply(res, 404, { error: `Unknown feature flag: "${id}". Register it in engine/features.js.` });
+      }
+      const enabled = body.enabled === true;
+      const configPath = path.join(MINIONS_DIR, 'config.json');
+      mutateJsonFileLocked(configPath, (cfg) => {
+        if (!cfg.features || typeof cfg.features !== 'object') cfg.features = {};
+        cfg.features[id] = enabled;
+        return cfg;
+      });
+      reloadConfig();
+      invalidateStatusCache();
+      return jsonReply(res, 200, { ok: true, id, enabled });
+    } catch (e) { return jsonReply(res, e.statusCode || 500, { error: e.message }); }
+  }
+
   async function handleHealth(req, res) {
     const engine = getEngineState();
     const agents = getAgents();
@@ -7043,6 +7130,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'POST', path: '/api/settings/routing', desc: 'Update routing.md', params: 'content', handler: handleSettingsRouting },
     { method: 'POST', path: '/api/settings/reset', desc: 'Reset engine + claude + agent settings to defaults', handler: handleSettingsReset },
 
+    // Feature flags (experimental / in-progress UX gates — see engine/features.js)
+    { method: 'GET', path: '/api/features', desc: 'List registered feature flags with current enabled state', handler: handleFeaturesList },
+    { method: 'POST', path: '/api/features/toggle', desc: 'Enable/disable a registered feature flag', params: 'id, enabled', handler: handleFeaturesToggle },
+
     // Teams Bot Framework webhook
     { method: 'POST', path: '/api/bot', desc: 'Bot Framework webhook for Teams integration', handler: handleTeamsBot },
   ];

package/docs/command-center.md

@@ -13,11 +13,12 @@ CC maintains a true multi-turn session using Claude CLI's `--resume` flag. Unlik
 **Session lifecycle:**
 - **Created** on first message (or after the system prompt changes, or when you click **New Session**)
 - **Resumed** on subsequent messages via `--resume <sessionId>`
-- **Invalidated** when the CC system prompt changes — detected by hashing `CC_STATIC_SYSTEM_PROMPT` into `_ccPromptHash` and comparing on each call. Sessions are also bounded by `ENGINE_DEFAULTS.ccMaxTurns` (default 50 turns) and `ENGINE_DEFAULTS.ccSessionTtlMs` (default 2h — resumed sessions older than this get rotated).
-- **Persisted** to `engine/cc-session.json` — survives dashboard restarts
+- **Invalidated** only when the CC system prompt changes — detected by hashing `CC_STATIC_SYSTEM_PROMPT` into `_ccPromptHash` and comparing on each call. CC chat sessions do **not** auto-expire by TTL or turn count; `ENGINE_DEFAULTS.ccMaxTurns` (default 50) is a per-call tool-use cap inside the Claude CLI, not a session lifetime cap.
+- **Persisted** to `engine/cc-session.json` (legacy global session) and `engine/cc-sessions.json` (per-tab sessions) — both survive dashboard restarts and engine cleanup ticks
 - **Frontend messages** saved to `localStorage` — survive page refresh
+- **Removed** only when the user explicitly closes a tab via the **×** button on the tab strip — that fires `DELETE /api/cc-sessions/:id` to evict the persisted session
 
-Click **New Session** in the drawer header to start fresh.
+Click **New Session** in the drawer header to start fresh; click the **×** on a tab to remove it permanently.
 
 ### Fresh State Each Turn
 

package/engine/cleanup.js

@@ -681,20 +681,11 @@ async function runCleanup(config, verbose = false) {
     }
   } catch (e) { log('warn', 'orphan PRD status reset: ' + e.message); }
 
-  // 10. Prune CC tab sessions — cap at 50 entries, remove oldest beyond cap
+  // 10. CC tab sessions are non-expiring by design — they persist until the
+  // user explicitly closes the tab (which fires DELETE /api/cc-sessions/:id).
+  // Cleanup intentionally does NOT prune cc-sessions.json; doing so would
+  // silently invalidate live chat tabs the user expects to keep.
   cleaned.ccSessions = 0;
-  try {
-    const ccSessionsPath = path.join(ENGINE_DIR, 'cc-sessions.json');
-    const sessions = shared.safeJsonArr(ccSessionsPath);
-    const CC_SESSIONS_CAP = 50;
-    if (sessions.length > CC_SESSIONS_CAP) {
-      // Sort by lastActiveAt descending, keep newest
-      sessions.sort((a, b) => new Date(b.lastActiveAt || 0) - new Date(a.lastActiveAt || 0));
-      const pruned = sessions.slice(0, CC_SESSIONS_CAP);
-      cleaned.ccSessions = sessions.length - pruned.length;
-      safeWrite(ccSessionsPath, pruned);
-    }
-  } catch (e) { log('warn', 'prune cc-sessions: ' + e.message); }
 
   // 10b. Prune doc-chat sessions — cap at 100 entries, remove oldest beyond cap
   cleaned.docSessions = 0;

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-05T22:02:28.540Z"
+  "cachedAt": "2026-05-06T00:40:29.215Z"
 }

package/engine/features.js

@@ -0,0 +1,58 @@
+/**
+ * engine/features.js — Feature flag registry. Recipe in CLAUDE.md → "Feature Flags".
+ */
+
+// Entry shape: id → { description, default: bool, addedIn?: version, expires?: ISO-date }
+const FEATURES = {
+  // Example:
+  // 'ux-sidebar-v2': { description: '…', default: false, addedIn: '0.1.1738', expires: '2026-06-01' },
+};
+
+const ENV_TRUTHY = new Set(['1', 'true', 'on', 'yes']);
+const ENV_FALSY = new Set(['0', 'false', 'off', 'no', '']);
+
+function envKey(id) {
+  return 'MINIONS_FEATURE_' + String(id).toUpperCase().replace(/-/g, '_');
+}
+
+function readEnvOverride(id) {
+  const raw = process.env[envKey(id)];
+  if (raw === undefined) return undefined;
+  const v = String(raw).trim().toLowerCase();
+  if (ENV_TRUTHY.has(v)) return true;
+  if (ENV_FALSY.has(v)) return false;
+  return undefined;
+}
+
+function isFeatureOn(id, config, registry = FEATURES) {
+  if (!Object.prototype.hasOwnProperty.call(registry, id)) {
+    throw new Error(`Unknown feature flag: "${id}". Register it in engine/features.js.`);
+  }
+  const env = readEnvOverride(id);
+  if (env !== undefined) return env;
+  const fromConfig = config && config.features && config.features[id];
+  if (typeof fromConfig === 'boolean') return fromConfig;
+  return registry[id].default === true;
+}
+
+function listFeatures(config, registry = FEATURES) {
+  const now = Date.now();
+  return Object.entries(registry).map(([id, meta]) => {
+    const expiresAt = meta.expires ? Date.parse(meta.expires) : NaN;
+    return {
+      id,
+      description: meta.description || '',
+      default: meta.default === true,
+      enabled: isFeatureOn(id, config, registry),
+      addedIn: meta.addedIn || null,
+      expires: meta.expires || null,
+      expired: expiresAt < now,
+    };
+  });
+}
+
+function hasFeature(id, registry = FEATURES) {
+  return Object.prototype.hasOwnProperty.call(registry, id);
+}
+
+module.exports = { FEATURES, isFeatureOn, listFeatures, hasFeature };

package/engine/llm.js

@@ -23,6 +23,7 @@ const { resolveRuntime } = require('./runtimes');
 const MINIONS_DIR = shared.MINIONS_DIR;
 const ENGINE_DIR = path.join(MINIONS_DIR, 'engine');
 const COPILOT_TASK_COMPLETE_GRACE_MS = 3000;
+const LLM_EXIT_SETTLE_GRACE_MS = 1000;
 const MISSING_RUNTIME_EXIT_CODE = 78;
 
 // ─── Engine-Usage Metrics ────────────────────────────────────────────────────
@@ -609,6 +610,8 @@ function callLLM(promptText, sysPromptText, opts = {}) {
       maxBudget, bare, fallbackModel,
       ...runtimeFeatureOpts,
     });
+    let settled = false;
+    let exitSettleTimer = null;
     let taskCompleteTimer = null;
     const scheduleTaskCompleteClose = () => {
       if (taskCompleteTimer) return;
@@ -635,11 +638,16 @@ function callLLM(promptText, sysPromptText, opts = {}) {
 
     const timer = setTimeout(() => { shared.killImmediate(proc); }, timeout);
 
-    proc.on('close', (code) => {
+    function finish(code) {
+      if (settled) return;
+      settled = true;
       clearTimeout(timer);
+      if (exitSettleTimer) clearTimeout(exitSettleTimer);
       clearTaskCompleteTimer();
       for (const f of cleanupFiles) safeUnlink(f);
       const parsed = acc.finalize();
+      try { proc.stdout?.destroy(); } catch {}
+      try { proc.stderr?.destroy(); } catch {}
       const durationMs = Date.now() - _startMs;
       const usage = parsed.usage ? { ...parsed.usage, durationMs } : { durationMs };
       // parseError lets the adapter classify obvious failure modes (auth /
@@ -659,10 +667,19 @@ function callLLM(promptText, sysPromptText, opts = {}) {
         runtime: runtime.name,
         errorClass: errInfo.code,
       });
+    }
+
+    proc.on('close', finish);
+    proc.on('exit', (code) => {
+      if (settled) return;
+      exitSettleTimer = setTimeout(() => finish(code), LLM_EXIT_SETTLE_GRACE_MS);
     });
 
     proc.on('error', (err) => {
+      if (settled) return;
+      settled = true;
       clearTimeout(timer);
+      if (exitSettleTimer) clearTimeout(exitSettleTimer);
       clearTaskCompleteTimer();
       for (const f of cleanupFiles) safeUnlink(f);
       shared.log('error', `LLM spawn error (${label}): ${err.message}`);
@@ -709,6 +726,8 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
       maxBudget, bare, fallbackModel,
       ...runtimeFeatureOpts,
     });
+    let settled = false;
+    let exitSettleTimer = null;
     let taskCompleteTimer = null;
     const scheduleTaskCompleteClose = () => {
       if (taskCompleteTimer) return;
@@ -738,11 +757,16 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
 
     const timer = setTimeout(() => { shared.killImmediate(proc); }, timeout);
 
-    proc.on('close', (code) => {
+    function finish(code) {
+      if (settled) return;
+      settled = true;
       clearTimeout(timer);
+      if (exitSettleTimer) clearTimeout(exitSettleTimer);
       clearTaskCompleteTimer();
       for (const f of cleanupFiles) safeUnlink(f);
       const parsed = acc.finalize();
+      try { proc.stdout?.destroy(); } catch {}
+      try { proc.stderr?.destroy(); } catch {}
       const durationMs = Date.now() - _startMs;
       const usage = parsed.usage ? { ...parsed.usage, durationMs } : { durationMs };
       const errInfo = code !== 0
@@ -759,10 +783,22 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
         runtime: runtime.name,
         errorClass: errInfo.code,
       });
+    }
+
+    proc.on('close', finish);
+    proc.on('exit', (code) => {
+      // 'close' waits for stdio to close. If the runtime spawned a detached
+      // grandchild that inherited stdout/stderr, the OS pipe stays open and
+      // 'close' may never fire. Fall back to 'exit' after a drain window.
+      if (settled) return;
+      exitSettleTimer = setTimeout(() => finish(code), LLM_EXIT_SETTLE_GRACE_MS);
     });
 
     proc.on('error', (err) => {
+      if (settled) return;
+      settled = true;
       clearTimeout(timer);
+      if (exitSettleTimer) clearTimeout(exitSettleTimer);
       clearTaskCompleteTimer();
       for (const f of cleanupFiles) safeUnlink(f);
       shared.log('error', `LLM-stream spawn error (${label}): ${err.message}`);

package/engine/shared.js

@@ -914,7 +914,6 @@ const ENGINE_DEFAULTS = {
   removeWorktreeFailureTtlMs: 24 * 60 * 60 * 1000, // stale failed paths are forgotten after a day
   removeWorktreeFailureMaxEntries: 1000, // bound failed-worktree retry suppression cache
   ccMaxTurns: 50, // max tool-use turns for CC/doc-chat before CLI stops
-  ccSessionTtlMs: 7 * 24 * 60 * 60 * 1000, // 7d — keep chats resumable after breaks, still bounded by turn cap
   docSessionTtlMs: 7 * 24 * 60 * 60 * 1000, // 7d — longer-lived doc sessions, still bounded
   docSessionMaxEntries: 200, // cap doc-chat session map/disk store by least-recent activity
   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.1737",
+  "version": "0.1.1739",
   "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"