@yemi33/minions 0.1.774 → 0.1.776

package/CHANGELOG.md

@@ -1,11 +1,13 @@
 # Changelog
 
-## 0.1.774 (2026-04-10)
+## 0.1.776 (2026-04-10)
 
 ### Features
+-  auto-rebase dependent PRs after dependency merge
 -  show PR merged/active status on PRD item links
 
 ### Fixes
+-  better agent comment filtering — detect by patterns, not just signature
 -  filter CI bot noise from PR human comment detection
 
 ### Other

package/engine/ado.js

@@ -458,12 +458,18 @@ async function pollPrHumanComments(config) {
     for (const thread of threads) {
       for (const comment of (thread.comments || [])) {
         if (!comment.content || comment.commentType === 'system') continue;
-        if (/\bMinions\s*\(/i.test(comment.content)) continue; // skip minions's own comments
+        const content = comment.content;
+        // Minions agent signatures
+        if (/\bMinions\s*\(/i.test(content)) continue;
+        if (/\b(Review|Fixed|Explored|Verified|Tested)\s+by\s+Minions\b/i.test(content)) continue;
+        if (/\[minions\]/i.test(content)) continue;
         // Skip bot/service account comments
         const authorName = (comment.author?.displayName || '').toLowerCase();
         if (/\b(bot|service|build|pipeline|codecov|sonar)\b/i.test(authorName)) continue;
-        // Skip automated status comments (coverage, build reports)
-        if (/^#{1,3}\s*(Coverage|Build|Test|Deploy|Pipeline)\s*(Report|Status|Result|Summary)/i.test(comment.content)) continue;
+        // Short comments from same author that look agent-generated
+        if (content.length < 500 && /\b(fixed|addressed|resolved|pushed|updated|rebased)\b/i.test(content) && /\b(review|feedback|comment|finding)\b/i.test(content)) continue;
+        // Automated status comments (coverage, build reports)
+        if (/^#{1,3}\s*(Coverage|Build|Test|Deploy|Pipeline)\s*(Report|Status|Result|Summary)/i.test(content)) continue;
 
         const entry = {
           threadId: thread.id,

package/engine/github.js

@@ -441,17 +441,25 @@ async function pollPrHumanComments(config) {
       ...(Array.isArray(reviewComments) ? reviewComments : []).map(c => ({ ...c, _type: 'review' }))
     ];
 
-    // Filter out bot comments, minions's own comments, and CI noise
+    // Filter out bot comments, minions agent comments, and CI noise
+    // Agents post as the PAT owner — detect by signature patterns, not account type
+    const prAuthorLogin = (prData?.user?.login || '').toLowerCase();
     const humanComments = allComments.filter(c => {
       if (c.user?.type === 'Bot') return false;
-      if (/\bMinions\s*\(/i.test(c.body || '')) return false;
-      // Common CI bot usernames
+      const body = c.body || '';
+      // Minions agent signatures (review, fix, explore, etc.)
+      if (/\bMinions\s*\(/i.test(body)) return false;
+      if (/\b(Review|Fixed|Explored|Verified|Tested)\s+by\s+Minions\b/i.test(body)) return false;
+      if (/\[minions\]/i.test(body)) return false;
+      // Comments from the PR author account are likely agent-generated (agents use same PAT)
+      // Only skip if the comment looks automated (short, or has agent patterns)
       const login = (c.user?.login || '').toLowerCase();
+      if (login === prAuthorLogin && body.length < 500 && /\b(fixed|addressed|resolved|pushed|updated|rebased)\b/i.test(body)) return false;
+      // Common CI bot usernames
       if (/\b(bot|codecov|sonar|dependabot|renovate|github-actions|azure-pipelines)\b/i.test(login)) return false;
       // Automated status comments (coverage reports, build badges, etc.)
-      const body = c.body || '';
       if (/^#{1,3}\s*(Coverage|Build|Test|Deploy|Pipeline)\s*(Report|Status|Result|Summary)/i.test(body)) return false;
-      if (/!\[.*\]\(https?:\/\/.*badge/i.test(body)) return false; // badge images
+      if (/!\[.*\]\(https?:\/\/.*badge/i.test(body)) return false;
       return true;
     });
 

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.776",
   "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"