@yemi33/minions 0.1.2359 → 0.1.2361

package/engine/github.js

@@ -1161,7 +1161,7 @@ async function pollPrStatus(config) {
         try {
           const mergeMethod = ['squash', 'merge', 'rebase'].includes(config.engine?.prMergeMethod) ? config.engine.prMergeMethod : 'squash';
           // P-a7c4d2e8 (F1): argv-form merge call — eliminates shell interpolation of slug/prNum/mergeMethod.
-          await shared.shellSafeGh(['pr', 'merge', String(prNum), `--${mergeMethod}`, '--repo', shared.validateGhSlug(slug), '--delete-branch'], { timeout: 30000, maxBuffer: GH_MAX_BUFFER });
+          await shared.shellSafeGh(['pr', 'merge', String(prNum), `--${mergeMethod}`, '--repo', shared.validateGhSlug(slug), '--delete-branch', '--admin'], { timeout: 30000, maxBuffer: GH_MAX_BUFFER });
           pr._autoCompleted = true;
           log('info', `Auto-completed PR ${pr.id}: builds green + review approved → merged (${mergeMethod})`);
           updated = true;

package/engine/pipeline.js

@@ -1163,18 +1163,33 @@ async function discoverPipelineWork(config) {
             }).join('\n\n');
           }
 
-          // Scan for inbox/archive notes created by this stage's agents
+          // Scan for inbox/archive notes created by this stage's agents.
+          // stageWiIds are scoped to this run (work-item ids embed the unique
+          // run id), so matching on them alone is safe. stage.id/pipeline.id
+          // are STATIC across every run of a recurring pipeline, so a bare
+          // substring match on them would match every historical note ever
+          // written for that stage/pipeline name (W-mrcr6do0001404e6). Keep
+          // that fallback only as a safety net for notes that don't embed a
+          // WI id, and gate it on mtime >= this run's startedAt so it can
+          // never pick up notes older than the current run.
           try {
             const notesDirs = [
               NOTES_INBOX_DIR,
               NOTES_ARCHIVE_DIR,
             ];
             const stageWiIds = stageState.artifacts?.workItems || [];
+            const runStartedAt = activeRun.startedAt ? new Date(activeRun.startedAt).getTime() : 0;
             const notes = [];
             for (const dir of notesDirs) {
               for (const f of safeReadDir(dir).filter(n => n.endsWith('.md'))) {
-                if (stageWiIds.some(id => f.includes(id)) || f.includes(stage.id) || f.includes(pipeline.id)) {
+                if (stageWiIds.some(id => f.includes(id))) {
                   notes.push(f);
+                  continue;
+                }
+                if (f.includes(stage.id) || f.includes(pipeline.id)) {
+                  let mtime = 0;
+                  try { mtime = fs.statSync(path.join(dir, f)).mtimeMs; } catch { /* file may have vanished */ }
+                  if (mtime >= runStartedAt) notes.push(f);
                 }
               }
             }

package/engine.js

@@ -1023,22 +1023,44 @@ async function runWorktreeAdd(rootDir, worktreePath, addArgs, gitOpts, worktreeC
 // origin/<mainRef>; the stale-HEAD guard at the top of spawn-agent then
 // trips on every dispatch and the cooldown machinery starves the PR.
 //
-// Returns true only on a confirmed advertised head; ls-remote exit code 2
-// (no matching ref) and any other failure (network/auth) return false so
-// the caller falls back to the existing `-b origin/<mainRef>` path.
+// Returns true only on a confirmed advertised head. ls-remote exit code 2
+// (no matching ref — a clean, authoritative "branch does not exist upstream")
+// returns false so the caller falls back to the `-b origin/<mainRef>` path.
+//
+// Any OTHER failure (network blip, transient auth/401, ADO throttle, timeout)
+// is NOT a confirmed absence — conflating the two caused #767: a transient
+// probe failure against a branch that genuinely exists on origin (e.g. a
+// PR-author's real branch) silently took the fresh-branch fallback and
+// forked a divergent local branch under the same name instead of retrying.
+// We retry once with a short backoff (mirroring `_fetchWithTransientRetry`);
+// if the retry still doesn't cleanly resolve to "not found", we throw so the
+// caller does NOT treat this as a confirmed absence.
 async function probeBranchOnRemote(rootDir, branchName, gitOpts) {
   if (!branchName || !rootDir) return false;
+  const _attemptProbe = () => shared.shellSafeGit(
+    ['ls-remote', '--exit-code', '--heads', 'origin', branchName],
+    { ...gitOpts, cwd: rootDir, timeout: 10000 },
+  );
   try {
-    await shared.shellSafeGit(
-      ['ls-remote', '--exit-code', '--heads', 'origin', branchName],
-      { ...gitOpts, cwd: rootDir, timeout: 10000 },
-    );
+    await _attemptProbe();
     return true;
   } catch (e) {
-    if (e && e.code !== 2) {
-      log('warn', `probeBranchOnRemote: ls-remote --heads origin ${branchName} failed: ${(e.message || '').split('\n')[0].slice(0, 200)} — treating as not-on-remote`);
+    if (e && e.code === 2) return false; // clean, authoritative "not found"
+    const firstErrMsg = adoGitAuth.redactBearer(String(e?.message || e)).split('\n')[0].slice(0, 200);
+    log('warn', `probeBranchOnRemote: ls-remote --heads origin ${branchName} failed (${firstErrMsg}) — retrying once after 1.5s before giving up`);
+    await new Promise(r => setTimeout(r, 1500));
+    try {
+      await _attemptProbe();
+      return true;
+    } catch (e2) {
+      if (e2 && e2.code === 2) return false; // clean, authoritative "not found" on retry
+      const retryErrMsg = adoGitAuth.redactBearer(String(e2?.message || e2)).split('\n')[0].slice(0, 200);
+      log('warn', `probeBranchOnRemote: ls-remote --heads origin ${branchName} retry also failed (${retryErrMsg}) — cannot confirm branch absence, surfacing error`);
+      const probeErr = new Error(`probeBranchOnRemote: could not determine whether origin has ${branchName} after retry: ${retryErrMsg}`);
+      probeErr._probeFailed = true;
+      probeErr._cause = e2;
+      throw probeErr;
     }
-    return false;
   }
 }
 
@@ -6547,23 +6569,33 @@ function restoreHijackedOperatorCheckouts(config) {
       if (!localPath || !fs.existsSync(localPath)) continue;
       if (shared.resolveCheckoutMode(project) === shared.CHECKOUT_MODES.LIVE) continue; // live-mode: feature branch is intentional
       const main = project.mainBranch || 'main';
-      if (String(execSilent('git rev-parse --is-inside-work-tree', { cwd: localPath }) || '').trim() !== 'true') continue;
-      const cur = String(execSilent('git rev-parse --abbrev-ref HEAD', { cwd: localPath }) || '').trim();
+      const opts = { cwd: localPath };
+      // W-mrcvh5hw000o6cf1: use the argv-form (shell: false) git helper instead of
+      // execSilent(). execSilent() shells out via cmd.exe, which cannot chdir into
+      // a UNC path (`//wsl.localhost/...`, `\\server\share\...`) — it silently
+      // falls back to the Windows directory and every git call then fails with
+      // "fatal: not a git repository", every tick, forever, for WSL/UNC-hosted
+      // projects. shellSafeGitSync spawns git.exe directly (execFileSync,
+      // shell:false) so `cwd` is honored even for UNC paths.
+      let isRepo;
+      try { isRepo = String(shared.shellSafeGitSync(['rev-parse', '--is-inside-work-tree'], opts) || '').trim(); }
+      catch { continue; } // not a git repo (or transiently unreachable) — nothing to restore, skip quietly
+      if (isRepo !== 'true') continue;
+      const cur = String(shared.shellSafeGitSync(['rev-parse', '--abbrev-ref', 'HEAD'], opts) || '').trim();
       if (!cur || cur === 'HEAD' || cur === main) continue; // on main or detached — fine
-      const gitDir = String(execSilent('git rev-parse --git-dir', { cwd: localPath }) || '').trim();
+      const gitDir = String(shared.shellSafeGitSync(['rev-parse', '--git-dir'], opts) || '').trim();
       const absGitDir = gitDir ? (path.isAbsolute(gitDir) ? gitDir : path.join(localPath, gitDir)) : path.join(localPath, '.git');
       const mergeStuck = fs.existsSync(path.join(absGitDir, 'MERGE_HEAD'));
       const rebaseStuck = fs.existsSync(path.join(absGitDir, 'rebase-merge')) || fs.existsSync(path.join(absGitDir, 'rebase-apply'));
       if (!mergeStuck && !rebaseStuck && !_FLEET_BRANCH_RE.test(cur)) continue; // likely a human's deliberate checkout — leave it
       const why = mergeStuck ? ' (stuck merge)' : rebaseStuck ? ' (stuck rebase)' : ' (fleet branch in live checkout)';
       log('warn', `Operator checkout for ${project.name} is on '${cur}'${why}; worktree-mode requires ${main} — restoring`);
-      const opts = { cwd: localPath };
-      if (mergeStuck) execSilent('git merge --abort', opts);
-      if (rebaseStuck) execSilent('git rebase --abort', opts);
-      execSilent('git reset --hard HEAD', opts); // drop uncommitted hijack state; branch commits stay on the ref
+      if (mergeStuck) shared.shellSafeGitSync(['merge', '--abort'], opts);
+      if (rebaseStuck) shared.shellSafeGitSync(['rebase', '--abort'], opts);
+      shared.shellSafeGitSync(['reset', '--hard', 'HEAD'], opts); // drop uncommitted hijack state; branch commits stay on the ref
       try { shared.validateGitRef(main); } catch (ve) { throw new Error(`restoreHijackedOperatorCheckouts: invalid mainBranch ${JSON.stringify(main)}: ${ve.message}`); }
       shared.shellSafeGitSync(['checkout', main], opts);
-      const now = String(execSilent('git rev-parse --abbrev-ref HEAD', { cwd: localPath }) || '').trim();
+      const now = String(shared.shellSafeGitSync(['rev-parse', '--abbrev-ref', 'HEAD'], opts) || '').trim();
       if (now === main) {
         try {
           writeInboxAlert(`operator-checkout-restored-${project.name}`,

package/package.json

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