@yemi33/minions 0.1.2241 → 0.1.2243

package/bin/minions.js

@@ -1358,6 +1358,15 @@ ${fs.existsSync(path.join(PKG_ROOT, '.git')) ? `
   // Clear stale beacons AFTER the kill so the old dashboard's last writes
   // can't repopulate the file in the gap between clear and shutdown.
   _clearDashboardBrowserState(MINIONS_HOME);
+  // Respawn-race guard: the watchdog (or a surviving supervisor) can spawn a
+  // fresh engine/dashboard during the kill→spawn window — those become ORPHANS
+  // the new stack never reaps, and orphan engines keep dispatching agents +
+  // spawning copilot (the root of the recurring multi-engine / MCP-auth storms).
+  // stop-intent is STILL set here, so any respawn has already stood down or is
+  // about to; reap once more so the stack we spawn below is the ONLY one. Scoped
+  // by command-line to engine/dashboard/supervisor — never touches agent/copilot
+  // children, preserving the re-attach invariant.
+  killMinionsProcesses(['engine.js', 'dashboard.js', 'supervisor.js']);
   // Clear stop-intent so the freshly-spawned supervisor resumes guarding.
   clearStopIntent();
   spawnFullStackAndVerify({ rest, forceOpen, dashWasUp, restartStartMs });

package/engine/live-checkout.js

@@ -125,20 +125,25 @@ async function prepareLiveCheckout(opts = {}) {
   const exists = (typeof _exists === 'function') ? _exists : fs.existsSync;
   const baseOpts = { cwd: localPath, ...(gitOpts || {}) };
 
-  // ── Step 1: git status --porcelain. Bail early on dirty tree. ─────────
-  // Porcelain format begins each line with a two-char XY status code (e.g.
+  // ── Step 1: git status --porcelain=v1 -b. Bail early on dirty tree. ─────
+  // Porcelain v1 -b adds a `## <branch>` header line as the first output line
+  // so callers get branch diagnostics for free alongside the file-status lines.
+  // The file-status lines still use the two-char XY status code (e.g.
   // " M file.js", "?? new.js", "MM stage+unstage.js"). The leading space on
   // unstaged-only lines is SIGNIFICANT, so we split first and strip ONLY
-  // trailing whitespace/CR per line — outer-trimming the whole blob would
-  // eat the leading XY space on the first line.
-  const statusRaw = await git(['status', '--porcelain'], baseOpts);
+  // trailing whitespace/CR per line — outer-trimming the whole blob would eat
+  // the leading XY space on the first line. The `## ` header is separated out
+  // before the dirtyFiles check so callers receive it as `branchInfo`.
+  const statusRaw = await git(['status', '--porcelain=v1', '-b'], baseOpts);
   const statusStr = typeof statusRaw === 'string' ? statusRaw : '';
-  const dirtyFiles = statusStr
+  const statusLines = statusStr
     .split(/\r?\n/)
     .map((line) => line.replace(/\s+$/, ''))
     .filter((line) => line.length > 0);
+  const branchInfo = statusLines.find((line) => line.startsWith('## ')) || '';
+  const dirtyFiles = statusLines.filter((line) => !line.startsWith('## '));
   if (dirtyFiles.length > 0) {
-    return { ok: false, reason: 'dirty', dirtyFiles };
+    return { ok: false, reason: 'dirty', dirtyFiles, branchInfo };
   }
 
   // ── Step 2: mid-operation / detached-HEAD preflight (P-b2e8d4a6). ──────

package/engine/shared.js

@@ -5666,6 +5666,30 @@ function resolveAgentCopilotHome(minionsDir) {
   return path.join(base, '.minions-agent-copilot-home');
 }
 
+/**
+ * Derive a scratch/temp base dir on the same volume agent work already lives on
+ * — the configured worktree location (engine.worktreeRoot, default
+ * `../worktrees`). Agents (copilot/node/git + JVM-based MCP servers) write heavy
+ * temp under %TEMP% / $TMPDIR; when that resolves to a full system drive (e.g.
+ * C:), operations thrash or fail and routinely overrun the CLI's per-command
+ * timeout, surfacing to the operator as "Operation cancelled". Anchoring agent
+ * temp next to the worktrees keeps scratch on the operator's work volume with NO
+ * config knob and NO hardcoded path — it simply follows wherever worktrees
+ * already go (a location the operator already placed off the system drive).
+ *
+ * Returns an absolute dir path, or null when no anchor can be resolved — callers
+ * MUST treat null as "leave the inherited TEMP untouched" (fail-open).
+ */
+function resolveAgentTempBaseDir(project, engine, minionsDir) {
+  let projectRoot;
+  try { projectRoot = resolveProjectRootDir(project && project.localPath, minionsDir); }
+  catch { return null; }
+  const wtRel = (engine && engine.worktreeRoot) || ENGINE_DEFAULTS.worktreeRoot;
+  let anchor;
+  try { anchor = path.resolve(projectRoot, wtRel); } catch { return null; }
+  return path.join(anchor, '.agent-temp');
+}
+
 // 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
@@ -8995,6 +9019,7 @@ module.exports = {
   assertWorktreeOutsideProject,
   resolveProjectRootDir,
   resolveAgentCopilotHome,
+  resolveAgentTempBaseDir,
   ensureAgentCopilotHome,
   resolveSpawnPaths,
   validateWorkItemWorkdir,

package/engine.js

@@ -1915,6 +1915,25 @@ function _applyAgentCopilotHome(childEnv) {
   catch { /* leave inherited COPILOT_HOME untouched */ }
 }
 
+// Point a spawned agent's TEMP/TMP/TMPDIR at a scratch dir on the worktree
+// volume instead of the (often full) system drive — see
+// shared.resolveAgentTempBaseDir. copilot/node/git + JVM-based MCP servers write
+// heavy temp there; on a full C: that thrashes and overruns the CLI's per-command
+// timeout ("Operation cancelled"). Best-effort + fail-open: any resolution/mkdir
+// failure leaves the inherited TEMP in place. Sets all three vars to cover
+// Windows (TEMP/TMP) and POSIX (TMPDIR).
+function _applyAgentTempEnv(childEnv, project) {
+  try {
+    const agentTmp = shared.resolveAgentTempBaseDir(project, getConfig()?.engine, MINIONS_DIR);
+    if (agentTmp) {
+      fs.mkdirSync(agentTmp, { recursive: true });
+      childEnv.TEMP = agentTmp;
+      childEnv.TMP = agentTmp;
+      childEnv.TMPDIR = agentTmp;
+    }
+  } catch { /* leave inherited TEMP untouched */ }
+}
+
 async function spawnAgent(dispatchItem, config) {
   const { id, agent: agentId, type, meta } = dispatchItem;
   // Resolve prompt — prefers sidecar file when dispatchItem._promptFile is set
@@ -2340,6 +2359,14 @@ async function spawnAgent(dispatchItem, config) {
     }
     if (_liveResult && _liveResult.ok === false && _liveResult.reason === 'dirty') {
       const _dirtyFiles = Array.isArray(_liveResult.dirtyFiles) ? _liveResult.dirtyFiles : [];
+      const _branchInfo = typeof _liveResult.branchInfo === 'string' ? _liveResult.branchInfo : '';
+      // #329: Check if this is a retry after a prior dirty failure. If the WI
+      // already carries `_pendingReason:'live_checkout_dirty'` from a previous
+      // dispatch, the dirty state is persistent (user-owned) and we mark it
+      // non-retryable. First-attempt dirty failures are retried once so a
+      // transient or engine-owned dirty state can clear before permanently
+      // failing the plan item.
+      const _alreadyDirtyFailed = dispatchItem.meta?.item?._pendingReason === 'live_checkout_dirty';
       const _alertBody = [
         '# Live-checkout refused: dirty worktree',
         '',
@@ -2348,16 +2375,19 @@ async function spawnAgent(dispatchItem, config) {
         `**Branch:** ${branchName}`,
         `**Work item:** ${_wiIdForAlert}`,
         `**Dispatch:** ${id}`,
+        ...(_branchInfo ? ['', `**Current checkout:** \`${_branchInfo}\``] : []),
         '',
         `The engine refused to spawn the agent because \`${cwd}\` has uncommitted changes. Live-checkout mode runs in your project directly — the engine never \`git reset\` or \`git clean\` your tree.`,
         '',
-        '## Dirty files (`git status --porcelain`)',
+        '## Dirty files (`git status --porcelain=v1 -b`)',
         '',
         '```',
         ...(_dirtyFiles.length > 0 ? _dirtyFiles : ['(none reported)']),
         '```',
         '',
-        'Recovery: commit, stash, or discard the changes in the project checkout, then re-dispatch the work item.',
+        _alreadyDirtyFailed
+          ? 'Recovery: dirty state persisted across retries — commit, stash, or discard the changes in the project checkout, then re-dispatch the work item.'
+          : 'This dispatch will be retried once automatically in case the dirty state is transient. If dirty again on retry, commit, stash, or discard the changes, then re-dispatch.',
       ].join('\n');
       try { writeInboxAlert(`live-checkout-dirty-${_wiIdForAlert}`, _alertBody); }
       catch (e) { log('warn', `live-checkout: writeInboxAlert failed: ${e.message}`); }
@@ -2372,14 +2402,19 @@ async function spawnAgent(dispatchItem, config) {
           });
         }
       } catch (e) { log('warn', `live-checkout: failed to stamp _pendingReason: ${e.message}`); }
+      const _dirtyMsg = _branchInfo
+        ? `live-checkout refused: ${_dirtyFiles.length} dirty file(s) in ${cwd} (${_branchInfo.replace(/^## /, '')})`
+        : `live-checkout refused: ${_dirtyFiles.length} dirty file(s) in ${cwd}`;
       log('error', `spawnAgent: live-checkout refused for ${id}: ${_dirtyFiles.length} dirty file(s) in ${cwd}`);
       _cleanupPromptFiles();
       completeDispatch(
         id,
         DISPATCH_RESULT.ERROR,
-        `live-checkout refused: ${_dirtyFiles.length} dirty file(s) in ${cwd}`.slice(0, 800),
-        'Live-checkout mode requires a clean tree; engine refuses to overwrite operator changes. Commit/stash/discard and re-dispatch.',
-        { failureClass: FAILURE_CLASS.LIVE_CHECKOUT_DIRTY, agentRetryable: false },
+        _dirtyMsg.slice(0, 800),
+        _alreadyDirtyFailed
+          ? 'Live-checkout dirty state persisted across retries — operator must commit/stash/discard before re-dispatch.'
+          : 'Live-checkout dirty tree retried once automatically; if dirty persists, operator must commit/stash/discard.',
+        { failureClass: FAILURE_CLASS.LIVE_CHECKOUT_DIRTY, agentRetryable: !_alreadyDirtyFailed },
       );
       cleanupTempAgent(agentId);
       return null;
@@ -3750,6 +3785,9 @@ async function spawnAgent(dispatchItem, config) {
   // MCP-free copilot config so agents never pop a per-spawn Microsoft auth
   // window — see _applyAgentCopilotHome / shared.resolveAgentCopilotHome.
   _applyAgentCopilotHome(childEnv);
+  // Keep agent scratch off a (possibly full) system drive — anchors TEMP/TMP to
+  // the worktree volume. See _applyAgentTempEnv / shared.resolveAgentTempBaseDir.
+  _applyAgentTempEnv(childEnv, project);
 
   if (getRepoHost(project) === 'ado') {
     // Inject cached ADO token so ADO agents skip re-authentication (#998).
@@ -4262,6 +4300,8 @@ async function spawnAgent(dispatchItem, config) {
       childEnv.MINIONS_NO_AUTO_OPEN = '1';
       // Same MCP-free copilot home on steering resume (see the initial spawn site).
       _applyAgentCopilotHome(childEnv);
+      // Same agent-scratch redirect on steering resume.
+      _applyAgentTempEnv(childEnv, project);
       if (getRepoHost(project) === 'ado') {
         // Inject cached ADO token for steering session too (#998)
         try {

package/package.json

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