claude-code-infinite 1.0.16 → 1.0.18

package/dist/proxy.d.ts.map

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

package/dist/proxy.js

@@ -52,9 +52,10 @@ 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 { contextLimitForModel, hasEarlierNonToolUserMessage, isAwaySummaryUserMessage, isLocalBashCommandTurn, isNonToolUserMessage, isToolResultUserMessage, lastNonSystemMessage, messagesWithSystem, modelForMemtree, stripSystemReminderText, } from "./turns.js";
-import { COMPRESSED_NOTICE, compressedTotalsText, DEGRADED_NOTICE, NOT_COMPRESSED_NOTE, recapLinkText, PAYMENT_REQUIRED_NOTICE, SseNoticeRewriter, sanitizeNoticeDetail, stripNoticeBlocks, stripNoticeSystem, } from "./notices.js";
-import { NoticeDeliveryQueue, MEMTREE_COMPACT_COMMAND, MEMTREE_HELP_COMMAND, TRAILER_LABEL, LINK_LABEL, linkLines, terminalSupportsHyperlinks, isMemtreeViewCommand, sessionCommandArgs, parseNoticeHookInput, } from "./hooks.js";
+import { COMPRESSED_NOTICE, compressedTotalsText, DEGRADED_NOTICE, NOT_COMPRESSED_NOTE, recapLinkText, SseNoticeRewriter, stripNoticeBlocks, stripNoticeSystem, } from "./notices.js";
+import { NoticeDeliveryQueue, MEMTREE_COMPACT_COMMAND, MEMTREE_HELP_COMMAND, TRAILER_LABEL, LINK_LABEL, linkLines, urlLine, terminalSupportsHyperlinks, isMemtreeViewCommand, sessionCommandArgs, parseNoticeHookInput, } from "./hooks.js";
 import { hyperlink } from "./payment-gate.js";
+import { PaymentNoticeThrottle, paymentNoticeText } from "./payment-notice.js";
 import { MEMTREE_LINKS_MAX_SESSIONS } from "./memtree-links.js";
 import { describeClaudeCodeRequest, inspectMonitorTranscript, isClaudeCodeSideRequest, memtreeClientMeta, sessionTag, } from "./cc-request.js";
 import { approxTokensFromBytes, mergeUsageFromJsonBody, mergeUsageFromSseEvent, } from "./reqlog.js";
@@ -69,6 +70,8 @@ const HOOK_BODY_LIMIT = 64 * 1024;
 // Long enough that a real outage costs one stall, short enough that a
 // transient blip does not disable recovery for a working session.
 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;
 const SKIP_REQUEST_HEADERS = new Set([
     "host",
     "connection",
@@ -260,7 +263,8 @@ export function startProxy(opts) {
     const acceptedRequests = new Set();
     const shutdownAbort = new AbortController();
     const state = {
-        paymentNoticeShown: false,
+        paymentNotice: new PaymentNoticeThrottle(opts.paymentNoticeIntervalMs),
+        unpaidDetail: () => opts.memtree.paymentRequiredDetail,
         notices: new NoticeDeliveryQueue(),
         mainNoticePending: false,
         mainPromptGeneration: 0,
@@ -277,8 +281,13 @@ export function startProxy(opts) {
         shutdownSignal: shutdownAbort.signal,
         routeInstallFault: opts.routeInstallFault,
         memtreePages: new Map(),
+        memorySourcePages: new Map(),
         memtreeCallSeq: 0,
         memtreeLinkStore: opts.memtreeLinkStore,
+        stablePrefixStore: opts.stablePrefixStore,
+        storedPrefixLookups: new Map(),
+        storageOwner: typeof opts.memtree.storageIdentity === "string"
+            ? opts.memtree.storageIdentity : undefined,
         newestTrees: opts.newestTrees,
         memtreeLinkPlacement: opts.memtreeLinkPlacement ?? "turn",
         compactTargets: new Map(),
@@ -547,7 +556,7 @@ async function handleMemTreeFinder(req, res, opts, upstreamPath, url) {
  */
 async function handleMemTreeCurrent(req, res, opts, state, url) {
     const sessionId = url.searchParams.get("session") || undefined;
-    const page = currentMemtreePage(state, sessionId);
+    const page = currentMemorySourcePage(state, sessionId);
     const id = page ? memtreePageId(page.url) : undefined;
     if (!page || !id) {
         res.writeHead(404, { "content-type": "application/json" });
@@ -579,6 +588,12 @@ async function handleMemTreeCurrent(req, res, opts, state, url) {
     }
 }
 const MEMTREE_CURRENT_PATH = `${MEMTREE_PASSTHROUGH_PREFIX}current`;
+/** The page whose memory is in the prompt, else (none adopted yet) the newest page. */
+function currentMemorySourcePage(state, sessionId) {
+    if (!sessionId)
+        return undefined;
+    return state.memorySourcePages.get(sessionId) ?? currentMemtreePage(state, sessionId);
+}
 function currentMemtreePage(state, sessionId) {
     if (!sessionId)
         return undefined;
@@ -640,7 +655,7 @@ onMainStop) {
         if (parsed.agent_id === undefined && parsed.source === "resume") {
             await state.newestTrees?.settle(parsed.session_id);
         }
-        const line = resumeLinkLine(state, parsed);
+        const line = joinNoticeLines(resumeLinkLine(state, parsed), resumePaymentNotice(state, parsed));
         if (!line) {
             res.writeHead(204);
             res.end();
@@ -659,16 +674,16 @@ onMainStop) {
         // `/memtree-view`: answered here and blocked, so no model turn runs and
         // the prompt never enters the conversation. Not a human turn either, so
         // none of the turn state below is touched.
-        if (parsed.agent_id === undefined) {
-            // `/memtree-view` waits briefly for the newest tree; a prompt only warms it.
-            if (isMemtreeViewCommand(parsed.prompt))
-                await state.newestTrees?.settle(parsed.session_id);
-            else
-                state.newestTrees?.peek(parsed.session_id);
-        }
+        // `/memtree-view` waits briefly for the newest tree; a prompt only warms it.
+        // In a subagent's view the command is answered too (with the main
+        // session's page): unanswered, the plugin's fallback body would run.
+        if (isMemtreeViewCommand(parsed.prompt))
+            await state.newestTrees?.settle(parsed.session_id);
+        else if (parsed.agent_id === undefined)
+            state.newestTrees?.peek(parsed.session_id);
         const commandReply = parsed.agent_id === undefined
             ? sessionCommandReply(state, parsed.session_id, parsed.prompt)
-            : undefined;
+            : subagentCommandReply(state, parsed.session_id, parsed.prompt);
         if (commandReply !== undefined) {
             const body = Buffer.from(JSON.stringify({
                 decision: "block",
@@ -936,7 +951,9 @@ async function handleMessages(req, res, opts, upstream, state) {
         },
     }, state.countTokensCooldowns);
     const requestSizing = new RequestSizing(countSession, opts.countTokens === true);
-    const sizeSlot = wholeRequestSizeSlot(state, isMainRequest, requestSessionKey, requestSizeKey);
+    if (carriesServerTools(body))
+        serverToolRecords.add(rec);
+    const sizeSlot = wholeRequestSizeSlot(state, isMainRequest, requestSessionKey, requestSizeKey, body.model);
     const originalCandidate = requestSizing.register(rawBody, "original", sizeSlot.get());
     const forwardCandidate = requestSizing.register(forwardBody, "original", sizeSlot.get());
     candidateSizeOwners.set(originalCandidate, sizeSlot);
@@ -947,6 +964,9 @@ async function handleMessages(req, res, opts, upstream, state) {
         output: bodyOutputReservation(body),
         recountOutput: outputReservation(undefined, body.max_tokens), // full max_tokens
     });
+    if (isMainRequest && requestSessionKey !== undefined) {
+        adoptStoredPrefix(opts, state, rec, requestSessionKey, body, messages, modelContextLimit);
+    }
     const rides = state.memoryRoutes.has(requestRouteKey) ||
         (isMainRequest && requestSessionKey !== undefined && state.stablePrefixes.has(requestSessionKey));
     if (!rides) {
@@ -1254,6 +1274,7 @@ async function handleMessages(req, res, opts, upstream, state) {
                         ...(plan.fallback ? { fallback: plan.fallback } : {}),
                         retryAtTokens: plan.estimateTokens +
                             Math.floor(plan.budgetTokens * TOOL_COMPACTION_RETRY_BUDGET_RATIO),
+                        ...(plan.fallback ? {} : { wholeRefused: () => wholeRequestRefused(requestSizing, originalCandidate, sizingLimits()) }),
                     }).finally(() => {
                         recoveryAttempt.inFlight = false;
                     }));
@@ -1280,7 +1301,7 @@ async function handleMessages(req, res, opts, upstream, state) {
             if (toolRide)
                 noteRideSize(toolRide.sizeHolder, rec, sendBody.length);
             else {
-                noteWholeRequestSize(state, isMainRequest, toolSessionId, requestSizeKey, rec, sendBody.length);
+                noteWholeRequestSize(state, isMainRequest, toolSessionId, requestSizeKey, body.model, rec, sendBody.length);
             }
         }));
     }
@@ -1390,6 +1411,11 @@ async function handleMessages(req, res, opts, upstream, state) {
                 return;
             }
             const installed = installMemoryRoute(state, requestRouteKey, req, body, messages, compressedBody, routeEpoch, routeDecisionGeneration, stable);
+            // The answer's memory is now what future requests reuse; a ride keeps
+            // the prior source, and a failed or stale forward adopts nothing.
+            if (installed && result && linkSeq !== undefined) {
+                noteMemorySource(state, linkSeq, sessionId, result);
+            }
             commitRouteDecision();
             // Leave this false if installMemoryRoute unexpectedly throws: the
             // delivery-complete fallback then gets one safe retry.
@@ -1514,7 +1540,7 @@ async function handleMessages(req, res, opts, upstream, state) {
     const sendingWhole = () => { requestSendPolicies.get(req).failedRebuild = true; };
     const noteWholeSize = () => {
         if (isMainRequest)
-            notePassthroughSize(state, sessionId, rec, forwardBody.length);
+            notePassthroughSize(state, sessionId, body.model, rec, forwardBody.length);
     };
     // The complete request upload can outlive its downstream subscriber while
     // MemTree compression is in flight. Track that subscriber locally without
@@ -1549,6 +1575,10 @@ async function handleMessages(req, res, opts, upstream, state) {
                 : edge?.kind === "off"
                     ? { compaction: {} }
                     : {}),
+            // 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) &&
+                await wholeRequestRefused(requestSizing, forwardCandidate, sizingLimits()),
         });
     }
     catch {
@@ -1561,7 +1591,7 @@ async function handleMessages(req, res, opts, upstream, state) {
         return logged(forwardRaw(req, res, rawBody, opts, upstream, state.shutdownSignal, rec)
             .then((delivered) => {
             if (isMainRequest)
-                notePassthroughSize(state, sessionId, rec, rawBody.length);
+                notePassthroughSize(state, sessionId, body.model, rec, rawBody.length);
             if (delivered)
                 markMainPromptDelivered();
         }));
@@ -1596,21 +1626,17 @@ async function handleMessages(req, res, opts, upstream, state) {
         // it. Degrade to passthrough and queue a display-only hook notice for a
         // visible turn. The hidden away-summary request deliberately stays quiet.
         // Unpaid key (402, from this compress OR an earlier background index) gets
-        // a payment-specific notice instead of the generic degraded one, at most
-        // once per proxy process after it has actually been delivered.
+        // a payment-specific notice with the subscribe link instead of the generic
+        // degraded one: on the first 402, then at most once per throttle interval
+        // (counted from actual delivery). In between, unpaid turns stay quiet.
         recordTurn(rec, "followup-degraded", forwardBody);
         releaseForOriginalFallback();
         sendingWhole();
         capture(opts, "anthropic-request", forwardBody);
         const paymentDetail = opts.memtree.paymentRequiredDetail;
         const mayQueueNotice = displayForThisTurn && state.mainPromptGeneration === noticePromptGeneration;
-        if (mayQueueNotice && paymentDetail !== null && !state.paymentNoticeShown) {
-            const detailFirstLine = sanitizeNoticeDetail(paymentDetail.split(/[\r\n]/, 1)[0]);
-            state.notices.queueSuffix(detailFirstLine
-                ? `${PAYMENT_REQUIRED_NOTICE}\n${detailFirstLine}`
-                : PAYMENT_REQUIRED_NOTICE, () => {
-                state.paymentNoticeShown = true;
-            }, noticePromptId);
+        if (mayQueueNotice && paymentDetail !== null && state.paymentNotice.due()) {
+            state.notices.queueSuffix(paymentNoticeText(paymentDetail, recapLink(state, sessionId)?.link), () => state.paymentNotice.markShown(), noticePromptId);
         }
         else if (mayQueueNotice && paymentDetail === null) {
             state.notices.queueSuffix(DEGRADED_NOTICE, undefined, noticePromptId);
@@ -1831,6 +1857,25 @@ function resumeLinkLine(state, input) {
     }
     return state.notices.resumeLine(link, sessionId);
 }
+/**
+ * The unpaid-key notice for a resumed main session whose key the server has
+ * already answered 402 for: a resume is a fresh look at the session, so it
+ * says again why it runs uncompressed, regardless of the throttle. The link
+ * line above it already names the session's MemTree page.
+ */
+function resumePaymentNotice(state, input) {
+    if (input.agent_id !== undefined || input.source !== "resume")
+        return undefined;
+    const detail = state.unpaidDetail();
+    if (detail === null)
+        return undefined;
+    state.paymentNotice.markShown();
+    return state.notices.warningText(paymentNoticeText(detail));
+}
+function joinNoticeLines(...parts) {
+    const present = parts.filter((part) => !!part);
+    return present.length ? present.join("\n") : undefined;
+}
 export const MEMTREE_COMPACT_MIN_TOKENS = 20_000;
 /** The reply to a ccc slash command, or undefined for an ordinary prompt. */
 function sessionCommandReply(state, sessionId, prompt) {
@@ -1851,6 +1896,9 @@ function sessionCommandReply(state, sessionId, prompt) {
         state.memoryRoutes.delete(JSON.stringify([sessionId, "main"]));
         state.compactNow.delete(sessionId);
         state.stablePrefixes.delete(sessionId);
+        if (state.storageOwner)
+            state.stablePrefixStore?.delete(sessionId, state.storageOwner);
+        state.storedPrefixLookups.set(sessionId, null);
         return `${TRAILER_LABEL} compaction off: the conversation is sent whole, and MemTree compresses only when it outgrows the model's budget.`;
     }
     if (args === "") {
@@ -1872,6 +1920,22 @@ function sessionCommandReply(state, sessionId, prompt) {
     state.compactNow.add(sessionId);
     return `${TRAILER_LABEL} compacting: your next message is sent compressed to about ${Math.round(target / 1000)}k tokens, ${keep}`;
 }
+export const SUBAGENT_VIEW_NOTE = "(main session's page; subagent pages aren't linked yet)";
+export const SUBAGENT_COMPACT_REPLY = "MemTree compact applies to the main session only.";
+/**
+ * The reply to a ccc slash command typed in a subagent's view. `sessionId` is
+ * the parent session's: the view shows its page, and compaction (per session)
+ * is refused rather than applied to the main conversation from here.
+ */
+function subagentCommandReply(state, sessionId, prompt) {
+    if (isMemtreeViewCommand(prompt)) {
+        return `${memtreeViewLine(state, sessionId)}\n${SUBAGENT_VIEW_NOTE}`;
+    }
+    if (sessionCommandArgs(prompt, MEMTREE_COMPACT_COMMAND) !== undefined) {
+        return `${TRAILER_LABEL} ${SUBAGENT_COMPACT_REPLY}`;
+    }
+    return sessionCommandReply(state, sessionId, prompt);
+}
 /** "50k", "50000", "1.5m" → tokens; undefined when not a positive count. */
 export function parseTokenCount(text) {
     const match = /^(\d+(?:\.\d+)?)\s*([km])?$/i.exec(text.trim());
@@ -1892,13 +1956,16 @@ function memtreeViewLine(state, sessionId) {
         return `${TRAILER_LABEL} no page yet: this session has not been indexed. The link appears once it has.`;
     }
     // Blocked-prompt reasons need an explicit hyperlink in styled terminals.
-    const url = terminalSupportsHyperlinks() ? hyperlink(link.link, link.link) : link.link;
-    const lines = linkLines(LINK_LABEL, url, link.note);
+    const lines = linkLines(LINK_LABEL, viewUrl(link.link), link.note);
     // The memory the agent works from can be an older tree than the newest one.
     return page?.compressed && page.url !== link.link
-        ? `${lines}\n  memory from ${page.url}`
+        ? `${lines}\n${urlLine(viewUrl(page.url), "memory from ")}`
         : lines;
 }
+/** A `/memtree-view` URL: an explicit OSC 8 link where the terminal has them. */
+function viewUrl(url) {
+    return terminalSupportsHyperlinks() ? hyperlink(url, url) : url;
+}
 /**
  * The link shown for a session: its newest completed tree when the server
  * named one (newestTrees), else `source`, the page its memory came from. The
@@ -1947,12 +2014,30 @@ function noteMemtreePage(state, seq, sessionId, result) {
     // A cached newest tree may predate this page; ask again.
     state.newestTrees?.invalidate(sessionId);
 }
-/** Bound optional page state independently of how many sessions use the proxy. */
+/**
+ * Record a compress answer's page as the source of the memory now forwarded
+ * (memorySourcePages), unless a later-submitted call's memory already is.
+ */
+function noteMemorySource(state, seq, sessionId, result) {
+    const url = result.memtreeUrl;
+    const index = result.memtreeIndex;
+    if (!sessionId || !url || !index)
+        return;
+    const latest = state.memorySourcePages.get(sessionId);
+    if (latest && latest.seq >= seq)
+        return;
+    const page = { sessionId, url, index, compressed: didMemtreeCompress(result), seq };
+    rememberPage(state.memorySourcePages, sessionId, page);
+}
 function rememberMemtreePage(state, sessionId, page) {
-    state.memtreePages.delete(sessionId);
-    state.memtreePages.set(sessionId, page);
-    while (state.memtreePages.size > MEMTREE_LINKS_MAX_SESSIONS) {
-        state.memtreePages.delete(state.memtreePages.keys().next().value);
+    rememberPage(state.memtreePages, sessionId, page);
+}
+/** Bound optional page state independently of how many sessions use the proxy. */
+function rememberPage(pages, sessionId, page) {
+    pages.delete(sessionId);
+    pages.set(sessionId, page);
+    while (pages.size > MEMTREE_LINKS_MAX_SESSIONS) {
+        pages.delete(pages.keys().next().value);
     }
 }
 /**
@@ -2085,6 +2170,9 @@ stable) {
         // request carried, and the compressed bytes sent for them. Later requests
         // reuse these bytes unchanged, so the prefix stays a cache read.
         route.stablePrefix = storeStablePrefix(state, sessionId, originalMessages, route, stable);
+        if (route.stablePrefix && key === JSON.stringify([sessionId, "main"])) {
+            persistStablePrefix(state, sessionId, route.stablePrefix);
+        }
     }
     setMemoryRoute(state, key, route);
     state.routeDecisionsLive.set(key, new Set([decisionGeneration]));
@@ -2120,6 +2208,83 @@ function storeStablePrefix(state, sessionId, originalMessages, compressed, stabl
     state.compactNow.delete(sessionId);
     return prefix;
 }
+/**
+ * Persist the main lane's newly adopted prefix with its memory-source page.
+ * Deferred one tick so the page noted right after the install is included,
+ * and skipped when a newer prefix replaced this one meanwhile.
+ */
+function persistStablePrefix(state, sessionId, prefix) {
+    const store = state.stablePrefixStore;
+    const owner = state.storageOwner;
+    if (!store || !owner)
+        return;
+    state.storedPrefixLookups.set(sessionId, null);
+    setImmediate(() => {
+        if (state.stablePrefixes.get(sessionId) !== prefix)
+            return;
+        const page = state.memorySourcePages.get(sessionId);
+        store.save(sessionId, owner, {
+            originalSystemHash: prefix.originalSystemHash,
+            originalPrefixHashes: prefix.originalPrefixHashes,
+            compressedMessages: prefix.compressedMessages,
+            compressedSystem: prefix.compressedSystem,
+            hasCompressedSystem: prefix.hasCompressedSystem,
+            targetTokens: prefix.targetTokens,
+            explicitTarget: prefix.explicitTarget,
+            modelContextLimit: prefix.modelContextLimit,
+        }, page && { url: page.url, index: page.index, compressed: page.compressed });
+    });
+}
+/**
+ * A fresh process's main-lane requests for a session: adopt the session's
+ * persisted prefix when this history passes the checks the in-memory prefix
+ * would (same session, system and covered messages; same window; a routable
+ * body). Only an authoritative main history may discard it: one with the same
+ * system and window, no server tools, and at least the covered length, whose
+ * covered messages differ. Anything else (a side or helper request such as
+ * the Haiku WebSearch call) leaves it for a later request. The disk is read
+ * once per session; the store checks the backend/account owner.
+ */
+function adoptStoredPrefix(opts, state, rec, sessionId, body, messages, modelContextLimit) {
+    const { stablePrefixStore: store, storageOwner: owner } = state;
+    if (!store || !owner || state.stablePrefixes.has(sessionId))
+        return;
+    if (compactionMode(opts, state, sessionId).mode === "off")
+        return;
+    let entry = state.storedPrefixLookups.get(sessionId);
+    if (entry === undefined) {
+        entry = store.load(sessionId, owner) ?? null;
+        boundedSet(state.storedPrefixLookups, sessionId, entry);
+    }
+    if (entry === null)
+        return;
+    const prefix = { sessionId, ...entry.prefix };
+    const verdict = storedPrefixVerdict(body, messages, prefix, modelContextLimit);
+    if (verdict === "defer")
+        return;
+    state.storedPrefixLookups.set(sessionId, null);
+    if (verdict === "discard") {
+        store.delete(sessionId, owner);
+        rec.storedPrefix = "discarded";
+        return;
+    }
+    boundedSet(state.stablePrefixes, sessionId, prefix);
+    if (entry.source && !state.memorySourcePages.has(sessionId)) {
+        rememberPage(state.memorySourcePages, sessionId, { sessionId, ...entry.source, seq: 0 });
+    }
+    rec.storedPrefix = "adopted";
+}
+/** What this request says about a persisted prefix (adoptStoredPrefix). */
+function storedPrefixVerdict(body, messages, prefix, modelContextLimit) {
+    if (carriesServerTools(body) || prefix.modelContextLimit !== modelContextLimit)
+        return "defer";
+    const miss = prefixMismatch(body, messages, prefix, prefix.sessionId, stablePrefixMessageHash);
+    if (miss === null)
+        return prefixRoutedBody(body, messages, prefix) ? "adopt" : "defer";
+    const authoritative = miss === "prefix" &&
+        messages.length >= prefix.originalPrefixHashes.length;
+    return authoritative ? "discard" : "defer";
+}
 /**
  * A fork of the main conversation (the away recap) sent on the main thread's
  * last compressed prefix: that prefix, then the fork's own messages after it.
@@ -2301,11 +2466,31 @@ function notePrefixSize(prefix, rec, bytes) {
     prefix.lastSize = sample;
 }
 /** Record the reported size of a main-thread request forwarded whole. */
-function notePassthroughSize(state, sessionId, rec, bytes) {
+function notePassthroughSize(state, sessionId, model, rec, bytes) {
     const sample = reportedSample(rec, bytes);
     if (sessionId === undefined || sample === undefined)
         return;
-    boundedSet(state.passthroughSizes, sessionId, sample);
+    boundedSet(state.passthroughSizes, sessionSizeKey(sessionId, model), sample);
+}
+/** Key of a main-thread size sample (ProxyState.passthroughSizes). */
+function sessionSizeKey(sessionId, model) {
+    return JSON.stringify([sessionId, typeof model === "string" ? model : null]);
+}
+/** Requests whose reported input includes server-injected tool results. */
+const serverToolRecords = new WeakSet();
+/**
+ * Whether the request offers server tools (web search, web fetch, code
+ * execution, tool search): their results are added to the input server-side,
+ * so the reported size says nothing about the body's bytes.
+ */
+function carriesServerTools(body) {
+    return Array.isArray(body.tools) && body.tools.some((tool) => typeof tool?.type === "string" && SERVER_TOOL_TYPE.test(tool.type));
+}
+const SERVER_TOOL_TYPE = /^(web_search|web_fetch|code_execution|tool_search_tool)_/;
+/** Whether the response reports any server tool use (server_tool_use counts). */
+function usedServerTools(rec) {
+    const used = rec.usage?.server_tool_use;
+    return !!used && Object.values(used).some((count) => count > 0);
 }
 /**
  * The size Anthropic reported for a body of `bytes`, if it can describe one:
@@ -2315,6 +2500,8 @@ function notePassthroughSize(state, sessionId, rec, bytes) {
 function reportedSample(rec, bytes) {
     if (changedDeliveryRecords.has(rec))
         return undefined;
+    if (serverToolRecords.has(rec) || usedServerTools(rec))
+        return undefined;
     const tokens = reportedInputTokens(rec);
     if (tokens === undefined)
         return undefined;
@@ -2334,15 +2521,16 @@ function laneSizeKey(req, routeKey, model) {
     ]);
 }
 /** The session's passthrough size on the main thread, else the lane's. */
-function wholeRequestSizeSlot(state, isMainRequest, sessionId, sizeKey) {
+function wholeRequestSizeSlot(state, isMainRequest, sessionId, sizeKey, model) {
     const main = isMainRequest && sessionId !== undefined;
+    const mainKey = main ? sessionSizeKey(sessionId, model) : "";
     return {
-        get: () => (main ? state.passthroughSizes.get(sessionId) : state.laneSizes.get(sizeKey)),
+        get: () => (main ? state.passthroughSizes.get(mainKey) : state.laneSizes.get(sizeKey)),
         set: (sample) => {
             if (!plausibleSample(sample))
                 return;
             if (main)
-                boundedSet(state.passthroughSizes, sessionId, sample);
+                boundedSet(state.passthroughSizes, mainKey, sample);
             else
                 boundedSet(state.laneSizes, sizeKey, sample, MEMORY_ROUTE_MAX_LANES);
         },
@@ -2354,9 +2542,9 @@ const noteRideSize = notePrefixSize;
  * Record the reported size of a request forwarded whole: the session's
  * passthrough size on the main thread, else its lane's.
  */
-function noteWholeRequestSize(state, isMainRequest, sessionId, sizeKey, rec, bytes) {
+function noteWholeRequestSize(state, isMainRequest, sessionId, sizeKey, model, rec, bytes) {
     if (isMainRequest && sessionId !== undefined) {
-        notePassthroughSize(state, sessionId, rec, bytes);
+        notePassthroughSize(state, sessionId, model, rec, bytes);
         return;
     }
     const sample = reportedSample(rec, bytes);
@@ -2529,7 +2717,7 @@ function planToolCompaction(args) {
     const sample = ride
         ? ride.sizeHolder.lastSize
         : stableLane
-            ? state.passthroughSizes.get(sessionId)
+            ? state.passthroughSizes.get(sessionSizeKey(sessionId, body.model))
             : state.laneSizes.get(args.sizeKey);
     const candidate = args.sizing.register(ride?.raw ?? forwardBody, ride ? "ride" : "original", sample);
     if (ride)
@@ -2921,6 +3109,8 @@ async function runBlockingCompression(args) {
         : undefined;
     const messageTimes = transcriptTimesFor(opts, args.sessionId, args.agentId)?.(msgsForMemtree);
     const compressStarted = Date.now();
+    const budgetMs = args.longBudget
+        ? opts.memtree.longCompressBudgetMs : opts.memtree.compressBudgetMs;
     const compressMeta = {
         // Model + tools drive the server's model-based memory budget
         // (e.g. 800k whole-request target for Fable / Opus 5). Omitting
@@ -2946,6 +3136,7 @@ async function runBlockingCompression(args) {
         ...(messageTimes && Object.keys(messageTimes).length ? { messageTimes } : {}),
         ...(args.sessionId !== undefined ? { sessionId: args.sessionId } : {}),
         ...(args.clientMeta ? { clientMeta: args.clientMeta } : {}),
+        ...(args.longBudget ? { timeoutMs: 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.
@@ -2953,7 +3144,7 @@ async function runBlockingCompression(args) {
     // compress() maps every failure to a resolved null (it never rejects).
     // Keep foreground work finite even if a transport ignores its abort signal.
     let deadline;
-    const maximumWait = Math.min(30_000, Math.max(1, Number.isFinite(opts.memtree.compressBudgetMs) ? opts.memtree.compressBudgetMs : 15_000));
+    const maximumWait = Math.min(args.longBudget ? MAX_LONG_COMPRESS_WAIT_MS : 30_000, Math.max(1, Number.isFinite(budgetMs) ? budgetMs : 15_000));
     const result = await Promise.race([
         opts.memtree.compress(hash, msgsForMemtree, modelContextLimit, state.shutdownSignal, compressMeta),
         new Promise((resolve) => { deadline = setTimeout(() => resolve(null), maximumWait); }),
@@ -2977,7 +3168,7 @@ 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.
-        timedOut: result === null && compressMs >= opts.memtree.compressBudgetMs,
+        timedOut: result === null && compressMs >= budgetMs,
     };
     return {
         result,
@@ -3095,7 +3286,7 @@ async function recoverToolRouteMiss(args) {
         capture(opts, "anthropic-request", args.originalBody);
         return forwardRaw(req, res, args.originalBody, opts, upstream, state.shutdownSignal, rec).then((delivered) => {
             toolForwarding.settle(delivered);
-            noteWholeRequestSize(state, isMainRequest, sessionId, args.sizeKey, rec, args.originalBody.length);
+            noteWholeRequestSize(state, isMainRequest, sessionId, args.sizeKey, body.model, rec, args.originalBody.length);
         });
     };
     // Same downstream-close tracking as the followup path: compression
@@ -3124,6 +3315,7 @@ async function recoverToolRouteMiss(args) {
             sizing: args.sizing,
             inputCandidate: args.inputCandidate,
             ...(args.compaction ? { compaction: args.compaction } : {}),
+            longBudget: args.wholeRefused ? await args.wholeRefused() : false,
         });
     }
     catch {
@@ -3275,6 +3467,10 @@ async function recoverToolRouteMiss(args) {
         activationAttempted = true;
         installedRoute = installed;
         installFate = installed ? "installed" : "stale";
+        // Only an installed route makes this answer's memory the reused one.
+        if (installed && linkSeq !== undefined) {
+            noteMemorySource(state, linkSeq, requestSessionId(req), result);
+        }
         // A tool continuation can arrive after message_stop while this HTTP
         // stream is still draining. Its route is already complete, so a smaller
         // window may buy recovery now. Mutate only this attempt's object: a late
@@ -3539,6 +3735,17 @@ async function selectForwardCandidate(args) {
     }
     return changed ? candidate.body : intended;
 }
+/**
+ * Whether delivery would refuse `candidate` sent whole: it is planned over the
+ * window, and the measurement selection would use (an exact count, else the
+ * same estimate or bytes/4 fallback) does not fit either. Only then is there
+ * no fallback, and only then may a compress take the long budget.
+ */
+async function wholeRequestRefused(sizing, candidate, limits) {
+    if (fitsNative(sizing.plan(candidate).tokens, limits))
+        return false;
+    return !fitsMeasured(await sizing.measure(candidate, limits), limits);
+}
 /** Write the bounded fallback refusal (route-fallback.ts); always false. */
 function refuseWholeRequest(args, inputTokens, budgetTokens) {
     const failure = args.state.fallbackFailures.fail(args.routeKey, { awaitingIndex: args.rec.indexBehind === true });
@@ -3577,6 +3784,9 @@ function noteSelectedCandidateSize(rec) {
     const tokens = reportedInputTokens(rec);
     if (!candidate || !owner || tokens === undefined)
         return;
+    // Server tools' injected results inflate the reported input (reportedSample).
+    if (serverToolRecords.has(rec) || usedServerTools(rec))
+        return;
     const sample = { tokens, forwardedBytes: candidate.body.length };
     if (!plausibleSample(sample))
         return;