claude-code-infinite 1.0.30 → 1.0.32

package/dist/proxy.js

@@ -40,7 +40,7 @@
  */
 import { capCacheBreakpoints } from "./route-cache.js";
 import { PromptAccounting } from "./prompt-accounting.js";
-import { INDEX_WAIT_RETRY_AFTER_SECONDS, RouteFallbackFailures, pausedRefusal } from "./route-fallback.js";
+import { INDEX_WAIT_RETRY_AFTER_SECONDS, RefusalStreaks, RouteFallbackFailures, pausedRefusal } from "./route-fallback.js";
 import { createCountTokensSession, CountTokensCooldowns, plausibleSample, } from "./count-tokens.js";
 import { RequestSizing, estimateRequestTokens, fitsMeasured, fitsNative, outputReservation } from "./request-sizing.js";
 import { extendsHistory, mediaFreeMessageHash, prefixIdentity, prefixMessageMatches, } from "./route-identity.js";
@@ -54,15 +54,18 @@ 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, 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 { 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 { USAGE_LABEL, USAGE_SIGN_IN_NOTE } from "./usage-link.js";
 import { hyperlink } from "./payment-gate.js";
 import { keyInvalidNoticeText, keyInvalidRefusalMessage } from "./key-status.js";
+import { KEY_INVALID_KIND, ModelContextNotices, PAUSED_KIND, keyInvalidModelContext, lastToldKindInFile, pausedModelContext } from "./model-context.js";
 import { PaymentNoticeThrottle, pausedCompactionText, pausedRefusalMessage, paymentNoticeText, subscribeUrlFromDetail } from "./payment-notice.js";
 import { MEMTREE_LINKS_MAX_SESSIONS } from "./memtree-links.js";
 import { describeClaudeCodeRequest, inspectMonitorTranscript, knownSideRequestKind, transcriptWarning, isClaudeCodeSideRequest, memtreeClientMeta, sessionTag, } from "./cc-request.js";
 import { isResumableSessionId } from "./resume-hint.js";
+import { subagentMemoryHintText, subagentStartOutput, } from "./subagent-hint.js";
+import { RESUME_GUIDANCE_HOOK_SUFFIX } from "./hooks.js";
 import { conservativeBodyTokens } from "./token-estimate.js";
 import { bodyImages } from "./image-tokens.js";
 import { claudeAuthFromHeaders, upstreamErrorCode } from "./claude-auth.js";
@@ -70,6 +73,8 @@ import { rateLimitFromResponse } from "./rate-limit.js";
 import { approxTokensFromBytes, mergeUsageFromJsonBody, mergeUsageFromSseEvent, } from "./reqlog.js";
 const DEFAULT_UPSTREAM = "https://api.anthropic.com";
 const HOOK_BODY_LIMIT = 64 * 1024;
+/** A hook body still arriving after this is dropped (the hook itself waits 5 s). */
+const HOOK_BODY_TIMEOUT_MS = 3_000;
 // After a recovery attempt returns null (MemTree down, 5xx, or a burned
 // timeout budget), suppress the blocking attempt for this long, across every
 // lane. A lane's own growth backoff alone would let each over-budget tool turn
@@ -336,16 +341,22 @@ export function startProxy(opts) {
         pausedNearWindowWarned: new Set(),
         unpaidDetail: () => opts.memtree.paymentRequiredDetail,
         pausedDetail: () => opts.memtree.pausedDetail,
+        pausedReason: () => opts.memtree.pausedReason,
+        memtreeAnswering: () => opts.memtree.answering,
+        modelNotices: new ModelContextNotices(),
         usageUrl: opts.memtree.usageDashboardUrl,
         sessionStartNotice: opts.sessionStartNotice,
         promptSubmitNotice: opts.promptSubmitNotice,
         projectTrees: opts.projectTrees,
+        subagentHint: opts.subagentHint,
+        resumeGuidance: opts.resumeGuidance,
         diagnostics: opts.diagnostics,
         notices: new NoticeDeliveryQueue(),
         mainNoticePending: false,
         mainPromptGeneration: 0,
         promptAccounting: new PromptAccounting(),
         fallbackFailures: new RouteFallbackFailures(undefined, opts.indexWaitDeadlineMs),
+        refusalStreaks: new RefusalStreaks(),
         activeSubagents: new Set(),
         memoryRoutes: new Map(),
         mainRouteEpoch: 0,
@@ -489,6 +500,12 @@ async function handleRequest(req, res, opts, upstream, state, hookPath) {
         res.end(JSON.stringify({ detail: "The ccc proxy only serves programs on this machine" }));
         return;
     }
+    if (url.pathname === PRECOMPACT_HOOK_PATH) {
+        return handleNoticeHook(req, res, state, opts.reqlog, undefined, "PreCompact");
+    }
+    if (url.pathname === `${hookPath}${RESUME_GUIDANCE_HOOK_SUFFIX}`) {
+        return handleResumeGuidanceHook(req, res, state);
+    }
     if (url.pathname === hookPath) {
         return handleNoticeHook(req, res, state, opts.reqlog, (sessionId) => opts.memtree.scheduleFinalIndex(sessionId, (signal) => opts.transcriptUsage?.finalReplyAsync
             ? opts.transcriptUsage.finalReplyAsync(sessionId, signal)
@@ -720,10 +737,45 @@ function noteMainSessionStart(state, source, sessionId) {
         state.resumableMainSession = undefined;
     }
 }
+/**
+ * SessionStart on its own hook (resume-guidance.ts): only the current MemTree
+ * guidance, so Claude Code sees it as one context of its own and adds an
+ * identical one only once. Never fails the hook: anything unexpected is 204.
+ */
+async function handleResumeGuidanceHook(req, res, state) {
+    const raw = req.method === "POST" ? await readBodyWithin(req, HOOK_BODY_LIMIT) : undefined;
+    if (req.method !== "POST")
+        req.resume();
+    let input = null;
+    try {
+        if (raw !== undefined && raw.length > 0) {
+            input = parseNoticeHookInput(JSON.parse(raw.toString("utf-8")));
+        }
+    }
+    catch {
+        input = null;
+    }
+    const context = input?.hook_event_name === "SessionStart"
+        ? await resumeGuidanceContext(state, input) : undefined;
+    if (!context) {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    const body = Buffer.from(JSON.stringify(sessionStartOutput(undefined, context)), "utf-8");
+    res.writeHead(200, {
+        "content-type": "application/json",
+        "content-length": String(body.length),
+        "cache-control": "no-store",
+    });
+    res.end(body);
+}
 /** Serve only validated Claude hook POSTs on the randomized localhost path. */
 async function handleNoticeHook(req, res, state, reqlog, 
 /** A main-lane turn ended: the session may be over (its final index). */
-onMainStop) {
+onMainStop, 
+/** The only event this path takes (the token-free PreCompact path). */
+onlyEvent) {
     if (req.method !== "POST") {
         res.writeHead(405, { allow: "POST" });
         res.end();
@@ -757,19 +809,32 @@ onMainStop) {
         res.end();
         return;
     }
+    if (onlyEvent !== undefined && parsed.hook_event_name !== onlyEvent) {
+        res.writeHead(403);
+        res.end();
+        return;
+    }
     if (parsed.hook_event_name === "SessionStart") {
         if (parsed.agent_id === undefined) {
             recordSessionStart(state, parsed.source);
             noteMainSessionStart(state, parsed.source, parsed.session_id);
+            // Claude Code's compaction dropped any MemTree notice from the transcript.
+            if (parsed.source === "compact")
+                state.modelNotices.forget(parsed.session_id);
         }
         // Earlier trees in this project: asked now, so its wait overlaps the resume's.
         const contextPromise = projectTreesContext(state.projectTrees, parsed);
+        // A resumed or forked history may carry notices an earlier process gave.
+        const restored = parsed.agent_id === undefined &&
+            (parsed.source === "resume" || parsed.source === "fork")
+            ? restoreModelNotices(state, parsed) : Promise.resolve();
         // A resume waits briefly for the newest tree; a fresh session has none to wait for.
         if (parsed.agent_id === undefined && parsed.source === "resume") {
             await state.newestTrees?.settle(parsed.session_id);
         }
         const line = joinNoticeLines(resumeLinkLine(state, parsed), resumePaymentNotice(state, parsed), extraSessionStartLine(state.sessionStartNotice, parsed));
         const context = await contextPromise;
+        await restored;
         if (!line && !context) {
             res.writeHead(204);
             res.end();
@@ -784,6 +849,25 @@ onMainStop) {
         res.end(body);
         return;
     }
+    if (parsed.hook_event_name === "PreCompact") {
+        // A typed /compact while MemTree compresses: say why it isn't needed, once.
+        const reason = parsed.agent_id === undefined && parsed.trigger === "manual"
+            ? state.modelNotices.blockCompact(parsed.session_id, memtreeWorking(state))
+            : undefined;
+        if (reason === undefined) {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        const body = Buffer.from(JSON.stringify({ decision: "block", reason }), "utf-8");
+        res.writeHead(200, {
+            "content-type": "application/json",
+            "content-length": String(body.length),
+            "cache-control": "no-store",
+        });
+        res.end(body);
+        return;
+    }
     if (parsed.hook_event_name === "UserPromptSubmit") {
         // `/memtree-view`: answered here and blocked, so no model turn runs and
         // the prompt never enters the conversation. Not a human turn either, so
@@ -822,8 +906,11 @@ onMainStop) {
             recordMainPromptNotice(state, parsed.prompt_id, parsed.prompt);
         }
         const line = parsed.agent_id === undefined ? promptSubmitLine(state) : undefined;
-        if (line) {
-            const body = Buffer.from(JSON.stringify({ systemMessage: line }), "utf-8");
+        const context = parsed.agent_id === undefined
+            ? state.modelNotices.next(parsed.session_id, currentModelNotice(state))
+            : undefined;
+        if (line || context) {
+            const body = Buffer.from(JSON.stringify(promptSubmitOutput(line, context)), "utf-8");
             res.writeHead(200, {
                 "content-type": "application/json",
                 "content-length": String(body.length),
@@ -838,8 +925,19 @@ onMainStop) {
     }
     if (parsed.hook_event_name === "SubagentStart") {
         state.activeSubagents.add(parsed.agent_id);
-        res.writeHead(204);
-        res.end();
+        const hint = await subagentHintContext(state, parsed.session_id);
+        if (hint === undefined) {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        const body = Buffer.from(JSON.stringify(subagentStartOutput(hint)), "utf-8");
+        res.writeHead(200, {
+            "content-type": "application/json",
+            "content-length": String(body.length),
+            "cache-control": "no-store",
+        });
+        res.end(body);
         return;
     }
     if (parsed.hook_event_name === "SubagentStop") {
@@ -937,6 +1035,8 @@ async function handleMessages(req, res, opts, upstream, state) {
         requestBytes: rawBody.length,
         claudeAuth: claudeAuthFromHeaders(req.headers),
     };
+    // The prompt this request was made for, before any await (Codex r2 P2).
+    noticeContexts.set(rec, { promptId: state.mainPromptId, generation: state.mainPromptGeneration });
     const logged = async (forward) => {
         try {
             await forward;
@@ -1176,7 +1276,11 @@ async function handleMessages(req, res, opts, upstream, state) {
                     lane: isAwaySummary ? "away" : requestRouteLane === "main" ? "main" : "other" },
                 ...(target !== undefined ? { target } : {}) });
         },
-        delivered: () => { state.fallbackFailures.succeeded(requestRouteKey); toolForwarding.settle(true); },
+        delivered: () => {
+            state.fallbackFailures.succeeded(requestRouteKey);
+            state.refusalStreaks.delivered(requestRouteKey);
+            toolForwarding.settle(true);
+        },
     });
     const rawMsgsForMemtree = messagesWithSystem(messages, body.system);
     const msgsForMemtree = normalizeMessagesForMemtree(rawMsgsForMemtree);
@@ -1765,7 +1869,7 @@ async function handleMessages(req, res, opts, upstream, state) {
                     : {}),
             // Riding the old prefix, or sending a raw request that fits, keeps the
             // short budget; with neither, a timeout could only end in a refusal.
-            longBudget: !(edge?.kind === "compress" && edge.fallback) &&
+            longBudget: !(edge?.kind === "compress" && edge.fallback && !edge.fallback.uncounted) &&
                 await wholeRequestRefused(requestSizing, forwardCandidate, sizingLimits()),
         });
     }
@@ -1814,6 +1918,28 @@ async function handleMessages(req, res, opts, upstream, state) {
     // Each forwarder installs its own close listener synchronously, so this is
     // an event-loop-atomic handoff of downstream-close ownership.
     if (!result) {
+        const paymentDetail = opts.memtree.paymentRequiredDetail;
+        const mayQueueNotice = displayForThisTurn && state.mainPromptGeneration === noticePromptGeneration;
+        if (mayQueueNotice && paymentDetail === null && !state.keyInvalid()) {
+            // Under the budget the whole request is what compression would have
+            // sent: the turn is not degraded, so the failure stays in the logs.
+            // Delivery decides the rest (selectForwardCandidate): only a whole
+            // history actually sent warns. A refusal (Claude Code retries it) or a
+            // ride on a compressed prefix did not run uncompressed (2026-10-28).
+            const eager = compressionNeeded(rec.compaction);
+            // Delivery sizes the request again (an exact count, else a
+            // conservative bound): a planned fit it finds over the budget warns then.
+            if (!eager)
+                rec.degradedNotice = "quiet-under-budget";
+            degradedNotices.set(rec, { eager, warn: () => {
+                    // A 402 or refused key meanwhile keeps its own, actionable notice (Codex r2 P2).
+                    if (state.mainPromptGeneration !== noticePromptGeneration ||
+                        opts.memtree.paymentRequiredDetail !== null || state.keyInvalid())
+                        return;
+                    state.notices.queueSuffix(DEGRADED_NOTICE, undefined, noticePromptId);
+                    rec.degradedNotice = "shown";
+                } });
+        }
         const kept = rideOldPrefix(false);
         if (kept)
             return kept;
@@ -1828,8 +1954,6 @@ async function handleMessages(req, res, opts, upstream, state) {
         releaseForOriginalFallback();
         sendingWhole();
         capture(opts, "anthropic-request", forwardBody);
-        const paymentDetail = opts.memtree.paymentRequiredDetail;
-        const mayQueueNotice = displayForThisTurn && state.mainPromptGeneration === noticePromptGeneration;
         const overBudget = reachedBudget(rec.compaction);
         if (state.keyInvalid()) {
             // A refused key (401/403) says why MemTree is off and how to fix it;
@@ -1853,26 +1977,6 @@ async function handleMessages(req, res, opts, upstream, state) {
             if (overBudget)
                 state.nearWindowNotice = handle;
         }
-        else if (mayQueueNotice && paymentDetail === null) {
-            // Under the budget the whole request is what compression would have
-            // sent: the turn is not degraded, so the failure stays in the logs.
-            const warn = () => {
-                state.notices.queueSuffix(DEGRADED_NOTICE, undefined, noticePromptId);
-                rec.degradedNotice = "shown";
-            };
-            if (compressionNeeded(rec.compaction)) {
-                warn();
-            }
-            else {
-                // Delivery sizes the request again (an exact count, else a
-                // conservative bound): a turn it finds over the budget warns then.
-                rec.degradedNotice = "quiet-under-budget";
-                quietDegrades.set(rec, () => {
-                    if (state.mainPromptGeneration === noticePromptGeneration)
-                        warn();
-                });
-            }
-        }
         return logged(forwardRaw(req, res, forwardBody, opts, upstream, state.shutdownSignal, rec).then((delivered) => {
             noteWholeSize();
             if (delivered)
@@ -2114,6 +2218,47 @@ function promptSubmitLine(state) {
         return undefined;
     }
 }
+/**
+ * Whether MemTree is known to be compressing: its latest answer a success and
+ * no pause (402) remembered. Before any answer, or after an outage, it is not.
+ */
+function memtreeWorking(state) {
+    return state.memtreeAnswering() === true && state.unpaidDetail() === null;
+}
+/**
+ * What the model should know about MemTree right now: a notice, undefined
+ * when it is known to work, null when neither is known (no answer, an outage).
+ */
+function currentModelNotice(state) {
+    if (state.keyInvalid()) {
+        return { kind: KEY_INVALID_KIND, text: keyInvalidModelContext(state.keyPageUrl) };
+    }
+    const detail = state.unpaidDetail();
+    if (detail !== null) {
+        return { kind: PAUSED_KIND, text: pausedModelContext(detail, state.pausedReason()) };
+    }
+    return memtreeWorking(state) ? undefined : null;
+}
+/**
+ * A resumed session's transcript may hold a notice from an earlier ccc process
+ * (paused, then paid in between): start from it, so the change is announced.
+ * A missing or unreadable transcript, or a scan past its time box, starts from
+ * nothing. Never throws.
+ */
+async function restoreModelNotices(state, input) {
+    if (!input.transcript_path)
+        return;
+    state.modelNotices.restore(input.session_id, await lastToldKindInFile(input.transcript_path));
+}
+/** UserPromptSubmit's answer: a line for the user, context for the model, or both. */
+function promptSubmitOutput(line, context) {
+    return {
+        ...(line ? { systemMessage: line } : {}),
+        ...(context
+            ? { hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: context } }
+            : {}),
+    };
+}
 /** The caller's extra SessionStart line; a throwing provider shows nothing. */
 function extraSessionStartLine(provider, input) {
     if (!provider || input.agent_id !== undefined || input.source === "compact")
@@ -2139,6 +2284,48 @@ async function projectTreesContext(hint, input) {
         return undefined;
     }
 }
+/**
+ * The parent's memory hint for a starting subagent: only while MemTree works
+ * and the session has the tools, naming the parent's newest tree (a bounded
+ * wait when no answer is cached). Undefined otherwise; never throws.
+ */
+async function subagentHintContext(state, sessionId) {
+    if (!state.subagentHint?.enabled || !memtreeWorking(state))
+        return undefined;
+    try {
+        // A cached tree will do (peek refreshes it in the background); wait only for none.
+        const tree = state.newestTrees?.peek(sessionId) ?? await state.newestTrees?.settle(sessionId);
+        // MemTree may have paused or failed while the lookup was on its way.
+        if (!tree || !state.subagentHint.enabled || !memtreeWorking(state))
+            return undefined;
+        return subagentMemoryHintText(sessionId, tree.key);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The current MemTree guidance for a resumed main session (resume-guidance.ts). */
+async function resumeGuidanceContext(state, input) {
+    try {
+        return await state.resumeGuidance?.contextFor(input, {
+            working: () => resumeMemtreeWorking(state),
+            compressed: () => currentMemtreePage(state, input.session_id)?.compressed,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Whether MemTree works as a session resumes: not paused, key not refused,
+ * and its latest answer, if any, a success. A new `ccc --resume` process has
+ * no answer yet; its startup key check already turned a refused or unpaid
+ * key into no guidance (resumeGuidanceFor).
+ */
+function resumeMemtreeWorking(state) {
+    return state.memtreeAnswering() !== false && state.unpaidDetail() === null &&
+        !state.keyInvalid();
+}
 /**
  * The SessionStart hook's answer: the banner line for the user
  * (`systemMessage`), model context (`additionalContext`), or both.
@@ -2745,6 +2932,15 @@ function calibratedSizeExceedsWindow(record, body, modelContextLimit) {
     return record.uncountedOverWindow === true || (record.sizeSource === "reported" &&
         (record.estimatedTokens ?? 0) + outputTokens > modelContextLimit);
 }
+/**
+ * Over the window (calibratedSizeExceedsWindow) only by the uncounted
+ * conservative bound: a calibrated estimate that fits the window with the
+ * full max_tokens says otherwise.
+ */
+function uncountedOnlyOverWindow(record, body, modelContextLimit) {
+    return record.uncountedOverWindow === true && record.sizeSource === "reported" &&
+        (record.estimatedTokens ?? 0) + bodyOutputReservation(body, false) <= modelContextLimit;
+}
 function calibratedSizeExceedsLimits(record, body, modelContextLimit) {
     return (record.sizeSource === "reported" &&
         (record.estimatedTokens ?? 0) >= record.budgetTokens) ||
@@ -2965,7 +3161,14 @@ async function planEdgeCompaction(args) {
         // image-aware bound), not bytes: a flatten that kept images is mostly
         // base64 that costs a fixed amount per image.
         const overWindow = calibratedSizeExceedsWindow(compaction, body, modelContextLimit);
-        const fallback = overWindow ? undefined : { prefix, routed };
+        // Over the window only by the conservative bound of a ride whose planning
+        // count timed out: delivery counts it again before sending it, so it stays
+        // the fallback a failed compress rides (2026-10-28: a 528k ride whose
+        // count timed out was dropped, and the failed compress refused the turn).
+        const uncounted = overWindow && uncountedOnlyOverWindow(compaction, body, modelContextLimit) &&
+            args.sizing.canRetryCount(prefixCandidate);
+        const fallback = overWindow && !uncounted
+            ? undefined : { prefix, routed, ...(uncounted ? { uncounted: true } : {}) };
         if (state.compactNow.has(sessionId))
             return forced("manual", fallback);
         if (prefix.modelContextLimit !== modelContextLimit ||
@@ -4481,8 +4684,8 @@ async function selectForwardCandidate(args) {
         (args.rec.routeLane === "main" && args.opts.toolOutputs
             ? await truncatedToFit(args.rec, policy.sizing, target, args.limits, args.opts.toolOutputs)
             : undefined);
-    const quietDegrade = quietDegrades.get(args.rec);
-    quietDegrades.delete(args.rec);
+    const degraded = degradedNotices.get(args.rec);
+    degradedNotices.delete(args.rec);
     const lateInstall = lateRouteInstalls.get(args.rec);
     if (lateInstall && (!selection || selection.candidate !== target || target === preferred)) {
         lateRouteInstalls.delete(args.rec);
@@ -4510,14 +4713,29 @@ async function selectForwardCandidate(args) {
         args.rec.lateCountRecovery.outcome =
             changed && candidate.kind === "replacement" ? "compressed" : "forwarded";
     delete args.rec.overBudgetForward;
-    if (measurement.tokens > args.limits.budget ||
+    const overBudget = measurement.tokens > args.limits.budget ||
         (measurement.source !== "exact" && candidate.kind === "original" &&
-            measurement.estimatedTokens > args.limits.budget)) {
+            measurement.estimatedTokens > args.limits.budget);
+    if (overBudget) {
         args.rec.overBudgetForward = { reason: measurement.source === "exact"
                 ? "exact-count-fits-window" : measurement.source === "bytes"
                 ? "bytes-fallback-fits-window" : "estimate-fits-window" };
         warnPausedNearWindow(args.state, args.rec, requestSessionId(args.req));
-        quietDegrade?.();
+    }
+    // Uncompressed only when the whole history goes out (or a truncation of
+    // it), not a compressed ride.
+    const whole = candidate.kind === "original" || wholeHistoryCandidates.has(candidate);
+    if (degraded && whole) {
+        // A failed compress's ride that delivery could not send went out whole.
+        if (args.rec.turnType === "followup-prefix") {
+            args.rec.turnType = "followup-degraded";
+            delete args.rec.compaction?.keptPrefix;
+        }
+        if (degraded.eager || overBudget)
+            degraded.warn();
+    }
+    else if (degraded) {
+        delete args.rec.degradedNotice;
     }
     return changed ? candidate.body : intended;
 }
@@ -4585,6 +4803,9 @@ async function truncateCandidate(rec, sizing, base, limits, store) {
         if (!plan)
             return undefined;
         const candidate = sizing.register(Buffer.from(JSON.stringify(plan.body), "utf-8"), "replacement");
+        if (base.kind === "original" || wholeHistoryCandidates.has(base)) {
+            wholeHistoryCandidates.add(candidate);
+        }
         const measurement = await sizing.measure(candidate, limits);
         if (fitsMeasured(measurement, limits) && measurement.tokens <= goal) {
             rec.truncatedToolResult = { originalChars: plan.originalChars,
@@ -4693,6 +4914,17 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
             : args.state.fallbackFailures.fail(args.routeKey, { awaitingIndex: args.rec.indexBehind === true });
     args.rec.forwardedBytes = 0;
     args.rec.approxInputTokens = 0;
+    // Nothing went out uncompressed: Claude Code retries it (2026-10-28).
+    // A failed compress's ride that could not be sent either (review r2 P3).
+    const refusedRide = args.rec.turnType === "followup-prefix" &&
+        args.rec.compaction?.keptPrefix === true;
+    if (args.rec.turnType === "followup-degraded" || refusedRide) {
+        args.rec.turnType = "followup-refused";
+        delete args.rec.compaction?.keptPrefix;
+    }
+    delete args.rec.degradedNotice;
+    if (unpaid === null && !keyInvalid)
+        noteSlowRetry(args, failure);
     args.state.diagnostics?.record("refusal", {
         status: failure.status, attempt: failure.attempt,
         input_ktokens: Math.round(inputTokens / 1000), budget_ktokens: Math.round(budgetTokens / 1000),
@@ -4719,6 +4951,24 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
         args.state.keyNotice.markShown();
     return false;
 }
+/**
+ * A repeated retryable refusal on the main thread: say once per streak that
+ * MemTree is slow and Claude Code is retrying, unless another notice waits.
+ */
+function noteSlowRetry(args, failure) {
+    const { state, rec } = args;
+    const prompt = noticeContexts.get(rec);
+    // Not for a stale prompt or a closed response, nor an index wait (its 503
+    // says why), nor a final refusal (its own message shows).
+    const canShow = failure.status === 503 && rec.routeLane === "main" &&
+        rec.indexBehind !== true && prompt !== undefined &&
+        prompt.generation === state.mainPromptGeneration && !args.res.destroyed &&
+        !state.notices.hasPending();
+    if (!state.refusalStreaks.refused(args.routeKey, Date.now(), canShow))
+        return;
+    state.notices.queueSuffix(SLOW_RETRY_NOTICE, undefined, prompt.promptId);
+    rec.slowRetryNotice = true;
+}
 /**
  * The refusal text already says MemTree is paused and how to resume, so it
  * counts as the paused notice: the throttle restarts, and this request's
@@ -4794,7 +5044,7 @@ function reachedBudget(compaction) {
  * forced compaction (budget, window, `/memtree-compact`, a rebuilt prefix), a
  * size at or over the budget, or a size nobody measured. A planned fit is
  * provisional: delivery's own sizing can still find the turn over the budget
- * (quietDegrades), since a plan can undercount.
+ * (degradedNotices), since a plan can undercount.
  */
 function compressionNeeded(compaction) {
     if (compaction === undefined || compaction.reason !== undefined)
@@ -4804,10 +5054,15 @@ function compressionNeeded(compaction) {
     return compaction.estimatedTokens >= compaction.budgetTokens;
 }
 /**
- * A degraded turn whose plan fit the budget, so it queued no notice: the
- * notice to queue if delivery's sizing finds it over the budget after all.
+ * A degraded turn's notice, queued by delivery only when the whole request
+ * goes out: at once when planning said it needed compression (`eager`), else
+ * when delivery's sizing finds it over the budget after all.
  */
-const quietDegrades = new WeakMap();
+const degradedNotices = new WeakMap();
+/** Truncations (truncatedToFit) of the whole history: they still run uncompressed. */
+const wholeHistoryCandidates = new WeakSet();
+/** The prompt a request was made for, for notices its refusal may queue. */
+const noticeContexts = new WeakMap();
 /** The paused notice a degraded request queued, until it is refused or settles. */
 const pausedNotices = new WeakMap();
 const changedDeliveryRecords = new WeakSet();
@@ -5495,6 +5750,41 @@ function capture(opts, kind, body) {
         // diagnostics only — never break the proxy path
     }
 }
+/**
+ * The body, or undefined once it passes `limit` bytes (declared or streamed)
+ * or takes longer than HOOK_BODY_TIMEOUT_MS: the rest is drained unkept.
+ */
+function readBodyWithin(req, limit) {
+    return new Promise((resolve) => {
+        const chunks = [];
+        let size = 0;
+        let done = false;
+        const finish = (body) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            if (body === undefined) {
+                chunks.length = 0;
+                req.removeAllListeners("data");
+                req.resume();
+            }
+            resolve(body);
+        };
+        const timer = setTimeout(() => finish(undefined), HOOK_BODY_TIMEOUT_MS);
+        if (Number(req.headers["content-length"] ?? 0) > limit)
+            return finish(undefined);
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > limit)
+                finish(undefined);
+            else
+                chunks.push(chunk);
+        });
+        req.on("end", () => finish(Buffer.concat(chunks)));
+        req.on("error", () => finish(undefined));
+    });
+}
 function readBody(req) {
     return readAll(req);
 }