@yemi33/minions 0.1.1926 → 0.1.1928

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/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

@@ -823,7 +823,9 @@ async function spawnAgent(dispatchItem, config) {
     shared.assertWorktreeOutsideProject(worktreePath, rootDir);
 
     // If branch is already checked out in an existing worktree, reuse it
+    _phaseT.findExistingStart = Date.now();
     const existingWt = await findExistingWorktree(rootDir, branchName);
+    _phaseT.findExistingEnd = Date.now();
     if (existingWt) {
       // Same guard for reuse — a previously-created bad worktree must not
       // be silently reused either; the cleanup sweep flags these so the
@@ -834,13 +836,16 @@ async function spawnAgent(dispatchItem, config) {
       // Probe origin first — locally-created branches that were never pushed
       // (orphan/timeout retry before first push) would otherwise emit a
       // "couldn't find remote ref" warn pair on every reuse.
+      _phaseT.reuseSyncStart = Date.now();
       await syncReusedWorktree(rootDir, existingWt, branchName, _gitOpts);
+      _phaseT.reuseSyncEnd = Date.now();
     } else if (READ_ONLY_ROOT_TASK_TYPES.has(type) && !isPipelineBranchName(branchName)) {
       // Read-only tasks — no worktree needed, run in rootDir
       log('info', `${type}: read-only task, no worktree needed — running in rootDir`);
       branchName = null;
       worktreePath = null;
     } else {
+      _phaseT.createWorktreeStart = Date.now();
       try {
         if (!fs.existsSync(worktreePath)) {
           const isSharedBranch = meta?.branchStrategy === 'shared-branch' || meta?.useExistingBranch;
@@ -965,6 +970,7 @@ async function spawnAgent(dispatchItem, config) {
           return null;
         }
       }
+      _phaseT.createWorktreeEnd = Date.now();
     }
 
     // Shared-branch preflight (#2439): refuse to dispatch into a dirty shared
@@ -974,7 +980,9 @@ async function spawnAgent(dispatchItem, config) {
     // fires AFTER spawn — converting orchestration hygiene into fake
     // implementation failures and cascading dependent items.
     if (worktreePath && fs.existsSync(worktreePath) && meta?.branchStrategy === 'shared-branch' && branchName) {
+      _phaseT.cleanCheckStart = Date.now();
       const cleanResult = await assertCleanSharedWorktree(rootDir, worktreePath, branchName, id, _gitOpts);
+      _phaseT.cleanCheckEnd = Date.now();
       if (!cleanResult.clean) {
         const previewFiles = (cleanResult.dirtyFiles || []).slice(0, 5).join(', ');
         const reasonMsg = `DIRTY_WORKTREE: shared branch ${branchName} worktree at ${worktreePath} is dirty (${cleanResult.reason}); ${cleanResult.dirtyFiles?.length || 0} file(s)${previewFiles ? ': ' + previewFiles : ''}`;
@@ -1281,6 +1289,7 @@ async function spawnAgent(dispatchItem, config) {
   // Inject dirty file list when worktree has uncommitted changes (e.g., max_turns retry)
   // This signals to the respawned agent that prior work exists in the worktree (#960)
   if (worktreePath && fs.existsSync(worktreePath)) {
+    _phaseT.dirtyProbeStart = Date.now();
     try {
       const dirtyResult = await execAsync('git status --porcelain', { ..._gitOpts, cwd: worktreePath, timeout: 10000 });
       const dirtyOutput = (dirtyResult.stdout || '').trim();
@@ -1298,6 +1307,7 @@ async function spawnAgent(dispatchItem, config) {
         log('info', `Injected ${dirtyFiles.length} dirty files into prompt for ${id}`);
       }
     } catch (e) { log('warn', `git status --porcelain for dirty files: ${e.message}`); }
+    _phaseT.dirtyProbeEnd = Date.now();
   }
 
   // Safety check: warn if a write-capable task is running in the main repo without a worktree
@@ -1504,6 +1514,11 @@ async function spawnAgent(dispatchItem, config) {
     const timings = {
       prompt: _diff('start', 'afterPrompt'),
       worktree_total: _diff('afterPrompt', 'afterWorktree'),
+      wt_find_existing: _diff('findExistingStart', 'findExistingEnd'),
+      wt_reuse_sync: _diff('reuseSyncStart', 'reuseSyncEnd'),
+      wt_create: _diff('createWorktreeStart', 'createWorktreeEnd'),
+      wt_clean_check: _diff('cleanCheckStart', 'cleanCheckEnd'),
+      wt_dirty_probe: _diff('dirtyProbeStart', 'dirtyProbeEnd'),
       dep_fetch: _diff('depFetchStart', 'depFetchEnd'),
       dep_preflight: _diff('depPreflightStart', 'depPreflightEnd'),
       dep_merge: _diff('depMergeStart', 'depMergeEnd'),

package/package.json

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