claude-code-infinite 1.0.33 → 1.0.35

package/dist/proxy.js

@@ -38,9 +38,13 @@
  * strip pass before hashing/forwarding. Live notices use Claude Code hooks and
  * upstream response bytes pass through to the client unchanged.
  */
+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 } from "./route-fallback.js";
+import { INDEX_WAIT_RETRY_AFTER_SECONDS, RefusalStreaks, RouteFallbackFailures, pausedRefusal, unreachableRefusal } from "./route-fallback.js";
+import { refusalCause, refusalMessage } from "./refusal-reason.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";
 import { extendsHistory, mediaFreeMessageHash, prefixIdentity, prefixMessageMatches, } from "./route-identity.js";
@@ -48,14 +52,15 @@ import { COMPRESSION_RESERVE_TOKENS, compressionTrigger, PreparedCompressions, p
 import { truncateToolResults } from "./tool-result-truncation.js";
 import http from "node:http";
 import https from "node:https";
-import { createHash, randomBytes } from "node:crypto";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+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";
+import { NoticeDeliveryQueue, MEMTREE_COMPACT_COMMAND, MEMTREE_HELP_COMMAND, TRAILER_LABEL, LINK_LABEL, linkLines, terminalSupportsHyperlinks, isMemtreeViewCommand, sessionCommandArgs, parseNoticeHookInput, PRECOMPACT_HOOK_PATH } from "./hooks.js";
 import { USAGE_LABEL, USAGE_SIGN_IN_NOTE } from "./usage-link.js";
 import { hyperlink } from "./payment-gate.js";
 import { keyInvalidNoticeText, keyInvalidRefusalMessage } from "./key-status.js";
@@ -64,8 +69,8 @@ import { PaymentNoticeThrottle, pausedCompactionText, pausedRefusalMessage, paym
 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 { isSubagentCall, postToolUseOutput, SUBAGENT_RESULT_HINT, subagentMemoryHintText, subagentStartOutput, } from "./subagent-hint.js";
+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 { claudeAuthFromHeaders, upstreamErrorCode } from "./claude-auth.js";
@@ -73,6 +78,11 @@ 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;
+/**
+ * Hook bodies that carry a whole prompt (UserPromptSubmit) or a subagent's prompt and
+ * full result (PostToolUse on Agent|Task).
+ */
+const LARGE_HOOK_BODY_LIMIT = 16 * 1024 * 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
@@ -221,6 +231,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;
 }
@@ -346,6 +362,8 @@ export function startProxy(opts) {
         pausedDetail: () => opts.memtree.pausedDetail,
         pausedReason: () => opts.memtree.pausedReason,
         memtreeAnswering: () => opts.memtree.answering,
+        memtreeUnreachable: () => opts.memtree.unreachable,
+        anthropicUnreachable: () => upstream.unreachable,
         modelNotices: new ModelContextNotices(),
         usageUrl: opts.memtree.usageDashboardUrl,
         sessionStartNotice: opts.sessionStartNotice,
@@ -353,13 +371,15 @@ export function startProxy(opts) {
         openUrl: opts.openUrl,
         projectTrees: opts.projectTrees,
         subagentHint: opts.subagentHint,
+        projectTreesGiven: new Set(),
         resumeGuidance: opts.resumeGuidance,
         diagnostics: opts.diagnostics,
         notices: new NoticeDeliveryQueue(),
         mainNoticePending: false,
         mainPromptGeneration: 0,
         promptAccounting: new PromptAccounting(),
-        fallbackFailures: new RouteFallbackFailures(undefined, opts.indexWaitDeadlineMs),
+        slowUploads: new SlowUploads(undefined, opts.slowUploadMinBytes),
+        fallbackFailures: new RouteFallbackFailures(undefined, opts.indexWaitDeadlineMs, opts.indexWaitMaxMs),
         refusalStreaks: new RefusalStreaks(),
         activeSubagents: new Set(),
         deferredAgentIndexes: new Map(),
@@ -376,6 +396,7 @@ export function startProxy(opts) {
         routeInstallFault: opts.routeInstallFault,
         memtreePages: new Map(),
         memorySourcePages: new Map(),
+        hostToken: randomBytes(24).toString("hex"),
         memtreeCallSeq: 0,
         memtreeLinkStore: opts.memtreeLinkStore,
         stablePrefixStore: opts.stablePrefixStore,
@@ -383,6 +404,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,
@@ -398,6 +421,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 };
@@ -486,6 +511,8 @@ export function startProxy(opts) {
                 },
                 drain,
                 mainSessionId: () => state.resumableMainSession,
+                setHostPid: (pid) => { state.hostPid = pid; },
+                hostToken: state.hostToken,
             });
         });
     });
@@ -513,13 +540,22 @@ async function handleRequest(req, res, opts, upstream, state, hookPath) {
         return handleNoticeHook(req, res, state, opts.reqlog, undefined, "PreCompact");
     }
     if (url.pathname === `${hookPath}${RESUME_GUIDANCE_HOOK_SUFFIX}`) {
-        return handleResumeGuidanceHook(req, res, state);
+        return handleSessionStartContextHook(req, res, (input) => resumeGuidanceContext(state, input));
+    }
+    if (url.pathname === `${hookPath}${SUBAGENT_RESULT_HOOK_SUFFIX}`) {
+        return handleSubagentResultHook(req, res, state);
+    }
+    if (url.pathname === `${hookPath}${PROJECT_TREES_HOOK_SUFFIX}`) {
+        return handlePrintProjectTreesHook(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)
             : opts.transcriptUsage?.finalReply?.(sessionId)));
     }
+    if (req.method === "GET" && url.pathname === MEMTREE_HOST_SESSION_PATH) {
+        return handleMemTreeHostSession(req, res, state, url);
+    }
     if (req.method === "GET" &&
         (url.pathname === MEMTREE_CURRENT_PATH || url.pathname === `${MEMTREE_CURRENT_PATH}.json`)) {
         return handleMemTreeCurrent(req, res, opts, state, url);
@@ -584,12 +620,14 @@ const MEMTREE_PASSTHROUGH_PREFIX = "/memtree/";
  * `<request id>`, `<request id>.json`, `<request id>/session.json` (the
  * page's session pane), `<request id>/search` (the server's term search over
  * that tree, `?q=&limit=`), `<request id>/messages` (the un-indexed messages
- * after it, `?start=&end=`), or `sessions/<Claude Code session id>.json` (every
+ * after it, `?start=&end=`), `<request id>/user_messages` (the person's own
+ * messages, `?since=&until=&q=&cursor=`), `<request id>/handover` (the handover
+ * pack), or `sessions/<Claude Code session id>.json` (every
  * page from one session, newest first); nothing that could walk the upstream
  * path. The id is the request UUID or the server's short form of it (leading
  * hex, as in the `/m/<id>` links it hands out) — the server accepts both.
  */
-const MEMTREE_PASSTHROUGH_TARGET_RE = /^(?:[A-Za-z0-9-]+(\.json|\/session\.json|\/search|\/messages)?|sessions\/[A-Za-z0-9][A-Za-z0-9_-]{0,127}\.json)$/;
+const MEMTREE_PASSTHROUGH_TARGET_RE = /^(?:[A-Za-z0-9-]+(\.json|\/session\.json|\/search|\/messages|\/user_messages|\/handover)?|sessions\/[A-Za-z0-9][A-Za-z0-9_-]{0,127}\.json)$/;
 /**
  * `GET /memtree/<id>[.json][?share=…]` on the loopback: read the user's own
  * MemTree page with their key. Claude Code's child env already carries this
@@ -606,7 +644,7 @@ async function handleMemTreePassthrough(req, res, opts, url) {
         return;
     }
     try {
-        const upstream = await opts.memtree.fetchMemTree(`/usage/memtree/${target}${url.search}`, req.headers.accept ?? "application/json");
+        const upstream = await opts.memtree.fetchMemTree(`/usage/memtree/${target}${url.search}`, req.headers.accept ?? "application/json", undefined, memtreeToolHeaders(req));
         res.writeHead(upstream.status, { "content-type": upstream.contentType });
         res.end(upstream.body);
     }
@@ -633,15 +671,29 @@ const MEMTREE_FINDER_RELAY = new Map([
     [`${MEMTREE_PASSTHROUGH_PREFIX}search`, "/v1/memtree/search"],
 ]);
 const SESSION_ID_HEADER_VALUE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
-async function handleMemTreeFinder(req, res, opts, upstreamPath, url) {
+/** `x-memtree-tool` as the memtree MCP server sends it: a tool name. */
+const MEMTREE_TOOL_HEADER_VALUE = /^[a-z_]{1,20}$/;
+/**
+ * What a MemTree tool's read carries on to the server: the tool (`x-memtree-tool`)
+ * and the calling Claude Code session, when well formed. The server logs one
+ * content-free line per tool call with them (polychat memtree_tool_log.py).
+ */
+export function memtreeToolHeaders(req) {
     const headers = {};
-    const meta = memtreeClientMeta({ project: opts.projectMeta });
-    if (Object.keys(meta).length)
-        headers["x-client-meta"] = JSON.stringify(meta);
+    const tool = firstNonEmptyHeader(req, "x-memtree-tool");
+    if (tool && MEMTREE_TOOL_HEADER_VALUE.test(tool))
+        headers["x-memtree-tool"] = tool;
     const sessionId = firstNonEmptyHeader(req, "x-claude-code-session-id");
     if (sessionId && SESSION_ID_HEADER_VALUE.test(sessionId)) {
         headers["x-claude-code-session-id"] = sessionId;
     }
+    return headers;
+}
+async function handleMemTreeFinder(req, res, opts, upstreamPath, url) {
+    const headers = memtreeToolHeaders(req);
+    const meta = memtreeClientMeta({ project: opts.projectMeta });
+    if (Object.keys(meta).length)
+        headers["x-client-meta"] = JSON.stringify(meta);
     try {
         const upstream = await opts.memtree.fetchMemTree(`${upstreamPath}${url.search}`, req.headers.accept ?? "application/json", undefined, headers);
         res.writeHead(upstream.status, { "content-type": upstream.contentType });
@@ -658,18 +710,23 @@ async function handleMemTreeFinder(req, res, opts, upstreamPath, url) {
  * reads (memtree-mcp.ts). Bare `current` answers the pointer
  * `{id, url, index, session_id, compressed}` without an upstream call, so the
  * MCP server can keep its cached tree until the page changes; `current.json`
- * relays the page JSON itself, like `/memtree/<id>.json`.
+ * relays the page JSON itself, like `/memtree/<id>.json`. With no page here,
+ * the server's newest tree for the session (currentPageOrServerTree): that
+ * waits a bounded time (NewestTreeLookup.current), cached; 503 when the
+ * server could not be asked.
  *
  * Every pointer is scoped to the caller's exact session id. Missing session
  * ids never fall back to another conversation served by the same proxy.
  */
 async function handleMemTreeCurrent(req, res, opts, state, url) {
     const sessionId = url.searchParams.get("session") || undefined;
-    const page = currentMemorySourcePage(state, sessionId);
+    const found = await currentPageOrServerTree(state, sessionId);
+    const page = "page" in found ? found.page : undefined;
     const id = page ? memtreePageId(page.url) : undefined;
     if (!page || !id) {
-        res.writeHead(404, { "content-type": "application/json" });
-        res.end(JSON.stringify({ detail: "No MemTree page for this session yet" }));
+        const unknown = "unknown" in found;
+        res.writeHead(unknown ? 503 : 404, { "content-type": "application/json" });
+        res.end(JSON.stringify({ detail: unknown ? CURRENT_LOOKUP_FAILED : "No MemTree page for this session yet" }));
         return;
     }
     if (!url.pathname.endsWith(".json")) {
@@ -684,7 +741,7 @@ async function handleMemTreeCurrent(req, res, opts, state, url) {
         return;
     }
     try {
-        const upstream = await opts.memtree.fetchMemTree(`/usage/memtree/${id}.json`, req.headers.accept ?? "application/json");
+        const upstream = await opts.memtree.fetchMemTree(`/usage/memtree/${id}.json`, req.headers.accept ?? "application/json", undefined, memtreeToolHeaders(req));
         res.writeHead(upstream.status, {
             "content-type": upstream.contentType,
             "x-memtree-page": page.url,
@@ -697,6 +754,60 @@ async function handleMemTreeCurrent(req, res, opts, state, url) {
     }
 }
 const MEMTREE_CURRENT_PATH = `${MEMTREE_PASSTHROUGH_PREFIX}current`;
+const MEMTREE_HOST_SESSION_PATH = `${MEMTREE_PASSTHROUGH_PREFIX}host-session`;
+/**
+ * `GET /memtree/host-session?host_pid=<pid>`: the session ccc's own Claude Code process
+ * is on, for that process's memtree MCP server (memtree-mcp.ts: refreshHostSession),
+ * which is started with the launch session id and not restarted when the process
+ * resumes or clears. Answered only to a caller that names that process's pid (the
+ * server's parent) and carries the token from this ccc's MCP config, and only once a
+ * SessionStart hook from that process has named the session; 404 otherwise. The pid is
+ * not a secret and the token alone is not enough: a teammate Claude Code replays the
+ * same MCP config, with another parent. So neither a Claude Code started from inside
+ * the session nor a teammate is handed this process's conversation.
+ */
+function handleMemTreeHostSession(req, res, state, url) {
+    const known = isHostPid(state, url.searchParams.get("host_pid")) &&
+        sameSecret(req.headers[HOST_TOKEN_HEADER], state.hostToken);
+    res.writeHead(known && state.hostSession ? 200 : 404, { "content-type": "application/json" });
+    res.end(JSON.stringify(known && state.hostSession
+        ? { session_id: state.hostSession } : { detail: "No session for this process" }));
+}
+/** Whether `pid` (a header or query value) is the Claude Code process ccc launched. */
+function isHostPid(state, pid) {
+    return state.hostPid !== undefined && typeof pid === "string" && /^\d+$/.test(pid) &&
+        Number(pid) === state.hostPid;
+}
+function sameSecret(given, secret) {
+    if (typeof given !== "string")
+        return false;
+    const a = Buffer.from(given), b = Buffer.from(secret);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+const CURRENT_LOOKUP_FAILED = "This process has no MemTree page for this session and could not ask the MemTree server for one";
+/**
+ * The session's page here (currentMemorySourcePage), else its newest completed
+ * tree on the server (`/v1/memtree/sessions`, this account's own sessions,
+ * exact session id only; cached by NewestTreeLookup and superseded as soon as
+ * a served index is noted). After a restart, a session whose history goes as
+ * index-only calls or rides a stored prefix gets no served index here, while
+ * the server has its whole tree. `unknown`: the server could not be asked.
+ */
+async function currentPageOrServerTree(state, sessionId) {
+    const page = currentMemorySourcePage(state, sessionId);
+    if (page || !sessionId || !state.newestTrees || !SESSION_ID_HEADER_VALUE.test(sessionId)) {
+        return { page };
+    }
+    const answer = await state.newestTrees.current(sessionId);
+    // A served index noted during the wait takes precedence.
+    const served = currentMemorySourcePage(state, sessionId);
+    if (served)
+        return { page: served };
+    if (answer.tree) {
+        return { page: { url: answer.tree.url, index: answer.tree.key, compressed: false, sessionId } };
+    }
+    return answer.answered ? {} : { unknown: true };
+}
 /** The page whose memory is in the prompt, else (none adopted yet) the newest page. */
 function currentMemorySourcePage(state, sessionId) {
     if (!sessionId)
@@ -746,12 +857,95 @@ function noteMainSessionStart(state, source, sessionId) {
         state.resumableMainSession = undefined;
     }
 }
+/**
+ * PostToolUse after an Agent/Task call: point the model at the subagent's own tree
+ * (subagent-hint.ts), unless MemTree is known not to work, when the session has the tools.
+ */
+async function handleSubagentResultHook(req, res, state) {
+    // The body carries the subagent's whole prompt and result: allow a large one.
+    const raw = req.method === "POST"
+        ? await readBodyWithin(req, LARGE_HOOK_BODY_LIMIT) : undefined;
+    if (req.method !== "POST")
+        req.resume();
+    let input = null;
+    try {
+        if (raw !== undefined && raw.length > 0)
+            input = JSON.parse(raw.toString("utf-8"));
+    }
+    catch {
+        input = null;
+    }
+    // Not known to be broken is enough: a short print run's first requests can finish
+    // before MemTree has answered any (non-blocking first turn), and the subagent is
+    // indexed either way.
+    const say = state.subagentHint?.enabled === true && resumeMemtreeWorking(state) &&
+        isSubagentCall(input);
+    if (!say) {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    const body = Buffer.from(JSON.stringify(postToolUseOutput(SUBAGENT_RESULT_HINT)), "utf-8");
+    res.writeHead(200, {
+        "content-type": "application/json",
+        "content-length": String(body.length),
+        "cache-control": "no-store",
+    });
+    res.end(body);
+}
+/**
+ * Print runs: the earlier-sessions block (project-trees.ts) with a session's first
+ * prompt, as UserPromptSubmit context. Main sessions only, once per session per
+ * process; anything unexpected is 204.
+ */
+async function handlePrintProjectTreesHook(req, res, state) {
+    // The body carries the whole prompt.
+    const raw = req.method === "POST" ? await readBodyWithin(req, LARGE_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 first = input?.hook_event_name === "UserPromptSubmit" && input.agent_id === undefined &&
+        !state.projectTreesGiven.has(input.session_id);
+    const context = first && state.projectTrees
+        ? await safeContext(() => state.projectTrees.contextFor(input.session_id)) : undefined;
+    if (!context) {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    state.projectTreesGiven.add(input.session_id);
+    const body = Buffer.from(JSON.stringify({ hookSpecificOutput: {
+            hookEventName: "UserPromptSubmit", additionalContext: context
+        } }), "utf-8");
+    res.writeHead(200, {
+        "content-type": "application/json",
+        "content-length": String(body.length),
+        "cache-control": "no-store",
+    });
+    res.end(body);
+}
+async function safeContext(get) {
+    try {
+        return await get();
+    }
+    catch {
+        return 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) {
+async function handleSessionStartContextHook(req, res, contextFor) {
     const raw = req.method === "POST" ? await readBodyWithin(req, HOOK_BODY_LIMIT) : undefined;
     if (req.method !== "POST")
         req.resume();
@@ -765,7 +959,7 @@ async function handleResumeGuidanceHook(req, res, state) {
         input = null;
     }
     const context = input?.hook_event_name === "SessionStart"
-        ? await resumeGuidanceContext(state, input) : undefined;
+        ? await contextFor(input) : undefined;
     if (!context) {
         res.writeHead(204);
         res.end();
@@ -827,6 +1021,12 @@ onlyEvent) {
         if (parsed.agent_id === undefined) {
             recordSessionStart(state, parsed.source);
             noteMainSessionStart(state, parsed.source, parsed.session_id);
+            // Only ccc's own Claude Code moves the host session: a teammate process loads
+            // the same plugin and posts its own session starts here.
+            if (isHostPid(state, req.headers[CLAUDE_PID_HEADER]) &&
+                typeof parsed.session_id === "string" && parsed.session_id) {
+                state.hostSession = parsed.session_id;
+            }
             // Claude Code's compaction dropped any MemTree notice from the transcript.
             if (parsed.source === "compact")
                 state.modelNotices.forget(parsed.session_id);
@@ -1047,6 +1247,8 @@ async function handleMessages(req, res, opts, upstream, state) {
     };
     // The prompt this request was made for, before any await (Codex r2 P2).
     noticeContexts.set(rec, { promptId: state.mainPromptId, generation: state.mainPromptGeneration });
+    // An index wait may hold this request (runBlockingCompression) until Claude Code leaves.
+    indexHolds.set(rec, { started: received, closed: closedSignal(res) });
     const logged = async (forward) => {
         try {
             await forward;
@@ -1165,6 +1367,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
@@ -1173,6 +1380,14 @@ async function handleMessages(req, res, opts, upstream, state) {
     const isSubagentRequest = requestRouteLane === "agent";
     const isMainRequest = requestRouteLane === "main";
     const requestSizeKey = laneSizeKey(req, requestRouteKey, body.model);
+    const hold = indexHolds.get(rec);
+    if (hold) {
+        hold.lane = requestRouteKey;
+        // Arriving while the lane waits for its index: this request's asks stay within its
+        // own hold even if that wait ends meanwhile (laneHeldCap).
+        if (state.fallbackFailures.indexWaiting(requestRouteKey))
+            hold.underIndexWait = true;
+    }
     // Extended 1M context arrives as the `context-1m` beta header (Claude Code
     // strips the `[1m]` model suffix on the wire). Current native-1M models send
     // neither, so contextLimitForModel also needs the launcher's native setting.
@@ -1491,12 +1706,16 @@ async function handleMessages(req, res, opts, upstream, state) {
                 }
                 else if (prior?.retryAtTokens !== undefined &&
                     plan.estimateTokens < prior.retryAtTokens &&
-                    Date.now() < (prior.retryDeadline ?? 0)) {
+                    Date.now() < (prior.retryDeadline ?? 0) && !outageOver(state, prior.offline)) {
                     // This lane's last attempt this human turn produced nothing; wait
                     // for growth instead of paying a blocking call on every tool turn.
                     rec.routeRecovery = { outcome: "backoff" };
+                    // MemTree answered that attempt: a refusal now is about the fit (Codex r1 P2).
+                    if (!prior.offline)
+                        answeredBackoffs.add(rec);
                 }
                 else if (Date.now() < state.toolRecoveryCooldownUntil &&
+                    !outageOver(state, state.toolRecoveryCooldownOffline) &&
                     !(plan.overWindow && !plan.fallback && (!plan.uncountedOverWindowOnly ||
                         await wholeRequestRefused(requestSizing, originalCandidate, sizingLimits())))) {
                     // A recent attempt burned the full compress budget and still
@@ -2572,10 +2791,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
@@ -2594,6 +2814,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) {
@@ -2644,6 +2871,7 @@ function noteMemtreeHealth(state, compression) {
             return;
         state.toolRecoveryCooldownUntil =
             Date.now() + TOOL_RECOVERY_FAILURE_COOLDOWN_MS;
+        state.toolRecoveryCooldownOffline = state.memtreeUnreachable() !== undefined;
         return;
     }
     if (compression.liveHealth === "success") {
@@ -2797,6 +3025,8 @@ function persistStablePrefix(state, sessionId, prefix) {
             originalSystemHash: prefix.originalSystemHash,
             originalPrefixHashes: prefix.originalPrefixHashes,
             originalMediaFreeHashes: prefix.originalMediaFreeHashes,
+            originalPortableHashes: prefix.originalPortableHashes,
+            originalPortableMediaFreeHashes: prefix.originalPortableMediaFreeHashes,
             compressedMessages: prefix.compressedMessages,
             compressedSystem: prefix.compressedSystem,
             hasCompressedSystem: prefix.hasCompressedSystem,
@@ -2837,6 +3067,7 @@ function adoptStoredPrefix(opts, state, rec, sessionId, body, messages, modelCon
     if (verdict === "discard") {
         store.delete(sessionId, owner);
         rec.storedPrefix = "discarded";
+        rec.storedPrefixMissAt = firstPrefixMiss(messages, prefix, "stable");
         return;
     }
     boundedSet(state.stablePrefixes, sessionId, prefix);
@@ -2885,15 +3116,19 @@ function prefixMismatch(body, messages, prefix, sessionId, kind = "route") {
     if (routeValueHash(normalizeRouteSystem(body.system)) !== prefix.originalSystemHash) {
         return "system";
     }
-    const prefixLength = prefix.originalPrefixHashes.length;
-    if (messages.length < prefixLength)
+    if (messages.length < prefix.originalPrefixHashes.length)
         return "prefix";
-    for (let i = 0; i < prefixLength; i++) {
-        if (!prefixMessageMatches(messages[i], kind, prefix.originalPrefixHashes[i], prefix.originalMediaFreeHashes?.[i])) {
-            return "prefix";
+    return firstPrefixMiss(messages, prefix, kind) === undefined ? null : "prefix";
+}
+/** The first message the prefix covers that no longer matches it, if any. */
+function firstPrefixMiss(messages, prefix, kind) {
+    const length = Math.min(messages.length, prefix.originalPrefixHashes.length);
+    for (let i = 0; i < length; i++) {
+        if (!prefixMessageMatches(messages[i], kind, prefix.originalPrefixHashes[i], prefix.originalMediaFreeHashes?.[i], prefix.originalPortableHashes?.[i], prefix.originalPortableMediaFreeHashes?.[i])) {
+            return i;
         }
     }
-    return null;
+    return undefined;
 }
 /**
  * Message identity for a stable prefix: routeMessageHash without assistant
@@ -3757,7 +3992,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) ||
@@ -3770,6 +4005,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)
@@ -3786,6 +4024,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));
 }
@@ -3824,7 +4070,7 @@ function memoryRoutedToolBody(body, messages, route, routeEpoch, sessionId) {
     if (messages.length < prefixLength)
         return null;
     for (let i = 0; i < prefixLength; i++) {
-        if (!prefixMessageMatches(messages[i], "route", route.originalPrefixHashes[i], route.originalMediaFreeHashes?.[i])) {
+        if (!prefixMessageMatches(messages[i], "route", route.originalPrefixHashes[i], route.originalMediaFreeHashes?.[i], route.originalPortableHashes?.[i], route.originalPortableMediaFreeHashes?.[i])) {
             return null;
         }
     }
@@ -4188,6 +4434,154 @@ function cloneJson(value) {
         return value;
     return JSON.parse(JSON.stringify(value));
 }
+/**
+ * A compress call that, while MemTree answers that its index is still catching up on
+ * this conversation (an indexing 413, index-wait-413.ts), holds the request and asks
+ * again at the server's pace instead of refusing at once: up to INDEX_HOLD_MS per
+ * request, below Claude Code's wait for a first byte. A wait it cannot finish here is
+ * left to the refusal (rec.indexBehind), whose 503 says how long is left and has Claude
+ * Code retry, until the lane's deadline (route-fallback.ts). Only when nothing else could
+ * be sent (longBudget): a ride on an earlier prefix, or a request that fits, goes at once.
+ * Never for a background call (its record is a copy) or a 413 that waiting cannot fix.
+ */
+async function runBlockingCompression(args) {
+    let capMs = laneHeldCap(args);
+    for (;;) {
+        const outcome = await runBlockingCompressionOnce(capMs === undefined ? args
+            : { ...args, capMs });
+        // An ask cut short by the hold's end is no evidence of an outage; and while the
+        // lane waits for its index it is that wait, not a strike (a later answer ends it).
+        if (capMs !== undefined && args.rec.compress?.timedOut) {
+            outcome.liveHealth = "none";
+            if (outcome.indexWaitSeconds === undefined && !activeIndexWaits.has(args.rec)) {
+                const lane = indexHolds.get(args.rec)?.lane;
+                noteIndexWait413(args.rec, (lane !== undefined
+                    ? args.state.fallbackFailures.indexSecondsLeft(lane) : undefined) ??
+                    UNKNOWN_INDEX_WAIT_SECONDS);
+                return outcome;
+            }
+        }
+        if (outcome.indexWaitSeconds === undefined) {
+            // Settled otherwise (an answer, or a failure of another kind): the wait is over.
+            // A timed-out ask said nothing new, so a refusal still waits.
+            if (outcome.result !== null || !args.rec.compress?.timedOut)
+                endIndexWait(args.rec);
+            return outcome;
+        }
+        noteIndexWait413(args.rec, outcome.indexWaitSeconds);
+        capMs = await holdForIndex(args, outcome.indexWaitSeconds);
+        if (capMs === undefined)
+            return outcome;
+    }
+}
+/**
+ * While the lane waits for its index (another request held it, likely this one's wait
+ * too), a request's first ask gets only what is left of its own hold: its time waiting
+ * for the lane already counts toward Claude Code's first-byte wait.
+ */
+function laneHeldCap(args) {
+    const hold = indexHolds.get(args.rec);
+    if (!hold || hold.lane === undefined)
+        return undefined;
+    // Waiting now, or at any time since this request arrived (it may have queued behind a
+    // hold that has since delivered).
+    if (!hold.underIndexWait &&
+        !args.state.fallbackFailures.indexWaitSince(hold.lane, hold.started)) {
+        return undefined;
+    }
+    hold.underIndexWait = true;
+    return Math.max(1, (args.opts.indexHoldMs ?? INDEX_HOLD_MS) - (Date.now() - hold.started));
+}
+/** One request's index hold: when it arrived, its lane, and a signal for Claude Code leaving. */
+const indexHolds = new WeakMap();
+/**
+ * Requests whose latest compress answer was an indexing 413: the seconds it stated. Set
+ * only by runBlockingCompression, and cleared when a later ask settles otherwise.
+ */
+const activeIndexWaits = new WeakMap();
+/** The most one request is held for an index (Claude Code 2.1.319 waits 180 s for headers). */
+const INDEX_HOLD_MS = 120_000;
+/** The longest pause between asks while held (the server's Retry-After, when shorter). */
+const INDEX_POLL_MAX_MS = 30_000;
+/**
+ * A held ask gets at least this long (MemTree itself holds an indexing 413 for up to
+ * 90 s); with less left, the request is not held.
+ */
+const INDEX_MIN_ASK_MS = 30_000;
+/** An indexing 413: refusing this request waits for the index, saying how long is left. */
+function noteIndexWait413(rec, seconds) {
+    if (!activeIndexWaits.has(rec) && rec.indexBehind !== true)
+        indexBehindSetByWait.add(rec);
+    activeIndexWaits.set(rec, seconds);
+    rec.indexBehind = true;
+    rec.indexWait = { secondsLeft: seconds, asks: (rec.indexWait?.asks ?? 0) + 1,
+        heldMs: rec.indexWait?.heldMs ?? 0 };
+}
+/** Requests whose indexBehind only an indexing 413 set (endIndexWait clears it). */
+const indexBehindSetByWait = new WeakSet();
+/** A later ask settled otherwise: the request no longer waits (rec.indexWait stays as history). */
+function endIndexWait(rec) {
+    if (!activeIndexWaits.delete(rec))
+        return;
+    if (indexBehindSetByWait.delete(rec))
+        delete rec.indexBehind;
+    if (rec.indexWait)
+        rec.indexWait.ended = true;
+}
+/**
+ * Pause before asking MemTree again, when another ask fits this request's hold and its
+ * lane's wait is still open: the time left of the hold for that ask (its cap). Undefined
+ * when not (nothing else could be sent is false, the estimate is past the cap, the lane's
+ * deadline passed, or Claude Code or the proxy left).
+ */
+async function holdForIndex(args, seconds) {
+    const hold = indexHolds.get(args.rec);
+    if (!hold || args.longBudget !== true)
+        return undefined;
+    const laneEnds = hold.lane === undefined ? Infinity
+        : args.state.fallbackFailures.indexWaitDeadline(hold.lane, seconds);
+    if (laneEnds === undefined || args.state.fallbackFailures.hopeless(seconds))
+        return undefined;
+    const pause = Math.min(seconds * 1000, args.opts.indexPollMaxMs ?? INDEX_POLL_MAX_MS);
+    const holdMs = args.opts.indexHoldMs ?? INDEX_HOLD_MS;
+    // The earlier of the request's hold and the lane's wait bounds the pause and the ask.
+    const left = () => Math.min(holdMs - (Date.now() - hold.started), laneEnds - Date.now());
+    if (left() - pause < Math.min(INDEX_MIN_ASK_MS, holdMs / 4))
+        return undefined;
+    const signals = [hold.closed, args.state.shutdownSignal, args.signal]
+        .filter((signal) => signal !== undefined);
+    const paused = Date.now();
+    const waited = await abortableDelay(pause, signals);
+    if (args.rec.indexWait)
+        args.rec.indexWait.heldMs += Date.now() - paused;
+    return waited ? Math.max(1, left()) : undefined;
+}
+/** Wait `ms`; false at once if any signal aborts first (or already has). */
+function abortableDelay(ms, signals) {
+    if (signals.some((signal) => signal.aborted))
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        const done = (waited) => {
+            clearTimeout(timer);
+            for (const signal of signals)
+                signal.removeEventListener("abort", aborted);
+            resolve(waited);
+        };
+        const aborted = () => done(false);
+        // Unref'd: a hold never keeps the process open.
+        const timer = setTimeout(() => done(true), ms);
+        timer.unref();
+        for (const signal of signals)
+            signal.addEventListener("abort", aborted, { once: true });
+    });
+}
+/** Aborted when Claude Code closes this response before it finished. */
+function closedSignal(res) {
+    const controller = new AbortController();
+    res.once("close", () => { if (!res.writableFinished)
+        controller.abort(); });
+    return controller.signal;
+}
 /**
  * The blocking-compression step, shared by the main followup path and
  * tool-route miss recovery: the compress call plus the `compress` telemetry
@@ -4198,7 +4592,7 @@ function cloneJson(value) {
  * `checkCompressedHistory(result, msgsForMemtree).usable` must hold before
  * the result may be forwarded or become a route.
  */
-async function runBlockingCompression(args) {
+async function runBlockingCompressionOnce(args) {
     const { opts, state, body, msgsForMemtree, hash, modelContextLimit, rec } = args;
     const compaction = args.compaction ??
         laneCompaction(opts, state, args.sessionId, body.model, modelContextLimit);
@@ -4210,10 +4604,14 @@ async function runBlockingCompression(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);
+    // 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 && carriedBudgetMs(opts, scaledMs) >= budgetMs + CARRY_MIN_EXTRA_MS
-        ? args.carry : undefined;
+    const carry = args.carry && args.capMs === undefined &&
+        carriedBudgetMs(opts, scaledMs) >= budgetMs + CARRY_MIN_EXTRA_MS ? args.carry : undefined;
     const compressMeta = {
         // Model + tools drive the server's model-based memory budget
         // (e.g. 800k whole-request target for Fable / Opus 5). Omitting
@@ -4266,7 +4664,7 @@ async function runBlockingCompression(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.
@@ -4274,6 +4672,8 @@ async function runBlockingCompression(args) {
         opts.memtree.lastCompressFailureArming(hash, modelContextLimit, compressMeta);
     const failureStatus = result === null
         ? opts.memtree.lastCompressFailureStatus?.(hash, modelContextLimit, compressMeta) : undefined;
+    // A joined call's answer counts too: it is this request's answer.
+    const indexWaitSeconds = result === null ? opts.memtree.compressIndexWait?.(call) : undefined;
     const hadLiveSuccess = !cached && result !== null;
     // Only arming-class live failures (network error, timeout, 5xx, 402) are
     // fuse evidence. A responsive server's other 4xx failed THIS call but says
@@ -4291,12 +4691,25 @@ async function runBlockingCompression(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 } : {}),
-        ...(!cached && failureStatus === OVER_CONTEXT_STATUS ? { refused: true } : {}),
+        // A joined call's indexing 413 is MemTree's refusal of this request too.
+        ...((!cached && failureStatus === OVER_CONTEXT_STATUS) || indexWaitSeconds !== undefined
+            ? { refused: true } : {}),
     };
     return {
         result,
@@ -4306,6 +4719,7 @@ async function runBlockingCompression(args) {
             : hadLiveFailure
                 ? "failure"
                 : "none",
+        ...(indexWaitSeconds !== undefined ? { indexWaitSeconds } : {}),
     };
 }
 /**
@@ -4420,6 +4834,10 @@ async function recoverToolRouteMiss(args) {
         if (args.retryAtTokens !== undefined) {
             recoveryAttempt.retryAtTokens = args.retryAtTokens;
             recoveryAttempt.retryDeadline = Date.now() + TOOL_RECOVERY_FAILURE_COOLDOWN_MS;
+            if (state.memtreeUnreachable())
+                recoveryAttempt.offline = true;
+            else
+                delete recoveryAttempt.offline;
         }
     };
     const sessionId = requestSessionId(req);
@@ -4487,7 +4905,10 @@ async function recoverToolRouteMiss(args) {
         modelContextLimit, rec, targetTokens: stable.targetTokens, explicitTarget: stable.explicitTarget,
         linkSeq }) : undefined;
     let compression;
+    // Nothing else could be sent if this compress fails: the long budget, and an index hold.
+    let longBudget = false;
     try {
+        longBudget = args.wholeRefused ? await args.wholeRefused() : false;
         compression = await runBlockingCompression({
             opts,
             state,
@@ -4502,7 +4923,7 @@ async function recoverToolRouteMiss(args) {
             sizing: args.sizing,
             inputCandidate: args.inputCandidate,
             ...(args.compaction ? { compaction: args.compaction } : {}),
-            longBudget: args.wholeRefused ? await args.wholeRefused() : false,
+            longBudget,
             ...(toolCarry ? { carry: toolCarry } : {}),
         });
     }
@@ -4545,6 +4966,11 @@ async function recoverToolRouteMiss(args) {
     if (!result) {
         rec.routeRecovery = { conversationBytes, outcome: "failed" };
         releaseOwnReservation();
+        // MemTree's 413 for an index still catching up, with nothing else to send: the
+        // refusal waits for the index (its 503 paces the retries), and growth cannot help,
+        // so the retry asks again. With a ride to send, the usual backoff paces the asks.
+        if (longBudget && activeIndexWaits.has(rec))
+            return forwardOriginal(false);
         // An ordinary server/network failure or timeout retains the background
         // submission: its longer independent budget can still warm the index for
         // a later turn. An unpaid key (402, possibly set by this very compress)
@@ -5082,6 +5508,9 @@ async function truncatedToFit(rec, sizing, preferred, limits, store) {
  * compression summarize instead.
  */
 function compressionSettled(rec) {
+    // An indexing 413 is MemTree's refusal too: the safety net may still fit the request.
+    if (activeIndexWaits.has(rec))
+        return true;
     if (rec.indexBehind === true)
         return false;
     if (rec.compress?.refused === true || rec.compaction?.prepared === "used")
@@ -5240,14 +5669,45 @@ 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.
     const keyInvalid = args.state.keyInvalid();
     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))
-            : args.state.fallbackFailures.fail(args.routeKey, { awaitingIndex: args.rec.indexBehind === true });
+            : offline ? unreachableRefusal(offline.message)
+                : args.state.fallbackFailures.fail(args.routeKey, { awaitingIndex: args.rec.indexBehind === true,
+                    indexSecondsLeft: activeIndexWaits.get(args.rec),
+                    refusalMessage: refusalMessage(cause, currentSessionLink(args.state, requestSessionId(args.req))) });
     args.rec.forwardedBytes = 0;
     args.rec.approxInputTokens = 0;
     // Nothing went out uncompressed: Claude Code retries it (2026-10-28).
@@ -5259,7 +5719,8 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
         delete args.rec.compaction?.keptPrefix;
     }
     delete args.rec.degradedNotice;
-    if (unpaid === null && !keyInvalid)
+    // An unreachable MemTree's 503 says why itself: not "slow to answer".
+    if (unpaid === null && !keyInvalid && !offline)
         noteSlowRetry(args, failure);
     args.state.diagnostics?.record("refusal", {
         status: failure.status, attempt: failure.attempt,
@@ -5272,6 +5733,8 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
         outputReservation: bodyOutputReservation(args.body), indexBehind: args.rec.indexBehind === true,
         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);
@@ -5287,6 +5750,37 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
         args.state.keyNotice.markShown();
     return false;
 }
+/** Requests held back by a lane backoff whose attempt MemTree answered (unreachableNow). */
+const answeredBackoffs = new WeakSet();
+/**
+ * Whether a backoff or cooldown armed by a call that could not connect (`offline`) is over:
+ * MemTree has answered since, so the next request asks it again.
+ */
+function outageOver(state, offline) {
+    return offline === true && state.memtreeUnreachable() === undefined;
+}
+/**
+ * Why a request only MemTree could fit can't go now, when MemTree's latest compress call
+ * could not connect (recently): the internet when Anthropic's latest forward could not
+ * either. Never for a request MemTree answered (live or from the cache), one held back by a
+ * backoff MemTree's answer armed, or one sent on a prepared prefix or waiting for its index:
+ * its refusal is about the fit (review r1, Codex r1).
+ */
+function unreachableNow(state, rec) {
+    if (rec.compress?.ok === true || rec.compress?.refused === true ||
+        // The backoff's answer speaks only while this request made no compress call of its
+        // own (a delivery-time one that could not connect is its own evidence: Codex r2).
+        (rec.compress === undefined && answeredBackoffs.has(rec)) ||
+        rec.compaction?.prepared === "used" || rec.indexBehind === true ||
+        activeIndexWaits.has(rec))
+        return undefined;
+    const memtree = freshFailure(state.memtreeUnreachable());
+    if (!memtree)
+        return undefined;
+    const anthropic = freshFailure(state.anthropicUnreachable());
+    return { message: unreachableMessage(memtree, anthropic),
+        what: anthropic ? "internet" : "memtree" };
+}
 /**
  * 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.
@@ -5563,6 +6057,7 @@ function forwardAccepted(req, res, bodyBuffer, opts, upstream, shutdownSignal, r
             path: req.url, // path + query string verbatim (?beta=true etc.)
             headers,
         }, (upstreamRes) => {
+            upstream.unreachable = undefined;
             activeUpstreamRes = upstreamRes;
             const contentType = String(upstreamRes.headers["content-type"] ?? "");
             const isSse = contentType.includes("text/event-stream");
@@ -5821,7 +6316,7 @@ function forwardAccepted(req, res, bodyBuffer, opts, upstream, shutdownSignal, r
         });
         upstreamReq.on("error", (err) => {
             if (!shutdownCancelled) {
-                sendAnthropicError(res, `upstream connection failed: ${err.message}`);
+                sendAnthropicError(res, upstreamFailureMessage(upstream, err, !activeUpstreamRes));
             }
             settle(false);
         });
@@ -5973,6 +6468,7 @@ function passThroughStreaming(req, res, upstream, shutdownSignal) {
                 upstreamRes.destroy();
                 return;
             }
+            upstream.unreachable = undefined;
             activeUpstreamRes = upstreamRes;
             const onUpstreamResponseEnd = () => {
                 upstreamResponseEnded = true;
@@ -6018,7 +6514,7 @@ function passThroughStreaming(req, res, upstream, shutdownSignal) {
             if (upstreamReq)
                 req.unpipe(upstreamReq);
             activeUpstreamRes?.unpipe(res);
-            sendAnthropicError(res, `upstream connection failed: ${err.message}`);
+            sendAnthropicError(res, upstreamFailureMessage(upstream, err, !activeUpstreamRes));
             if (res.writableFinished)
                 onDownstreamFinish();
         });
@@ -6052,6 +6548,18 @@ function forwardableResponseHeaders(upstreamRes) {
     }
     return out;
 }
+/**
+ * The 502 text for a forward that got no answer: plainly that ccc can't reach Anthropic
+ * when it could not connect (noted on `upstream`; only before any response: review r1 P3),
+ * else the error as it came.
+ */
+function upstreamFailureMessage(upstream, err, unanswered) {
+    const failure = unanswered ? networkFailureOf(err, upstream.host) : undefined;
+    if (!failure)
+        return `upstream connection failed: ${err.message}`;
+    upstream.unreachable = failure;
+    return unreachableMessage(undefined, failure);
+}
 /** Well-formed Anthropic-shaped error body so Claude Code fails fast, not weird. */
 function sendAnthropicError(res, message) {
     if (res.headersSent) {