@yemi33/minions 0.1.1911 → 0.1.1913

package/dashboard/js/settings.js

@@ -230,6 +230,7 @@ async function openSettings() {
           settingsToggle('Copilot: suppress AGENTS.md', 'set-copilotSuppressAgentsMd', e.copilotSuppressAgentsMd !== false, '--no-custom-instructions: stops AGENTS.md auto-load from fighting Minions playbook prompts') +
           settingsToggle('Copilot: reasoning summaries', 'set-copilotReasoningSummaries', !!e.copilotReasoningSummaries, '--enable-reasoning-summaries (Anthropic-family models only)') +
           settingsToggle('Disable model discovery', 'set-disableModelDiscovery', !!e.disableModelDiscovery, 'Skip /api/runtimes/<name>/models REST calls fleet-wide. Settings UI falls back to free-text.') +
+          settingsToggle('Use persistent Copilot worker pool (faster CC responses)', 'set-ccUseWorkerPool', !!e.ccUseWorkerPool, 'Experimental — sub-task C of W-mp2w003600196c51 (CC perf). When ON, Command Center routes through engine/cc-worker-pool.js (one persistent `copilot --acp` process per CC tab) instead of spawning a fresh CLI per turn. Saves ~14s of cold-start cost on warm follow-up turns. Engine/agent dispatch path is unchanged. Off by default.') +
         '</div>' +
         '<div style="display:grid;grid-template-columns:1fr 3fr;gap:8px;margin-top:8px">' +
           '<div>' +
@@ -625,6 +626,7 @@ async function saveSettings() {
       copilotReasoningSummaries: !!document.getElementById('set-copilotReasoningSummaries')?.checked,
       maxBudgetUsd: (document.getElementById('set-maxBudgetUsd')?.value ?? '').trim(),
       disableModelDiscovery: !!document.getElementById('set-disableModelDiscovery')?.checked,
+      ccUseWorkerPool: !!document.getElementById('set-ccUseWorkerPool')?.checked,
       maxTurnsByType: (function() {
         var mbt = {};
         var types = ['explore', 'ask', 'review', 'implement', 'fix', 'test', 'verify', 'plan', 'decompose'];

package/dashboard.js

@@ -32,6 +32,7 @@ const dispatchMod = require('./engine/dispatch');
 const steering = require('./engine/steering');
 const projectDiscovery = require('./engine/project-discovery');
 const features = require('./engine/features');
+const ccWorkerPool = require('./engine/cc-worker-pool');
 const os = require('os');
 
 const { safeRead, safeReadDir, safeWrite, safeJson, safeJsonObj, safeJsonArr, safeJsonNoRestore, safeUnlink, mutateJsonFileLocked, mutateTextFileLocked, mutateControl, mutateCooldowns, mutateWorkItems, getProjects: _getProjects, DONE_STATUSES, WI_STATUS, WORK_TYPE, reopenWorkItem } = shared;
@@ -5826,6 +5827,18 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         const abort = ccInFlightAborts.get(tabId);
         if (abort) { try { abort(); } catch {} }
       }
+      // Sub-task C of W-mp2w003600196c51: when the worker pool is on, abort
+      // must also fire `session/cancel` on the persistent ACP process so the
+      // remote daemon stops generating into a torn-down session. The pool
+      // exposes cancellation via the SessionHandle returned from getSession;
+      // we don't keep that handle around here, so route through closeTab to
+      // both cancel inflight and tear down the worker (cheaper than tracking
+      // per-tab handles in dashboard state, and matches "tab close" semantics
+      // — if the user explicitly aborted, we don't owe them a warm process).
+      // Off when the flag is off so legacy SIGTERM-only behavior is preserved.
+      if (CONFIG.engine && CONFIG.engine.ccUseWorkerPool) {
+        try { ccWorkerPool.closeTab(tabId); } catch { /* swallow */ }
+      }
       _clearCcLiveStream(tabId);
       _releaseCCTab(tabId);
       return jsonReply(res, 200, { ok: true });
@@ -5846,6 +5859,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const sessions = _filterCcTabSessions(raw);
       return sessions.filter(s => s.id !== id);
     }, { defaultValue: [] });
+    // Sub-task C of W-mp2w003600196c51: tear down the persistent ACP worker
+    // for this tab so we don't leak a Copilot process after the user closes
+    // the tab. closeTab is a no-op when the pool has no entry for the tabId,
+    // so it's safe to call regardless of whether the flag is on.
+    try { ccWorkerPool.closeTab(id); } catch { /* swallow */ }
     return jsonReply(res, 200, { ok: true });
   }
 
@@ -5875,6 +5893,14 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         if (body.sessionId && ccSession._promptHash && ccSession._promptHash !== _ccPromptHash) {
           ccSession = { sessionId: null, createdAt: null, lastActiveAt: null, turnCount: 0 };
           sessionReset = true;
+          // Sub-task C of W-mp2w003600196c51: drop the persistent ACP worker
+          // for this tab so the next turn rebuilds against the new prompt.
+          // The pool's getSession() handles systemPromptHash deltas via
+          // newSession() (warm-process reuse), but evicting the tab here is
+          // belt-and-suspenders — matches the spec's "call closeTab on
+          // _ccPromptHash change" requirement and matches the way we just
+          // dropped ccSession entirely.
+          try { ccWorkerPool.closeTab(tabId); } catch { /* swallow */ }
         }
         const wasResume = !!(body.sessionId && body.sessionId === ccSession.sessionId && ccSessionValid());
 
@@ -5943,8 +5969,21 @@ What would you like to discuss or change? When you're happy, say "approve" and I
    * onChunk/onToolUse shape — only `sessionId` differs (set on
    * initial call, undefined on retry). Hoisted to keep the two call sites
    * in lock-step.
+   *
+   * Sub-task C of W-mp2w003600196c51 (CC perf): when
+   * `engineConfig.ccUseWorkerPool` is true the call routes through
+   * engine/cc-worker-pool.js (`copilot --acp`, one persistent process per
+   * CC tab) instead of spawning a fresh CLI per turn. The pool path
+   * preserves the existing onChunk/onToolUse/result shape so callers
+   * (handleCommandCenterStream, retry path) need no change. Engine/agent
+   * dispatch path is intentionally NOT routed through the pool; that
+   * lives on the per-dispatch _spawnProcess model in engine.js (regression
+   * test enforces engine.js does not import cc-worker-pool).
    */
-  function _invokeCcStream({ prompt, sessionId, liveState, toolUses, model, effort, maxTurns, engineConfig, systemPrompt = CC_STATIC_SYSTEM_PROMPT }) {
+  function _invokeCcStream({ prompt, sessionId, liveState, toolUses, model, effort, maxTurns, engineConfig, systemPrompt = CC_STATIC_SYSTEM_PROMPT, tabId }) {
+    if (engineConfig && engineConfig.ccUseWorkerPool) {
+      return _invokeCcStreamViaPool({ prompt, liveState, model, effort, engineConfig, systemPrompt, tabId });
+    }
     const { callLLMStreaming } = require('./engine/llm');
     return callLLMStreaming(prompt, systemPrompt, {
       timeout: CC_CALL_TIMEOUT_MS, label: 'command-center', model, maxTurns,
@@ -5965,6 +6004,87 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     });
   }
 
+  /**
+   * Pool-routed implementation of _invokeCcStream. Keeps the public contract
+   * identical: returns a Promise that resolves to a result envelope shaped like
+   * callLLMStreaming's (`{ text, sessionId, code, usage, raw, stderr,
+   * missingRuntime }`) and exposes an `.abort` property so the SSE handler can
+   * cancel the in-flight stream by calling `_ccStreamAbort()`.
+   *
+   * Differences vs the direct path:
+   *   - Pool's `onChunk(text)` from agent_message_chunk is a DELTA, but
+   *     callLLMStreaming's contract is "full accumulated text"; we accumulate
+   *     here so `liveState.text` and downstream chunk events keep the same
+   *     semantics consumers already depend on.
+   *   - Tool calls are not surfaced in sub-task B (the pool ignores
+   *     `tool_call` notifications). `toolUses` stays empty on this path; if
+   *     sub-task C/D adds tool_call surfacing in the pool we'll plumb a
+   *     callback here too.
+   *   - `usage` is reported as an empty object — ACP doesn't expose token
+   *     counts in the in-flight session/update notifications, and the pool's
+   *     long-lived process makes per-turn usage attribution non-trivial.
+   *     trackEngineUsage is a no-op on `{}`.
+   */
+  function _invokeCcStreamViaPool({ prompt, liveState, model, effort, engineConfig, systemPrompt, tabId }) {
+    const resolvedTabId = tabId || 'default';
+    let cancelled = false;
+    let accumulated = '';
+    let sessionHandle = null;
+    let resolveResult;
+    const promise = new Promise((resolve) => { resolveResult = resolve; });
+    promise.abort = () => {
+      cancelled = true;
+      try { sessionHandle && sessionHandle.cancel(); } catch { /* swallow */ }
+    };
+    (async () => {
+      try {
+        sessionHandle = await ccWorkerPool.getSession({
+          tabId: resolvedTabId,
+          model,
+          effort,
+          mcpServers: (engineConfig && engineConfig.mcpServers) || [],
+          systemPromptHash: _ccPromptHash,
+        });
+      } catch (err) {
+        return resolveResult({
+          text: '',
+          sessionId: null,
+          code: 1,
+          usage: {},
+          raw: '',
+          stderr: String((err && err.message) || err || 'cc-worker-pool spawn failed'),
+        });
+      }
+      if (cancelled) {
+        try { sessionHandle.cancel(); } catch { /* swallow */ }
+        return resolveResult({ text: accumulated, sessionId: sessionHandle.sessionId, code: 0, usage: {}, raw: accumulated, stderr: '' });
+      }
+      await sessionHandle.stream(prompt, {
+        systemPromptText: systemPrompt,
+        onChunk: (delta) => {
+          accumulated += delta;
+          _touchCcLiveStream(liveState);
+          liveState.text = accumulated;
+          if (liveState.writer) liveState.writer({ type: 'chunk', text: accumulated });
+        },
+        onDone: () => {
+          resolveResult({ text: accumulated, sessionId: sessionHandle.sessionId, code: 0, usage: {}, raw: accumulated, stderr: '' });
+        },
+        onError: (err) => {
+          resolveResult({
+            text: accumulated,
+            sessionId: sessionHandle.sessionId,
+            code: cancelled ? 0 : 1,
+            usage: {},
+            raw: accumulated,
+            stderr: String((err && err.message) || err || 'cc-worker-pool stream error'),
+          });
+        },
+      });
+    })();
+    return promise;
+  }
+
   async function handleCommandCenterStream(req, res) {
     // SSE Origin gate (belt-and-suspenders: the top-level dispatcher has
     // already rejected disallowed origins on POST, but validate again here
@@ -6106,6 +6226,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
             tabSessionId = null;
             sessionReset = true;
             sessionResetReason = 'promptChanged';
+            // Sub-task C of W-mp2w003600196c51: matched dashboard reload with
+            // a new prompt template — evict the persistent ACP worker so the
+            // next turn rebuilds against the new prompt. (See same hook in
+            // handleCommandCenter above.)
+            try { ccWorkerPool.closeTab(body.tabId || 'default'); } catch { /* swallow */ }
           } else if (tabEntry.runtime && tabEntry.runtime !== currentRuntime) {
             tabSessionId = null;
             sessionReset = true;
@@ -6149,6 +6274,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           model: streamModel, effort: streamEffort, maxTurns: ccMaxTurns,
           engineConfig: CONFIG.engine,
           systemPrompt: turnSystemPrompt,
+          tabId,
         });
         _ccStreamAbort = llmPromise.abort;
         liveState.abortFn = _ccStreamAbort;
@@ -6174,6 +6300,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
             model: streamModel, effort: streamEffort, maxTurns: ccMaxTurns,
             engineConfig: CONFIG.engine,
             systemPrompt: turnSystemPrompt,
+            tabId,
           });
           _ccStreamAbort = retryPromise.abort;
           liveState.abortFn = _ccStreamAbort;

package/engine/cli.js

@@ -992,6 +992,7 @@ const commands = {
       'claudeBareMode', 'claudeFallbackModel',
       'copilotDisableBuiltinMcps', 'copilotSuppressAgentsMd', 'copilotStreamMode', 'copilotReasoningSummaries',
       'maxBudgetUsd', 'disableModelDiscovery',
+      'ccUseWorkerPool',
     ];
     const activeFlags = [];
     for (const f of flagFields) {

package/engine/gh-comment.js

@@ -46,6 +46,12 @@ const REPO_SLUG_RE = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
 const MINIONS_COMMENT_MARKER_RE =
   /^<!--\s*minions:agent=([^\s]+)\s+kind=([^\s]+)(?:\s+wi=([^\s]+))?\s*-->/m;
 
+// Sample marker constant for tests / fixtures that need a body with a
+// canonical-format marker but don't care about the specific agent / kind /
+// wi fields. Matches MINIONS_COMMENT_MARKER_RE. Production comments build
+// their marker via _buildMarker / buildMinionsCommentBody.
+const MINIONS_COMMENT_MARKER = '<!-- minions:agent=minions kind=marker -->';
+
 // Cheaper "is this body already marked?" check that matches only at position 0
 // (for idempotency in buildMinionsCommentBody). Kept separate from the
 // exported regex so the public regex can be used by downstream classifiers
@@ -231,6 +237,7 @@ module.exports = {
   // Builders / parsers (pure functions — usable from anywhere)
   buildMinionsCommentBody,
   parseMinionsMarker,
+  MINIONS_COMMENT_MARKER,
   MINIONS_COMMENT_MARKER_RE,
   // Validation regexes (exported for downstream consumers)
   AGENT_ID_RE,

package/engine/github.js

@@ -7,6 +7,7 @@
 const shared = require('./shared');
 const { exec, execAsync, getProjects, projectPrPath, projectWorkItemsPath, safeJson, safeJsonArr, safeWrite, mutateJsonFileLocked, MINIONS_DIR, getPrLinks, backfillPrPrdItems, log, ts, dateStamp, PR_STATUS, PR_POLLABLE_STATUSES, createThrottleTracker, getProjectOrg } = shared;
 const { getPrs } = require('./queries');
+const { MINIONS_COMMENT_MARKER_RE } = require('./gh-comment');
 const path = require('path');
 
 // Lazy require to avoid circular dependency — only needed for engine().handlePostMerge
@@ -85,131 +86,94 @@ function _isNonActionableComment(c, config = {}) {
   if (_isAgentComment(c)) return true;
   if (_isCiReportCommentBody(c?.body)) return true;
   if (_isPreviewStatusComment(c)) return true;
-  if (_isAgentPositiveSignalComment(c, config)) return true;
+  if (_isMinionsAuthoredComment(c)) return true;
   return false;
 }
 
-// P-a3f9b2c1 — Detect agent self-positive-signal comments (verification SUCCESS reports,
-// VERDICT:APPROVE recaps, noop:true confessions) posted via the shared `gh` PAT identity.
+// W-mp3bp0ha000997ab-b — Structural classifier for Minions-authored PR comments.
 //
-// Sibling to PR #2431's `_isAgentSelfReviewDeclinedComment` but keys off body-shape markers
-// + an opt-in shared-minions login allowlist (REST `/issues/:n/comments` doesn't expose
-// GraphQL's `viewerDidAuthor` flag, so we approximate via configured logins).
+// 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
+// shared PAT identity used by all minions agents).
 //
-// Configuration:
-//   engine.botCommentLogins: string[]  — primary opt-in list (e.g. ['yemi33'])
-//   engine.ignoredCommentAuthors: string[]  — fallback (back-compat with existing knob)
+// Both gates are required:
+//   - `viewerDidAuthor: true` 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.
 //
-// Reference: PR #2433 (3 consecutive noop fix-dispatches when verify agents posted
-// "Result: SUCCESS" comments via the shared yemi33 PAT identity).
-function _sharedMinionsLogins(config = {}) {
-  const primary = Array.isArray(config?.engine?.botCommentLogins) ? config.engine.botCommentLogins : [];
-  const fallback = Array.isArray(config?.engine?.ignoredCommentAuthors) ? config.engine.ignoredCommentAuthors : [];
-  return new Set([...primary, ...fallback].map(s => String(s || '').toLowerCase()).filter(Boolean));
+// Production note: the GitHub REST endpoints we poll (/issues/:n/comments and
+// /pulls/:n/comments) do NOT populate `viewerDidAuthor` — that field is GraphQL-
+// only. `pollPrHumanComments` therefore backfills it via `_backfillViewerDidAuthor`
+// using the viewer login resolved by `_resolveViewerLogin` (one `gh api user` call
+// per process). This keeps the classifier alive in production without forcing a
+// GraphQL migration on every fetch site.
+//
+// Sub-item -a populates the marker on every minions-posted comment via a helper.
+// Sub-item -c migrates existing engine call sites + playbook examples.
+function _isMinionsAuthoredComment(c) {
+  if (!c || c.viewerDidAuthor !== true) return false;
+  const body = c.body || '';
+  const m = MINIONS_COMMENT_MARKER_RE.exec(body);
+  if (!m) return false;
+  // Strict: marker must be on its OWN first line (no leading content,
+  // no trailing content on the same line). MINIONS_COMMENT_MARKER_RE uses
+  // /m so it would otherwise match the start of any line; we additionally
+  // require the match to be at index 0 AND to occupy the first line
+  // exactly (modulo surrounding whitespace).
+  if (m.index !== 0) return false;
+  const lineEnd = body.indexOf('\n');
+  const firstLine = lineEnd === -1 ? body : body.slice(0, lineEnd);
+  return firstLine.trim() === m[0].trim();
 }
 
-// Pure body-shape matcher for agent positive-signal markers in PR comments.
-// Triggers on:
-//   - "Verification SUCCESS" / "Verification SUCCEEDED" / "Verification ran" (verify-dispatch reports)
-//   - "Result: SUCCESS" (verify-dispatch report header per playbooks/verify.md)
-//   - "VERDICT: APPROVE" (review-loop positive verdict — defense-in-depth alongside _hasMinionsReviewVerdict)
-//   - `noop: true` / `"noop": true` (completion-report-style noop confession copied to comment)
-function _hasAgentPositiveSignalBody(body) {
-  const text = String(body || '');
-  if (!text) return false;
-  if (/(?:^|\n)\s*\*{0,2}VERDICT[:\s]+\*{0,2}APPROVE\b/i.test(text)) return true;
-  if (/"?\bnoop\b"?\s*:\s*true\b/i.test(text)) return true;
-  if (/\bVerification\s+(?:SUCCESS(?:FUL|FULLY)?|SUCCEEDED|ran)\b/i.test(text)) return true;
-  if (/(?:^|\n)\s*#{0,3}\s*Result\s*:\s*SUCCESS\b/i.test(text)) return true;
-  return false;
+// ─── Viewer Login Resolution ────────────────────────────────────────────────
+// `_isMinionsAuthoredComment` (above) gates on `c.viewerDidAuthor === true`.
+// That field is populated by GitHub's GraphQL API but NOT by the REST
+// `/issues/:n/comments` and `/pulls/:n/comments` endpoints we use in
+// `pollPrHumanComments` (REST returns `viewerDidAuthor: null`). To make the
+// classifier alive in production without changing every fetch site to
+// GraphQL, we backfill the field by comparing the comment author's login to
+// the viewer login resolved via `gh api user` once per process. The shared
+// PAT identity does not change during a process lifetime, so a simple
+// in-memory cache is sufficient.
+let _cachedViewerLogin = null;
+
+async function _resolveViewerLogin() {
+  if (_cachedViewerLogin) return _cachedViewerLogin;
+  try {
+    const result = await execAsync('gh api user', { timeout: 10000, encoding: 'utf-8', maxBuffer: GH_MAX_BUFFER });
+    const parsed = JSON.parse(String(result || ''));
+    const login = parsed?.login ? String(parsed.login).toLowerCase() : null;
+    if (login) _cachedViewerLogin = login;
+    return login;
+  } catch (e) {
+    log('warn', `GitHub viewer-login resolution failed: ${e?.message || e}`);
+    return null;
+  }
 }
 
-function _isAgentPositiveSignalComment(c, config = {}) {
-  if (!c) return false;
-  const sharedLogins = _sharedMinionsLogins(config);
-  if (sharedLogins.size === 0) return false;
-  const login = String(c?.user?.login || '').toLowerCase();
-  if (!login || !sharedLogins.has(login)) return false;
-  return _hasAgentPositiveSignalBody(c.body);
+// Test hook: lets tests prime or clear the cached viewer login without
+// shelling out. Pass `null` to force a re-resolve on the next call.
+function _setCachedViewerLogin(login) {
+  _cachedViewerLogin = login ? String(login).toLowerCase() : null;
 }
 
-// W-mp2h696g000a7bc0 — Detect agent self-review-declined no-op comments.
-//
-// Per the documented contract (memory `subject: self-review`, docs/completion-reports.md:83-105):
-// when an agent is dispatched to review a PR they implemented, they post a `gh pr comment`
-// (no `VERDICT:` line) explaining the recusal and complete with `noop:true, verdict:null,
-// needs_rerun:true`. Because `gh` authenticates as the shared PAT user (`yemi33`), the
-// classifier can't tell the noop comment from a real human comment by author alone.
-//
-// Detection requires a stronger signal than author identity. Returns true only when BOTH:
-//   1. Body has NO `VERDICT:` line (we never want to swallow a real verdict comment), AND
-//   2. EITHER the body contains the canonical "Self-review declined" phrase AND references
-//      a dispatch id matching `<agent>-<type>-<uid>` that resolves to a same-agent
-//      review/implement dispatch in the completed history,
-//      OR the most recent review dispatch on this PR was assigned to the same agent as the
-//      PR author and completed with the noop:true / verdict:null / needs_rerun:true contract.
-//
-// This is a narrow allowlist for the noop pattern — generic PAT-user comments still flow
-// through `_isNonActionableComment` and trigger `humanFeedback.pendingFix=true` as before.
-function _isAgentSelfReviewDeclinedComment(c, { pr, dispatch } = {}) {
-  if (!c || !pr) return false;
-  const body = String(c.body || '');
-  if (!body) return false;
-  if (_hasMinionsReviewVerdict(body)) return false;
-
-  const prAuthorAgent = String(pr.agent || '').toLowerCase();
-  if (!prAuthorAgent) return false;
-
-  const completed = (dispatch && Array.isArray(dispatch.completed)) ? dispatch.completed : [];
-  const isNoopContract = (sc) => {
-    if (!sc || typeof sc !== 'object') return false;
-    if (sc.noop !== true && sc.noop !== 'true') return false;
-    if (sc.verdict !== null && sc.verdict !== undefined && sc.verdict !== '') return false;
-    if (sc.needs_rerun !== true && sc.needsRerun !== true) return false;
-    return true;
-  };
-
-  // Signal A — explicit "Self-review declined" phrase + verifiable dispatch id pointing
-  // at a same-agent review/implement/fix dispatch in the completed history.
-  const phraseMatch = /self[\s\-_]+review\s+declined/i.test(body);
-  if (phraseMatch) {
-    const dispatchIdMatches = body.match(/\b[a-z][a-z0-9]*-[a-z][a-z0-9]*-[a-z0-9]{8,}\b/g) || [];
-    for (const id of dispatchIdMatches) {
-      const entry = completed.find(d => d && d.id === id);
-      if (!entry) continue;
-      const agent = String(entry.agent || '').toLowerCase();
-      const t = String(entry.type || '').toLowerCase();
-      if (agent !== prAuthorAgent) continue;
-      if (t === 'review' || t === 'implement' || t === 'implement-large' || t === 'fix') {
-        return true;
-      }
-    }
+// Backfill `c.viewerDidAuthor` for an array of REST-fetched comments using
+// the resolved viewer login. Only sets the field when REST returned
+// null/undefined — never overrides a value that GraphQL or the test fixture
+// already supplied. Mutates the comment objects in place.
+function _backfillViewerDidAuthor(comments, viewerLogin) {
+  if (!Array.isArray(comments) || !viewerLogin) return;
+  for (const c of comments) {
+    if (!c || typeof c !== 'object') continue;
+    if (c.viewerDidAuthor === true || c.viewerDidAuthor === false) continue;
+    const login = c.user?.login;
+    if (typeof login !== 'string' || !login) continue;
+    c.viewerDidAuthor = login.toLowerCase() === viewerLogin;
   }
-
-  // Signal B — most recent review dispatch on this PR was assigned to the PR author
-  // and completed with the documented noop contract. Catches the case where the agent
-  // forgot the canonical phrase but the completion-report contract still flags a noop.
-  const prId = String(pr.id || '');
-  const prNumberRaw = pr.prNumber;
-  const prNumber = prNumberRaw == null ? null : Number(prNumberRaw);
-  const reviewDispatches = completed.filter(d => {
-    if (!d || String(d.type || '').toLowerCase() !== 'review') return false;
-    const dpr = d.meta && d.meta.pr;
-    if (!dpr) return false;
-    if (prId && String(dpr.id || '') === prId) return true;
-    if (prNumber != null && Number(dpr.prNumber) === prNumber) return true;
-    return false;
-  });
-  if (reviewDispatches.length === 0) return false;
-  reviewDispatches.sort((a, b) => {
-    const ta = String(a.completed_at || a.created_at || '');
-    const tb = String(b.completed_at || b.created_at || '');
-    return tb.localeCompare(ta);
-  });
-  const latest = reviewDispatches[0];
-  if (!latest) return false;
-  if (String(latest.agent || '').toLowerCase() !== prAuthorAgent) return false;
-  return isNoopContract(latest.structuredCompletion);
 }
 
 // ─── Per-Repo Poll Backoff ──────────────────────────────────────────────────
@@ -821,13 +785,18 @@ async function pollPrStatus(config) {
 
 async function pollPrHumanComments(config) {
   // Load dispatch state once per poll cycle (cached for ~2s by queries.getDispatch).
-  // Used by `_isAgentSelfReviewDeclinedComment` to verify dispatch ids referenced in
-  // candidate noop comments belong to the PR author.
+  // (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 dispatch = (() => {
     try { return queries.getDispatch(); }
     catch { return { pending: [], active: [], completed: [] }; }
   })();
+  // Resolve viewer login once per poll cycle so we can backfill
+  // `viewerDidAuthor` on REST comments — the field GraphQL would have
+  // populated. `_resolveViewerLogin` caches process-wide, so repeated calls
+  // across PRs are free.
+  const viewerLogin = await _resolveViewerLogin();
   const totalUpdated = await forEachActiveGhPr(config, async (project, pr, prNum, slug) => {
     // Get issue comments (general PR comments)
     const comments = await ghApi(`/issues/${prNum}/comments`, slug);
@@ -840,6 +809,11 @@ async function pollPrHumanComments(config) {
       ...(Array.isArray(reviewComments) ? reviewComments : []).map(c => ({ ...c, _type: 'review' }))
     ];
 
+    // Backfill viewerDidAuthor on each comment so _isMinionsAuthoredComment
+    // can actually fire on production traffic. No-op when GraphQL or a test
+    // fixture already populated the field.
+    _backfillViewerDidAuthor(allComments, viewerLogin);
+
     const cutoffStr = pr.humanFeedback?.lastProcessedCommentDate || pr.created || '1970-01-01';
     const cutoffMs = new Date(cutoffStr).getTime() || 0;
 
@@ -853,12 +827,12 @@ async function pollPrHumanComments(config) {
     for (const c of allComments) {
       const date = c.created_at || c.updated_at || '';
       const dateMs = date ? new Date(date).getTime() : 0;
-      // W-mp2h696g000a7bc0 — agent self-review-declined no-op comments are posted via
-      // `gh pr comment` and authenticate as the shared PAT user, so author identity alone
-      // can't distinguish them from real human feedback. The narrow allowlist check uses
-      // the comment body + dispatch history to identify the documented noop pattern.
-      const isNonActionable = _isNonActionableComment(c, config)
-        || _isAgentSelfReviewDeclinedComment(c, { pr, dispatch });
+      // W-mp3bp0ha000997ab-b — All non-actionable filtering routes through
+      // _isNonActionableComment, which now composes _isMinionsAuthoredComment
+      // (structural marker check). The previous OR chain that appended
+      // _isAgentSelfReviewDeclinedComment is gone — that helper was deleted
+      // with this PR.
+      const isNonActionable = _isNonActionableComment(c, config);
       if (dateMs) allCommentDates.push(date);
       if (isNonActionable) continue;
       const entry = {
@@ -883,26 +857,6 @@ async function pollPrHumanComments(config) {
     }
     if (newComments.length === 0) return false;
 
-    // P-a3f9b2c1 — Defense-in-depth: when the PR is already approved AND every new comment
-    // is from a configured shared-minions PAT identity AND every new comment matches the
-    // positive-signal body shape, suppress pendingFix and advance cutoff. Belt-and-suspenders
-    // against future regressions in `_isAgentPositiveSignalComment`. This is intentionally
-    // narrow — a single human-shaped comment in newComments (e.g. "rename _foo to bar") will
-    // disqualify the entire batch and let the normal human-feedback flow run.
-    if (String(pr.reviewStatus || '').toLowerCase() === 'approved') {
-      const sharedLogins = _sharedMinionsLogins(config);
-      if (sharedLogins.size > 0) {
-        const allFromSharedPat = newComments.every(nc => sharedLogins.has(String(nc.author || '').toLowerCase()));
-        const allPositiveShape = newComments.every(nc => _hasAgentPositiveSignalBody(nc.content));
-        if (allFromSharedPat && allPositiveShape) {
-          const cutoff = allNewDates.sort().pop() || newComments[newComments.length - 1].date;
-          pr.humanFeedback = { ...(pr.humanFeedback || {}), lastProcessedCommentDate: cutoff };
-          log('info', `PR ${pr.id}: ${newComments.length} new shared-PAT positive-signal comment(s) on approved PR — defense-in-depth suppression`);
-          return true;
-        }
-      }
-    }
-
     // Sort all comments chronologically and build full context for the fix agent
     allCommentEntries.sort((a, b) => a.date.localeCompare(b.date));
     newComments.sort((a, b) => a.date.localeCompare(b.date));
@@ -1200,9 +1154,9 @@ module.exports = {
   _hasMinionsReviewVerdict, // exported for testing
   _isAgentComment, // exported for testing
   _isNonActionableComment, // exported for testing
-  _isAgentSelfReviewDeclinedComment, // exported for testing
-  _isAgentPositiveSignalComment, // exported for testing (P-a3f9b2c1)
-  _hasAgentPositiveSignalBody, // exported for testing (P-a3f9b2c1)
-  _sharedMinionsLogins, // exported for testing (P-a3f9b2c1)
+  _isMinionsAuthoredComment, // exported for testing (W-mp3bp0ha000997ab-b)
   _isPreviewStatusComment, // exported for testing
+  _resolveViewerLogin, // exported for testing (W-mp3bp0ha000997ab-b backfill)
+  _setCachedViewerLogin, // exported for testing (W-mp3bp0ha000997ab-b backfill)
+  _backfillViewerDidAuthor, // exported for testing (W-mp3bp0ha000997ab-b backfill)
 };

package/engine/shared.js

@@ -1119,6 +1119,7 @@ const ENGINE_DEFAULTS = {
   copilotSuppressAgentsMd: true,     // Copilot --no-custom-instructions: stop AGENTS.md auto-load from fighting Minions playbook prompts
   copilotStreamMode: 'on',           // Copilot --stream <on|off>: 'on' streams assistant.message_delta events live; 'off' batches them
   copilotReasoningSummaries: false,  // Copilot --enable-reasoning-summaries (Anthropic-family models only)
+  ccUseWorkerPool: false,            // Sub-task C of W-mp2w003600196c51 (CC perf): when true, _invokeCcStream routes through engine/cc-worker-pool.js (persistent `copilot --acp` per CC tab) instead of spawning a fresh CLI per turn. Off by default — opt-in feature flag. Engine/agent dispatch path stays per-process regardless.
   maxBudgetUsd: undefined,       // fleet USD ceiling for --max-budget-usd (per-agent override: agents.<id>.maxBudgetUsd). Honors 0 via ?? so a literal cap of $0 works
   disableModelDiscovery: false,  // skip runtime.listModels() REST calls fleet-wide (settings UI falls back to free-text)
   maxPendingContexts: 20, // cap pendingContexts arrays in cooldowns.json to prevent unbounded growth

package/package.json

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