@yemi33/minions 0.1.1738 → 0.1.1740

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1740 (2026-05-06)
+
+### Features
+- doc-chat resume retry + 1h timeout + surfaced stderr (#2101)
+- make Command Center chat sessions non-expiring (#2100)
+
+### Fixes
+- invalidate stale session IDs on runtime switch (#2102)
+- drop 5s setTimeout that nuked sysprompt .tmp before Claude could read it (#2105)
+
 ## 0.1.1738 (2026-05-06)
 
 ### Features

package/dashboard/js/command-center.js

@@ -392,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

package/dashboard.js

@@ -932,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
@@ -947,9 +952,10 @@ const CC_STREAM_REATTACH_GRACE_MS = 60000; // keep CC job alive briefly after di
 const CC_STREAM_DONE_RETENTION_MS = 30000; // retain final payload briefly so reconnect can still receive it
 const CC_LIVE_STREAM_MAX_AGE_MS = shared.ENGINE_DEFAULTS.ccLiveStreamMaxAgeMs;
 // Doc-chat is interactive — long-doc edits with multi-step Read+Write tool use can run
-// 4–5 min on `canEdit:true` paths. CC's default 2-min timeout was killing legitimate
-// edits mid-stream. Pinned to 6 min as the bounded but generous ceiling.
-const DOC_CHAT_TIMEOUT_MS = 360000;
+// well past 5 min on `canEdit:true` paths. Bumped to 1 hour (matching CC) so legitimate
+// edits aren't killed mid-stream and the backend timeout never beats the user's reading
+// time. The doc-chat handlers still abort on client disconnect.
+const DOC_CHAT_TIMEOUT_MS = 60 * 60 * 1000;
 function _releaseCCTab(tabId) { ccInFlightTabs.delete(tabId); ccInFlightAborts.delete(tabId); }
 function _getCcLiveStream(tabId) {
   return ccLiveStreams.get(tabId) || null;
@@ -1070,18 +1076,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
@@ -1120,11 +1125,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)
   );
 }
@@ -1157,10 +1164,12 @@ function _buildTranscriptCarryover(transcript, { previousRuntime } = {}) {
   return `${header}\n\n${truncationNote}${lines.join('\n\n')}\n\n--- Current message follows ---`;
 }
 
-// Load persisted CC session on startup
+// 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;
@@ -2458,6 +2467,56 @@ function _formatDocChatContext({ document, title, filePath, selection, canEdit,
   return context;
 }
 
+// Build the doc-chat extraContext for a single ccCall pass — refreshed on retry
+// so a fresh-session retry includes the full document instead of relying on the
+// dead session's prior turn for context.
+function _buildDocChatPass({ docSlice, title, filePath, selection, canEdit, isJson, sessionKey, freshSession }) {
+  const existing = freshSession ? null : resolveSession('doc', sessionKey);
+  const docHash = require('crypto').createHash('md5').update(docSlice).digest('hex').slice(0, 8);
+  const docUnchanged = existing?.sessionId && existing._docHash === docHash;
+  const extraContext = _formatDocChatContext({
+    document: docSlice, title, filePath, selection, canEdit, isJson, docUnchanged,
+  });
+  return { extraContext, docHash, hadSession: !!existing?.sessionId };
+}
+
+// One-shot recovery from a stuck resumed session: if the initial call rode an
+// existing session and came back empty / non-zero, invalidate the persisted
+// session and re-run via the supplied closure. ccCall already retries fresh
+// when the runtime can't extract a sessionId, but on adapter-still-alive
+// failures it preserves the session — and from doc-chat's perspective that's
+// the failure mode the user actually sees ("Failed to process request").
+async function _retryDocChatAfterResumeFailure({ result, initialPass, freshSession, sessionKey, runOnce }) {
+  if (!initialPass.hadSession || freshSession || result.missingRuntime) return result;
+  if (result.code === 0 && result.text) return result;
+  console.log(`[doc-chat] Resumed session call failed (code=${result.code}, empty=${!result.text}) — invalidating session and retrying fresh for ${sessionKey || 'untitled'}`);
+  if (sessionKey) {
+    docSessions.delete(sessionKey);
+    schedulePersistDocSessions();
+  }
+  return runOnce();
+}
+
+// Build the {error} envelope returned to the dashboard when doc-chat ultimately
+// fails. Keeps the polite user-facing message but exposes the runtime's real
+// stderr / exit code / errorClass so the UI can render the cause and so future
+// failures are debuggable from logs.
+function _docChatFailureResponse(label, filePath, result) {
+  const stderrTail = (result.stderr || '').slice(-2048);
+  console.error(`[${label}] Failed: code=${result.code}, empty=${!result.text}, filePath=${filePath}, errorClass=${result.errorClass || 'null'}, stderr=${stderrTail.slice(0, 200)}`);
+  return {
+    answer: 'Failed to process request. Try again.',
+    content: null,
+    actions: [],
+    error: {
+      code: result.code ?? null,
+      stderr: stderrTail,
+      errorClass: result.errorClass || null,
+      runtime: result.runtime || null,
+    },
+  };
+}
+
 // Doc-specific wrapper — adds document context, parses ---DOCUMENT---
 async function ccDocCall({ message, document, title, filePath, selection, canEdit, isJson, model, freshSession, onAbortReady }) {
   const sessionKey = filePath || title;
@@ -2471,34 +2530,30 @@ async function ccDocCall({ message, document, title, filePath, selection, canEdi
     // Skip persistDocSessions() here — the post-call cleanup below handles persistence.
   }
 
-  // Skip re-sending full document on session resume if content unchanged
-  const docHash = require('crypto').createHash('md5').update(docSlice).digest('hex').slice(0, 8);
-  const existing = freshSession ? null : resolveSession('doc', sessionKey);
-  const docUnchanged = existing?.sessionId && existing._docHash === docHash;
-
-  const docContext = _formatDocChatContext({
-    document: docSlice,
-    title,
-    filePath,
-    selection,
-    canEdit,
-    isJson,
-    docUnchanged,
-  });
   const allowActions = _messageRequestsOrchestration(message);
 
-  const result = await ccCall(message, {
-    store: 'doc', sessionKey,
-    extraContext: docContext, label: 'doc-chat',
-    timeout: DOC_CHAT_TIMEOUT_MS,
-    allowedTools: canEdit ? 'Read,Write,Edit,Glob,Grep' : 'Read,Glob,Grep',
-    maxTurns: canEdit ? 25 : 10,
-    timeout: DOC_CHAT_TIMEOUT_MS,
-    skipStatePreamble: true,
-    systemPrompt: DOC_CHAT_SYSTEM_PROMPT,
-    ...(model ? { model } : {}),
-    onAbortReady,
+  const runOnce = async () => {
+    const { extraContext } = _buildDocChatPass({
+      docSlice, title, filePath, selection, canEdit, isJson, sessionKey, freshSession,
+    });
+    return ccCall(message, {
+      store: 'doc', sessionKey,
+      extraContext, label: 'doc-chat',
+      timeout: DOC_CHAT_TIMEOUT_MS,
+      allowedTools: canEdit ? 'Read,Write,Edit,Glob,Grep' : 'Read,Glob,Grep',
+      maxTurns: canEdit ? 25 : 10,
+      skipStatePreamble: true,
+      systemPrompt: DOC_CHAT_SYSTEM_PROMPT,
+      ...(model ? { model } : {}),
+      onAbortReady,
+    });
+  };
+
+  const initialPass = _buildDocChatPass({
+    docSlice, title, filePath, selection, canEdit, isJson, sessionKey, freshSession,
   });
+  let result = await runOnce();
+  result = await _retryDocChatAfterResumeFailure({ result, initialPass, freshSession, sessionKey, runOnce });
 
   if (freshSession && sessionKey) {
     // One-shot call — discard the session ccCall just stored so it cannot
@@ -2508,7 +2563,7 @@ async function ccDocCall({ message, document, title, filePath, selection, canEdi
   } else if (result.code === 0 && result.sessionId) {
     // Store doc hash for next call's unchanged check
     const session = resolveSession('doc', sessionKey);
-    if (session) session._docHash = docHash;
+    if (session) session._docHash = initialPass.docHash;
   }
 
   if (result.missingRuntime) {
@@ -2516,8 +2571,7 @@ async function ccDocCall({ message, document, title, filePath, selection, canEdi
   }
 
   if (result.code !== 0 || !result.text) {
-    console.error(`[doc-chat] Failed: code=${result.code}, empty=${!result.text}, filePath=${filePath}, stderr=${(result.stderr || '').slice(0, 200)}`);
-    return { answer: 'Failed to process request. Try again.', content: null, actions: [] };
+    return _docChatFailureResponse('doc-chat', filePath, result);
   }
 
   return _parseDocChatResultText(result.text, { allowActions });
@@ -2531,42 +2585,39 @@ async function ccDocCallStreaming({ message, document, title, filePath, selectio
     docSessions.delete(sessionKey);
   }
 
-  const docHash = require('crypto').createHash('md5').update(docSlice).digest('hex').slice(0, 8);
-  const existing = freshSession ? null : resolveSession('doc', sessionKey);
-  const docUnchanged = existing?.sessionId && existing._docHash === docHash;
-
-  const docContext = _formatDocChatContext({
-    document: docSlice,
-    title,
-    filePath,
-    selection,
-    canEdit,
-    isJson,
-    docUnchanged,
-  });
   const allowActions = _messageRequestsOrchestration(message);
 
-  const result = await ccCallStreaming(message, {
-    store: 'doc', sessionKey,
-    extraContext: docContext, label: 'doc-chat',
-    timeout: DOC_CHAT_TIMEOUT_MS,
-    allowedTools: canEdit ? 'Read,Write,Edit,Glob,Grep' : 'Read,Glob,Grep',
-    maxTurns: canEdit ? 25 : 10,
-    timeout: DOC_CHAT_TIMEOUT_MS,
-    skipStatePreamble: true,
-    systemPrompt: DOC_CHAT_SYSTEM_PROMPT,
-    ...(model ? { model } : {}),
-    onAbortReady,
-    onChunk: (text) => { if (onChunk) onChunk(_docChatDisplayText(text, { allowActions })); },
-    onToolUse,
+  const runOnce = async () => {
+    const { extraContext } = _buildDocChatPass({
+      docSlice, title, filePath, selection, canEdit, isJson, sessionKey, freshSession,
+    });
+    return ccCallStreaming(message, {
+      store: 'doc', sessionKey,
+      extraContext, label: 'doc-chat',
+      timeout: DOC_CHAT_TIMEOUT_MS,
+      allowedTools: canEdit ? 'Read,Write,Edit,Glob,Grep' : 'Read,Glob,Grep',
+      maxTurns: canEdit ? 25 : 10,
+      skipStatePreamble: true,
+      systemPrompt: DOC_CHAT_SYSTEM_PROMPT,
+      ...(model ? { model } : {}),
+      onAbortReady,
+      onChunk: (text) => { if (onChunk) onChunk(_docChatDisplayText(text, { allowActions })); },
+      onToolUse,
+    });
+  };
+
+  const initialPass = _buildDocChatPass({
+    docSlice, title, filePath, selection, canEdit, isJson, sessionKey, freshSession,
   });
+  let result = await runOnce();
+  result = await _retryDocChatAfterResumeFailure({ result, initialPass, freshSession, sessionKey, runOnce });
 
   if (freshSession && sessionKey) {
     docSessions.delete(sessionKey);
     schedulePersistDocSessions();
   } else if (result.code === 0 && result.sessionId) {
     const session = resolveSession('doc', sessionKey);
-    if (session) session._docHash = docHash;
+    if (session) session._docHash = initialPass.docHash;
   }
 
   if (result.missingRuntime) {
@@ -2574,8 +2625,7 @@ async function ccDocCallStreaming({ message, document, title, filePath, selectio
   }
 
   if (result.code !== 0 || !result.text) {
-    console.error(`[doc-chat-stream] Failed: code=${result.code}, empty=${!result.text}, filePath=${filePath}, stderr=${(result.stderr || '').slice(0, 200)}`);
-    return { answer: 'Failed to process request. Try again.', content: null, actions: [] };
+    return _docChatFailureResponse('doc-chat-stream', filePath, result);
   }
 
   return _parseDocChatResultText(result.text, { allowActions });
@@ -4672,7 +4722,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         }
       }
 
-      const { answer, content, actions, actionParseError } = await ccDocCall({
+      const { answer, content, actions, actionParseError, error: ccError } = await ccDocCall({
         message: body.message, document: currentContent, title: body.title,
         filePath: body.filePath, selection: body.selection, canEdit, isJson,
         model: body.model || undefined,
@@ -4681,11 +4731,12 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       });
       const actionResults = await executeDocChatActions(actions);
       const baseReply = (extra = {}) => ({
-        ok: true,
+        ok: !ccError,
         answer,
         actions,
         ...(actionResults ? { actionResults } : {}),
         ...(actionParseError ? { actionParseError } : {}),
+        ...(ccError ? { error: ccError } : {}),
         ...extra,
       });
 
@@ -4787,7 +4838,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
       try {
 
-        const { answer, content, actions, actionParseError } = await ccDocCallStreaming({
+        const { answer, content, actions, actionParseError, error: ccError } = await ccDocCallStreaming({
           message: body.message, document: currentContent, title: body.title,
           filePath: body.filePath, selection: body.selection, canEdit, isJson,
           model: body.model || undefined,
@@ -4803,6 +4854,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           actions,
           ...(actionResults ? { actionResults } : {}),
           ...(actionParseError ? { actionParseError } : {}),
+          ...(ccError ? { error: ccError } : {}),
           ...extra,
         });
 

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-06T00:16:35.626Z"
+  "cachedAt": "2026-05-06T00:41:30.276Z"
 }

package/engine/llm.js

@@ -787,6 +787,9 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
 
     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);
     });

package/engine/runtimes/claude.js

@@ -287,12 +287,33 @@ function getSkillWriteTargets({ homeDir = os.homedir(), project = null } = {}) {
   };
 }
 
+// Stamped into every session.json this adapter writes so the pre-spawn resume
+// path can detect "session was produced by a different runtime" — Claude
+// rejects Copilot session IDs (and vice versa) with "No conversation found",
+// which would otherwise burn a retry slot before the post-failure cleanup at
+// engine.js:1195 fires. See W-mot9fwya000d09cb.
+const RUNTIME_NAME = 'claude';
+
 function getResumeSessionId({ agentId, branchName, agentsDir, maxAgeMs = 2 * 60 * 60 * 1000, logger = console } = {}) {
   if (!agentId || agentId.startsWith('temp-') || !agentsDir) return null;
+  const sessionPath = path.join(agentsDir, agentId, 'session.json');
   try {
-    const sessionPath = path.join(agentsDir, agentId, 'session.json');
     const sessionFile = _safeJson(sessionPath);
     if (!sessionFile?.sessionId || !sessionFile.savedAt) return null;
+
+    // Runtime-mismatch invalidation. Distinct from stale-by-age: the session is
+    // structurally unusable on this runtime, so drop it AND clear session.json
+    // so the next dispatch starts fresh instead of failing with --resume.
+    // Legacy sessions (no `runtime` field) are treated as compatible — opt-in
+    // check, no false invalidations on first deploy.
+    if (sessionFile.runtime && sessionFile.runtime !== RUNTIME_NAME) {
+      if (logger && typeof logger.info === 'function') {
+        logger.info(`Skipping resume for ${agentId}: runtime mismatch (session: ${sessionFile.runtime}, current: ${RUNTIME_NAME}) — clearing session.json`);
+      }
+      try { fs.unlinkSync(sessionPath); } catch {}
+      return null;
+    }
+
     const sessionAge = Date.now() - new Date(sessionFile.savedAt).getTime();
     const sameBranch = branchName && sessionFile.branch && sessionFile.branch === branchName;
     if (sessionAge < maxAgeMs && sameBranch) {
@@ -315,6 +336,7 @@ function saveSession({ agentId, dispatchId, branch, sessionId, agentsDir, now =
       dispatchId,
       savedAt: typeof now === 'function' ? now() : new Date().toISOString(),
       branch: branch || null,
+      runtime: RUNTIME_NAME,
     });
     return true;
   } catch (err) {

package/engine/runtimes/copilot.js

@@ -306,12 +306,33 @@ function getSkillWriteTargets({ homeDir = os.homedir(), project = null } = {}) {
   };
 }
 
+// Stamped into every session.json this adapter writes so the pre-spawn resume
+// path can detect "session was produced by a different runtime" — Copilot
+// rejects Claude session IDs (and vice versa) with "No conversation found",
+// which would otherwise burn a retry slot before the post-failure cleanup at
+// engine.js:1195 fires. See W-mot9fwya000d09cb.
+const RUNTIME_NAME = 'copilot';
+
 function getResumeSessionId({ agentId, branchName, agentsDir, maxAgeMs = 2 * 60 * 60 * 1000, logger = console } = {}) {
   if (!agentId || agentId.startsWith('temp-') || !agentsDir) return null;
+  const sessionPath = path.join(agentsDir, agentId, 'session.json');
   try {
-    const sessionPath = path.join(agentsDir, agentId, 'session.json');
     const sessionFile = _safeJson(sessionPath);
     if (!sessionFile?.sessionId || !sessionFile.savedAt) return null;
+
+    // Runtime-mismatch invalidation. Distinct from stale-by-age: the session is
+    // structurally unusable on this runtime, so drop it AND clear session.json
+    // so the next dispatch starts fresh instead of failing with --resume.
+    // Legacy sessions (no `runtime` field) are treated as compatible — opt-in
+    // check, no false invalidations on first deploy.
+    if (sessionFile.runtime && sessionFile.runtime !== RUNTIME_NAME) {
+      if (logger && typeof logger.info === 'function') {
+        logger.info(`Skipping resume for ${agentId}: runtime mismatch (session: ${sessionFile.runtime}, current: ${RUNTIME_NAME}) — clearing session.json`);
+      }
+      try { fs.unlinkSync(sessionPath); } catch {}
+      return null;
+    }
+
     const sessionAge = Date.now() - new Date(sessionFile.savedAt).getTime();
     const sameBranch = branchName && sessionFile.branch && sessionFile.branch === branchName;
     if (sessionAge < maxAgeMs && sameBranch) {
@@ -334,6 +355,7 @@ function saveSession({ agentId, dispatchId, branch, sessionId, agentsDir, now =
       dispatchId,
       savedAt: typeof now === 'function' ? now() : new Date().toISOString(),
       branch: branch || null,
+      runtime: RUNTIME_NAME,
     });
     return true;
   } catch (err) {

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/engine/spawn-agent.js

@@ -355,11 +355,14 @@ function main() {
 
   // Clean up sys tmp (only created for non-resume sessions on adapters that
   // use --system-prompt-file).
-  if (wantsSystemPromptFile) {
-    setTimeout(() => { try { fs.unlinkSync(sysTmpPath); } catch { /* cleanup */ } }, 5000);
-  }
-
-  // Register exit handler to clean up orphaned temp files
+  //
+  // We deliberately DO NOT use a fixed-delay setTimeout here. Claude CLI reads
+  // `--system-prompt-file` lazily during init; on cold starts (MCP boot,
+  // `--add-dir` traversal, Windows process startup) the read can land well
+  // after any short timer fires, leaving Claude to bail with
+  // "System prompt file not found". The exit/SIGTERM handler below — plus the
+  // matching unlinks in engine/dispatch.js and engine/meeting.js on dispatch
+  // completion — are sufficient to keep tmp files from leaking.
   function _cleanupSpawnTempFiles() {
     if (wantsSystemPromptFile) {
       try { fs.unlinkSync(sysTmpPath); } catch { /* may already be cleaned */ }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1738",
+  "version": "0.1.1740",
   "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"