@yemi33/minions 0.1.1992 → 0.1.1993

package/dashboard/js/command-center.js

@@ -179,48 +179,130 @@ async function _ccDashboardHealth() {
   }
 }
 
+// Pure predicate — extracted so test/unit/dashboard-resilience.test.js can
+// behaviour-test the new-vs-old-instance decision without standing up a DOM.
+// Returns true only when newDashId is provably a NEW dashboard process:
+//   - When preRestartDashId is known, any difference proves a different process.
+//   - When preRestartDashId is unknown (page just loaded, _lastStatus empty),
+//     accept only if newDashId parses to a timestamp strictly AFTER the click.
+//     Guards against the still-alive OLD dashboard answering /api/status
+//     before its kill lands (~1s into the restart child's lifetime).
+function _ccIsNewDashboardInstance(preRestartDashId, newDashId, clickTimeMs) {
+  if (!newDashId) return false;
+  if (preRestartDashId) return newDashId !== preRestartDashId;
+  var parsed = Date.parse(newDashId);
+  return Number.isFinite(parsed) && parsed > clickTimeMs;
+}
+
 // Triggered by the CC "Restart Minions" recovery button when a stale dashboard
 // connection is killing CC streams with "Failed to fetch". Spawns the same
 // `minions restart` flow as the CLI command (kills + respawns engine AND
-// dashboard). Then polls /api/health until the new dashboard is online before
-// reloading — fixed timers either fired too early (reload hits dead port) or
-// fired after the fetch threw (dashboard killed mid-response → 500ms reload
-// to nothing).
+// dashboard) and reloads once the NEW dashboard is up.
+//
+// W-mpehvbed0018e27d: previous version polled /api/health which returns 200
+// from EITHER the still-alive OLD dashboard (before the spawned restart child
+// finished its kill sequence) OR the NEW one. Reloading on the OLD instance
+// landed the page on a dying port; reloading on the NEW instance with a cold
+// status cache hung the freshly-reloaded page on its first /api/status fetch.
+// Both produced the "click does nothing / page still broken" symptoms.
+//
+// Fix:
+//   1. Capture pre-restart dashboardStartedAt before POSTing the restart
+//      (so we can detect the NEW instance vs the still-alive OLD one).
+//   2. Poll /api/status (not /api/health) — a 200 response proves the status
+//      cache has been built once, so the post-reload first request is warm.
+//   3. Only reload when _ccIsNewDashboardInstance() confirms a different
+//      dashboardStartedAt, with per-poll AbortController so a hanging cold
+//      rebuild can't starve the global deadline.
+//   4. Cache-bust the reload (?cb=) so an updated dashboard JS bundle is not
+//      served from the browser disk cache. location.replace() so the broken
+//      pre-restart URL doesn't pollute history.
 async function ccRestartMinions(btn) {
   if (btn) { try { btn.disabled = true; btn.textContent = 'Restarting...'; } catch {} }
-  // Fire and forget the POST. We do NOT await it — the dashboard often kills
-  // its own process before the response is flushed, so the fetch throws even
-  // though the restart child is happily running. Whatever the POST does, the
-  // next step (wait-for-healthy) is the truth.
+  var clickTimeMs = Date.now();
+
+  // Capture pre-restart dashboard instance ID BEFORE the POST so the polling
+  // step has a baseline to compare against. _lastStatus is populated by
+  // refresh.js's 4s poll; on a freshly-opened page it may still be null, so
+  // we fall back to a bounded /api/status fetch, then to clickTime-based
+  // detection inside _ccIsNewDashboardInstance.
+  var preRestartDashId = (window._lastStatus && window._lastStatus.version)
+    ? window._lastStatus.version.dashboardStartedAt : null;
+  if (!preRestartDashId) {
+    try {
+      var preCtl = new AbortController();
+      var preTimer = setTimeout(function() { preCtl.abort(); }, 2000);
+      try {
+        var preRes = await fetch('/api/status', { cache: 'no-store', signal: preCtl.signal });
+        if (preRes && preRes.ok) {
+          var preData = await preRes.json().catch(function() { return null; });
+          if (preData && preData.version) preRestartDashId = preData.version.dashboardStartedAt || null;
+        }
+      } finally { clearTimeout(preTimer); }
+    } catch { /* best-effort — clickTime fallback inside helper still covers us */ }
+  }
+
+  // Fire-and-forget the restart POST. We do NOT await it — the dashboard often
+  // kills its own process before the response is flushed, so the fetch throws
+  // even though the restart child (a detached `minions restart`) is happily
+  // running. The polling loop is the source of truth for completion.
   try {
     fetch('/api/dashboard/restart', { method: 'POST', headers: { 'Content-Type': 'application/json' } })
       .catch(function() { /* dashboard process likely killed mid-response — expected */ });
   } catch { /* network layer threw before fetch even queued — also expected */ }
   if (btn) { try { btn.textContent = 'Restarting Minions — waiting for new dashboard...'; } catch {} }
+
   var startedAt = Date.now();
-  var DEADLINE_MS = 60000;
+  var DEADLINE_MS = 90000; // generous: cold Windows AV + status rebuild can eat 30s
   var INTERVAL_MS = 500;
-  function pollHealth() {
-    fetch('/api/health', { cache: 'no-store' }).then(function(res) {
-      if (res && res.ok) {
-        if (btn) { try { btn.textContent = 'Dashboard online — reloading...'; } catch {} }
-        try { location.reload(); } catch {}
-        return;
+  var POLL_TIMEOUT_MS = 5000;
+
+  function reloadWithCacheBust(label) {
+    if (btn) { try { btn.textContent = label; } catch {} }
+    try {
+      var url = new URL(location.href);
+      url.searchParams.set('cb', String(Date.now()));
+      location.replace(url.toString());
+    } catch {
+      try { location.reload(); } catch {}
+    }
+  }
+
+  async function pollStatus() {
+    var ctl = new AbortController();
+    var pollTimer = setTimeout(function() { ctl.abort(); }, POLL_TIMEOUT_MS);
+    var shouldRetry = false;
+    try {
+      var res = await fetch('/api/status', { cache: 'no-store', signal: ctl.signal });
+      if (!res || !res.ok) { shouldRetry = true; }
+      else {
+        var data = await res.json().catch(function() { return null; });
+        var newDashId = (data && data.version) ? data.version.dashboardStartedAt : null;
+        if (_ccIsNewDashboardInstance(preRestartDashId, newDashId, clickTimeMs)) {
+          reloadWithCacheBust('Dashboard online — reloading...');
+          return;
+        }
+        // Same instance (or unparseable) — old dashboard still answering or
+        // new dashboard ID hasn't advanced past clickTime yet. Keep polling.
+        shouldRetry = true;
       }
-      throw new Error('not ok');
-    }).catch(function() {
+    } catch { shouldRetry = true; }
+    finally { clearTimeout(pollTimer); }
+    if (shouldRetry) {
       if (Date.now() - startedAt > DEADLINE_MS) {
-        if (btn) { try { btn.textContent = 'Restart timed out — reloading...'; } catch {} }
-        try { location.reload(); } catch {}
+        // Last-ditch reload. refresh.js's auto-detection (4s poll on
+        // dashboardStartedAt change) will pick up the new instance once it
+        // does come up.
+        reloadWithCacheBust('Restart timed out — reloading anyway...');
         return;
       }
-      setTimeout(pollHealth, INTERVAL_MS);
-    });
+      setTimeout(pollStatus, INTERVAL_MS);
+    }
   }
-  // Don't poll immediately — give the restart child a moment to actually kill
-  // the old dashboard. If we polled at t=0 we'd hit the OLD (dying) dashboard
-  // and prematurely reload before the new one is up.
-  setTimeout(pollHealth, 2000);
+
+  // Give the restart child a moment to actually kill the old dashboard before
+  // we start polling. Polling at t=0 risks confirming the dying old instance.
+  setTimeout(pollStatus, 2000);
 }
 
 function _ccIsReconnectableStreamError(err) {

package/dashboard.js

@@ -9379,6 +9379,17 @@ if (require.main === module) {
       } catch { /* warm-up is best-effort */ }
     });
 
+    // Pre-warm /api/status cache (W-mpehvbed0018e27d). The CC "Restart Minions"
+    // recovery button polls /api/status and only reloads once the new dashboard
+    // reports a NEW dashboardStartedAt. Without warming, the first /api/status
+    // request (from the button OR from refresh.js OR from the post-reload page
+    // load) triggers a cold getStatus() rebuild that takes 2-5s on Windows+AV
+    // and stalls the freshly-reloaded page in a spinner. Warming on listen
+    // means the first request hits the cached buffer.
+    setImmediate(() => {
+      try { getStatusJson(); } catch { /* warm-up is best-effort */ }
+    });
+
     // ─── Engine Watchdog ─────────────────────────────────────────────────────
     // Every 30s, check if engine PID is alive. If dead but control.json says
     // running, auto-restart it. Prevents silent engine death.

package/package.json

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