agent-nuvira 3.5.0 → 3.5.1

package/dist/learning/retry-patience.js

@@ -0,0 +1,169 @@
+/**
+ * Blip patience — how long to STAY on the pair that just failed, and whether
+ * walking away is even a remedy.
+ *
+ * THE OBSERVED PROBLEM THIS ENCODES. A cloud provider does not go down for a
+ * turn: it returns 200, then a few empty/5xx responses for a handful of seconds,
+ * then serves normally again (measured repeatedly on `deepseek`). Two opposite
+ * mistakes are available, and the codebase has made both:
+ *
+ *   - FAIL FAST: give up after seconds and fold onto the next candidate — which
+ *     for that blip means silently dropping from a strong model to a weak one.
+ *     The result is answered, badly, by a model the user did not choose.
+ *   - WAIT BLINDLY: sit out a long fixed backoff on a pair that is actually
+ *     dead, and make every user of a broken provider pay for it.
+ *
+ * A timeout cannot tell those apart, so a fixed schedule is the wrong shape
+ * either way. What CAN tell them apart is the evidence already in hand:
+ *
+ *   1. THE ALTERNATIVES. Walking away is only a remedy when it does not cost
+ *      quality. If every alternative sits in a LOWER capability band, then
+ *      "fail over" means "de-escalate", and for a blip that is the worse trade —
+ *      so we wait instead. If a same-or-better band is reachable, failing over is
+ *      free and waiting is pure waste.
+ *   2. THE PAIR'S TRACK RECORD. A pair that has served real traffic with a low
+ *      error rate earns patience; a never-proven id does not.
+ *   3. THE SHAPE OF THE FAILURE. One failing step is a blip. The SAME pair
+ *      failing two steps in a row is not — patience collapses there, whatever
+ *      the alternatives look like.
+ *
+ * And the schedule's SHAPE matters as much as its total: a 2-second blink is
+ * caught by a retry at t≈1s, not at t=5s, so the early delays are dense and the
+ * late ones sparse ({@link TRANSIENT_BLIP_DELAYS_MS} → attempts at ≈1, 3, 7, 15,
+ * 30, 60s). That rides out both a blink and a real minute-long spike.
+ *
+ * PURE AND DETERMINISTIC. This module reads no clock, no registry and no config:
+ * the caller gathers the evidence (it has the registry and the ranked pool) and
+ * gets back a plan it can log. That is what makes the policy reviewable and
+ * testable one row at a time — see the table in the tests.
+ */
+import { bandRank, capabilityClassOf } from './model-capability.js';
+/**
+ * Transient (server/network/timeout) backoff, dense early and sparse late:
+ * attempts at ≈1s, 3s, 7s, 15s, 30s, 60s. Used exactly when WAITING beats
+ * walking away — no alternative, or only degrading ones.
+ */
+export const TRANSIENT_BLIP_DELAYS_MS = [1_000, 2_000, 4_000, 8_000, 15_000, 30_000];
+/**
+ * Transient backoff when a same-or-better-band candidate IS reachable: a short
+ * courtesy retry (two blinks' worth, <2s) and then the walk. Spending longer is
+ * waste — the replacement costs nothing in quality.
+ */
+export const TRANSIENT_FREE_ALTERNATIVE_DELAYS_MS = [500, 1_500];
+/**
+ * Transient backoff for a pair we have no reason to trust and no alternative to:
+ * a token wait (≈5s), then the honest failure.
+ */
+export const TRANSIENT_LAST_RESORT_DELAYS_MS = [1_000, 4_000];
+/** Empty-response patience for a proven pair — the "final verse" case. */
+export const EMPTY_PATIENCE_MS = [2_000, 5_000];
+/**
+ * Empty-response patience when EVERY alternative would de-escalate. Longer, and
+ * deliberately so: this is the one situation where the choice is literally
+ * "wait a few more seconds" vs "answer with a weaker model".
+ */
+export const EMPTY_PATIENCE_WAIT_BEATS_FOLDING_MS = [2_000, 5_000, 10_000];
+/**
+ * Error rate at or below which a verified pair counts as a proven track record.
+ * Above it the pair has failed roughly 1 call in 5, which is not something a
+ * blip explains away.
+ */
+export const PROVEN_ERROR_RATE_MAX = 0.2;
+/** Is the registry evidence strong enough to grant a pair extra patience? */
+function hasProvenTrackRecord(evidence) {
+    if (!evidence?.verified)
+        return false;
+    if ((evidence.errorRate ?? 0) > PROVEN_ERROR_RATE_MAX)
+        return false;
+    // A `probe` (catalog listing) is not evidence about answers; `telemetry` and
+    // `spot-check` are.
+    return evidence.source !== 'probe';
+}
+/**
+ * Decide how patient to be with the pair that just failed, and say why.
+ *
+ * The whole policy, in order (see the tests for each row):
+ *
+ *   1. The pair already failed an earlier step of this turn → NOT a blip. One
+ *      token wait, no empty patience.
+ *   2. Nothing to gain by patience: a same-or-better band is reachable → short
+ *      transient retry; empty patched only for a proven pair (a good pair's
+ *      first blink is still worth two short waits).
+ *   3. A PROVEN pair facing only degrading alternatives (or none) → long, dense
+ *      transient patience, and extended empty patience. This is the row that
+ *      stops a blinking strong model from being replaced by a weak one.
+ *   4. An UNPROVEN pair with nowhere better to go → a token wait; the walk (or
+ *      the honest failure) is the remedy, not optimism about a stranger.
+ */
+export function planBlipPatience(input) {
+    const currentBand = capabilityClassOf(input.current.model);
+    const currentRank = bandRank(currentBand);
+    let bestRank = -1;
+    let bestAlternativeBand;
+    for (const alternative of input.alternatives) {
+        if (!alternative?.model)
+            continue;
+        const band = capabilityClassOf(alternative.model);
+        const rank = bandRank(band);
+        if (rank > bestRank) {
+            bestRank = rank;
+            bestAlternativeBand = band;
+        }
+    }
+    const hasAlternative = bestRank >= 0;
+    const sameOrBetterReachable = bestRank >= currentRank;
+    const foldingWouldDegrade = hasAlternative && !sameOrBetterReachable;
+    const proven = hasProvenTrackRecord(input.evidence) || input.deliveredWorkThisTurn === true;
+    // 1. Two failing steps in a row is a pattern, not a blip.
+    if (input.failedEarlierStep) {
+        return {
+            transientDelaysMs: TRANSIENT_LAST_RESORT_DELAYS_MS,
+            emptyResponseDelaysMs: [],
+            bestAlternativeBand,
+            foldingWouldDegrade: false,
+            reason: `${input.current.provider}/${input.current.model} failed an earlier step too — not a blip, so no patience`,
+        };
+    }
+    // 2. A same-or-better candidate is reachable: failing over costs no quality.
+    if (sameOrBetterReachable) {
+        return {
+            transientDelaysMs: TRANSIENT_FREE_ALTERNATIVE_DELAYS_MS,
+            emptyResponseDelaysMs: proven ? EMPTY_PATIENCE_MS : [],
+            bestAlternativeBand,
+            foldingWouldDegrade: false,
+            reason: `a ${bestAlternativeBand}-band candidate is reachable — failing over costs no quality`,
+        };
+    }
+    // 3. Waiting beats folding down a band.
+    if (foldingWouldDegrade && proven) {
+        return {
+            transientDelaysMs: TRANSIENT_BLIP_DELAYS_MS,
+            emptyResponseDelaysMs: EMPTY_PATIENCE_WAIT_BEATS_FOLDING_MS,
+            bestAlternativeBand,
+            foldingWouldDegrade: true,
+            reason: `waiting on ${input.current.provider}/${input.current.model} (${currentBand}) rather than ` +
+                `de-escalating to ${bestAlternativeBand} — a blip is not a reason to downgrade`,
+        };
+    }
+    // 3b. Nowhere else to go, but the pair has a track record: waiting is the only remedy.
+    if (!hasAlternative && proven) {
+        return {
+            transientDelaysMs: TRANSIENT_BLIP_DELAYS_MS,
+            emptyResponseDelaysMs: EMPTY_PATIENCE_WAIT_BEATS_FOLDING_MS,
+            bestAlternativeBand,
+            foldingWouldDegrade: false,
+            reason: `no alternative is configured — waiting on ${input.current.provider}/${input.current.model} is the only remedy`,
+        };
+    }
+    // 4. Unproven pair: a token wait, then the walk or the honest failure.
+    return {
+        transientDelaysMs: TRANSIENT_LAST_RESORT_DELAYS_MS,
+        emptyResponseDelaysMs: hasAlternative ? [] : EMPTY_PATIENCE_MS,
+        bestAlternativeBand,
+        foldingWouldDegrade,
+        reason: hasAlternative
+            ? `${input.current.provider}/${input.current.model} has no track record — the walk is the remedy`
+            : `nothing is proven for ${input.current.provider}/${input.current.model} and there is no alternative`,
+    };
+}
+//# sourceMappingURL=retry-patience.js.map

package/dist/learning/retry-patience.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-patience.js","sourceRoot":"","sources":["../../src/learning/retry-patience.ts"],"names":[],"mappings":"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"}

package/dist/tools/tool-loop.d.ts

@@ -1086,9 +1086,18 @@ export declare const DEFAULT_THREAD_BUDGET_CHARS = 200000;
 /**
  * Deterministically trim a thread to `maxChars`:
  * 1. Never touch the system prompt or the FIRST user message (the ask).
- * 2. Never touch the last `RECENT_KEEP` messages (recent context).
- * 3. Oldest-first: tool results longer than 500 chars collapse to the stub;
- *    if still over budget, remaining old tool results collapse entirely.
+ * 2. Never touch the last `RECENT_KEEP` messages (recent context) — except for
+ *    the tail clamps in steps 4–5, which run ONLY when the oldest-first passes
+ *    could not pay for the overage.
+ * 3. Oldest-first pays FIRST, and only as much as the deficit needs: tool
+ *    results longer than 500 chars collapse to the stub; if still over budget,
+ *    remaining old tool results collapse entirely; then oversized old user
+ *    messages shrink.
+ * 4. Only if the thread is STILL over does the protected tail pay: an oversized
+ *    recent tool result is clamped to head + rescued error lines + tail, and
+ *    then clamped harder, so the prompt actually fits the window it goes to.
+ *    The ORDER is what protects delivery: recent context is the model's working
+ *    memory, so it is spent only when nothing older can cover the overage.
  * Returns a NEW array (input untouched) + how many messages were trimmed.
  */
 export declare function trimThreadBudget(thread: ToolMessage[], maxChars?: number): {
@@ -1106,6 +1115,35 @@ export declare function buildWorkDigest(input: {
     mutatedPaths: readonly string[];
     executedActions: readonly ExecutedAction[];
 }): string;
+/** Marker prefix identifying the loop's mid-turn HANDOFF note. */
+export declare const HANDOFF_NOTE_MARKER = "[handoff \u2014 the model serving this turn changed]";
+/**
+ * The note a mid-turn model switch leaves in the thread.
+ *
+ * It says three things the TRANSCRIPT cannot say by itself: that the pair
+ * answering this step is not the pair that answered the previous ones, that the
+ * context above is genuinely this model's to use (nothing was restarted), and
+ * which work is already DONE (files changed, commands and their verdicts) — so
+ * the replacement continues instead of re-deriving a plan from the ask. It also
+ * states the rule that costs real steps when broken: do not re-run finished
+ * commands or restate the work in more words.
+ *
+ * Deterministic and LLM-free, like the digest it borrows its facts from — a
+ * handoff must not spend a model call to describe itself.
+ */
+export declare function buildHandoffNote(input: {
+    route?: string;
+    facts?: string;
+}): string;
+/**
+ * Insert or refresh the single handoff note. Idempotent — a turn may hand off
+ * more than once (a second pair can also answer with nothing), and stacking a
+ * note per handoff would fill the thread with the same information. Kept with
+ * the run's framing (right after the leading system prompt) so it is a `system`
+ * message: the thread-budget passes never trim one, and it therefore survives
+ * every compaction between the handoff and the answer.
+ */
+export declare function upsertHandoffNote(thread: ToolMessage[], note: string): void;
 /**
  * Insert or refresh the single work-digest message. Idempotent: a digest already
  * in the thread is UPDATED in place, never stacked, so repeated compaction in a

package/dist/tools/tool-loop.d.ts.map

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

package/dist/tools/tool-loop.js

@@ -1056,7 +1056,7 @@ async function runToolLoopInner(opts, progress) {
                     if (digest)
                         upsertWorkDigest(thread, digest);
                 }
-                deps.onEvent?.(`   ✂️ ${trimmedResult.trimmed} old tool result(s) trimmed to fit the ${Math.round(budgetChars / 1000)}K-char context budget.`);
+                deps.onEvent?.(`   ✂️ ${trimmedResult.trimmed} message(s) trimmed to fit the ${Math.round(budgetChars / 1000)}K-char context budget.`);
             }
         }
         // ── The route feed, re-synced before every call ────────────────────────
@@ -1288,6 +1288,43 @@ async function runToolLoopInner(opts, progress) {
                     }
                     if (switched) {
                         modelHandoffs += 1;
+                        // ── CONTEXT HANDOFF NOTE (Proposal 2, reassessed) ─────────────
+                        //
+                        // The CONTEXT already travels: one `thread` is kept across the
+                        // switch, so the replacement receives the ask, every tool call and
+                        // every result. What deliberately does NOT travel is the previous
+                        // model's `reasoningContent` (replaying a stranger's chain-of-
+                        // thought is either rejected outright or anchors the new model to
+                        // the failed reading of the task) — that stays dropped.
+                        //
+                        // What was missing is the plain STATEMENT of the handoff: a model
+                        // that starts mid-thread with no note reads the transcript as its
+                        // own and re-plans from the ask, re-running finished commands and
+                        // re-reading files whose results are already in front of it. The
+                        // note names the change, tells it the context is its own, and hands
+                        // it the facts (files changed, commands with their verdicts) so it
+                        // continues instead of restarting.
+                        let servedNow;
+                        try {
+                            const route = opts.servedRoute?.();
+                            if (route?.model && !isUnresolvedModel(route.model)) {
+                                servedNow = `${route.providerType}/${route.model}`;
+                            }
+                        }
+                        catch {
+                            // An unknown route is fine — the note reads generically then.
+                        }
+                        upsertHandoffNote(thread, buildHandoffNote({
+                            route: servedNow,
+                            facts: isWorkDigestEnabled(context.configManager)
+                                ? buildWorkDigest({
+                                    successfulTools: progress.successfulToolCalls,
+                                    mutatedPaths: progress.mutatedPaths,
+                                    executedActions: progress.executedActions,
+                                })
+                                : '',
+                        }));
+                        deps.onEvent?.('   🤝 handoff note written into the thread — the replacement model starts from the work already done.');
                         // ── C5 — RE-FIT THE THREAD TO THE MODEL THAT NOW ANSWERS ──────
                         // `budgetChars` was resolved before this loop started, from the pair
                         // the turn BEGAN on — and the handoff worth catching is the one to a
@@ -3771,16 +3808,127 @@ export const DEFAULT_THREAD_BUDGET_CHARS = 200_000;
 const RECENT_KEEP = 6;
 /** Stub left in place of a trimmed tool result. */
 const TRIM_STUB = '[earlier tool result trimmed to fit the context budget]';
+/**
+ * Floor for the per-message tool-result clamp (the tail clamp). A single tool
+ * result may never exceed half the thread budget, so one oversized output cannot
+ * dominate the prompt; this floor keeps the clamp sane for a tiny budget.
+ */
+const MIN_TOOL_RESULT_CHARS = 8_000;
+/**
+ * Bounded scan window for the clamp's error-line rescue. An elided middle can be
+ * megabytes, and scanning all of it would cost more CPU than the prompt costs
+ * tokens, so only the EDGES of the middle are searched. Nothing here is
+ * unrecoverable: a clipped result is re-runnable (`run_terminal` again) or
+ * re-readable (`read_file` with offset/limit), which the notice says out loud.
+ */
+const CLAMP_SCAN_CHARS = 250_000;
+/** Cap on rescued error-looking lines, and on the chars they may add back. */
+const CLAMP_ERROR_LINES = 12;
+const CLAMP_ERROR_CHARS = 2_000;
+/**
+ * A line that looks like the REASON something failed. Deliberately broad: one
+ * extra line costs a few tokens, while dropping the only line that says WHY the
+ * build broke costs a wrong fix built on a log the model never saw.
+ */
+const ERROR_LINE_RE = /\b(?:error|errors|fail|failed|failing|failure|exception|panic|fatal|traceback|assert|assertion|expected|received|refused|denied|unhandled|cannot|unable|timeout|enoent|econnrefused)\b|\btimed out\b|\bexit(?:ed)?(?: with)?(?: code)? [1-9]\d*\b|[✗✘✕]/i;
+/** `5234567` → `5,234,567` (deterministic grouping — no locale/ICU dependence). */
+function withThousands(n) {
+    return String(Math.max(0, Math.trunc(n))).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
 /** Estimated character size of one thread message (chars/4 ≈ tokens). */
 function messageChars(m) {
     return (m.content?.length ?? 0) + (m.toolCalls?.length ? JSON.stringify(m.toolCalls).length : 0);
 }
+/**
+ * Rescue the error-looking lines from the MIDDLE of a result that is about to be
+ * clamped away. The clamp keeps head + tail, and a tool's verdict usually lands
+ * in the tail — but the REASON for a failure (an assertion, a stack frame, `exit
+ * code 1`) can sit in the middle, and a model that never sees it fixes the wrong
+ * thing. Deterministic: a line filter, no LLM, no summary, no drift.
+ */
+function errorLinesFrom(middle) {
+    const regions = middle.length <= CLAMP_SCAN_CHARS * 2
+        ? [middle]
+        : [middle.slice(0, CLAMP_SCAN_CHARS), middle.slice(-CLAMP_SCAN_CHARS)];
+    const out = [];
+    let used = 0;
+    for (const region of regions) {
+        for (const raw of region.split('\n')) {
+            const line = raw.trim();
+            if (!line)
+                continue;
+            // NO length filter. A tool's output rarely ends on a newline, so the tail
+            // cut lands MID-LINE and fuses the last real line with the kept tail —
+            // MEASURED: a 38-char `AssertionError: 2 !== 3 (received 3)` arrived here
+            // as 1,036 chars, and a `> 1000` skip dropped it, i.e. the rescue silently
+            // lost exactly the line it exists to save. Long lines are kept by their
+            // first 200 chars instead (an error keyword in a minified blob is still
+            // the start of the reason).
+            if (!ERROR_LINE_RE.test(line))
+                continue;
+            const kept = line.slice(0, 200);
+            if (out.includes(kept))
+                continue;
+            if (used + kept.length > CLAMP_ERROR_CHARS)
+                return out;
+            out.push(kept);
+            used += kept.length;
+            if (out.length >= CLAMP_ERROR_LINES)
+                return out;
+        }
+    }
+    return out;
+}
+/**
+ * The notice a clamp leaves behind: it names the tool, counts the elided
+ * characters and says how to get them back. A model handed a SILENTLY partial
+ * result cannot tell whether anything is missing; one handed a QUANTIFIED cut
+ * can re-run the command or re-read the file — far cheaper than a fix built on a
+ * log it never saw.
+ */
+function clampNotice(tool, elided, errorLines) {
+    const who = tool ? `${tool}: ` : '';
+    const rescued = errorLines.length > 0 ? '; the error-looking lines from the elided middle are kept below' : '';
+    return (`\n[tool result trimmed to fit the context budget — ${who}${withThousands(elided)} chars elided ` +
+        `from the middle${rescued}. The beginning and the end are kept verbatim; re-run the command, or ` +
+        `read the file again with offset/limit, to see the rest.]\n` +
+        (errorLines.length > 0 ? `${errorLines.join('\n')}\n` : ''));
+}
+/**
+ * Clamp one oversized tool result to `cap` chars, keeping its HEAD and TAIL so
+ * the model still sees which tool ran and how its output ended, plus any
+ * error-looking lines from the elided middle. Deterministic — no summary, no
+ * model call. The result never exceeds `cap`: the head absorbs what the notice
+ * and the rescued lines do not use.
+ */
+function clampToolResult(content, cap, tool) {
+    if (content.length <= cap)
+        return content;
+    const tailLen = Math.min(1_000, Math.floor(cap / 4));
+    const tailStart = Math.max(0, content.length - tailLen);
+    const middle = content.slice(0, tailStart);
+    const errors = errorLinesFrom(middle);
+    // Sized with the LARGEST possible elided count, so the exact (smaller) notice
+    // that follows can never push the result past `cap`.
+    const headLen = Math.max(0, cap - tailLen - clampNotice(tool, middle.length, errors).length);
+    const head = content.slice(0, headLen);
+    return head + clampNotice(tool, Math.max(0, middle.length - headLen), errors) + content.slice(tailStart);
+}
 /**
  * Deterministically trim a thread to `maxChars`:
  * 1. Never touch the system prompt or the FIRST user message (the ask).
- * 2. Never touch the last `RECENT_KEEP` messages (recent context).
- * 3. Oldest-first: tool results longer than 500 chars collapse to the stub;
- *    if still over budget, remaining old tool results collapse entirely.
+ * 2. Never touch the last `RECENT_KEEP` messages (recent context) — except for
+ *    the tail clamps in steps 4–5, which run ONLY when the oldest-first passes
+ *    could not pay for the overage.
+ * 3. Oldest-first pays FIRST, and only as much as the deficit needs: tool
+ *    results longer than 500 chars collapse to the stub; if still over budget,
+ *    remaining old tool results collapse entirely; then oversized old user
+ *    messages shrink.
+ * 4. Only if the thread is STILL over does the protected tail pay: an oversized
+ *    recent tool result is clamped to head + rescued error lines + tail, and
+ *    then clamped harder, so the prompt actually fits the window it goes to.
+ *    The ORDER is what protects delivery: recent context is the model's working
+ *    memory, so it is spent only when nothing older can cover the overage.
  * Returns a NEW array (input untouched) + how many messages were trimmed.
  */
 export function trimThreadBudget(thread, maxChars = DEFAULT_THREAD_BUDGET_CHARS) {
@@ -3801,6 +3949,9 @@ export function trimThreadBudget(thread, maxChars = DEFAULT_THREAD_BUDGET_CHARS)
     }
     let over = total - maxChars;
     let trimmed = 0;
+    // A single result may never exceed half the budget, whatever the passes below
+    // do (see MIN_TOOL_RESULT_CHARS).
+    const perMessageCap = Math.max(MIN_TOOL_RESULT_CHARS, Math.floor(maxChars / 2));
     // Pass 1: collapse long OLD tool results to the stub (keep the first 500
     // chars so the model retains the gist of what it did).
     for (const i of eligible) {
@@ -3848,6 +3999,66 @@ export function trimThreadBudget(thread, maxChars = DEFAULT_THREAD_BUDGET_CHARS)
             trimmed++;
         }
     }
+    // ── Pass 4 — only NOW does the PROTECTED TAIL pay ─────────────────────────
+    // Nothing older could cover the deficit, so an oversized RECENT tool result
+    // must be clamped — otherwise the prompt goes out verbatim and either the
+    // provider rejects it or the model silently loses its middle.
+    //
+    // MEASURED (trace-1791879575576-x731yp): step 4 ran a 24s test command; its
+    // result landed in the tail, the oldest-first passes could not reach it, and
+    // step 5 — handed to `local/qwen2.5:0.5b` (32K window) — recorded 5,292,237
+    // context chars (~1.18M tokens), carried into the dashboard and cost ledger
+    // as REAL input. Running this pass here (rather than before the oldest-first
+    // passes) is deliberate: recent context is the model's working memory, so it
+    // is spent only when older output cannot pay for the overage.
+    // A tool message carries only the call ID, so the notice's tool name comes
+    // from the assistant message that made the call. Built lazily: a turn whose
+    // thread fits never walks the thread for names it will not print.
+    const toolNameById = new Map();
+    const toolNameOf = (m) => {
+        if (!m.toolCallId)
+            return undefined;
+        if (toolNameById.size === 0) {
+            for (const t of thread) {
+                for (const call of t.toolCalls ?? []) {
+                    if (call?.id)
+                        toolNameById.set(call.id, call.name);
+                }
+            }
+        }
+        return toolNameById.get(m.toolCallId);
+    };
+    if (over > 0) {
+        for (let i = Math.max(0, out.length - RECENT_KEEP); i < out.length && over > 0; i++) {
+            const m = out[i];
+            if (m.role !== 'tool' || m.content.length <= perMessageCap)
+                continue;
+            const clamped = clampToolResult(m.content, perMessageCap, toolNameOf(m));
+            if (clamped.length >= m.content.length)
+                continue;
+            out[i] = { ...m, content: clamped };
+            over -= m.content.length - clamped.length;
+            trimmed++;
+        }
+    }
+    // Pass 5: STILL over — the protected tail holds the bulk even after the clamp
+    // above; clamp its tool results harder rather than ship a prompt the model's
+    // window cannot hold. Only TOOL results in the tail are touched — the user's
+    // ask and the latest assistant turn stay.
+    if (over > 0) {
+        const tailFloor = Math.max(500, Math.floor(perMessageCap / 4));
+        for (let i = Math.max(0, out.length - RECENT_KEEP); i < out.length && over > 0; i++) {
+            const m = out[i];
+            if (m.role !== 'tool')
+                continue;
+            const clamped = clampToolResult(m.content, tailFloor, toolNameOf(m));
+            if (clamped.length >= m.content.length)
+                continue;
+            out[i] = { ...m, content: clamped };
+            over -= m.content.length - clamped.length;
+            trimmed++;
+        }
+    }
     return { thread: out, trimmed };
 }
 // ─── Within-turn work digest (the memory a trimmed thread keeps) ────────────
@@ -3895,6 +4106,51 @@ export function buildWorkDigest(input) {
         return '';
     return `${WORK_DIGEST_MARKER}\n${lines.join('\n')}`;
 }
+/** Marker prefix identifying the loop's mid-turn HANDOFF note. */
+export const HANDOFF_NOTE_MARKER = '[handoff — the model serving this turn changed]';
+/**
+ * The note a mid-turn model switch leaves in the thread.
+ *
+ * It says three things the TRANSCRIPT cannot say by itself: that the pair
+ * answering this step is not the pair that answered the previous ones, that the
+ * context above is genuinely this model's to use (nothing was restarted), and
+ * which work is already DONE (files changed, commands and their verdicts) — so
+ * the replacement continues instead of re-deriving a plan from the ask. It also
+ * states the rule that costs real steps when broken: do not re-run finished
+ * commands or restate the work in more words.
+ *
+ * Deterministic and LLM-free, like the digest it borrows its facts from — a
+ * handoff must not spend a model call to describe itself.
+ */
+export function buildHandoffNote(input) {
+    const served = input.route
+        ? ` This step is served by ${input.route}.`
+        : ' This step is served by a different model.';
+    const facts = (input.facts ?? '').trim();
+    return (`${HANDOFF_NOTE_MARKER}${served}\n` +
+        'The pair that had been answering returned nothing usable, so the turn was handed to you mid-flight —\n' +
+        'everything above is YOUR context: the ask, every tool call and every result. Nothing was restarted.\n' +
+        (facts ? `${facts}\n` : '') +
+        'Continue from the work that is already done. Do not re-run finished commands, re-read files whose results\n' +
+        'are above, or restate the work in more words.');
+}
+/**
+ * Insert or refresh the single handoff note. Idempotent — a turn may hand off
+ * more than once (a second pair can also answer with nothing), and stacking a
+ * note per handoff would fill the thread with the same information. Kept with
+ * the run's framing (right after the leading system prompt) so it is a `system`
+ * message: the thread-budget passes never trim one, and it therefore survives
+ * every compaction between the handoff and the answer.
+ */
+export function upsertHandoffNote(thread, note) {
+    const existing = thread.findIndex((m) => m.content.startsWith(HANDOFF_NOTE_MARKER));
+    if (existing !== -1) {
+        thread[existing] = { ...thread[existing], content: note };
+        return;
+    }
+    const insertAt = thread.length > 0 && thread[0].role === 'system' ? 1 : 0;
+    thread.splice(insertAt, 0, { role: 'system', content: note });
+}
 /**
  * Insert or refresh the single work-digest message. Idempotent: a digest already
  * in the thread is UPDATED in place, never stacked, so repeated compaction in a