@yemi33/minions 0.1.2349 → 0.1.2351

package/engine/kb-sweep.js

@@ -658,8 +658,14 @@ ${body}`;
   return { processed, bytesBefore, bytesAfter };
 }
 
-function _applyLlmPlan(plan, manifest, opts = {}) {
+function _applyLlmPlan(plan, manifest, changedIdx, opts = {}) {
   let removed = 0, merged = 0, reclassified = 0;
+  // changedIdx is the set of manifest indices actually content-analyzed by
+  // the LLM this batch (see _llmBatchSweep's scannedIdx). Duplicate pairs
+  // referencing only unanalyzed indices (LLM hallucination / stale index
+  // mis-reference) must never be archived — a pair is only trustworthy if
+  // at least one side was actually analyzed this batch (W-mrb447th00062813).
+  const changedSet = new Set(changedIdx || []);
   for (const r of (plan.remove || [])) {
     const entry = manifest[r.index];
     if (!entry) continue;
@@ -667,6 +673,11 @@ function _applyLlmPlan(plan, manifest, opts = {}) {
     if (_archiveKbFile(path.join(KB_DIR, entry.category, entry.file), `stale: ${r.reason || ''}`)) removed++;
   }
   for (const d of (plan.duplicates || [])) {
+    const pairIdx = [d.keep, ...(d.remove || [])];
+    if (!pairIdx.some((idx) => changedSet.has(idx))) {
+      log('warn', `[kb-sweep] duplicate pair (keep=${d.keep}, remove=${JSON.stringify(d.remove)}) references no analyzed (changedIdx) entry — skipping archive to avoid acting on a hallucinated/stale LLM reference`);
+      continue;
+    }
     for (const idx of (d.remove || [])) {
       const entry = manifest[idx];
       if (!entry) continue;
@@ -954,7 +965,7 @@ async function _runKbSweepImpl(opts = {}) {
   // Only runs against survivors, but we need indices that match the LIST sent to the LLM
   const llmManifest = afterConsolidate;
   const { plan, scannedIdx: llmScannedIdx } = await _llmBatchSweep(llmManifest, callLLM, trackEngineUsage, opts);
-  const llmActions = _applyLlmPlan(plan, llmManifest, opts);
+  const llmActions = _applyLlmPlan(plan, llmManifest, llmScannedIdx, opts);
   summary.llmDuplicatesArchived = llmActions.merged;
   summary.staleRemoved = llmActions.removed;
   summary.reclassified = llmActions.reclassified;
@@ -1170,6 +1181,7 @@ module.exports = {
   _llmBatchSweep,
   _classifyLlmScanFreshness,
   _markLlmScanned,
+  _applyLlmPlan,
   LLM_SCAN_FLAG_KEY,
   CONSOLIDATION_DIGEST_PREFIX,
   COMPRESS_THRESHOLD_BYTES,

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.2349",
+  "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"