claude-code-infinite 1.0.31 → 1.0.33

package/dist/proxy.js

@@ -40,7 +40,7 @@
  */
 import { capCacheBreakpoints } from "./route-cache.js";
 import { PromptAccounting } from "./prompt-accounting.js";
-import { INDEX_WAIT_RETRY_AFTER_SECONDS, RouteFallbackFailures, pausedRefusal } from "./route-fallback.js";
+import { INDEX_WAIT_RETRY_AFTER_SECONDS, RefusalStreaks, RouteFallbackFailures, pausedRefusal } from "./route-fallback.js";
 import { createCountTokensSession, CountTokensCooldowns, plausibleSample, } from "./count-tokens.js";
 import { RequestSizing, estimateRequestTokens, fitsMeasured, fitsNative, outputReservation } from "./request-sizing.js";
 import { extendsHistory, mediaFreeMessageHash, prefixIdentity, prefixMessageMatches, } from "./route-identity.js";
@@ -52,10 +52,10 @@ 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, indexLagEvidence, MemtreeClient, modelBudgetTokens, normalizeMessagesForMemtree, serverFlattenedMessages, rawPromptTokenCount, } from "./memtree.js";
+import { cachedPromptTokenCount, checkCompressedHistory, didMemtreeCompress, indexLagEvidence, losesMedia, 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, SseNoticeRewriter, stripNoticeBlocks, stripNoticeSystem, } from "./notices.js";
-import { NoticeDeliveryQueue, MEMTREE_COMPACT_COMMAND, MEMTREE_HELP_COMMAND, TRAILER_LABEL, LINK_LABEL, linkLines, urlLine, terminalSupportsHyperlinks, isMemtreeViewCommand, sessionCommandArgs, parseNoticeHookInput, PRECOMPACT_HOOK_PATH, } from "./hooks.js";
+import { COMPRESSED_NOTICE, compressedTotalsText, DEGRADED_NOTICE, NOT_COMPRESSED_NOTE, SLOW_RETRY_NOTICE, recapLinkText, SseNoticeRewriter, stripNoticeBlocks, stripNoticeSystem, } from "./notices.js";
+import { NoticeDeliveryQueue, MEMTREE_COMPACT_COMMAND, MEMTREE_HELP_COMMAND, TRAILER_LABEL, LINK_LABEL, linkLines, terminalSupportsHyperlinks, isMemtreeViewCommand, sessionCommandArgs, parseNoticeHookInput, PRECOMPACT_HOOK_PATH, } from "./hooks.js";
 import { USAGE_LABEL, USAGE_SIGN_IN_NOTE } from "./usage-link.js";
 import { hyperlink } from "./payment-gate.js";
 import { keyInvalidNoticeText, keyInvalidRefusalMessage } from "./key-status.js";
@@ -64,6 +64,8 @@ import { PaymentNoticeThrottle, pausedCompactionText, pausedRefusalMessage, paym
 import { MEMTREE_LINKS_MAX_SESSIONS } from "./memtree-links.js";
 import { describeClaudeCodeRequest, inspectMonitorTranscript, knownSideRequestKind, transcriptWarning, isClaudeCodeSideRequest, memtreeClientMeta, sessionTag, } from "./cc-request.js";
 import { isResumableSessionId } from "./resume-hint.js";
+import { subagentMemoryHintText, subagentStartOutput, } from "./subagent-hint.js";
+import { RESUME_GUIDANCE_HOOK_SUFFIX } from "./hooks.js";
 import { conservativeBodyTokens } from "./token-estimate.js";
 import { bodyImages } from "./image-tokens.js";
 import { claudeAuthFromHeaders, upstreamErrorCode } from "./claude-auth.js";
@@ -71,6 +73,8 @@ import { rateLimitFromResponse } from "./rate-limit.js";
 import { approxTokensFromBytes, mergeUsageFromJsonBody, mergeUsageFromSseEvent, } from "./reqlog.js";
 const DEFAULT_UPSTREAM = "https://api.anthropic.com";
 const HOOK_BODY_LIMIT = 64 * 1024;
+/** A hook body still arriving after this is dropped (the hook itself waits 5 s). */
+const HOOK_BODY_TIMEOUT_MS = 3_000;
 // After a recovery attempt returns null (MemTree down, 5xx, or a burned
 // timeout budget), suppress the blocking attempt for this long, across every
 // lane. A lane's own growth backoff alone would let each over-budget tool turn
@@ -82,8 +86,11 @@ const HOOK_BODY_LIMIT = 64 * 1024;
 const TOOL_RECOVERY_FAILURE_COOLDOWN_MS = 60_000;
 /** Safety cap on a long-budget compress, should a transport ignore its abort. */
 const MAX_LONG_COMPRESS_WAIT_MS = 10 * 60_000;
-/** The most a blocking compress with a fallback may wait (its budget grows with its upload). */
-const MAX_COMPRESS_WAIT_MS = 60_000;
+/**
+ * The most a blocking compress with a fallback may wait (its budget grows with its upload):
+ * a 30 MB upload's scaled budget (15 s + 2.5 ms/KiB, ~90 s) fits under it.
+ */
+const MAX_COMPRESS_WAIT_MS = 120_000;
 const SKIP_REQUEST_HEADERS = new Set([
     "host",
     "connection",
@@ -343,14 +350,20 @@ export function startProxy(opts) {
         usageUrl: opts.memtree.usageDashboardUrl,
         sessionStartNotice: opts.sessionStartNotice,
         promptSubmitNotice: opts.promptSubmitNotice,
+        openUrl: opts.openUrl,
         projectTrees: opts.projectTrees,
+        subagentHint: opts.subagentHint,
+        resumeGuidance: opts.resumeGuidance,
         diagnostics: opts.diagnostics,
         notices: new NoticeDeliveryQueue(),
         mainNoticePending: false,
         mainPromptGeneration: 0,
         promptAccounting: new PromptAccounting(),
         fallbackFailures: new RouteFallbackFailures(undefined, opts.indexWaitDeadlineMs),
+        refusalStreaks: new RefusalStreaks(),
         activeSubagents: new Set(),
+        deferredAgentIndexes: new Map(),
+        adoptingPrepared: new Map(),
         memoryRoutes: new Map(),
         mainRouteEpoch: 0,
         mainRouteDecisionGeneration: 0,
@@ -446,8 +459,10 @@ export function startProxy(opts) {
         ]);
         if (timer)
             clearTimeout(timer);
-        if (completed)
+        if (completed) {
+            sendDeferredAgentIndexes(state);
             return true;
+        }
         // The grace period protects useful in-flight delivery. Once it
         // expires, signal every forwarding path first so each can
         // classify the close as proxy-owned, then tear down any request that was
@@ -456,6 +471,7 @@ export function startProxy(opts) {
         for (const accepted of acceptedRequests)
             cancelAcceptedRequest(accepted);
         await quiesced;
+        sendDeferredAgentIndexes(state);
         return false;
     };
     return new Promise((resolve, reject) => {
@@ -496,6 +512,9 @@ async function handleRequest(req, res, opts, upstream, state, hookPath) {
     if (url.pathname === PRECOMPACT_HOOK_PATH) {
         return handleNoticeHook(req, res, state, opts.reqlog, undefined, "PreCompact");
     }
+    if (url.pathname === `${hookPath}${RESUME_GUIDANCE_HOOK_SUFFIX}`) {
+        return handleResumeGuidanceHook(req, res, state);
+    }
     if (url.pathname === hookPath) {
         return handleNoticeHook(req, res, state, opts.reqlog, (sessionId) => opts.memtree.scheduleFinalIndex(sessionId, (signal) => opts.transcriptUsage?.finalReplyAsync
             ? opts.transcriptUsage.finalReplyAsync(sessionId, signal)
@@ -727,6 +746,39 @@ function noteMainSessionStart(state, source, sessionId) {
         state.resumableMainSession = undefined;
     }
 }
+/**
+ * SessionStart on its own hook (resume-guidance.ts): only the current MemTree
+ * guidance, so Claude Code sees it as one context of its own and adds an
+ * identical one only once. Never fails the hook: anything unexpected is 204.
+ */
+async function handleResumeGuidanceHook(req, res, state) {
+    const raw = req.method === "POST" ? await readBodyWithin(req, HOOK_BODY_LIMIT) : undefined;
+    if (req.method !== "POST")
+        req.resume();
+    let input = null;
+    try {
+        if (raw !== undefined && raw.length > 0) {
+            input = parseNoticeHookInput(JSON.parse(raw.toString("utf-8")));
+        }
+    }
+    catch {
+        input = null;
+    }
+    const context = input?.hook_event_name === "SessionStart"
+        ? await resumeGuidanceContext(state, input) : undefined;
+    if (!context) {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    const body = Buffer.from(JSON.stringify(sessionStartOutput(undefined, context)), "utf-8");
+    res.writeHead(200, {
+        "content-type": "application/json",
+        "content-length": String(body.length),
+        "cache-control": "no-store",
+    });
+    res.end(body);
+}
 /** Serve only validated Claude hook POSTs on the randomized localhost path. */
 async function handleNoticeHook(req, res, state, reqlog, 
 /** A main-lane turn ended: the session may be over (its final index). */
@@ -882,12 +934,24 @@ onlyEvent) {
     }
     if (parsed.hook_event_name === "SubagentStart") {
         state.activeSubagents.add(parsed.agent_id);
-        res.writeHead(204);
-        res.end();
+        const hint = await subagentHintContext(state, parsed.session_id);
+        if (hint === undefined) {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        const body = Buffer.from(JSON.stringify(subagentStartOutput(hint)), "utf-8");
+        res.writeHead(200, {
+            "content-type": "application/json",
+            "content-length": String(body.length),
+            "cache-control": "no-store",
+        });
+        res.end(body);
         return;
     }
     if (parsed.hook_event_name === "SubagentStop") {
         state.activeSubagents.delete(parsed.agent_id);
+        sendDeferredAgentIndex(state, parsed.agent_id);
         res.writeHead(204);
         res.end();
         return;
@@ -981,6 +1045,8 @@ async function handleMessages(req, res, opts, upstream, state) {
         requestBytes: rawBody.length,
         claudeAuth: claudeAuthFromHeaders(req.headers),
     };
+    // The prompt this request was made for, before any await (Codex r2 P2).
+    noticeContexts.set(rec, { promptId: state.mainPromptId, generation: state.mainPromptGeneration });
     const logged = async (forward) => {
         try {
             await forward;
@@ -1220,7 +1286,11 @@ async function handleMessages(req, res, opts, upstream, state) {
                     lane: isAwaySummary ? "away" : requestRouteLane === "main" ? "main" : "other" },
                 ...(target !== undefined ? { target } : {}) });
         },
-        delivered: () => { state.fallbackFailures.succeeded(requestRouteKey); toolForwarding.settle(true); },
+        delivered: () => {
+            state.fallbackFailures.succeeded(requestRouteKey);
+            state.refusalStreaks.delivered(requestRouteKey);
+            toolForwarding.settle(true);
+        },
     });
     const rawMsgsForMemtree = messagesWithSystem(messages, body.system);
     const msgsForMemtree = normalizeMessagesForMemtree(rawMsgsForMemtree);
@@ -1349,7 +1419,7 @@ async function handleMessages(req, res, opts, upstream, state) {
             // prefix, else whole) with no compress call; at it, compress once to
             // the target (planToolCompaction). A "replay" is a client retry of the
             // request that installed the route, forwarded verbatim.
-            const plan = await planToolCompaction({
+            const planArgs = {
                 opts,
                 state,
                 body,
@@ -1364,7 +1434,24 @@ async function handleMessages(req, res, opts, upstream, state) {
                 rec,
                 ride: toolRide,
                 canCompress,
-            });
+            };
+            let plan = await planToolCompaction(planArgs);
+            // Over the window with nothing to ride while the lane compresses: going without it
+            // can only be refused (staging 2026-10-30: a 120 s compress, every tool turn meanwhile
+            // refused). Wait for it, then plan again on what it installed.
+            if (plan.kind === "compress" && plan.overWindow && !plan.fallback &&
+                state.toolRecoveryAttemptedLanes.get(requestRouteKey)?.inFlight) {
+                // Stops early if Claude Code drops this request meanwhile.
+                const clientGone = new AbortController();
+                const onClose = () => clientGone.abort();
+                res.once("close", onClose);
+                rec.laneWaitMs = await waitForLaneIdle(state, requestRouteKey, Math.min(MAX_LONG_COMPRESS_WAIT_MS, opts.memtree.longCompressBudgetMs), clientGone.signal);
+                res.off("close", onClose);
+                // Plan on what the lane holds now: the route its compression installed (or, on the
+                // main lane, the session's new stable prefix), never the ride read before the wait.
+                plan = await planToolCompaction({ ...planArgs,
+                    ride: currentLaneRide(state, requestRouteKey, body, messages, toolSessionId, isMainRequest) });
+            }
             if (isMainRequest && toolSessionId !== undefined && canCompress &&
                 (plan.kind === "ride" || plan.kind === "pass")) {
                 maybePrepareCompression({ opts, state, body, messages, msgsForMemtree, hash,
@@ -1422,6 +1509,10 @@ async function handleMessages(req, res, opts, upstream, state) {
                     // the lane's backoff.
                     rec.routeRecovery = { outcome: "cooldown" };
                 }
+                else if (state.toolRecoveryAttemptedLanes.get(requestRouteKey)?.inFlight) {
+                    // Claimed while the cooldown check above awaited a count (a crossing prompt).
+                    rec.routeRecovery = { outcome: "in-flight" };
+                }
                 else {
                     const recoveryAttempt = { modelContextLimit, inFlight: true };
                     if (!prior && state.toolRecoveryAttemptedLanes.size >= 128) {
@@ -1488,7 +1579,8 @@ async function handleMessages(req, res, opts, upstream, state) {
             requestSendPolicies.get(req)?.allowed.add(toolRide.raw);
         const sendBody = toolRide?.raw ?? (toolNeedsOriginal ? rawBody : forwardBody);
         recordTurn(rec, toolRide ? toolRide.turnType : isUserTurn ? "first-user" : "tool", sendBody);
-        opts.memtree.indexInBackground(hash, msgsForMemtree, modelContextLimit, toolSessionId, clientMeta, transcriptTimesFor(opts, toolSessionId, agentAttributionId(req)));
+        indexTurn({ opts, state, req, rec, hash, msgsForMemtree, modelContextLimit,
+            sessionId: toolSessionId, clientMeta });
         capture(opts, toolRide ? "anthropic-request-memory-tool" : "anthropic-request", sendBody);
         // The size Anthropic reports is the next budget check's anchor: a ride
         // reports to its prefix (or route), a whole request to the session's (or
@@ -1559,6 +1651,32 @@ async function handleMessages(req, res, opts, upstream, state) {
             rec.compaction.prepared ??= prepared;
         }
     }
+    // Never beside the main lane's compression in flight either (a tool turn's that Claude
+    // Code dropped, or another prompt's, both after the preparation they waited for failed):
+    // wait for it, then plan again on what it left: a prefix to ride, or a preparation.
+    // Bounded; stops early if Claude Code drops this request (release 1.0.33 E2E).
+    const crossing = () => edge?.kind === "compress" && isMainRequest &&
+        isAutoCrossing(rec, body.model, modelContextLimit);
+    for (let i = 0; i < 2 && crossing() &&
+        state.toolRecoveryAttemptedLanes.get(requestRouteKey)?.inFlight; i++) {
+        const clientGone = new AbortController();
+        const onClose = () => clientGone.abort();
+        res.once("close", onClose);
+        if (res.destroyed)
+            clientGone.abort();
+        rec.laneWaitMs = (rec.laneWaitMs ?? 0) + await waitForLaneIdle(state, requestRouteKey, Math.min(MAX_LONG_COMPRESS_WAIT_MS, opts.memtree.longCompressBudgetMs), clientGone.signal);
+        res.off("close", onClose);
+        await awaitPreparation(state, sessionId, opts.memtree.longCompressBudgetMs, rec.compaction);
+        edge = await planEdge();
+    }
+    // Claude Code dropped it while it waited: the lane's compression in flight already carries
+    // this session's crossing (the next turn rides it), so none beside it for nobody (r3 P1).
+    if (crossing() && state.toolRecoveryAttemptedLanes.get(requestRouteKey)?.inFlight &&
+        res.destroyed && !res.writableFinished) {
+        releaseUncommittedRouteDecision();
+        recordTurn(rec, "followup-client-closed", Buffer.alloc(0));
+        return logged(Promise.resolve());
+    }
     // Not beside a blocking compress call: the two would overlap on the server.
     if (sessionId !== undefined && edge && (edge.kind === "ride" || edge.kind === "pass")) {
         maybePrepareCompression({ opts, state, body, messages, msgsForMemtree, hash, sessionId,
@@ -1787,9 +1905,17 @@ async function handleMessages(req, res, opts, upstream, state) {
     // The hidden away-summary request compresses too, but its page is not the
     // conversation the user is looking at.
     const linkSeq = isMainRequest && !isAwaySummary ? nextMemtreeCallSeq(state) : undefined;
+    const edgeCarry = edge?.kind === "compress" && !isAwaySummary
+        ? carryFor({ state, isMainRequest, sessionId, body, messages, msgsForMemtree,
+            modelContextLimit, rec,
+            targetTokens: edge.targetTokens, explicitTarget: edge.explicitTarget, linkSeq })
+        : undefined;
     let compression;
+    // A main-thread compaction holds its lane, claimed with no await since the check above:
+    // a concurrent turn of the lane waits for it or rides its fallback, never compresses beside it.
+    const edgeLane = (run) => crossing() ? holdingLane(state, requestRouteKey, run) : run();
     try {
-        compression = await runBlockingCompression({
+        compression = await edgeLane(async () => runBlockingCompression({
             opts,
             state,
             body,
@@ -1809,9 +1935,10 @@ async function handleMessages(req, res, opts, upstream, state) {
                     : {}),
             // Riding the old prefix, or sending a raw request that fits, keeps the
             // short budget; with neither, a timeout could only end in a refusal.
-            longBudget: !(edge?.kind === "compress" && edge.fallback) &&
+            longBudget: !(edge?.kind === "compress" && edge.fallback && !edge.fallback.uncounted) &&
                 await wholeRequestRefused(requestSizing, forwardCandidate, sizingLimits()),
-        });
+            ...(edgeCarry ? { carry: edgeCarry } : {}),
+        }));
     }
     catch {
         const kept = rideOldPrefix(false);
@@ -1851,6 +1978,9 @@ async function handleMessages(req, res, opts, upstream, state) {
     if (downstreamClosedDuringCompression ||
         (res.destroyed && !res.writableFinished)) {
         releaseUncommittedRouteDecision();
+        // Claude Code gave up on the turn, not on the compaction: the next turn rides it.
+        if (result && edgeCarry)
+            carryOverCompression(state, edgeCarry, Promise.resolve(result));
         recordTurn(rec, "followup-client-closed", Buffer.alloc(0));
         return logged(Promise.resolve());
     }
@@ -1858,6 +1988,28 @@ async function handleMessages(req, res, opts, upstream, state) {
     // Each forwarder installs its own close listener synchronously, so this is
     // an event-loop-atomic handoff of downstream-close ownership.
     if (!result) {
+        const paymentDetail = opts.memtree.paymentRequiredDetail;
+        const mayQueueNotice = displayForThisTurn && state.mainPromptGeneration === noticePromptGeneration;
+        if (mayQueueNotice && paymentDetail === null && !state.keyInvalid()) {
+            // Under the budget the whole request is what compression would have
+            // sent: the turn is not degraded, so the failure stays in the logs.
+            // Delivery decides the rest (selectForwardCandidate): only a whole
+            // history actually sent warns. A refusal (Claude Code retries it) or a
+            // ride on a compressed prefix did not run uncompressed (2026-10-28).
+            const eager = compressionNeeded(rec.compaction);
+            // Delivery sizes the request again (an exact count, else a
+            // conservative bound): a planned fit it finds over the budget warns then.
+            if (!eager)
+                rec.degradedNotice = "quiet-under-budget";
+            degradedNotices.set(rec, { eager, warn: () => {
+                    // A 402 or refused key meanwhile keeps its own, actionable notice (Codex r2 P2).
+                    if (state.mainPromptGeneration !== noticePromptGeneration ||
+                        opts.memtree.paymentRequiredDetail !== null || state.keyInvalid())
+                        return;
+                    state.notices.queueSuffix(DEGRADED_NOTICE, undefined, noticePromptId);
+                    rec.degradedNotice = "shown";
+                } });
+        }
         const kept = rideOldPrefix(false);
         if (kept)
             return kept;
@@ -1872,8 +2024,6 @@ async function handleMessages(req, res, opts, upstream, state) {
         releaseForOriginalFallback();
         sendingWhole();
         capture(opts, "anthropic-request", forwardBody);
-        const paymentDetail = opts.memtree.paymentRequiredDetail;
-        const mayQueueNotice = displayForThisTurn && state.mainPromptGeneration === noticePromptGeneration;
         const overBudget = reachedBudget(rec.compaction);
         if (state.keyInvalid()) {
             // A refused key (401/403) says why MemTree is off and how to fix it;
@@ -1897,26 +2047,6 @@ async function handleMessages(req, res, opts, upstream, state) {
             if (overBudget)
                 state.nearWindowNotice = handle;
         }
-        else if (mayQueueNotice && paymentDetail === null) {
-            // Under the budget the whole request is what compression would have
-            // sent: the turn is not degraded, so the failure stays in the logs.
-            const warn = () => {
-                state.notices.queueSuffix(DEGRADED_NOTICE, undefined, noticePromptId);
-                rec.degradedNotice = "shown";
-            };
-            if (compressionNeeded(rec.compaction)) {
-                warn();
-            }
-            else {
-                // Delivery sizes the request again (an exact count, else a
-                // conservative bound): a turn it finds over the budget warns then.
-                rec.degradedNotice = "quiet-under-budget";
-                quietDegrades.set(rec, () => {
-                    if (state.mainPromptGeneration === noticePromptGeneration)
-                        warn();
-                });
-            }
-        }
         return logged(forwardRaw(req, res, forwardBody, opts, upstream, state.shutdownSignal, rec).then((delivered) => {
             noteWholeSize();
             if (delivered)
@@ -2224,6 +2354,48 @@ async function projectTreesContext(hint, input) {
         return undefined;
     }
 }
+/**
+ * The parent's memory hint for a starting subagent: only while MemTree works
+ * and the session has the tools, naming the parent's newest tree (a bounded
+ * wait when no answer is cached). Undefined otherwise; never throws.
+ */
+async function subagentHintContext(state, sessionId) {
+    if (!state.subagentHint?.enabled || !memtreeWorking(state))
+        return undefined;
+    try {
+        // A cached tree will do (peek refreshes it in the background); wait only for none.
+        const tree = state.newestTrees?.peek(sessionId) ?? await state.newestTrees?.settle(sessionId);
+        // MemTree may have paused or failed while the lookup was on its way.
+        if (!tree || !state.subagentHint.enabled || !memtreeWorking(state))
+            return undefined;
+        return subagentMemoryHintText(sessionId, tree.key);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The current MemTree guidance for a resumed main session (resume-guidance.ts). */
+async function resumeGuidanceContext(state, input) {
+    try {
+        return await state.resumeGuidance?.contextFor(input, {
+            working: () => resumeMemtreeWorking(state),
+            compressed: () => currentMemtreePage(state, input.session_id)?.compressed,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Whether MemTree works as a session resumes: not paused, key not refused,
+ * and its latest answer, if any, a success. A new `ccc --resume` process has
+ * no answer yet; its startup key check already turned a refused or unpaid
+ * key into no guidance (resumeGuidanceFor).
+ */
+function resumeMemtreeWorking(state) {
+    return state.memtreeAnswering() !== false && state.unpaidDetail() === null &&
+        !state.keyInvalid();
+}
 /**
  * The SessionStart hook's answer: the banner line for the user
  * (`systemMessage`), model context (`additionalContext`), or both.
@@ -2251,15 +2423,14 @@ function sessionCommandReply(state, sessionId, prompt) {
         : pausedCompactionText(viewUrl(subscribeUrlFromDetail(unpaid)));
     if (sessionCommandArgs(prompt, MEMTREE_HELP_COMMAND) !== undefined) {
         return [
-            "• /memtree-view · show this session's MemTree page link",
+            "• /memtree-view · open this session's MemTree page and show its link",
             paused !== undefined ? `• ${paused}`
                 : `• /memtree-compact [tokens | off] · compact this session on your next message (default half the budget, at least ${MEMTREE_COMPACT_MIN_TOKENS / 1000}k)`,
             usageLines(state),
         ].filter((line) => line !== undefined).join("\n");
     }
-    if (isMemtreeViewCommand(prompt)) {
-        return joinNoticeLines(memtreeViewLine(state, sessionId), usageLines(state)) ?? "";
-    }
+    if (isMemtreeViewCommand(prompt))
+        return memtreeView(state, sessionId);
     const args = sessionCommandArgs(prompt, MEMTREE_COMPACT_COMMAND);
     if (args === undefined)
         return undefined;
@@ -2303,10 +2474,8 @@ export const SUBAGENT_COMPACT_REPLY = "MemTree compact applies to the main sessi
  * is refused rather than applied to the main conversation from here.
  */
 function subagentCommandReply(state, sessionId, prompt) {
-    if (isMemtreeViewCommand(prompt)) {
-        const view = `${memtreeViewLine(state, sessionId)}\n${SUBAGENT_VIEW_NOTE}`;
-        return joinNoticeLines(view, usageLines(state)) ?? view;
-    }
+    if (isMemtreeViewCommand(prompt))
+        return `${memtreeView(state, sessionId)}\n${SUBAGENT_VIEW_NOTE}`;
     if (sessionCommandArgs(prompt, MEMTREE_COMPACT_COMMAND) !== undefined) {
         return `${TRAILER_LABEL} ${SUBAGENT_COMPACT_REPLY}`;
     }
@@ -2321,8 +2490,13 @@ export function parseTokenCount(text) {
     const value = Math.round(Number(match[1]) * scale);
     return Number.isFinite(value) && value > 0 ? value : undefined;
 }
-/** The `/memtree-view` answer: this session's newest page, or why there is none. */
-function memtreeViewLine(state, sessionId) {
+/**
+ * The `/memtree-view` answer: one link, this session's newest page (the
+ * newest completed tree, which covers the whole session, rather than the
+ * possibly stale page its memory was compressed from), opened in the browser
+ * where the CLI allows it; or why there is none.
+ */
+function memtreeView(state, sessionId) {
     const inMemory = state.memtreePages.get(sessionId);
     const page = inMemory && (inMemory.sessionId === undefined || inMemory.sessionId === sessionId)
         ? inMemory
@@ -2331,15 +2505,17 @@ function memtreeViewLine(state, sessionId) {
     if (!link) {
         return `${TRAILER_LABEL} no page yet: this session has not been indexed. The link appears once it has.`;
     }
+    try {
+        state.openUrl?.(link.link);
+    }
+    catch {
+        // The printed link below is the fallback.
+    }
     // Blocked-prompt reasons need an explicit hyperlink in styled terminals.
-    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${urlLine(viewUrl(page.url), "memory from ")}`
-        : lines;
+    return linkLines(LINK_LABEL, viewUrl(link.link), link.note);
 }
 /**
- * The usage dashboard link that `/memtree` and `/memtree-view` end with,
+ * The usage dashboard link that `/memtree` ends with,
  * formatted like the MemTree link; undefined when the environment has none.
  */
 function usageLines(state) {
@@ -2830,6 +3006,15 @@ function calibratedSizeExceedsWindow(record, body, modelContextLimit) {
     return record.uncountedOverWindow === true || (record.sizeSource === "reported" &&
         (record.estimatedTokens ?? 0) + outputTokens > modelContextLimit);
 }
+/**
+ * Over the window (calibratedSizeExceedsWindow) only by the uncounted
+ * conservative bound: a calibrated estimate that fits the window with the
+ * full max_tokens says otherwise.
+ */
+function uncountedOnlyOverWindow(record, body, modelContextLimit) {
+    return record.uncountedOverWindow === true && record.sizeSource === "reported" &&
+        (record.estimatedTokens ?? 0) + bodyOutputReservation(body, false) <= modelContextLimit;
+}
 function calibratedSizeExceedsLimits(record, body, modelContextLimit) {
     return (record.sizeSource === "reported" &&
         (record.estimatedTokens ?? 0) >= record.budgetTokens) ||
@@ -3050,7 +3235,14 @@ async function planEdgeCompaction(args) {
         // image-aware bound), not bytes: a flatten that kept images is mostly
         // base64 that costs a fixed amount per image.
         const overWindow = calibratedSizeExceedsWindow(compaction, body, modelContextLimit);
-        const fallback = overWindow ? undefined : { prefix, routed };
+        // Over the window only by the conservative bound of a ride whose planning
+        // count timed out: delivery counts it again before sending it, so it stays
+        // the fallback a failed compress rides (2026-10-28: a 528k ride whose
+        // count timed out was dropped, and the failed compress refused the turn).
+        const uncounted = overWindow && uncountedOnlyOverWindow(compaction, body, modelContextLimit) &&
+            args.sizing.canRetryCount(prefixCandidate);
+        const fallback = overWindow && !uncounted
+            ? undefined : { prefix, routed, ...(uncounted ? { uncounted: true } : {}) };
         if (state.compactNow.has(sessionId))
             return forced("manual", fallback);
         if (prefix.modelContextLimit !== modelContextLimit ||
@@ -3174,6 +3366,16 @@ async function planToolCompaction(args) {
         return { kind: "ride",
             ride: { raw: adopted.routed.raw, turnType: "tool-prefix", sizeHolder: adopted.prefix } };
     }
+    // Another turn that waited for the same preparation installed it meanwhile: plan again on
+    // it (once) rather than compress beside it (Codex r1 P1, release 1.0.33).
+    if (stableLane && !args.replanned && state.stablePrefixes.get(sessionId) !== current) {
+        const waited = compaction.preparedWaitMs;
+        const plan = await planToolCompaction({ ...args, replanned: true,
+            ride: currentLaneRide(state, args.routeKey, body, messages, sessionId, true) });
+        if (waited !== undefined && rec.compaction)
+            rec.compaction.preparedWaitMs = waited;
+        return plan;
+    }
     // Settings current after any wait for a preparation (a /memtree-compact N meanwhile).
     const modeNow = compactionMode(opts, state, sessionId);
     if (modeNow.mode === "off")
@@ -3233,10 +3435,49 @@ async function adoptPreparedPrefix(args) {
     const { state, sessionId } = args;
     const base = state.stablePrefixes.get(sessionId);
     await awaitPreparation(state, sessionId, args.waitMs, args.compaction);
+    // Checked and taken with no await between: two turns resuming together see one owner.
+    while (state.adoptingPrepared.has(sessionId))
+        await awaitAdoption(state, sessionId, args.compaction);
     const entry = state.prepared.get(sessionId);
     if (!entry)
         return undefined;
     state.prepared.discard(sessionId);
+    const release = holdAdoption(state, sessionId);
+    try {
+        return await adoptEntry(args, entry, base);
+    }
+    finally {
+        release();
+    }
+}
+/**
+ * Another turn of the session is adopting its prepared prefix (two turns waited for the same
+ * preparation): wait for it to finish, so this turn plans on the prefix it installs instead of
+ * compressing again (Codex r1 P1, release 1.0.33). Counted as preparation wait, so a human
+ * turn plans again after it.
+ */
+async function awaitAdoption(state, sessionId, compaction) {
+    const adopting = state.adoptingPrepared.get(sessionId);
+    if (!adopting)
+        return;
+    const started = Date.now();
+    await adopting;
+    compaction.preparedWaitMs = (compaction.preparedWaitMs ?? 0) + (Date.now() - started);
+}
+/** Mark the session's prepared prefix as being adopted; the returned function ends it. */
+function holdAdoption(state, sessionId) {
+    let done;
+    const adopting = new Promise((resolve) => { done = resolve; });
+    state.adoptingPrepared.set(sessionId, adopting);
+    return () => {
+        if (state.adoptingPrepared.get(sessionId) === adopting)
+            state.adoptingPrepared.delete(sessionId);
+        done();
+    };
+}
+/** adoptPreparedPrefix's check and install of the entry it took. */
+async function adoptEntry(args, entry, base) {
+    const { state, sessionId } = args;
     const fit = await preparedFit(args, entry);
     // Another request installed a prefix, or `/memtree-compact` asked for its
     // own target, while this one waited or counted: that wins.
@@ -3365,17 +3606,98 @@ function maybePrepareCompression(args) {
     });
     boundedSet(state.preparing, sessionId, pending);
 }
+/**
+ * A subagent's share of its budget from which it is indexed on every tool turn, as the
+ * main thread is; below it, only once, when it ends. 2026-10-30: 29 subagents ran ~32
+ * index jobs each ($45.63 a week for one session), and none came near its budget, so no
+ * subagent tree was ever used to compress. Its tree is still built (at SubagentStop, or
+ * at exit), so MemTree search and the page still find it.
+ */
+const AGENT_PER_TURN_INDEX_SHARE = 0.5;
+/** Subagents whose unsent index is kept; the oldest past this is sent at once. */
+const DEFERRED_AGENT_INDEX_MAX = 64;
+/**
+ * A tool turn's background index call: now on the main thread and for a subagent past
+ * AGENT_PER_TURN_INDEX_SHARE of its budget; otherwise kept, replacing the subagent's
+ * previous one, until it ends (sendDeferredAgentIndex).
+ */
+function indexTurn(args) {
+    const { opts, state, req, sessionId } = args;
+    const send = (mode) => opts.memtree.indexInBackground(args.hash, args.msgsForMemtree, args.modelContextLimit, sessionId, args.clientMeta, transcriptTimesFor(opts, sessionId, agentAttributionId(req)), mode === "final" ? { finalIndex: true } : mode === "flush" ? { force: true } : {});
+    // Only a request with its own agent id (the one SubagentStop names) waits for its end; one
+    // attributed by its parent's id only is indexed per turn as before.
+    const agentId = firstNonEmptyHeader(req, "x-claude-code-agent-id");
+    if (agentId === undefined || sessionId === undefined)
+        return send();
+    const compaction = args.rec.compaction;
+    if (compaction?.estimatedTokens !== undefined &&
+        compaction.estimatedTokens >= compaction.budgetTokens * AGENT_PER_TURN_INDEX_SHARE) {
+        send();
+        // Kept too: its last turns under the text minimum still go at its end (forced).
+        keepDeferredIndex(state, deferredIndexKey(agentId, args.msgsForMemtree), { messages: args.msgsForMemtree, send });
+        return;
+    }
+    // Per agent and conversation: a side request made under the subagent's (or its parent's)
+    // id is another conversation and must not replace the subagent's own.
+    keepDeferredIndex(state, deferredIndexKey(agentId, args.msgsForMemtree), { messages: args.msgsForMemtree, send });
+}
+/** Keep `entry` as its key's newest unsent index call (bounded). */
+function keepDeferredIndex(state, key, entry) {
+    const kept = state.deferredAgentIndexes.get(key);
+    // A rewind or another branch: the kept history is not part of this one, so it goes now.
+    // So does one holding media Claude Code has evicted since (never uploaded otherwise).
+    if (kept && (!extendsHistory(entry.messages, kept.messages) ||
+        losesMedia(kept.messages, entry.messages)))
+        sendDeferredIndex(state, key, "flush");
+    state.deferredAgentIndexes.delete(key);
+    state.deferredAgentIndexes.set(key, entry);
+    while (state.deferredAgentIndexes.size > DEFERRED_AGENT_INDEX_MAX) {
+        const oldest = state.deferredAgentIndexes.keys().next().value;
+        if (oldest === undefined)
+            break;
+        sendDeferredIndex(state, oldest, "flush");
+    }
+}
+/** A deferred index's key: the agent id and its conversation's first message. */
+function deferredIndexKey(agentId, messages) {
+    const first = messages.find((message) => message.role !== "system");
+    return JSON.stringify([agentId, first ? mediaFreeMessageHash(first) : ""]);
+}
+/** A subagent ended: send each of its conversations' kept index call, whatever its size. */
+function sendDeferredAgentIndex(state, agentId) {
+    for (const key of [...state.deferredAgentIndexes.keys()]) {
+        if (JSON.parse(key)[0] === agentId)
+            sendDeferredIndex(state, key, "final");
+    }
+}
+function sendDeferredIndex(state, key, mode) {
+    const kept = state.deferredAgentIndexes.get(key);
+    state.deferredAgentIndexes.delete(key);
+    kept?.send(mode);
+}
+/** At exit: every subagent's kept index calls. */
+function sendDeferredAgentIndexes(state) {
+    for (const key of [...state.deferredAgentIndexes.keys()])
+        sendDeferredIndex(state, key, "final");
+}
 /** The background prepare call and the prefix it yields (maybePrepareCompression). */
 async function prepareInBackground(args) {
-    const { opts, state, body, msgsForMemtree, modelContextLimit, sessionId } = args;
+    const { opts, state, body, msgsForMemtree, modelContextLimit } = args;
     const result = await opts.memtree.compress(args.hash, msgsForMemtree, modelContextLimit, state.backgroundSignal, preparedCompressMeta(args));
     noteServerBudget(state, body.model, modelContextLimit, result);
     if (!result)
         return undefined;
     state.prepared.noteServerAnswer(result.prepared === true);
-    if (result.prepared !== true || !didMemtreeCompress(result) ||
-        !checkCompressedHistory(result, msgsForMemtree).usable)
+    if (result.prepared !== true)
+        return undefined;
+    return preparedFromResult(args, result);
+}
+/** A compressed answer for a session's history, as its prepared prefix (or undefined). */
+function preparedFromResult(args, result) {
+    const { body, sessionId, modelContextLimit } = args;
+    if (!didMemtreeCompress(result) || !checkCompressedHistory(result, args.msgsForMemtree).usable) {
         return undefined;
+    }
     const built = buildCompressedBody(body, result);
     if (!built)
         return undefined;
@@ -3390,11 +3712,83 @@ async function prepareInBackground(args) {
         explicitTarget: args.explicitTarget,
         modelContextLimit,
     };
-    const source = result.memtreeUrl && result.memtreeIndex
+    const source = result.memtreeUrl && result.memtreeIndex && args.linkSeq !== undefined
         ? { url: result.memtreeUrl, index: result.memtreeIndex, seq: args.linkSeq } : undefined;
     return { prefix, atTokens: args.tokens, triggerTokens: args.triggerTokens,
         ...(source ? { source } : {}) };
 }
+/**
+ * Whether a main-thread compaction is a budget crossing at the automatic target where
+ * preparations exist: the turns that may race one (a dropped crossing turn and the next
+ * prompt) are serialized on its lane, as carryFor carries it.
+ */
+function isAutoCrossing(rec, model, modelContextLimit) {
+    const compaction = rec.compaction;
+    return compaction?.mode === "auto" &&
+        (compaction.reason === "budget" || compaction.reason === "prefix-mismatch") &&
+        preparesCompression(model, modelContextLimit);
+}
+/** A main-thread compaction's CarryOver, when its plan has the automatic target. */
+function carryFor(args) {
+    const compaction = args.rec.compaction;
+    // Where prepared prefixes exist (preparesCompression): the turn after rides it. Not a
+    // /memtree-compact (adoption refuses it) nor beside a preparation (the carry would be
+    // refused, its call left running for nothing).
+    if (!args.isMainRequest || args.sessionId === undefined || args.explicitTarget !== false ||
+        args.targetTokens === undefined || compaction?.mode !== "auto" ||
+        // A crossing only: a call the server decides (maybe a passthrough) is not waited for.
+        (compaction.reason !== "budget" && compaction.reason !== "prefix-mismatch") || args.state.compactNow.has(args.sessionId) ||
+        args.state.preparing.has(args.sessionId) || args.state.prepared.isInFlight(args.sessionId) ||
+        args.state.backgroundSignal.aborted ||
+        !preparesCompression(args.body.model, args.modelContextLimit))
+        return undefined;
+    return { body: args.body, messages: args.messages, msgsForMemtree: args.msgsForMemtree,
+        sessionId: args.sessionId, modelContextLimit: args.modelContextLimit,
+        tokens: compaction.estimatedTokens ?? 0, triggerTokens: compaction.budgetTokens,
+        targetTokens: args.targetTokens, explicitTarget: false,
+        ...(args.linkSeq !== undefined ? { linkSeq: args.linkSeq } : {}),
+        base: args.state.stablePrefixes.get(args.sessionId) };
+}
+/**
+ * A main-thread compaction its turn stopped waiting for (its budget ran out) becomes the
+ * session's preparation: it runs on to the long budget, the session's next turn at the
+ * budget waits for it (awaitPreparation) instead of starting another, and rides its
+ * answer as a prepared prefix. Before, each turn gave up on its call and started a new
+ * one beside it: 2026-10-30, eleven 26 MB compressions in ten minutes, each billed, none
+ * used. False when the session already has a preparation in flight (it serves instead).
+ */
+function carryOverCompression(state, carry, pending) {
+    const { sessionId, base } = carry;
+    // A prefix installed since the call started (another turn's) supersedes it already.
+    if (state.backgroundSignal.aborted || state.preparing.has(sessionId) ||
+        state.stablePrefixes.get(sessionId) !== base ||
+        !state.prepared.begin(sessionId, carry.tokens, carry.triggerTokens))
+        return false;
+    const done = pending
+        .then((result) => {
+        // A late answer clears the cooldown; a late failure is no new outage evidence (a
+        // refusal or a slow server's timeout must not arm it, as runBlockingCompression).
+        if (result)
+            noteMemtreeHealth(state, { result, liveHealth: "success" });
+        return result ? preparedFromResult(carry, result) : undefined;
+    })
+        .catch(() => undefined)
+        .then((prepared) => {
+        // A prefix installed meanwhile supersedes it.
+        const current = state.stablePrefixes.get(sessionId) === base;
+        state.prepared.finish(sessionId, current ? prepared : undefined);
+        if (state.preparing.get(sessionId) === done)
+            state.preparing.delete(sessionId);
+    });
+    boundedSet(state.preparing, sessionId, done);
+    return true;
+}
+/** How long a carried compaction may run: the long budget, or its upload's if longer. */
+/** How much longer than its turn's wait a carried call must be allowed to run. */
+const CARRY_MIN_EXTRA_MS = 5_000;
+function carriedBudgetMs(opts, scaledMs) {
+    return Math.min(MAX_LONG_COMPRESS_WAIT_MS, Math.max(opts.memtree.longCompressBudgetMs, scaledMs));
+}
 /** What a prepare call sends: a forced compression to the target, no threshold. */
 function preparedCompressMeta(args) {
     const { opts, body, sessionId, msgsForMemtree, modelContextLimit } = args;
@@ -3813,9 +4207,13 @@ async function runBlockingCompression(args) {
         : undefined;
     const messageTimes = transcriptTimesFor(opts, args.sessionId, args.agentId)?.(msgsForMemtree);
     const compressStarted = Date.now();
-    // The upload is about the request's size: the budget grows with it.
-    const budgetMs = Math.min(args.longBudget ? MAX_LONG_COMPRESS_WAIT_MS : MAX_COMPRESS_WAIT_MS, args.longBudget ? opts.memtree.longCompressBudgetMs
-        : opts.memtree.compressBudgetForBytes(rec.requestBytes));
+    // The upload is about the request's size: the budget grows with it (the long one
+    // too, never below the short one's).
+    const scaledMs = opts.memtree.compressBudgetForBytes(rec.requestBytes);
+    const budgetMs = Math.min(args.longBudget ? MAX_LONG_COMPRESS_WAIT_MS : MAX_COMPRESS_WAIT_MS, args.longBudget ? Math.max(opts.memtree.longCompressBudgetMs, scaledMs) : scaledMs);
+    // Carried only when running on gives it meaningfully more time than this wait.
+    const carry = args.carry && carriedBudgetMs(opts, scaledMs) >= budgetMs + CARRY_MIN_EXTRA_MS
+        ? args.carry : undefined;
     const compressMeta = {
         // Model + tools drive the server's model-based memory budget
         // (e.g. 800k whole-request target for Fable / Opus 5). Omitting
@@ -3844,8 +4242,8 @@ async function runBlockingCompression(args) {
         ...(args.sessionId !== undefined ? { sessionId: args.sessionId } : {}),
         ...(args.clientMeta ? { clientMeta: args.clientMeta } : {}),
         // The deadline this wait uses (the upload-scaled budget included), so the
-        // call and its waiters end together.
-        timeoutMs: budgetMs,
+        // call and its waiters end together; a carried call runs on to the long one.
+        timeoutMs: carry ? Math.max(budgetMs, carriedBudgetMs(opts, scaledMs)) : budgetMs,
     };
     // Sampled BEFORE the call, while it still describes this call: after the
     // await the hash is in the cache regardless of who put it there.
@@ -3854,12 +4252,21 @@ async function runBlockingCompression(args) {
     // Keep foreground work finite even if a transport ignores its abort signal.
     let deadline;
     const maximumWait = Math.min(args.longBudget ? MAX_LONG_COMPRESS_WAIT_MS : MAX_COMPRESS_WAIT_MS, Math.max(1, Number.isFinite(budgetMs) ? budgetMs : 15_000));
+    let settled = false;
+    // A refused carry is not aborted: the call may be shared (in-flight join) with a
+    // request that carried it.
+    const call = opts.memtree.compress(hash, msgsForMemtree, modelContextLimit, args.signal ?? state.shutdownSignal, compressMeta);
+    const settle = () => { settled = true; };
+    call.then(settle, settle);
     const result = await Promise.race([
-        opts.memtree.compress(hash, msgsForMemtree, modelContextLimit, args.signal ?? state.shutdownSignal, compressMeta),
+        call,
         new Promise((resolve) => { deadline = setTimeout(() => resolve(null), maximumWait); }),
     ]).finally(() => { if (deadline)
         clearTimeout(deadline); });
     const compressMs = Date.now() - compressStarted;
+    // Given up on but still running: the session's next turn waits for it, not a new call.
+    const carried = result === null && !settled && carry !== undefined &&
+        carryOverCompression(state, carry, call);
     noteServerBudget(state, body.model, modelContextLimit, result);
     // Sampled at this call's settle, before a concurrent same-request failure of
     // another class can overwrite the complete-key entry.
@@ -3875,16 +4282,20 @@ async function runBlockingCompression(args) {
     // Budget-consumed heuristic: the client maps every failure to null, so a
     // null that took (roughly) the whole abort budget was almost certainly
     // the AbortSignal timeout, not a fast server error.
-    const timedOut = result === null && compressMs >= Math.min(budgetMs, maximumWait);
+    // A few ms of slack: a timer can fire a millisecond early by the wall clock (CI flake).
+    const timedOut = result === null &&
+        compressMs + TIMER_SLACK_MS >= Math.min(budgetMs, maximumWait);
     // A timeout while other compress calls answered (one succeeded after this
     // one started) is this call's size or the server's slow reply, not an outage: it arms no cooldown (2026-10-23:
     // healthy-server timeouts kept the fuse lit and a screenshot turn was refused).
     const othersAnswered = timedOut && (opts.memtree.lastCompressSuccessAt ?? 0) >= compressStarted;
-    const hadLiveFailure = !cached && result === null && failureArming && !othersAnswered;
+    // A carried call has not failed: it is still running (its answer reports its health).
+    const hadLiveFailure = !cached && result === null && failureArming && !othersAnswered && !carried;
     rec.compress = {
         ms: compressMs,
         ok: result !== null,
         timedOut,
+        ...(carried ? { carriedOver: true } : {}),
         ...(!cached && failureStatus === OVER_CONTEXT_STATUS ? { refused: true } : {}),
     };
     return {
@@ -4071,6 +4482,10 @@ async function recoverToolRouteMiss(args) {
     };
     res.once("close", markDownstreamClosed);
     const linkSeq = isMainRequest ? nextMemtreeCallSeq(state) : undefined;
+    const toolCarry = stable ? carryFor({ state, isMainRequest, sessionId, body, messages,
+        msgsForMemtree,
+        modelContextLimit, rec, targetTokens: stable.targetTokens, explicitTarget: stable.explicitTarget,
+        linkSeq }) : undefined;
     let compression;
     try {
         compression = await runBlockingCompression({
@@ -4088,6 +4503,7 @@ async function recoverToolRouteMiss(args) {
             inputCandidate: args.inputCandidate,
             ...(args.compaction ? { compaction: args.compaction } : {}),
             longBudget: args.wholeRefused ? await args.wholeRefused() : false,
+            ...(toolCarry ? { carry: toolCarry } : {}),
         });
     }
     catch {
@@ -4109,9 +4525,11 @@ async function recoverToolRouteMiss(args) {
     if (downstreamClosedDuringCompression ||
         (res.destroyed && !res.writableFinished)) {
         // The MemTree work keeps its cache/index value, but a dead client gets
-        // no Anthropic request and no route.
+        // no Anthropic request and no route. The session's next turn rides it.
         rec.routeRecovery = { conversationBytes, outcome: "client-closed" };
         releaseOwnReservation();
+        if (result && toolCarry)
+            carryOverCompression(state, toolCarry, Promise.resolve(result));
         // Same hazard class as the post-forward fates "upstream-failed" /
         // "client-aborted": no route was installed and the client's identical
         // retry is imminent, so no backoff is set and the attempt mark is
@@ -4131,7 +4549,9 @@ async function recoverToolRouteMiss(args) {
         // submission: its longer independent budget can still warm the index for
         // a later turn. An unpaid key (402, possibly set by this very compress)
         // or a shutting-down proxy gets no retry.
+        // A carried compression still runs on this history (and indexes it): no upload beside it.
         if (!state.shutdownSignal.aborted &&
+            rec.compress?.carriedOver !== true &&
             opts.memtree.paymentRequiredDetail === null &&
             !opts.memtree.keyInvalid // a refused key refuses the index too
         ) {
@@ -4566,8 +4986,8 @@ async function selectForwardCandidate(args) {
         (args.rec.routeLane === "main" && args.opts.toolOutputs
             ? await truncatedToFit(args.rec, policy.sizing, target, args.limits, args.opts.toolOutputs)
             : undefined);
-    const quietDegrade = quietDegrades.get(args.rec);
-    quietDegrades.delete(args.rec);
+    const degraded = degradedNotices.get(args.rec);
+    degradedNotices.delete(args.rec);
     const lateInstall = lateRouteInstalls.get(args.rec);
     if (lateInstall && (!selection || selection.candidate !== target || target === preferred)) {
         lateRouteInstalls.delete(args.rec);
@@ -4595,14 +5015,29 @@ async function selectForwardCandidate(args) {
         args.rec.lateCountRecovery.outcome =
             changed && candidate.kind === "replacement" ? "compressed" : "forwarded";
     delete args.rec.overBudgetForward;
-    if (measurement.tokens > args.limits.budget ||
+    const overBudget = measurement.tokens > args.limits.budget ||
         (measurement.source !== "exact" && candidate.kind === "original" &&
-            measurement.estimatedTokens > args.limits.budget)) {
+            measurement.estimatedTokens > args.limits.budget);
+    if (overBudget) {
         args.rec.overBudgetForward = { reason: measurement.source === "exact"
                 ? "exact-count-fits-window" : measurement.source === "bytes"
                 ? "bytes-fallback-fits-window" : "estimate-fits-window" };
         warnPausedNearWindow(args.state, args.rec, requestSessionId(args.req));
-        quietDegrade?.();
+    }
+    // Uncompressed only when the whole history goes out (or a truncation of
+    // it), not a compressed ride.
+    const whole = candidate.kind === "original" || wholeHistoryCandidates.has(candidate);
+    if (degraded && whole) {
+        // A failed compress's ride that delivery could not send went out whole.
+        if (args.rec.turnType === "followup-prefix") {
+            args.rec.turnType = "followup-degraded";
+            delete args.rec.compaction?.keptPrefix;
+        }
+        if (degraded.eager || overBudget)
+            degraded.warn();
+    }
+    else if (degraded) {
+        delete args.rec.degradedNotice;
     }
     return changed ? candidate.body : intended;
 }
@@ -4670,6 +5105,9 @@ async function truncateCandidate(rec, sizing, base, limits, store) {
         if (!plan)
             return undefined;
         const candidate = sizing.register(Buffer.from(JSON.stringify(plan.body), "utf-8"), "replacement");
+        if (base.kind === "original" || wholeHistoryCandidates.has(base)) {
+            wholeHistoryCandidates.add(candidate);
+        }
         const measurement = await sizing.measure(candidate, limits);
         if (fitsMeasured(measurement, limits) && measurement.tokens <= goal) {
             rec.truncatedToolResult = { originalChars: plan.originalChars,
@@ -4714,6 +5152,40 @@ function lateRecoveryPlan(state, rec, preferred, measured, limits, routeKey) {
     return preferred.kind === "original" && !fitsMeasured(measured, limits)
         ? { tokens: measured.tokens } : undefined;
 }
+/**
+ * Wait (up to `maxMs`, or until `signal` aborts) for the lane's in-flight compression to
+ * end; the milliseconds waited.
+ */
+async function waitForLaneIdle(state, routeKey, maxMs, signal) {
+    const started = Date.now();
+    while (state.toolRecoveryAttemptedLanes.get(routeKey)?.inFlight && !signal.aborted &&
+        !state.shutdownSignal.aborted && !state.backgroundSignal.aborted &&
+        Date.now() - started < maxMs) {
+        // Unref'd: a wait never holds the process open.
+        await new Promise((resolve) => setTimeout(resolve, LANE_WAIT_POLL_MS).unref());
+    }
+    return Date.now() - started;
+}
+/**
+ * The ride the lane's current memory route gives this request, read afresh (after a wait):
+ * undefined when there is none, it does not match this history, or (main lane) a newer
+ * stable prefix superseded it, which the planner then rides itself.
+ */
+function currentLaneRide(state, routeKey, body, messages, sessionId, isMainRequest) {
+    const route = getMemoryRoute(state, routeKey);
+    if (!route)
+        return undefined;
+    if (isMainRequest && sessionId !== undefined &&
+        route.stablePrefix !== state.stablePrefixes.get(sessionId))
+        return undefined;
+    const raw = memoryRoutedToolBody(body, messages, route, state.mainRouteEpoch, sessionId);
+    return raw ? { raw, turnType: "tool-memory", sizeHolder: route.stablePrefix ?? route }
+        : undefined;
+}
+/** Wall-clock slack when judging whether a call ran its whole budget (timers fire early). */
+const TIMER_SLACK_MS = 5;
+/** How often a turn waiting for its lane's compression looks again. */
+const LANE_WAIT_POLL_MS = 100;
 /**
  * Run a delivery-time compression as the lane's in-flight operation, so a
  * concurrent request of the lane neither starts its own (planning sees
@@ -4778,6 +5250,17 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
             : args.state.fallbackFailures.fail(args.routeKey, { awaitingIndex: args.rec.indexBehind === true });
     args.rec.forwardedBytes = 0;
     args.rec.approxInputTokens = 0;
+    // Nothing went out uncompressed: Claude Code retries it (2026-10-28).
+    // A failed compress's ride that could not be sent either (review r2 P3).
+    const refusedRide = args.rec.turnType === "followup-prefix" &&
+        args.rec.compaction?.keptPrefix === true;
+    if (args.rec.turnType === "followup-degraded" || refusedRide) {
+        args.rec.turnType = "followup-refused";
+        delete args.rec.compaction?.keptPrefix;
+    }
+    delete args.rec.degradedNotice;
+    if (unpaid === null && !keyInvalid)
+        noteSlowRetry(args, failure);
     args.state.diagnostics?.record("refusal", {
         status: failure.status, attempt: failure.attempt,
         input_ktokens: Math.round(inputTokens / 1000), budget_ktokens: Math.round(budgetTokens / 1000),
@@ -4804,6 +5287,24 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
         args.state.keyNotice.markShown();
     return false;
 }
+/**
+ * A repeated retryable refusal on the main thread: say once per streak that
+ * MemTree is slow and Claude Code is retrying, unless another notice waits.
+ */
+function noteSlowRetry(args, failure) {
+    const { state, rec } = args;
+    const prompt = noticeContexts.get(rec);
+    // Not for a stale prompt or a closed response, nor an index wait (its 503
+    // says why), nor a final refusal (its own message shows).
+    const canShow = failure.status === 503 && rec.routeLane === "main" &&
+        rec.indexBehind !== true && prompt !== undefined &&
+        prompt.generation === state.mainPromptGeneration && !args.res.destroyed &&
+        !state.notices.hasPending();
+    if (!state.refusalStreaks.refused(args.routeKey, Date.now(), canShow))
+        return;
+    state.notices.queueSuffix(SLOW_RETRY_NOTICE, undefined, prompt.promptId);
+    rec.slowRetryNotice = true;
+}
 /**
  * The refusal text already says MemTree is paused and how to resume, so it
  * counts as the paused notice: the throttle restarts, and this request's
@@ -4879,7 +5380,7 @@ function reachedBudget(compaction) {
  * forced compaction (budget, window, `/memtree-compact`, a rebuilt prefix), a
  * size at or over the budget, or a size nobody measured. A planned fit is
  * provisional: delivery's own sizing can still find the turn over the budget
- * (quietDegrades), since a plan can undercount.
+ * (degradedNotices), since a plan can undercount.
  */
 function compressionNeeded(compaction) {
     if (compaction === undefined || compaction.reason !== undefined)
@@ -4889,10 +5390,15 @@ function compressionNeeded(compaction) {
     return compaction.estimatedTokens >= compaction.budgetTokens;
 }
 /**
- * A degraded turn whose plan fit the budget, so it queued no notice: the
- * notice to queue if delivery's sizing finds it over the budget after all.
+ * A degraded turn's notice, queued by delivery only when the whole request
+ * goes out: at once when planning said it needed compression (`eager`), else
+ * when delivery's sizing finds it over the budget after all.
  */
-const quietDegrades = new WeakMap();
+const degradedNotices = new WeakMap();
+/** Truncations (truncatedToFit) of the whole history: they still run uncompressed. */
+const wholeHistoryCandidates = new WeakSet();
+/** The prompt a request was made for, for notices its refusal may queue. */
+const noticeContexts = new WeakMap();
 /** The paused notice a degraded request queued, until it is refused or settles. */
 const pausedNotices = new WeakMap();
 const changedDeliveryRecords = new WeakSet();
@@ -5580,6 +6086,41 @@ function capture(opts, kind, body) {
         // diagnostics only — never break the proxy path
     }
 }
+/**
+ * The body, or undefined once it passes `limit` bytes (declared or streamed)
+ * or takes longer than HOOK_BODY_TIMEOUT_MS: the rest is drained unkept.
+ */
+function readBodyWithin(req, limit) {
+    return new Promise((resolve) => {
+        const chunks = [];
+        let size = 0;
+        let done = false;
+        const finish = (body) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            if (body === undefined) {
+                chunks.length = 0;
+                req.removeAllListeners("data");
+                req.resume();
+            }
+            resolve(body);
+        };
+        const timer = setTimeout(() => finish(undefined), HOOK_BODY_TIMEOUT_MS);
+        if (Number(req.headers["content-length"] ?? 0) > limit)
+            return finish(undefined);
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > limit)
+                finish(undefined);
+            else
+                chunks.push(chunk);
+        });
+        req.on("end", () => finish(Buffer.concat(chunks)));
+        req.on("error", () => finish(undefined));
+    });
+}
 function readBody(req) {
     return readAll(req);
 }