claude-code-infinite 1.0.14 → 1.0.17

package/dist/proxy.js

@@ -40,9 +40,9 @@
  */
 import { capCacheBreakpoints } from "./route-cache.js";
 import { PromptAccounting } from "./prompt-accounting.js";
-import { RouteFallbackFailures } from "./route-fallback.js";
+import { INDEX_WAIT_RETRY_AFTER_SECONDS, RouteFallbackFailures } from "./route-fallback.js";
 import { createCountTokensSession, CountTokensCooldowns, plausibleSample, } from "./count-tokens.js";
-import { RequestSizing, estimateRequestTokens, fitsNative } from "./request-sizing.js";
+import { RequestSizing, estimateRequestTokens, fitsMeasured, fitsNative, outputReservation } from "./request-sizing.js";
 import { routeMessageHash, stablePrefixMessageHash } from "./route-identity.js";
 import http from "node:http";
 import https from "node:https";
@@ -50,11 +50,12 @@ import { createHash, randomBytes } from "node:crypto";
 import { brotliDecompressSync, createBrotliDecompress, createGunzip, createInflate, gunzipSync, inflateSync, } from "node:zlib";
 import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { cachedPromptTokenCount, checkCompressedHistory, didMemtreeCompress, MemtreeClient, modelBudgetTokens, normalizeMessagesForMemtree, serverFlattenedMessages, rawPromptTokenCount, } from "./memtree.js";
+import { cachedPromptTokenCount, checkCompressedHistory, didMemtreeCompress, indexLagEvidence, MemtreeClient, modelBudgetTokens, normalizeMessagesForMemtree, serverFlattenedMessages, rawPromptTokenCount, } from "./memtree.js";
 import { contextLimitForModel, hasEarlierNonToolUserMessage, isAwaySummaryUserMessage, isLocalBashCommandTurn, isNonToolUserMessage, isToolResultUserMessage, lastNonSystemMessage, messagesWithSystem, modelForMemtree, stripSystemReminderText, } from "./turns.js";
-import { COMPRESSED_NOTICE, compressedTotalsText, DEGRADED_NOTICE, NOT_COMPRESSED_NOTE, recapLinkText, PAYMENT_REQUIRED_NOTICE, SseNoticeRewriter, sanitizeNoticeDetail, stripNoticeBlocks, stripNoticeSystem, } from "./notices.js";
-import { NoticeDeliveryQueue, MEMTREE_COMPACT_COMMAND, MEMTREE_HELP_COMMAND, TRAILER_LABEL, LINK_LABEL, linkLines, terminalSupportsHyperlinks, isMemtreeViewCommand, sessionCommandArgs, parseNoticeHookInput, } from "./hooks.js";
+import { COMPRESSED_NOTICE, compressedTotalsText, DEGRADED_NOTICE, NOT_COMPRESSED_NOTE, recapLinkText, SseNoticeRewriter, stripNoticeBlocks, stripNoticeSystem, } from "./notices.js";
+import { NoticeDeliveryQueue, MEMTREE_COMPACT_COMMAND, MEMTREE_HELP_COMMAND, TRAILER_LABEL, LINK_LABEL, linkLines, urlLine, terminalSupportsHyperlinks, isMemtreeViewCommand, sessionCommandArgs, parseNoticeHookInput, } from "./hooks.js";
 import { hyperlink } from "./payment-gate.js";
+import { PaymentNoticeThrottle, paymentNoticeText } from "./payment-notice.js";
 import { MEMTREE_LINKS_MAX_SESSIONS } from "./memtree-links.js";
 import { describeClaudeCodeRequest, inspectMonitorTranscript, isClaudeCodeSideRequest, memtreeClientMeta, sessionTag, } from "./cc-request.js";
 import { approxTokensFromBytes, mergeUsageFromJsonBody, mergeUsageFromSseEvent, } from "./reqlog.js";
@@ -135,6 +136,31 @@ function checkAwaitedIndex(opts, attempt, shutdownSignal) {
         waiting.checking = false;
     });
 }
+/**
+ * Record lag evidence from `result` (indexLagEvidence): a refusal of this
+ * request then waits for the index, and the cached answer expires after the
+ * retry interval so a later retry asks MemTree again — at most one fresh
+ * compress per interval for the same request.
+ */
+function noteIndexLag(opts, rec, result) {
+    if (!indexLagEvidence(result))
+        return false;
+    rec.indexBehind = true;
+    opts.memtree.expireCompressResult?.(result, opts.indexWaitRefreshMs ?? INDEX_WAIT_RETRY_AFTER_SECONDS * 1000);
+    return true;
+}
+/** Mark a lane as waiting for the tree behind `result`'s MemTree page. */
+function awaitIndex(opts, attempt, record, result) {
+    const pageId = result.memtreeUrl ? memtreePageId(result.memtreeUrl) : undefined;
+    if (!pageId)
+        return;
+    attempt.awaitingIndex = {
+        pageId,
+        checking: false,
+        deadline: Date.now() + (opts.awaitedIndexWaitTimeoutMs ?? 60_000),
+    };
+    record.awaitingIndex = true;
+}
 /** Growth (share of the budget) a lane waits for after an attempt that failed. */
 const TOOL_COMPACTION_RETRY_BUDGET_RATIO = 0.05;
 /**
@@ -235,12 +261,13 @@ export function startProxy(opts) {
     const acceptedRequests = new Set();
     const shutdownAbort = new AbortController();
     const state = {
-        paymentNoticeShown: false,
+        paymentNotice: new PaymentNoticeThrottle(opts.paymentNoticeIntervalMs),
+        unpaidDetail: () => opts.memtree.paymentRequiredDetail,
         notices: new NoticeDeliveryQueue(),
         mainNoticePending: false,
         mainPromptGeneration: 0,
         promptAccounting: new PromptAccounting(),
-        fallbackFailures: new RouteFallbackFailures(),
+        fallbackFailures: new RouteFallbackFailures(undefined, opts.indexWaitDeadlineMs),
         activeSubagents: new Set(),
         memoryRoutes: new Map(),
         mainRouteEpoch: 0,
@@ -252,6 +279,7 @@ export function startProxy(opts) {
         shutdownSignal: shutdownAbort.signal,
         routeInstallFault: opts.routeInstallFault,
         memtreePages: new Map(),
+        memorySourcePages: new Map(),
         memtreeCallSeq: 0,
         memtreeLinkStore: opts.memtreeLinkStore,
         newestTrees: opts.newestTrees,
@@ -522,7 +550,7 @@ async function handleMemTreeFinder(req, res, opts, upstreamPath, url) {
  */
 async function handleMemTreeCurrent(req, res, opts, state, url) {
     const sessionId = url.searchParams.get("session") || undefined;
-    const page = currentMemtreePage(state, sessionId);
+    const page = currentMemorySourcePage(state, sessionId);
     const id = page ? memtreePageId(page.url) : undefined;
     if (!page || !id) {
         res.writeHead(404, { "content-type": "application/json" });
@@ -554,6 +582,12 @@ async function handleMemTreeCurrent(req, res, opts, state, url) {
     }
 }
 const MEMTREE_CURRENT_PATH = `${MEMTREE_PASSTHROUGH_PREFIX}current`;
+/** The page whose memory is in the prompt, else (none adopted yet) the newest page. */
+function currentMemorySourcePage(state, sessionId) {
+    if (!sessionId)
+        return undefined;
+    return state.memorySourcePages.get(sessionId) ?? currentMemtreePage(state, sessionId);
+}
 function currentMemtreePage(state, sessionId) {
     if (!sessionId)
         return undefined;
@@ -615,7 +649,7 @@ onMainStop) {
         if (parsed.agent_id === undefined && parsed.source === "resume") {
             await state.newestTrees?.settle(parsed.session_id);
         }
-        const line = resumeLinkLine(state, parsed);
+        const line = joinNoticeLines(resumeLinkLine(state, parsed), resumePaymentNotice(state, parsed));
         if (!line) {
             res.writeHead(204);
             res.end();
@@ -634,16 +668,16 @@ onMainStop) {
         // `/memtree-view`: answered here and blocked, so no model turn runs and
         // the prompt never enters the conversation. Not a human turn either, so
         // none of the turn state below is touched.
-        if (parsed.agent_id === undefined) {
-            // `/memtree-view` waits briefly for the newest tree; a prompt only warms it.
-            if (isMemtreeViewCommand(parsed.prompt))
-                await state.newestTrees?.settle(parsed.session_id);
-            else
-                state.newestTrees?.peek(parsed.session_id);
-        }
+        // `/memtree-view` waits briefly for the newest tree; a prompt only warms it.
+        // In a subagent's view the command is answered too (with the main
+        // session's page): unanswered, the plugin's fallback body would run.
+        if (isMemtreeViewCommand(parsed.prompt))
+            await state.newestTrees?.settle(parsed.session_id);
+        else if (parsed.agent_id === undefined)
+            state.newestTrees?.peek(parsed.session_id);
         const commandReply = parsed.agent_id === undefined
             ? sessionCommandReply(state, parsed.session_id, parsed.prompt)
-            : undefined;
+            : subagentCommandReply(state, parsed.session_id, parsed.prompt);
         if (commandReply !== undefined) {
             const body = Buffer.from(JSON.stringify({
                 decision: "block",
@@ -919,7 +953,8 @@ async function handleMessages(req, res, opts, upstream, state) {
     const sizingLimits = () => ({
         budget: resolveBudget(opts, state, body.model, modelContextLimit).tokens,
         context: modelContextLimit,
-        output: typeof body.max_tokens === "number" ? Math.max(0, body.max_tokens) : 0,
+        output: bodyOutputReservation(body),
+        recountOutput: outputReservation(undefined, body.max_tokens), // full max_tokens
     });
     const rides = state.memoryRoutes.has(requestRouteKey) ||
         (isMainRequest && requestSessionKey !== undefined && state.stablePrefixes.has(requestSessionKey));
@@ -983,7 +1018,7 @@ async function handleMessages(req, res, opts, upstream, state) {
             const measured = await requestSizing.measure(candidate, sizingLimits());
             // A validated ride is still eligible for bounded late recovery. Final
             // selection considers it together with the original and any replacement.
-            return candidate.kind === "ride" || fitsNative(measured.tokens, sizingLimits());
+            return candidate.kind === "ride" || fitsMeasured(measured, sizingLimits());
         },
         recoverLate: async (buffer, tokens) => {
             if (rec.compress || compactionMode(opts, state, requestSessionKey).mode === "off" ||
@@ -1014,6 +1049,8 @@ async function handleMessages(req, res, opts, upstream, state) {
     // Hook state controls notices only. Hidden requests cannot consume main notices.
     if (typeof body.model === "string")
         rec.model = body.model;
+    if (typeof body.max_tokens === "number")
+        rec.maxTokens = body.max_tokens;
     rec.stream = body.stream === true;
     // Observation only: which requests carry Claude Code's turn origin.
     if (clientInfo)
@@ -1045,7 +1082,7 @@ async function handleMessages(req, res, opts, upstream, state) {
                     candidateSizeOwners.set(routedCandidate, owner);
                     // Advisory window pressure can request recovery, but never removes a
                     // structurally valid candidate before request-local counting/selection.
-                    if (!fitsNative(requestSizing.plan(routedCandidate).tokens, sizingLimits())) {
+                    if (!fitsMeasured(plannedMeasurement(requestSizing, routedCandidate), sizingLimits())) {
                         routeMiss = "rejected";
                         regrantSmallerWindowRecovery(state, requestRouteKey, modelContextLimit);
                     }
@@ -1319,6 +1356,9 @@ async function handleMessages(req, res, opts, upstream, state) {
      */
     const forwardCompressed = async (compressedBody, compressedRaw, turnType, stable, result) => {
         if (!(await requestSendPolicies.get(req).fitsNative(compressedRaw))) {
+            // A lagging index left history verbatim: a refusal waits for indexing.
+            if (result)
+                noteIndexLag(opts, rec, result);
             releaseUncommittedRouteDecision();
             recordTurn(rec, "followup-degraded", rawBody);
             return logged(forwardRaw(req, res, rawBody, opts, upstream, state.shutdownSignal, rec));
@@ -1359,6 +1399,11 @@ async function handleMessages(req, res, opts, upstream, state) {
                 return;
             }
             const installed = installMemoryRoute(state, requestRouteKey, req, body, messages, compressedBody, routeEpoch, routeDecisionGeneration, stable);
+            // The answer's memory is now what future requests reuse; a ride keeps
+            // the prior source, and a failed or stale forward adopts nothing.
+            if (installed && result && linkSeq !== undefined) {
+                noteMemorySource(state, linkSeq, sessionId, result);
+            }
             commitRouteDecision();
             // Leave this false if installMemoryRoute unexpectedly throws: the
             // delivery-complete fallback then gets one safe retry.
@@ -1565,21 +1610,17 @@ async function handleMessages(req, res, opts, upstream, state) {
         // it. Degrade to passthrough and queue a display-only hook notice for a
         // visible turn. The hidden away-summary request deliberately stays quiet.
         // Unpaid key (402, from this compress OR an earlier background index) gets
-        // a payment-specific notice instead of the generic degraded one, at most
-        // once per proxy process after it has actually been delivered.
+        // a payment-specific notice with the subscribe link instead of the generic
+        // degraded one: on the first 402, then at most once per throttle interval
+        // (counted from actual delivery). In between, unpaid turns stay quiet.
         recordTurn(rec, "followup-degraded", forwardBody);
         releaseForOriginalFallback();
         sendingWhole();
         capture(opts, "anthropic-request", forwardBody);
         const paymentDetail = opts.memtree.paymentRequiredDetail;
         const mayQueueNotice = displayForThisTurn && state.mainPromptGeneration === noticePromptGeneration;
-        if (mayQueueNotice && paymentDetail !== null && !state.paymentNoticeShown) {
-            const detailFirstLine = sanitizeNoticeDetail(paymentDetail.split(/[\r\n]/, 1)[0]);
-            state.notices.queueSuffix(detailFirstLine
-                ? `${PAYMENT_REQUIRED_NOTICE}\n${detailFirstLine}`
-                : PAYMENT_REQUIRED_NOTICE, () => {
-                state.paymentNoticeShown = true;
-            }, noticePromptId);
+        if (mayQueueNotice && paymentDetail !== null && state.paymentNotice.due()) {
+            state.notices.queueSuffix(paymentNoticeText(paymentDetail, recapLink(state, sessionId)?.link), () => state.paymentNotice.markShown(), noticePromptId);
         }
         else if (mayQueueNotice && paymentDetail === null) {
             state.notices.queueSuffix(DEGRADED_NOTICE, undefined, noticePromptId);
@@ -1598,6 +1639,10 @@ async function handleMessages(req, res, opts, upstream, state) {
         usable: historyCheck.usable,
     };
     if (!actuallyCompressed || !historyCheck.usable) {
+        // A pass-through from a cold index: if the history cannot go out whole,
+        // the refusal waits for the tree instead of spending its strikes.
+        if (!actuallyCompressed)
+            noteIndexLag(opts, rec, result);
         const kept = rideOldPrefix(!actuallyCompressed);
         if (kept)
             return kept;
@@ -1796,6 +1841,25 @@ function resumeLinkLine(state, input) {
     }
     return state.notices.resumeLine(link, sessionId);
 }
+/**
+ * The unpaid-key notice for a resumed main session whose key the server has
+ * already answered 402 for: a resume is a fresh look at the session, so it
+ * says again why it runs uncompressed, regardless of the throttle. The link
+ * line above it already names the session's MemTree page.
+ */
+function resumePaymentNotice(state, input) {
+    if (input.agent_id !== undefined || input.source !== "resume")
+        return undefined;
+    const detail = state.unpaidDetail();
+    if (detail === null)
+        return undefined;
+    state.paymentNotice.markShown();
+    return state.notices.warningText(paymentNoticeText(detail));
+}
+function joinNoticeLines(...parts) {
+    const present = parts.filter((part) => !!part);
+    return present.length ? present.join("\n") : undefined;
+}
 export const MEMTREE_COMPACT_MIN_TOKENS = 20_000;
 /** The reply to a ccc slash command, or undefined for an ordinary prompt. */
 function sessionCommandReply(state, sessionId, prompt) {
@@ -1837,6 +1901,22 @@ function sessionCommandReply(state, sessionId, prompt) {
     state.compactNow.add(sessionId);
     return `${TRAILER_LABEL} compacting: your next message is sent compressed to about ${Math.round(target / 1000)}k tokens, ${keep}`;
 }
+export const SUBAGENT_VIEW_NOTE = "(main session's page; subagent pages aren't linked yet)";
+export const SUBAGENT_COMPACT_REPLY = "MemTree compact applies to the main session only.";
+/**
+ * The reply to a ccc slash command typed in a subagent's view. `sessionId` is
+ * the parent session's: the view shows its page, and compaction (per session)
+ * is refused rather than applied to the main conversation from here.
+ */
+function subagentCommandReply(state, sessionId, prompt) {
+    if (isMemtreeViewCommand(prompt)) {
+        return `${memtreeViewLine(state, sessionId)}\n${SUBAGENT_VIEW_NOTE}`;
+    }
+    if (sessionCommandArgs(prompt, MEMTREE_COMPACT_COMMAND) !== undefined) {
+        return `${TRAILER_LABEL} ${SUBAGENT_COMPACT_REPLY}`;
+    }
+    return sessionCommandReply(state, sessionId, prompt);
+}
 /** "50k", "50000", "1.5m" → tokens; undefined when not a positive count. */
 export function parseTokenCount(text) {
     const match = /^(\d+(?:\.\d+)?)\s*([km])?$/i.exec(text.trim());
@@ -1857,13 +1937,16 @@ function memtreeViewLine(state, sessionId) {
         return `${TRAILER_LABEL} no page yet: this session has not been indexed. The link appears once it has.`;
     }
     // Blocked-prompt reasons need an explicit hyperlink in styled terminals.
-    const url = terminalSupportsHyperlinks() ? hyperlink(link.link, link.link) : link.link;
-    const lines = linkLines(LINK_LABEL, url, link.note);
+    const lines = linkLines(LINK_LABEL, viewUrl(link.link), link.note);
     // The memory the agent works from can be an older tree than the newest one.
     return page?.compressed && page.url !== link.link
-        ? `${lines}\n  memory from ${page.url}`
+        ? `${lines}\n${urlLine(viewUrl(page.url), "memory from ")}`
         : lines;
 }
+/** A `/memtree-view` URL: an explicit OSC 8 link where the terminal has them. */
+function viewUrl(url) {
+    return terminalSupportsHyperlinks() ? hyperlink(url, url) : url;
+}
 /**
  * The link shown for a session: its newest completed tree when the server
  * named one (newestTrees), else `source`, the page its memory came from. The
@@ -1912,12 +1995,30 @@ function noteMemtreePage(state, seq, sessionId, result) {
     // A cached newest tree may predate this page; ask again.
     state.newestTrees?.invalidate(sessionId);
 }
-/** Bound optional page state independently of how many sessions use the proxy. */
+/**
+ * Record a compress answer's page as the source of the memory now forwarded
+ * (memorySourcePages), unless a later-submitted call's memory already is.
+ */
+function noteMemorySource(state, seq, sessionId, result) {
+    const url = result.memtreeUrl;
+    const index = result.memtreeIndex;
+    if (!sessionId || !url || !index)
+        return;
+    const latest = state.memorySourcePages.get(sessionId);
+    if (latest && latest.seq >= seq)
+        return;
+    const page = { sessionId, url, index, compressed: didMemtreeCompress(result), seq };
+    rememberPage(state.memorySourcePages, sessionId, page);
+}
 function rememberMemtreePage(state, sessionId, page) {
-    state.memtreePages.delete(sessionId);
-    state.memtreePages.set(sessionId, page);
-    while (state.memtreePages.size > MEMTREE_LINKS_MAX_SESSIONS) {
-        state.memtreePages.delete(state.memtreePages.keys().next().value);
+    rememberPage(state.memtreePages, sessionId, page);
+}
+/** Bound optional page state independently of how many sessions use the proxy. */
+function rememberPage(pages, sessionId, page) {
+    pages.delete(sessionId);
+    pages.set(sessionId, page);
+    while (pages.size > MEMTREE_LINKS_MAX_SESSIONS) {
+        pages.delete(pages.keys().next().value);
     }
 }
 /**
@@ -2225,8 +2326,8 @@ function laneCompaction(opts, state, sessionId, model, modelContextLimit) {
 }
 /** Calibrated input must leave room for the requested output as well. */
 function calibratedSizeExceedsWindow(record, body, modelContextLimit) {
-    const outputTokens = typeof body.max_tokens === "number" && Number.isFinite(body.max_tokens)
-        ? Math.max(0, body.max_tokens) : 0;
+    // A planning estimate, so the full max_tokens (the floor needs an exact count).
+    const outputTokens = bodyOutputReservation(body, false);
     return record.sizeSource === "reported" &&
         (record.estimatedTokens ?? 0) + outputTokens > modelContextLimit;
 }
@@ -2487,8 +2588,9 @@ function planToolCompaction(args) {
         }
     }
     if (!ride) {
-        const originalSize = args.sizing.plan(args.sizing.register(forwardBody, "original"));
-        overWindow ||= originalSize.tokens + Math.max(0, body.max_tokens ?? 0) > modelContextLimit;
+        const original = args.sizing.register(forwardBody, "original");
+        overWindow ||= args.sizing.plan(original).tokens +
+            bodyOutputReservation(body, args.sizing.isExact(original)) > modelContextLimit;
     }
     const sample = ride
         ? ride.sizeHolder.lastSize
@@ -2503,7 +2605,7 @@ function planToolCompaction(args) {
     compaction.estimatedBytes = (ride?.raw ?? forwardBody).length;
     compaction.sizeSource = size.source;
     overWindow ||= !fitsNative(size.tokens, { budget: budget.tokens, context: modelContextLimit,
-        output: typeof body.max_tokens === "number" ? Math.max(0, body.max_tokens) : 0 });
+        output: bodyOutputReservation(body, args.sizing.isExact(candidate)) });
     if (!args.canCompress) {
         if (overWindow)
             return { kind: "pass", original: true };
@@ -2567,12 +2669,21 @@ function memoryRoutedToolBody(body, messages, route, routeEpoch, sessionId) {
 }
 /** Size the assembled input (including system/tools) and reserve output room. */
 function routedBodyExceedsContext(body, routedBody, modelContextLimit) {
-    const outputTokens = typeof body.max_tokens === "number" &&
-        Number.isFinite(body.max_tokens) ? Math.max(0, body.max_tokens) : 0;
+    const outputTokens = bodyOutputReservation(body, false);
     // This is the existing local byte estimate, not a tokenizer or a hard cap.
     // Final forwarding checks can replace this estimate with Count Tokens.
     return approxTokensFromBytes(routedBody.length) + outputTokens > modelContextLimit;
 }
+/** Output room a native-fit check reserves: the model's floor for an exact
+ * count, else (an estimate) the full max_tokens. */
+function bodyOutputReservation(body, exact = true) {
+    return outputReservation(exact && typeof body.model === "string" ? body.model : undefined, body.max_tokens);
+}
+/** A planned size as a measurement, exact only when Count Tokens measured it. */
+function plannedMeasurement(sizing, candidate) {
+    const planned = sizing.plan(candidate);
+    return { tokens: planned.tokens, source: sizing.isExact(candidate) ? "exact" : planned.source };
+}
 function regrantSmallerWindowRecovery(state, key, modelContextLimit) {
     const previous = state.toolRecoveryAttemptedLanes.get(key);
     if (previous && !previous.inFlight && modelContextLimit < previous.modelContextLimit) {
@@ -3031,9 +3142,10 @@ async function recoverToolRouteMiss(args) {
      * The attempt produced nothing: send what the turn would have sent without
      * it — the old ride (kept prefix) or the whole history — and back off.
      */
-    const forwardOriginal = () => {
+    const forwardOriginal = (growthBackoff = true) => {
         requestSendPolicies.get(req).failedRebuild = true;
-        backOff();
+        if (growthBackoff)
+            backOff();
         if (fallback) {
             requestSendPolicies.get(req)?.allowed.add(fallback.raw);
             if (rec.compaction)
@@ -3146,17 +3258,11 @@ async function recoverToolRouteMiss(args) {
         };
         // No tree yet (nothing indexed): wait for it to be built rather than
         // retrying on growth, which on a fast-growing loop is every tool turn.
-        const pageId = result.memtreeUrl ? memtreePageId(result.memtreeUrl) : undefined;
-        if (!actuallyCompressed && !(cachedPromptTokenCount(result) ?? 0) && pageId) {
-            recoveryAttempt.awaitingIndex = {
-                pageId,
-                checking: false,
-                deadline: Date.now() + (opts.awaitedIndexWaitTimeoutMs ?? 60_000),
-            };
-            rec.routeRecovery.awaitingIndex = true;
-        }
         releaseOwnReservation();
-        return forwardOriginal();
+        if (actuallyCompressed || !noteIndexLag(opts, rec, result))
+            return forwardOriginal();
+        awaitIndex(opts, recoveryAttempt, rec.routeRecovery, result);
+        return forwardOriginal(false);
     }
     // Serializing the compressed body is the one synchronous step here that can
     // realistically throw: these are the multi-megabyte payloads that court
@@ -3194,7 +3300,14 @@ async function recoverToolRouteMiss(args) {
     if (!(await requestSendPolicies.get(req).fitsNative(compressedRaw))) {
         rec.routeRecovery = { conversationBytes, outcome: "unusable" };
         releaseOwnReservation();
-        return forwardOriginal();
+        if (!noteIndexLag(opts, rec, result))
+            return forwardOriginal();
+        // The index trails the conversation, so this result kept most of it
+        // verbatim. Growth cannot help; the next compress after indexing can.
+        // Skip the growth backoff so retries compress again, and let a refusal
+        // wait for the index rather than spend the strike budget.
+        awaitIndex(opts, recoveryAttempt, rec.routeRecovery, result);
+        return forwardOriginal(false);
     }
     if (compressedRaw.length >= (fallback?.raw ?? forwardBody).length) {
         // The final transformed body is the proof of payload recovery; a result
@@ -3228,6 +3341,10 @@ async function recoverToolRouteMiss(args) {
         activationAttempted = true;
         installedRoute = installed;
         installFate = installed ? "installed" : "stale";
+        // Only an installed route makes this answer's memory the reused one.
+        if (installed && linkSeq !== undefined) {
+            noteMemorySource(state, linkSeq, requestSessionId(req), result);
+        }
         // A tool continuation can arrive after message_stop while this HTTP
         // stream is still draining. Its route is already complete, so a smaller
         // window may buy recovery now. Mutate only this attempt's object: a late
@@ -3432,6 +3549,10 @@ async function recoverLateCount(args) {
             compaction: { target: compactionTarget(compactionMode(args.opts, args.state, requestSessionId(args.req)), budget) },
         });
         noteMemtreeHealth(args.state, outcome);
+        // Like every compress path: a refusal after a lagging answer waits for
+        // the index, and the cached answer expires so a retry asks again.
+        if (outcome.result)
+            noteIndexLag(args.opts, args.rec, outcome.result);
         if (!outcome.result || !didMemtreeCompress(outcome.result) ||
             !checkCompressedHistory(outcome.result, messages).usable)
             return undefined;
@@ -3490,12 +3611,13 @@ async function selectForwardCandidate(args) {
 }
 /** Write the bounded fallback refusal (route-fallback.ts); always false. */
 function refuseWholeRequest(args, inputTokens, budgetTokens) {
-    const failure = args.state.fallbackFailures.fail(args.routeKey);
+    const failure = args.state.fallbackFailures.fail(args.routeKey, { awaitingIndex: args.rec.indexBehind === true });
     args.rec.forwardedBytes = 0;
     args.rec.approxInputTokens = 0;
     console.error("[ccc proxy] request exceeds native context window; recovery failed", {
         lane: args.routeKey, attempt: failure.attempt, status: failure.status,
         inputTokens, outputTokens: args.body.max_tokens ?? 0,
+        outputReservation: bodyOutputReservation(args.body), indexBehind: args.rec.indexBehind === true,
         budgetTokens, modelContextLimit: args.modelContextLimit,
     });
     if (args.res.headersSent || args.res.destroyed)