@yemi33/minions 0.1.1817 → 0.1.1819

package/CHANGELOG.md

@@ -1,15 +1,20 @@
 # Changelog
 
-## 0.1.1817 (2026-05-09)
+## 0.1.1819 (2026-05-09)
+
+### Fixes
+- stop visibility=hidden beacons from racing pagehide and resurrecting closed-tab entries in dashboard-browser.json (#2275)
+
+## 0.1.1818 (2026-05-09)
+
+### Fixes
+- write [process-exit] sentinel directly to live-output.log instead of bouncing it through stdout (#2266)
+
+## 0.1.1816 (2026-05-09)
 
 ### Features
-- suppress duplicate inline ask dispatch (#2256)
 - correlate CC action failures (#2254)
 
-### Other
-- test(shared): add unit tests for project resolution and path comparison helpers (#2268)
-- test(cli): add unit tests for pid/dispatch helpers and help formatter (#2267)
-
 ## 0.1.1815 (2026-05-09)
 
 ### Features

package/dashboard/js/state.js

@@ -127,7 +127,14 @@ function _sendDashboardPresence(closed) {
 
 window.addEventListener('pagehide', function() { _sendDashboardPresence(true); });
 window.addEventListener('beforeunload', function() { _sendDashboardPresence(true); });
-document.addEventListener('visibilitychange', function() { _sendDashboardPresence(false); });
+// Only ping on becoming visible — hidden->presence beacons race the pagehide close
+// beacon (both fire on tab close in quick succession via sendBeacon, ordering not
+// guaranteed) and can resurrect a just-deleted entry with visibility:"hidden".
+// Hidden tabs naturally expire via the 45s presence window; foreground returns
+// re-fire visibilitychange so we still get a fresh heartbeat when the user comes back.
+document.addEventListener('visibilitychange', function() {
+  if (document.visibilityState === 'visible') _sendDashboardPresence(false);
+});
 
 function rerenderPrdFromCache() {
   if (!window._lastStatus || !window._lastStatus.prdProgress) return;

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-09T15:29:07.860Z"
+  "cachedAt": "2026-05-09T17:41:50.994Z"
 }

package/engine/spawn-agent.js

@@ -158,55 +158,32 @@ function injectAdoTokenEnvForRepoHost(env, opts) {
   return injectAdoTokenEnv(env, opts);
 }
 
-const PROCESS_EXIT_SENTINEL_FLUSH_TIMEOUT_MS = 2000;
-
 function formatProcessExitSentinel(exitCode, signal) {
   return `\n[process-exit] code=${exitCode}${signal ? ` signal=${signal}` : ''}\n`;
 }
 
-function _appendSentinelFallback(outputPath, sentinel) {
-  if (!outputPath) return false;
-  try {
-    fs.appendFileSync(outputPath, sentinel);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function _writeStdoutWithTimeout(stdout, sentinel, timeoutMs) {
-  return new Promise((resolve) => {
-    let settled = false;
-    const finish = (flushed) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(flushed);
-    };
-    const timer = setTimeout(() => finish(false), Math.max(0, timeoutMs));
-    try {
-      if (!stdout || typeof stdout.write !== 'function') {
-        finish(false);
-        return;
-      }
-      stdout.write(sentinel, () => finish(true));
-    } catch {
-      finish(false);
-    }
-  });
-}
-
-async function writeProcessExitSentinel({
+// The orphan reaper recovers an agent's exit code by scanning live-output.log for
+// `[process-exit] code=N`. The previous design wrote the sentinel to stdout, hoping
+// the engine's stdout consumer (engine.js) would copy it into the file — but when
+// the engine was force-killed during a restart on Windows, the broken pipe
+// silently swallowed the sentinel and the recovery never happened (see #2265 for
+// the read-side recovery; this is the upstream fix). The orphan reaper only reads
+// the file, so the simplest correct thing is to write the file directly. No
+// stdout, no timeouts, no callbacks — one synchronous append.
+function writeProcessExitSentinel({
   exitCode,
   signal = null,
-  stdout = process.stdout,
   outputPath = process.env.MINIONS_LIVE_OUTPUT_PATH,
-  timeoutMs = PROCESS_EXIT_SENTINEL_FLUSH_TIMEOUT_MS,
 } = {}) {
   const sentinel = formatProcessExitSentinel(exitCode, signal);
-  const stdoutFlushed = await _writeStdoutWithTimeout(stdout, sentinel, timeoutMs);
-  const outputPathWritten = stdoutFlushed ? false : _appendSentinelFallback(outputPath, sentinel);
-  return { sentinel, stdoutFlushed, outputPathWritten };
+  let fileWritten = false;
+  if (outputPath) {
+    try {
+      fs.appendFileSync(outputPath, sentinel);
+      fileWritten = true;
+    } catch { /* file unavailable; orphan reaper falls back to runtime result event (#2265) */ }
+  }
+  return { sentinel, fileWritten };
 }
 
 function _appendOutputFallback(outputPath, chunk, prefix = '') {
@@ -432,19 +409,19 @@ function main() {
   }, MCP_STARTUP_TIMEOUT);
   proc.stdout.once('data', () => { gotFirstOutput = true; clearTimeout(startupTimer); });
 
-  proc.on('close', async (code, signal) => {
+  proc.on('close', (code, signal) => {
     clearTimeout(startupTimer);
     const exitCode = normalizeRuntimeExit(code, signal);
-    const sentinelResult = await writeProcessExitSentinel({ exitCode, signal });
+    const sentinelResult = writeProcessExitSentinel({ exitCode, signal });
     fs.appendFileSync(debugPath, `EXIT: code=${exitCode}${signal ? ` signal=${signal}` : ''}\nSTDERR: ${stderrBuf.slice(0, 500)}\n`);
-    if (!sentinelResult.stdoutFlushed && sentinelResult.outputPathWritten) {
-      fs.appendFileSync(debugPath, `EXIT SENTINEL FALLBACK: ${process.env.MINIONS_LIVE_OUTPUT_PATH}\n`);
+    if (!sentinelResult.fileWritten) {
+      fs.appendFileSync(debugPath, `EXIT SENTINEL: file write failed for ${process.env.MINIONS_LIVE_OUTPUT_PATH}\n`);
     }
     process.exit(exitCode);
   });
-  proc.on('error', async (err) => {
+  proc.on('error', (err) => {
     fs.appendFileSync(debugPath, `ERROR: ${err.message}\n`);
-    await writeProcessExitSentinel({ exitCode: 1 });
+    writeProcessExitSentinel({ exitCode: 1 });
     process.exit(1);
   });
 }

package/package.json

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