@yemi33/minions 0.1.914 → 0.1.915

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## 0.1.914 (2026-04-13)
+## 0.1.915 (2026-04-13)
 
 ### Features
 - fix dep re-merge failure on retry with existing commits (#977)
@@ -17,6 +17,8 @@
 - add red dot notification on CC tab when response completes (#934) (#946)
 
 ### Fixes
+- dep merge ancestor pruning + pre-flight simulation (#958) (#979)
+- add MAX_TURNS failure class and fix enum count test (#983)
 - prevent Create Plan from meeting saving doc-chat context bleed (#980)
 - plan completion incorrectly overrides awaiting-approval status (#970) (#978)
 -  CC queued messages sent to wrong tab after tab switch

package/engine/lifecycle.js

@@ -1893,8 +1893,14 @@ function classifyFailure(code, stdout = '', stderr = '') {
     return FAILURE_CLASS.MERGE_CONFLICT;
   }
 
-  // Context window / max turns exhausted
-  if (/context window|max.*turns.*reached|error_max_turns|terminal_reason.*max_turns|token limit|conversation.*too long|context.*length.*exceeded/i.test(combined)) {
+  // Max turns exhausted (error_max_turns) — work in progress, retryable
+  // Must be checked BEFORE OUT_OF_CONTEXT to avoid misclassification as non-retryable
+  if (/error_max_turns|"subtype"\s*:\s*"error_max_turns"|terminal_reason.*max_turns|max.*turns.*reached/i.test(combined)) {
+    return FAILURE_CLASS.MAX_TURNS;
+  }
+
+  // Context window exhausted (token limit, context length — NOT max turns)
+  if (/context window|token limit|conversation.*too long|context.*length.*exceeded/i.test(combined)) {
     return FAILURE_CLASS.OUT_OF_CONTEXT;
   }
 

package/engine/recovery.js

@@ -64,6 +64,12 @@ const RECOVERY_RECIPES = new Map([
     freshSession: false,
     description: 'Network/API error — retry with exponential backoff',
   }],
+  [FAILURE_CLASS.MAX_TURNS, {
+    maxAttempts: 3,
+    escalation: ESCALATION_POLICY.RETRY_SAME,
+    freshSession: false,
+    description: 'Max turns reached — work in progress, retry same agent to continue',
+  }],
   [FAILURE_CLASS.OUT_OF_CONTEXT, {
     maxAttempts: 1,
     escalation: ESCALATION_POLICY.HUMAN_REVIEW,

package/engine/shared.js

@@ -672,12 +672,13 @@ const FAILURE_CLASS = {
   EMPTY_OUTPUT: 'empty-output',           // Agent produced no meaningful output
   SPAWN_ERROR: 'spawn-error',             // Process failed to start or crashed immediately
   NETWORK_ERROR: 'network-error',         // API rate limit, DNS, connectivity
-  OUT_OF_CONTEXT: 'out-of-context',       // Context window exhausted, max turns reached
+  OUT_OF_CONTEXT: 'out-of-context',       // Context window exhausted (token limit, context length)
+  MAX_TURNS: 'max-turns',                 // Claude CLI error_max_turns — work in progress, retryable
   UNKNOWN: 'unknown',                     // Unclassified failure
 };
 const ESCALATION_POLICY = {
   NO_RETRY: 'no-retry',         // CONFIG_ERROR, PERMISSION_BLOCKED — never retry
-  RETRY_SAME: 'retry-same',     // MERGE_CONFLICT, BUILD_FAILURE — retry same agent
+  RETRY_SAME: 'retry-same',     // MERGE_CONFLICT, BUILD_FAILURE, MAX_TURNS — retry same agent
   RETRY_FRESH: 'retry-fresh',   // TIMEOUT, SPAWN_ERROR — retry with fresh session
   HUMAN_REVIEW: 'human-review', // EMPTY_OUTPUT, OUT_OF_CONTEXT — flag for human
   AUTO: 'auto',                 // UNKNOWN, NETWORK_ERROR — use default retry logic

package/engine.js

@@ -167,6 +167,68 @@ function parseConflictFiles(mergeOutput) {
   return [...new Set(files)]; // dedupe
 }
 
+// Prune dep branches that are ancestors of other dep branches (#958)
+// When B already contains A's commits, merging both A and B causes conflicts.
+async function pruneAncestorDeps(deps, gitOpts, cwd) {
+  if (deps.length <= 1) return deps;
+  const ancestorIndices = new Set();
+  for (let i = 0; i < deps.length; i++) {
+    if (ancestorIndices.has(i)) continue;
+    for (let j = 0; j < deps.length; j++) {
+      if (i === j || ancestorIndices.has(j)) continue;
+      try {
+        await execAsync(`git merge-base --is-ancestor "origin/${deps[i].branch}" "origin/${deps[j].branch}"`, { ...gitOpts, cwd });
+        // deps[i] is an ancestor of deps[j] — prune deps[i]
+        ancestorIndices.add(i);
+        break;
+      } catch (_) { /* not an ancestor — that's fine */ }
+    }
+  }
+  return deps.filter((_, i) => !ancestorIndices.has(i));
+}
+
+// Pre-flight merge simulation using git merge-tree --write-tree (#958)
+// Simulates sequential merges by chaining output tree SHAs via temporary commits.
+// Returns { ok, conflictBranch, conflictFiles, isInterDep, prevBranch }
+async function preflightMergeSimulation(deps, mainRef, gitOpts, cwd) {
+  if (deps.length === 0) return { ok: true };
+  let currentRef = `origin/${mainRef}`;
+  let prevBranch = mainRef;
+  for (let i = 0; i < deps.length; i++) {
+    const depBranch = deps[i].branch;
+    try {
+      const result = await execAsync(`git merge-tree --write-tree "${currentRef}" "origin/${depBranch}"`, { ...gitOpts, cwd });
+      const treeSha = (typeof result === 'string' ? result : (result.stdout?.toString?.() || '')).trim().split('\n')[0];
+      if (!treeSha) return { ok: true }; // can't parse tree SHA, skip pre-flight
+      // Create temp commit to chain for next dep (skip for last dep — no chaining needed)
+      if (i < deps.length - 1) {
+        try {
+          const commitResult = await execAsync(
+            `git commit-tree "${treeSha}" -p "${currentRef}" -p "origin/${depBranch}" -m "preflight-merge"`,
+            { ...gitOpts, cwd }
+          );
+          const commitSha = (typeof commitResult === 'string' ? commitResult : (commitResult.stdout?.toString?.() || '')).trim();
+          if (commitSha) {
+            prevBranch = depBranch;
+            currentRef = commitSha;
+          }
+        } catch (_) { return { ok: true }; } // commit-tree failed, skip pre-flight gracefully
+      }
+    } catch (err) {
+      const output = (err.stdout?.toString?.() || '') + '\n' + (err.stderr?.toString?.() || '');
+      const isInterDep = prevBranch !== mainRef;
+      return {
+        ok: false,
+        conflictBranch: depBranch,
+        conflictFiles: parseConflictFiles(output),
+        isInterDep,
+        prevBranch,
+      };
+    }
+  }
+  return { ok: true };
+}
+
 const _FAST_WORK_TYPES = new Set([WORK_TYPE.EXPLORE, WORK_TYPE.ASK, WORK_TYPE.REVIEW]);
 const _MAX_TURNS_BY_TYPE = {
   [WORK_TYPE.EXPLORE]: 30, [WORK_TYPE.ASK]: 20, [WORK_TYPE.REVIEW]: 30,
@@ -524,11 +586,27 @@ async function spawnAgent(dispatchItem, config) {
           }
           // Merge successfully-fetched + recovered (local-only pushed) branches sequentially
           const fetched = fetchable.filter((_, i) => fetchResults[i].status === 'fulfilled' || recoveredBranches.has(fetchable[i].branch));
-          // Skip dep re-merge if worktree HEAD already contains all dep commits (#973)
+          // Ancestor pruning: remove dep branches already contained in another (#958)
+          let prunedDeps = fetched;
+          let _isInterDepConflict = false;
+          let _preflightConflictPrev = null;
+          if (fetched.length > 1 && !depMergeFailed) {
+            try {
+              prunedDeps = await pruneAncestorDeps(fetched, _gitOpts, rootDir);
+              if (prunedDeps.length < fetched.length) {
+                const pruned = fetched.filter(d => !prunedDeps.includes(d));
+                log('info', `Ancestor pruning removed ${pruned.length} dep(s): ${pruned.map(d => d.branch).join(', ')}`);
+              }
+            } catch (e) {
+              log('warn', `Ancestor pruning failed, using all deps: ${e.message}`);
+              prunedDeps = fetched;
+            }
+          }
+          // Skip dep re-merge if worktree HEAD already contains all pruned dep commits (#973)
           let skipDepMerge = false;
-          if (!depMergeFailed && fetched.length > 0) {
+          if (!depMergeFailed && prunedDeps.length > 0) {
             const ancestorChecks = await Promise.all(
-              fetched.map(async ({ branch: depBranch }) => {
+              prunedDeps.map(async ({ branch: depBranch }) => {
                 try {
                   await execAsync(`git merge-base --is-ancestor "origin/${depBranch}" HEAD`, { ..._gitOpts, cwd: worktreePath });
                   return true;
@@ -536,13 +614,30 @@ async function spawnAgent(dispatchItem, config) {
               })
             );
             if (ancestorChecks.every(Boolean)) {
-              log('info', `All ${fetched.length} dep branch(es) already merged into ${branchName} — skipping dep re-merge`);
+              log('info', `All ${prunedDeps.length} dep branch(es) already merged into ${branchName} — skipping dep re-merge`);
               skipDepMerge = true;
             }
           }
+          // Pre-flight merge simulation: detect conflicts without touching the worktree (#958)
+          if (!depMergeFailed && !skipDepMerge && prunedDeps.length > 0) {
+            const pfMainRef = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
+            try {
+              const sim = await preflightMergeSimulation(prunedDeps, pfMainRef, _gitOpts, rootDir);
+              if (!sim.ok) {
+                depMergeFailed = true;
+                depConflictBranch = sim.conflictBranch;
+                depConflictFiles = sim.conflictFiles;
+                _isInterDepConflict = sim.isInterDep;
+                _preflightConflictPrev = sim.prevBranch;
+                log('warn', `Pre-flight merge simulation detected conflict: ${sim.conflictBranch}${sim.isInterDep ? ` (inter-dep with ${sim.prevBranch})` : ''}`);
+              }
+            } catch (e) {
+              log('warn', `Pre-flight simulation failed, proceeding with real merge: ${e.message}`);
+            }
+          }
           // Stash uncommitted changes before dep merge if worktree is dirty (#973)
           let stashed = false;
-          if (!depMergeFailed && !skipDepMerge && fetched.length > 0) {
+          if (!depMergeFailed && !skipDepMerge && prunedDeps.length > 0) {
             try {
               const statusOut = (await execAsync('git status --porcelain', { ..._gitOpts, cwd: worktreePath })).stdout.toString().trim();
               if (statusOut) {
@@ -555,7 +650,7 @@ async function spawnAgent(dispatchItem, config) {
             }
           }
           if (!depMergeFailed && !skipDepMerge) {
-            for (const { branch: depBranch, prId } of fetched) {
+            for (const { branch: depBranch, prId } of prunedDeps) {
               try {
                 await execAsync(`git merge "origin/${depBranch}" --no-edit`, { ..._gitOpts, cwd: worktreePath });
                 log('info', `Merged dependency branch ${depBranch} (${prId}) into worktree ${branchName}`);
@@ -568,30 +663,42 @@ async function spawnAgent(dispatchItem, config) {
                 try {
                   await execAsync(`git reset --hard "origin/${mainRef}"`, { ..._gitOpts, cwd: worktreePath });
                   log('info', `Reset worktree ${branchName} to origin/${mainRef} for clean dep re-merge`);
-                  // Re-merge ALL fetched dep branches from scratch on clean base
-                  for (const { branch: reBranch, prId: rePrId } of fetched) {
+                  // Re-merge ALL pruned dep branches from scratch on clean base
+                  for (const { branch: reBranch, prId: rePrId } of prunedDeps) {
                     await execAsync(`git merge "origin/${reBranch}" --no-edit`, { ..._gitOpts, cwd: worktreePath });
                     log('info', `Re-merged dependency branch ${reBranch} (${rePrId}) into worktree ${branchName}`);
                   }
-                  log('info', `Successfully re-merged all ${fetched.length} dep branches after reset for ${branchName}`);
+                  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?.() || '');
                   log('warn', `Failed to reset and re-merge deps for ${branchName}: ${resetErr.message}`);
                   try { await execAsync(`git merge --abort`, { ..._gitOpts, cwd: worktreePath }); } catch (_) { /* no merge in progress */ }
-                  // Identify which dep branch caused the conflict during re-merge
-                  // The last branch attempted in the re-merge loop is the one that failed
-                  for (const { branch: reBranch2 } of fetched) {
-                    try {
-                      const mainRef2 = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
-                      const mergeBase = (await execAsync(`git merge-base "origin/${mainRef2}" "origin/${reBranch2}"`, { ..._gitOpts, cwd: rootDir })).stdout.toString().trim();
-                      const treeResult = await execAsync(`git 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 */ }
+                  // 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;
+                    }
+                  } 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 execAsync(`git merge-base "origin/${mainRef2}" "origin/${reBranch2}"`, { ..._gitOpts, cwd: rootDir })).stdout.toString().trim();
+                        const treeResult = await execAsync(`git 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: parse conflict files from the error output if merge-tree didn't identify them
                   if (!depConflictBranch) {
@@ -614,10 +721,15 @@ async function spawnAgent(dispatchItem, config) {
           }
           if (depMergeFailed) {
             _cleanupPromptFiles();
-            // Build actionable failReason identifying the conflicting branch and files
+            // Build actionable failReason identifying the conflicting branch and files (#958)
+            const mainBranch = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
             let failReason = 'Dependency merge failed';
             if (depConflictBranch) {
-              failReason = `Dependency merge failed: ${depConflictBranch} conflicts with ${sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch))}`;
+              if (_isInterDepConflict && _preflightConflictPrev) {
+                failReason = `Dependency merge failed: ${depConflictBranch} conflicts with dep ${_preflightConflictPrev}`;
+              } else {
+                failReason = `Dependency merge failed: ${depConflictBranch} conflicts with ${mainBranch}`;
+              }
               if (depConflictFiles.length > 0) failReason += ` in ${depConflictFiles.slice(0, 5).join(', ')}`;
               failReason += ' — dep branch needs updating';
             }
@@ -633,22 +745,26 @@ async function spawnAgent(dispatchItem, config) {
                 const filesDesc = depConflictFiles.length > 0
                   ? `\n\nConflicting files:\n${depConflictFiles.map(f => '- ' + f).join('\n')}`
                   : '';
-                const mainBranch = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
+                // Inter-dep conflict: rebase onto the conflicting dep; dep-vs-main: merge main (#958)
+                const conflictFixDesc = _isInterDepConflict && _preflightConflictPrev
+                  ? `Branch \`${depConflictBranch}\` conflicts with dependency branch \`${_preflightConflictPrev}\`. Rebase \`${depConflictBranch}\` onto \`${_preflightConflictPrev}\` (or merge \`${_preflightConflictPrev}\` into \`${depConflictBranch}\`) and resolve conflicts, then push.`
+                  : `Branch \`${depConflictBranch}\` conflicts with \`${mainBranch}\`. Merge ${mainBranch} into the branch and resolve conflicts, then push.`;
                 mutateWorkItems(wiPath, items => {
                   // Don't create duplicate conflict-fix items
                   const existing = items.find(i => i.id === conflictFixId && i.status !== WI_STATUS.DONE && i.status !== WI_STATUS.FAILED && i.status !== WI_STATUS.CANCELLED);
                   if (existing) return;
                   items.push({
                     id: conflictFixId,
-                    title: `Fix merge conflict: ${depConflictBranch} conflicts with ${mainBranch}`,
+                    title: `Fix merge conflict: ${depConflictBranch} conflicts with ${_isInterDepConflict ? _preflightConflictPrev : mainBranch}`,
                     type: WORK_TYPE.FIX,
                     priority: 'high',
                     status: WI_STATUS.PENDING,
-                    description: `Branch \`${depConflictBranch}\` conflicts with \`${mainBranch}\`. Merge ${mainBranch} into the branch and resolve conflicts, then push.${filesDesc}\n\nBlocked downstream item: \`${meta.item.id}\` — ${meta.item.title || ''}`,
+                    description: `${conflictFixDesc}${filesDesc}\n\nBlocked downstream item: \`${meta.item.id}\` — ${meta.item.title || ''}`,
                     created: ts(),
                     createdBy: 'engine:dep-conflict-fix',
                     _branch: depConflictBranch,
                     _blockedItem: meta.item.id,
+                    _isInterDepConflict: _isInterDepConflict || false,
                     project: project.name || null,
                   });
                   log('info', `Auto-queued conflict-fix work item ${conflictFixId} for ${depConflictBranch} (blocked: ${meta.item.id})`);
@@ -666,6 +782,28 @@ async function spawnAgent(dispatchItem, config) {
 
   updateAgentStatus(id, AGENT_STATUS.READY, 'Worktree ready, preparing to spawn process');
 
+  // Inject dirty file list when worktree has uncommitted changes (e.g., max_turns retry)
+  // This signals to the respawned agent that prior work exists in the worktree (#960)
+  if (worktreePath && fs.existsSync(worktreePath)) {
+    try {
+      const dirtyResult = await execAsync('git status --porcelain', { ..._gitOpts, cwd: worktreePath, timeout: 10000 });
+      const dirtyOutput = (dirtyResult.stdout || '').trim();
+      if (dirtyOutput) {
+        const dirtyFiles = dirtyOutput.split('\n').map(l => l.trim()).filter(Boolean);
+        const dirtySection = [
+          '\n## Uncommitted Work in Worktree\n',
+          'The worktree has uncommitted changes from a previous agent run. Review these files and continue from where the previous agent left off.\n',
+          '```',
+          ...dirtyFiles,
+          '```\n',
+        ].join('\n');
+        // Append dirty file list to the already-written prompt file
+        try { fs.appendFileSync(promptPath, dirtySection); } catch (e) { log('warn', `dirty files inject: ${e.message}`); }
+        log('info', `Injected ${dirtyFiles.length} dirty files into prompt for ${id}`);
+      }
+    } catch (e) { log('warn', `git status --porcelain for dirty files: ${e.message}`); }
+  }
+
   // Safety check: warn if a write-capable task is running in the main repo without a worktree
   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`);
@@ -3248,7 +3386,7 @@ module.exports = {
 
   // Shared helpers (used by lifecycle.js and tests)
   reconcileItemsWithPrs, detectDependencyCycles,
-  parseConflictFiles, // exported for testing
+  parseConflictFiles, pruneAncestorDeps, preflightMergeSimulation, // exported for testing
 
   // Playbooks
   renderPlaybook, validatePlaybookVars, PLAYBOOK_REQUIRED_VARS, buildWorkItemDispatchVars,

package/package.json

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