@yemi33/minions 0.1.2239 → 0.1.2241

package/dashboard.js

@@ -14178,6 +14178,14 @@ if (require.main === module) {
   // engine reads, port binding) is captured rather than dying silently.
   _installCrashHandlers();
 
+  // Every copilot the dashboard spawns — Command Center, doc-chat, and the CC
+  // worker pool (`copilot --acp`) — inherits this process's COPILOT_HOME. Point
+  // it at the seeded, MCP-filtered home so those `direct:true` copilot calls
+  // load the filtered config instead of the operator's full `~/.copilot` stack
+  // (which would pop a Microsoft auth window per call). Mirrors the engine's
+  // boot-time set. See shared.ensureAgentCopilotHome. Fail-open.
+  try { process.env.COPILOT_HOME = shared.ensureAgentCopilotHome(MINIONS_DIR, CONFIG?.engine); } catch {}
+
   // Pre-warm the per-project git-status cache before accepting requests so
   // the first /api/status after restart already returns gitState='ok' with a
   // real branch instead of the ~8s pending gap that hides the projects-bar

package/engine/shared.js

@@ -2958,19 +2958,20 @@ const ENGINE_DEFAULTS = {
   copilotSuppressAgentsMd: true,     // Copilot --no-custom-instructions: stop AGENTS.md auto-load from fighting Minions playbook prompts
   copilotStreamMode: 'on',           // Copilot --stream <on|off>: 'on' streams assistant.message_delta events live; 'off' batches them
   copilotReasoningSummaries: false,  // Copilot --enable-reasoning-summaries (Anthropic-family models only)
-  // P-mcp-storm — Copilot loads `~/.copilot/mcp-config.json` (the operator's
-  // user-scope MCP servers) UNCONDITIONALLY on every process start: it is NOT
-  // gated by `--add-dir`, cwd, or `hermeticHarness` (proven empirically — a
-  // copilot spawned from a neutral dir with no `--add-dir ~/.copilot` still
-  // connects every server). So every spawned Copilot agent boots the operator's
-  // full interactive MCP stack; on Windows each `type:local`/`stdio` server
-  // (e.g. playwright, maestro) launches its own visible console window and
-  // playwright opens browser tabs. The only lever Copilot exposes is
-  // `--disable-mcp-server <name>` (repeatable). This list names the servers the
-  // engine disables for autonomous agent dispatches. Default [] = inherit ALL
-  // (no behavior change). Per-agent override `agent.copilotAgentDisabledMcpServers`.
-  // Resolved through `shared.resolveCopilotAgentDisabledMcpServers(agent, engine)`.
-  // NOTE: `hermeticHarness` does NOT suppress these (it only strips `--add-dir`).
+  // P-mcp-storm — Copilot SPAWNS every server in its `mcp-config.json` on every
+  // process start and authenticates it. `--disable-mcp-server <name>` only hides
+  // a server's TOOLS from the model; it does NOT stop the server process (proven
+  // empirically — agents spawned azmcp/workiq even with the flag set), so any
+  // auth-requiring server pops a Microsoft sign-in window on EVERY agent spawn.
+  // The ONLY real lever is the CONFIG: a server absent from the config can't be
+  // spawned. The engine therefore points agents at a private COPILOT_HOME
+  // (`shared.resolveAgentCopilotHome`) whose mcp-config is a copy of the operator's
+  // `~/.copilot/mcp-config.json` MINUS the names in this list (see engine.js
+  // `_applyAgentCopilotHome`). Default [] = inherit ALL of the operator's MCP
+  // servers for agents (non-breaking). Add a name to disable it for agents only;
+  // the operator's interactive `~/.copilot` is never touched. Per-agent override
+  // `agent.copilotAgentDisabledMcpServers`. Resolved through
+  // `shared.resolveCopilotAgentDisabledMcpServers(agent, engine)`.
   copilotAgentDisabledMcpServers: [],
   ccUseWorkerPool: false,            // Sub-task C of W-mp2w003600196c51 (CC perf): when true AND CC runtime is copilot, _invokeCcStream routes through engine/cc-worker-pool.js (persistent `copilot --acp` per CC tab) instead of spawning a fresh CLI per turn. Off by default — opt-in feature flag. **Structurally copilot-only**: the pool spawns `copilot --acp` (Agent Client Protocol); Claude Code does not implement ACP, so resolveCcUseWorkerPool returns false on non-copilot CC runtimes even with explicit-true (W-mphlriic00095f69 — prevents silent runtime switch). Engine/agent dispatch path stays per-process regardless.
   maxBudgetUsd: undefined,       // fleet USD ceiling for --max-budget-usd (per-agent override: agents.<id>.maxBudgetUsd). Honors 0 via ?? so a literal cap of $0 works
@@ -3375,13 +3376,15 @@ function resolveAgentBareMode(agent, engine) {
 }
 
 // P-mcp-storm — Resolve the list of MCP server names to disable for spawned
-// Copilot agents (emitted as `--disable-mcp-server <name>`). Chain: per-agent
+// Copilot agents. The engine FILTERS these out of the agent's seeded
+// COPILOT_HOME mcp-config (engine.js `_applyAgentCopilotHome`) — a server absent
+// from the config can't be spawned, which is the only effective disable
+// (`--disable-mcp-server` does not stop the process). Chain: per-agent
 // `agent.copilotAgentDisabledMcpServers` → `engine.copilotAgentDisabledMcpServers`
 // → `[]` (inherit all). Tolerant of either an array OR a comma/whitespace-
 // separated string (Settings UI / `MINIONS_*` env deliver strings). Always
 // returns a deduped array of trimmed, non-empty strings. See ENGINE_DEFAULTS
-// for why this exists (Copilot loads ~/.copilot MCP config unconditionally;
-// `hermeticHarness` does NOT suppress it).
+// for the full rationale.
 function _normalizeMcpServerList(v) {
   if (v == null) return null;
   const raw = Array.isArray(v) ? v : String(v).split(/[\s,]+/);
@@ -5637,6 +5640,66 @@ function resolveProjectRootDir(localPath, minionsDir) {
   return fallback;
 }
 
+/**
+ * Resolve a stable, repo-EXTERNAL COPILOT_HOME for spawned copilot agents.
+ *
+ * Copilot loads `$COPILOT_HOME/mcp-config.json` and SPAWNS every server in it on
+ * every process start. `--disable-mcp-server <name>` only hides a server's tools
+ * from the model — it does NOT stop the server PROCESS from launching, so any
+ * server that does interactive auth (azure-kusto/azmcp, DevBox, workiq, loop, …)
+ * still pops a Microsoft sign-in window on EVERY agent spawn. With minions
+ * spawning agents continuously that is an unbounded popup storm.
+ *
+ * The only effective lever is to give agents a COPILOT_HOME whose mcp-config has
+ * NO user servers (the engine seeds `{"mcpServers":{}}` there). Copilot auth is
+ * unaffected — it uses GH_TOKEN / the OS credential store, not files under the
+ * home — and the operator's real `~/.copilot` (interactive copilot) is untouched.
+ *
+ * Placed on the MINIONS_DIR volume (copilot's session-store can grow to GBs, so
+ * keep it off a possibly-full system drive) but OUTSIDE the repo, at the drive
+ * root, so concurrent git branch switches in the working tree can never delete or
+ * dirty it. Stable path so copilot session resume (`--resume`) stays consistent
+ * across spawns. Falls back to the user home when no minionsDir is given.
+ */
+function resolveAgentCopilotHome(minionsDir) {
+  const base = minionsDir ? path.parse(path.resolve(String(minionsDir))).root : os.homedir();
+  return path.join(base, '.minions-agent-copilot-home');
+}
+
+// Seed the agent COPILOT_HOME's mcp-config (copy of `~/.copilot/mcp-config.json`
+// MINUS `engine.copilotAgentDisabledMcpServers`) and return the home path. This
+// is the single source of truth for "what MCP servers may a minions-spawned
+// copilot load." It is applied to EVERY copilot spawn path — agent dispatches
+// (engine), internal `llm.callLLM` calls (engine), and CC / doc-chat / the CC
+// worker pool (dashboard) — by setting `process.env.COPILOT_HOME` at the boot of
+// both processes, so every copilot CHILD inherits the filtered config. copilot
+// SPAWNS every server in its config and authenticates it (`--disable-mcp-server`
+// only hides tools), so any auth-requiring server pops a Microsoft window per
+// spawn — filtering the config is the only effective control. Idempotent: writes
+// only when the content changes (safe under concurrent callers). The operator's
+// real `~/.copilot` (interactive copilot) is never touched. Fail-open.
+function ensureAgentCopilotHome(minionsDir, engine) {
+  const home = resolveAgentCopilotHome(minionsDir);
+  try {
+    fs.mkdirSync(home, { recursive: true });
+    const disabled = new Set(resolveCopilotAgentDisabledMcpServers(null, engine));
+    let servers = {};
+    try {
+      const userCfgPath = path.join(os.homedir(), '.copilot', 'mcp-config.json');
+      const userCfg = JSON.parse(fs.readFileSync(userCfgPath, 'utf8').replace(/^/, ''));
+      for (const [name, def] of Object.entries(userCfg.mcpServers || {})) {
+        if (!disabled.has(name)) servers[name] = def;
+      }
+    } catch { servers = {}; /* no/unreadable user config → no MCPs */ }
+    const desired = JSON.stringify({ mcpServers: servers }, null, 2);
+    const cfgFile = path.join(home, 'mcp-config.json');
+    let current = null;
+    try { current = fs.readFileSync(cfgFile, 'utf8'); } catch {}
+    if (current !== desired) fs.writeFileSync(cfgFile, desired);
+  } catch { /* fail-open: leave whatever home/config exists */ }
+  return home;
+}
+
 // ── Spawn cwd vs worktree placement (W-mp73x32w000l143d) ──────────────────────
 // Work types that don't need a git worktree — they read repo state but don't
 // produce code changes. Centralized here so engine.js spawnAgent and any
@@ -8931,6 +8994,8 @@ module.exports = {
   parseWorktreePorcelain,
   assertWorktreeOutsideProject,
   resolveProjectRootDir,
+  resolveAgentCopilotHome,
+  ensureAgentCopilotHome,
   resolveSpawnPaths,
   validateWorkItemWorkdir,
   applyWorkdir,

package/engine.js

@@ -1886,6 +1886,35 @@ async function recoverPartialWorktree(rootDir, worktreePath, branchName, gitOpts
   }
 }
 
+// Seed a spawned agent's COPILOT_HOME mcp-config as a copy of the operator's
+// `~/.copilot/mcp-config.json` MINUS the servers in
+// `engine.copilotAgentDisabledMcpServers`, then point COPILOT_HOME at it.
+//
+// Why config-filtering and not `--disable-mcp-server`: copilot SPAWNS every
+// server in its config on startup and authenticates it; `--disable-mcp-server
+// <name>` only hides that server's TOOLS from the model, it does NOT stop the
+// server process. So any auth-requiring server (azure-kusto/azmcp, DevBox,
+// workiq, loop, teams…) pops a Microsoft sign-in window on EVERY agent spawn —
+// an unbounded popup storm at minions' spawn cadence. A server simply ABSENT
+// from the config can't be spawned, so filtering the config is the only real
+// disable lever.
+//
+// Default disabled list `[]` => agents inherit ALL of the operator's MCP servers
+// (non-breaking; matches interactive copilot). Add a name to disable it for
+// agents. COPILOT_HOME is copilot-specific; claude/codex ignore it, so this is
+// set unconditionally (no runtime.name branching, per the adapter contract).
+// Copilot auth is unaffected (GH_TOKEN / OS credential store); the operator's
+// real ~/.copilot is untouched. Best-effort/fail-open: any failure leaves the
+// inherited COPILOT_HOME so a hiccup never blocks a dispatch.
+function _applyAgentCopilotHome(childEnv) {
+  // Re-seed (picks up Settings changes to the disabled list) + stamp the env.
+  // process.env.COPILOT_HOME is also set at engine boot (see below) so the
+  // child would inherit it anyway; this is belt-and-suspenders + keeps the
+  // seed fresh per dispatch. See shared.ensureAgentCopilotHome.
+  try { childEnv.COPILOT_HOME = shared.ensureAgentCopilotHome(MINIONS_DIR, getConfig()?.engine); }
+  catch { /* leave inherited COPILOT_HOME untouched */ }
+}
+
 async function spawnAgent(dispatchItem, config) {
   const { id, agent: agentId, type, meta } = dispatchItem;
   // Resolve prompt — prefers sidecar file when dispatchItem._promptFile is set
@@ -3579,12 +3608,6 @@ async function spawnAgent(dispatchItem, config) {
   const resolvedModel = runtime.resolveModel(shared.resolveAgentModel(agentConfig, engineConfig));
   const resolvedMaxBudget = shared.resolveAgentMaxBudget(agentConfig, engineConfig);
   const resolvedBare = shared.resolveAgentBareMode(agentConfig, engineConfig);
-  // P-mcp-storm (opg#134 backport) — user-scope MCP servers to keep out of
-  // this agent dispatch. Copilot loads ~/.copilot/mcp-config.json
-  // unconditionally; the adapter re-emits these as --disable-mcp-server <name>.
-  // Other runtimes ignore the opt (their buildSpawnFlags don't read it), so no
-  // runtime.name branch here.
-  const resolvedDisabledMcpServers = shared.resolveCopilotAgentDisabledMcpServers(agentConfig, engineConfig);
   // P-49e1c8b7 — hermetic harness opt-out (per-agent override allowed).
   // When true, this dispatch:
   //   - skips Claude workspace .mcp.json pre-approval (preApproveWorkspaceMcps),
@@ -3648,7 +3671,6 @@ async function spawnAgent(dispatchItem, config) {
     disableBuiltinMcps: engineConfig.copilotDisableBuiltinMcps,
     suppressAgentsMd: engineConfig.copilotSuppressAgentsMd,
     reasoningSummaries: engineConfig.copilotReasoningSummaries,
-    disabledMcpServers: resolvedDisabledMcpServers,
   });
 
   // MCP servers: agents inherit from ~/.claude.json directly as Claude Code processes.
@@ -3725,6 +3747,9 @@ async function spawnAgent(dispatchItem, config) {
   // random localhost port (blank window). Belt-and-suspenders with dashboard.js's
   // stdout.isTTY gate.
   childEnv.MINIONS_NO_AUTO_OPEN = '1';
+  // MCP-free copilot config so agents never pop a per-spawn Microsoft auth
+  // window — see _applyAgentCopilotHome / shared.resolveAgentCopilotHome.
+  _applyAgentCopilotHome(childEnv);
 
   if (getRepoHost(project) === 'ado') {
     // Inject cached ADO token so ADO agents skip re-authentication (#998).
@@ -4205,7 +4230,6 @@ async function spawnAgent(dispatchItem, config) {
         disableBuiltinMcps: engineConfig?.copilotDisableBuiltinMcps,
         suppressAgentsMd: engineConfig?.copilotSuppressAgentsMd,
         reasoningSummaries: engineConfig?.copilotReasoningSummaries,
-        disabledMcpServers: resolvedDisabledMcpServers,
       });
       if (!resumeArgs.includes('--resume')) {
         log('warn', `Steering: runtime ${runtime.name} did not accept session resume — skipping for ${agentId}`);
@@ -4236,6 +4260,8 @@ async function spawnAgent(dispatchItem, config) {
       // W-mqef-dashboard-tty — same browser-popup suppression on steering resume
       // (see the initial spawn site). Agents must never auto-open a browser.
       childEnv.MINIONS_NO_AUTO_OPEN = '1';
+      // Same MCP-free copilot home on steering resume (see the initial spawn site).
+      _applyAgentCopilotHome(childEnv);
       if (getRepoHost(project) === 'ado') {
         // Inject cached ADO token for steering session too (#998)
         try {
@@ -10232,6 +10258,14 @@ module.exports = {
 // ─── Entrypoint ─────────────────────────────────────────────────────────────
 
 if (require.main === module) {
+  // Every copilot this process spawns — agent dispatches AND internal
+  // `llm.callLLM` calls (consolidation, classification, meetings, …) — inherits
+  // this process's COPILOT_HOME, so point it at the seeded, MCP-filtered home.
+  // Without this, those `direct:true` copilot calls load the operator's full
+  // `~/.copilot` stack and pop a Microsoft auth window per call. The dashboard
+  // sets the same at its own boot for CC / doc-chat / the CC worker pool.
+  // See shared.ensureAgentCopilotHome. Fail-open.
+  try { process.env.COPILOT_HOME = shared.ensureAgentCopilotHome(MINIONS_DIR, getConfig()?.engine); } catch {}
   const { handleCommand } = require('./engine/cli');
   const [cmd, ...args] = process.argv.slice(2);
   handleCommand(cmd, args);

package/package.json

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