@yemi33/minions 0.1.2386 → 0.1.2388

package/dashboard.js

@@ -3570,18 +3570,23 @@ function _getCcLiveStream(tabId) {
 function _touchCcLiveStream(state) {
   if (!state) return;
   state.updatedAt = Date.now();
-  // W-mpmwxni2000c25c7-b — every CC streaming progress event (onChunk,
-  // onToolUse, onToolUpdate in both _invokeCcStream paths) already routes
-  // through here for the stall detector. Piggy-back the per-turn watchdog's
-  // bumpTimer on the same heartbeat so a turn that's actively streaming
-  // tokens or running long tools can't be killed by stale inactivity. The
-  // watchdog installs `_bumpTimer` for the duration of the turn and removes
-  // it in `finally`, so late progress callbacks delivered after resolution
-  // are a no-op.
+  // W-mpmwxni2000c25c7-b — every CC streaming progress event routes through
+  // here for the stall detector. The direct path also reports startup and
+  // reasoning events through callLLMStreaming.onProgress, while the pool path
+  // reports chunks and tools. Piggy-back the per-turn watchdog's bumpTimer on
+  // the same heartbeat so active work cannot be killed by stale inactivity.
+  // The watchdog removes `_bumpTimer` in `finally`, so late callbacks are no-op.
   if (typeof state._bumpTimer === 'function') {
     try { state._bumpTimer(); } catch { /* swallow */ }
   }
 }
+function _resolveCcDirectStreamSessionId({ sessionId, hasImages, useWorkerPool }) {
+  // ACP session IDs belong to the live worker process. A one-off image CLI
+  // cannot resume that session while the worker owns it, so rely on the
+  // transcript carryover already included in the direct prompt.
+  if (hasImages && useWorkerPool) return null;
+  return sessionId || null;
+}
 function _clearCcLiveTimers(tabId) {
   const state = _getCcLiveStream(tabId);
   if (!state) return;
@@ -9804,9 +9809,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     // already-working --attachment path below, while image-less turns keep
     // using the fast warm pool.
     const hasImages = Array.isArray(images) && images.length > 0;
-    if (!hasImages && shared.resolveCcUseWorkerPool(engineConfig)) {
+    const useWorkerPool = shared.resolveCcUseWorkerPool(engineConfig);
+    if (!hasImages && useWorkerPool) {
       return _invokeCcStreamViaPool({ prompt, liveState, toolUses, model, effort, engineConfig, systemPrompt, tabId });
     }
+    const directSessionId = _resolveCcDirectStreamSessionId({ sessionId, hasImages, useWorkerPool });
     const setStatus = (message) => {
       liveState.statusMessage = message;
       if (liveState.writer) liveState.writer({ type: 'status', message });
@@ -9819,10 +9826,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     return callLLMStreaming(prompt, systemPrompt, {
       timeout: CC_CALL_TIMEOUT_MS, label: 'command-center', model, maxTurns,
       allowedTools: 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch',
-      sessionId, effort, direct: true,
+      sessionId: directSessionId, effort, direct: true,
       engineConfig, images,
+      onProgress: () => _touchCcLiveStream(liveState),
       onChunk: (text, segmentId) => {
-        _touchCcLiveStream(liveState);
         if (liveState.statusMessage) {
           setStatus('');
         }
@@ -9830,7 +9837,6 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         if (liveState.writer) liveState.writer({ type: 'chunk', text, segmentId });
       },
       onToolUse: (name, input, id) => {
-        _touchCcLiveStream(liveState);
         if (liveState.statusMessage) {
           setStatus('');
         }
@@ -9842,7 +9848,6 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(input), id: id || null });
       },
       onToolUpdate: (id, status) => {
-        _touchCcLiveStream(liveState);
         // toolUses and liveState.tools share entry references — patch once so a
         // reconnect replays the resolved (green/red) state, not just pending.
         const entry = toolUses.find((e) => e && e.id === id);
@@ -10476,13 +10481,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           timeoutMs: turnTimeoutMs, label: 'command-center-stream',
         }, async (registerAbort, bumpTimer) => {
           // W-mpmwxni2000c25c7-b — no-progress semantics: install bumpTimer
-          // on liveState so _touchCcLiveStream (called from every onChunk /
-          // onToolUse / onToolUpdate in both _invokeCcStream paths) resets
-          // the watchdog on every liveness signal. A turn that's actively
-          // streaming tokens or running long tools survives indefinitely
-          // up to the outer CC_CALL_TIMEOUT_MS ceiling. Cleared in
-          // `finally` so a late progress event after resolution can't
-          // re-arm against a stale abort target.
+          // on liveState so _touchCcLiveStream resets the watchdog on every
+          // liveness signal. Direct calls include runtime startup/reasoning
+          // events; pool calls include chunks and tool updates. A productive
+          // turn survives up to the outer CC_CALL_TIMEOUT_MS ceiling. Cleared
+          // in `finally` so late progress cannot re-arm a stale abort target.
           liveState._bumpTimer = bumpTimer;
           try {
           const llmPromise = _invokeCcStream({
@@ -14814,6 +14817,7 @@ module.exports = {
   _ccRuntimeNeedsResumeCarryover,
   _ccRuntimeNeedsResumeBookkeepingGuard,
   _joinCcPromptParts,
+  _resolveCcDirectStreamSessionId, // exported for testing
   _captureApiRoutesMeta,
   _resetPublicApiRoutesCacheForTest,
   _formatCcApiRoutesIndex,

package/docs/command-center.md

@@ -70,7 +70,7 @@ Any violation rejects the **whole turn** with a typed error envelope (`code: 'in
 
 **Worker-pool interaction (W-mray463s001zcee2).** The opt-in Copilot ACP worker pool (`engine.ccUseWorkerPool: true`, default ON for Copilot CC) is a **separate protocol path** from the table above — `engine/cc-worker-pool.js`'s `session/prompt` call only ever sends a single text content block (`[{ type: 'text', text: prompt }]`) and has no image/attachment content-block support today. This used to mean image turns were silently dropped whenever the pool was active, with a comment incorrectly blaming a Copilot capability gap (`imageInput:false`) that doesn't exist — Copilot's `imageInput` is `true` and fully supports images on the direct spawn path. The fix: `_invokeCcStream` (dashboard.js) now checks for a non-empty `images` array **before** routing through `resolveCcUseWorkerPool` — image-bearing turns bypass the warm pool for that turn only and cold-spawn a one-off CLI process via the working `--attachment` path (same as the non-pooled path always used), while image-less turns keep using the fast warm pool. If `engine/cc-worker-pool.js`'s ACP session protocol is later extended to carry attachments (Option A), this per-turn bypass in `_invokeCcStream` should be revisited/removed.
 
-Because that bypass can spend tens of seconds starting a one-off process before the first model token, the SSE stream shows a user-focused “Looking at the image…” status instead of exposing the cold-start implementation detail or leaving an apparently stalled spinner.
+Because that bypass can spend tens of seconds starting a one-off process before the first model token, the SSE stream shows a user-focused “Looking at the image…” status instead of exposing the cold-start implementation detail or leaving an apparently stalled spinner. The one-off process does not resume the live worker's process-scoped ACP session ID: it starts a transport-compatible fresh session and receives prior conversation context through the existing transcript carryover. Every parsed direct-runtime event, including startup and reasoning events, resets the five-minute silence watchdog; the safety bound therefore still catches a truly silent process without killing an image turn that is making progress.
 
 `_resolveImageOpts` (in `engine/llm.js`) is pure and unit-tested: it forwards the `images` list only when `runtime.capabilities.imageInput` is truthy, otherwise returns the typed error so CC/doc-chat surface the envelope instead of a silently-text-only reply. `_spawnProcess` re-applies the same gate (`if (!caps.imageInput) adapterOpts.images = undefined`) as defense in depth. Image **filenames** are run through the untrusted-input fence (`buildSource('cc-image-filename', …)`) before they reach prompt text, since they are user-supplied.
 

package/engine/llm.js

@@ -482,6 +482,7 @@ function _createStreamAccumulator({
   onTaskComplete = null,
   onTerminalResult = null,
   onThinking = null,
+  onProgress = null,
 }) {
   if (!runtime?.capabilities?.streamConsumer || typeof runtime.createStreamConsumer !== 'function') {
     throw new Error(`runtime ${runtime?.name || '<unknown>'} missing createStreamConsumer (capabilities.streamConsumer)`);
@@ -600,6 +601,11 @@ function _createStreamAccumulator({
   };
 
   const consumer = runtime.createStreamConsumer(ctx);
+  function consumeEvent(ev) {
+    if (!ev) return;
+    if (onProgress) onProgress(ev);
+    consumer.consume(ev);
+  }
 
   function ingestStdout(chunk) {
     const str = chunk == null ? '' : chunk.toString();
@@ -608,8 +614,7 @@ function _createStreamAccumulator({
     const lines = lineBuf.split('\n');
     lineBuf = lines.pop() || '';
     for (const line of lines) {
-      const ev = runtime.parseStreamChunk(line);
-      if (ev) consumer.consume(ev);
+      consumeEvent(runtime.parseStreamChunk(line));
     }
   }
 
@@ -619,10 +624,7 @@ function _createStreamAccumulator({
 
   function finalize() {
     const trimmed = lineBuf.trim();
-    if (trimmed) {
-      const ev = runtime.parseStreamChunk(trimmed);
-      if (ev) consumer.consume(ev);
-    }
+    if (trimmed) consumeEvent(runtime.parseStreamChunk(trimmed));
     if (!text && lastTaskCompleteSummary) text = lastTaskCompleteSummary;
     // Reconciliation: always let the runtime adapter re-parse the complete
     // stdout. Stream consumers emit live progress, but parseOutput() owns the
@@ -851,11 +853,14 @@ function callLLM(promptText, sysPromptText, opts = {}) {
  * onChunk(text, segmentIndex) is called for each assistant text block as it
  * arrives; segmentIndex increments across distinct text blocks so consumers can
  * keep them visually separate instead of welding them together.
+ * onProgress(event) is called for every parsed runtime event, including startup
+ * and reasoning events that do not produce a text or tool callback.
  */
 function callLLMStreaming(promptText, sysPromptText, opts = {}) {
   const {
     timeout = 120000, label = 'llm', maxTurns = 1, allowedTools = '',
     sessionId = null, onChunk = () => {}, onToolUse = null, onToolUpdate = null,
+    onProgress = null,
     effort = null, direct = false,
     model: modelOverride, cli: cliOverride, engineConfig,
     maxBudget, bare, fallbackModel,
@@ -903,6 +908,7 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
       // 'exit'/'close' when an inherited pipe keeps the parent's FDs open.
       onTerminalResult: () => scheduleExitFallback(exitCode != null ? exitCode : 0),
       onThinking: opts.onThinking || null,
+      onProgress,
     });
 
     _abort = () => { shared.killImmediate(proc); };

package/engine/supervisor.js

@@ -507,7 +507,39 @@ function _isRespawnEligibleEngineState(state) {
   return state === 'running' || state === 'degraded';
 }
 
-function checkEngine(now) {
+const ENGINE_WATCHDOG_OPERATION_NAMES = [
+  'isPidAlive',
+  'reapStrayProcesses',
+  'spawnEngine',
+  'recordCrashLoopRespawn',
+];
+
+// Isolated state does not isolate this module's source checkout, so tests must
+// provide every OS/process side effect before an engine respawn is possible.
+function _resolveEngineWatchdogOperations(injected) {
+  const provided = injected && typeof injected === 'object' ? injected : {};
+  if (process.env.MINIONS_TEST_DIR) {
+    const missing = ENGINE_WATCHDOG_OPERATION_NAMES
+      .filter(name => typeof provided[name] !== 'function');
+    if (missing.length > 0) {
+      throw new Error(
+        `MINIONS_TEST_DIR is set; inject engine watchdog operations instead of using real process control: ${missing.join(', ')}`,
+      );
+    }
+  }
+  return {
+    isPidAlive: typeof provided.isPidAlive === 'function' ? provided.isPidAlive : isPidAlive,
+    reapStrayProcesses: typeof provided.reapStrayProcesses === 'function'
+      ? provided.reapStrayProcesses
+      : reapStrayProcesses,
+    spawnEngine: typeof provided.spawnEngine === 'function' ? provided.spawnEngine : spawnEngine,
+    recordCrashLoopRespawn: typeof provided.recordCrashLoopRespawn === 'function'
+      ? provided.recordCrashLoopRespawn
+      : _recordCrashLoopRespawn,
+  };
+}
+
+function checkEngine(now, operations) {
   if (now - _lastEngineRespawnAt < POST_SPAWN_GRACE_MS) return;
   const control = safeReadJson(CONTROL_PATH_FN());
   // Respawn when control.json says "running" (PID died unexpectedly) or
@@ -515,7 +547,6 @@ function checkEngine(now) {
   // above). "paused"/"stopped"/"stopping" are legitimate user-intent states the
   // supervisor must not override.
   if (!control || !_isRespawnEligibleEngineState(control.state)) return;
-  if (control.pid && isPidAlive(control.pid)) return;
 
   // Cross-watchdog race guard: dashboard.js's in-process engine watchdog
   // writes `{pid: null, restarted_at}` BEFORE spawning a new engine. During
@@ -530,13 +561,16 @@ function checkEngine(now) {
     }
   }
 
+  const ops = _resolveEngineWatchdogOperations(operations);
+  if (control.pid && ops.isPidAlive(control.pid)) return;
+
   console.log(`[supervisor] Engine PID ${control.pid || '(none)'} is dead — respawning...`);
   // Reap any orphan engines first so a stale control.json PID can't snowball
   // into an unbounded pile of contending engine processes.
-  reapStrayProcesses(path.join(MINIONS_DIR, 'engine.js'), 'engine');
-  const newPid = spawnEngine();
+  ops.reapStrayProcesses(path.join(MINIONS_DIR, 'engine.js'), 'engine');
+  const newPid = ops.spawnEngine();
   _lastEngineRespawnAt = now;
-  _recordCrashLoopRespawn('supervisor:dead-pid');
+  ops.recordCrashLoopRespawn('supervisor:dead-pid');
   console.log(`[supervisor] Engine respawned (new PID: ${newPid})`);
 }
 
@@ -546,7 +580,7 @@ function checkEngine(now) {
 // is alive but control.heartbeat has not advanced for SUPERVISOR_STALE_ENGINE_HEARTBEAT_MS.
 // The heartbeat is written every ~15s by a dedicated timer in engine/cli.js; if
 // it goes stale while the PID persists, the event loop is stuck.
-function checkEngineHung(now) {
+function checkEngineHung(now, operations) {
   if (now - _lastEngineRespawnAt < POST_SPAWN_GRACE_MS) return;
   const control = safeReadJson(CONTROL_PATH_FN());
   // Include 'degraded' (see _isRespawnEligibleEngineState) so a permanently
@@ -554,8 +588,6 @@ function checkEngineHung(now) {
   // re-enters) still gets force-restarted once its own heartbeat goes stale,
   // instead of being ignored forever the moment the state flips to 'degraded'.
   if (!control || !_isRespawnEligibleEngineState(control.state)) return;
-  // Only acts when the PID is alive — a dead PID is handled by checkEngine().
-  if (!control.pid || !isPidAlive(control.pid)) return;
 
   const heartbeat = Number(control.heartbeat);
   if (!heartbeat || !Number.isFinite(heartbeat)) return; // no heartbeat yet (fresh start)
@@ -563,15 +595,20 @@ function checkEngineHung(now) {
   const heartbeatAge = now - heartbeat;
   if (heartbeatAge < SUPERVISOR_STALE_ENGINE_HEARTBEAT_MS) return;
 
+  // Only acts when the PID is alive — a dead PID is handled by checkEngine().
+  if (!control.pid) return;
+  const ops = _resolveEngineWatchdogOperations(operations);
+  if (!ops.isPidAlive(control.pid)) return;
+
   console.log(
     `[supervisor] Engine PID ${control.pid} is alive but heartbeat is stale ` +
     `(${Math.round(heartbeatAge / 1000)}s old, threshold ${SUPERVISOR_STALE_ENGINE_HEARTBEAT_MS / 1000}s) — ` +
     `event loop likely frozen; restarting engine`,
   );
-  reapStrayProcesses(path.join(MINIONS_DIR, 'engine.js'), 'engine');
-  const newPid = spawnEngine();
+  ops.reapStrayProcesses(path.join(MINIONS_DIR, 'engine.js'), 'engine');
+  const newPid = ops.spawnEngine();
   _lastEngineRespawnAt = now;
-  _recordCrashLoopRespawn('supervisor:stale-heartbeat');
+  ops.recordCrashLoopRespawn('supervisor:stale-heartbeat');
   console.log(`[supervisor] Engine restarted due to stale heartbeat (new PID: ${newPid})`);
 }
 

package/package.json

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