@yemi33/minions 0.1.2196 → 0.1.2198

package/dashboard/js/command-center.js

@@ -1447,11 +1447,41 @@ function _ccActionResultLine(action, result) {
   }
   if (result && result.ok) {
     var duplicate = result.duplicate ? ' <span style="color:var(--orange)">already exists</span>' : '';
-    return '<div class="cc-action-feedback-chip" style="' + CC_ACTION_CHIP_STYLE + ';color:var(--green)">&#10003; ' + label + duplicate + '</div>';
+    var chip = '<div class="cc-action-feedback-chip" style="' + CC_ACTION_CHIP_STYLE + ';color:var(--green)">&#10003; ' + label + duplicate + '</div>';
+    // P-ppa10004: a successful pr-action carries follow-up affordances
+    // ([Comment] [Fix once] [Track for auto-fix]); render them as clickable
+    // chips that send a templated CC turn.
+    var followups = (result && result.followups) || (action && action.followups);
+    return chip + _ccFollowupChips(followups);
   }
   return '';
 }
 
+// Render follow-up action chips (P-ppa10004). Each chip click sends its
+// templated CC message as a fresh turn via ccPrActionFollowup.
+function _ccFollowupChips(followups) {
+  if (!Array.isArray(followups) || followups.length === 0) return '';
+  var btns = followups.map(function(f) {
+    if (!f || !f.label || !f.message) return '';
+    return '<button type="button" class="cc-followup-chip" onclick="ccPrActionFollowup(' + _ccJsArg(f.message) + ')" ' +
+      'style="padding:3px 10px;border-radius:4px;font-size:var(--text-sm);border:1px solid var(--border);background:var(--surface2);color:var(--blue);cursor:pointer">' +
+      escHtml(f.label) + '</button>';
+  }).filter(Boolean).join('');
+  if (!btns) return '';
+  return '<div class="cc-followup-chips" style="margin:4px 0 0 0;display:flex;flex-wrap:wrap;gap:6px">' + btns + '</div>';
+}
+
+// Click handler for a follow-up action chip: drop the templated message into
+// the input and send it as a normal CC turn (so the user sees their intent and
+// CC routes it — forward-compatible with the Phase 2/3 flows).
+function ccPrActionFollowup(message) {
+  if (!message) return;
+  var input = document.getElementById('cc-input');
+  if (!input) return;
+  input.value = String(message);
+  ccSend();
+}
+
 
 function _ccAppendHtmlToMessage(tabOrId, messageId, html) {
   if (!messageId || !html) return false;
@@ -2163,4 +2193,4 @@ if (document.readyState === 'loading') {
   ccInitResize();
 }
 
-window.MinionsCC = { toggleCommandCenter, ccNewSession, ccNewTab, ccSwitchTab, ccCloseTab, ccRenderTabBar, ccRestoreMessages, ccSaveState, ccUpdateSessionIndicator, ccAddMessage, ccSend, ccAbort, ccExecuteAction };
+window.MinionsCC = { toggleCommandCenter, ccNewSession, ccNewTab, ccSwitchTab, ccCloseTab, ccRenderTabBar, ccRestoreMessages, ccSaveState, ccUpdateSessionIndicator, ccAddMessage, ccSend, ccAbort, ccExecuteAction, ccPrActionFollowup };

package/dashboard/js/modal-qa.js

@@ -335,6 +335,19 @@ function _qaBuildRawErrorHtml(err) {
     '</details>';
 }
 
+function _qaDocStreamErrorMessage(evt) {
+  if (!evt) return 'Failed';
+  if (typeof evt.error === 'string' && evt.error) return evt.error;
+  if (evt.message) return String(evt.message);
+  if (evt.errorMessage) return String(evt.errorMessage);
+  if (evt.error && typeof evt.error === 'object') {
+    if (evt.error.errorMessage) return String(evt.error.errorMessage);
+    if (evt.error.message) return String(evt.error.message);
+    if (evt.error.stderr) return String(evt.error.stderr);
+  }
+  return 'Failed';
+}
+
 function _qaBuildAssistantHtml(text, opts) {
   const body = opts?.isError ? escHtml(text) : renderMd(text);
   const style = opts?.isError
@@ -713,6 +726,7 @@ async function _processQaMessage(message, selection, opts) {
     const decoder = new TextDecoder();
     let buf = '';
     let terminalEventSeen = false;
+    let pendingStreamErrorEvent = null;
 
     async function _qaHandleStreamEvent(evt) {
       if (!evt || !evt.type) return;
@@ -842,8 +856,8 @@ async function _processQaMessage(message, selection, opts) {
         return;
       }
       if (evt.type === 'error') {
-        _clearQaStreamWatchdog();
-        throw new Error(evt.error || 'Failed');
+        pendingStreamErrorEvent = evt;
+        return;
       }
     }
 
@@ -867,7 +881,11 @@ async function _processQaMessage(message, selection, opts) {
         await _qaHandleStreamEvent(JSON.parse(line.slice(6)));
       }
     }
-    if (!terminalEventSeen) throw new Error('The response stream ended before completion.');
+    if (!terminalEventSeen) {
+      throw new Error(pendingStreamErrorEvent
+        ? _qaDocStreamErrorMessage(pendingStreamErrorEvent)
+        : 'The response stream ended before completion.');
+    }
   } catch (e) {
     clearInterval(qaTimer);
     _clearQaStreamWatchdog();

package/dashboard.js

@@ -42,6 +42,10 @@ const { wrapUntrusted, buildSource } = require('./engine/untrusted-fence');
 const steering = require('./engine/steering');
 const steeringStore = require('./engine/steering-store');
 const projectDiscovery = require('./engine/project-discovery');
+const prAction = require('./engine/pr-action');
+const prResolve = require('./engine/pr-resolve');
+const prFixTarget = require('./engine/pr-fix-target');
+const prTrack = require('./engine/pr-track');
 const features = require('./engine/features');
 const ccWorkerPool = require('./engine/cc-worker-pool');
 const diagnosticsMemory = require('./engine/diagnostics-memory');
@@ -3404,6 +3408,9 @@ function _buildSyntheticActionResultsForTurn(turnId, message, requestedAt) {
     };
     if (entry.project) action.project = entry.project;
     if (entry.path) action.path = entry.path;
+    // P-ppa10004: pr-action chips carry follow-up affordances ([Comment]
+    // [Fix once] [Track for auto-fix]) so the renderer can offer the next step.
+    if (Array.isArray(entry.followups) && entry.followups.length) action.followups = entry.followups;
     actions.push(action);
     const result = {
       ok: true,
@@ -3419,6 +3426,7 @@ function _buildSyntheticActionResultsForTurn(turnId, message, requestedAt) {
     if (entry.id) result.id = entry.id;
     if (entry.project) result.project = entry.project;
     if (entry.path) result.path = entry.path;
+    if (Array.isArray(entry.followups) && entry.followups.length) result.followups = entry.followups;
     results.push(result);
   }
   return { actions, results };
@@ -3435,6 +3443,7 @@ function _ccTurnEntryToActionType(kind) {
     case 'pipeline-run': return 'trigger-pipeline';
     case 'watch': return 'create-watch';
     case 'meeting': return 'create-meeting';
+    case 'pr-action': return 'pr-action';
     default: return kind;
   }
 }
@@ -12606,6 +12615,92 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       })();
     }},
 
+    { method: 'POST', path: '/api/pr-action', desc: 'User-initiated read-only action on any GitHub/ADO PR URL (no project/clone required). Resolves the PR via the projectless resolver. Default: returns an observable dispatch handle. With `execute:true`: runs the read-only action now (fetch → fence → DIRECT LLM) and returns its output plus follow-up action chips ([Comment] [Fix once] [Track for auto-fix]). Read-only only — no auto-polling/discovery.', params: 'url (PR URL or canonical id), action (review|summarize|comment|triage), execute (optional bool — run now and return output + follow-up chips)', handler: async (req, res) => {
+      const body = await readBody(req);
+      try {
+        if (body && body.execute) {
+          reloadConfig();
+          const record = await prAction.runPrAction({ url: body?.url, action: body?.action }, { engineConfig: CONFIG.engine });
+          const followups = record.status === 'done' ? prAction.buildPrActionFollowups(record, { prUrl: body?.url }) : [];
+          recordCcTurnIfPresent(req, { kind: 'pr-action', id: record.id, title: `${record.action} ${record.prId || ''}`.trim(), followups });
+          return jsonReply(res, 200, { ok: record.status !== 'failed', ...record, followups }, req);
+        }
+        const handle = await prAction.createPrAction({ url: body?.url, action: body?.action });
+        recordCcTurnIfPresent(req, { kind: 'pr-action', id: handle.id, title: `${handle.action} ${handle.prId || ''}`.trim() });
+        return jsonReply(res, 200, { ok: true, ...handle }, req);
+      } catch (e) {
+        return jsonReply(res, e.statusCode || 400, { error: e.message }, req);
+      }
+    }},
+
+    { method: 'POST', path: '/api/pr-action/fix', desc: 'Plan a one-off fix on any GitHub/ADO PR URL (Phase 2, P-ppa10005 — decision/routing surface only). Without `target`: returns the execution-target choice. If the PR’s repo is already a configured project, returns {status:"project-ready"} (skip the prompt, use the existing project fix path); otherwise {status:"awaiting-target-choice"} with options [clone-keep, temp-clone (default), remote-patch, devbox] plus a CC prompt + dashboard modal — NOTHING is cloned. With `target`: validates the choice and returns the routing intent {status:"routed", executor} to the matching executor. temp-clone (default) is implemented in engine/pr-temp-clone.js (executor.module:"pr-temp-clone"), clone-keep in engine/pr-clone-keep.js (executor.module:"pr-clone-keep", auto-clone + persistent project registration), remote-patch in engine/pr-remote-patch.js (executor.module:"pr-remote-patch", GitHub Contents API single-file edit, NO clone and NO validation — GitHub-only), and devbox in engine/pr-devbox.js (executor.module:"pr-devbox", P-ppa10011 stretch — ephemeral clone+fix+push ON A DEVBOX, zero local footprint, never auto-selected). Never clones silently. P-ppa10009: pass `remember:true` alongside `target` to remember the choice per repo so subsequent fixes on that repo skip the prompt; a remembered choice makes the no-`target` call return {status:"routed", fromRemembered:true} instead of prompting. Pass `reprompt:true` to force the prompt despite a remembered choice (override). Clear a remembered choice via POST /api/pr-action/fix-target/forget.', params: 'url (PR URL or canonical id), target (optional — clone-keep|temp-clone|remote-patch|devbox), remember (optional bool — persist target per repo), reprompt (optional bool — force the choice despite a remembered one)', handler: async (req, res) => {
+      const body = await readBody(req);
+      try {
+        reloadConfig();
+        if (body && body.target != null && body.target !== '') {
+          // `remember:true` persists this choice per repo so future fixes skip
+          // the prompt (P-ppa10009).
+          const routed = prFixTarget.resolvePrFixTarget({ url: body?.url }, body.target, { config: CONFIG, remember: !!body.remember });
+          recordCcTurnIfPresent(req, { kind: 'pr-action', id: routed.prId || '', title: `fix ${routed.prId || ''} → ${routed.target}`.trim() });
+          return jsonReply(res, 200, { ok: true, ...routed }, req);
+        }
+        // `reprompt:true` forces the execution-target prompt even when a per-repo
+        // choice is remembered (the override path for P-ppa10009).
+        const plan = prFixTarget.planPrFix({ url: body?.url }, { config: CONFIG, prUrl: body?.url, ignoreRemembered: !!body?.reprompt });
+        recordCcTurnIfPresent(req, { kind: 'pr-action', id: plan.prId || '', title: `fix ${plan.prId || ''} (${plan.status})`.trim() });
+        return jsonReply(res, 200, { ok: true, ...plan }, req);
+      } catch (e) {
+        return jsonReply(res, e.statusCode || 400, { error: e.message }, req);
+      }
+    }},
+
+    { method: 'POST', path: '/api/pr-action/fix-target/forget', desc: 'Clear/override the remembered per-repo execution-target choice (Phase 3, P-ppa10009). Given a PR `url` (or canonical id), forgets the remembered clone-keep|temp-clone|remote-patch choice for that repo scope so the next fix re-prompts. Returns {cleared:true} if a remembered choice existed, {cleared:false} otherwise.', params: 'url (PR URL or canonical id)', handler: async (req, res) => {
+      const body = await readBody(req);
+      try {
+        const ref = prResolve.normalizePrRef(typeof body?.url === 'string' ? body.url.trim() : '');
+        if (!ref) return jsonReply(res, 400, { error: `unrecognized PR reference: ${JSON.stringify(String(body?.url || '').slice(0, 120))}` }, req);
+        const cleared = prFixTarget.clearRememberedTargetForRef(ref);
+        recordCcTurnIfPresent(req, { kind: 'pr-action', id: ref.id || '', title: `forget fix target ${ref.id || ''}`.trim() });
+        return jsonReply(res, 200, { ok: true, cleared, prId: ref.id || null }, req);
+      } catch (e) {
+        return jsonReply(res, e.statusCode || 400, { error: e.message }, req);
+      }
+    }},
+
+    { method: 'POST', path: '/api/pr-action/track', desc: 'Promote a one-off PR to TRACKED auto-fix (Phase 3, P-ppa10010 — enrollment wiring). If the PR’s repo is NOT a configured project, returns {status:"awaiting-target-choice"} with options [clone-keep (recommended for ongoing tracking), temp-clone, remote-patch] + a CC prompt and dashboard modal — NOTHING is cloned (pick "clone-keep" via POST /api/pr-action/fix to register a persistent project, then call this again to finish enrollment). If the repo IS a configured project, enrolls the PR via the manual-link path with contextOnly:false (the canonical shared.isAutoManagedPrRecord signal) and returns {status:"enrolled", autoManaged:true}. From enrollment on the EXISTING pollers/discoverFromPrs → review/fix/re-review → auto-merge pipeline runs unchanged — no new fix engine.', params: 'url (PR URL or canonical id)', handler: async (req, res) => {
+      const body = await readBody(req);
+      try {
+        reloadConfig();
+        const plan = prTrack.planPrTrack({ url: body?.url }, { config: CONFIG, prUrl: body?.url });
+        if (plan.status === 'awaiting-target-choice') {
+          // Unconfigured repo — ongoing tracking needs a persistent checkout, so
+          // pause for the Clone & keep choice. NOTHING is cloned/enrolled yet.
+          recordCcTurnIfPresent(req, { kind: 'pr-action', id: plan.prId || '', title: `track ${plan.prId || ''} (${plan.status})`.trim() });
+          return jsonReply(res, 200, { ok: true, ...plan }, req);
+        }
+        // project-ready: enroll via the existing manual-link path. Linking with
+        // contextOnly:false creates the record if missing and PROMOTES an existing
+        // context-only record to auto-managed (upsert refuses to demote a managed
+        // PR). No new engine — the existing pipeline discovers it next tick.
+        const enrollment = prTrack.buildTrackEnrollment(plan, { prUrl: body?.url });
+        const linkResult = linkPullRequestForTracking({ url: enrollment.url, contextOnly: enrollment.contextOnly }, CONFIG);
+        invalidateStatusCache();
+        const autoManaged = shared.isAutoManagedPrRecord(linkResult.record);
+        recordCcTurnIfPresent(req, { kind: 'pr-action', id: linkResult.id, title: `track ${linkResult.id} → auto-fix`.trim() });
+        return jsonReply(res, 200, {
+          ok: true,
+          status: 'enrolled',
+          prId: linkResult.id,
+          autoManaged,
+          contextOnly: false,
+          project: linkResult.targetProject?.name || 'central',
+          projectName: plan.projectName || linkResult.targetProject?.name || null,
+        }, req);
+      } catch (e) {
+        return jsonReply(res, e.statusCode || 400, { error: e.message }, req);
+      }
+    }},
+
     { method: 'POST', path: '/api/pull-requests/observe', desc: 'Toggle canonical contextOnly flag on a tracked PR (public `observe` body param is preserved as the inverse for backward compat)', params: 'host (github|ado), slug, number, observe (boolean)', handler: async (req, res) => {
       const body = await readBody(req);
       reloadConfig();

package/engine/db/migrations/014-pr-fix-target-prefs.js

@@ -0,0 +1,29 @@
+// engine/db/migrations/014-pr-fix-target-prefs.js
+//
+// Plan: projectless-pr-actions, Phase 3, item P-ppa10009 — "Remember
+// execution-target choice per repo (optional)".
+//
+// Adds the `pr_fix_target_prefs` table — one row per repo scope — so the
+// execution-target choice surface (engine/pr-fix-target.js) can OPTIONALLY
+// remember the user's pick (clone-keep | temp-clone | remote-patch) keyed by
+// canonical PR scope (github:owner/repo / ado:org/proj/repo). When a remembered
+// choice exists, a repeat fix on that repo routes straight to the executor
+// instead of re-prompting. Absence of a row still prompts (the safe default —
+// never clone silently). The choice is clearable/overridable.
+//
+// SQL-first per CLAUDE.md "New state goes into SQL first" — no JSON sidecar;
+// reads/writes go through engine/pr-fix-target-store.js.
+
+module.exports = {
+  version: 14,
+  description: 'pr_fix_target_prefs: remembered per-repo execution-target choices',
+  up(db) {
+    db.exec(`
+      CREATE TABLE pr_fix_target_prefs (
+        repo_scope   TEXT PRIMARY KEY,
+        target       TEXT NOT NULL,
+        updated_at   INTEGER NOT NULL
+      );
+    `);
+  },
+};

package/engine/dispatch.js

@@ -12,7 +12,7 @@ const dispatchEvents = require('./dispatch-events');
 
 const { safeJsonArr, mutateWorkItems,
   mutatePullRequests, getProjects, projectPrPath, log, ts, dateStamp,
-  sidecarDispatchPrompt, deleteDispatchPromptSidecar,
+  sidecarDispatchPrompt, deleteDispatchPromptSidecar, DONE_STATUSES,
   WI_STATUS, WORK_TYPE, DISPATCH_RESULT, ENGINE_DEFAULTS, AGENT_STATUS, FAILURE_CLASS, PR_STATUS } = shared;
 const { getConfig, INBOX_DIR } = queries;
 
@@ -426,12 +426,12 @@ function getStalePrDispatchReason(entry, config) {
   //   1. `entry.meta?.source !== 'work-item'` — blocks any non-work-item dispatch
   //      (e.g. legacy `pr`/`pr-human-feedback` discovery paths) from running
   //      against a context-only PR. Auto-discovery in engine.js#discoverFromPrs
-  //      already skips _contextOnly PRs at the source, so this is defense-in-depth.
+  //      already skips context-only PRs at the source, so this is defense-in-depth.
   //   2. `!NON_MUTATING_DISPATCH_TYPES.has(entry.type)` — even an explicit
   //      work-item dispatch is dropped if it's a mutating type (fix, implement,
   //      test, verify, decompose, docs). Only review/ask/explore — which never
   //      push to the PR's source branch — are allowed through.
-  if (tracked._contextOnly
+  if (shared.isContextOnlyPrRecord(tracked)
       && (entry.meta?.source !== 'work-item' || !NON_MUTATING_DISPATCH_TYPES.has(entry.type))) {
     return `PR ${tracked.id || prLabel} is context-only`;
   }
@@ -445,6 +445,40 @@ function getStalePrDispatchReason(entry, config) {
   return '';
 }
 
+function cancelSourceWorkItemForPrunedDispatch(entry, reason) {
+  const itemId = entry?.meta?.item?.id;
+  if (!itemId) return false;
+  let wiPath;
+  try { wiPath = lifecycle().resolveWorkItemPath(entry.meta); }
+  catch (e) {
+    log('warn', `Failed to resolve source work item for pruned dispatch ${entry.id}: ${e.message}`);
+    return false;
+  }
+  if (!wiPath) return false;
+
+  let cancelled = false;
+  try {
+    mutateWorkItems(wiPath, (items) => {
+      if (!Array.isArray(items)) return items;
+      const wi = items.find(w => w && w.id === itemId);
+      if (!wi) return items;
+      if (DONE_STATUSES.has(wi.status) || wi.status === WI_STATUS.FAILED || wi.status === WI_STATUS.CANCELLED) return items;
+      wi.status = WI_STATUS.CANCELLED;
+      wi._cancelledBy = reason || 'stale PR dispatch pruned';
+      wi.cancelledAt = ts();
+      wi._lastDispatchResult = 'pruned-stale-pr-dispatch';
+      delete wi.dispatched_at;
+      delete wi.dispatched_to;
+      delete wi._pendingReason;
+      cancelled = true;
+      return items;
+    }, { skipWriteIfUnchanged: true });
+  } catch (e) {
+    log('warn', `Failed to cancel work item ${itemId} for pruned dispatch ${entry.id}: ${e.message}`);
+  }
+  return cancelled;
+}
+
 function pruneStalePrDispatches(config = queries.getConfig()) {
   const removed = [];
   mutateDispatch((dispatch) => {
@@ -459,7 +493,8 @@ function pruneStalePrDispatches(config = queries.getConfig()) {
 
   for (const { entry, reason } of removed) {
     try { deleteDispatchPromptSidecar(entry); } catch { /* cleanup best-effort */ }
-    log('info', `Dropped stale PR dispatch ${entry.id}: ${reason}`);
+    const cancelled = cancelSourceWorkItemForPrunedDispatch(entry, reason);
+    log('info', `Dropped stale PR dispatch ${entry.id}: ${reason}${cancelled ? ' (source work item cancelled)' : ''}`);
   }
   return removed.length;
 }

package/engine/gh-token.js

@@ -109,6 +109,35 @@ function resolveTokenForSlug(slug, opts = {}) {
   return _fetchTokenForAccount(account, opts);
 }
 
+/**
+ * Resolve a GitHub PAT for a named account directly (bypassing slug→account
+ * mapping). Used by the projectless PR resolver's unknown-slug fallback
+ * (engine/pr-resolve.js) to try each authed account in turn WITHOUT touching
+ * the global active `gh auth` profile. Returns the token string or null.
+ */
+function tokenForAccount(account, opts = {}) {
+  return _fetchTokenForAccount(account, opts);
+}
+
+/**
+ * List the distinct gh account names configured in `engine.ghAccounts`. This is
+ * the candidate set the unknown-slug fallback iterates over (per the plan:
+ * "fall back across the available authed accounts" rather than relying on the
+ * active `gh auth` profile). Order follows the config object's own key order.
+ */
+function listConfiguredAccounts(opts = {}) {
+  const config = _readConfig(opts);
+  const accounts = (config && config.engine && config.engine.ghAccounts) || {};
+  if (!accounts || typeof accounts !== 'object') return [];
+  const seen = new Set();
+  const out = [];
+  for (const value of Object.values(accounts)) {
+    const name = value == null ? '' : String(value);
+    if (name && !seen.has(name)) { seen.add(name); out.push(name); }
+  }
+  return out;
+}
+
 /** Test-only: prime a slug→token override that bypasses config + shell-out. */
 function _setTokenForTest(slug, token) {
   if (!slug) return;
@@ -127,6 +156,8 @@ function _clearTokenCache() {
 module.exports = {
   resolveTokenForSlug,
   resolveAccountForSlug,
+  tokenForAccount,
+  listConfiguredAccounts,
   _setTokenForTest,
   _clearTokenCache,
   // Constants exposed for tests + diagnostics.

package/engine/lifecycle.js

@@ -790,6 +790,19 @@ function reconcilePrdStatuses(config) {
 
 // ─── PR Sync from Output ─────────────────────────────────────────────────────
 
+const ONE_SHOT_CONTEXT_PR_TYPES = new Set([
+  WORK_TYPE.REVIEW,
+  WORK_TYPE.ASK,
+  WORK_TYPE.EXPLORE,
+]);
+
+function shouldSyncPrAsContextOnly(meta) {
+  const item = meta?.item;
+  if (!item?.oneShot || item.skipPr) return false;
+  const type = String(item.type || item.itemType || '').trim();
+  return ONE_SHOT_CONTEXT_PR_TYPES.has(type);
+}
+
 function syncPrsFromOutput(output, agentId, meta, config, opts = {}) {
   const { structuredCompletion = null } = opts;
   const outputText = String(output || '');
@@ -996,13 +1009,14 @@ function syncPrsFromOutput(output, agentId, meta, config, opts = {}) {
       url: prUrl,
       prdItems: meta?.item?.id ? [meta.item.id] : [],
       sourcePlan: meta?.item?.sourcePlan || '',
-      itemType: meta?.item?.itemType || ''
+      itemType: meta?.item?.itemType || '',
+      contextOnly: shouldSyncPrAsContextOnly(meta),
     };
     applyScheduleContextToPrEntry(entry, meta?.item, config);
-    // Issue #1772: one-off dispatches (e.g. human-initiated "review this PR" via CC)
-    // must not enroll the discovered PR into the auto eval loop. Tag _contextOnly so
-    // discoverFromPrs skips it for review/fix dispatch (still polled for status/comments).
-    if (meta?.item?.oneShot) entry._contextOnly = true;
+    // Issue #1772: explicit one-off review/ask/explore dispatches (for example,
+    // "review this PR" via CC) must stay reference-only. QA-session setup and
+    // other oneShot+skipPr PR-targeted work are operational context, not an
+    // observe toggle, so they must not demote a real tracked PR.
     newPrsByPath.get(prPath).entries.push({ prId, fullId, entry });
   }
 
@@ -1145,7 +1159,7 @@ function _existingPrRecordForCanonicalId(canonicalPrId) {
  * can render the real merged/abandoned status instead of a perpetual blue ○.
  *
  * Idempotent: returns `{ enrolled: false, reason: 'already_tracked' }` if a row
- * already exists. Marks new records with `_contextOnly: true` so the engine
+ * already exists. Marks new records with `contextOnly: true` so the engine
  * doesn't try to manage them (no re-dispatch of fix/review loops). Live state
  * is fetched via `gh pr view` for GitHub; ADO enrollment is best-effort with
  * a conservative ACTIVE default.
@@ -1259,7 +1273,7 @@ async function enrollPrFromCanonicalId(canonicalPrId, project, opts = {}) {
     url,
     prdItems: opts.itemId ? [opts.itemId] : [],
     _attachedAt: ts(),
-    _contextOnly: true,
+    contextOnly: true,
     _enrolledBy: 'enrollPrFromCanonicalId',
   };
   if (liveState && liveState.mergedAt) entry.mergedAt = liveState.mergedAt;