@yemi33/minions 0.1.1814 → 0.1.1816

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1816 (2026-05-09)
+
+### Features
+- correlate CC action failures (#2254)
+
+## 0.1.1815 (2026-05-09)
+
+### Features
+- verify restart health (#2258)
+
 ## 0.1.1814 (2026-05-09)
 
 ### Features

package/bin/minions.js

@@ -40,6 +40,7 @@ const { spawn, spawnSync, execSync } = require('child_process');
 
 const PKG_ROOT = path.resolve(__dirname, '..');
 const shared = require(path.join(PKG_ROOT, 'engine', 'shared'));
+const { waitForRestartHealth, formatRestartHealthError } = require(path.join(PKG_ROOT, 'engine', 'restart-health'));
 const DASH_PORT = 7331;
 const DASHBOARD_BROWSER_PRESENCE_MAX_AGE_MS = 45000;
 
@@ -708,7 +709,22 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
   console.log(`\n  Engine started (PID: ${engineProc.pid})`);
   const dashProc = spawnDashboard(suppressDashboardOpen);
   console.log(`  Dashboard started (PID: ${dashProc.pid})`);
-  console.log(`  Dashboard: http://localhost:${DASH_PORT}\n`);
+  console.log(`  Dashboard: http://localhost:${DASH_PORT}`);
+  console.log('  Verifying restart health...');
+  void (async () => {
+    const result = await waitForRestartHealth({
+      minionsHome: MINIONS_HOME,
+      dashboardUrl: `http://127.0.0.1:${DASH_PORT}/api/health`,
+    });
+    if (!result.ok) {
+      console.error(formatRestartHealthError(result));
+      process.exit(1);
+    }
+    console.log(`  Restart verified: engine PID ${result.engine.pid}; dashboard healthy.\n`);
+  })().catch(err => {
+    console.error(`\n  ERROR: Restart verification failed: ${err.message}\n`);
+    process.exit(1);
+  });
 } else if (cmd === 'nuke') {
   ensureInstalled();
   if (!rest.includes('--confirm')) {

package/dashboard/js/command-center.js

@@ -826,11 +826,15 @@ async function _ccDoSend(message, skipUserMsg, forceTabId, intentMetadata) {
             var failures = evt.actionResults.filter(function(r) { return r && r.error; });
             var warnings = evt.actionResults.filter(function(r) { return r && r.warning; });
             if (failures.length > 0) {
-              var failHtml = failures.map(function(r) { return '<li>' + escHtml(r.type || 'action') + ': ' + escHtml(r.error) + '</li>'; }).join('');
+              var failHtml = failures.map(function(r) {
+                return '<li>' + escHtml(r.type || (r.actionContext && r.actionContext.type) || 'action') + ': ' + escHtml(r.error) + _ccActionContextSuffix(r.actionContext) + '</li>';
+              }).join('');
               addMsg('system', '<div style="padding:6px 12px;font-size:11px;color:var(--red);background:var(--surface2);border-radius:6px;margin:4px 0">⚠️ ' + failures.length + ' action' + (failures.length > 1 ? 's' : '') + ' failed:<ul style="margin:4px 0 0 16px;padding:0">' + failHtml + '</ul></div>', false, activeTabId);
             }
             if (warnings.length > 0) {
-              var warnHtml = warnings.map(function(r) { return '<li>' + escHtml(r.type || 'action') + ': ' + escHtml(r.warning) + '</li>'; }).join('');
+              var warnHtml = warnings.map(function(r) {
+                return '<li>' + escHtml(r.type || (r.actionContext && r.actionContext.type) || 'action') + ': ' + escHtml(r.warning) + _ccActionContextSuffix(r.actionContext) + '</li>';
+              }).join('');
               addMsg('system', '<div style="padding:6px 12px;font-size:11px;color:var(--orange);background:var(--surface2);border-radius:6px;margin:4px 0">ℹ️ ' + warnings.length + ' action' + (warnings.length > 1 ? '' : '') + ' completed with warnings:<ul style="margin:4px 0 0 16px;padding:0">' + warnHtml + '</ul></div>', false, activeTabId);
             }
           }
@@ -1012,6 +1016,28 @@ async function _ccFetch(url, body, method) {
   return res;
 }
 
+var CC_ACTION_CONTEXT_STALE_MS = 2 * 60 * 1000;
+function _ccActionContextIsStale(ctx, nowMs) {
+  if (!ctx || !ctx.requestedAt) return false;
+  var ts = Date.parse(ctx.requestedAt);
+  if (!Number.isFinite(ts)) return false;
+  var now = Number.isFinite(nowMs) ? nowMs : Date.now();
+  return now - ts > CC_ACTION_CONTEXT_STALE_MS;
+}
+
+function _ccActionContextSuffix(ctx, nowMs) {
+  if (!ctx || typeof ctx !== 'object') return '';
+  var parts = [];
+  if (ctx.title) parts.push('action "' + escHtml(ctx.title) + '"');
+  if (ctx.request) parts.push('request "' + escHtml(ctx.request) + '"');
+  if (ctx.requestedAt) parts.push('started ' + escHtml(ctx.requestedAt));
+  if (parts.length === 0) return '';
+  var stale = _ccActionContextIsStale(ctx, nowMs)
+    ? ' <strong style="color:var(--orange)">possibly stale</strong>'
+    : '';
+  return '<div style="font-size:10px;color:var(--muted);margin-top:2px">Context: ' + parts.join(' | ') + stale + '</div>';
+}
+
 // Tag actions that the server already executed so ccExecuteAction skips the API call
 function _tagServerExecuted(actions, actionResults) {
   if (!actionResults || !Array.isArray(actionResults)) return;
@@ -1022,10 +1048,12 @@ function _tagServerExecuted(actions, actionResults) {
       if (r.id) actions[i]._serverId = r.id;
       if (r.warning) actions[i]._serverWarning = r.warning;
       if (r.duplicate) actions[i]._serverDuplicate = true;
+      if (r.actionContext) actions[i]._serverContext = r.actionContext;
       if (r.reusedFromAction !== undefined) actions[i]._serverHidden = true;
     } else if (r && r.error) {
       actions[i]._serverExecuted = true;
       actions[i]._serverError = r.error;
+      if (r.actionContext) actions[i]._serverContext = r.actionContext;
     }
     // clientExecuted: false means server didn't handle it — frontend must execute
   }
@@ -1040,7 +1068,8 @@ async function ccExecuteAction(action, targetTabId) {
   if (action._serverExecuted) {
     if (action._serverHidden) return;
     if (action._serverError) {
-      status.innerHTML = '&#10007; ' + escHtml(action.type) + ' failed: ' + escHtml(action._serverError);
+      status.innerHTML = '&#10007; ' + escHtml(action.type) + ' failed: ' + escHtml(action._serverError) +
+        _ccActionContextSuffix(action._serverContext);
       status.style.color = 'var(--red)';
     } else {
       var label = action._serverId ? escHtml(action._serverId) : escHtml(action.title || action.type);
@@ -1048,7 +1077,8 @@ async function ccExecuteAction(action, targetTabId) {
       var successLabel = serverActionType === 'dispatch' ? 'Dispatched' : serverActionType;
       status.innerHTML = '&#10003; ' + escHtml(successLabel) + ': <strong>' + label + '</strong>' +
         (action._serverDuplicate ? '<div style="font-size:10px;color:var(--orange);margin-top:2px">Already existed from a previous request; no duplicate work item was created.</div>' : '') +
-        (action._serverWarning ? '<div style="font-size:10px;color:var(--muted);margin-top:2px">' + escHtml(action._serverWarning) + '</div>' : '');
+        (action._serverWarning ? '<div style="font-size:10px;color:var(--muted);margin-top:2px">' + escHtml(action._serverWarning) + '</div>' : '') +
+        _ccActionContextSuffix(action._serverContext);
       status.style.color = 'var(--green)';
     }
     ccAddMessage('action', status.outerHTML, false, targetTabId);

package/dashboard.js

@@ -2202,6 +2202,34 @@ function _actionsWithIntentFallback(actions, opts = {}) {
   return [action];
 }
 
+function _ccActionContextValue(action) {
+  if (!action || typeof action !== 'object') return '';
+  const candidates = [action.title, action.id, action.file, action.target, action.pr, action.endpoint];
+  for (const value of candidates) {
+    const cleaned = _ccCleanIntentString(value, 160);
+    if (cleaned) return cleaned;
+  }
+  return '';
+}
+
+function _annotateCCActionResults(actions, actionResults, opts = {}) {
+  if (!Array.isArray(actionResults)) return actionResults;
+  const requestedAt = _ccCleanIntentString(opts.requestedAt || new Date().toISOString(), 80);
+  const request = _ccCleanIntentString(opts.message, 180);
+  return actionResults.map((result, idx) => {
+    if (!result || typeof result !== 'object') return result;
+    const action = Array.isArray(actions) ? normalizeCCAction(actions[idx]) : null;
+    const context = {
+      type: _ccCleanIntentString(result.type || action?.type || 'action', 80) || 'action',
+    };
+    const title = _ccActionContextValue(action);
+    if (title) context.title = title;
+    if (request) context.request = request;
+    if (requestedAt) context.requestedAt = requestedAt;
+    return { ...result, actionContext: context };
+  });
+}
+
 function parseCCActions(text) {
   let actions = [];
   let displayText = stripCCActionsForDisplay(text);
@@ -7100,6 +7128,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     try {
       const body = await readBody(req);
       if (!body.message) return jsonReply(res, 400, { error: 'message required' });
+      const actionRequestedAt = new Date().toISOString();
 
       // Per-tab concurrency guard
       tabId = body.tabId || 'default';
@@ -7155,7 +7184,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           { message: body.message, intentMetadata: body.intentMetadata, source: 'command-center', answerText: parsed.text, toolUses }
         );
         if (parsed.actions.length > 0) {
-          parsed.actionResults = await executeCCActions(parsed.actions);
+          parsed.actionResults = _annotateCCActionResults(
+            parsed.actions,
+            await executeCCActions(parsed.actions),
+            { message: body.message, requestedAt: actionRequestedAt }
+          );
         }
         // Mirror only user-facing text to Teams; never send the internal action block.
         if (!tabId.startsWith('teams-')) {
@@ -7259,6 +7292,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const body = await readBody(req);
       if (!body.message && !body.reconnect) { res.statusCode = 400; res.end('message required'); return; }
       tabId = body.tabId || 'default';
+      const actionRequestedAt = new Date().toISOString();
       if (body.reconnect) {
         const live = _getCcLiveStream(tabId);
         if (!live) { res.statusCode = 409; res.end('No live command-center response to reconnect'); return; }
@@ -7487,7 +7521,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         );
         let actionResults;
         if (actions.length > 0) {
-          actionResults = await executeCCActions(actions);
+          actionResults = _annotateCCActionResults(
+            actions,
+            await executeCCActions(actions),
+            { message: body.message, requestedAt: actionRequestedAt }
+          );
         }
         const donePayload = { type: 'done', text: displayText, actions, actionResults, sessionId: responseSessionId, newSession: !wasResume };
         // Issue #1834: surface action JSON parse failures so the UI can warn

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-09T15:01:20.730Z"
+  "cachedAt": "2026-05-09T15:27:55.877Z"
 }

package/engine/restart-health.js

@@ -0,0 +1,169 @@
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const https = require('https');
+const { execSync } = require('child_process');
+
+const DEFAULT_RESTART_HEALTH_TIMEOUT_MS = 15000;
+const DEFAULT_RESTART_HEALTH_INTERVAL_MS = 250;
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function readEngineControl(minionsHome) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(minionsHome, 'engine', 'control.json'), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function normalizePid(pid) {
+  const n = Number(pid);
+  return Number.isInteger(n) && n > 0 ? n : null;
+}
+
+function isProcessAlive(pid) {
+  const n = normalizePid(pid);
+  if (!n || n === process.pid) return false;
+  try {
+    if (process.platform === 'win32') {
+      const out = execSync(`tasklist /FI "PID eq ${n}" /NH`, {
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: 3000,
+      });
+      return new RegExp(`\\b${n}\\b`).test(out) && out.toLowerCase().includes('node');
+    }
+    process.kill(n, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function httpGetJson(url, timeoutMs = 1000) {
+  return new Promise(resolve => {
+    let settled = false;
+    const parsed = new URL(url);
+    const client = parsed.protocol === 'https:' ? https : http;
+    const req = client.get(parsed, { timeout: timeoutMs }, res => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', chunk => { body += chunk; });
+      res.on('end', () => {
+        if (settled) return;
+        settled = true;
+        let json = null;
+        try { json = body ? JSON.parse(body) : null; }
+        catch (err) {
+          resolve({ ok: false, statusCode: res.statusCode, error: err, body });
+          return;
+        }
+        resolve({ ok: res.statusCode >= 200 && res.statusCode < 300, statusCode: res.statusCode, json, body });
+      });
+    });
+    req.on('timeout', () => {
+      if (settled) return;
+      settled = true;
+      req.destroy();
+      resolve({ ok: false, error: new Error(`timed out after ${timeoutMs}ms`) });
+    });
+    req.on('error', err => {
+      if (settled) return;
+      settled = true;
+      resolve({ ok: false, error: err });
+    });
+  });
+}
+
+async function checkRestartHealth(options = {}) {
+  const {
+    minionsHome,
+    dashboardUrl = 'http://127.0.0.1:7331/api/health',
+    readControl = readEngineControl,
+    isProcessAlive: isAlive = isProcessAlive,
+    httpGetJson: getJson = httpGetJson,
+  } = options;
+
+  const control = readControl(minionsHome);
+  const pid = normalizePid(control && control.pid);
+  const engineAlive = pid ? isAlive(pid) : false;
+  const engineOk = control && control.state === 'running' && engineAlive;
+
+  const dashboard = await getJson(dashboardUrl, 1000);
+  const dashboardStatus = dashboard && dashboard.json && dashboard.json.status;
+  const dashboardOk = !!(dashboard && dashboard.ok && dashboardStatus === 'healthy');
+
+  const errors = [];
+  if (!engineOk) {
+    const state = control && control.state ? control.state : 'unknown';
+    const pidLabel = pid || 'none';
+    errors.push(`Engine is not healthy (state=${state}, pid=${pidLabel}, alive=${engineAlive ? 'yes' : 'no'})`);
+  }
+  if (!dashboardOk) {
+    const detail = dashboard && dashboard.error
+      ? dashboard.error.message
+      : dashboard && dashboard.statusCode
+        ? `HTTP ${dashboard.statusCode}${dashboardStatus ? `, status=${dashboardStatus}` : ''}`
+        : 'no response';
+    errors.push(`Dashboard failed health check at ${dashboardUrl} (${detail})`);
+  }
+
+  return {
+    ok: engineOk && dashboardOk,
+    engine: { state: control && control.state, pid, alive: engineAlive },
+    dashboard: { url: dashboardUrl, ok: !!(dashboard && dashboard.ok), statusCode: dashboard && dashboard.statusCode, status: dashboardStatus },
+    errors,
+  };
+}
+
+async function waitForRestartHealth(options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_RESTART_HEALTH_TIMEOUT_MS;
+  const intervalMs = options.intervalMs ?? DEFAULT_RESTART_HEALTH_INTERVAL_MS;
+  const maxAttempts = normalizePid(options.maxAttempts);
+  const started = Date.now();
+  let attempts = 0;
+  let last = null;
+
+  while (true) {
+    attempts++;
+    last = await checkRestartHealth(options);
+    last.attempts = attempts;
+    last.elapsedMs = Date.now() - started;
+    if (last.ok) return last;
+    if (maxAttempts && attempts >= maxAttempts) break;
+    const remainingMs = timeoutMs - (Date.now() - started);
+    if (!maxAttempts && remainingMs <= 0) break;
+    await sleep(maxAttempts ? intervalMs : Math.min(intervalMs, remainingMs));
+  }
+
+  return last || {
+    ok: false,
+    attempts,
+    elapsedMs: Date.now() - started,
+    errors: ['Restart health check did not run'],
+  };
+}
+
+function formatRestartHealthError(result) {
+  const elapsed = typeof result.elapsedMs === 'number' ? `${result.elapsedMs}ms` : 'unknown time';
+  const attempts = result.attempts || 0;
+  const details = (result.errors || ['Unknown restart verification failure']).map(err => `  - ${err}`).join('\n');
+  return `\n  ERROR: Restart verification failed after ${elapsed} (${attempts} attempt${attempts === 1 ? '' : 's'}).\n${details}\n`;
+}
+
+module.exports = {
+  DEFAULT_RESTART_HEALTH_TIMEOUT_MS,
+  DEFAULT_RESTART_HEALTH_INTERVAL_MS,
+  checkRestartHealth,
+  waitForRestartHealth,
+  formatRestartHealthError,
+  _private: {
+    httpGetJson,
+    isProcessAlive,
+    readEngineControl,
+    normalizePid,
+  },
+};

package/package.json

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