@yemi33/minions 0.1.2350 → 0.1.2351

package/engine/live-checkout.js

@@ -389,6 +389,45 @@ function _defaultWriteInboxNote(slug, content) {
   return require('./dispatch').writeInboxAlert(slug, content);
 }
 
+// Best-effort, side-effect-light resolution of `mainRef` as a restore target
+// when a captured originalRef is found to be contaminated (see
+// ENGINE_DISPATCH_BRANCH_PATTERN above). Mirrors the STALE-BASE GUARD's
+// local-main / auto-base-repair fallback (Step 4d) but never switches HEAD
+// itself — it only materializes a local `<mainRef>` branch (a plain ref op,
+// no checkout, no fetch, issue #226 preserved) when auto-base-repair is
+// enabled and no local ref already exists. Returns `{ ref, type }` on success
+// or `{ ref: null, type: null }` when mainRef cannot be resolved without a
+// fetch and auto-base-repair is disabled or unavailable.
+async function _resolveMainRefForRestore({ git, baseOpts, mainRef, autoBaseRepair, _resolveAutoBaseRepair, localPath, logFn }) {
+  try {
+    await git(['rev-parse', '--verify', '--quiet', `refs/heads/${mainRef}`], baseOpts);
+    return { ref: mainRef, type: 'branch' };
+  } catch { /* fall through to auto-repair */ }
+
+  let wantBaseRepair = false;
+  if (typeof autoBaseRepair === 'boolean') {
+    wantBaseRepair = autoBaseRepair;
+  } else {
+    const resolver = (typeof _resolveAutoBaseRepair === 'function') ? _resolveAutoBaseRepair : _defaultResolveAutoBaseRepair;
+    try { wantBaseRepair = !!resolver(localPath); } catch { wantBaseRepair = false; }
+  }
+  if (!wantBaseRepair) return { ref: null, type: null };
+
+  try {
+    await git(['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${mainRef}`], baseOpts);
+  } catch {
+    return { ref: null, type: null };
+  }
+  try {
+    await git(['branch', '--no-track', mainRef, `refs/remotes/origin/${mainRef}`], baseOpts);
+    logFn('info',
+      `live-checkout: materialized local '${mainRef}' from 'origin/${mainRef}' (no fetch, issue #226 preserved) to correct a contaminated originalRef.`);
+    return { ref: mainRef, type: 'branch' };
+  } catch {
+    return { ref: null, type: null };
+  }
+}
+
 async function prepareLiveCheckout(opts = {}) {
   const {
     localPath,
@@ -842,6 +881,32 @@ async function prepareLiveCheckout(opts = {}) {
     // Plain checkout — NO --force, NO -B, NO pull. Operator owns local commits.
     const failed = await runCheckout(['checkout', branchName], { creating: false });
     if (failed) return failed;
+    // ── originalRef contamination invariant (W-mrb6an8300058fd8). ──────────
+    // originalRef was captured at Step 3 BEFORE this checkout, from whatever
+    // HEAD happened to be. If it itself looks like a prior dispatch's own
+    // engine-managed branch (`_looksLikeAgentBranch` — the same `work/<id>`
+    // check issue #608's dirty-tree self-heal uses above) — and this isn't an
+    // explicit PR-continuation (allowNonMainBase) — it is never a sane restore
+    // target: prefer mainRef instead, while still surfacing the anomaly via
+    // logFn rather than silently swallowing it.
+    if (!allowNonMainBase && originalRefType === 'branch' && originalRef && originalRef !== mainRef &&
+        _looksLikeAgentBranch(originalRef)) {
+      logFn(
+        `[live-checkout] originalRef anomaly: HEAD was on engine-managed branch '${originalRef}' before checking out '${branchName}' — ` +
+        `this looks like leftover contamination from an earlier dispatch, not a sane restore target. Attempting to correct to '${mainRef}'.`,
+        'warn'
+      );
+      const corrected = await _resolveMainRefForRestore({ git, baseOpts, mainRef, autoBaseRepair, _resolveAutoBaseRepair, localPath, logFn });
+      if (corrected.ref) {
+        originalRef = corrected.ref;
+        originalRefType = corrected.type;
+      } else {
+        logFn(
+          `[live-checkout] originalRef anomaly: could not resolve '${mainRef}' as a corrected restore target (no local ref, auto-base-repair disabled, or 'origin/${mainRef}' missing) — leaving originalRef as the contaminated '${originalRef}'; a human should verify the operator checkout manually.`,
+          'warn'
+        );
+      }
+    }
     return { ok: true, branch: branchName, created: false, originalRef, originalRefType };
   }
 
@@ -983,6 +1048,21 @@ async function prepareLiveCheckout(opts = {}) {
       }
       logFn('info',
         `live-checkout: HEAD was on '${headBranch}' (not base '${mainRef}') — switched to local '${mainRef}' before forking '${branchName}' (no fetch, issue #226 preserved)`);
+      // ── originalRef correction (W-mrb6an8300058fd8). ─────────────────────
+      // originalRef/originalRefType were captured at Step 3 from the STALE
+      // headBranch, BEFORE this self-heal ran. The tree has now been switched
+      // to the CORRECTED mainRef, so the value returned to the caller (and
+      // persisted on the dispatch record — engine.js spawnAgent ~line
+      // 3106-3122) must reflect mainRef, not the stale branch. Otherwise
+      // restoreLiveCheckoutAtDispatchEnd would put the operator checkout BACK
+      // onto the stale branch at dispatch end, propagating the contamination
+      // into every subsequent live-mode dispatch that captures HEAD (the
+      // exact recurrence observed on minions-opg 2026-07-07: HEAD landed on
+      // 'main' via this self-heal, but the persisted originalRef still said
+      // 'work/sched-daily-remove-merged-prs-…', so the dispatch-end restore
+      // switched the operator checkout back onto that stale branch).
+      originalRef = mainRef;
+      originalRefType = 'branch';
     }
   }
 

package/package.json

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