@yemi33/minions 0.1.1924 → 0.1.1926

package/dashboard.js

@@ -1190,21 +1190,24 @@ function getDiskVersion() {
 }
 
 // ── MCP server discovery ─────────────────────────────────────────────────────
-// Mirrors what each CLI actually loads at runtime:
-//   • `claude mcp list`         → user + plugin (+ workspace if cwd in project)
-//   • `copilot mcp list --json` → user + workspace + plugin + builtin (merged)
+// Reads MCP server registrations directly from each CLI's config file:
+//   • `~/.claude.json` → `mcpServers` (Claude user scope)
+//   • `~/.copilot/mcp-config.json` → `mcpServers` (Copilot user scope)
 //   • Each registered project's `<localPath>/.mcp.json` → workspace scope
 //
-// CLI calls are slow (claude health-checks every server on stdio), so we cache
-// for ~5 minutes and refresh in the background. getMcpServers() always returns
-// synchronously from cache; first call before background fill returns [].
+// We used to shell out to `claude mcp list` + `copilot mcp list --json`, but
+// `claude mcp list` blocks on a TTY check when the dashboard daemon has no
+// parent console (bin/minions.js spawns it with windowsHide:true), so every
+// refresh timed out and the cache stayed empty. File reads are zero-spawn and
+// the config files are the authoritative source for registration.
+//
+// Cost: we lose live connection status (✓ Connected / ! Needs auth) and the
+// Claude plugin: <plugin>:<server> rows. The UI shows status only in a hover
+// tooltip, and plugin servers are rare; reliability matters more.
 
 const _MCP_CACHE_TTL = 5 * 60 * 1000;
-const _MCP_CLAUDE_TIMEOUT = 30000;
-const _MCP_COPILOT_TIMEOUT = 15000;
 let _mcpServersCache = null;
 let _mcpServersCacheTs = 0;
-let _mcpRefreshInflight = null;
 
 function _parseClaudeMcpListLine(line) {
   const trimmed = (line || '').trim();
@@ -1248,19 +1251,43 @@ function _parseCopilotMcpListJson(raw) {
   } catch { return []; }
 }
 
-function _runCliAsync(cmd, args, timeoutMs) {
-  return new Promise(resolve => {
-    try {
-      const { exec } = require('child_process');
-      // exec() runs through the shell so Windows resolves .cmd/.exe shims off
-      // PATH. Args are static so there's no injection surface.
-      const line = [cmd, ...args].join(' ');
-      exec(line, {
-        timeout: timeoutMs, windowsHide: true, encoding: 'utf8',
-        maxBuffer: 1024 * 1024,
-      }, (err, stdout) => resolve(err ? null : stdout));
-    } catch { resolve(null); }
-  });
+// Read Claude's user-scope MCP servers from `~/.claude.json` directly.
+// Shelling out to `claude mcp list` is unreliable from the dashboard daemon —
+// the CLI's MCP health probes block on a TTY check when the parent has no
+// console (bin/minions.js launches the dashboard with windowsHide:true), and
+// neither exec() nor spawn(..., {detached:true}) reliably sidesteps it.
+// Config-file reads are zero-spawn, instant, and the file is the authoritative
+// source for which servers are registered.
+function _readClaudeUserMcpServers() {
+  try {
+    const data = safeJsonObj(path.join(os.homedir(), '.claude.json'));
+    const servers = data?.mcpServers || {};
+    return Object.entries(servers).map(([name, cfg]) => ({
+      name,
+      source: 'Claude user',
+      command: cfg.command || cfg.url || '',
+      args: Array.isArray(cfg.args) ? cfg.args.join(' ') : (cfg.args || ''),
+    }));
+  } catch { return []; }
+}
+
+// Copilot stores its MCP config at `~/.copilot/mcp-config.json` (may have a
+// UTF-8 BOM — Windows tooling tends to write one).
+function _readCopilotUserMcpServers() {
+  try {
+    const configPath = path.join(os.homedir(), '.copilot', 'mcp-config.json');
+    if (!fs.existsSync(configPath)) return [];
+    let raw = fs.readFileSync(configPath, 'utf8');
+    if (raw.charCodeAt(0) === 0xFEFF) raw = raw.slice(1);
+    const data = JSON.parse(raw);
+    const servers = data?.mcpServers || {};
+    return Object.entries(servers).map(([name, cfg]) => ({
+      name,
+      source: 'Copilot',
+      command: cfg.command || cfg.url || '',
+      args: Array.isArray(cfg.args) ? cfg.args.join(' ') : (cfg.args || ''),
+    }));
+  } catch { return []; }
 }
 
 function _readWorkspaceMcpServers(projects) {
@@ -1293,42 +1320,26 @@ function _dedupeMcpServers(entries) {
   return out;
 }
 
-async function _refreshMcpServersCache() {
-  if (_mcpRefreshInflight) return _mcpRefreshInflight;
-  _mcpRefreshInflight = (async () => {
-    try {
-      const [claudeOut, copilotOut] = await Promise.all([
-        _runCliAsync('claude', ['mcp', 'list'], _MCP_CLAUDE_TIMEOUT),
-        _runCliAsync('copilot', ['mcp', 'list', '--json'], _MCP_COPILOT_TIMEOUT),
-      ]);
-      const claudeEntries = (claudeOut || '').split(/\r?\n/).map(_parseClaudeMcpListLine).filter(Boolean);
-      const copilotEntries = _parseCopilotMcpListJson(copilotOut || '{}');
-      const workspaceEntries = _readWorkspaceMcpServers(PROJECTS);
-      _mcpServersCache = _dedupeMcpServers([...claudeEntries, ...copilotEntries, ...workspaceEntries]);
-      _mcpServersCacheTs = Date.now();
-    } catch (e) {
-      console.error('[mcp-discovery] refresh failed:', e.message?.split('\n')?.[0]);
-      if (!_mcpServersCache) _mcpServersCache = [];
-      _mcpServersCacheTs = Date.now();
-    } finally {
-      _mcpRefreshInflight = null;
-    }
-  })();
-  return _mcpRefreshInflight;
-}
-
 function getMcpServers() {
   const now = Date.now();
-  if (!_mcpServersCache || (now - _mcpServersCacheTs) >= _MCP_CACHE_TTL) {
-    _refreshMcpServersCache().catch(() => {});
+  if (_mcpServersCache && (now - _mcpServersCacheTs) < _MCP_CACHE_TTL) {
+    return _mcpServersCache;
+  }
+  try {
+    const entries = [
+      ..._readClaudeUserMcpServers(),
+      ..._readCopilotUserMcpServers(),
+      ..._readWorkspaceMcpServers(PROJECTS),
+    ];
+    _mcpServersCache = _dedupeMcpServers(entries);
+  } catch (e) {
+    console.error('[mcp-discovery] refresh failed:', e.message?.split('\n')?.[0]);
+    if (!_mcpServersCache) _mcpServersCache = [];
   }
-  return _mcpServersCache || [];
+  _mcpServersCacheTs = now;
+  return _mcpServersCache;
 }
 
-// Kick off first discovery on startup so the dashboard has data before the
-// first slow-state rebuild.
-_refreshMcpServersCache().catch(() => {});
-
 function parsePinnedEntries(content) {
   if (!content) return [];
   const entries = [];

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.1924",
+  "version": "0.1.1926",
   "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"