@yemi33/minions 0.1.2238 → 0.1.2240

package/engine.js

@@ -1886,6 +1886,50 @@ 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) {
+  try {
+    const home = shared.resolveAgentCopilotHome(MINIONS_DIR);
+    fs.mkdirSync(home, { recursive: true });
+    const disabled = new Set(shared.resolveCopilotAgentDisabledMcpServers(null, getConfig()?.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 → agents get no MCPs */ }
+    // Write only when the content changes — keeps concurrent spawns from racing
+    // on the shared file (the engine-level list is identical across agents).
+    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);
+    childEnv.COPILOT_HOME = home;
+  } 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
@@ -2257,10 +2301,15 @@ async function spawnAgent(dispatchItem, config) {
   //   cwd = project.localPath, worktreeRootDir = null, liveMode = true.
   // Instead of creating an engine-managed worktree we run prepareLiveCheckout
   // in-place: it validates a clean tree and then checks out (or creates) the
-  // target branch. On dirty refusal we write an inbox alert, stamp
+  // target branch. On a CONFIRMED dirty refusal (the helper returns
+  // { ok:false, reason:'dirty', dirtyFiles:[…] }) we write an inbox alert, stamp
   // `_pendingReason: 'live_checkout_dirty'` on the WI, complete the dispatch
   // non-retryably with FAILURE_CLASS.LIVE_CHECKOUT_DIRTY, and return — the
-  // engine never runs `git reset`/`git clean` against the operator tree.
+  // engine never runs `git reset`/`git clean` against the operator tree. If the
+  // helper instead THROWS (guard/ref-validation/transient git error), that is
+  // NOT proof of a dirty tree (#305): we complete with the separate
+  // FAILURE_CLASS.LIVE_CHECKOUT_FAILED, which is retryable with bounded backoff
+  // so racy branch-lock handoff or a transient git failure auto-recovers.
   // On success we fall through; the worktree-creation block below is gated
   // on `!liveMode`, so it never runs, and downstream cleanup paths
   // (worktreePool.returnToPool, worktree-gc.gcDispatchWorktreeIfOrphan) are
@@ -2284,14 +2333,22 @@ async function spawnAgent(dispatchItem, config) {
         log: (msg, lvl) => log(lvl || 'info', msg),
       });
     } catch (liveErr) {
-      log('error', `spawnAgent: live-checkout helper failed for ${id}: ${liveErr.message}`);
+      // #305: A THROWN helper/git error is NOT proof the worktree is dirty.
+      // Classify it as LIVE_CHECKOUT_FAILED (transient/pre-spawn) and let the
+      // dispatch retry path decide retryability via isRetryableFailureReason —
+      // racy branch-lock handoff, a just-finished sibling dispatch, or a
+      // transient `git status`/`rev-parse`/`checkout` failure usually clears on
+      // the next attempt (bounded by ENGINE_DEFAULTS.maxRetries). Do NOT stamp
+      // _pendingReason: 'live_checkout_dirty' or write a dirty-files alert here —
+      // those belong to the confirmed-dirty result path below.
+      log('error', `spawnAgent: live-checkout helper threw for ${id}: ${liveErr.message}`);
       _cleanupPromptFiles();
       completeDispatch(
         id,
         DISPATCH_RESULT.ERROR,
         `live-checkout failed: ${liveErr.message}`.slice(0, 800),
-        'Live-checkout helper threw before agent spawn; non-retryable until the underlying git state or invocation is fixed.',
-        { failureClass: FAILURE_CLASS.LIVE_CHECKOUT_DIRTY, agentRetryable: false },
+        'Live-checkout helper threw before agent spawn (not proof of a dirty tree). Auto-retried with bounded backoff; transient git/branch-lock state usually clears on the next attempt.',
+        { failureClass: FAILURE_CLASS.LIVE_CHECKOUT_FAILED },
       );
       cleanupTempAgent(agentId);
       return null;
@@ -2342,7 +2399,96 @@ async function spawnAgent(dispatchItem, config) {
       cleanupTempAgent(agentId);
       return null;
     }
+    // P-c5a1f3b8: mid-operation / detached-HEAD refusal. The tree is clean
+    // (the dirty branch above already bailed) but the branch op cannot proceed
+    // because the operator is mid-merge/rebase/cherry-pick/revert or sitting on
+    // a detached HEAD. Distinct operator condition from `dirty` → distinct
+    // FAILURE_CLASS (LIVE_CHECKOUT_MID_OPERATION) and distinct recovery
+    // guidance. The engine NEVER runs git reset/clean/stash or aborts the
+    // operator's in-progress operation — it refuses and tells the operator how
+    // to recover with their own commands.
+    if (_liveResult && _liveResult.ok === false
+        && (_liveResult.reason === 'mid-operation' || _liveResult.reason === 'detached-head')) {
+      const _isMidOp = _liveResult.reason === 'mid-operation';
+      const _op = _isMidOp ? (_liveResult.op || 'operation') : null;
+      const _sha = _isMidOp ? null : (_liveResult.sha || '(unknown)');
+      const _alertBody = [
+        _isMidOp
+          ? '# Live-checkout blocked: in-progress git operation'
+          : '# Live-checkout blocked: detached HEAD',
+        '',
+        `**Project:** ${project.name || '(unknown)'}`,
+        `**Local path:** ${cwd}`,
+        `**Branch:** ${branchName}`,
+        `**Work item:** ${_wiIdForAlert}`,
+        `**Dispatch:** ${id}`,
+        '',
+        _isMidOp
+          ? `The engine refused to spawn the agent because \`${cwd}\` has an in-progress **${_op}**. Live-checkout mode runs in your project directly — the engine never \`git reset\`, \`git clean\`, or aborts an operation in your tree.`
+          : `The engine refused to spawn the agent because \`${cwd}\` is in a **detached-HEAD** state (HEAD at \`${_sha}\`). Branching off a detached HEAD would strand your anonymous commits, so the engine refuses rather than risk losing work.`,
+        '',
+        '## Recovery',
+        '',
+        _isMidOp
+          ? `Finish or abort the in-progress ${_op} with your own git commands (e.g. \`git ${_op} --continue\` or \`git ${_op} --abort\`), or checkout a branch, then re-dispatch the work item.`
+          : 'Checkout a branch (e.g. `git checkout <branch>`) so HEAD points at a named ref, then re-dispatch the work item. If you have commits on the detached HEAD you want to keep, create a branch first (`git branch <name>`).',
+      ].join('\n');
+      try { writeInboxAlert(`live-checkout-blocked-${_wiIdForAlert}`, _alertBody); }
+      catch (e) { log('warn', `live-checkout: writeInboxAlert failed: ${e.message}`); }
+      const _pendingReason = _isMidOp ? 'live_checkout_mid_operation' : 'live_checkout_detached_head';
+      try {
+        const _wiPath = resolveWorkItemPath(dispatchItem.meta);
+        if (_wiPath && dispatchItem.meta?.item?.id) {
+          mutateJsonFileLocked(_wiPath, (data) => {
+            if (!Array.isArray(data)) return data;
+            const wi = data.find(i => i && i.id === dispatchItem.meta.item.id);
+            if (wi) wi._pendingReason = _pendingReason;
+            return data;
+          });
+        }
+      } catch (e) { log('warn', `live-checkout: failed to stamp _pendingReason: ${e.message}`); }
+      const _shortMsg = _isMidOp
+        ? `live-checkout blocked: in-progress ${_op} in ${cwd}`
+        : `live-checkout blocked: detached HEAD (${_sha}) in ${cwd}`;
+      const _guidance = _isMidOp
+        ? `Live-checkout mode cannot switch/create a branch while a ${_op} is in progress; the engine never aborts operator operations. Finish/abort the ${_op} or checkout a branch, then re-dispatch.`
+        : 'Live-checkout mode cannot branch off a detached HEAD without risking operator commits; the engine never moves HEAD for you. Checkout a branch, then re-dispatch.';
+      log('error', `spawnAgent: ${_shortMsg}`);
+      _cleanupPromptFiles();
+      completeDispatch(
+        id,
+        DISPATCH_RESULT.ERROR,
+        _shortMsg.slice(0, 800),
+        _guidance,
+        { failureClass: FAILURE_CLASS.LIVE_CHECKOUT_MID_OPERATION, agentRetryable: false },
+      );
+      cleanupTempAgent(agentId);
+      return null;
+    }
     log('info', `live-checkout: ${_liveResult.created ? 'created' : 'switched to'} branch ${branchName} in ${cwd} (in-place; no worktree)`);
+    // P-c5a1f3b8: persist the operator's original ref on the dispatch record so
+    // the dispatch-end auto-restore (P-d9e6b2c4) can return the tree to where the
+    // operator started — even after an engine restart + re-attach, where the
+    // spawnAgent closure is gone and only the persisted dispatch record survives
+    // (same pattern as resolveHarnessPropagated at engine/lifecycle.js:3576).
+    if (_liveResult.originalRef) {
+      dispatchItem.originalRef = _liveResult.originalRef;
+      dispatchItem.originalRefType = _liveResult.originalRefType || 'branch';
+      try {
+        mutateDispatch((dispatch) => {
+          for (const queue of ['pending', 'active', 'completed']) {
+            const arr = Array.isArray(dispatch?.[queue]) ? dispatch[queue] : null;
+            if (!arr) continue;
+            const found = arr.find(d => d && d.id === id);
+            if (found) {
+              found.originalRef = _liveResult.originalRef;
+              found.originalRefType = _liveResult.originalRefType || 'branch';
+            }
+          }
+          return dispatch;
+        });
+      } catch (e) { log('warn', `live-checkout: failed to persist originalRef for ${id}: ${e.message}`); }
+    }
   }
 
   if (branchName && !liveMode) {
@@ -3477,12 +3623,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),
@@ -3546,7 +3686,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.
@@ -3623,6 +3762,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).
@@ -3814,6 +3956,15 @@ async function spawnAgent(dispatchItem, config) {
     }
 
     _phaseT.spawnCallStart = Date.now();
+    // P-c5a1f3b8 (Item D — live-mode push/PR-create cwd guard): in live mode
+    // worktreePath stays null, so `cwd` here is project.localPath (it is never
+    // reassigned to a worktree by the `if (worktreePath ...)` block above). The
+    // agent's `git push -u origin <branch>` and PR-create therefore run in-place
+    // against the operator's checkout. This cwd MUST NEVER be null for a mutating
+    // live dispatch — shared.resolveSpawnPaths returns cwd === project.localPath
+    // for live mode (regression-guarded in
+    // test/unit/spawn-agent-live-mode-wiring.test.js). A null cwd would push from
+    // the engine's own process dir and open the PR off the wrong tree.
     // `detached: true` puts the agent in its own process group (POSIX) / job
     // object (Windows), so when the engine dies — gracefully via stop, abruptly
     // via taskkill, or because of a crash — the agent keeps running and can be
@@ -4094,7 +4245,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}`);
@@ -4125,6 +4275,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 {
@@ -4946,6 +5098,43 @@ async function spawnAgent(dispatchItem, config) {
       }
     }
 
+    // ── P-d9e6b2c4 — live-mode dispatch-end auto-restore + terminal-failure
+    //    notify. Runs on EVERY terminal result for a live-mode dispatch: the
+    //    agent ran in-place in the operator's checkout, so switch the tree back
+    //    to the ref it was on before (see engine/live-checkout.js#
+    //    restoreLiveCheckoutAtDispatchEnd). The worktree-GC block above no-ops
+    //    in live mode (worktreePath===null); this is its live-mode counterpart.
+    //    originalRef was captured by prepareLiveCheckout and persisted on the
+    //    dispatch record at branch-resolution time (P-c5a1f3b8); the in-memory
+    //    closure copy is authoritative here. The engine-restart reattach path
+    //    fires the same helper from the persisted record in engine/cli.js. The
+    //    restore is a plain `git checkout <originalRef>` — never --force/reset/
+    //    clean/stash — and is best-effort: a thrown restore never alters the
+    //    dispatch result.
+    if (liveMode && branchName) {
+      try {
+        const _liveRestore = require('./engine/live-checkout');
+        await _liveRestore.restoreLiveCheckoutAtDispatchEnd({
+          localPath: cwd,
+          branchName,
+          originalRef: dispatchItem.originalRef || '',
+          originalRefType: dispatchItem.originalRefType || 'branch',
+          dispatchId: id,
+          projectName: project?.name,
+          isTerminalFailure: effectiveResult !== DISPATCH_RESULT.SUCCESS,
+          resultLabel: errorReason || effectiveResult,
+          gitOpts: _gitOpts,
+          log,
+          writeInboxAlert,
+        });
+      } catch (restoreErr) {
+        // restoreLiveCheckoutAtDispatchEnd swallows its own errors; this guard
+        // is belt-and-suspenders so a require() hiccup can never break the
+        // dispatch-completion path that follows.
+        log('warn', `live-checkout: dispatch-end restore wiring threw for ${id}: ${restoreErr.message}`);
+      }
+    }
+
     completeDispatch(id, effectiveResult, errorReason, resultSummary, completeOpts);
 
     // W-mpbpexrg00110661 — surface managed-spawn partial-healthcheck failures

package/package.json

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