@yemi33/minions 0.1.2360 → 0.1.2362

package/dashboard.js

@@ -1373,6 +1373,11 @@ function linkPullRequestForTracking({ url, title, project: projectName, contextO
   }, {
     project: targetProject,
     itemId: linkedWorkItemId,
+    // W-mrdutzdr000t22f4 — a POST /api/pull-requests/link call is deliberate
+    // user intent to (re)track this PR. Unlike passive re-enrollment paths
+    // (pollers, enrollPrFromCanonicalId), this call site should clear a
+    // tombstone left by a prior explicit delete rather than silently no-op.
+    allowResurrect: true,
   });
   return { ...result, prPath, targetProject, projectResolution, prNum };
 }
@@ -13844,16 +13849,25 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       } catch (e) {
         return jsonReply(res, e.statusCode || 400, { error: e.message }, req);
       }
-      const { id: prId, prPath, prNum, created, linked, targetProject, projectResolution } = linkResult;
+      const { id: prId, prPath, prNum, created, linked, targetProject, projectResolution, skipped, resurrected } = linkResult;
       invalidateStatusCache();
+      // W-mrdutzdr000t22f4 — upsertPullRequestRecord can leave the record
+      // untouched (`skipped: true`) for reasons other than a resurrect, e.g.
+      // a legitimate cross-scope tombstone match it still refuses to touch.
+      // Surface that instead of always claiming success so a caller relying
+      // on "PR linked." isn't misled into thinking the record changed.
       jsonReply(res, 200, {
         ok: true,
         id: prId,
         created,
         linked,
+        skipped: skipped === true,
+        resurrected: resurrected === true,
         project: targetProject?.name || 'central',
         projectResolution,
-        message: projectResolution?.message || 'PR linked.',
+        message: skipped
+          ? 'PR was not linked: an existing tracked record blocked the update.'
+          : (projectResolution?.message || 'PR linked.'),
       });
 
       // Async-enrich: fetch title, description, branch, author from GitHub/ADO API

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/shared.js

@@ -7873,7 +7873,7 @@ function collapseDuplicatePrRecords(prPath, { project = null } = {}) {
  * manually records a PR for a work item must use this helper so the PR record
  * and the canonical work-item attachment are created together and idempotently.
  */
-function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null, itemIds = null, beforeInsert = null } = {}) {
+function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null, itemIds = null, beforeInsert = null, allowResurrect = false } = {}) {
   if (!prPath) throw new Error('prPath required');
   if (!entry || typeof entry !== 'object') throw new Error('entry required');
 
@@ -7906,6 +7906,7 @@ function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null,
   let created = false;
   let linked = false;
   let skipped = false;
+  let resurrected = false;
   let record = null;
 
   mutatePullRequests(prPath, (prs) => {
@@ -7914,9 +7915,20 @@ function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null,
     // Issue #384: tombstoned records (userDeleted:true) must not be re-activated
     // by any poller path. Return skipped so reconcilePrs / shared-branch-reconcile
     // cannot resurrect a PR the user explicitly removed.
+    //
+    // W-mrdutzdr000t22f4 — passive re-enrollment (pollers, enrollPrFromCanonicalId)
+    // must keep respecting the tombstone, but a deliberate user-initiated relink
+    // via POST /api/pull-requests/link is explicit intent to bring the PR back.
+    // Callers that want that behavior opt in with `allowResurrect: true`, which
+    // clears the tombstone here and lets the normal field-merge logic below run.
     if (target && target.userDeleted === true) {
-      skipped = true;
-      return prs;
+      if (!allowResurrect) {
+        skipped = true;
+        return prs;
+      }
+      delete target.userDeleted;
+      delete target.userDeletedAt;
+      resurrected = true;
     }
     // P-e9f0a2b4 — When findPrRecord returns null but multiple records share the
     // same prNumber (e.g. cross-scope contamination or a project-config change
@@ -7980,7 +7992,7 @@ function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null,
     }
   }
 
-  return { id: canonicalId, prNumber, created, linked, skipped, record };
+  return { id: canonicalId, prNumber, created, linked, skipped, resurrected, record };
 }
 
 // ─── PR Reference → URL Derivation ───────────────────────────────────────────

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.2362",
   "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"