@yemi33/minions 0.1.774 → 0.1.775

package/CHANGELOG.md

@@ -1,8 +1,9 @@
 # Changelog
 
-## 0.1.774 (2026-04-10)
+## 0.1.775 (2026-04-10)
 
 ### Features
+-  auto-rebase dependent PRs after dependency merge
 -  show PR merged/active status on PRD item links
 
 ### Fixes

package/engine/lifecycle.js

@@ -7,11 +7,12 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const shared = require('./shared');
-const { safeRead, safeJson, safeWrite, mutateJsonFileLocked, mutateWorkItems, execSilent, projectPrPath, getPrLinks, addPrLink,
+const { safeRead, safeJson, safeWrite, mutateJsonFileLocked, mutateWorkItems, execSilent, execAsync, projectPrPath, getPrLinks, addPrLink,
   log, ts, dateStamp, WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, PLAN_STATUS, PR_STATUS, DISPATCH_RESULT,
   ENGINE_DEFAULTS, DEFAULT_AGENT_METRICS, FAILURE_CLASS } = shared;
 const { trackEngineUsage } = require('./llm');
 const queries = require('./queries');
+const { isBranchActive } = require('./cooldown');
 const { getConfig, getInboxFiles, getNotes, getPrs, getDispatch,
   MINIONS_DIR, ENGINE_DIR, PLANS_DIR, PRD_DIR, INBOX_DIR, AGENTS_DIR } = queries;
 
@@ -797,6 +798,119 @@ function updatePrAfterFix(pr, project, source) {
   }, { defaultValue: [] });
 }
 
+// ─── Post-Merge Rebase ──────────────────────────────────────────────────────
+
+/**
+ * Find active PRs whose work items depend on the just-merged item.
+ * Excludes shared-branch items (those use git pull instead).
+ */
+function findDependentActivePrs(mergedItemId, config) {
+  const results = [];
+  const allWi = queries.getWorkItems(config);
+  const dependentWis = allWi.filter(wi =>
+    wi.depends_on?.includes(mergedItemId) &&
+    !DONE_STATUSES.has(wi.status) &&
+    wi.branchStrategy !== 'shared-branch'
+  );
+  if (dependentWis.length === 0) return results;
+
+  const projects = shared.getProjects(config);
+  for (const p of projects) {
+    const prs = safeJson(projectPrPath(p)) || [];
+    for (const pr of prs) {
+      if (!pr.branch || pr.status !== 'active') continue;
+      const linked = (pr.prdItems || []).some(id => dependentWis.some(wi => wi.id === id));
+      if (linked && !results.some(r => r.pr.id === pr.id)) {
+        const wi = dependentWis.find(w => (pr.prdItems || []).includes(w.id));
+        results.push({ pr, project: p, workItem: wi });
+      }
+    }
+  }
+  return results;
+}
+
+/**
+ * Rebase a PR branch onto main in a temporary worktree.
+ * Returns { success: true } or { success: false, error: string }.
+ */
+async function rebaseBranchOntoMain(pr, project, config) {
+  const root = path.resolve(project.localPath);
+  const mainBranch = shared.resolveMainBranch(root, project.mainBranch);
+  const branch = pr.branch;
+  const wtRoot = path.resolve(root, config.engine?.worktreeRoot || ENGINE_DEFAULTS.worktreeRoot);
+  const tmpWt = path.join(wtRoot, `rebase-${shared.sanitizeBranch(branch)}-${Date.now()}`).replace(/\\/g, '/');
+  const _gitOpts = { cwd: root, timeout: 30000, windowsHide: true };
+
+  try {
+    await execAsync(`git fetch origin "${mainBranch}" "${branch}"`, _gitOpts);
+    try {
+      await execAsync(`git worktree add "${tmpWt}" "${branch}"`, { ..._gitOpts, timeout: 60000 });
+    } catch (wtErr) {
+      // Branch may already be checked out in a stale worktree — prune and retry once
+      if (String(wtErr.message || wtErr).includes('already checked out')) {
+        await execAsync(`git worktree prune`, _gitOpts);
+        await execAsync(`git worktree add "${tmpWt}" "${branch}"`, { ..._gitOpts, timeout: 60000 });
+      } else { throw wtErr; }
+    }
+  } catch (err) {
+    log('warn', `Post-merge rebase: setup failed for ${branch}: ${err.message}`);
+    try { await execAsync(`git worktree remove "${tmpWt}" --force`, _gitOpts); } catch {}
+    return { success: false, error: err.message };
+  }
+
+  try {
+    await execAsync(`git rebase "origin/${mainBranch}"`, { cwd: tmpWt, timeout: 120000, windowsHide: true });
+    await execAsync(`git push --force-with-lease origin "${branch}"`, { cwd: tmpWt, timeout: 30000, windowsHide: true });
+    log('info', `Post-merge rebase: rebased ${branch} onto ${mainBranch} and force-pushed`);
+    return { success: true };
+  } catch (err) {
+    try { await execAsync(`git rebase --abort`, { cwd: tmpWt, timeout: 10000, windowsHide: true }); } catch {}
+    log('warn', `Post-merge rebase failed for ${branch}: ${err.message}`);
+    return { success: false, error: err.message };
+  } finally {
+    try { shared.removeWorktree(tmpWt, root, wtRoot); } catch {}
+    try { await execAsync(`git worktree prune`, _gitOpts); } catch {}
+  }
+}
+
+const PENDING_REBASES_PATH = path.join(ENGINE_DIR, 'pending-rebases.json');
+
+function queuePendingRebase(pr, project, mergedItemId) {
+  const pending = safeJson(PENDING_REBASES_PATH) || [];
+  if (pending.some(e => e.prId === pr.id)) return; // already queued
+  pending.push({ prId: pr.id, branch: pr.branch, projectName: project.name, mergedItemId, queuedAt: ts(), attempts: 0 });
+  safeWrite(PENDING_REBASES_PATH, pending);
+}
+
+async function processPendingRebases(config) {
+  const pending = safeJson(PENDING_REBASES_PATH) || [];
+  if (pending.length === 0) return;
+
+  const remaining = [];
+  for (const entry of pending) {
+    if (isBranchActive(entry.branch)) { remaining.push(entry); continue; }
+
+    const project = shared.getProjects(config).find(p => p.name === entry.projectName);
+    if (!project) continue;
+
+    const prs = safeJson(projectPrPath(project)) || [];
+    const pr = prs.find(p => p.id === entry.prId && p.status === 'active');
+    if (!pr) continue; // PR closed/merged since queuing
+
+    const result = await rebaseBranchOntoMain(pr, project, config);
+    if (!result.success) {
+      entry.attempts = (entry.attempts || 0) + 1;
+      if (entry.attempts < 3) {
+        remaining.push(entry);
+      } else {
+        shared.writeToInbox('engine', `rebase-fail-${pr.id}`,
+          `# Rebase Failed: ${pr.id}\n\nBranch \`${pr.branch}\` could not be rebased onto main after dependency ${entry.mergedItemId} merged.\n\nError: ${result.error}\n\nManual rebase may be needed.`);
+      }
+    }
+  }
+  safeWrite(PENDING_REBASES_PATH, remaining);
+}
+
 // ─── Post-Merge / Post-Close Hooks ───────────────────────────────────────────
 
 async function handlePostMerge(pr, project, config, newStatus) {
@@ -871,6 +985,23 @@ async function handlePostMerge(pr, project, config, newStatus) {
         if (found) break;
       } catch (err) { log('warn', `Post-merge work item update: ${err.message}`); }
     }
+
+    // Rebase dependent PRs onto main now that this dependency is merged
+    try {
+      const dependentPrs = findDependentActivePrs(mergedItemId, config);
+      for (const { pr: depPr, project: depProject } of dependentPrs) {
+        if (isBranchActive(depPr.branch)) {
+          queuePendingRebase(depPr, depProject, mergedItemId);
+          log('info', `Post-merge rebase deferred: ${depPr.branch} locked by active agent`);
+          continue;
+        }
+        const result = await rebaseBranchOntoMain(depPr, depProject, config);
+        if (!result.success) {
+          shared.writeToInbox('engine', `rebase-fail-${depPr.id}`,
+            `# Rebase Failed: ${depPr.id}\n\nBranch \`${depPr.branch}\` could not be rebased onto main after dependency ${mergedItemId} merged.\n\nError: ${result.error}\n\nManual rebase may be needed.`);
+        }
+      }
+    } catch (err) { log('warn', `Post-merge rebase phase error: ${err.message}`); }
   }
 
   const agentId = (pr.agent || '').toLowerCase();
@@ -1615,5 +1746,7 @@ module.exports = {
   resolveWorkItemPath,
   isItemCompleted,
   classifyFailure,
+  processPendingRebases,
+  findDependentActivePrs,
 };
 

package/engine.js

@@ -137,7 +137,7 @@ const { renderPlaybook, validatePlaybookVars, PLAYBOOK_REQUIRED_VARS,
 const { runPostCompletionHooks, updateWorkItemStatus, syncPrdItemStatus, handlePostMerge, checkPlanCompletion,
   syncPrsFromOutput, updatePrAfterReview, updatePrAfterFix, checkForLearnings, extractSkillsFromOutput,
   updateAgentHistory, updateMetrics, createReviewFeedbackForAuthor, parseAgentOutput, syncPrdFromPrs,
-  isItemCompleted, classifyFailure } = require('./engine/lifecycle');
+  isItemCompleted, classifyFailure, processPendingRebases } = require('./engine/lifecycle');
 
 // ─── Agent Spawner ──────────────────────────────────────────────────────────
 
@@ -1664,11 +1664,11 @@ async function discoverFromPrs(config, project) {
     // Grace period: after a build fix push, wait for CI to run before re-dispatching
     // Skip if build hasn't transitioned since last fix (still showing the old failure)
     if (pr._buildFixPushedAt && pr.buildStatus === 'failing') {
-      const gracePeriodMs = config.engine?.buildFixGracePeriod ?? ENGINE_DEFAULTS.buildFixGracePeriod;
+      const gracePeriodMs = config.engine?.buildFixGracePeriod ?? DEFAULTS.buildFixGracePeriod;
       if (Date.now() - new Date(pr._buildFixPushedAt).getTime() < gracePeriodMs) continue;
     }
     if (pr.status === PR_STATUS.ACTIVE && pr.buildStatus === 'failing') {
-      const maxBuildFix = config.engine?.maxBuildFixAttempts ?? ENGINE_DEFAULTS.maxBuildFixAttempts;
+      const maxBuildFix = config.engine?.maxBuildFixAttempts ?? DEFAULTS.maxBuildFixAttempts;
 
       // Check if max retry cap reached — escalate to human instead of dispatching another fix
       if ((pr.buildFixAttempts || 0) >= maxBuildFix) {
@@ -2694,6 +2694,7 @@ async function tickInner() {
   if (tickCount % 6 === 0 || needsAdoPollRetry()) {
     try { await pollPrStatus(config); } catch (err) { log('warn', `ADO PR status poll error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }
     try { await ghPollPrStatus(config); } catch (err) { log('warn', `GitHub PR status poll error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }
+    try { await processPendingRebases(config); } catch (err) { log('warn', `Pending rebase processing error: ${err?.message || err}`); }
     // Sync PR status back to PRD items (missing → done when active PR exists)
     try { syncPrdFromPrs(config); } catch (err) { log('warn', `PRD sync error: ${err?.message || err}`); }
     // Check if any plans can be marked completed (all features done/in-pr)

package/package.json

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