@yemi33/minions 0.1.1824 → 0.1.1826

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1826 (2026-05-09)
+
+### Fixes
+- always open dashboard if no live tab reconnects after restart
+
+## 0.1.1825 (2026-05-09)
+
+### Fixes
+- isolate test artifacts under MINIONS_TEST_DIR + dashboard TEST badge
+
 ## 0.1.1824 (2026-05-09)
 
 ### Other

package/bin/minions.js

@@ -86,6 +86,43 @@ function hasRecentDashboardBrowserTab(minionsHome, now = Date.now()) {
   } catch { return false; }
 }
 
+// Clear the browser-presence cache. Pre-restart beacons can outlive the
+// browser window that produced them (closed Edge, locked-screen RDP session,
+// stale heuristic timer) and falsely tell `restart` to skip the auto-open. We
+// wipe it during restart so the post-restart probe only counts beacons that
+// arrive AFTER the new dashboard is up — i.e. from a still-living tab.
+function _clearDashboardBrowserState(minionsHome) {
+  try {
+    const fp = path.join(minionsHome, 'engine', 'dashboard-browser.json');
+    fs.writeFileSync(fp, JSON.stringify({ tabs: {}, updatedAt: new Date().toISOString() }));
+  } catch {}
+}
+
+async function _waitForBrowserReconnect(minionsHome, { afterMs, timeoutMs = 5000, pollMs = 500 } = {}) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const fp = path.join(minionsHome, 'engine', 'dashboard-browser.json');
+      const state = JSON.parse(fs.readFileSync(fp, 'utf8'));
+      const tabs = state && state.tabs ? Object.values(state.tabs) : [];
+      if (tabs.some(t => Number(t && t.lastSeen) > afterMs)) return true;
+    } catch { /* file may be temporarily missing during write */ }
+    await new Promise(r => setTimeout(r, pollMs));
+  }
+  return false;
+}
+
+function _openInBrowser(url) {
+  try {
+    if (process.platform === 'win32') execSync(`start "" "${url}"`, { stdio: 'ignore', windowsHide: true });
+    else if (process.platform === 'darwin') execSync(`open "${url}"`, { stdio: 'ignore' });
+    else execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
+  } catch (e) {
+    console.log(`  Could not auto-open browser: ${e.message}`);
+    console.log(`  Please open ${url} manually.`);
+  }
+}
+
 /**
  * Read the engine's recorded PID from engine/control.json. Returns null if
  * the file is missing/corrupt or the PID isn't a positive integer.
@@ -411,12 +448,12 @@ function init() {
   if (isUpgrade && skipStart) return;
 
   // Auto-start on fresh install; direct force-upgrade restarts automatically.
-  // Probe before kill so we suppress browser auto-open only when a browser tab
-  // was recently polling the dashboard. A bare/orphan dashboard process on the
-  // port is not enough; cold starts should still open the UI.
   const dashWasUp = isPortListening(DASH_PORT);
-  const suppressDashboardOpen = !forceOpen && dashWasUp && hasRecentDashboardBrowserTab(MINIONS_HOME);
+  const restartStartMs = Date.now();
   if (isUpgrade) {
+    // Clear stale beacons so the post-restart probe only counts tabs that
+    // reconnect to the NEW dashboard.
+    _clearDashboardBrowserState(MINIONS_HOME);
     try { execSync(`node "${path.join(MINIONS_HOME, 'engine.js')}" stop`, { stdio: 'ignore', cwd: MINIONS_HOME, timeout: 10000, windowsHide: true }); } catch {}
     // Free the dashboard port too — without this the new dashboard EADDRINUSE-dies
     // silently and the user keeps running stale code from the old dashboard process.
@@ -431,10 +468,28 @@ function init() {
   engineProc.unref();
   console.log(`  Engine started (PID: ${engineProc.pid})`);
 
-  const dashProc = spawnDashboard(suppressDashboardOpen);
+  // Always suppress dashboard's self-open — we decide here after the health
+  // check based on whether an existing browser tab actually reconnects.
+  const dashProc = spawnDashboard(true);
   console.log(`  Dashboard started (PID: ${dashProc.pid})`);
   console.log(`  Dashboard: http://localhost:${DASH_PORT}`);
 
+  void (async () => {
+    let shouldOpen = forceOpen || !dashWasUp;
+    if (!shouldOpen) {
+      // Hot upgrade: give an existing browser tab up to 5s to reconnect via
+      // its 4s auto-refresh poll. If nothing beacons, the tab is gone — open.
+      const reconnected = await _waitForBrowserReconnect(MINIONS_HOME, {
+        afterMs: restartStartMs, timeoutMs: 5000,
+      });
+      shouldOpen = !reconnected;
+    }
+    if (shouldOpen) {
+      console.log(`  Opening dashboard in browser...`);
+      _openInBrowser(`http://localhost:${DASH_PORT}`);
+    }
+  })();
+
   // Next steps guidance
   console.log(`
   Next steps:
@@ -689,11 +744,11 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
   // `--cli` / `--model` flags forward to `engine.js start` so the runtime
   // fleet flips before the daemon spawns (P-6b3f9c2e AC: works on restart).
   ensureInstalled();
-  // Probe before kill so we suppress browser auto-open only when a browser tab
-  // was recently polling the dashboard. A bare/orphan dashboard process on the
-  // port is not enough; cold starts should still open the UI.
   const dashWasUp = isPortListening(DASH_PORT);
-  const suppressDashboardOpen = !forceOpen && dashWasUp && hasRecentDashboardBrowserTab(MINIONS_HOME);
+  // Mark the restart boundary so post-restart beacon timestamps are unambiguous,
+  // and clear stale beacons (browsers that closed without notifying).
+  const restartStartMs = Date.now();
+  _clearDashboardBrowserState(MINIONS_HOME);
   // Layered kill — each step is best-effort, layered so the next still runs if
   // one fails. Goal: the old engine is gone before we spawn a new one, even if
   // PowerShell is unavailable, the engine is hung, or its cmdline doesn't match.
@@ -712,7 +767,9 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
   });
   engineProc.unref();
   console.log(`\n  Engine started (PID: ${engineProc.pid})`);
-  const dashProc = spawnDashboard(suppressDashboardOpen);
+  // Always tell the dashboard to skip its own auto-open — we'll decide here
+  // after observing whether an existing browser tab reconnects.
+  const dashProc = spawnDashboard(true);
   console.log(`  Dashboard started (PID: ${dashProc.pid})`);
   console.log(`  Dashboard: http://localhost:${DASH_PORT}`);
   console.log('  Verifying restart health...');
@@ -725,7 +782,20 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
       console.error(formatRestartHealthError(result));
       process.exit(1);
     }
-    console.log(`  Restart verified: engine PID ${result.engine.pid}; dashboard healthy.\n`);
+    console.log(`  Restart verified: engine PID ${result.engine.pid}; dashboard healthy.`);
+
+    let shouldOpen = forceOpen || !dashWasUp;
+    if (!shouldOpen) {
+      const reconnected = await _waitForBrowserReconnect(MINIONS_HOME, {
+        afterMs: restartStartMs, timeoutMs: 5000,
+      });
+      shouldOpen = !reconnected;
+    }
+    if (shouldOpen) {
+      console.log(`  Opening dashboard in browser...`);
+      _openInBrowser(`http://localhost:${DASH_PORT}`);
+    }
+    console.log('');
   })().catch(err => {
     console.error(`\n  ERROR: Restart verification failed: ${err.message}\n`);
     process.exit(1);

package/dashboard/styles.css

@@ -516,6 +516,12 @@
   .engine-badge.running { background: rgba(63,185,80,0.15); color: var(--green); border: 1px solid var(--green); }
   .engine-badge.paused { background: rgba(210,153,34,0.15); color: var(--yellow); border: 1px solid var(--yellow); }
   .engine-badge.stopped { background: rgba(248,81,73,0.15); color: var(--red); border: 1px solid var(--red); }
+  .test-mode-badge {
+    display: inline-block; margin-left: var(--space-6); padding: var(--space-1) var(--space-5);
+    background: var(--orange); color: #1a1a1a; font-size: var(--text-md); font-weight: 700;
+    letter-spacing: 0.5px; border-radius: var(--radius-sm); vertical-align: middle;
+  }
+  body.minions-test-mode > header { box-shadow: inset 0 -3px 0 var(--orange); }
   .engine-alert {
     display: none; margin: 8px 24px 0; padding: 8px 10px; border: 1px solid rgba(248,81,73,0.45);
     background: rgba(248,81,73,0.1); border-radius: var(--radius-sm); font-size: 11px; color: var(--text);

package/dashboard.js

@@ -805,9 +805,25 @@ function resolvePlanPath(file) {
   return active;
 }
 
-// Assemble dashboard HTML from fragments (canonical source: dashboard/)
+// Test-mode banner: surfaced in <title> + <h1> + body class when the dashboard
+// is started under MINIONS_TEST_DIR or on a non-default port. Makes it visually
+// obvious that the user is looking at a sandboxed instance, not their live
+// fleet — prevents acting on test fixtures by mistake.
+function _isTestMode() {
+  return !!process.env.MINIONS_TEST_DIR || (typeof PORT === 'number' && PORT !== 7331);
+}
+
+function _testBadgeLabel() {
+  if (process.env.MINIONS_TEST_DIR) return 'TEST';
+  if (typeof PORT === 'number' && PORT !== 7331) return `TEST :${PORT}`;
+  return '';
+}
+
+// Assemble dashboard HTML from fragments (canonical source: dashboard/).
+// Resolves dashboard/ relative to __dirname (the checkout root) so test
+// invocations under MINIONS_TEST_DIR still find the static layout/CSS/JS.
 function buildDashboardHtml() {
-  const dashDir = path.join(MINIONS_DIR, 'dashboard');
+  const dashDir = path.join(__dirname, 'dashboard');
   const layoutPath = path.join(dashDir, 'layout.html');
 
   if (!fs.existsSync(layoutPath)) {
@@ -854,10 +870,22 @@ function buildDashboardHtml() {
 
   const featuresBootstrap = `window.MINIONS_FEATURES = ${JSON.stringify(featuresBoot)};\n`;
 
-  return layout
+  let assembled = layout
     .replace('/* __CSS__ */', () => css)
     .replace('<!-- __PAGES__ -->', () => pageHtml)
     .replace('/* __JS__ */', () => `window.__MINIONS_HOME = ${JSON.stringify(os.homedir())};\n${featuresBootstrap}${jsHtml}`);
+
+  if (_isTestMode()) {
+    const label = _testBadgeLabel();
+    assembled = assembled
+      .replace('<title>Minions Mission Control</title>',
+        `<title>[${label}] Minions Mission Control</title>`)
+      .replace('<h1>Minions Mission Control</h1>',
+        `<h1>Minions Mission Control <span class="test-mode-badge">${label}</span></h1>`)
+      .replace('<body>',
+        '<body class="minions-test-mode">');
+  }
+  return assembled;
 }
 
 let HTML_RAW = buildDashboardHtml();

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-09T18:23:44.280Z"
+  "cachedAt": "2026-05-09T22:56:52.587Z"
 }

package/engine/runtimes/claude.js

@@ -28,10 +28,11 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { FAILURE_CLASS, safeWrite, ts } = require('../shared');
+const { FAILURE_CLASS, safeWrite, ts, resolveEngineCacheDir } = require('../shared');
 
 const ENGINE_DIR = __dirname.replace(/[\\/]runtimes$/, '');
 const MINIONS_DIR = path.resolve(ENGINE_DIR, '..');
+const _CACHE_DIR = resolveEngineCacheDir(ENGINE_DIR);
 
 const isWin = process.platform === 'win32';
 
@@ -40,7 +41,7 @@ const isWin = process.platform === 'win32';
 // repeated path-probe (PATH / npm-global / npm-root-g) only happens once per
 // install.
 
-const CAPS_FILE = path.join(ENGINE_DIR, 'claude-caps.json');
+const CAPS_FILE = path.join(_CACHE_DIR, 'claude-caps.json');
 
 function _safeJson(p) {
   try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
@@ -185,7 +186,7 @@ function listModels() {
   return null;
 }
 
-const MODELS_CACHE = path.join(ENGINE_DIR, 'claude-models.json');
+const MODELS_CACHE = path.join(_CACHE_DIR, 'claude-models.json');
 
 // ── Argument Construction ────────────────────────────────────────────────────
 

package/engine/runtimes/copilot.js

@@ -32,9 +32,10 @@ const https = require('https');
 const os = require('os');
 const path = require('path');
 const { execSync } = require('child_process');
-const { FAILURE_CLASS, safeWrite, ts } = require('../shared');
+const { FAILURE_CLASS, safeWrite, ts, resolveEngineCacheDir } = require('../shared');
 
 const ENGINE_DIR = __dirname.replace(/[\\/]runtimes$/, '');
+const _CACHE_DIR = resolveEngineCacheDir(ENGINE_DIR);
 const isWin = process.platform === 'win32';
 
 // ── Binary Resolution ───────────────────────────────────────────────────────
@@ -51,8 +52,8 @@ const isWin = process.platform === 'win32';
 // We deliberately do NOT npm-probe — Copilot is not an npm package. Doing so
 // would be confusing dead code that suggests an install path that doesn't exist.
 
-const CAPS_FILE = path.join(ENGINE_DIR, 'copilot-caps.json');
-const MODELS_CACHE = path.join(ENGINE_DIR, 'copilot-models.json');
+const CAPS_FILE = path.join(_CACHE_DIR, 'copilot-caps.json');
+const MODELS_CACHE = path.join(_CACHE_DIR, 'copilot-models.json');
 
 function _safeJson(p) {
   try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }

package/engine/shared.js

@@ -240,6 +240,17 @@ function _currentLogPath() {
   return path.join(root, 'engine', 'log.json');
 }
 
+// MINIONS_TEST_DIR-aware engine dir for cache files (runtime caps, models,
+// spawn-debug.log). Returns `<MINIONS_TEST_DIR>/engine` under tests; otherwise
+// the caller's source-adjacent fallback (typically `__dirname`-derived). Never
+// consults MINIONS_HOME — tests must not leak into the install root.
+function resolveEngineCacheDir(fallbackEngineDir) {
+  if (process.env.MINIONS_TEST_DIR) {
+    return path.join(path.resolve(process.env.MINIONS_TEST_DIR), 'engine');
+  }
+  return fallbackEngineDir;
+}
+
 function _flushLogBuffer() {
   if (_logBuffer.length === 0) return;
   const drained = _logBuffer.splice(0);
@@ -3368,6 +3379,7 @@ function createThrottleTracker({ label, baseBackoffMs = 60000, maxBackoffMs = 32
 module.exports = {
   MINIONS_DIR,
   ENGINE_DIR,
+  resolveEngineCacheDir,
   CONTROL_PATH,
   COOLDOWNS_PATH,
   PR_LINKS_PATH,

package/engine/spawn-agent.js

@@ -35,7 +35,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { runFile, cleanChildEnv, killGracefully, killImmediate, ts } = require('./shared');
+const { runFile, cleanChildEnv, killGracefully, killImmediate, ts, resolveEngineCacheDir } = require('./shared');
 const { resolveRuntime } = require('./runtimes');
 const { acquireAdoTokenSync, isLikelyAdoToken } = require('./ado-token');
 
@@ -321,8 +321,8 @@ function main() {
     opts, passthrough, addDirs,
   });
 
-  // Debug log (async — not on critical path)
-  const tmpDir = path.join(__dirname, 'tmp');
+  // Debug log (async — not on critical path).
+  const tmpDir = path.join(resolveEngineCacheDir(__dirname), 'tmp');
   if (!fs.existsSync(tmpDir)) fs.mkdirSync(tmpDir, { recursive: true });
   const debugPath = path.join(tmpDir, 'spawn-debug.log');
   fs.writeFile(

package/package.json

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