claude-code-infinite 1.0.34 → 1.0.36

package/dist/proxy.js

@@ -42,6 +42,9 @@ import { UNKNOWN_INDEX_WAIT_SECONDS } from "./index-wait-413.js";
 import { capCacheBreakpoints } from "./route-cache.js";
 import { PromptAccounting } from "./prompt-accounting.js";
 import { INDEX_WAIT_RETRY_AFTER_SECONDS, RefusalStreaks, RouteFallbackFailures, pausedRefusal, unreachableRefusal } from "./route-fallback.js";
+import { refusalCause, refusalMessage } from "./refusal-reason.js";
+import { AGENT_RESULT_WAITING_LINE, LaneActivity, heavyRequestNoticeText } from "./lane-activity.js";
+import { SlowUploads } from "./slow-upload.js";
 import { freshFailure, networkFailureOf, unreachableMessage, } from "./network-failure.js";
 import { createCountTokensSession, CountTokensCooldowns, plausibleSample, } from "./count-tokens.js";
 import { RequestSizing, estimateRequestTokens, fitsMeasured, fitsNative, outputReservation } from "./request-sizing.js";
@@ -55,7 +58,7 @@ import { CLAUDE_PID_HEADER, HOST_TOKEN_HEADER } from "./host-session.js";
 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, losesMedia, MemtreeClient, modelBudgetTokens, normalizeMessagesForMemtree, serverFlattenedMessages, rawPromptTokenCount, } from "./memtree.js";
+import { cachedPromptTokenCount, checkCompressedHistory, didMemtreeCompress, indexLagEvidence, losesMedia, MemtreeClient, modelBudgetTokens, normalizeMessagesForMemtree, serverFlattenedMessages, rawPromptTokenCount, memoryReadySeconds, unindexedTokenCount, } 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, terminalSupportsHyperlinks, isMemtreeViewCommand, sessionCommandArgs, parseNoticeHookInput, PRECOMPACT_HOOK_PATH } from "./hooks.js";
@@ -71,6 +74,7 @@ import { isSubagentCall, postToolUseOutput, SUBAGENT_RESULT_HINT, subagentMemory
 import { PROJECT_TREES_HOOK_SUFFIX, RESUME_GUIDANCE_HOOK_SUFFIX, SUBAGENT_RESULT_HOOK_SUFFIX, } from "./hooks.js";
 import { conservativeBodyTokens } from "./token-estimate.js";
 import { bodyImages } from "./image-tokens.js";
+import { bodyShape, prefixDigest } from "./body-shape.js";
 import { claudeAuthFromHeaders, upstreamErrorCode } from "./claude-auth.js";
 import { rateLimitFromResponse } from "./rate-limit.js";
 import { approxTokensFromBytes, mergeUsageFromJsonBody, mergeUsageFromSseEvent, } from "./reqlog.js";
@@ -229,6 +233,12 @@ function noteIndexLag(opts, rec, result) {
     if (!indexLagEvidence(result))
         return false;
     rec.indexBehind = true;
+    const etaSeconds = memoryReadySeconds(result);
+    const unindexedTokens = unindexedTokenCount(result);
+    if (etaSeconds !== undefined || unindexedTokens !== undefined) {
+        rec.indexLag = { ...(etaSeconds !== undefined ? { etaSeconds } : {}),
+            ...(unindexedTokens !== undefined ? { unindexedTokens } : {}) };
+    }
     opts.memtree.expireCompressResult?.(result, opts.indexWaitRefreshMs ?? INDEX_WAIT_RETRY_AFTER_SECONDS * 1000);
     return true;
 }
@@ -370,9 +380,11 @@ export function startProxy(opts) {
         mainNoticePending: false,
         mainPromptGeneration: 0,
         promptAccounting: new PromptAccounting(),
+        slowUploads: new SlowUploads(undefined, opts.slowUploadMinBytes),
         fallbackFailures: new RouteFallbackFailures(undefined, opts.indexWaitDeadlineMs, opts.indexWaitMaxMs),
         refusalStreaks: new RefusalStreaks(),
         activeSubagents: new Set(),
+        laneActivity: new LaneActivity(),
         deferredAgentIndexes: new Map(),
         adoptingPrepared: new Map(),
         memoryRoutes: new Map(),
@@ -395,6 +407,8 @@ export function startProxy(opts) {
         storageOwner: typeof opts.memtree.storageIdentity === "string"
             ? opts.memtree.storageIdentity : undefined,
         newestTrees: opts.newestTrees,
+        statusLinks: opts.statusLinks,
+        statusLinkRefresh: opts.statusLinkRefresh === true,
         memtreeLinkPlacement: opts.memtreeLinkPlacement ?? "turn",
         compactTargets: new Map(),
         defaultCompactOff: opts.defaultCompactTarget === null,
@@ -410,6 +424,8 @@ export function startProxy(opts) {
         laneSizes: new Map(),
     };
     installMemtreeLink(state, state.memtreeLinkPlacement);
+    // A newer tree from the background lookup reaches the status line without a turn ending.
+    opts.newestTrees?.onTree((sessionId) => publishStatusLink(state, sessionId));
     state.notices.setFirstTreeIntro(opts.firstTreeIntro ?? null);
     const server = http.createServer((req, res) => {
         const accepted = { req, res };
@@ -1243,6 +1259,7 @@ async function handleMessages(req, res, opts, upstream, state) {
         finally {
             if (rec.totalMs === undefined)
                 rec.totalMs = Date.now() - received;
+            noteForwardedSize(state, rec, requestSessionId(req));
             opts.reqlog?.log(rec);
         }
     };
@@ -1354,6 +1371,11 @@ async function handleMessages(req, res, opts, upstream, state) {
             return link ? recapLinkText(link.link, streamedTextChars, link.note) : undefined;
         });
     }
+    else if (state.statusLinks && state.statusLinkRefresh) {
+        // Keeps the status line's link fresh through long tool runs: answers from the cache,
+        // refreshing in the background at most once a minute (NEWEST_TREE_TTL_MS).
+        state.newestTrees?.peek(requestSessionId(req));
+    }
     const isLocalBashCommand = isLocalBashCommandTurn(messages);
     // CC 2.1.207 identifies agent API calls explicitly. Use that wire-level
     // attribution before lifecycle-hook state so an agent request cannot claim
@@ -1413,6 +1435,7 @@ async function handleMessages(req, res, opts, upstream, state) {
         }
     }
     rec.routeLane = requestRouteLane;
+    noteLaneActivity(state, rec, requestSessionId(req));
     // Stored by the server on the usage row (client_meta): which Claude Code,
     // lane, agent and model produced this request.
     const clientMeta = memtreeClientMeta({
@@ -2773,10 +2796,11 @@ function noteMemtreePage(state, seq, sessionId, result) {
     if (latest && latest.seq >= seq)
         return;
     const compressed = didMemtreeCompress(result);
+    // A cached newest tree may predate this page; ask again (first, so the status line's
+    // link is this page until the lookup answers).
+    state.newestTrees?.invalidate(sessionId);
     rememberMemtreePage(state, sessionId, { sessionId, url, index, compressed, seq });
     state.memtreeLinkStore?.put(sessionId, { url, index, compressed });
-    // A cached newest tree may predate this page; ask again.
-    state.newestTrees?.invalidate(sessionId);
 }
 /**
  * Record a compress answer's page as the source of the memory now forwarded
@@ -2795,6 +2819,13 @@ function noteMemorySource(state, seq, sessionId, result) {
 }
 function rememberMemtreePage(state, sessionId, page) {
     rememberPage(state.memtreePages, sessionId, page);
+    publishStatusLink(state, sessionId);
+}
+/** Write the session's current link (as the trailers would show it) for the status line. */
+function publishStatusLink(state, sessionId) {
+    if (!state.statusLinks)
+        return;
+    state.statusLinks.write(sessionId, currentSessionLink(state, sessionId));
 }
 /** Bound optional page state independently of how many sessions use the proxy. */
 function rememberPage(pages, sessionId, page) {
@@ -3300,8 +3331,16 @@ function reportedSample(rec, sent) {
 }
 /** A size sample of `sent` carrying its inline images (estimateRequestTokens). */
 function sizeSampleOf(sent, tokens, model) {
-    const { imageBytes, imageTokens } = bodyImages(sent, typeof model === "string" ? model : undefined);
-    return { tokens, forwardedBytes: sent.length, imageBytes, imageTokens };
+    const id = typeof model === "string" ? model : undefined;
+    const { imageBytes, imageTokens } = bodyImages(sent, id);
+    return { tokens, forwardedBytes: sent.length, imageBytes, imageTokens, ...sampleLineage(sent, id) };
+}
+/** The sampled body's lineage (body-shape.ts) for anchoredBound; none for a small body. */
+function sampleLineage(sent, model) {
+    const shape = bodyShape(sent);
+    const digest = shape && prefixDigest(shape, shape.messages.length);
+    return shape && digest && model
+        ? { model, messageCount: shape.messages.length, prefixDigest: digest } : {};
 }
 /**
  * Anthropic's input tokens for the body this request forwarded, when its usage
@@ -3966,7 +4005,7 @@ function carryFor(args) {
  * 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) {
+function carryOverCompression(state, carry, pending, bytes = 0) {
     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) ||
@@ -3979,6 +4018,9 @@ function carryOverCompression(state, carry, pending) {
         // refusal or a slow server's timeout must not arm it, as runBlockingCompression).
         if (result)
             noteMemtreeHealth(state, { result, liveHealth: "success" });
+        // Its upload got through: a slow-upload episode is over (Codex r4 P2).
+        if (result)
+            state.slowUploads.settled(sessionId, bytes, "ok");
         return result ? preparedFromResult(carry, result) : undefined;
     })
         .catch(() => undefined)
@@ -3995,6 +4037,14 @@ function carryOverCompression(state, carry, pending) {
 /** 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;
+/**
+ * The long compress budget for an upload of `bytes`: the long budget or the upload's
+ * scaled one if longer, raised after the session's last large upload timed out.
+ */
+function longCompressBudgetFor(opts, state, sessionId, bytes) {
+    const longMs = Math.max(opts.memtree.longCompressBudgetMs, opts.memtree.compressBudgetForBytes(bytes));
+    return state.slowUploads.budgetMs(sessionId, bytes, longMs);
+}
 function carriedBudgetMs(opts, scaledMs) {
     return Math.min(MAX_LONG_COMPRESS_WAIT_MS, Math.max(opts.memtree.longCompressBudgetMs, scaledMs));
 }
@@ -4075,6 +4125,8 @@ const exactSizedRecords = new WeakSet();
  * it is over the window for planning and takes the normal gated compression.
  */
 function noteUncountedBound(record, sizing, candidate, body, modelContextLimit) {
+    if (candidate.anchored)
+        record.anchoredBound = true;
     if (sizing.isExact(candidate)) {
         exactSizedRecords.add(record);
         return;
@@ -4567,7 +4619,11 @@ async function runBlockingCompressionOnce(args) {
     // 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, args.capMs ?? Infinity);
+    // A session whose last large upload ran out of the long budget gets more (slow-upload.ts).
+    const extendedBudget = args.longBudget === true &&
+        state.slowUploads.extended(args.sessionId, rec.requestBytes);
+    const budgetMs = Math.min(args.longBudget ? MAX_LONG_COMPRESS_WAIT_MS : MAX_COMPRESS_WAIT_MS, args.longBudget ? longCompressBudgetFor(opts, state, args.sessionId, rec.requestBytes)
+        : scaledMs, args.capMs ?? Infinity);
     // Carried only when running on gives it meaningfully more time than this wait.
     const carry = args.carry && args.capMs === undefined &&
         carriedBudgetMs(opts, scaledMs) >= budgetMs + CARRY_MIN_EXTRA_MS ? args.carry : undefined;
@@ -4623,7 +4679,7 @@ async function runBlockingCompressionOnce(args) {
     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);
+        carryOverCompression(state, carry, call, rec.requestBytes);
     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.
@@ -4650,10 +4706,21 @@ async function runBlockingCompressionOnce(args) {
     const othersAnswered = timedOut && (opts.memtree.lastCompressSuccessAt ?? 0) >= compressStarted;
     // A carried call has not failed: it is still running (its answer reports its health).
     const hadLiveFailure = !cached && result === null && failureArming && !othersAnswered && !carried;
+    // Only a whole long budget spent is the upload's slowness (a hold's cap is not).
+    // A large upload's live answer (any budget, not a cache hit) ends a slow-upload episode.
+    if (result !== null && !cached)
+        state.slowUploads.settled(args.sessionId, rec.requestBytes, "ok");
+    const uploadTimeout = result === null && args.longBudget === true &&
+        args.capMs === undefined && !carried &&
+        state.slowUploads.settled(args.sessionId, rec.requestBytes, timedOut ? "timeout" : "other");
     rec.compress = {
         ms: compressMs,
         ok: result !== null,
         timedOut,
+        budgetMs,
+        ...(extendedBudget ? { extendedBudget: true } : {}),
+        ...(uploadTimeout ? { uploadTimeout: true } : {}),
+        ...(failureStatus !== undefined ? { status: failureStatus } : {}),
         ...(carried ? { carriedOver: true } : {}),
         // A joined call's indexing 413 is MemTree's refusal of this request too.
         ...((!cached && failureStatus === OVER_CONTEXT_STATUS) || indexWaitSeconds !== undefined
@@ -5175,7 +5242,23 @@ async function recoverToolRouteMiss(args) {
 function recordTurn(rec, turnType, forwardBody) {
     rec.turnType = turnType;
     rec.forwardedBytes = forwardBody.length;
-    rec.approxInputTokens = approxTokensFromBytes(forwardBody.length);
+    rec.approxInputTokens = approxBodyTokens(forwardBody, rec.model);
+    forwardedImageBytes.set(rec, bodyImages(forwardBody, typeof rec.model === "string" ? rec.model : undefined).imageBytes);
+}
+/** The forwarded body's inline image bytes (recordTurn), for the heavy-request notice. */
+const forwardedImageBytes = new WeakMap();
+/** What this request uploaded to Anthropic, for the session's heavy-request notice. */
+function noteForwardedSize(state, rec, sessionId) {
+    const bytes = rec.forwardedBytes ?? 0;
+    if (bytes > 0) {
+        state.laneActivity.sent(sessionId, { bytes, imageBytes: forwardedImageBytes.get(rec) ?? 0 });
+    }
+}
+/** A body's text at bytes/4 plus its inline images at their visual tokens (log only):
+ * bytes/4 alone logged a 22 MB contact-sheet lane at 5.5M tokens (Anthropic: 491k). */
+function approxBodyTokens(body, model) {
+    const images = bodyImages(body, typeof model === "string" ? model : undefined);
+    return approxTokensFromBytes(body.length - images.imageBytes) + images.imageTokens;
 }
 function headerText(headers, name) {
     const value = headers[name];
@@ -5617,6 +5700,30 @@ async function wholeRequestRefused(sizing, candidate, limits) {
         return false;
     return !fitsMeasured(await sizing.measure(candidate, limits), limits);
 }
+/** What explains refusing this request (refusal-reason.ts), from its record and the lane. */
+function refusalCauseFor(args, inputTokens) {
+    const { state, rec } = args;
+    const sessionId = requestSessionId(args.req);
+    const bytes = rec.requestBytes;
+    // After a slow upload: what the session's next long-budget try gets.
+    const nextCompressBudgetMs = rec.compress?.uploadTimeout
+        ? Math.min(MAX_LONG_COMPRESS_WAIT_MS, longCompressBudgetFor(args.opts, state, sessionId, bytes))
+        : undefined;
+    // This request's own 413, then its own answer's ETA, then the lane's last stated time.
+    const known = (seconds) => seconds === UNKNOWN_INDEX_WAIT_SECONDS ? undefined : seconds;
+    return refusalCause(rec, {
+        inputTokens, modelContextLimit: args.modelContextLimit,
+        // The 60 s stand-in for an indexing 413 that stated no time is no estimate.
+        indexSecondsLeft: known(activeIndexWaits.get(rec)) ?? rec.indexLag?.etaSeconds ??
+            known(state.fallbackFailures.indexSecondsLeft(args.routeKey)),
+        nextCompressBudgetMs,
+    });
+}
+/** The session's MemTree page (refusal line, status line), as the trailers would show it. */
+function currentSessionLink(state, sessionId) {
+    return sessionId === undefined ? undefined
+        : sessionLink(state, sessionId, currentMemtreePage(state, sessionId))?.link;
+}
 /** Write the bounded fallback refusal (route-fallback.ts); always false. */
 function refuseWholeRequest(args, inputTokens, budgetTokens) {
     // A refused key or a paused one: a retry cannot fix either, so it is final at once.
@@ -5624,11 +5731,14 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
     const unpaid = keyInvalid ? null : args.state.pausedDetail();
     // MemTree can't be reached: nothing says the request can't fit, so no strike (2026-11-09).
     const offline = keyInvalid || unpaid !== null ? undefined : unreachableNow(args.state, args.rec);
+    const cause = keyInvalid || unpaid !== null || offline ? undefined
+        : refusalCauseFor(args, inputTokens);
     const failure = keyInvalid ? pausedRefusal(keyInvalidRefusalMessage(args.state.keyPageUrl))
         : unpaid !== null ? pausedRefusal(pausedRefusalMessage(unpaid))
             : offline ? unreachableRefusal(offline.message)
                 : args.state.fallbackFailures.fail(args.routeKey, { awaitingIndex: args.rec.indexBehind === true,
-                    indexSecondsLeft: activeIndexWaits.get(args.rec) });
+                    indexSecondsLeft: activeIndexWaits.get(args.rec),
+                    refusalMessage: refusalMessage(cause, currentSessionLink(args.state, requestSessionId(args.req)), agentResultNote(args)) });
     args.rec.forwardedBytes = 0;
     args.rec.approxInputTokens = 0;
     // Nothing went out uncompressed: Claude Code retries it (2026-10-28).
@@ -5655,6 +5765,7 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
         budgetTokens, modelContextLimit: args.modelContextLimit, ...(unpaid !== null ? { paused: true } : {}),
         ...(keyInvalid ? { keyInvalid: true } : {}),
         ...(offline ? { unreachable: offline.what } : {}),
+        ...(cause && failure.status === 400 ? { cause: cause.kind } : {}),
     };
     if (unpaid !== null || keyInvalid)
         cancelPausedNotice(args.state, args.rec);
@@ -5670,6 +5781,17 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
         args.state.keyNotice.markShown();
     return false;
 }
+/**
+ * A main-lane refusal while an agent lane of this session was recently active: a
+ * background agent's finished result reaches the main session only as part of its
+ * next turn, so say it may be waiting (2026-11-13: a refused main lane held one back).
+ */
+function agentResultNote(args) {
+    // This session's own agent traffic only: activeSubagents is process-wide (review r1 P3).
+    return args.rec.routeLane === "main" &&
+        args.state.laneActivity.agentRecent(requestSessionId(args.req))
+        ? AGENT_RESULT_WAITING_LINE : undefined;
+}
 /** Requests held back by a lane backoff whose attempt MemTree answered (unreachableNow). */
 const answeredBackoffs = new WeakSet();
 /**
@@ -5701,6 +5823,25 @@ function unreachableNow(state, rec) {
     return { message: unreachableMessage(memtree, anthropic),
         what: anthropic ? "internet" : "memtree" };
 }
+/**
+ * Note this request's lane (lane-activity.ts) and, on a main-lane request of the current
+ * prompt, queue the session's one heavy-request warning when an earlier upload passed the
+ * size and no other notice waits. It is the lowest priority (otherNoticePending): any
+ * other notice may replace it, which leaves it due for a later turn.
+ */
+function noteLaneActivity(state, rec, sessionId) {
+    state.laneActivity.seen(sessionId, rec.routeLane);
+    const heavy = state.laneActivity.heavyDue(sessionId);
+    const prompt = noticeContexts.get(rec);
+    if (!heavy || sessionId === undefined || rec.routeLane !== "main" || prompt === undefined ||
+        prompt.generation !== state.mainPromptGeneration || state.notices.hasPending())
+        return;
+    state.heavyNotice = state.notices.queueSuffix(heavyRequestNoticeText(heavy), () => state.laneActivity.markWarned(sessionId), prompt.promptId);
+}
+/** Whether a notice other than the heavy-request one (the lowest priority) waits. */
+function otherNoticePending(state, promptId) {
+    return state.notices.hasPending(promptId) && !state.notices.pendingIs(state.heavyNotice);
+}
 /**
  * A repeated retryable refusal on the main thread: say once per streak that
  * MemTree is slow and Claude Code is retrying, unless another notice waits.
@@ -5713,7 +5854,7 @@ function noteSlowRetry(args, failure) {
     const canShow = failure.status === 503 && rec.routeLane === "main" &&
         rec.indexBehind !== true && prompt !== undefined &&
         prompt.generation === state.mainPromptGeneration && !args.res.destroyed &&
-        !state.notices.hasPending();
+        !otherNoticePending(state);
     if (!state.refusalStreaks.refused(args.routeKey, Date.now(), canShow))
         return;
     state.notices.queueSuffix(SLOW_RETRY_NOTICE, undefined, prompt.promptId);
@@ -5764,7 +5905,7 @@ function warnPausedNearWindow(state, rec, sessionId) {
     // Never replace another queued notice (or this one again): a later request tries.
     if (detail === null || rec.routeLane !== "main" || sessionId === undefined ||
         pausedNotices.has(rec) || nearWindowWarned(state, sessionId) ||
-        state.notices.hasPending(state.mainPromptId))
+        otherNoticePending(state, state.mainPromptId))
         return;
     state.nearWindowNotice = state.notices.queueSuffix(paymentNoticeText(detail, undefined, { overBudget: true }), () => {
         state.paymentNotice.markShown();