@yemi33/minions 0.1.1932 → 0.1.1934

package/bin/minions.js

@@ -8,7 +8,7 @@
  *   minions add <project-dir>        Link a project (interactive)
  *   minions remove <project-dir>     Unlink a project
  *   minions list                     List linked projects
- *   minions update                   Update to latest version
+ *   minions update [--no-wait]       Update to latest version (--no-wait backgrounds the post-update restart)
  *   minions version                  Show installed and package versions
  *   minions doctor                   Check prerequisites and runtime health
  *   minions restart [--open]         Start engine + dashboard (--open forces a new browser tab)
@@ -604,6 +604,28 @@ function runPostUpdateRestart() {
   process.exit(1);
 }
 
+// Fire-and-forget variant for `minions update --no-wait`. The npm + init phases
+// have already completed synchronously, so package-install failures surface
+// normally; only the long-tail engine/dashboard restart + health check is
+// backgrounded. stdio is redirected to a log so the user can postmortem if the
+// restart fails after the parent has exited.
+function runPostUpdateRestartDetached() {
+  const initScript = path.join(PKG_ROOT, 'bin', 'minions.js');
+  const out = _openStdioLog('update-restart-stdio.log');
+  const err = _openStdioLog('update-restart-stdio.log');
+  const proc = spawn(process.execPath, [initScript, 'restart'], {
+    cwd: process.cwd(),
+    env: { ...process.env, MINIONS_HOME },
+    stdio: ['ignore', out, err],
+    detached: true,
+    windowsHide: true,
+  });
+  proc.unref();
+  const logPath = path.join(MINIONS_HOME, 'engine', 'update-restart-stdio.log');
+  console.log(`  Restart spawned in background (PID: ${proc.pid}); logs: ${logPath}`);
+  console.log(`  Verify with: minions status\n`);
+}
+
 // ─── Version command ────────────────────────────────────────────────────────
 
 function showVersion() {
@@ -668,7 +690,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
 
   Setup:
     minions init                     Bootstrap ~/.minions/ (first time)
-    minions update                   Update to latest version (npm update + one restart)
+    minions update [--no-wait]       Update to latest version (--no-wait backgrounds the restart)
     minions version                  Show installed vs package version
     minions doctor                   Check prerequisites and runtime health
     minions add <project-dir>        Link a project (interactive)
@@ -707,6 +729,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
 } else if (cmd === 'init') {
   init();
 } else if (cmd === 'update') {
+  const noWait = rest.includes('--no-wait') || rest.includes('--detach');
   console.log('\n  Updating Minions...\n');
   // Dev/symlink installs: PKG_ROOT === MINIONS_HOME — npm update is a no-op (symlink already
   // points to the repo), and `minions init --force` would fail (cwd/.minions is inside PKG_ROOT).
@@ -726,9 +749,15 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
     // the global shim while npm is still settling the updated install.
     runPostUpdateInit();
   }
-  // Restart engine + dashboard so they pick up the new code
+  // Restart engine + dashboard so they pick up the new code. With --no-wait the
+  // restart is spawned detached so the caller (e.g. a DevBox maintenance task)
+  // can return immediately without holding the parent open for the health poll.
   console.log('\n  Restarting engine and dashboard...\n');
-  runPostUpdateRestart();
+  if (noWait) {
+    runPostUpdateRestartDetached();
+  } else {
+    runPostUpdateRestart();
+  }
 } else if (cmd === 'version' || cmd === '--version' || cmd === '-v') {
   showVersion();
 } else if (cmd === 'add' || cmd === 'remove' || cmd === 'list' || cmd === 'scan') {

package/dashboard.js

@@ -6368,7 +6368,28 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     let accumulated = '';
     let sessionHandle = null;
     let resolveResult;
+    // Per-turn phase timing — emitted as one structured [cc-timing] log line
+    // so we can attribute Copilot CC slowness (e.g. 36s) to spawn vs first-byte
+    // vs streaming vs trailing inference. Parallels engine.js's [spawn-timing].
+    const _tStart = Date.now();
+    let _tFirstByte = null;
+    let _tFirstTool = null;
+    let _chunkCount = 0;
+    let _toolUseCount = 0;
     const promise = new Promise((resolve) => { resolveResult = resolve; });
+    const _emitTimingLog = (lifecycle, sessionReady, streamEnd, outcome) => {
+      try {
+        const _diff = (a, b) => (a != null && b != null) ? (b - a) : null;
+        const timings = {
+          get_session: _diff(_tStart, sessionReady),
+          first_byte: _diff(sessionReady, _tFirstByte),
+          first_tool: _diff(sessionReady, _tFirstTool),
+          stream: _diff(sessionReady, streamEnd),
+          total: _diff(_tStart, streamEnd),
+        };
+        shared.log('info', `[cc-timing] tab=${resolvedTabId} lifecycle=${lifecycle || 'unknown'} outcome=${outcome} chunks=${_chunkCount} tools=${_toolUseCount} ${JSON.stringify(timings)}`);
+      } catch { /* telemetry is best-effort */ }
+    };
     promise.abort = () => {
       cancelled = true;
       try { sessionHandle && sessionHandle.cancel(); } catch { /* swallow */ }
@@ -6383,6 +6404,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           systemPromptHash: _ccPromptHash,
         });
       } catch (err) {
+        _emitTimingLog(null, null, Date.now(), 'spawn-failed');
         return resolveResult({
           text: '',
           sessionId: null,
@@ -6392,19 +6414,26 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           stderr: String((err && err.message) || err || 'cc-worker-pool spawn failed'),
         });
       }
+      const _tSessionReady = Date.now();
+      const _lifecycle = sessionHandle.lifecycle || 'unknown';
       if (cancelled) {
         try { sessionHandle.cancel(); } catch { /* swallow */ }
+        _emitTimingLog(_lifecycle, _tSessionReady, Date.now(), 'cancelled-pre-stream');
         return resolveResult({ text: accumulated, sessionId: sessionHandle.sessionId, code: 0, usage: {}, raw: accumulated, stderr: '' });
       }
       await sessionHandle.stream(prompt, {
         systemPromptText: systemPrompt,
         onChunk: (delta) => {
+          if (_tFirstByte == null) _tFirstByte = Date.now();
+          _chunkCount += 1;
           accumulated += delta;
           _touchCcLiveStream(liveState);
           liveState.text = accumulated;
           if (liveState.writer) liveState.writer({ type: 'chunk', text: accumulated });
         },
         onToolUse: (name, input) => {
+          if (_tFirstTool == null) _tFirstTool = Date.now();
+          _toolUseCount += 1;
           _touchCcLiveStream(liveState);
           const safeInput = input || {};
           if (Array.isArray(toolUses)) toolUses.push({ name, input: safeInput });
@@ -6412,9 +6441,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(safeInput) });
         },
         onDone: () => {
+          _emitTimingLog(_lifecycle, _tSessionReady, Date.now(), 'done');
           resolveResult({ text: accumulated, sessionId: sessionHandle.sessionId, code: 0, usage: {}, raw: accumulated, stderr: '' });
         },
         onError: (err) => {
+          _emitTimingLog(_lifecycle, _tSessionReady, Date.now(), cancelled ? 'cancelled' : 'error');
           resolveResult({
             text: accumulated,
             sessionId: sessionHandle.sessionId,

package/engine/cc-worker-pool.js

@@ -483,6 +483,12 @@ async function getSession({ tabId, model, effort, mcpServers, systemPromptHash,
   if (!tabId) throw new Error('cc-worker-pool.getSession: tabId is required');
   const mcpServersHash = _hashMcpServers(mcpServers);
   let worker = _tabs.get(tabId);
+  // Track which lifecycle path we took so the dashboard's [cc-timing] log can
+  // attribute warm-reuse vs new-session vs cold-spawn. One of:
+  //   'warm-reuse'  — proc + session both reused (no spawn, no session/new)
+  //   'new-session' — proc reused, fresh session/new (sysprompt hash changed)
+  //   'cold-spawn'  — fresh proc + initialize + session/new
+  let lifecycle = 'warm-reuse';
 
   if (worker) {
     if (worker.killed) {
@@ -501,6 +507,7 @@ async function getSession({ tabId, model, effort, mcpServers, systemPromptHash,
       // caller has rotated in (Bug B / issue #2479).
       await worker.newSession({ mcpServers, systemPromptHash, model, effort });
       worker.lastUsedAt = _internals.now();
+      lifecycle = 'new-session';
     } else {
       // Warm reuse — only update bookkeeping. model/effort changes on a
       // warm session are tracked here but not pushed via configOptions in
@@ -524,12 +531,14 @@ async function getSession({ tabId, model, effort, mcpServers, systemPromptHash,
       try { worker.close(); } catch { /* already torn down */ }
       throw err;
     }
+    lifecycle = 'cold-spawn';
   }
 
   _ensureReaper();
 
   return {
     sessionId: worker.sessionId,
+    lifecycle,
     stream: (promptText, opts) => worker.stream(promptText, opts),
     cancel: () => worker.cancel(),
     close: () => closeTab(tabId),

package/package.json

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

package/engine/copilot-models.json

@@ -1,5 +0,0 @@
-{
-  "runtime": "copilot",
-  "models": null,
-  "cachedAt": "2026-05-14T03:48:55.090Z"
-}