@yemi33/minions 0.1.2360 → 0.1.2361

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

@@ -6569,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.2360",
+  "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"