@nexrall/code-core 1.4.26 → 1.4.28

package/dist/agent/loop.d.ts

@@ -1,4 +1,47 @@
 import type { Message, AgentLoopOptions, EnvContext } from '../types';
+/**
+ * Fingerprint one round's tool failures, for the repeated-failure runaway guard.
+ *
+ * Exported (with the limits) purely as a test seam: the guard's whole value is in the
+ * edge cases — that a DIFFERENT error each round must NOT trip it, that call order
+ * within a round is irrelevant, that a long error body doesn't make every occurrence
+ * look unique — and none of that is reachable without driving a live model loop.
+ *
+ * Sorted so parallel tool calls completing in a different order still compare equal;
+ * truncated because errors often embed a varying path or timestamp late in the string.
+ */
+export declare function errorRoundSignature(errored: Array<{
+    name: string;
+    error: string;
+}>): string;
+/** Runaway-guard limits, exposed for tests. */
+export declare const _stallLimits: {
+    STALL_LIMIT: number;
+    REPEAT_STALL_LIMIT: number;
+};
+/**
+ * Why an agent run stopped.
+ *
+ * `'clean'` and `'aborted'` are the two silent-by-design outcomes: the model gave a
+ * final answer, or the user pressed Ctrl+C and already knows why it stopped.
+ * EVERYTHING else owes the user an explanation, which is what stopReasonNotice covers.
+ */
+export type StopReason = 'clean' | 'aborted' | 'reported-elsewhere' | 'empty-response' | 'no-balance' | 'stalled' | 'stalled-repeat' | 'budget' | 'unknown';
+/**
+ * The message shown when a run ends for any reason other than a clean finish.
+ *
+ * Pure and exported so every branch is testable: reaching some of these for real needs
+ * an empty wallet, a dead upstream, or hundreds of iterations. Returns null only for
+ * the two outcomes that are deliberately silent.
+ *
+ * `'unknown'` deliberately produces a message rather than nothing. If a future `break`
+ * forgets to set a reason, the symptom should be a visible "ended unexpectedly" line —
+ * annoying and reportable — not the silent stop that made this refactor necessary.
+ */
+export declare function stopReasonNotice(reason: StopReason, ctx?: {
+    budget?: number;
+    repeatError?: string | null;
+}): string | null;
 export declare function resolveMaxIterations(optionValue: number | undefined, settingsRaw: Record<string, unknown>): number;
 /**
  * Minimal concurrency gate. Hand-rolled rather than pulling in `p-limit` because
@@ -111,6 +154,15 @@ export interface ProgressLedger {
         tool: string;
         edits: number;
     }>;
+    /**
+     * DISTINCT paths ever touched, including any since evicted from `filesTouched`.
+     *
+     * The Map is bounded (see ledgerRecord), so `filesTouched.size` is a window, not a
+     * total. The preamble states "FILES CHANGED THIS SESSION (N)" as a fact the model
+     * reasons about, so N must not silently shrink when eviction kicks in on a very long
+     * run — that would tell the model less work happened than actually did.
+     */
+    filesTouchedTotal: number;
     verifications: Array<{
         cmd: string;
         ok: boolean;
@@ -121,6 +173,19 @@ export interface ProgressLedger {
         path: string;
         reason: string;
     }>;
+    /**
+     * TOTAL test-integrity findings ever recorded, including ones since trimmed.
+     *
+     * `testIntegrity` is a bounded window (older entries are spliced off once it grows
+     * past 2×LEDGER_MAX_NOTES), so its `.length` STOPS being a running total after the
+     * first trim. The one-shot nudge compares "how many findings exist" against "how
+     * many I've already surfaced", and comparing against a window that shrinks meant the
+     * count could never move ahead again — silently disabling the reward-hacking warning
+     * for the remainder of a long session, i.e. exactly when it matters most.
+     *
+     * This counter only ever increases, so it is a safe basis for that comparison.
+     */
+    testIntegrityTotal: number;
     /**
      * Monotonic mutation epoch: incremented on every successful source write. Two
      * verification runs sharing an epoch had NO edit between them, so a PASS↔FAIL

package/dist/agent/loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"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"}

package/dist/agent/loop.js

@@ -33,7 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERIFY_CMD_RE = exports.WRITE_TOOL_NAMES = exports.ToolNotAllowedError = void 0;
+exports.VERIFY_CMD_RE = exports.WRITE_TOOL_NAMES = exports.ToolNotAllowedError = exports._stallLimits = void 0;
+exports.errorRoundSignature = errorRoundSignature;
+exports.stopReasonNotice = stopReasonNotice;
 exports.resolveMaxIterations = resolveMaxIterations;
 exports.createLimiter = createLimiter;
 exports.extractSubTaskText = extractSubTaskText;
@@ -189,6 +191,74 @@ const DEFAULT_MAX_ITERATIONS = 500;
 const MAX_ITERATIONS_CEILING = 2000; // default auto-continue backstop (no explicit opt-in)
 const HARD_ITERATIONS_CAP = 100000; // absolute safety cap — even explicit opt-in can't exceed this
 const STALL_LIMIT = 8; // consecutive all-failed tool rounds → give up (runaway guard)
+// Consecutive rounds producing the IDENTICAL error(s) → give up, even if other calls in
+// those rounds succeeded. Higher than STALL_LIMIT because a repeat is weaker evidence of
+// being stuck than a total failure: legitimately retrying one failing command a few times
+// while making progress elsewhere is normal, twelve times is not.
+const REPEAT_STALL_LIMIT = 12;
+/**
+ * Fingerprint one round's tool failures, for the repeated-failure runaway guard.
+ *
+ * Exported (with the limits) purely as a test seam: the guard's whole value is in the
+ * edge cases — that a DIFFERENT error each round must NOT trip it, that call order
+ * within a round is irrelevant, that a long error body doesn't make every occurrence
+ * look unique — and none of that is reachable without driving a live model loop.
+ *
+ * Sorted so parallel tool calls completing in a different order still compare equal;
+ * truncated because errors often embed a varying path or timestamp late in the string.
+ */
+function errorRoundSignature(errored) {
+    return errored
+        .map(({ name, error }) => `${name}:${String(error).slice(0, 200)}`)
+        .sort()
+        .join('|');
+}
+/** Runaway-guard limits, exposed for tests. */
+exports._stallLimits = { STALL_LIMIT, REPEAT_STALL_LIMIT };
+/**
+ * The message shown when a run ends for any reason other than a clean finish.
+ *
+ * Pure and exported so every branch is testable: reaching some of these for real needs
+ * an empty wallet, a dead upstream, or hundreds of iterations. Returns null only for
+ * the two outcomes that are deliberately silent.
+ *
+ * `'unknown'` deliberately produces a message rather than nothing. If a future `break`
+ * forgets to set a reason, the symptom should be a visible "ended unexpectedly" line —
+ * annoying and reportable — not the silent stop that made this refactor necessary.
+ */
+function stopReasonNotice(reason, ctx = {}) {
+    switch (reason) {
+        case 'clean':
+        case 'aborted':
+        // A dedicated channel (e.g. the zero-balance bubble via onBalanceStatus) has already
+        // told the user why this stopped. Naming this case explicitly — rather than reusing
+        // 'aborted' — keeps "the user cancelled" from silently coming to mean two things.
+        case 'reported-elsewhere':
+            return null;
+        case 'empty-response':
+            return `\n\u26a0\ufe0f The model returned an empty response, so nothing was done. This is usually a transient ` +
+                `upstream hiccup \u2014 send "continue" to retry.\n`;
+        case 'no-balance':
+            return `\n\ud83d\udcb3 Stopped: your balance is empty, so the request was rejected before it started. ` +
+                `Top up and send "continue" \u2014 no tokens were used for this turn.\n`;
+        case 'stalled':
+            return `\n\ud83d\uded1 Stopped: the last ${STALL_LIMIT} tool rounds all failed, so the agent looked stuck. ` +
+                `Fix the underlying error (or grant the needed permission) and send "continue".\n`;
+        case 'stalled-repeat':
+            return `\n\ud83d\uded1 Stopped: the same tool error repeated ${REPEAT_STALL_LIMIT} rounds in a row, so the agent ` +
+                `was looping without making progress.` +
+                (ctx.repeatError ? ` The recurring error was:\n${ctx.repeatError}\n` : '\n') +
+                `Fix that underlying cause (or grant the needed permission) and send "continue".\n`;
+        case 'budget':
+            return `\n\u23f8\ufe0f Stopped at the ${ctx.budget}-step safety limit \u2014 the task may be incomplete. ` +
+                `Send "continue" to resume, or raise the limit via "maxIterations" in .nexrall/settings.json ` +
+                `(or the NEXRALL_MAX_ITERATIONS env var). Auto-continue can be disabled with "autoContinue": false.\n`;
+        case 'unknown':
+        default:
+            return `\n\u26a0\ufe0f The run ended unexpectedly without completing. Your work so far is preserved \u2014 ` +
+                `send "continue" to resume.\n`;
+    }
+}
 // Resolve the soft iteration budget. Precedence:
 //   options.maxIterations  →  env NEXRALL_MAX_ITERATIONS  →  settings.maxIterations  →  default
 //
@@ -830,6 +900,26 @@ function compactionThresholds() {
 // so we require at least this many bytes reclaimed before accepting a prune.
 const PRUNE_MIN_RECLAIM_BYTES = 256 * 1024; // 256 KB
 const COMPACT_KEEP_MIN = 6; // always keep at least the last N messages verbatim
+/**
+ * Bytes a compaction must reclaim to count as productive.
+ *
+ * Deliberately much smaller than PRUNE_MIN_RECLAIM_BYTES: a prune declines when the
+ * gain isn't worth busting the prompt cache, whereas by the time we are summarising
+ * we are already committed to rewriting the prefix — the only question is whether the
+ * summariser is making ANY headway. 32 KB is small enough that a genuinely useful
+ * compaction always clears it, large enough that shuffling a few bytes doesn't.
+ */
+const COMPACT_MIN_RECLAIM_BYTES = 32 * 1024; // 32 KB
+/**
+ * Consecutive non-productive compaction attempts before auto-compaction is switched
+ * off for the rest of the run.
+ *
+ * 3 rather than 1 because the failure is often transient — a summariser stream that
+ * blipped will usually succeed on the next turn, and giving up instantly would lose
+ * the safety net for a whole long session over one network hiccup. 3 also bounds the
+ * wasted spend: at most three summariser calls, not hundreds.
+ */
+const COMPACT_MAX_FAILURES = 3;
 // Byte-level safety net, independent of the token estimate.
 //
 // Tool-heavy sessions on large codebases accumulate many tool_result blocks
@@ -1013,7 +1103,7 @@ function transcriptOf(messages) {
 const LEDGER_MAX_FILES = 60; // cap the file list so the preamble can't balloon
 const LEDGER_MAX_NOTES = 20; // cap verification/among notes
 function createLedger() {
-    return { filesTouched: new Map(), verifications: [], testIntegrity: [], epoch: 0 };
+    return { filesTouched: new Map(), filesTouchedTotal: 0, verifications: [], testIntegrity: [], testIntegrityTotal: 0, epoch: 0 };
 }
 /** Record one tool call's effect on the ledger (deterministic, no model call). */
 function ledgerRecord(ledger, toolName, input, ok, output, exitCode) {
@@ -1026,7 +1116,32 @@ function ledgerRecord(ledger, toolName, input, ok, output, exitCode) {
         const p = typeof input?.path === 'string' ? input.path : undefined;
         if (p) {
             const prev = ledger.filesTouched.get(p);
+            if (!prev)
+                ledger.filesTouchedTotal++;
+            // DELETE before SET, so a re-touched path moves to the BACK of the insertion
+            // order. `Map.set` on an existing key keeps its ORIGINAL slot, which quietly
+            // broke the eviction policy below: a file edited hundreds of times over a long
+            // session kept the position of its FIRST edit, so it aged out like a file nobody
+            // had looked at since — and on the next edit it was re-inserted as "new", double-
+            // counting filesTouchedTotal (which is documented as DISTINCT paths). Making the
+            // Map a true LRU-by-touch is what lets the `key !== p` guard below mean anything.
+            ledger.filesTouched.delete(p);
             ledger.filesTouched.set(p, { tool: toolName, edits: (prev?.edits ?? 0) + 1 });
+            // Bound the Map itself, not just its rendering. LEDGER_MAX_FILES caps how many
+            // paths the preamble PRINTS (see ledgerSummary's slice), but the Map was only ever
+            // written to — so a multi-hour run touching thousands of files grew it without
+            // limit, and it is deliberately retained across every compaction. Evict the
+            // least-recently-touched entries once we hold well beyond what can ever be
+            // displayed. Hysteresis (evict down to 2× only once we exceed 4×) keeps this an
+            // occasional bulk sweep instead of a delete on every single write.
+            if (ledger.filesTouched.size > LEDGER_MAX_FILES * 4) {
+                for (const key of ledger.filesTouched.keys()) {
+                    if (ledger.filesTouched.size <= LEDGER_MAX_FILES * 2)
+                        break;
+                    if (key !== p)
+                        ledger.filesTouched.delete(key);
+                }
+            }
         }
         // Reward-hacking guard: if this write WEAKENED a test file, record it so the
         // signal survives compaction and can be surfaced before the agent finishes.
@@ -1046,6 +1161,7 @@ function ledgerRecord(ledger, toolName, input, ok, output, exitCode) {
         if (reasons.length && p) {
             for (const reason of reasons) {
                 ledger.testIntegrity.push({ path: p, reason });
+                ledger.testIntegrityTotal++;
             }
             if (ledger.testIntegrity.length > LEDGER_MAX_NOTES * 2) {
                 ledger.testIntegrity.splice(0, ledger.testIntegrity.length - LEDGER_MAX_NOTES);
@@ -1078,8 +1194,11 @@ function ledgerSummary(ledger) {
     const lines = [];
     if (ledger.filesTouched.size) {
         const files = [...ledger.filesTouched.entries()];
-        const shown = files.slice(0, LEDGER_MAX_FILES);
-        lines.push(`FILES CHANGED THIS SESSION (${ledger.filesTouched.size}):`);
+        // The TAIL, not the head: the Map is ordered least-recently-touched first, so
+        // slicing from the front showed the OLDEST files and reliably omitted the ones the
+        // agent was working on right now — the opposite of what this preamble is for.
+        const shown = files.slice(-LEDGER_MAX_FILES);
+        lines.push(`FILES CHANGED THIS SESSION (${ledger.filesTouchedTotal || ledger.filesTouched.size}):`);
         for (const [p, meta] of shown) {
             lines.push(`  • ${p}  (${meta.tool}${meta.edits > 1 ? ` ×${meta.edits}` : ''})`);
         }
@@ -1461,17 +1580,35 @@ async function runAgentLoop(initialMessages, options) {
     // condition where one sub-agent's chdir overwrites another's, making every tool
     // that falls back to process.cwd() resolve paths against the wrong directory.
     // workDir is now threaded explicitly through executeTool → resolvePath instead.
-    // Distinguish a clean finish (model produced a final answer) from hitting the
-    // iteration backstop, so we can tell the user what happened rather than
-    // silently returning a half-done task.
-    let completedCleanly = false;
+    // ─── Why did this run stop? ───────────────────────────────────────────────────
+    //
+    // The epilogue used to INFER the reason by re-testing state (`stalledOut`, then
+    // `iteration >= budget`). Inference only covers the cases someone thought to test,
+    // so any `break` that matched none of them fell through and the run ended in total
+    // silence — the worst possible outcome after an hour of work, because the user
+    // cannot tell "finished" from "died". Two such holes existed:
+    //
+    //   • the pre-flight 402 (wallet empty) broke out with no flag set at all, leaving
+    //     the optional onBalanceStatus callback as the ONLY signal;
+    //   • a thinking-only/empty model turn set completedCleanly = true, actively
+    //     claiming success for a turn that produced nothing.
+    //
+    // So the reason is now RECORDED at each exit instead of reconstructed after it.
+    // Anything that isn't an explicit clean finish or a user abort must name itself,
+    // and `default` in the switch below means a future `break` cannot go silent.
+    let stopReason = 'unknown';
     // Tool rounds actually completed in this call. Counted explicitly rather than derived
     // from `messages.length` because auto-compaction splices the history SHORTER mid-run:
     // a long session that compacted and then lost its connection would show a negative
     // length delta and be judged "no progress", discarding the work it most needs to keep.
     let completedRounds = 0;
-    let stalledOut = false; // tripped the runaway guard (all-failed rounds)
     let consecutiveErrorRounds = 0; // rounds where every tool call errored
+    // Repeated-identical-failure guard: see the runaway guards below. Tracked
+    // separately from consecutiveErrorRounds because a round can contain a succeeding
+    // call and still be part of a livelock.
+    let repeatedErrorRounds = 0;
+    let lastErrorSignature = '';
+    let stalledRepeatError = null;
     let budget = maxIterations; // extended by auto-continue, capped at hardCap
     let iteration = 0;
     // ─── Verification nudge (GAP D) ───────────────────────────────────────────────
@@ -1498,10 +1635,37 @@ async function runAgentLoop(initialMessages, options) {
     let claimEvidenceNudged = false;
     // GAP E — deterministic progress ledger, preserved verbatim across compactions.
     const ledger = createLedger();
+    // ─── Auto-compact circuit breaker ─────────────────────────────────────────────
+    //
+    // The in-loop compaction trigger below re-derives its pressure from the CURRENT
+    // body on every iteration. That is correct, but it means a compaction which does
+    // not shrink anything leaves the trigger condition still true — so the next
+    // iteration pays for another summariser call over the same (up to ~600KB)
+    // transcript, and so on for the rest of the run. Two ways that happens:
+    //
+    //   • autoCompactMessages returns false (summariser stream threw, or came back
+    //     empty). Nothing was replaced, so the pressure is unchanged.
+    //   • It returns true but cannot get under MAX_BODY_BYTES, because the messages
+    //     it must retain (COMPACT_KEEP_MIN) are themselves huge. `lastPromptTokens = 0`
+    //     suppresses only the TOKEN trigger; the BYTE trigger fires again immediately.
+    //
+    // Both are invisible to the user (the success notice only prints when `did`), so
+    // the symptom is a long run that silently gets slower and more expensive. Count
+    // consecutive non-productive attempts and stop trying after a few — losing
+    // compaction degrades gracefully (the turn may still fit, and the prune pass
+    // still runs), whereas an unbounded retry loop does not.
+    //
+    // The resume-time compactor already had exactly these guards
+    // (compactMessagesForResume: a bounded loop plus `if (!did) break`); this brings
+    // the in-loop path in line with it.
+    let compactFailures = 0;
+    let compactDisabled = false;
     try {
         for (; iteration < budget; iteration++) {
-            if (options.abortSignal?.aborted)
+            if (options.abortSignal?.aborted) {
+                stopReason = 'aborted';
                 break;
+            }
             // Auto-compact: keep the resent prompt small BEFORE the next stream so we
             // never hit the context-window wall — or the backend body-size limit — and,
             // just as importantly, so we stop paying cache-read on an ever-growing prefix
@@ -1546,10 +1710,17 @@ async function runAgentLoop(initialMessages, options) {
                     (options.onNotice ?? options.onText)(`\u267b\ufe0f Trimmed ~${(reclaimed / (1024 * 1024)).toFixed(1)}MB of already-processed tool output to keep this chat cheap to continue.`);
                 }
             }
-            if (autoCompact && !compacting && (tokenPressure || bytePressure) && messages.length > COMPACT_KEEP_MIN + 2) {
+            if (autoCompact && !compactDisabled && !compacting && (tokenPressure || bytePressure) && messages.length > COMPACT_KEEP_MIN + 2) {
                 compacting = true;
                 try {
+                    // Measured BEFORE, so "did it actually help?" is a fact about bytes rather
+                    // than a claim from the compactor. A compaction that returns true but
+                    // reclaims nothing is a failure for our purposes — it leaves the trigger
+                    // armed for the next iteration, which is precisely the runaway.
+                    const bytesBefore = estimateBodyBytes(messages);
                     const did = await autoCompactMessages(messages, options, ledger);
+                    const bytesAfter = did ? estimateBodyBytes(messages) : bytesBefore;
+                    const reclaimed = bytesBefore - bytesAfter;
                     if (did) {
                         lastPromptTokens = 0; // stale — next usage event refreshes it
                         const reason = bytePressure
@@ -1558,6 +1729,24 @@ async function runAgentLoop(initialMessages, options) {
                         // Same reasoning as above: this is a system notice about housekeeping,
                         // not part of the model's answer — keep it out of the text bubble.
                         (options.onNotice ?? options.onText)(`\u267b\ufe0f Auto-compacted earlier conversation to stay within the ${reason}.`);
+                        // Refresh local pressure so the rest of THIS iteration sees the new size.
+                        bodyBytes = bytesAfter;
+                        bytePressure = bodyBytes > MAX_BODY_BYTES;
+                    }
+                    // Productive == it shrank the body meaningfully. A successful-but-useless
+                    // compaction counts as a failure, otherwise the "cannot get under the byte
+                    // cap" case would never trip the breaker.
+                    if (did && reclaimed >= COMPACT_MIN_RECLAIM_BYTES) {
+                        compactFailures = 0;
+                    }
+                    else if (++compactFailures >= COMPACT_MAX_FAILURES) {
+                        compactDisabled = true;
+                        // Surfaced ONCE. The user needs to know the automatic safety net is off
+                        // (so a context-window error later isn't a total surprise) and what to do
+                        // about it, but repeating this every iteration would be its own spam.
+                        (options.onNotice ?? options.onText)(`\u26a0\ufe0f Auto-compaction isn't reducing this conversation any further, so it's been switched off ` +
+                            `for the rest of this run to avoid repeated summarising. If the context fills up, start a fresh ` +
+                            `chat or run /compact manually.`);
                     }
                 }
                 finally {
@@ -1672,8 +1861,10 @@ async function runAgentLoop(initialMessages, options) {
                 }, onEvent);
             }
             catch (err) {
-                if (options.abortSignal?.aborted || err.name === 'AbortError')
+                if (options.abortSignal?.aborted || err.name === 'AbortError') {
+                    stopReason = 'aborted';
                     break;
+                }
                 // Pre-flight 402 (routes/code.js — wallet already empty, the turn couldn't even
                 // start) is tagged with `status`/`balance` by client.ts. Surface it as the same
                 // low/zero-balance nudge a mid-turn 'balance_status' event would, instead of a
@@ -1681,7 +1872,16 @@ async function runAgentLoop(initialMessages, options) {
                 const status = err.status;
                 if (status === 402) {
                     const balance = err.balance ?? 0;
+                    // Prefer the rich, actionable UI (a persistent bubble with a link to Billing)
+                    // where the client implements it…
                     options.onBalanceStatus?.(balance, true);
+                    // …but do not DEPEND on it. The callback is optional, so a client without it
+                    // used to show the user absolutely nothing — the run simply stopped mid-task.
+                    //
+                    // Set the reason ONLY when there is no richer channel, so clients that do
+                    // render the bubble don't also get a redundant plain-text line saying the same
+                    // thing. Either way the user is told something, which is the actual guarantee.
+                    stopReason = options.onBalanceStatus ? 'reported-elsewhere' : 'no-balance';
                     break;
                 }
                 runSimpleHooks(hooks.OnError, options.workDir);
@@ -1694,8 +1894,10 @@ async function runAgentLoop(initialMessages, options) {
                 // assistant→tool_result pair here, so it is valid to resend as-is.
                 throw new types_1.AgentTurnError(`Stream failed: ${err.message}`, trimToResumableBoundary(messages), completedRounds, err);
             }
-            if (options.abortSignal?.aborted)
+            if (options.abortSignal?.aborted) {
+                stopReason = 'aborted';
                 break;
+            }
             // 2. Strip thinking blocks — API rejects them in message history
             assistantMessage.content = assistantMessage.content.filter((b) => b.type !== 'thinking' && b.type !== 'redacted_thinking');
             // If the model returned nothing usable (e.g. thinking-only, then stopped), the
@@ -1711,8 +1913,12 @@ async function runAgentLoop(initialMessages, options) {
                     messages.push({ role: 'user', content: [{ type: 'text', text }] });
                     continue;
                 }
+                // NOT a clean finish. This used to set completedCleanly = true, which told the
+                // caller the task succeeded when the model had in fact produced nothing at all
+                // — indistinguishable, to the user, from a finished job with no summary. An
+                // empty turn is a (usually transient) upstream failure, so name it and say so.
                 runSimpleHooks(hooks.PostMessageComplete, options.workDir);
-                completedCleanly = true;
+                stopReason = 'empty-response';
                 break;
             }
             // stopReason is transient, single-turn metadata for the truncated-tool-call guard
@@ -1772,9 +1978,19 @@ async function runAgentLoop(initialMessages, options) {
                 // and require the agent to either justify each change (legit refactor) or
                 // revert it and fix the real code. Deterministic — the signal comes from
                 // diff structure, not model self-report, so it can't be gamed away.
-                if (ledger.testIntegrity.length > testIntegrityNudgedCount) {
-                    const fresh = ledger.testIntegrity.slice(testIntegrityNudgedCount);
-                    testIntegrityNudgedCount = ledger.testIntegrity.length;
+                //
+                // Compared against testIntegrityTotal, NOT testIntegrity.length: the array is a
+                // bounded window that gets trimmed, so once a long session passed ~40 findings
+                // its length stopped growing and could even fall BELOW the already-nudged count,
+                // permanently wedging this condition false and disabling the guard for the rest
+                // of the run. The total only ever increases.
+                if (ledger.testIntegrityTotal > testIntegrityNudgedCount) {
+                    // How many are genuinely new, clamped to what the window still holds — the
+                    // trimmed-away ones are unrecoverable, and reporting the tail we DO have is
+                    // strictly better than reporting nothing.
+                    const newCount = Math.min(ledger.testIntegrityTotal - testIntegrityNudgedCount, ledger.testIntegrity.length);
+                    const fresh = ledger.testIntegrity.slice(ledger.testIntegrity.length - newCount);
+                    testIntegrityNudgedCount = ledger.testIntegrityTotal;
                     const bullet = fresh.map((t) => `  • ${t.path}: ${t.reason}`).join('\n');
                     messages.push({
                         role: 'user',
@@ -1850,7 +2066,7 @@ async function runAgentLoop(initialMessages, options) {
                     }
                 }
                 runSimpleHooks(hooks.PostMessageComplete, options.workDir);
-                completedCleanly = true;
+                stopReason = 'clean';
                 break;
             }
             // 5. Execute all tool uses in parallel
@@ -2073,14 +2289,44 @@ async function runAgentLoop(initialMessages, options) {
             // tool_result user turn). Let the caller checkpoint progress so a crash
             // mid-run loses only the in-flight step, not the whole session.
             options.onProgress?.(messages);
-            // Runaway guard: if every tool call in this round failed, count it. Enough
-            // consecutive all-failed rounds (e.g. a command that always errors, or the
-            // user denying every permission) means we're stuck — stop instead of
-            // burning the whole budget spinning.
-            const allErrored = toolResults.length > 0 && toolResults.every(({ result }) => result.error !== undefined);
+            // ── Runaway guards ────────────────────────────────────────────────────────
+            //
+            // TWO independent counters, because "stuck" has two shapes and the original
+            // all-failed test only caught the first.
+            //
+            //   1. TOTAL failure: every call in the round errored (a command that always
+            //      errors, the user denying every permission). Unambiguous.
+            //
+            //   2. REPEATED failure: the SAME error keeps coming back, round after round,
+            //      even though other calls in those rounds succeed. This is the livelock the
+            //      `.every()` test missed entirely — one trivially-succeeding sibling (say a
+            //      `read_file` alongside an `edit_file` that fails identically every time)
+            //      reset the counter to 0 forever, so a genuine loop burned the full
+            //      2000-iteration ceiling instead of stopping at 8. That is the expensive,
+            //      user-visible "it just spun for an hour" failure.
+            //
+            // Keyed on tool + error text so a DIFFERENT error each round (real progress
+            // through a chain of distinct problems) does not trip it.
+            const errored = toolResults.filter(({ result }) => result.error !== undefined);
+            const allErrored = toolResults.length > 0 && errored.length === toolResults.length;
             consecutiveErrorRounds = allErrored ? consecutiveErrorRounds + 1 : 0;
             if (consecutiveErrorRounds >= STALL_LIMIT) {
-                stalledOut = true;
+                stopReason = 'stalled';
+                break;
+            }
+            // Signature of this round's failures, order-independent and truncated so a long
+            // error body (or a path echoed inside it) doesn't make every occurrence unique.
+            const errSignature = errorRoundSignature(errored.map(({ block, result }) => ({ name: block.name, error: String(result.error) })));
+            if (errSignature && errSignature === lastErrorSignature) {
+                repeatedErrorRounds++;
+            }
+            else {
+                repeatedErrorRounds = 0;
+                lastErrorSignature = errSignature;
+            }
+            if (repeatedErrorRounds >= REPEAT_STALL_LIMIT) {
+                stopReason = 'stalled-repeat';
+                stalledRepeatError = errored[0] ? String(errored[0].result.error).slice(0, 300) : null;
                 break;
             }
             // Auto-continue: about to exhaust the current budget but the model is still
@@ -2094,20 +2340,23 @@ async function runAgentLoop(initialMessages, options) {
             }
             // Loop back to step 1
         }
-        // Explain why we stopped when it wasn't a clean finish or a user abort, so a
-        // long run never just goes silent. History ends on a tool_result turn, so
-        // "continue" resumes exactly where it left off.
-        if (!options.abortSignal?.aborted && !completedCleanly) {
-            if (stalledOut) {
-                options.onText(`\n🛑 Stopped: the last ${STALL_LIMIT} tool rounds all failed, so the agent looked stuck. ` +
-                    `Fix the underlying error (or grant the needed permission) and send "continue".\n`);
-            }
-            else if (iteration >= budget) {
-                options.onText(`\n⏸️ Stopped at the ${budget}-step safety limit — the task may be incomplete. ` +
-                    `Send "continue" to resume, or raise the limit via "maxIterations" in .nexrall/settings.json ` +
-                    `(or the NEXRALL_MAX_ITERATIONS env var). Auto-continue can be disabled with "autoContinue": false.\n`);
-            }
-        }
+        // Explain why we stopped, so a long run never just goes silent. History ends on a
+        // tool_result turn, so "continue" resumes exactly where it left off.
+        //
+        // The budget case is resolved HERE rather than at a break: exhausting the `for`
+        // condition is a normal loop exit, not a branch we can annotate. Everything else
+        // named itself on the way out, and 'unknown' is the loud fallback for a break that
+        // forgot to.
+        if (stopReason === 'unknown' && iteration >= budget)
+            stopReason = 'budget';
+        if (options.abortSignal?.aborted)
+            stopReason = 'aborted';
+        // Routed through onNotice (falling back to onText) like every other housekeeping
+        // message in this file — these are statements from the harness, not from the model,
+        // and splicing them into the assistant's own bubble reads as if it said them.
+        const notice = stopReasonNotice(stopReason, { budget, repeatError: stalledRepeatError });
+        if (notice)
+            (options.onNotice ?? options.onText)(notice);
     }
     catch (err) {
         // Every other failure path (a tool executor blowing up, a hook throwing, an

package/dist/api/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAA8B,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAiErH,eAAO,MAAM,QAAQ,QAAmB,CAAC;AAIzC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5D,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GACtD,CAAC,EAAE,CAeL;AAiGD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IACnC,oFAAoF;IACpF,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACjG,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6IAA6I;IAC7I,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAiDD,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAI,GAC7B,OAAO,CAAC,OAAO,CAAC,CA6jClB;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU9D;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAYxD;AAID,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CA0BlD;AAID,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA+B1E;AAID,wBAAsB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA0BhF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAA8B,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAiErH,eAAO,MAAM,QAAQ,QAAmB,CAAC;AAIzC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5D,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GACtD,CAAC,EAAE,CAeL;AAiGD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IACnC,oFAAoF;IACpF,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACjG,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6IAA6I;IAC7I,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAiDD,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAI,GAC7B,OAAO,CAAC,OAAO,CAAC,CAwlClB;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU9D;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAYxD;AAID,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CA0BlD;AAID,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA+B1E;AAID,wBAAsB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA0BhF"}