@yemi33/minions 0.1.2098 → 0.1.2100

package/dashboard/js/settings.js

@@ -145,7 +145,7 @@ async function openSettings() {
         // W-mpmwxni2000c25c7-d — per-turn watchdog. Surfaced under CC overrides
         // because it gates CC/doc-chat error visibility (not the agent fleet).
         '<div style="display:grid;grid-template-columns:1fr;gap:8px;margin-top:8px">' +
-          settingsField('CC Turn Timeout', 'set-ccTurnTimeoutMs', e.ccTurnTimeoutMs || 300000, 'ms', 'Per-turn watchdog for CC + doc-chat. If no terminal SSE event arrives within this window the handler emits event: error with code: cc-turn-timeout, the spinner stops, and a Retry button is shown. Clamped to 10000–3600000 ms.') +
+          settingsField('CC Turn Timeout', 'set-ccTurnTimeoutMs', e.ccTurnTimeoutMs || 300000, 'ms', 'Per-turn no-progress watchdog for CC + doc-chat. Resets on every liveness signal (token chunk, tool call, tool update) so an actively-streaming turn — long shell command, deep search, sub-agent loop — survives indefinitely up to the outer 1h hard ceiling. Only true silence past this window fires event: error with code: cc-turn-timeout, stops the spinner, and offers Retry. Clamped to 10000–3600000 ms.') +
         '</div>' +
       '</details>' +
     '</div>' +

package/dashboard.js

@@ -2566,7 +2566,19 @@ function _getCcLiveStream(tabId) {
   return ccLiveStreams.get(tabId) || null;
 }
 function _touchCcLiveStream(state) {
-  if (state) state.updatedAt = Date.now();
+  if (!state) return;
+  state.updatedAt = Date.now();
+  // W-mpmwxni2000c25c7-b — every CC streaming progress event (onChunk,
+  // onToolUse, onToolUpdate in both _invokeCcStream paths) already routes
+  // through here for the stall detector. Piggy-back the per-turn watchdog's
+  // bumpTimer on the same heartbeat so a turn that's actively streaming
+  // tokens or running long tools can't be killed by stale inactivity. The
+  // watchdog installs `_bumpTimer` for the duration of the turn and removes
+  // it in `finally`, so late progress callbacks delivered after resolution
+  // are a no-op.
+  if (typeof state._bumpTimer === 'function') {
+    try { state._bumpTimer(); } catch { /* swallow */ }
+  }
 }
 function _clearCcLiveTimers(tabId) {
   const state = _getCcLiveStream(tabId);
@@ -4225,43 +4237,71 @@ function _buildDocChatErrorEnvelope(result) {
 // with a doc-chat-shaped failure payload that flows through the existing
 // _docChatFailureResponse / SSE error event paths. timeoutMs <= 0 disables
 // the watchdog (passthrough).
-async function _raceCcDocChatTimeout(callPromise, timeoutMs, abortFn, label) {
-  if (!timeoutMs || timeoutMs <= 0) return callPromise;
+async function _raceCcDocChatTimeout(callPromiseOrFactory, timeoutMs, abortFn, label) {
+  // W-mpmwxni2000c25c7-b — no-progress semantics. Callers that want a
+  // self-resetting watchdog pass `callPromiseOrFactory` as a function
+  // `(bumpTimer) => Promise<result>`. The factory is invoked synchronously
+  // before the race starts so any onChunk/onToolUse closures defined inside
+  // can capture `bumpTimer` and reset the timer on each liveness signal.
+  // Legacy callers that pass a pre-started Promise get the old wall-clock
+  // behavior — kept for the non-streaming doc-chat path which has no
+  // progress hooks to wire bump into.
+  const isFactory = typeof callPromiseOrFactory === 'function';
+  if (!timeoutMs || timeoutMs <= 0) {
+    return isFactory ? callPromiseOrFactory(() => {}) : callPromiseOrFactory;
+  }
   let timer = null;
   let timedOut = false;
+  let done = false;
+  let timeoutResolve = null;
+  const fire = () => {
+    if (done) return;
+    timedOut = true;
+    try { if (abortFn) abortFn(); } catch { /* swallow */ }
+    if (timeoutResolve) timeoutResolve(null);
+  };
+  const bumpTimer = () => {
+    if (timedOut || done) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(fire, timeoutMs);
+  };
   const timeoutPromise = new Promise((resolve) => {
-    timer = setTimeout(() => {
-      timedOut = true;
-      try { if (abortFn) abortFn(); } catch { /* swallow */ }
-      resolve(null);
-    }, timeoutMs);
+    timeoutResolve = resolve;
+    timer = setTimeout(fire, timeoutMs);
     // NOTE: do NOT unref — Node would exit the event loop while awaiting the
     // call promise (Promises don't keep the loop open; timers/I/O do). Cleared
     // immediately on the success path below.
   });
-  const winner = await Promise.race([callPromise, timeoutPromise]);
-  if (!timedOut) {
-    clearTimeout(timer);
-    return winner;
-  }
-  // Drain the in-flight call so its cleanup runs before we hand back the
-  // synthetic envelope.
-  await callPromise.catch(() => null);
-  const message = `${label || 'doc-chat'} turn timed out after ${timeoutMs}ms`;
-  return {
-    answer: 'Document chat request timed out — try again.',
-    toolUses: [],
-    error: {
-      code: 'cc-turn-timeout',
-      stderr: '',
-      errorClass: 'cc-turn-timeout',
-      errorMessage: message,
-      runtime: null,
-      typedCode: 'cc-turn-timeout',
-      typedMessage: message,
-      retriable: true,
-    },
-  };
+  // Factory branch: invoke synchronously so bumpTimer is already in scope
+  // before any progress event fires. Promise branch: legacy passthrough.
+  const callPromise = isFactory
+    ? Promise.resolve().then(() => callPromiseOrFactory(bumpTimer))
+    : callPromiseOrFactory;
+  try {
+    const winner = await Promise.race([callPromise, timeoutPromise]);
+    if (!timedOut) return winner;
+    // Drain the in-flight call so its cleanup runs before we hand back the
+    // synthetic envelope.
+    await callPromise.catch(() => null);
+    const message = `${label || 'doc-chat'} turn timed out after ${timeoutMs}ms with no progress`;
+    return {
+      answer: 'Document chat request timed out — try again.',
+      toolUses: [],
+      error: {
+        code: 'cc-turn-timeout',
+        stderr: '',
+        errorClass: 'cc-turn-timeout',
+        errorMessage: message,
+        runtime: null,
+        typedCode: 'cc-turn-timeout',
+        typedMessage: message,
+        retriable: true,
+      },
+    };
+  } finally {
+    done = true;
+    if (timer) { clearTimeout(timer); timer = null; }
+  }
 }
 
 function _docChatFailureResponse(label, filePath, result, sessionPreserved = false) {
@@ -7104,12 +7144,17 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const ccTurnId = 'cct-' + shared.uid();
       const turnSystemPrompt = renderDocChatSystemPromptForTurn(ccTurnId);
 
-      // W-mpmwxni2000c25c7-b — wall-clock turn watchdog. The doc-chat call
-      // can internally spawn resume + fresh + final-retry LLM calls; we want
-      // ONE wall-clock cap that covers the whole turn so a runtime stuck
+      // W-mpmwxni2000c25c7-b — wall-clock turn watchdog. The non-streaming
+      // doc-chat path has no progress callbacks to wire `bumpTimer` into,
+      // so this caller intentionally uses the legacy promise shape of
+      // _raceCcDocChatTimeout (wall-clock cap, not no-progress). The
+      // doc-chat call can internally spawn resume + fresh + final-retry LLM
+      // calls; one wall-clock cap covers the whole turn so a runtime stuck
       // mid-stream can't outlive ccTurnTimeoutMs. On expiry the watchdog
-      // calls _docAbort (kills the in-flight CLI) and the synthesized payload
-      // below flows through the existing _docChatFailureResponse path.
+      // calls _docAbort (kills the in-flight CLI) and the synthesized
+      // payload below flows through the existing _docChatFailureResponse
+      // path. Streaming consumers (handleDocChatStream) get the proper
+      // no-progress behavior via the factory shape.
       const _docTurnTimeoutMs = _resolveCcTurnTimeoutMs();
       const _docCallPromise = ccDocCall({
         message: body.message, document: currentContent, title: body.title,
@@ -7248,25 +7293,27 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         const ccTurnId = 'cct-' + shared.uid();
         const turnSystemPrompt = renderDocChatSystemPromptForTurn(ccTurnId);
 
-        // W-mpmwxni2000c25c7-b — wall-clock turn watchdog (mirrors the
-        // non-stream handleDocChat path). On expiry _docAbort kills the
-        // in-flight LLM and the synthesized payload below flows through the
-        // SSE done frame the client already expects with `error` set.
+        // W-mpmwxni2000c25c7-b — no-progress turn watchdog (mirrors the
+        // non-stream handleDocChat path). The factory shape lets the
+        // onChunk/onToolUse callbacks close over `bumpTimer` so each chunk
+        // or tool event resets the timer; only true silence past
+        // `_docTurnTimeoutMs` (no chunks, no tools) fires `_docAbort` and
+        // surfaces the synthesized payload below through the SSE done frame
+        // the client already expects with `error` set.
         const _docTurnTimeoutMs = _resolveCcTurnTimeoutMs();
-        const _docStreamCallPromise = ccDocCallStreaming({
+        const _docStreamResult = await _raceCcDocChatTimeout((bumpTimer) => ccDocCallStreaming({
           message: body.message, document: currentContent, title: body.title,
           filePath: body.filePath, selection: body.selection, canEdit, isJson,
           model: body.model || undefined,
           freshSession: !!body.freshSession,
           transcript: body.transcript,
           onAbortReady: (abort) => { _docAbort = abort; },
-          onChunk: (text) => { writeDocEvent({ type: 'chunk', text }); },
-          onToolUse: (name, input) => { writeDocEvent({ type: 'tool', name, input: _lightToolInput(input) }); },
-          onRetry: (attempt) => { writeDocEvent({ type: 'progress', attempt }); },
+          onChunk: (text) => { bumpTimer(); writeDocEvent({ type: 'chunk', text }); },
+          onToolUse: (name, input) => { bumpTimer(); writeDocEvent({ type: 'tool', name, input: _lightToolInput(input) }); },
+          onRetry: (attempt) => { bumpTimer(); writeDocEvent({ type: 'progress', attempt }); },
           systemPrompt: turnSystemPrompt,
           turnId: ccTurnId,
-        });
-        const _docStreamResult = await _raceCcDocChatTimeout(_docStreamCallPromise, _docTurnTimeoutMs, () => _docAbort && _docAbort(), 'doc-chat-stream');
+        }), _docTurnTimeoutMs, () => _docAbort && _docAbort(), 'doc-chat-stream');
         let { answer, partial, warning, toolUses, error: ccError } = _docStreamResult;
         const finalize = _finalizeDocChatEdit({
           filePath: body.filePath, fullPath, isJson, canEdit,
@@ -8565,7 +8612,17 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         const turnTimeoutMs = _resolveCcTurnTimeoutMs();
         const result = await withTimeout({
           timeoutMs: turnTimeoutMs, label: 'command-center-stream',
-        }, async (registerAbort) => {
+        }, async (registerAbort, bumpTimer) => {
+          // W-mpmwxni2000c25c7-b — no-progress semantics: install bumpTimer
+          // on liveState so _touchCcLiveStream (called from every onChunk /
+          // onToolUse / onToolUpdate in both _invokeCcStream paths) resets
+          // the watchdog on every liveness signal. A turn that's actively
+          // streaming tokens or running long tools survives indefinitely
+          // up to the outer CC_CALL_TIMEOUT_MS ceiling. Cleared in
+          // `finally` so a late progress event after resolution can't
+          // re-arm against a stale abort target.
+          liveState._bumpTimer = bumpTimer;
+          try {
           const llmPromise = _invokeCcStream({
             prompt, sessionId, liveState, toolUses,
             model: streamModel, effort: streamEffort, maxTurns: ccMaxTurns,
@@ -8614,6 +8671,13 @@ What would you like to discuss or change? When you're happy, say "approve" and I
             }
           }
           return initial;
+          } finally {
+            // Only clear if this turn's bumpTimer is still installed —
+            // belt-and-suspenders for any future code that might swap a
+            // newer bumpTimer in mid-turn (shouldn't happen today, but
+            // protects against silent overwrite).
+            if (liveState._bumpTimer === bumpTimer) delete liveState._bumpTimer;
+          }
         });
         if (result.missingRuntime) {
           finishMissingRuntime(result, liveState);

package/docs/command-center.md

@@ -27,7 +27,7 @@ Canonical envelope (`_buildCcErrorEnvelope` in `dashboard.js`):
 
 `code` is clamped to the allowlist (`CC_ERROR_CODES` constant); unknown codes collapse to `crash`. `retryable: true` is informational — there is **no auto-retry**; the dashboard always offers a manual Retry button instead. Auto-retrying these errors is a footgun because most are operator-fix categories (auth, budget, missing model) where re-spawning makes no progress.
 
-**Watchdog (`engine.ccTurnTimeoutMs`, default 5 min, clamped 10s–1h).** Each turn arms a `setTimeout` that fires `event: error` with `code: 'cc-turn-timeout'`, aborts the in-flight LLM call, and ends the stream when no terminal event (`done`/`error`) arrives in time. Independent of `CC_CALL_TIMEOUT_MS` (the outer 1h hard ceiling); the watchdog is the *visible-to-user* no-progress cap. Surfaced in Settings → CC overrides.
+**Watchdog (`engine.ccTurnTimeoutMs`, default 5 min, clamped 10s–1h).** Per-turn **no-progress** cap. Each turn arms a `setTimeout` that fires `event: error` with `code: 'cc-turn-timeout'`, aborts the in-flight LLM call, and ends the stream when no liveness signal arrives within the window. The timer **resets on every progress event** — token chunk, tool-call notification, tool-update — so a turn that's actively streaming or running long tools (e.g. `Bash` running `npm test`, `WebFetch`/`WebSearch` against slow targets, agent sub-dispatches) survives indefinitely up to the outer 1h `CC_CALL_TIMEOUT_MS` hard ceiling. Wired via `liveState._bumpTimer` (CC stream path) and the factory shape of `_raceCcDocChatTimeout` (doc-chat stream path); the non-streaming doc-chat path has no progress hooks and retains wall-clock semantics. Surfaced in Settings → CC overrides.
 
 **No auto-retry policy.** The backend never re-spawns the LLM after an error envelope. The client never silently resends the user's turn. Retry is a single-click manual action — guards against silent budget burn on `budget-exceeded`, infinite loops on `auth-failure`, and accidental re-charges on `context-limit`. The 429 + reconnect paths (rate-limited fetch retry, SSE reconnect-after-disconnect) remain — those are transport-level, not error-envelope-level.
 

package/docs/copilot-cli-schema.md

@@ -63,14 +63,22 @@ The `gh-copilot` extension is documented at
 <https://docs.github.com/en/copilot/github-copilot-in-the-cli>. On this test
 machine `gh extension list` returned empty, so this path was **not exercised
 empirically**. The adapter contract still needs to support it for hosts without
-the WinGet standalone install:
+the WinGet standalone install.
+
+**Detection note (#2965):** `gh ≥ ~2.90` ships Copilot as a built-in preview
+subcommand, NOT as an extension — `gh extension list` does not list it, and
+`gh extension install github/gh-copilot` is rejected because the command is
+already provided. The adapter therefore probes with `gh copilot --help` (with
+`--no-update-notifier`); exit 0 means the subcommand is available via either
+the modern built-in OR a legacy installed extension, and exit non-zero means
+neither path is present. See `engine/runtimes/copilot.js#_findGhCopilotPath`.
 
 ```text
-gh extension install github/gh-copilot
-gh copilot --help    # subcommand of gh
+gh extension install github/gh-copilot   # only needed for gh < 2.90
+gh copilot --help                        # detection probe (built-in OR extension)
 ```
 
-When falling back to the extension form, the adapter must return:
+When falling back to the gh-hosted form, the adapter must return:
 
 ```js
 { bin: '<path-to-gh.exe>', native: true, leadingArgs: ['copilot'] }
@@ -584,8 +592,11 @@ When implementing `engine/runtimes/copilot.js`:
 2. `resolveBinary()`:
    - PATH → standalone first; cache to `engine/copilot-caps.json` with
      `{ copilotBin, copilotIsNative, leadingArgs: [] }`.
-   - `gh extension list | grep gh-copilot` → fallback with
-     `leadingArgs: ['copilot']`. Mark the result as `bestEffort: true` so
+   - `gh copilot --help` (exit 0) → fallback with
+     `leadingArgs: ['copilot']`. This covers BOTH the legacy `gh-copilot`
+     extension AND the modern built-in (gh ≥ ~2.90 ships `copilot` as a
+     built-in subcommand, not an extension — so `gh extension list` no longer
+     surfaces it; #2965). Mark the result as `bestEffort: true` so
      preflight can warn.
    - **Never** probe npm. Document this in the file header.
 3. `buildArgs(opts)` always emits:

package/docs/pr-review-fix-loop.md

@@ -65,6 +65,22 @@ The engine does not cap review→fix cycles or build-fix attempts. Each trigger
 - Routes to the PR author to resolve target-branch conflicts
 - Runs after review, human, and build triggers; if any earlier trigger enqueued a fix for this PR, the conflict fix waits for a later discovery pass
 
+### E. Paused causes (`_noOpFixes[cause].paused`)
+
+Each fix cause (build-failure, review-feedback, human-feedback, merge-conflict, pr-fix) tracks repeated no-op outcomes in `target._noOpFixes[cause]`. When `recordPrNoOpFixAttempt` flips `paused` from false to true (typically after multiple no-op dispatches with the same evidence fingerprint), the engine:
+
+- Writes a per-PR per-cause inbox alert with PR URL, branch, attempt count, before/after heads, the underlying reason, and three recovery paths.
+- Enriches the PR record returned from `queries.getPullRequests()` with `_pausedCauses` (the list of currently-paused cause keys).
+- Renders a red `_pausedCauses` chip per cause in the dashboard PR list (`dashboard/js/render-prs.js`).
+
+A paused cause **suppresses further auto-dispatch for that cause** until cleared. Recovery paths (any one):
+
+1. **Push a new SHA to the PR branch** — the next poll refreshes `pr.headSha`, the evidence fingerprint shifts, and `clearPrNoOpFixAttempt` runs on the next non-noop completion.
+2. **Click the red chip on the dashboard** — confirms, then `POST /api/pull-requests/clear-paused-cause` (`dashboard.js`, issue #2969) validates the cause against `shared.PR_FIX_CAUSE`, locates the PR via `mutatePullRequests` across project/central files, and calls `clearPrNoOpFixAttempt` to wipe the cause record.
+3. **Direct API call** — `POST /api/pull-requests/clear-paused-cause` with `{ prId, cause }`.
+
+The exported `recordPrNoOpFixAttempt` / `clearPrNoOpFixAttempt` helpers in `engine/lifecycle.js` are the only sanctioned entry points; the dispatch evaluator in `engine/lifecycle.js` (search `_noOpFixes[cause]`) gates re-dispatch on `record.paused === true`.
+
 ## 5. Fix completes
 
 - `updatePrAfterFix()` (lifecycle.js) sets `reviewStatus = 'waiting'` + `fixedAt = ts()`
@@ -128,6 +144,8 @@ The engine does not cap review→fix cycles or build-fix attempts. Each trigger
 | `lastReviewedAt` | `updatePrAfterReview()` | Prevents re-dispatch if reviewed |
 | `minionsReview` | Post-completion hooks | `{ reviewer, reviewedAt, note, fixedAt }` |
 | `humanFeedback` | `pollPrHumanComments()` | `{ pendingFix, feedbackContent, lastProcessedCommentDate }` |
+| `_noOpFixes[cause]` | `recordPrNoOpFixAttempt()` | Per-cause record `{ count, paused, fingerprint, beforeHead, afterHead }` driving the issue #2969 pause loop |
+| `_pausedCauses` | `queries.getPullRequests()` enrichment | Read-only list of currently-paused cause keys for UI rendering (computed from `_noOpFixes`) |
 
 ## Platform differences
 

package/engine/llm.js

@@ -913,60 +913,88 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
 
 // ─── CC turn watchdog ────────────────────────────────────────────────────────
 //
-// W-mpmwxni2000c25c7-b — wall-clock cap for a single CC/doc-chat turn. CC turns
+// W-mpmwxni2000c25c7-b — no-progress cap for a single CC/doc-chat turn. CC turns
 // are a higher-level concept than the per-LLM-call `timeout` opt: a turn can
 // internally retry (resume → fresh → final retry) and each retry has its own
 // per-call timer. Without a turn-level watchdog, a runtime stuck mid-stream
 // (no exit, no chunks, no errors) leaves the SSE handler waiting for the
 // per-call timer to fire and the user staring at the typing dots.
 //
-// Usage: `result = await withCcTurnTimeout({ timeoutMs, label, onAbortReady }, (registerAbort) => callerThatReturnsResultPromise(registerAbort))`.
+// Semantics: `timeoutMs` is a *no-progress* window, not a wall-clock cap.
+// Callers reset it by invoking `bumpTimer()` whenever a liveness signal
+// arrives (token chunk, tool-call notification, tool-update). A long but
+// actively-streaming turn survives indefinitely up to the outer call-level
+// hard ceiling (CC_CALL_TIMEOUT_MS, ~1h). Only true silence past `timeoutMs`
+// — no chunks, no tool events, no exit — fires the cancel. Without
+// `bumpTimer()` calls the behavior degrades to the old wall-clock cap.
+//
+// Usage: `result = await withCcTurnTimeout({ timeoutMs, label, onAbortReady },
+//   (registerAbort, bumpTimer) => callerThatReturnsResultPromise(registerAbort, bumpTimer))`.
 // The caller plumbs `registerAbort(abortFn)` into every nested LLM call's
 // `onAbortReady` so the watchdog can kill whichever attempt is in flight on
-// expiry. Returns the original result on success or a synthetic envelope
+// expiry, and invokes `bumpTimer()` from every progress callback so a still-
+// productive turn doesn't get killed by stale inactivity. Returns the original
+// result on success or a synthetic envelope
 // `{ text:'', error:{ code:'cc-turn-timeout', retriable:true } }` on expiry.
 async function withCcTurnTimeout({ timeoutMs, label = 'cc-turn', onAbortReady } = {}, callFn) {
-  if (!timeoutMs || timeoutMs <= 0) return callFn(onAbortReady || (() => {}));
+  if (!timeoutMs || timeoutMs <= 0) return callFn(onAbortReady || (() => {}), () => {});
   let currentAbort = null;
   let timedOut = false;
+  let done = false;
   let timer = null;
+  let timeoutResolve = null;
   const registerAbort = (abort) => {
     currentAbort = abort;
     if (onAbortReady) onAbortReady(abort);
   };
-  const inflight = Promise.resolve().then(() => callFn(registerAbort));
+  const fire = () => {
+    if (done) return;
+    timedOut = true;
+    try { if (currentAbort) currentAbort(); } catch { /* swallow */ }
+    if (timeoutResolve) timeoutResolve(null);
+  };
+  // bumpTimer is a no-op after the turn settles (done=true) so any late
+  // progress callback that fires post-resolution (e.g. a queued onChunk
+  // delivered after the SSE finished) cannot re-arm the watchdog and
+  // accidentally cancel a *future* unrelated abort target via a stale
+  // currentAbort reference.
+  const bumpTimer = () => {
+    if (timedOut || done) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(fire, timeoutMs);
+  };
   const timeoutPromise = new Promise((resolve) => {
-    timer = setTimeout(() => {
-      timedOut = true;
-      try { if (currentAbort) currentAbort(); } catch { /* swallow */ }
-      resolve(null);
-    }, timeoutMs);
+    timeoutResolve = resolve;
+    timer = setTimeout(fire, timeoutMs);
     // NOTE: do NOT unref this timer. If we did, Node would exit the event
     // loop while waiting on the inflight promise (Promises themselves don't
     // hold the loop open — only timers/I/O do). The race below clears the
     // timer immediately on success, so a still-armed timer never leaks past
     // the resolution.
   });
-  const winner = await Promise.race([inflight, timeoutPromise]);
-  if (!timedOut) {
-    clearTimeout(timer);
-    return winner;
+  const inflight = Promise.resolve().then(() => callFn(registerAbort, bumpTimer));
+  try {
+    const winner = await Promise.race([inflight, timeoutPromise]);
+    if (!timedOut) return winner;
+    // Let the in-flight call settle so its cleanup (cleanupFiles/Dirs, kill
+    // sweeps) actually runs before we hand a synthetic envelope to the caller.
+    const settled = await inflight.catch((err) => ({
+      text: '', usage: null, sessionId: null, code: 1, stderr: String(err && err.message || err), raw: '', toolUses: [],
+    }));
+    const message = `CC turn ${label} timed out after ${timeoutMs}ms with no progress`;
+    return {
+      ...settled,
+      text: '',
+      code: settled?.code || 1,
+      errorClass: 'cc-turn-timeout',
+      errorMessage: message,
+      error: { message, code: 'cc-turn-timeout', retriable: true },
+      ok: false,
+    };
+  } finally {
+    done = true;
+    if (timer) { clearTimeout(timer); timer = null; }
   }
-  // Let the in-flight call settle so its cleanup (cleanupFiles/Dirs, kill
-  // sweeps) actually runs before we hand a synthetic envelope to the caller.
-  const settled = await inflight.catch((err) => ({
-    text: '', usage: null, sessionId: null, code: 1, stderr: String(err && err.message || err), raw: '', toolUses: [],
-  }));
-  const message = `CC turn ${label} timed out after ${timeoutMs}ms`;
-  return {
-    ...settled,
-    text: '',
-    code: settled?.code || 1,
-    errorClass: 'cc-turn-timeout',
-    errorMessage: message,
-    error: { message, code: 'cc-turn-timeout', retriable: true },
-    ok: false,
-  };
 }
 
 module.exports = {

package/engine/shared.js

@@ -2072,7 +2072,7 @@ const ENGINE_DEFAULTS = {
   removeWorktreeFailureTtlMs: 24 * 60 * 60 * 1000, // stale failed paths are forgotten after a day
   removeWorktreeFailureMaxEntries: 1000, // bound failed-worktree retry suppression cache
   ccMaxTurns: 50, // max tool-use turns per CC/doc-chat call before CLI stops (per response, not per session)
-  ccTurnTimeoutMs: 300000, // W-mpmwxni2000c25c7-b/-d: 5min per-turn watchdog. Wall-clock cap per CC/doc-chat turn; on expiry the in-flight LLM call is aborted and the handler surfaces `{code:'cc-turn-timeout', retryable:true}` via the typed error envelope so the UI can stop the spinner and offer Retry. Clamped to [10000, 3600000] in the settings POST handler. Independent of CC_CALL_TIMEOUT_MS (the outer hour-long abort) — this is the visible-to-user no-progress cap.
+  ccTurnTimeoutMs: 300000, // W-mpmwxni2000c25c7-b/-d: 5min per-turn no-progress watchdog. The window resets on every liveness signal — token chunk, tool-call notification, tool-update — so an actively-streaming CC/doc-chat turn (long shell command, deep search, sub-agent loop) survives indefinitely up to the outer CC_CALL_TIMEOUT_MS (~1h) ceiling. Only true silence past this window with no progress fires the cancel: the in-flight LLM call is aborted and the handler surfaces `{code:'cc-turn-timeout', retryable:true}` via the typed error envelope so the UI can stop the spinner and offer Retry. Clamped to [10000, 3600000] in the settings POST handler. Independent of CC_CALL_TIMEOUT_MS. Non-streaming doc-chat is the lone wall-clock exception (no progress hooks); see _raceCcDocChatTimeout in dashboard.js for the dual factory/promise shape.
   docSessionMaxEntries: 200, // cap doc-chat session map/disk store by least-recent activity (LRU; sessions are non-expiring otherwise)
   ccLiveStreamMaxAgeMs: 30 * 60 * 1000, // hard cap reconnect buffers if abort/cleanup stalls
   metricsFlushIntervalMs: 10000, // batch trackEngineUsage writes to metrics.json — flushed every 10s instead of per-call to cut lock contention and dashboard mtime churn
@@ -5202,6 +5202,14 @@ function getPrFixAutomationCause({ dispatchKey = '', source = '', task = '' } =
   return PR_FIX_CAUSE.UNKNOWN;
 }
 
+// Source-branch head SHA, normalized across hosts. GitHub PRs carry
+// `headSha`/`headRefOid` (engine/github.js:718-742 keeps both in sync); ADO PRs
+// carry `_adoSourceCommit`/`headRefOid` (engine/ado.js:1083-1129) and a legacy
+// `_adoHeadCommit`. Mirrors engine/lifecycle.js:1849 getPrFixBaselineHead.
+function _prHeadSha(pr) {
+  return String(pr?.headRefOid || pr?.headSha || pr?._adoSourceCommit || pr?._adoHeadCommit || '').trim();
+}
+
 function prFixEvidenceFingerprint(pr, cause = PR_FIX_CAUSE.UNKNOWN) {
   const review = pr?.minionsReview || {};
   const feedback = pr?.humanFeedback || {};
@@ -5214,6 +5222,13 @@ function prFixEvidenceFingerprint(pr, cause = PR_FIX_CAUSE.UNKNOWN) {
     evidence.buildFailReason = pr?.buildFailReason || '';
     evidence.buildErrorLog = pr?.buildErrorLog || '';
     evidence.buildStatusDetail = pr?._buildStatusDetail || '';
+    // #2979 — head SHA + lastPushedAt are the only fingerprint components that
+    // change across a rebase + force-push. Without them, a no-op-fix pause was
+    // sticky forever because failing pipeline name / fail reason / error log
+    // are unchanged across the push. Existing paused records re-fingerprint on
+    // the next poll and clear naturally when the head moves.
+    evidence.headRefOid = _prHeadSha(pr);
+    evidence.lastPushedAt = pr?.lastPushedAt || '';
   } else if (cause === PR_FIX_CAUSE.MERGE_CONFLICT) {
     evidence.mergeConflict = !!pr?._mergeConflict;
     evidence.mergeStatus = pr?.mergeStatus || '';
@@ -5223,6 +5238,13 @@ function prFixEvidenceFingerprint(pr, cause = PR_FIX_CAUSE.UNKNOWN) {
     evidence.lastReviewedAt = pr?.lastReviewedAt || '';
     evidence.reviewedAt = review.reviewedAt || '';
     evidence.reviewNote = review.note || pr?.reviewNote || '';
+    // #2979 — same rationale as BUILD_FAILURE: review feedback fingerprints
+    // were sticky across force-push because reviewStatus / reviewedAt /
+    // reviewNote don't change when the author rebases. Adding the head SHA
+    // gives REVIEW_FEEDBACK the same natural-unsticking property HUMAN_FEEDBACK
+    // already has via lastProcessedCommentDate.
+    evidence.headRefOid = _prHeadSha(pr);
+    evidence.lastPushedAt = pr?.lastPushedAt || '';
   }
   return crypto.createHash('sha1').update(JSON.stringify(evidence)).digest('hex').slice(0, 16);
 }

package/package.json

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