@yemi33/minions 0.1.869 → 0.1.871

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## 0.1.869 (2026-04-11)
+## 0.1.871 (2026-04-11)
 
 ### Features
 -  ticking runtime counter on working agent cards
@@ -9,6 +9,8 @@
 -  optimistic running state on pipeline Run Now click
 
 ### Fixes
+-  orphan recovery misclassifies mid-run agents as failed on engine restart
+- dep merge failures identify conflicting branch and auto-queue fix (closes #814) (#882)
 -  always show doc-chat expand bar when thread is collapsed
 -  poll for old process exit before steering resume (replaces fixed delay)
 -  add 3s delay before steering resume to let old process tree exit

package/engine/cli.js

@@ -228,15 +228,20 @@ const commands = {
         const agentId = item.agent;
         const outputPath = path.join(MINIONS_DIR, 'agents', agentId, 'live-output.log');
         try {
-          const stat = fs.statSync(outputPath);
           const output = fs.readFileSync(outputPath, 'utf8');
 
-          // Check for completion markers in output
-          const hasResult = output.includes('"type":"result"') || output.includes('"type": "result"');
-          const hasError = output.includes('"is_error":true') || output.includes('"is_error": true');
-          if (!hasResult && !hasError) continue;
+          // Only process if the session actually emitted a result line — no result means the
+          // session was still running when the engine died and should be requeued, not failed.
+          // Tool-level is_error:true (e.g. a Read on a missing file) must not be confused with
+          // a session-level error, so we scope the is_error check to the result line only.
+          const resultIdx = output.search(/"type"\s*:\s*"result"/);
+          if (resultIdx === -1) continue;
 
-          let isSuccess = hasResult && !hasError;
+          const resultLineEnd = output.indexOf('\n', resultIdx);
+          const resultLine = output.slice(resultIdx, resultLineEnd === -1 ? output.length : resultLineEnd);
+          const hasError = resultLine.includes('"is_error":true') || resultLine.includes('"is_error": true');
+
+          let isSuccess = !hasError;
 
           // Extract PRs from output first — if PRs were created, the agent succeeded
           // regardless of intermediate error lines in the log

package/engine.js

@@ -25,7 +25,8 @@ const fs = require('fs');
 const path = require('path');
 const shared = require('./engine/shared');
 const { exec, execAsync, execSilent, runFile, ts, ENGINE_DEFAULTS: DEFAULTS,
-  WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, DISPATCH_RESULT, AGENT_STATUS } = shared;
+  WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, DISPATCH_RESULT, AGENT_STATUS,
+  FAILURE_CLASS } = shared;
 const queries = require('./engine/queries');
 
 // ─── Paths ──────────────────────────────────────────────────────────────────
@@ -149,6 +150,22 @@ let engineRestartGraceUntil = 0; // timestamp — suppress orphan detection unti
 // Per-tick cache of refs that failed to fetch — avoids repeating 30s ETIMEDOUT for same missing ref
 // Cleared at the start of each tick cycle (see tickInner)
 const _failedRefCache = new Set();
+
+// Parse conflicting file names from git merge error output (stderr/stdout combined)
+function parseConflictFiles(mergeOutput) {
+  const files = [];
+  // Match "CONFLICT (content): Merge conflict in <file>" lines
+  const conflictRe = /CONFLICT \([^)]*\): .*?(?:in|for) (.+)/g;
+  let m;
+  while ((m = conflictRe.exec(mergeOutput)) !== null) files.push(m[1].trim());
+  // Also match "Auto-merging <file>" followed by conflict (less specific, fallback)
+  if (files.length === 0) {
+    const autoMergeRe = /Auto-merging (.+)/g;
+    while ((m = autoMergeRe.exec(mergeOutput)) !== null) files.push(m[1].trim());
+  }
+  return [...new Set(files)]; // dedupe
+}
+
 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,
@@ -451,6 +468,8 @@ async function spawnAgent(dispatchItem, config) {
         try {
           const depBranches = resolveDependencyBranches(depIds, meta?.item?.sourcePlan, project, config);
           let depMergeFailed = false;
+          let depConflictBranch = null; // track which dep branch caused the conflict
+          let depConflictFiles = [];    // conflicting file names parsed from git output
           // Fetch all dependency branches in parallel (git fetches are independent)
           const fetchable = depBranches.filter(d => !_failedRefCache.has(d.branch));
           const unfetchable = depBranches.filter(d => _failedRefCache.has(d.branch));
@@ -525,8 +544,28 @@ async function spawnAgent(dispatchItem, config) {
                   }
                   log('info', `Successfully re-merged all ${fetched.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 */ }
+                  }
+                  // Fallback: parse conflict files from the error output if merge-tree didn't identify them
+                  if (!depConflictBranch) {
+                    depConflictFiles = parseConflictFiles(errOutput);
+                  }
                   depMergeFailed = true;
                 }
                 break;
@@ -535,7 +574,47 @@ async function spawnAgent(dispatchItem, config) {
           }
           if (depMergeFailed) {
             _cleanupPromptFiles();
-            completeDispatch(id, DISPATCH_RESULT.ERROR, `Dependency merge failed — will retry next tick`);
+            // Build actionable failReason identifying the conflicting branch and files
+            let failReason = 'Dependency merge failed';
+            if (depConflictBranch) {
+              failReason = `Dependency merge failed: ${depConflictBranch} conflicts with ${sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch))}`;
+              if (depConflictFiles.length > 0) failReason += ` in ${depConflictFiles.slice(0, 5).join(', ')}`;
+              failReason += ' — dep branch needs updating';
+            }
+            completeDispatch(id, DISPATCH_RESULT.ERROR, failReason, '', { failureClass: FAILURE_CLASS.MERGE_CONFLICT });
+
+            // Auto-queue conflict-fix work item when a specific dep branch is identified
+            if (depConflictBranch && meta?.item?.id && project) {
+              try {
+                const wiPath = project.name
+                  ? projectWorkItemsPath(project)
+                  : path.join(MINIONS_DIR, 'work-items.json');
+                const conflictFixId = `conflict-fix-${depConflictBranch.replace(/[^a-zA-Z0-9-]/g, '-')}`;
+                const filesDesc = depConflictFiles.length > 0
+                  ? `\n\nConflicting files:\n${depConflictFiles.map(f => '- ' + f).join('\n')}`
+                  : '';
+                const mainBranch = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
+                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}`,
+                    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 || ''}`,
+                    created: ts(),
+                    createdBy: 'engine:dep-conflict-fix',
+                    _branch: depConflictBranch,
+                    _blockedItem: meta.item.id,
+                    project: project.name || null,
+                  });
+                  log('info', `Auto-queued conflict-fix work item ${conflictFixId} for ${depConflictBranch} (blocked: ${meta.item.id})`);
+                });
+              } catch (e) { log('warn', `Failed to auto-queue conflict-fix: ${e.message}`); }
+            }
             return;
           }
         } catch (e) {
@@ -3088,6 +3167,7 @@ module.exports = {
 
   // Shared helpers (used by lifecycle.js and tests)
   reconcileItemsWithPrs, detectDependencyCycles,
+  parseConflictFiles, // exported for testing
 
   // Playbooks
   renderPlaybook, validatePlaybookVars, PLAYBOOK_REQUIRED_VARS, buildWorkItemDispatchVars,

package/package.json

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