claude-code-infinite 1.0.32 → 1.0.33

package/dist/proxy.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, SLOW_RETRY_NOTICE, 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 { 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";
@@ -86,8 +86,11 @@ const HOOK_BODY_TIMEOUT_MS = 3_000;
 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",
@@ -347,6 +350,7 @@ 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,
@@ -358,6 +362,8 @@ export function startProxy(opts) {
         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,
@@ -453,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
@@ -463,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) => {
@@ -942,6 +951,7 @@ onlyEvent) {
     }
     if (parsed.hook_event_name === "SubagentStop") {
         state.activeSubagents.delete(parsed.agent_id);
+        sendDeferredAgentIndex(state, parsed.agent_id);
         res.writeHead(204);
         res.end();
         return;
@@ -1409,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,
@@ -1424,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,
@@ -1482,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) {
@@ -1548,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
@@ -1619,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,
@@ -1847,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,
@@ -1871,7 +1937,8 @@ async function handleMessages(req, res, opts, upstream, state) {
             // short budget; with neither, a timeout could only end in a refusal.
             longBudget: !(edge?.kind === "compress" && edge.fallback && !edge.fallback.uncounted) &&
                 await wholeRequestRefused(requestSizing, forwardCandidate, sizingLimits()),
-        });
+            ...(edgeCarry ? { carry: edgeCarry } : {}),
+        }));
     }
     catch {
         const kept = rideOldPrefix(false);
@@ -1911,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());
     }
@@ -2353,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;
@@ -2405,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}`;
     }
@@ -2423,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
@@ -2433,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) {
@@ -3292,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")
@@ -3351,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.
@@ -3483,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;
@@ -3508,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;
@@ -3931,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
@@ -3962,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.
@@ -3972,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.
@@ -3993,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 {
@@ -4189,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({
@@ -4206,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 {
@@ -4227,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
@@ -4249,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
         ) {
@@ -4850,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