@yemi33/minions 0.1.1743 → 0.1.1745

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1745 (2026-05-06)
+
+### Features
+- fix doc-chat failure bugs from Ripley investigation (#2103)
+
 ## 0.1.1743 (2026-05-06)
 
 ### Fixes

package/dashboard/js/modal-qa.js

@@ -499,7 +499,7 @@ async function _processQaMessage(message, selection, opts) {
         selection: selection,
         filePath: capturedFilePath || null,
         model: window._lastStatus?.autoMode?.ccModel || undefined,
-        contentHash: capturedDocContext.content ? capturedDocContext.content.length + ':' + capturedDocContext.content.charCodeAt(0) + ':' + capturedDocContext.content.charCodeAt(capturedDocContext.content.length - 1) : undefined,
+        contentHash: capturedDocContext.content ? (function(s) { const m = Math.floor(s.length / 2); return s.length + ':' + s.charCodeAt(0) + ':' + s.charCodeAt(m) + ':' + s.charCodeAt(s.length - 1); })(capturedDocContext.content) : undefined,
       }),
     });
     let sessionDocContext = { ...capturedDocContext };
@@ -521,6 +521,12 @@ async function _processQaMessage(message, selection, opts) {
     async function _qaHandleStreamEvent(evt) {
       if (!evt || !evt.type) return;
       if (evt.type === 'heartbeat') return;
+      if (evt.type === 'progress') {
+        // Backend is retrying (attempt 2 or 3) — reset stall watchdog so the next
+        // attempt gets its own full stall window instead of sharing the first attempt's.
+        _resetQaStreamWatchdog();
+        return;
+      }
       if (evt.type === 'chunk') {
         _resetQaStreamWatchdog();
         streamedText = evt.text || '';

package/dashboard.js

@@ -2377,7 +2377,7 @@ async function ccCall(message, { store = 'cc', sessionKey, extraContext, label =
   return result;
 }
 
-async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext, label = 'command-center', timeout = CC_CALL_TIMEOUT_MS, maxTurns, allowedTools = 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch', skipStatePreamble = false, model, onAbortReady, onChunk, onToolUse, systemPrompt = CC_STATIC_SYSTEM_PROMPT } = {}) {
+async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext, label = 'command-center', timeout = CC_CALL_TIMEOUT_MS, maxTurns, allowedTools = 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch', skipStatePreamble = false, model, onAbortReady, onChunk, onToolUse, onRetry, systemPrompt = CC_STATIC_SYSTEM_PROMPT } = {}) {
   if (!maxTurns) maxTurns = CONFIG.engine?.ccMaxTurns || shared.ENGINE_DEFAULTS.ccMaxTurns;
   if (!model) model = CONFIG.engine?.ccModel || shared.ENGINE_DEFAULTS.ccModel;
   const ccEffort = CONFIG.engine?.ccEffort || shared.ENGINE_DEFAULTS.ccEffort;
@@ -2430,6 +2430,7 @@ async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext
     }
   }
 
+  if (onRetry) onRetry(2);
   const freshPrompt = buildPrompt();
   const p2 = llm.callLLMStreaming(freshPrompt, systemPrompt, {
     timeout, label, model, maxTurns, allowedTools, effort: ccEffort, direct: true,
@@ -2450,6 +2451,7 @@ async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext
   if (maxTurns <= 1) return result;
   console.log(`[${label}] Fresh call also failed (code=${result.code}, empty=${!result.text}), retrying once more...`);
   await new Promise(r => setTimeout(r, 2000));
+  if (onRetry) onRetry(3);
   const p3 = llm.callLLMStreaming(freshPrompt, systemPrompt, {
     timeout, label, model, maxTurns, allowedTools, effort: ccEffort, direct: true,
     engineConfig: CONFIG.engine,
@@ -2467,10 +2469,13 @@ async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext
   return result;
 }
 
-// Lightweight content fingerprint — same algorithm used browser-side (no crypto needed)
+// Lightweight content fingerprint — same algorithm used browser-side (no crypto needed).
+// Uses length + first + middle + last char codes. Collisions on same-length strings with
+// identical first/middle/last chars are rare enough for a staleness check (not a security hash).
 function contentFingerprint(str) {
   if (!str) return '';
-  return str.length + ':' + str.charCodeAt(0) + ':' + str.charCodeAt(str.length - 1);
+  const mid = Math.floor(str.length / 2);
+  return str.length + ':' + str.charCodeAt(0) + ':' + str.charCodeAt(mid) + ':' + str.charCodeAt(str.length - 1);
 }
 
 function _parseDocChatResultText(text, { allowActions = false } = {}) {
@@ -2524,6 +2529,17 @@ function _formatDocChatContext({ document, title, filePath, selection, canEdit,
   return context;
 }
 
+// Map errorClass codes from the runtime adapter to actionable user-facing messages.
+// sessionPreserved=true means ccCall preserved the session — user can retry immediately.
+function _docChatErrorMessage(errorClass, sessionPreserved = false) {
+  if (errorClass === 'auth-failure') return 'Claude authentication failed — run `claude auth` or check your API key, then try again.';
+  if (errorClass === 'context-limit') return 'Session context is too long. Click "Clear" to start a fresh conversation.';
+  if (errorClass === 'budget-exceeded') return 'API budget exceeded — check your Claude account spending limit.';
+  if (errorClass === 'crash') return 'Claude runtime crashed unexpectedly. Try again.';
+  if (sessionPreserved) return 'Temporary connection issue — your conversation is intact, send your message again.';
+  return 'Failed to process request. Try again.';
+}
+
 // 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.
@@ -2555,14 +2571,14 @@ async function _retryDocChatAfterResumeFailure({ result, initialPass, freshSessi
 }
 
 // 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) {
+// fails. Surfaces an actionable user-facing message (via _docChatErrorMessage)
+// plus 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, sessionPreserved = false) {
   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)}`);
+  console.error(`[${label}] Failed: code=${result.code}, errorClass=${result.errorClass || 'null'}, sessionPreserved=${sessionPreserved}, empty=${!result.text}, filePath=${filePath}, stderr=${stderrTail.slice(0, 200)}`);
   return {
-    answer: 'Failed to process request. Try again.',
+    answer: _docChatErrorMessage(result.errorClass, sessionPreserved),
     content: null,
     actions: [],
     error: {
@@ -2574,6 +2590,7 @@ function _docChatFailureResponse(label, filePath, result) {
   };
 }
 
+
 // 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;
@@ -2628,13 +2645,14 @@ async function ccDocCall({ message, document, title, filePath, selection, canEdi
   }
 
   if (result.code !== 0 || !result.text) {
-    return _docChatFailureResponse('doc-chat', filePath, result);
+    const sessionPreserved = !!(resolveSession('doc', sessionKey)?.sessionId);
+    return _docChatFailureResponse('doc-chat', filePath, result, sessionPreserved);
   }
 
   return _parseDocChatResultText(result.text, { allowActions });
 }
 
-async function ccDocCallStreaming({ message, document, title, filePath, selection, canEdit, isJson, model, freshSession, onAbortReady, onChunk, onToolUse }) {
+async function ccDocCallStreaming({ message, document, title, filePath, selection, canEdit, isJson, model, freshSession, onAbortReady, onChunk, onToolUse, onRetry }) {
   const sessionKey = filePath || title;
   const docSlice = document.slice(0, 20000);
 
@@ -2660,6 +2678,7 @@ async function ccDocCallStreaming({ message, document, title, filePath, selectio
       onAbortReady,
       onChunk: (text) => { if (onChunk) onChunk(_docChatDisplayText(text, { allowActions })); },
       onToolUse,
+      onRetry,
     });
   };
 
@@ -2682,7 +2701,8 @@ async function ccDocCallStreaming({ message, document, title, filePath, selectio
   }
 
   if (result.code !== 0 || !result.text) {
-    return _docChatFailureResponse('doc-chat-stream', filePath, result);
+    const sessionPreserved = !!(resolveSession('doc', sessionKey)?.sessionId);
+    return _docChatFailureResponse('doc-chat-stream', filePath, result, sessionPreserved);
   }
 
   return _parseDocChatResultText(result.text, { allowActions });
@@ -4903,6 +4923,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           onAbortReady: (abort) => { _docAbort = abort; },
           onChunk: (text) => { writeDocEvent({ type: 'chunk', text }); },
           onToolUse: (name, input) => { writeDocEvent({ type: 'tool', name, input: _lightToolInput(input) }); },
+          onRetry: (attempt) => { writeDocEvent({ type: 'progress', attempt }); },
         });
         const actionResults = await executeDocChatActions(actions);
         const donePayload = (extra = {}) => ({

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-06T01:38:23.998Z"
+  "cachedAt": "2026-05-06T02:33:28.238Z"
 }

package/engine/llm.js

@@ -23,8 +23,12 @@ 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;
+// When the spawned process emits 'exit' but 'close' is delayed (a detached
+// grandchild inherited stdio), wait this long for trailing stdout data to
+// drain into our buffer before finalizing on the exit fallback path. 'close'
+// is preferred; this is a safety net so callers don't hang on inherited pipes.
+const EXIT_DRAIN_FALLBACK_MS = 100;
 
 // ─── Engine-Usage Metrics ────────────────────────────────────────────────────
 //
@@ -423,6 +427,7 @@ function _createStreamAccumulator({
   onChunk = null,
   onToolUse = null,
   onTaskComplete = null,
+  onTerminalResult = null,
   onThinking = null,
 }) {
   if (!runtime?.capabilities?.streamConsumer || typeof runtime.createStreamConsumer !== 'function') {
@@ -438,6 +443,7 @@ function _createStreamAccumulator({
   let lastTextSent = '';
   let thinkingSent = false;
   let taskCompleteFired = false;
+  let terminalResultFired = false;
   let lastTaskCompleteSummary = '';
   const toolUses = [];
 
@@ -462,8 +468,18 @@ function _createStreamAccumulator({
       // override any streamed text (Claude's `result`, Copilot's final
       // assistant.message). onChunk is NOT fired here; this is the
       // authoritative final-text path, not a streaming chunk.
+      //
+      // Fire onTerminalResult once on the first non-empty terminal text so
+      // callers can early-resolve without waiting for the OS-level 'exit' /
+      // 'close' events — those can be delayed indefinitely on Linux when a
+      // detached grandchild has inherited the stdout pipe (e.g. Claude/Copilot
+      // CLIs that spawn background workers).
       if (typeof value !== 'string') return;
       text = _streamText(value);
+      if (value && onTerminalResult && !terminalResultFired) {
+        terminalResultFired = true;
+        onTerminalResult();
+      }
     },
     pushToolUse(name, input) {
       if (!name) return;
@@ -610,8 +626,6 @@ function callLLM(promptText, sysPromptText, opts = {}) {
       maxBudget, bare, fallbackModel,
       ...runtimeFeatureOpts,
     });
-    let settled = false;
-    let exitSettleTimer = null;
     let taskCompleteTimer = null;
     const scheduleTaskCompleteClose = () => {
       if (taskCompleteTimer) return;
@@ -623,12 +637,23 @@ function callLLM(promptText, sysPromptText, opts = {}) {
         taskCompleteTimer = null;
       }
     };
+    let resolved = false;
+    let exitFallbackTimer = null;
+    let exitCode = null;
+    const scheduleExitFallback = (code) => {
+      if (resolved || exitFallbackTimer) return;
+      exitFallbackTimer = setTimeout(() => finalizeAndResolve(code), EXIT_DRAIN_FALLBACK_MS);
+    };
     const acc = _createStreamAccumulator({
       runtime,
       maxRawBytes: ENGINE_DEFAULTS.maxLlmRawBytes,
       maxStderrBytes: ENGINE_DEFAULTS.maxLlmStderrBytes,
       maxLineBufferBytes: ENGINE_DEFAULTS.maxLlmLineBufferBytes,
       onTaskComplete: scheduleTaskCompleteClose,
+      // Terminal text from the runtime adapter signals the LLM has logically
+      // completed — kick the drain timer so we don't block on a delayed
+      // 'exit'/'close' when an inherited pipe keeps the parent's FDs open.
+      onTerminalResult: () => scheduleExitFallback(exitCode != null ? exitCode : 0),
     });
 
     _abort = () => { shared.killImmediate(proc); };
@@ -638,16 +663,14 @@ function callLLM(promptText, sysPromptText, opts = {}) {
 
     const timer = setTimeout(() => { shared.killImmediate(proc); }, timeout);
 
-    function finish(code) {
-      if (settled) return;
-      settled = true;
+    const finalizeAndResolve = (code) => {
+      if (resolved) return;
+      resolved = true;
       clearTimeout(timer);
-      if (exitSettleTimer) clearTimeout(exitSettleTimer);
       clearTaskCompleteTimer();
+      if (exitFallbackTimer) { clearTimeout(exitFallbackTimer); exitFallbackTimer = null; }
       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 /
@@ -667,20 +690,22 @@ 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);
-    });
+    // 'close' fires after stdio streams close; if a detached grandchild
+    // inherited stdout, that can be delayed indefinitely. 'exit' fires when
+    // the child itself exits — schedule a short drain window then resolve.
+    // On Linux, 'exit' itself can be delayed by an inherited pipe handle, so
+    // the accumulator's onTerminalResult provides a third early-resolve path.
+    proc.on('exit', (code) => { exitCode = code; scheduleExitFallback(code); });
+    proc.on('close', (code) => { finalizeAndResolve(code); });
 
     proc.on('error', (err) => {
-      if (settled) return;
-      settled = true;
+      if (resolved) return;
+      resolved = true;
       clearTimeout(timer);
-      if (exitSettleTimer) clearTimeout(exitSettleTimer);
       clearTaskCompleteTimer();
+      if (exitFallbackTimer) { clearTimeout(exitFallbackTimer); exitFallbackTimer = null; }
       for (const f of cleanupFiles) safeUnlink(f);
       shared.log('error', `LLM spawn error (${label}): ${err.message}`);
       resolve({
@@ -726,8 +751,6 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
       maxBudget, bare, fallbackModel,
       ...runtimeFeatureOpts,
     });
-    let settled = false;
-    let exitSettleTimer = null;
     let taskCompleteTimer = null;
     const scheduleTaskCompleteClose = () => {
       if (taskCompleteTimer) return;
@@ -739,6 +762,13 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
         taskCompleteTimer = null;
       }
     };
+    let resolved = false;
+    let exitFallbackTimer = null;
+    let exitCode = null;
+    const scheduleExitFallback = (code) => {
+      if (resolved || exitFallbackTimer) return;
+      exitFallbackTimer = setTimeout(() => finalizeAndResolve(code), EXIT_DRAIN_FALLBACK_MS);
+    };
     const acc = _createStreamAccumulator({
       runtime,
       maxRawBytes: ENGINE_DEFAULTS.maxLlmRawBytes,
@@ -747,6 +777,10 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
       onChunk,
       onToolUse,
       onTaskComplete: scheduleTaskCompleteClose,
+      // Terminal text from the runtime adapter signals the LLM has logically
+      // completed — kick the drain timer so we don't block on a delayed
+      // 'exit'/'close' when an inherited pipe keeps the parent's FDs open.
+      onTerminalResult: () => scheduleExitFallback(exitCode != null ? exitCode : 0),
       onThinking: opts.onThinking || null,
     });
 
@@ -757,16 +791,14 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
 
     const timer = setTimeout(() => { shared.killImmediate(proc); }, timeout);
 
-    function finish(code) {
-      if (settled) return;
-      settled = true;
+    const finalizeAndResolve = (code) => {
+      if (resolved) return;
+      resolved = true;
       clearTimeout(timer);
-      if (exitSettleTimer) clearTimeout(exitSettleTimer);
       clearTaskCompleteTimer();
+      if (exitFallbackTimer) { clearTimeout(exitFallbackTimer); exitFallbackTimer = null; }
       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
@@ -783,23 +815,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);
-    });
+    // 'close' fires after stdio streams close; if a detached grandchild
+    // inherited stdout, that can be delayed indefinitely. 'exit' fires when
+    // the child itself exits — schedule a short drain window then resolve.
+    // On Linux, 'exit' itself can be delayed by an inherited pipe handle, so
+    // the accumulator's onTerminalResult provides a third early-resolve path.
+    proc.on('exit', (code) => { exitCode = code; scheduleExitFallback(code); });
+    proc.on('close', (code) => { finalizeAndResolve(code); });
 
     proc.on('error', (err) => {
-      if (settled) return;
-      settled = true;
+      if (resolved) return;
+      resolved = true;
       clearTimeout(timer);
-      if (exitSettleTimer) clearTimeout(exitSettleTimer);
       clearTaskCompleteTimer();
+      if (exitFallbackTimer) { clearTimeout(exitFallbackTimer); exitFallbackTimer = null; }
       for (const f of cleanupFiles) safeUnlink(f);
       shared.log('error', `LLM-stream spawn error (${label}): ${err.message}`);
       resolve({

package/package.json

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