@yemi33/minions 0.1.2138 → 0.1.2139

package/engine/dispatch.js

@@ -758,6 +758,7 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
             [FAILURE_CLASS.EMPTY_OUTPUT]: 'agent produced no output \u2014 likely crashed on startup',
             [FAILURE_CLASS.BUILD_FAILURE]: 'build/test/lint failure in output',
             [FAILURE_CLASS.MERGE_CONFLICT]: 'merge conflict',
+            [FAILURE_CLASS.DEPENDENCY_MERGE_SETUP]: 'dependency merge setup failed',
             [FAILURE_CLASS.MAX_TURNS]: 'reached max turn limit',
             [FAILURE_CLASS.TIMEOUT]: 'timed out waiting for agent',
             [FAILURE_CLASS.SPAWN_ERROR]: 'agent process failed to start',

package/engine/shared.js

@@ -3519,6 +3519,7 @@ const FAILURE_CLASS = {
   WORKTREE_PREFLIGHT: 'worktree-preflight', // Pre-spawn worktree validation rejected (nested-in-project, drive-root collapse) — never retryable
   WORKTREE_DIRTY: 'worktree-dirty',         // #2996: reused worktree had uncommitted edits and the engine could not auto-heal (or already quarantined). Non-retryable for this dispatch — next discovery cycle creates a fresh worktree.
   WORKTREE_DIVERGENT: 'worktree-divergent', // #2996: reused worktree's local branch was N commits ahead of origin (unsafe to reset, may contain unpushed agent work). Engine quarantined the worktree + backed up the local ref; non-retryable for this dispatch.
+  DEPENDENCY_MERGE_SETUP: 'dependency-merge-setup', // Dependency pre-merge plumbing (stash/status/reset) failed before a real file conflict was verified. Retryable so a fresh worktree can recover.
   INVALID_KEEP_PROCESSES_WORKDIR: 'invalid-keep-processes-workdir', // W-mp6k7ywi000fa33c: keep-pids.json declared a cwd that is not a real git worktree (likely a selective copy of the repo) — never retryable; agent must rerun in a real worktree
   INVALID_KEEP_PROCESSES_SCHEMA: 'invalid-keep-processes-schema', // W-mp7i902u000l991f: keep-pids.json failed validation for a reason other than workdir (pids-missing, ttl-too-long, expires_at-missing, pids-too-many, port-invalid, etc.) — agent wrote the wrong shape; never retryable until they fix the file
   INVALID_MANAGED_SPAWN: 'invalid-managed-spawn', // P-7a3b1c92: agents/<id>/managed-spawn.json failed validator (bad schema, broken workdir, executable/env not on allowlist, healthcheck shape wrong). Engine refuses to spawn any spec — agent must fix file; never retryable as-is.

package/engine.js

@@ -208,6 +208,51 @@ function parseConflictFiles(mergeOutput) {
   return [...new Set(files)]; // dedupe
 }
 
+function gitOutputToString(result) {
+  if (result == null) return '';
+  if (Buffer.isBuffer(result)) return result.toString();
+  if (typeof result === 'string') return result;
+  if (result.stdout != null) return gitOutputToString(result.stdout);
+  return String(result);
+}
+
+function gitErrorOutput(err) {
+  return [
+    err?.message || '',
+    gitOutputToString(err?.stdout),
+    gitOutputToString(err?.stderr),
+  ].filter(Boolean).join('\n');
+}
+
+async function listUnmergedFiles(worktreePath, gitOpts = {}) {
+  try {
+    const out = await shared.shellSafeGit(['diff', '--name-only', '--diff-filter=U'], { ...gitOpts, cwd: worktreePath });
+    return gitOutputToString(out).split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+  } catch (e) {
+    log('warn', `Failed to inspect unmerged files in ${worktreePath}: ${e.message}`);
+    return [];
+  }
+}
+
+function classifyDepMergeFailureOutput(errOutput, unmergedFiles = []) {
+  const output = String(errOutput || '');
+  const files = Array.isArray(unmergedFiles) ? unmergedFiles.filter(Boolean) : [];
+  const conflictFiles = files.length > 0 ? files : parseConflictFiles(output);
+  const hasConflictSignal = files.length > 0
+    || /\bCONFLICT \(/.test(output)
+    || /Automatic merge failed/i.test(output)
+    || /fix conflicts/i.test(output)
+    || /you have unmerged paths/i.test(output);
+  const stashPlumbingFailed = /(?:fatal:\s*)?stash failed/i.test(output)
+    || /cannot save.*stash/i.test(output)
+    || /could not.*stash/i.test(output);
+  return {
+    isConflict: hasConflictSignal,
+    isPlumbingFailure: stashPlumbingFailed && !hasConflictSignal,
+    conflictFiles: hasConflictSignal ? conflictFiles : [],
+  };
+}
+
 // Build the work item used by the dep-merge-failure auto-queue path
 // (W-mpcwojgr000a0244). Routes the conflict-fix through the shared-branch
 // dispatch path (`branchStrategy: 'shared-branch'` + `featureBranch:
@@ -2029,6 +2074,8 @@ async function spawnAgent(dispatchItem, config) {
           let depMergeFailed = false;
           let depConflictBranch = null; // track which dep branch caused the conflict
           let depConflictFiles = [];    // conflicting file names parsed from git output
+          let depMergeSetupFailed = false;
+          let depMergeSetupReason = '';
           // W-mpcuc8i80003a7b3 — track whether ANY git op in the dep phase
           // failed with an ADO auth signature. If so, we escalate as
           // FAILURE_CLASS.AUTH (non-retryable + dedup'd inbox alert) instead
@@ -2186,14 +2233,18 @@ async function spawnAgent(dispatchItem, config) {
           let stashed = false;
           if (!depMergeFailed && !skipDepMerge && prunedDeps.length > 0) {
             try {
-              const statusOut = (await shared.shellSafeGit(['status', '--porcelain'], { ..._gitOpts, cwd: worktreePath })).stdout.toString().trim();
+              const statusOut = gitOutputToString(await shared.shellSafeGit(['status', '--porcelain'], { ..._gitOpts, cwd: worktreePath })).trim();
               if (statusOut) {
                 await shared.shellSafeGit(['stash', 'push', '--include-untracked', '-m', 'engine: stash before dep re-merge'], { ..._gitOpts, cwd: worktreePath });
                 stashed = true;
                 log('info', `Stashed uncommitted changes in ${branchName} before dep merge`);
               }
             } catch (stashErr) {
-              log('warn', `Failed to stash changes in ${branchName} before dep merge: ${stashErr.message}`);
+              const stashMsg = gitErrorOutput(stashErr);
+              depMergeFailed = true;
+              depMergeSetupFailed = true;
+              depMergeSetupReason = `Dependency merge setup failed while stashing local changes in ${branchName}: ${stashMsg || stashErr.message}`;
+              log('warn', depMergeSetupReason);
             }
           }
           if (!depMergeFailed && !skipDepMerge) {
@@ -2222,41 +2273,49 @@ async function spawnAgent(dispatchItem, config) {
                   }
                   log('info', `Successfully re-merged all ${prunedDeps.length} dep branches after reset for ${branchName}`);
                 } catch (resetErr) {
-                  const errOutput = (resetErr.message || '') + '\n' + (resetErr.stdout?.toString?.() || '') + '\n' + (resetErr.stderr?.toString?.() || '');
+                  const errOutput = gitErrorOutput(resetErr);
                   log('warn', `Failed to reset and re-merge deps for ${branchName}: ${resetErr.message}`);
                   if (adoGitAuth.isAdoAuthFailure(resetErr)) _depAuthFailed = true;
                   try { await shared.shellSafeGit(['merge', '--abort'], { ..._gitOpts, cwd: worktreePath }); } catch (_) { /* no merge in progress */ }
+                  const unmergedFiles = await listUnmergedFiles(worktreePath, _gitOpts);
+                  const depFailure = classifyDepMergeFailureOutput(errOutput, unmergedFiles);
+                  if (depFailure.isPlumbingFailure) {
+                    depMergeSetupFailed = true;
+                    depMergeSetupReason = `Dependency merge setup failed in engine git plumbing for ${branchName}: ${errOutput.split('\n').find(Boolean) || resetErr.message}`;
+                  }
                   // Post-mortem: incremental simulation to identify which dep caused the conflict (#958)
                   // Uses same chained merge-tree approach as pre-flight to catch inter-dep conflicts
                   const pmMainRef = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
-                  try {
-                    const sim = await preflightMergeSimulation(prunedDeps, pmMainRef, _gitOpts, rootDir);
-                    if (!sim.ok) {
-                      depConflictBranch = sim.conflictBranch;
-                      depConflictFiles = sim.conflictFiles;
-                      _isInterDepConflict = sim.isInterDep;
-                      _preflightConflictPrev = sim.prevBranch;
+                  if (!depMergeSetupFailed || depFailure.isConflict) {
+                    try {
+                      const sim = await preflightMergeSimulation(prunedDeps, pmMainRef, _gitOpts, rootDir);
+                      if (!sim.ok) {
+                        depConflictBranch = sim.conflictBranch;
+                        depConflictFiles = sim.conflictFiles;
+                        _isInterDepConflict = sim.isInterDep;
+                        _preflightConflictPrev = sim.prevBranch;
+                      }
+                    } catch (_simErr) {
+                      // Fallback: old per-branch isolation check via 3-arg git merge-tree
+                      for (const { branch: reBranch2 } of prunedDeps) {
+                        try {
+                          const mainRef2 = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
+                          const mergeBase = gitOutputToString(await shared.shellSafeGit(['merge-base', `origin/${mainRef2}`, `origin/${reBranch2}`], { ..._gitOpts, cwd: rootDir })).trim();
+                          const treeResult = await shared.shellSafeGit(['merge-tree', mergeBase, `origin/${mainRef2}`, `origin/${reBranch2}`], { ..._gitOpts, cwd: rootDir });
+                          const treeOutput = gitOutputToString(treeResult);
+                          if (treeOutput.includes('<<<<<<<') || treeOutput.includes('changed in both')) {
+                            depConflictBranch = reBranch2;
+                            depConflictFiles = parseConflictFiles(treeOutput);
+                            break;
+                          }
+                        } catch (_e) { /* merge-tree may fail — continue checking other branches */ }
+                      }
                     }
-                  } catch (_simErr) {
-                    // Fallback: old per-branch isolation check via 3-arg git merge-tree
-                    for (const { branch: reBranch2 } of prunedDeps) {
-                      try {
-                        const mainRef2 = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
-                        const mergeBase = (await shared.shellSafeGit(['merge-base', `origin/${mainRef2}`, `origin/${reBranch2}`], { ..._gitOpts, cwd: rootDir })).stdout.toString().trim();
-                        const treeResult = await shared.shellSafeGit(['merge-tree', mergeBase, `origin/${mainRef2}`, `origin/${reBranch2}`], { ..._gitOpts, cwd: rootDir });
-                        const treeOutput = treeResult.stdout?.toString?.() || '';
-                        if (treeOutput.includes('<<<<<<<') || treeOutput.includes('changed in both')) {
-                          depConflictBranch = reBranch2;
-                          depConflictFiles = parseConflictFiles(treeOutput);
-                          break;
-                        }
-                      } catch (_e) { /* merge-tree may fail — continue checking other branches */ }
+                    // Fallback: use verified unmerged files or conflict output if merge-tree didn't identify them.
+                    if (!depConflictBranch) {
+                      depConflictFiles = depFailure.conflictFiles;
                     }
                   }
-                  // Fallback: parse conflict files from the error output if merge-tree didn't identify them
-                  if (!depConflictBranch) {
-                    depConflictFiles = parseConflictFiles(errOutput);
-                  }
                   depMergeFailed = true;
                 }
                 break;
@@ -2327,6 +2386,18 @@ async function spawnAgent(dispatchItem, config) {
               cleanupTempAgent(agentId);
               return;
             }
+            if (depMergeSetupFailed) {
+              const setupReason = (depMergeSetupReason || `Dependency merge setup failed for ${branchName}`).slice(0, 800);
+              completeDispatch(
+                id,
+                DISPATCH_RESULT.ERROR,
+                setupReason,
+                'Engine dependency pre-merge plumbing failed before any real unmerged files were verified. Retrying in a fresh worktree should recover if the dependency branches still merge cleanly.',
+                { failureClass: FAILURE_CLASS.DEPENDENCY_MERGE_SETUP, agentRetryable: true },
+              );
+              cleanupTempAgent(agentId);
+              return;
+            }
             // Build actionable failReason identifying the conflicting branch and files (#958)
             const mainBranch = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
             let failReason = 'Dependency merge failed';
@@ -8082,6 +8153,7 @@ module.exports = {
   reconcileItemsWithPrs, detectDependencyCycles,
   areDependenciesMet, // exported for testing (P-bf04-decompose-zero-children)
   parseConflictFiles, pruneAncestorDeps, preflightMergeSimulation, // exported for testing
+  gitOutputToString, gitErrorOutput, classifyDepMergeFailureOutput, listUnmergedFiles, // exported for testing
   buildDepConflictFixItem, deriveConflictFixKey, // exported for testing (W-mpcwojgr000a0244)
   isWorktreeRetryableError, removeStaleIndexLock, syncReusedWorktree, assertCleanSharedWorktree, _quarantineDirtyWorktree, // exported for testing
   pruneStaleWorktreeForBranch, // exported for testing

package/package.json

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