@yemi33/minions 0.1.1925 → 0.1.1927

package/dashboard/js/render-other.js

@@ -166,9 +166,15 @@ function renderLlmPerf(metrics) {
     el.innerHTML = '<p class="empty">No LLM performance data yet.</p>';
     return;
   }
-  let html = '<table class="pr-table"><thead><tr><th>Call Type</th><th>Calls</th><th>Total Time</th><th>Avg Time</th><th>Cost</th></tr></thead><tbody>';
-  const entries = Object.entries(engine).filter(([k]) => !k.startsWith('test')).sort((a, b) => (b[1].calls || 0) - (a[1].calls || 0));
-  for (const [type, m] of entries) {
+  // Split entries: per-LLM-call rows vs per-agent-task agent-dispatch row.
+  // `calls` semantics differ between the two — agent-dispatch counts dispatched
+  // work items (with runtimeMs = wall-clock of the agent process), the others
+  // count LLM API round-trips (with totalDurationMs = sum of per-call latencies).
+  const filtered = Object.entries(engine).filter(([k]) => !k.startsWith('test'));
+  const perCall = filtered.filter(([k]) => k !== 'agent-dispatch')
+    .sort((a, b) => (b[1].calls || 0) - (a[1].calls || 0));
+  const perTask = filtered.filter(([k]) => k === 'agent-dispatch');
+  function renderRow(type, m) {
     const calls = m.calls || 0;
     const totalMs = m.totalDurationMs || 0;
     const timedCalls = m.timedCalls || 0;
@@ -176,16 +182,48 @@ function renderLlmPerf(metrics) {
     const fmtTotal = totalMs < 60000 ? Math.round(totalMs / 1000) + 's' : Math.round(totalMs / 60000) + 'm';
     const fmtAvg = avgMs < 1000 ? Math.round(avgMs) + 'ms' : avgMs < 60000 ? Math.round(avgMs / 1000) + 's' : Math.round(avgMs / 60000) + 'm';
     const cost = m.costUsd ? '$' + m.costUsd.toFixed(2) : '-';
-    html += '<tr><td style="font-weight:600">' + escHtml(type) + '</td>' +
+    return '<tr><td style="font-weight:600">' + escHtml(type) + '</td>' +
       '<td>' + calls + '</td>' +
       '<td style="color:var(--muted)">' + (totalMs ? fmtTotal : '-') + '</td>' +
       '<td style="color:var(--blue)">' + (avgMs ? fmtAvg : '-') + '</td>' +
       '<td style="color:var(--muted)">' + cost + '</td></tr>';
   }
+  let html = '<table class="pr-table"><thead><tr><th>Call Type</th><th>Calls</th><th>Total Time</th><th>Avg Time</th><th>Cost</th></tr></thead><tbody>';
+  for (const [type, m] of perCall) {
+    html += renderRow(type, m);
+  }
+  if (perTask.length > 0) {
+    // Visual divider + caption row to distinguish per-call (above) from
+    // per-task (below) — column units differ.
+    html += '<tr><td colspan="5" style="border-top:2px solid var(--border);padding-top:6px;font-size:10px;color:var(--muted);font-style:italic">— per agent task (calls = dispatched work items, time = wall-clock of agent process) —</td></tr>';
+    for (const [type, m] of perTask) {
+      html += renderRow(type + ' (per task)', m);
+    }
+  }
   html += '</tbody></table>';
   el.innerHTML = html;
 }
 
+// Aggregate _engine entries for the Token Usage summary tiles.
+// Excludes:
+//   - 'agent-dispatch' (already counted in per-agent metrics[agentId] totals;
+//     summing both would double-count agent spend in the tile)
+//   - 'test-*' / '_test*' (matching engine/llm.js trackEngineUsage filter so
+//     stale test categories don't inflate engineCalls)
+function _aggregateEngineUsageForTokenTile(engine) {
+  let cost = 0, input = 0, output = 0, cache = 0, calls = 0;
+  for (const [k, e] of Object.entries(engine || {})) {
+    if (k === 'agent-dispatch') continue;
+    if (k.startsWith('test-') || k.startsWith('_test')) continue;
+    cost += e.costUsd || 0;
+    input += e.inputTokens || 0;
+    output += e.outputTokens || 0;
+    cache += e.cacheRead || 0;
+    calls += e.calls || 0;
+  }
+  return { cost, input, output, cache, calls };
+}
+
 function renderTokenUsage(metrics) {
   const el = document.getElementById('token-usage-content');
   const agents = Object.entries(metrics).filter(([k]) => !k.startsWith('_'));
@@ -201,15 +239,11 @@ function renderTokenUsage(metrics) {
     agentCache += m.totalCacheRead || 0;
   }
 
-  // Aggregate engine totals
-  let engineCost = 0, engineInput = 0, engineOutput = 0, engineCache = 0, engineCalls = 0;
-  for (const [, e] of Object.entries(engine)) {
-    engineCost += e.costUsd || 0;
-    engineInput += e.inputTokens || 0;
-    engineOutput += e.outputTokens || 0;
-    engineCache += e.cacheRead || 0;
-    engineCalls += e.calls || 0;
-  }
+  // Aggregate engine totals (excludes agent-dispatch + test-* — see helper)
+  const engAgg = _aggregateEngineUsageForTokenTile(engine);
+  const engineCost = engAgg.cost, engineInput = engAgg.input,
+    engineOutput = engAgg.output, engineCache = engAgg.cache,
+    engineCalls = engAgg.calls; // eslint-disable-line no-unused-vars
 
   const totalCost = agentCost + engineCost;
   const totalInput = agentInput + engineInput;
@@ -430,4 +464,4 @@ async function _addSelectedProjects() {
   }
 }
 
-window.MinionsOther = { renderProjects, optimisticallyAddProject, projectChipRemove, renderMcpServers, renderMetrics, renderLlmPerf, renderTokenUsage, openScanProjectsModal };
+window.MinionsOther = { renderProjects, optimisticallyAddProject, projectChipRemove, renderMcpServers, renderMetrics, renderLlmPerf, renderTokenUsage, _aggregateEngineUsageForTokenTile, openScanProjectsModal };

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-14T02:03:25.197Z"
+  "cachedAt": "2026-05-14T02:06:41.197Z"
 }

package/engine/lifecycle.js

@@ -2550,8 +2550,14 @@ function updateMetrics(agentId, dispatchItem, result, taskUsage, prsCreatedCount
       metrics._engine['agent-dispatch'] = { calls: 0, costUsd: 0, inputTokens: 0, outputTokens: 0, cacheRead: 0, cacheCreation: 0, totalDurationMs: 0 };
     }
     const eng = metrics._engine['agent-dispatch'];
-    eng.calls++;
+    // Gate calls on runtimeMs > 0 so pre-spawn skips (deps unmet, cooldown,
+    // classified-fail) don't inflate the dispatch-tile call count. `calls` and
+    // `timedCalls` advance together for agent-dispatch; both fields are kept
+    // for schema parity with other _engine entries (CC/doc-chat/consolidation/
+    // kb-sweep) where calls = LLM round-trips and timedCalls subset = ones with
+    // a measured durationMs.
     if (runtimeMs > 0) {
+      eng.calls++;
       eng.totalDurationMs = (eng.totalDurationMs || 0) + runtimeMs;
       eng.timedCalls = (eng.timedCalls || 0) + 1;
     }

package/engine.js

@@ -735,6 +735,11 @@ async function spawnAgent(dispatchItem, config) {
   const claudeConfig = config.claude || {};
   const engineConfig = config.engine || {};
   const startedAt = ts();
+  // Phase timing — raw timestamps, emitted as one structured `[spawn-timing]`
+  // log line after spawn succeeds. Use Date.now() not ts() so deltas are plain
+  // milliseconds. Keys are stamped at phase boundaries below.
+  const _phaseT = { start: Date.now() };
+  let _depCountForLog = 0;
 
   updateAgentStatus(id, AGENT_STATUS.SPAWNING, `Preparing ${type} task for ${agentId}`);
 
@@ -802,6 +807,7 @@ async function spawnAgent(dispatchItem, config) {
   const sysPromptPath = path.join(tmpDir, `sysprompt-${safeId}.md`);
   safeWrite(sysPromptPath, systemPrompt);
   const _cleanupPromptFiles = () => { safeUnlink(promptPath); safeUnlink(sysPromptPath); };
+  _phaseT.afterPrompt = Date.now();
 
   if (branchName) {
     updateAgentStatus(id, AGENT_STATUS.WORKTREE_SETUP, `Setting up worktree for branch ${branchName}`);
@@ -990,7 +996,9 @@ async function spawnAgent(dispatchItem, config) {
     if (worktreePath && fs.existsSync(worktreePath)) {
       cwd = worktreePath;
       const depIds = meta?.item?.depends_on || [];
+      _depCountForLog = depIds.length;
       if (depIds.length > 0) {
+        _phaseT.depFetchStart = Date.now();
         try {
           const depBranches = resolveDependencyBranches(depIds, meta?.item?.sourcePlan, project, config);
           let depMergeFailed = false;
@@ -1047,6 +1055,8 @@ async function spawnAgent(dispatchItem, config) {
               depMergeFailed = true;
             }
           }
+          _phaseT.depFetchEnd = Date.now();
+          _phaseT.depPreflightStart = _phaseT.depFetchEnd;
           // Merge successfully-fetched + recovered (local-only pushed) branches sequentially
           const fetched = fetchable.filter((_, i) => fetchResults[i].status === 'fulfilled' || recoveredBranches.has(fetchable[i].branch));
           // Ancestor pruning: remove dep branches already contained in another (#958)
@@ -1098,6 +1108,8 @@ async function spawnAgent(dispatchItem, config) {
               log('warn', `Pre-flight simulation failed, proceeding with real merge: ${e.message}`);
             }
           }
+          _phaseT.depPreflightEnd = Date.now();
+          _phaseT.depMergeStart = _phaseT.depPreflightEnd;
           // Stash uncommitted changes before dep merge if worktree is dirty (#973)
           let stashed = false;
           if (!depMergeFailed && !skipDepMerge && prunedDeps.length > 0) {
@@ -1182,6 +1194,7 @@ async function spawnAgent(dispatchItem, config) {
               log('warn', `git stash pop failed in ${branchName}: ${popErr.message} — stash preserved for agent`);
             }
           }
+          _phaseT.depMergeEnd = Date.now();
           if (depMergeFailed) {
             _cleanupPromptFiles();
             // Build actionable failReason identifying the conflicting branch and files (#958)
@@ -1291,6 +1304,7 @@ async function spawnAgent(dispatchItem, config) {
   if (cwd === rootDir && ['implement', 'implement:large', 'fix', 'test', 'verify', 'plan-to-prd'].includes(type)) {
     log('warn', `Agent ${agentId} running ${type} task in main repo (no worktree) for ${id} — changes may land on master directly`);
   }
+  _phaseT.afterWorktree = Date.now();
 
   // ── Stale-HEAD guard for fix-task pushes (P-c8f2d5e3) ────────────────────
   // When a PR branch is rebased upstream (force-push), a reused worktree can
@@ -1302,6 +1316,7 @@ async function spawnAgent(dispatchItem, config) {
   // Read-only and non-fix dispatches are out of scope — implement tasks cut
   // their own branch from main, and review/verify don't push.
   if (type === WORK_TYPE.FIX && branchName && worktreePath && cwd === worktreePath) {
+    _phaseT.staleHeadStart = Date.now();
     try {
       const guard = await assertStaleHeadOk({
         branch: branchName,
@@ -1325,6 +1340,7 @@ async function spawnAgent(dispatchItem, config) {
       // to skipped:'fetch-failed'). Log and continue.
       log('warn', `Stale-HEAD guard error for ${id} (${branchName}): ${err.message}`);
     }
+    _phaseT.staleHeadEnd = Date.now();
   }
 
   // ── Runtime + opts resolution (P-2a6d9c4f) ────────────────────────────────
@@ -1371,6 +1387,7 @@ async function spawnAgent(dispatchItem, config) {
 
   // MCP servers: agents inherit from ~/.claude.json directly as Claude Code processes.
   // No --mcp-config needed — avoids redundant config and ensures agents always have latest servers.
+  _phaseT.afterRuntime = Date.now();
 
   log('info', `Spawning agent: ${agentId} (${id}) in ${cwd}`);
   log('info', `Task type: ${type} | Branch: ${branchName || 'none'}`);
@@ -1428,6 +1445,7 @@ async function spawnAgent(dispatchItem, config) {
   }
 
   let proc;
+  _phaseT.spawnCallStart = Date.now();
   try {
     // `detached: true` puts the agent in its own process group (POSIX) / job
     // object (Windows), so when the engine dies — gracefully via stop, abruptly
@@ -1441,6 +1459,7 @@ async function spawnAgent(dispatchItem, config) {
       env: childEnv,
       detached: true,
     });
+    _phaseT.spawnCallEnd = Date.now();
   } catch (spawnErr) {
     // Synchronous spawn failure — record it to the (already-stamped) log so the
     // orphan detector's "logSize > stub-only" check can tell this apart from a
@@ -1476,6 +1495,26 @@ async function spawnAgent(dispatchItem, config) {
   };
   activeProcesses.set(id, initialProcInfo);
 
+  // Emit per-phase timing for spawn-latency analysis. One structured line per
+  // dispatch; grep `[spawn-timing]` to aggregate. Null phases didn't run for
+  // this dispatch (e.g. stale_head only runs for fix tasks; dep_* only when
+  // the item has depends_on).
+  try {
+    const _diff = (a, b) => (_phaseT[a] != null && _phaseT[b] != null) ? (_phaseT[b] - _phaseT[a]) : null;
+    const timings = {
+      prompt: _diff('start', 'afterPrompt'),
+      worktree_total: _diff('afterPrompt', 'afterWorktree'),
+      dep_fetch: _diff('depFetchStart', 'depFetchEnd'),
+      dep_preflight: _diff('depPreflightStart', 'depPreflightEnd'),
+      dep_merge: _diff('depMergeStart', 'depMergeEnd'),
+      stale_head: _diff('staleHeadStart', 'staleHeadEnd'),
+      runtime: _diff('afterWorktree', 'afterRuntime'),
+      spawn_call: _diff('spawnCallStart', 'spawnCallEnd'),
+      total: _diff('start', 'spawnCallEnd'),
+    };
+    log('info', `[spawn-timing] id=${id} agent=${agentId} type=${type} runtime=${runtimeName} branch=${branchName || '-'} deps=${_depCountForLog} ${JSON.stringify(timings)}`);
+  } catch { /* telemetry is best-effort */ }
+
   const MAX_OUTPUT = 1024 * 1024; // 1MB
   let stdout = '';
   let stderr = '';

package/package.json

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