@yemi33/minions 0.1.2027 → 0.1.2028

package/engine.js

@@ -588,7 +588,23 @@ function resolveDependencyBranches(depIds, sourcePlan, project, config) {
  *
  * @returns {Promise<{skipped: boolean, reason?: string}>}
  */
-async function syncReusedWorktree(rootDir, worktreePath, branchName, gitOpts = {}) {
+async function syncReusedWorktree(rootDir, worktreePath, branchName, gitOpts = {}, opts = {}) {
+  // W-mph6n4p00006ce38: Freshen origin/<mainRef> and fast-forward the
+  // worktree to it BEFORE the branch sync. Without this, reused worktrees
+  // inherit whatever stale local master the engine clone happens to be on,
+  // so downstream dep-merges (and zero-dep agent work) get layered onto a
+  // stale base. Shared-branch / useExistingBranch dispatches MUST NOT
+  // auto-pick-up master mid-flight, so the carve-out is explicit.
+  const { mainRef, isSharedBranch } = opts;
+  if (mainRef && !isSharedBranch) {
+    try { await shared.shellSafeGit(['fetch', 'origin', mainRef], { ...gitOpts, cwd: rootDir }); }
+    catch (e) { log('warn', `git: failed to fetch origin/${mainRef} during reuse-sync: ${e.message}`); }
+    try { await shared.shellSafeGit(['merge', `origin/${mainRef}`, '--no-edit', '--no-ff'], { ...gitOpts, cwd: worktreePath }); }
+    catch (e) {
+      log('warn', `git: failed to merge origin/${mainRef} into ${branchName} during reuse-sync: ${e.message}`);
+      try { await shared.shellSafeGit(['merge', '--abort'], { ...gitOpts, cwd: worktreePath }); } catch (_) { /* no merge in progress */ }
+    }
+  }
   // ls-remote --exit-code returns 2 when no matching refs are found on the
   // remote. The probe only lists refs (no object transfer), so it's cheap
   // even on slow links.
@@ -1063,7 +1079,12 @@ async function spawnAgent(dispatchItem, config) {
       // (orphan/timeout retry before first push) would otherwise emit a
       // "couldn't find remote ref" warn pair on every reuse.
       _phaseT.reuseSyncStart = Date.now();
-      await syncReusedWorktree(rootDir, existingWt, branchName, _gitOpts);
+      // W-mph6n4p00006ce38: hand syncReusedWorktree the main ref + shared-branch
+      // flag so it can freshen origin/<mainRef> into the worktree (skipped on
+      // shared-branch dispatches — see syncReusedWorktree's opts contract).
+      const _reuseMainRef = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
+      const _reuseIsShared = meta?.branchStrategy === 'shared-branch' || meta?.useExistingBranch;
+      await syncReusedWorktree(rootDir, existingWt, branchName, _gitOpts, { mainRef: _reuseMainRef, isSharedBranch: _reuseIsShared });
       _phaseT.reuseSyncEnd = Date.now();
     } else {
       _phaseT.createWorktreeStart = Date.now();
@@ -1167,8 +1188,24 @@ async function spawnAgent(dispatchItem, config) {
           } else {
             log('info', `Creating worktree: ${worktreePath} on branch ${branchName}`);
             const mainRef = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
+            // W-mph6n4p00006ce38: mirror the pool-borrow path (~line 1110-1114)
+            // — fetch fresh origin/<mainRef> and start the new branch off it,
+            // not the local ref. Without this, fresh-create dispatches inherit
+            // whatever stale local master the engine clone happens to be on
+            // (most painful: long-lived engine processes between restarts).
+            // Non-fatal: if the fetch fails (network blip, transient auth),
+            // fall back to local mainRef so the dispatch still progresses;
+            // the dep-merge phase's own fetch + the on-failure
+            // `git reset --hard origin/<mainRef>` recovery remain as safety nets.
+            let _freshCreateBase = mainRef;
             try {
-              await runWorktreeAdd(rootDir, worktreePath, ['-b', branchName, mainRef], _worktreeGitOpts, worktreeCreateRetries);
+              await shared.shellSafeGit(['fetch', 'origin', mainRef], { ..._gitOpts, cwd: rootDir, timeout: 30000 });
+              _freshCreateBase = `origin/${mainRef}`;
+            } catch (mainFetchErr) {
+              log('warn', `Failed to fetch origin/${mainRef} before fresh-create worktree for ${branchName}: ${mainFetchErr.message} — falling back to local ${mainRef}`);
+            }
+            try {
+              await runWorktreeAdd(rootDir, worktreePath, ['-b', branchName, _freshCreateBase], _worktreeGitOpts, worktreeCreateRetries);
             } catch (e1) {
               const branchExists = e1.message?.includes('already exists');
               log('warn', `Worktree -b failed for ${branchName}: ${e1.message?.split('\n')[0]}`);
@@ -1180,7 +1217,7 @@ async function spawnAgent(dispatchItem, config) {
                 // Clean up partial worktree directory from failed attempt
                 try { if (fs.existsSync(worktreePath)) fs.rmSync(worktreePath, { recursive: true, force: true }); } catch { /* optional */ }
                 try {
-                  await runWorktreeAdd(rootDir, worktreePath, ['-b', branchName, mainRef], _worktreeGitOpts, 0);
+                  await runWorktreeAdd(rootDir, worktreePath, ['-b', branchName, _freshCreateBase], _worktreeGitOpts, 0);
                 } catch (e1b) {
                   log('error', `Worktree -b retry also failed for ${branchName}: ${e1b.message?.split('\n')[0]}`);
                   throw e1b;
@@ -1303,6 +1340,38 @@ async function spawnAgent(dispatchItem, config) {
           // of FAILURE_CLASS.MERGE_CONFLICT (which retries 3x against the
           // same broken auth path).
           let _depAuthFailed = false;
+          // W-mph6n4p00006ce38: Refresh origin/<mainRef> + freshen the worktree
+          // BEFORE the parallel dep fetches and preflight sim. Without this,
+          // preflight + real dep-merges run against whatever stale local master
+          // the engine clone happens to be on, producing false-positive
+          // conflicts whenever master drifted ahead of the engine's last fetch.
+          // The pool-borrow + fresh-create paths already start at fresh
+          // origin/<mainRef>, but the reuse path can outrun its sync; and even
+          // for the start-fresh paths, master can advance between worktree
+          // creation and dep-merge (long-lived dispatches). Shared-branch
+          // dispatches MUST NOT auto-pick-up master mid-flight — the carve-out
+          // is explicit. Non-fatal: failures log + continue with the stale base,
+          // and the existing on-failure `git reset --hard origin/<mainRef>`
+          // recovery (~line 1452) remains the safety net.
+          const _depMainRef = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
+          const _depIsSharedBranch = meta?.branchStrategy === 'shared-branch' || meta?.useExistingBranch;
+          if (!_failedRefCache.has(_depMainRef)) {
+            try {
+              await adoGitAuth.runAdoGit(project, ['fetch', 'origin', _depMainRef], { ..._gitOpts, cwd: rootDir });
+            } catch (mainFetchErr) {
+              log('warn', `Failed to fetch origin/${_depMainRef} before dep merge: ${mainFetchErr.message} — proceeding with stale base`);
+              if (adoGitAuth.isAdoAuthFailure(mainFetchErr)) _depAuthFailed = true;
+              _failedRefCache.add(_depMainRef);
+            }
+          }
+          if (!_depIsSharedBranch) {
+            try {
+              await shared.shellSafeGit(['merge', `origin/${_depMainRef}`, '--no-edit', '--no-ff'], { ..._gitOpts, cwd: worktreePath });
+            } catch (mainMergeErr) {
+              log('warn', `Failed to merge origin/${_depMainRef} into ${branchName} before dep merge: ${mainMergeErr.message} — proceeding without main refresh`);
+              try { await shared.shellSafeGit(['merge', '--abort'], { ..._gitOpts, cwd: worktreePath }); } catch (_) { /* no merge in progress */ }
+            }
+          }
           // 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));

package/package.json

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