@yemi33/minions 0.1.2448 → 0.1.2449

package/engine/{github.js → providers/github.js}

@@ -1,45 +1,46 @@
 /**
- * engine/github.js — GitHub integration for Minions engine.
+ * engine/providers/github.js — GitHub integration for Minions engine.
  * Parallel to ado.js: PR status polling, comment polling, reconciliation for GitHub-hosted projects.
  * Uses `gh` CLI for all GitHub API calls.
  */
 
-const shared = require('./shared');
-const { exec, execAsync, getProjects, readWorkItems, readPullRequests, safeJson, safeJsonArr, safeWrite, mutateMetrics, mutatePullRequests, MINIONS_DIR, getPrLinks, backfillPrPrdItems, log, ts, dateStamp, PR_STATUS, PR_POLLABLE_STATUSES, BUILD_STATUS, REVIEW_STATUS, FETCH_TIMEOUT_MS, ENGINE_DEFAULTS, createThrottleTracker, getProjectOrg } = shared;
-const { getPrs } = require('./queries');
+const shared = require('../core/shared');
+const { exec, execAsync, getProjects, readWorkItems, readPullRequests, safeJson, safeJsonArr, safeWrite, mutateMetrics, mutatePullRequests, MINIONS_DIR, getPrLinks, backfillPrPrdItems, log, ts, dateStamp, PR_STATUS, BUILD_STATUS, REVIEW_STATUS, FETCH_TIMEOUT_MS, ENGINE_DEFAULTS, createThrottleTracker, getProjectOrg } = shared;
+const { getPrs } = require('../core/queries');
 const {
   isPreviewStatusBody,
-  hasMinionsMarker,
   hasVerdictPrefix,
+  classifyMarkerAuthorship,
+  isMarkerAuthored,
   classifyNonActionableAutomationComment,
 } = require('./comment-classifier');
-const { wrapUntrusted, buildSource } = require('./untrusted-fence');
-const reviewLearning = require('./review-learning');
+const { wrapUntrusted, buildSource } = require('../core/untrusted-fence');
+const reviewLearning = require('../memory/review-learning');
 const ghToken = require('./gh-token');
 const path = require('path');
 
 // Lazy require to avoid circular dependency — only needed for engine().handlePostMerge
 let _engine = null;
 function engine() {
-  if (!_engine) _engine = require('../engine');
+  if (!_engine) _engine = require('../../engine');
   return _engine;
 }
 
 // Lazy require for dispatch module (avoids circular dependency via engine)
 let _dispatch = null;
-function dispatchModule() { if (!_dispatch) _dispatch = require('./dispatch'); return _dispatch; }
+function dispatchModule() { if (!_dispatch) _dispatch = require('../orchestration/dispatch'); return _dispatch; }
 
 // Lazy require for lifecycle module — only needed for the stale-noopfix sweep
 // in pollPrStatus (W-mpx44p05000ze8d8). lifecycle.js lazy-requires github.js
 // back, so this MUST stay lazy to avoid a circular import at module-load time.
 let _lifecycle = null;
-function lifecycleModule() { if (!_lifecycle) _lifecycle = require('./lifecycle'); return _lifecycle; }
+function lifecycleModule() { if (!_lifecycle) _lifecycle = require('../orchestration/lifecycle'); return _lifecycle; }
 
 // W-mp5trwh60008386d: test seam so unit tests can mock `gh api` shell-outs
 // without spawning the real CLI. Production code goes through the real
 // `execAsync` from shared; tests call `_setExecAsyncForTest(fn)` to swap in
 // a stub. Pass `null` to restore. Mirrors the `_setAdoTokenForTest` pattern
-// in engine/ado.js.
+// in engine/ado/index.js.
 let _execAsyncOverride = null;
 function _runExec(cmd, opts) {
   return (_execAsyncOverride || execAsync)(cmd, opts);
@@ -142,11 +143,11 @@ function getConfiguredGitHubAuthorLogins(config = {}) {
 }
 
 // P-f23classifier (F4): delegates to the host-agnostic VERDICT prefix check
-// in engine/comment-classifier.js. The literal regex used to live here;
+// in engine/providers/comment-classifier.js. The literal regex used to live here;
 // extraction allowed F4 (Wave 3) to tighten the prefix in a single place.
 // The tightened form requires `VERDICT: APPROVE|REQUEST_CHANGES` at line
 // start (under /m), optionally wrapped in `**`, `__`, or `#+ ` markers —
-// see engine/comment-classifier.js for the full contract.
+// see engine/providers/comment-classifier.js for the full contract.
 function _hasMinionsReviewVerdict(body) {
   return hasVerdictPrefix(body);
 }
@@ -169,7 +170,7 @@ function _isGitHubBotComment(c) {
 
 // P-f23classifier (F2): retains the GH-side bot-author gate (ADO has no
 // `user.type === 'bot'` equivalent) but delegates the body check to the
-// host-agnostic isPreviewStatusBody helper in engine/comment-classifier.js.
+// host-agnostic isPreviewStatusBody helper in engine/providers/comment-classifier.js.
 // The body matcher covers Coverage/Build/Test/Deploy/Pipeline report
 // headings + Firebase App Distribution + Appetize + Deploy-ready phrases +
 // shields.io badges (same set as before the extraction).
@@ -213,11 +214,11 @@ function _entryCommentKey(entry) {
 // Replaces the body-shape classifier chain (PR #2431's _isAgentSelfReviewDeclinedComment,
 // PR #2442's _isAgentPositiveSignalComment + _hasAgentPositiveSignalBody) with a single
 // structural check: a Minions-authored comment carries `MINIONS_COMMENT_MARKER` (defined
-// in engine/gh-comment.js) on its own first line AND was authored by the viewer (the
+// in engine/providers/gh-comment.js) on its own first line AND was authored by the viewer (the
 // shared PAT identity used by all minions agents).
 //
-// Both gates are required:
-//   - `viewerDidAuthor: true` prevents humans from spoofing the marker by quoting it.
+// Both gates are required whenever the viewer identity is KNOWN:
+//   - `viewerDidAuthor: false` prevents humans from spoofing the marker by quoting it.
 //   - `MINIONS_COMMENT_MARKER_RE` enforces "own first line" — quoted markers in the
 //     middle of a comment, or markers with trailing content on the same line, do NOT
 //     match. This is the structural complement to the viewer check.
@@ -233,12 +234,31 @@ function _entryCommentKey(entry) {
 // Sub-item -c migrates existing engine call sites + playbook examples.
 //
 // P-f23classifier (F3): the body-only "structural marker on own first line"
-// check is now hasMinionsMarker in engine/comment-classifier.js. GH retains
-// the viewerDidAuthor gate as the spoof guard (ADO uses a uniqueName cross-
-// check against config.engine.minionsAdoIdentities instead — see ado.js).
+// check is now hasMinionsMarker in engine/providers/comment-classifier.js.
+//
+// W-msbf1kf6033f46cb — marker authorship resolves through the shared
+// `classifyMarkerAuthorship` seam that engine/ado/index.js also uses, so the
+// two pollers cannot drift (mirror-ado-github-poll-fix convention). Only the
+// identity SOURCE differs: GH derives it from `viewerDidAuthor` (resolved at
+// runtime), ADO from the `config.engine.minionsAdoIdentities` allowlist.
+//
+// `viewerDidAuthor` is a tri-state here: `true`/`false` mean the viewer login
+// was resolved and the comment either is or is not ours, while `null`/absent
+// means the signal is unavailable (`_backfillViewerDidAuthor` no-ops without a
+// viewer login or an author login). The spoof guard is unchanged for the
+// `false` case — a real human who pasted our marker stays actionable. Only the
+// unavailable case now fails safe instead of open, matching ADO. In production
+// GH never reaches that case: `pollPrHumanComments` already skips the whole PR
+// when `_resolveViewerLogin` returns null (OQ-Y), so this is defense in depth
+// against that upstream guard being removed.
 function _isMinionsAuthoredComment(c) {
-  if (!c || c.viewerDidAuthor !== true) return false;
-  return hasMinionsMarker(c.body || '');
+  if (!c) return false;
+  const identityAvailable = c.viewerDidAuthor === true || c.viewerDidAuthor === false;
+  return isMarkerAuthored(classifyMarkerAuthorship({
+    body: c.body || '',
+    identityAvailable,
+    identityMatches: c.viewerDidAuthor === true,
+  }));
 }
 
 // ─── Viewer Login Resolution ────────────────────────────────────────────────
@@ -251,7 +271,7 @@ function _isMinionsAuthoredComment(c) {
 // the viewer login resolved via `gh api user`.
 //
 // W-mp76pw7a001da7c1 — The viewer login is no longer process-wide because
-// `ghApi` now resolves a per-slug token via `engine/gh-token.js`. Different
+// `ghApi` now resolves a per-slug token via `engine/providers/gh-token.js`. Different
 // accounts return different logins from `gh api user`, so the cache is keyed
 // by the resolved account name (or the sentinel `__ambient__` when no
 // account mapping applies and the call falls back to the ambient gh
@@ -291,7 +311,7 @@ async function _resolveViewerLogin(slug) {
 // data is still worth tracking so future audits can prioritize a deeper fix
 // (e.g. a credentialed re-probe of the gh CLI). Global counter under
 // `_engine.viewerLoginResolutionFailures`; surfaced through the existing
-// engine metrics aggregation (`getMetrics()` in `engine/queries.js`).
+// engine metrics aggregation (`getMetrics()` in `engine/core/queries.js`).
 function _incrementViewerLoginResolutionFailures() {
   try {
     mutateMetrics((metrics) => {
@@ -530,10 +550,18 @@ async function fetchGhBuildErrorLog(slug, failedRuns) {
 
 // ─── Shared PR Polling Loop ─────────────────────────────────────────────────
 
-async function forEachActiveGhPr(config, callback) {
+async function forEachActiveGhPr(config, callback, options = {}) {
   const projects = getProjects(config).filter(isGitHub);
   let totalUpdated = 0;
 
+  // W-msav5edk00g81710 — bounded re-probe of recently-abandoned records. Opt-in
+  // per call site (pollPrStatus only): the reopen signal lives on the status
+  // endpoint, so widening the comment poller would burn quota for no signal.
+  const pollOpts = {
+    windowMs: Number(options.abandonedRepollWindowMs) || 0,
+    now: Date.now(),
+  };
+
   for (const project of projects) {
     // W-mp625n27000m6e78 — Honor per-project workSources.pullRequests.enabled.
     // Default-ON: only skip when explicitly disabled (=== false). Missing/undefined
@@ -545,7 +573,7 @@ async function forEachActiveGhPr(config, callback) {
     if (src && src.enabled === false) continue;
 
     const prs = getPrs(project);
-    const activePrs = prs.filter(pr => PR_POLLABLE_STATUSES.has(pr.status)
+    const activePrs = prs.filter(pr => shared.isPrPollable(pr, pollOpts)
       && shared.isPrCompatibleWithProject(project, pr, pr.url || ''));
     if (activePrs.length === 0) continue;
 
@@ -640,7 +668,7 @@ async function forEachActiveGhPr(config, callback) {
     for (const slug of getProjectRepoSlugs(project)) configuredGhProjectsBySlug.set(slug.toLowerCase(), project);
   }
   const activeCentral = centralPrs.filter(pr => {
-    if (!PR_POLLABLE_STATUSES.has(pr.status)) return false;
+    if (!shared.isPrPollable(pr, pollOpts)) return false;
     if (!pr.url) return false;
     // Symmetric fix for #328: only defer to the project loop when the PR is
     // ACTUALLY present in that project's per-project file. If it's absent there,
@@ -696,7 +724,7 @@ async function forEachActiveGhPr(config, callback) {
       if (updated) {
         // Also update title/author/branch if still placeholder
         const currentTitle = pr.title || '';
-        if (shared.isPlaceholderPrTitle(currentTitle) || pr.agent === 'human' || pr.description === undefined) {
+        if (shared.isPlaceholderPrTitle(currentTitle) || !pr.author || pr.description === undefined) {
           const prData = await ghApi(`/pulls/${prNum}`, slug);
           if (prData) {
             const latestTitle = pr.title || '';
@@ -704,7 +732,10 @@ async function forEachActiveGhPr(config, callback) {
               pr.title = (prData.title || latestTitle).slice(0, 120);
             }
             if (pr.description === undefined) pr.description = (prData.body || '').slice(0, 500);
-            if (pr.agent === 'human' && prData.user?.login) pr.agent = prData.user.login;
+            // Populate the real author identity from PR metadata. Never overwrite
+            // pr.agent (the Minions author-agent) with a human login.
+            const ghAuthor = shared.buildGithubAuthorIdentity(prData.user);
+            if (ghAuthor) pr.author = shared.mergePrAuthorIdentity(pr.author, ghAuthor);
             if (!pr.branch && prData.head?.ref) {
               // P-a7c4d2e8 (F3): validate API-derived branch ref before
               // persistence. Defensive degrade — log and skip on invalid ref
@@ -757,7 +788,7 @@ async function forEachActiveGhPr(config, callback) {
 }
 
 /**
- * Issue #633 (mirror of engine/ado.js isStaleAdoRejectVote) — GitHub reviews
+ * Issue #633 (mirror of engine/ado/index.js isStaleAdoRejectVote) — GitHub reviews
  * generally get dismissed/replaced when a reviewer re-reviews, but a stale
  * CHANGES_REQUESTED review from a login that never re-reviews after a fix can
  * still pin `reviewStatus` at 'changes-requested' forever (the reviewer's
@@ -796,19 +827,36 @@ async function pollPrStatus(config) {
       if (next >= confirmCount) {
         if (pr.status !== PR_STATUS.ABANDONED) {
           pr.status = PR_STATUS.ABANDONED;
+          // W-msav5edk00g81710: anchor the bounded re-probe window. This path
+          // never sets `closedAt` (there is no platform record to read it from),
+          // so without the stamp a 404-abandoned record would have no age at all
+          // and `isPrPollable` would fail closed on it forever.
+          shared.stampPrAbandonedAt(pr, ts());
           delete pr._consecutive404s;
           log('info', `PR ${pr.id} returned 404 ${next} consecutive polls — marking abandoned`);
           return true;
         }
-        // Already abandoned; clear the counter if it lingered.
+        // Already abandoned and still 404ing under a healthy base-repo probe —
+        // that is exactly the evidence reconcileAbandonedPrs uses to confirm a
+        // genuine deletion (W-msav5edk00g81710). Record it so the PR drops out
+        // of the bounded re-probe window immediately instead of sawtoothing the
+        // counter for the window's full duration.
+        let changed = false;
         if (pr._consecutive404s) {
           delete pr._consecutive404s;
-          return true;
+          changed = true;
+        }
+        if (!pr._reconciliation404Confirmed) {
+          pr._reconciliation404Confirmed = true;
+          log('info', `PR ${pr.id} confirmed deleted after ${next} consecutive 404s — closing the abandoned re-probe window`);
+          changed = true;
         }
-        return false;
+        return changed;
       }
       pr._consecutive404s = next;
-      log('warn', `PR ${pr.id} returned 404 (${next}/${confirmCount}) — deferring abandonment until threshold`);
+      log('warn', pr.status === PR_STATUS.ABANDONED
+        ? `PR ${pr.id} returned 404 (${next}/${confirmCount}) — confirming deletion before closing the abandoned re-probe window`
+        : `PR ${pr.id} returned 404 (${next}/${confirmCount}) — deferring abandonment until threshold`);
       return true; // counter increment is a state change worth persisting
     }
 
@@ -855,9 +903,17 @@ async function pollPrStatus(config) {
       pr.description = (prData.body || '').slice(0, 500);
       updated = true;
     }
-    if (pr.agent === 'human' && prData.user?.login) {
-      pr.agent = prData.user.login;
-      updated = true;
+    // Populate the real author identity from PR metadata. Never overwrite
+    // pr.agent (the Minions author-agent) with a human login.
+    {
+      const ghAuthor = shared.buildGithubAuthorIdentity(prData.user);
+      if (ghAuthor) {
+        const mergedAuthor = shared.mergePrAuthorIdentity(pr.author, ghAuthor);
+        if (JSON.stringify(mergedAuthor) !== JSON.stringify(pr.author || null)) {
+          pr.author = mergedAuthor;
+          updated = true;
+        }
+      }
     }
 
     // Map GitHub PR state to minions status
@@ -904,7 +960,7 @@ async function pollPrStatus(config) {
     }
 
     // P-w1a3f9b2 — Phase 1.1: plumb mergeable / isDraft / mergeStateStatus /
-    // headRefOid onto the PR object so watches captureState (engine/watches.js)
+    // headRefOid onto the PR object so watches captureState (engine/watches/index.js)
     // and future predicates (Phase 2.1: head-commit-change, mergeable-flipped,
     // ready-for-merge, draft-flipped) can read them. We mirror GitHub's
     // tri-state contract for `mergeable` (true|false|null — see
@@ -949,9 +1005,9 @@ async function pollPrStatus(config) {
     // needing a separate counter. When skipped (flag off, PR closed,
     // missing refs, cross-repo fork, or compare-API error), behindBy is
     // explicitly set to null so the `behind-master` predicate
-    // (engine/watches.js BEHIND_MASTER) treats it as "no signal" and does
+    // (engine/watches/index.js BEHIND_MASTER) treats it as "no signal" and does
     // not over-fire on legacy / stale state. ADO PRs are handled in
-    // engine/ado.js with the same null contract.
+    // engine/ado/index.js with the same null contract.
     const includeBehindBy = config.engine?.watchesIncludeBehindBy === true;
     let newBehindBy = null;
     if (includeBehindBy && prData.state === 'open' && prData.base?.ref && prData.head?.sha) {
@@ -987,6 +1043,12 @@ async function pollPrStatus(config) {
       if ((newStatus === PR_STATUS.ABANDONED || newStatus === PR_STATUS.CLOSED) && !pr.closedAt) {
         pr.closedAt = prData.closed_at || ts();
       }
+      // W-msav5edk00g81710: anchor the bounded re-probe window on every entry
+      // into `abandoned`, including a re-close after a reopen (the window must
+      // restart, not inherit the first closure's age).
+      if (newStatus === PR_STATUS.ABANDONED) {
+        shared.stampPrAbandonedAt(pr, prData.closed_at || pr.closedAt || ts());
+      }
 
       if (newStatus === PR_STATUS.MERGED || newStatus === PR_STATUS.ABANDONED) {
         // Resolve stale 'waiting' review status — won't be polled again after this
@@ -1022,7 +1084,7 @@ async function pollPrStatus(config) {
       // references it. Invariant #14 ('approved is permanent terminal') is
       // preserved: we keep reviewStatus when it was 'approved' rather than
       // carving a wasReopened exception into the 8+ guard sites in
-      // engine/lifecycle.js, engine.js, engine/github.js, and engine/ado.js.
+      // engine/orchestration/lifecycle.js, engine.js, engine/providers/github.js, and engine/ado/index.js.
       // Re-review safety on new commits is handled by the pre-existing
       // pr.lastPushedAt > pr.lastReviewedAt path (engine.js alreadyReviewed
       // gate) plus the changes-requested override in lifecycle.js.
@@ -1035,6 +1097,11 @@ async function pollPrStatus(config) {
         // F6 not yet shipped (field absent).
         delete pr.humanFeedback.editsSeen;
         pr.fixDispatched = false;
+        // W-msav5edk00g81710: the record is no longer abandoned, so the
+        // re-probe anchor (and the stale close timestamp it falls back to)
+        // must not survive — a later re-close re-stamps a fresh window.
+        shared.clearPrAbandonedAt(pr);
+        delete pr.closedAt;
         if (pr.reviewStatus !== REVIEW_STATUS.APPROVED) pr.reviewStatus = REVIEW_STATUS.PENDING;
         log('info', `PR ${pr.id} reopened — reset transient state (reviewStatus=${pr.reviewStatus})`);
       }
@@ -1215,6 +1282,11 @@ async function pollPrStatus(config) {
     }
 
     return updated;
+  }, {
+    // W-msav5edk00g81710 — only the STATUS poll re-probes recently-abandoned
+    // records; that is where the host reports the reopen. `0` (operator opt-out)
+    // restores the strict PR_POLLABLE_STATUSES filter.
+    abandonedRepollWindowMs: shared.resolveAbandonedPrRepollWindowMs(config),
   });
 
   if (totalUpdated > 0) {
@@ -1228,13 +1300,13 @@ async function pollPrHumanComments(config) {
   // Load dispatch state once per poll cycle (cached for ~2s by queries.getDispatch).
   // (Previously used by `_isAgentSelfReviewDeclinedComment` to verify dispatch ids;
   // kept loaded in case downstream phases need dispatch context — cheap on cache hit.)
-  const queries = require('./queries');
+  const queries = require('../core/queries');
   const dispatch = (() => {
     try { return queries.getDispatch(); }
     catch { return { pending: [], active: [], completed: [] }; }
   })();
   // Viewer login is resolved per-PR (cheap on cache hit) because each slug
-  // can route to a different gh account via `engine/gh-token.js`. The cache
+  // can route to a different gh account via `engine/providers/gh-token.js`. The cache
   // is keyed by the resolved account name, so multiple PRs sharing one
   // account pay only the first shell-out.
   const totalUpdated = await forEachActiveGhPr(config, async (project, pr, prNum, slug) => {
@@ -1463,7 +1535,7 @@ async function pollPrHumanComments(config) {
       // `${threadId}:${commentId}` shape so the guard compares a single key
       // form. Falls back to the bare id when `_type` is absent (defensive;
       // every entry above sets it, but the pollPrHumanComments path in
-      // engine/ado.js writes the legacy format too).
+      // engine/ado/index.js writes the legacy format too).
       lastProcessedCommentKey: newComments[newComments.length - 1].commentKey || _entryCommentKey(newComments[newComments.length - 1]),
       pendingFix: true,
       feedbackContent,
@@ -1567,7 +1639,8 @@ async function reconcilePrs(config) {
             id: prId,
             prNumber: ghPr.number,
             title: (ghPr.title || `PR #${ghPr.number}`).slice(0, 120),
-            agent: (linkedItem?.dispatched_to || ghPr.user?.login || 'unknown').toLowerCase(),
+            agent: (linkedItem?.dispatched_to || shared.PR_AGENT_HUMAN).toLowerCase(),
+            author: shared.buildGithubAuthorIdentity(ghPr.user),
             branch,
             reviewStatus: REVIEW_STATUS.PENDING,
             status: PR_STATUS.ACTIVE,
@@ -1611,7 +1684,8 @@ async function reconcilePrs(config) {
         id: prId,
         prNumber: ghPr.number,
         title: (ghPr.title || `PR #${ghPr.number}`).slice(0, 120),
-        agent: (linkedItem?.dispatched_to || ghPr.user?.login || 'unknown').toLowerCase(),
+        agent: (linkedItem?.dispatched_to || shared.PR_AGENT_HUMAN).toLowerCase(),
+        author: shared.buildGithubAuthorIdentity(ghPr.user),
         branch,
         reviewStatus: REVIEW_STATUS.PENDING,
         status: PR_STATUS.ACTIVE,
@@ -1883,12 +1957,12 @@ async function checkLiveBuildAndConflict(pr, project) {
 // ─── One-Shot Startup Reconciliation for Abandoned PRs (W-mp60tw0u000j3931) ───
 //
 // Pairs with the W-mp5trwh60008386d 404-hardening fix in pollPrStatus.
-// pollPrStatus only iterates PR_POLLABLE_STATUSES = {active, linked} — once a
-// PR has status: 'abandoned' it is terminal for the regular poll loop. That
-// behavior is correct (no per-tick re-probing of dead PRs), but it leaves any
-// historical false-flips (e.g. the 16 PRs marked abandoned by the 2026-05-14
-// gh-auth-flip incident) permanently stuck unless something explicitly
-// re-probes the abandoned set.
+// W-msav5edk00g81710 gave `abandoned` records a BOUNDED re-probe window in the
+// normal poll (`shared.isPrPollable`), so a recently-abandoned PR that gets
+// reopened now self-heals within one poll cycle. This pass remains the only
+// heal path for records OUTSIDE that window — historical false-flips (e.g. the
+// 16 PRs marked abandoned by the 2026-05-14 gh-auth-flip incident) and anything
+// abandoned longer ago than `engine.abandonedPrRepollWindowMs`.
 //
 // This function is the explicit re-probe. Same base-repo probe gate as
 // pollPrStatus (cached per slug for the duration of the pass), then a single
@@ -1897,7 +1971,7 @@ async function checkLiveBuildAndConflict(pr, project) {
 // `_reconciliation404Confirmed: true` so we don't re-probe deleted PRs on
 // every future restart.
 //
-// Caller: engine/abandoned-pr-reconciliation.js (version-gated).
+// Caller: engine/providers/abandoned-pr-reconciliation.js (version-gated).
 async function reconcileAbandonedPrs(config) {
   const projects = shared.getProjects(config).filter(isGitHub);
   let flipped = 0, confirmedDeleted = 0, skipped = 0, errored = 0;
@@ -2010,6 +2084,9 @@ async function reconcileAbandonedPrs(config) {
             delete pr._consecutive404s;
             delete pr._404Count;
             delete pr._404FirstAt;
+            // W-msav5edk00g81710: the record left `abandoned`, so drop the
+            // bounded-re-probe anchor with it.
+            if (upd.newStatus !== PR_STATUS.ABANDONED) shared.clearPrAbandonedAt(pr);
             pr._reconciledAt = reconciledAt;
             pr._reconciledFrom = 'startup-pass';
           } else if (upd.action === 'confirm404') {
@@ -2035,7 +2112,7 @@ module.exports = {
   dismissPriorViewerChangesRequestedReviews, // W-mp7b1g8q000fea45 — clear stale CHANGES_REQUESTED on verdict flip
   isGhThrottled,
   getGhThrottleState,
-  ghApi, // P-8c1b6e45 — used by engine/shared-branch-pr-reconcile.js to list open PRs on a feature branch
+  ghApi, // P-8c1b6e45 — used by engine/providers/shared-branch-pr-reconcile.js to list open PRs on a feature branch
   prExists, // issue #246 — confirm a loose ref points at a PR (not an issue) before stamping
   getPrChangedFiles, // W-mr9jo2n2000667ad — stale-PR-pruner scope-overlap verification
   // Exported for testing

package/engine/{pr-action.js → providers/pr-action.js}

@@ -1,20 +1,20 @@
 /**
- * engine/pr-action.js — Projectless PR action validator/handle + read-only
+ * engine/providers/pr-action.js — Projectless PR action validator/handle + read-only
  * dispatch path.
  *
  * Plan: projectless-pr-actions, items P-ppa10002 (endpoint + handle) and
  * P-ppa10003 (the read-only projectless dispatch path). Backs the
  * user-initiated `POST /api/pr-action { url, action }` endpoint (dashboard.js).
  * It validates the action against an explicit allowlist, resolves the PR
- * reference via the P-ppa10001 resolver (engine/pr-resolve.js#normalizePrRef),
+ * reference via the P-ppa10001 resolver (engine/providers/pr-resolve.js#normalizePrRef),
  * and mints a dispatch handle the caller (CC, dashboard) can observe.
  *
  * P-ppa10003 — the read-only dispatch path — lives in `runPrAction`:
  *  - fetches `{ title, body, diff, comments, author }` with NO configured
- *    project and NO clone (engine/pr-resolve.js#fetchPrPayload),
+ *    project and NO clone (engine/providers/pr-resolve.js#fetchPrPayload),
  *  - fences all external PR content (body / diff / comments) via
- *    engine/untrusted-fence.js#wrapUntrusted so it is treated as data,
- *  - runs a read-only DIRECT LLM call (engine/llm.js#callLLM `{ direct:true }`)
+ *    engine/core/untrusted-fence.js#wrapUntrusted so it is treated as data,
+ *  - runs a read-only DIRECT LLM call (engine/agents/llm.js#callLLM `{ direct:true }`)
  *    — no worktree, no repo cloning, no engine.spawnAgent — and
  *  - returns a lightweight dispatch record (status / output / failure_class)
  *    for dashboard observability, mapping a reported injection attempt to a
@@ -29,15 +29,15 @@
  *    (P-ppa10005+) and intentionally NOT reachable from here.
  */
 
-const shared = require('./shared');
+const shared = require('../core/shared');
 const prResolve = require('./pr-resolve');
 const ghComment = require('./gh-comment');
-const adoToken = require('./ado-token');
-const { wrapUntrusted, buildSource } = require('./untrusted-fence');
+const adoToken = require('../ado/token');
+const { wrapUntrusted, buildSource } = require('../core/untrusted-fence');
 
 // Marker attribution for a posted `comment` action. The drafted text is posted
 // under the shared gh identity, so it MUST carry the minions marker (agentId +
-// kind) so engine/github.js classifies it as minions-authored rather than a
+// kind) so engine/providers/github.js classifies it as minions-authored rather than a
 // human comment. gh-comment validates these against /^[a-z][a-z0-9-]{0,30}$/.
 const PR_ACTION_COMMENT_AGENT_ID = 'minions';
 const PR_ACTION_COMMENT_KIND = 'pr-action';
@@ -121,7 +121,7 @@ function buildPrActionFollowups(record, opts = {}) {
   const messages = {
     'comment': `Post a PR comment on ${target} — call POST /api/pr-action with {"url":"${target}","action":"comment","execute":true}; this drafts the comment AND posts it to the PR, then show me what was posted (and the comment URL if returned). To preview without posting, add "draftOnly":true.`,
     'fix-once': `Fix ${target} once — call POST /api/pr-action/fix with {"url":"${target}"}. If it returns status "awaiting-target-choice", show me the execution-target options (clone-keep / temp-clone / remote-patch / devbox) and DO NOT clone until I pick one; if it returns "project-ready", say it will use the existing project fix path. Once I choose, call the same endpoint again with {"url":"${target}","target":"<choice>"}.`,
-    'track-auto-fix': `Track ${target} for auto-fix — call POST /api/pr-action/track with {"url":"${target}"}. If it returns status "awaiting-target-choice", show me the execution-target options (Clone & keep is recommended for ongoing tracking — temp clone is discarded after one push) and DO NOT clone until I pick; once "Clone & keep" registers the project, call POST /api/pr-action/track again to finish enrollment. If it returns status "enrolled", tell me the PR is now auto-managed (contextOnly:false) and the existing pollers → review/fix/re-review → auto-merge loop will track it automatically.`,
+    'track-auto-fix': `Track ${target} for auto-fix — call POST /api/pr-action/track with {"url":"${target}"}. If it returns status "awaiting-target-choice", show me the execution-target options (Clone & keep is recommended for ongoing tracking — temp clone is discarded after one push) and DO NOT clone until I pick; once "Clone & keep" registers the project, call POST /api/pr-action/track again to finish enrollment. If it returns status "enrolled", tell me the PR now has Auto Fix and Auto Review enabled and the existing pollers → review/fix/re-review → auto-merge loop will track it automatically.`,
   };
   return PR_ACTION_FOLLOWUPS.map((f) => ({
     kind: f.kind,
@@ -393,7 +393,7 @@ function buildPrActionPrompt(action, payload) {
 /**
  * POST a single PR thread comment to ADO. ADO has no `gh`-equivalent CLI for PR
  * comments, so this hits the REST threads endpoint directly with a bearer token
- * from engine/ado-token.js. The body is marker-prepended by the caller.
+ * from engine/ado/token.js. The body is marker-prepended by the caller.
  * `opts._adoPost` / `opts.adoToken` / `opts._acquireAdoToken` are test seams.
  */
 async function _defaultAdoPost(url, token, payload) {
@@ -546,7 +546,7 @@ async function runPrAction(input = {}, opts = {}) {
   }
 
   const prompt = buildPrActionPrompt(act, payload);
-  const callLLM = opts.callLLM || (() => require('./llm').callLLM)();
+  const callLLM = opts.callLLM || (() => require('../agents/llm').callLLM)();
 
   let res;
   try {
@@ -555,6 +555,7 @@ async function runPrAction(input = {}, opts = {}) {
       label: `pr-action:${act}`,
       maxTurns: 1,
       allowedTools: '', // read-only: no tools, only the fenced payload
+      disableTools: true,
       timeout: opts.timeout || 180000,
       engineConfig: opts.engineConfig,
     });

package/engine/{pr-clone-keep.js → providers/pr-clone-keep.js}

@@ -1,10 +1,10 @@
 /**
- * engine/pr-clone-keep.js — Clone & keep fix executor: auto-clone a PR's repo and
+ * engine/providers/pr-clone-keep.js — Clone & keep fix executor: auto-clone a PR's repo and
  * register it as a PERSISTENT project so ongoing tracking / auto-fix works.
  *
  * Plan: projectless-pr-actions, Phase 2, item P-ppa10007. This is the second
  * mutating executor in the chain (after the ephemeral temp-clone, P-ppa10006).
- * The execution-target choice surface (engine/pr-fix-target.js) routes
+ * The execution-target choice surface (engine/providers/pr-fix-target.js) routes
  * `clone-keep` here once the user has explicitly picked it — the "never clone
  * silently" invariant lives upstream; by the time we run, the user has chosen to
  * clone AND keep.
@@ -20,7 +20,7 @@
  *                                   cloned.
  *   executeCloneKeep(plan, opts)  — clone the BASE repo into the persistent dir
  *                                   and register it as a project via
- *                                   engine/projects.js#addProject. The repo then
+ *                                   engine/planning/projects.js#addProject. The repo then
  *                                   becomes `project-ready` so the fix itself
  *                                   flows through the engine's normal project fix
  *                                   path. On registration failure the partial
@@ -51,7 +51,7 @@
 const fs = require('fs');
 const path = require('path');
 
-const shared = require('./shared');
+const shared = require('../core/shared');
 const prResolve = require('./pr-resolve');
 const ghToken = require('./gh-token');
 const prFixTarget = require('./pr-fix-target');
@@ -107,7 +107,7 @@ function _baseCloneUrl(ref, branches) {
  * the persistent project dir + name. NOTHING is created or cloned here.
  *
  * `input` — `{ url }`, a normalized ref, or a routed plan from
- *   engine/pr-fix-target.js#resolvePrFixTarget.
+ *   engine/providers/pr-fix-target.js#resolvePrFixTarget.
  * `opts.fetchPrBranches` — override the branch fetch (test seam).
  * `opts.prUrl` — original user URL (preferred for surfacing).
  * `opts.cloneRoot` — override the persistent-clone root.
@@ -158,7 +158,7 @@ async function _resolveToken(plan, opts = {}) {
     return resolve(plan.ref.slug) || null;
   }
   if (plan.ref.host === 'ado') {
-    const acquire = opts._acquireAdoToken || require('./ado-token').acquireAdoToken;
+    const acquire = opts._acquireAdoToken || require('../ado/token').acquireAdoToken;
     const acquired = await acquire();
     return (acquired && acquired.token) || null;
   }
@@ -296,7 +296,7 @@ async function executeCloneKeep(planOrInput = {}, opts = {}) {
   }
 
   const gitClone = opts.gitClone || ((p, token) => _defaultGitClone(p, token, opts));
-  const addProject = opts.addProject || ((target, registerOptions) => require('./projects').addProject(target, registerOptions));
+  const addProject = opts.addProject || ((target, registerOptions) => require('../planning/projects').addProject(target, registerOptions));
   const mkdir = opts._mkdir || ((dir) => fs.promises.mkdir(dir, { recursive: true }));
 
   const rec = _record(plan, {});

package/engine/{pr-devbox.js → providers/pr-devbox.js}

@@ -1,10 +1,10 @@
 /**
- * engine/pr-devbox.js — DevBox execution target (the "never touches your machine"
+ * engine/providers/pr-devbox.js — DevBox execution target (the "never touches your machine"
  * option for a projectless one-off PR fix).
  *
  * Plan: projectless-pr-actions, Phase 4 (stretch), item P-ppa10011. Like
- * engine/pr-temp-clone.js this is an EXECUTOR the choice surface
- * (engine/pr-fix-target.js) routes to once the user has EXPLICITLY picked it —
+ * engine/providers/pr-temp-clone.js this is an EXECUTOR the choice surface
+ * (engine/providers/pr-fix-target.js) routes to once the user has EXPLICITLY picked it —
  * the "never clone silently" invariant lives upstream; by the time we run, the
  * user has chosen the DevBox target.
  *
@@ -39,10 +39,10 @@
  *    success, failure, or noop — so nothing persists on the DevBox either.
  *  - EXPLICIT CONSENT ONLY: DevBox is never the default target and is never
  *    auto-selected; it only runs when the user picks `devbox` at the choice
- *    surface (engine/pr-fix-target.js).
+ *    surface (engine/providers/pr-fix-target.js).
  */
 
-const shared = require('./shared');
+const shared = require('../core/shared');
 const prResolve = require('./pr-resolve');
 const { PrActionError } = require('./pr-action');
 
@@ -86,7 +86,7 @@ function _remoteJoin(root, name) {
  * created on the local machine and NOTHING is cloned here.
  *
  * `input` — `{ url }`, a normalized ref, or a routed plan from
- *   engine/pr-fix-target.js#resolvePrFixTarget.
+ *   engine/providers/pr-fix-target.js#resolvePrFixTarget.
  * `opts.fetchPrBranches` — override the branch fetch (test seam).
  * `opts.prUrl` — original user URL (preferred for surfacing).
  * `opts.remoteTmpRoot` — override the DevBox-side ephemeral-clone root.