claude-code-infinite 1.0.17 → 1.0.19

package/dist/proxy.js

@@ -54,6 +54,7 @@ import { cachedPromptTokenCount, checkCompressedHistory, didMemtreeCompress, ind
 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, } from "./hooks.js";
+import { USAGE_LABEL, USAGE_SIGN_IN_NOTE } from "./usage-link.js";
 import { hyperlink } from "./payment-gate.js";
 import { PaymentNoticeThrottle, paymentNoticeText } from "./payment-notice.js";
 import { MEMTREE_LINKS_MAX_SESSIONS } from "./memtree-links.js";
@@ -70,6 +71,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",
@@ -263,6 +266,7 @@ export function startProxy(opts) {
     const state = {
         paymentNotice: new PaymentNoticeThrottle(opts.paymentNoticeIntervalMs),
         unpaidDetail: () => opts.memtree.paymentRequiredDetail,
+        usageUrl: opts.memtree.usageDashboardUrl,
         notices: new NoticeDeliveryQueue(),
         mainNoticePending: false,
         mainPromptGeneration: 0,
@@ -282,6 +286,10 @@ export function startProxy(opts) {
         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(),
@@ -945,7 +953,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);
@@ -956,6 +966,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) {
@@ -1020,12 +1033,14 @@ async function handleMessages(req, res, opts, upstream, state) {
             // selection considers it together with the original and any replacement.
             return candidate.kind === "ride" || fitsMeasured(measured, sizingLimits());
         },
-        recoverLate: async (buffer, tokens) => {
+        // The ride's bytes are only what failed; recovery always compresses the
+        // ORIGINAL conversation (the one MemTree indexed), never the ride itself.
+        recoverLate: async (_ride, rideTokens) => {
             if (rec.compress || compactionMode(opts, state, requestSessionKey).mode === "off" ||
                 (rec.turnType.startsWith("tool") && opts.toolRouteRecovery === false))
                 return undefined;
-            return recoverLateCount({ opts, state, req, rec, bodyBuffer: buffer,
-                modelContextLimit, clientMeta, sizing: requestSizing });
+            return recoverLateCount({ opts, state, req, rec, body, msgsForMemtree, hash, rideTokens,
+                modelContextLimit, clientMeta, sizing: requestSizing, inputCandidate: forwardCandidate });
         },
         delivered: () => { state.fallbackFailures.succeeded(requestRouteKey); toolForwarding.settle(true); },
     });
@@ -1263,6 +1278,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;
                     }));
@@ -1289,7 +1305,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);
             }
         }));
     }
@@ -1528,7 +1544,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
@@ -1563,6 +1579,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 {
@@ -1575,7 +1595,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();
         }));
@@ -1867,10 +1887,12 @@ function sessionCommandReply(state, sessionId, prompt) {
         return [
             "• /memtree-view · show this session's MemTree page link",
             `• /memtree-compact [tokens | off] · compact this session on your next message (default half the budget, at least ${MEMTREE_COMPACT_MIN_TOKENS / 1000}k)`,
-        ].join("\n");
+            usageLines(state),
+        ].filter((line) => line !== undefined).join("\n");
+    }
+    if (isMemtreeViewCommand(prompt)) {
+        return joinNoticeLines(memtreeViewLine(state, sessionId), usageLines(state)) ?? "";
     }
-    if (isMemtreeViewCommand(prompt))
-        return memtreeViewLine(state, sessionId);
     const args = sessionCommandArgs(prompt, MEMTREE_COMPACT_COMMAND);
     if (args === undefined)
         return undefined;
@@ -1880,6 +1902,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 === "") {
@@ -1910,7 +1935,8 @@ export const SUBAGENT_COMPACT_REPLY = "MemTree compact applies to the main sessi
  */
 function subagentCommandReply(state, sessionId, prompt) {
     if (isMemtreeViewCommand(prompt)) {
-        return `${memtreeViewLine(state, sessionId)}\n${SUBAGENT_VIEW_NOTE}`;
+        const view = `${memtreeViewLine(state, sessionId)}\n${SUBAGENT_VIEW_NOTE}`;
+        return joinNoticeLines(view, usageLines(state)) ?? view;
     }
     if (sessionCommandArgs(prompt, MEMTREE_COMPACT_COMMAND) !== undefined) {
         return `${TRAILER_LABEL} ${SUBAGENT_COMPACT_REPLY}`;
@@ -1943,6 +1969,15 @@ function memtreeViewLine(state, sessionId) {
         ? `${lines}\n${urlLine(viewUrl(page.url), "memory from ")}`
         : lines;
 }
+/**
+ * The usage dashboard link that `/memtree` and `/memtree-view` end with,
+ * formatted like the MemTree link; undefined when the environment has none.
+ */
+function usageLines(state) {
+    return state.usageUrl === undefined
+        ? undefined
+        : linkLines(USAGE_LABEL, viewUrl(state.usageUrl), USAGE_SIGN_IN_NOTE);
+}
 /** A `/memtree-view` URL: an explicit OSC 8 link where the terminal has them. */
 function viewUrl(url) {
     return terminalSupportsHyperlinks() ? hyperlink(url, url) : url;
@@ -2151,6 +2186,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]));
@@ -2186,6 +2224,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.
@@ -2367,11 +2482,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:
@@ -2381,6 +2516,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;
@@ -2400,15 +2537,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);
         },
@@ -2420,9 +2558,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);
@@ -2595,7 +2733,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)
@@ -2987,6 +3125,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
@@ -3012,6 +3152,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.
@@ -3019,7 +3160,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); }),
@@ -3043,7 +3184,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,
@@ -3161,7 +3302,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
@@ -3190,6 +3331,7 @@ async function recoverToolRouteMiss(args) {
             sizing: args.sizing,
             inputCandidate: args.inputCandidate,
             ...(args.compaction ? { compaction: args.compaction } : {}),
+            longBudget: args.wholeRefused ? await args.wholeRefused() : false,
         });
     }
     catch {
@@ -3534,19 +3676,23 @@ async function handleCountTokens(req, res, opts, upstream, state) {
  * picks it up without threading a parameter through each one.
  */
 const recapLinkAppenders = new WeakMap();
-/** One delivery-time retry, against the assembled body whose exact count exceeded the budget. */
+/**
+ * One delivery-time retry after a ride's exact count exceeded the budget. It
+ * compresses the request's ORIGINAL conversation at a tighter target: the
+ * ride carries a memory prefix MemTree never indexed, so compressing it would
+ * miss the tree, index a divergent conversation and bill for it.
+ */
 async function recoverLateCount(args) {
     try {
-        const body = JSON.parse(args.bodyBuffer.toString("utf-8"));
-        const messages = normalizeMessagesForMemtree(messagesWithSystem(body.messages, body.system));
+        const { body, msgsForMemtree: messages } = args;
         const budget = resolveBudget(args.opts, args.state, body.model, args.modelContextLimit).tokens;
+        const target = lateRecoveryTarget(compactionTarget(compactionMode(args.opts, args.state, requestSessionId(args.req)), budget), budget, args.rideTokens);
         const outcome = await runBlockingCompression({
             opts: args.opts, state: args.state, body, msgsForMemtree: messages,
-            hash: MemtreeClient.hashMessages(messages), modelContextLimit: args.modelContextLimit,
+            hash: args.hash, modelContextLimit: args.modelContextLimit,
             rec: args.rec, sessionId: requestSessionId(args.req), agentId: agentAttributionId(args.req),
-            clientMeta: args.clientMeta, sizing: args.sizing,
-            inputCandidate: args.sizing.register(args.bodyBuffer, "ride"),
-            compaction: { target: compactionTarget(compactionMode(args.opts, args.state, requestSessionId(args.req)), budget) },
+            clientMeta: args.clientMeta, sizing: args.sizing, inputCandidate: args.inputCandidate,
+            compaction: { target },
         });
         noteMemtreeHealth(args.state, outcome);
         // Like every compress path: a refusal after a lagging answer waits for
@@ -3565,6 +3711,15 @@ async function recoverLateCount(args) {
         return undefined;
     }
 }
+/**
+ * The ride compressed to `target` still counted `rideTokens` (over the
+ * budget), so the recompression of the original aims proportionally lower.
+ */
+function lateRecoveryTarget(target, budget, rideTokens) {
+    if (!(rideTokens > budget) || !(budget > 0))
+        return target;
+    return Math.max(SERVER_MIN_TARGET_TOKENS, Math.floor(target * budget / rideTokens));
+}
 /** Select a measured eligible body before delivery; refusing one candidate never
  * prevents considering the original or a validated prefix retained by planning. */
 async function selectForwardCandidate(args) {
@@ -3609,6 +3764,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 });
@@ -3647,6 +3813,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;