@yemi33/minions 0.1.1972 → 0.1.1973

package/engine/cli.js

@@ -521,7 +521,14 @@ const commands = {
             const savedBranch = normalizeSessionBranch(sj?.branch);
             if (sj?.sessionId && (!expectedBranch || savedBranch === expectedBranch)) {
               sessionId = sj.sessionId;
-            } else if (sj?.sessionId && expectedBranch) {
+            } else if (sj?.sessionId && expectedBranch && sj?.dispatchId === item.id) {
+              // Only warn when the saved session is for THIS dispatch but on the
+              // wrong branch — that's a true anomaly worth flagging. The common
+              // case — leftover session.json from a previous (now-completed)
+              // dispatch on a different branch — is expected and silent, since
+              // the engine writes session.json on completion of each dispatch
+              // and a fresh dispatch may run on a different branch before
+              // saveSession overwrites it (W-mpbn93ou000611b3).
               shared.log('warn', `Reattach: ignoring session for ${agentId} on branch ${savedBranch || 'unknown'}; expected ${expectedBranch}`);
             }
           } catch {}

package/engine/spawn-agent.js

@@ -529,9 +529,44 @@ function main() {
     clearTimeout(startupTimer);
     clearTimeout(initialSnapshotTimer);
     clearInterval(descTimer);
+
+    // Compute the exit code and write the [process-exit] sentinel FIRST,
+    // before the descendant snapshot/reap. The engine's orphan reaper uses
+    // the sentinel as the single signal that "the runtime exited cleanly
+    // with code N"; if we delay it behind `snapshotDescendants()` (which
+    // shells out to `Get-CimInstance` on Windows and can block 1-5+s),
+    // there's a window where the runtime PID we track is already dead but
+    // no sentinel exists yet. After an engine restart that path triggers
+    // `canReapDeadProcess` and the dispatch gets auto-retried as orphaned
+    // even though it completed normally. See W-mpbn93ou000611b3 / the
+    // 2026-05-18 ripley-explore regression.
+    //
+    // Prefer the 'exit' event's code/signal when present (Node's 'close'
+    // event can report code=0 on Windows when the OS-level exit was
+    // non-zero — see the long-form note above the exit handler).
+    const effectiveCode = (realExitFromEvent != null) ? realExitFromEvent : code;
+    const effectiveSignal = realSignalFromEvent || signal;
+    const exitCode = normalizeRuntimeExit(effectiveCode, effectiveSignal);
+    if (sentinelWritten) {
+      // Defense-in-depth: never write a duplicate sentinel. We observed pairs
+      // of [process-exit] code=0 lines in live-output.log across many failed
+      // runs, which suggests close has fired twice in some edge cases (e.g.,
+      // shim re-launch on Windows). One sentinel per spawn is the contract.
+      // Skip descendant reap on the duplicate close too — the first close
+      // already handled it (reaping the same PIDs again is a no-op at best,
+      // but skipping is faster and matches the prior early-return contract).
+      fs.appendFileSync(debugPath, `EXIT (duplicate close, skipping sentinel): code=${exitCode}${effectiveSignal ? ` signal=${effectiveSignal}` : ''}\n`);
+      process.exit(exitCode);
+      return;
+    }
+    sentinelWritten = true;
+    const sentinelResult = writeProcessExitSentinel({ exitCode, signal: effectiveSignal });
+
     // Final snapshot + reap, but only when the runtime actually spawned
     // children. Read-only / very short agents (exit before the 3s initial
-    // snapshot fires) skip the wmic shell-out entirely.
+    // snapshot fires) skip the wmic shell-out entirely. Runs AFTER the
+    // sentinel write so a slow Get-CimInstance call can't gate completion
+    // detection — see the hoist note above.
     if (trackedDescendants.size || gotFirstOutput) {
       snapshotDescendants();
       if (trackedDescendants.size) {
@@ -580,21 +615,6 @@ function main() {
         try { fs.appendFileSync(debugPath, `DESCENDANTS reaped=${reaped}/${toKillPids.length} kept=${kept.length}\n`); } catch {}
       }
     }
-    // Prefer the 'exit' event's code/signal when present — see note above.
-    const effectiveCode = (realExitFromEvent != null) ? realExitFromEvent : code;
-    const effectiveSignal = realSignalFromEvent || signal;
-    const exitCode = normalizeRuntimeExit(effectiveCode, effectiveSignal);
-    if (sentinelWritten) {
-      // Defense-in-depth: never write a duplicate sentinel. We observed pairs
-      // of [process-exit] code=0 lines in live-output.log across many failed
-      // runs, which suggests close has fired twice in some edge cases (e.g.,
-      // shim re-launch on Windows). One sentinel per spawn is the contract.
-      fs.appendFileSync(debugPath, `EXIT (duplicate close, skipping sentinel): code=${exitCode}${effectiveSignal ? ` signal=${effectiveSignal}` : ''}\n`);
-      process.exit(exitCode);
-      return;
-    }
-    sentinelWritten = true;
-    const sentinelResult = writeProcessExitSentinel({ exitCode, signal: effectiveSignal });
     fs.appendFileSync(debugPath, `EXIT: code=${exitCode}${effectiveSignal ? ` signal=${effectiveSignal}` : ''} (close=${code} exit=${realExitFromEvent})\nSTDERR: ${stderrBuf.slice(0, 500)}\n`);
     if (!sentinelResult.fileWritten) {
       fs.appendFileSync(debugPath, `EXIT SENTINEL: file write failed for ${process.env.MINIONS_LIVE_OUTPUT_PATH}\n`);

package/package.json

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