claude-code-infinite 1.0.32 → 1.0.34

package/dist/proxy.js

@@ -38,9 +38,11 @@
  * 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 { 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 +50,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, MemtreeClient, modelBudgetTokens, normalizeMessagesForMemtree, serverFlattenedMessages, rawPromptTokenCount, } from "./memtree.js";
+import { cachedPromptTokenCount, checkCompressedHistory, didMemtreeCompress, indexLagEvidence, losesMedia, 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, 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 { 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 +67,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 +76,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
@@ -86,8 +94,11 @@ const HOOK_BODY_TIMEOUT_MS = 3_000;
 const TOOL_RECOVERY_FAILURE_COOLDOWN_MS = 60_000;
 /** Safety cap on a long-budget compress, should a transport ignore its abort. */
 const MAX_LONG_COMPRESS_WAIT_MS = 10 * 60_000;
-/** The most a blocking compress with a fallback may wait (its budget grows with its upload). */
-const MAX_COMPRESS_WAIT_MS = 60_000;
+/**
+ * The most a blocking compress with a fallback may wait (its budget grows with its upload):
+ * a 30 MB upload's scaled budget (15 s + 2.5 ms/KiB, ~90 s) fits under it.
+ */
+const MAX_COMPRESS_WAIT_MS = 120_000;
 const SKIP_REQUEST_HEADERS = new Set([
     "host",
     "connection",
@@ -343,21 +354,27 @@ 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,
         promptSubmitNotice: opts.promptSubmitNotice,
+        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),
+        fallbackFailures: new RouteFallbackFailures(undefined, opts.indexWaitDeadlineMs, opts.indexWaitMaxMs),
         refusalStreaks: new RefusalStreaks(),
         activeSubagents: new Set(),
+        deferredAgentIndexes: new Map(),
+        adoptingPrepared: new Map(),
         memoryRoutes: new Map(),
         mainRouteEpoch: 0,
         mainRouteDecisionGeneration: 0,
@@ -370,6 +387,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,
@@ -453,8 +471,10 @@ export function startProxy(opts) {
         ]);
         if (timer)
             clearTimeout(timer);
-        if (completed)
+        if (completed) {
+            sendDeferredAgentIndexes(state);
             return true;
+        }
         // The grace period protects useful in-flight delivery. Once it
         // expires, signal every forwarding path first so each can
         // classify the close as proxy-owned, then tear down any request that was
@@ -463,6 +483,7 @@ export function startProxy(opts) {
         for (const accepted of acceptedRequests)
             cancelAcceptedRequest(accepted);
         await quiesced;
+        sendDeferredAgentIndexes(state);
         return false;
     };
     return new Promise((resolve, reject) => {
@@ -477,6 +498,8 @@ export function startProxy(opts) {
                 },
                 drain,
                 mainSessionId: () => state.resumableMainSession,
+                setHostPid: (pid) => { state.hostPid = pid; },
+                hostToken: state.hostToken,
             });
         });
     });
@@ -504,13 +527,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);
@@ -575,12 +607,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
@@ -597,7 +631,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);
     }
@@ -624,15 +658,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 });
@@ -649,18 +697,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")) {
@@ -675,7 +728,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,
@@ -688,6 +741,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)
@@ -737,12 +844,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();
@@ -756,7 +946,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();
@@ -818,6 +1008,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);
@@ -942,6 +1138,7 @@ onlyEvent) {
     }
     if (parsed.hook_event_name === "SubagentStop") {
         state.activeSubagents.delete(parsed.agent_id);
+        sendDeferredAgentIndex(state, parsed.agent_id);
         res.writeHead(204);
         res.end();
         return;
@@ -1037,6 +1234,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;
@@ -1163,6 +1362,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.
@@ -1409,7 +1616,7 @@ async function handleMessages(req, res, opts, upstream, state) {
             // prefix, else whole) with no compress call; at it, compress once to
             // the target (planToolCompaction). A "replay" is a client retry of the
             // request that installed the route, forwarded verbatim.
-            const plan = await planToolCompaction({
+            const planArgs = {
                 opts,
                 state,
                 body,
@@ -1424,7 +1631,24 @@ async function handleMessages(req, res, opts, upstream, state) {
                 rec,
                 ride: toolRide,
                 canCompress,
-            });
+            };
+            let plan = await planToolCompaction(planArgs);
+            // Over the window with nothing to ride while the lane compresses: going without it
+            // can only be refused (staging 2026-10-30: a 120 s compress, every tool turn meanwhile
+            // refused). Wait for it, then plan again on what it installed.
+            if (plan.kind === "compress" && plan.overWindow && !plan.fallback &&
+                state.toolRecoveryAttemptedLanes.get(requestRouteKey)?.inFlight) {
+                // Stops early if Claude Code drops this request meanwhile.
+                const clientGone = new AbortController();
+                const onClose = () => clientGone.abort();
+                res.once("close", onClose);
+                rec.laneWaitMs = await waitForLaneIdle(state, requestRouteKey, Math.min(MAX_LONG_COMPRESS_WAIT_MS, opts.memtree.longCompressBudgetMs), clientGone.signal);
+                res.off("close", onClose);
+                // Plan on what the lane holds now: the route its compression installed (or, on the
+                // main lane, the session's new stable prefix), never the ride read before the wait.
+                plan = await planToolCompaction({ ...planArgs,
+                    ride: currentLaneRide(state, requestRouteKey, body, messages, toolSessionId, isMainRequest) });
+            }
             if (isMainRequest && toolSessionId !== undefined && canCompress &&
                 (plan.kind === "ride" || plan.kind === "pass")) {
                 maybePrepareCompression({ opts, state, body, messages, msgsForMemtree, hash,
@@ -1464,12 +1688,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
@@ -1482,6 +1710,10 @@ async function handleMessages(req, res, opts, upstream, state) {
                     // the lane's backoff.
                     rec.routeRecovery = { outcome: "cooldown" };
                 }
+                else if (state.toolRecoveryAttemptedLanes.get(requestRouteKey)?.inFlight) {
+                    // Claimed while the cooldown check above awaited a count (a crossing prompt).
+                    rec.routeRecovery = { outcome: "in-flight" };
+                }
                 else {
                     const recoveryAttempt = { modelContextLimit, inFlight: true };
                     if (!prior && state.toolRecoveryAttemptedLanes.size >= 128) {
@@ -1548,7 +1780,8 @@ async function handleMessages(req, res, opts, upstream, state) {
             requestSendPolicies.get(req)?.allowed.add(toolRide.raw);
         const sendBody = toolRide?.raw ?? (toolNeedsOriginal ? rawBody : forwardBody);
         recordTurn(rec, toolRide ? toolRide.turnType : isUserTurn ? "first-user" : "tool", sendBody);
-        opts.memtree.indexInBackground(hash, msgsForMemtree, modelContextLimit, toolSessionId, clientMeta, transcriptTimesFor(opts, toolSessionId, agentAttributionId(req)));
+        indexTurn({ opts, state, req, rec, hash, msgsForMemtree, modelContextLimit,
+            sessionId: toolSessionId, clientMeta });
         capture(opts, toolRide ? "anthropic-request-memory-tool" : "anthropic-request", sendBody);
         // The size Anthropic reports is the next budget check's anchor: a ride
         // reports to its prefix (or route), a whole request to the session's (or
@@ -1619,6 +1852,32 @@ async function handleMessages(req, res, opts, upstream, state) {
             rec.compaction.prepared ??= prepared;
         }
     }
+    // Never beside the main lane's compression in flight either (a tool turn's that Claude
+    // Code dropped, or another prompt's, both after the preparation they waited for failed):
+    // wait for it, then plan again on what it left: a prefix to ride, or a preparation.
+    // Bounded; stops early if Claude Code drops this request (release 1.0.33 E2E).
+    const crossing = () => edge?.kind === "compress" && isMainRequest &&
+        isAutoCrossing(rec, body.model, modelContextLimit);
+    for (let i = 0; i < 2 && crossing() &&
+        state.toolRecoveryAttemptedLanes.get(requestRouteKey)?.inFlight; i++) {
+        const clientGone = new AbortController();
+        const onClose = () => clientGone.abort();
+        res.once("close", onClose);
+        if (res.destroyed)
+            clientGone.abort();
+        rec.laneWaitMs = (rec.laneWaitMs ?? 0) + await waitForLaneIdle(state, requestRouteKey, Math.min(MAX_LONG_COMPRESS_WAIT_MS, opts.memtree.longCompressBudgetMs), clientGone.signal);
+        res.off("close", onClose);
+        await awaitPreparation(state, sessionId, opts.memtree.longCompressBudgetMs, rec.compaction);
+        edge = await planEdge();
+    }
+    // Claude Code dropped it while it waited: the lane's compression in flight already carries
+    // this session's crossing (the next turn rides it), so none beside it for nobody (r3 P1).
+    if (crossing() && state.toolRecoveryAttemptedLanes.get(requestRouteKey)?.inFlight &&
+        res.destroyed && !res.writableFinished) {
+        releaseUncommittedRouteDecision();
+        recordTurn(rec, "followup-client-closed", Buffer.alloc(0));
+        return logged(Promise.resolve());
+    }
     // Not beside a blocking compress call: the two would overlap on the server.
     if (sessionId !== undefined && edge && (edge.kind === "ride" || edge.kind === "pass")) {
         maybePrepareCompression({ opts, state, body, messages, msgsForMemtree, hash, sessionId,
@@ -1847,9 +2106,17 @@ async function handleMessages(req, res, opts, upstream, state) {
     // The hidden away-summary request compresses too, but its page is not the
     // conversation the user is looking at.
     const linkSeq = isMainRequest && !isAwaySummary ? nextMemtreeCallSeq(state) : undefined;
+    const edgeCarry = edge?.kind === "compress" && !isAwaySummary
+        ? carryFor({ state, isMainRequest, sessionId, body, messages, msgsForMemtree,
+            modelContextLimit, rec,
+            targetTokens: edge.targetTokens, explicitTarget: edge.explicitTarget, linkSeq })
+        : undefined;
     let compression;
+    // A main-thread compaction holds its lane, claimed with no await since the check above:
+    // a concurrent turn of the lane waits for it or rides its fallback, never compresses beside it.
+    const edgeLane = (run) => crossing() ? holdingLane(state, requestRouteKey, run) : run();
     try {
-        compression = await runBlockingCompression({
+        compression = await edgeLane(async () => runBlockingCompression({
             opts,
             state,
             body,
@@ -1871,7 +2138,8 @@ async function handleMessages(req, res, opts, upstream, state) {
             // short budget; with neither, a timeout could only end in a refusal.
             longBudget: !(edge?.kind === "compress" && edge.fallback && !edge.fallback.uncounted) &&
                 await wholeRequestRefused(requestSizing, forwardCandidate, sizingLimits()),
-        });
+            ...(edgeCarry ? { carry: edgeCarry } : {}),
+        }));
     }
     catch {
         const kept = rideOldPrefix(false);
@@ -1911,6 +2179,9 @@ async function handleMessages(req, res, opts, upstream, state) {
     if (downstreamClosedDuringCompression ||
         (res.destroyed && !res.writableFinished)) {
         releaseUncommittedRouteDecision();
+        // Claude Code gave up on the turn, not on the compaction: the next turn rides it.
+        if (result && edgeCarry)
+            carryOverCompression(state, edgeCarry, Promise.resolve(result));
         recordTurn(rec, "followup-client-closed", Buffer.alloc(0));
         return logged(Promise.resolve());
     }
@@ -2353,15 +2624,14 @@ function sessionCommandReply(state, sessionId, prompt) {
         : pausedCompactionText(viewUrl(subscribeUrlFromDetail(unpaid)));
     if (sessionCommandArgs(prompt, MEMTREE_HELP_COMMAND) !== undefined) {
         return [
-            "• /memtree-view · show this session's MemTree page link",
+            "• /memtree-view · open this session's MemTree page and show its link",
             paused !== undefined ? `• ${paused}`
                 : `• /memtree-compact [tokens | off] · compact this session on your next message (default half the budget, at least ${MEMTREE_COMPACT_MIN_TOKENS / 1000}k)`,
             usageLines(state),
         ].filter((line) => line !== undefined).join("\n");
     }
-    if (isMemtreeViewCommand(prompt)) {
-        return joinNoticeLines(memtreeViewLine(state, sessionId), usageLines(state)) ?? "";
-    }
+    if (isMemtreeViewCommand(prompt))
+        return memtreeView(state, sessionId);
     const args = sessionCommandArgs(prompt, MEMTREE_COMPACT_COMMAND);
     if (args === undefined)
         return undefined;
@@ -2405,10 +2675,8 @@ export const SUBAGENT_COMPACT_REPLY = "MemTree compact applies to the main sessi
  * is refused rather than applied to the main conversation from here.
  */
 function subagentCommandReply(state, sessionId, prompt) {
-    if (isMemtreeViewCommand(prompt)) {
-        const view = `${memtreeViewLine(state, sessionId)}\n${SUBAGENT_VIEW_NOTE}`;
-        return joinNoticeLines(view, usageLines(state)) ?? view;
-    }
+    if (isMemtreeViewCommand(prompt))
+        return `${memtreeView(state, sessionId)}\n${SUBAGENT_VIEW_NOTE}`;
     if (sessionCommandArgs(prompt, MEMTREE_COMPACT_COMMAND) !== undefined) {
         return `${TRAILER_LABEL} ${SUBAGENT_COMPACT_REPLY}`;
     }
@@ -2423,8 +2691,13 @@ export function parseTokenCount(text) {
     const value = Math.round(Number(match[1]) * scale);
     return Number.isFinite(value) && value > 0 ? value : undefined;
 }
-/** The `/memtree-view` answer: this session's newest page, or why there is none. */
-function memtreeViewLine(state, sessionId) {
+/**
+ * The `/memtree-view` answer: one link, this session's newest page (the
+ * newest completed tree, which covers the whole session, rather than the
+ * possibly stale page its memory was compressed from), opened in the browser
+ * where the CLI allows it; or why there is none.
+ */
+function memtreeView(state, sessionId) {
     const inMemory = state.memtreePages.get(sessionId);
     const page = inMemory && (inMemory.sessionId === undefined || inMemory.sessionId === sessionId)
         ? inMemory
@@ -2433,15 +2706,17 @@ function memtreeViewLine(state, sessionId) {
     if (!link) {
         return `${TRAILER_LABEL} no page yet: this session has not been indexed. The link appears once it has.`;
     }
+    try {
+        state.openUrl?.(link.link);
+    }
+    catch {
+        // The printed link below is the fallback.
+    }
     // Blocked-prompt reasons need an explicit hyperlink in styled terminals.
-    const lines = linkLines(LINK_LABEL, viewUrl(link.link), link.note);
-    // The memory the agent works from can be an older tree than the newest one.
-    return page?.compressed && page.url !== link.link
-        ? `${lines}\n${urlLine(viewUrl(page.url), "memory from ")}`
-        : lines;
+    return linkLines(LINK_LABEL, viewUrl(link.link), link.note);
 }
 /**
- * The usage dashboard link that `/memtree` and `/memtree-view` end with,
+ * The usage dashboard link that `/memtree` ends with,
  * formatted like the MemTree link; undefined when the environment has none.
  */
 function usageLines(state) {
@@ -2570,6 +2845,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") {
@@ -2723,6 +2999,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,
@@ -2763,6 +3041,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);
@@ -2811,15 +3090,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
@@ -3292,6 +3575,16 @@ async function planToolCompaction(args) {
         return { kind: "ride",
             ride: { raw: adopted.routed.raw, turnType: "tool-prefix", sizeHolder: adopted.prefix } };
     }
+    // Another turn that waited for the same preparation installed it meanwhile: plan again on
+    // it (once) rather than compress beside it (Codex r1 P1, release 1.0.33).
+    if (stableLane && !args.replanned && state.stablePrefixes.get(sessionId) !== current) {
+        const waited = compaction.preparedWaitMs;
+        const plan = await planToolCompaction({ ...args, replanned: true,
+            ride: currentLaneRide(state, args.routeKey, body, messages, sessionId, true) });
+        if (waited !== undefined && rec.compaction)
+            rec.compaction.preparedWaitMs = waited;
+        return plan;
+    }
     // Settings current after any wait for a preparation (a /memtree-compact N meanwhile).
     const modeNow = compactionMode(opts, state, sessionId);
     if (modeNow.mode === "off")
@@ -3351,10 +3644,49 @@ async function adoptPreparedPrefix(args) {
     const { state, sessionId } = args;
     const base = state.stablePrefixes.get(sessionId);
     await awaitPreparation(state, sessionId, args.waitMs, args.compaction);
+    // Checked and taken with no await between: two turns resuming together see one owner.
+    while (state.adoptingPrepared.has(sessionId))
+        await awaitAdoption(state, sessionId, args.compaction);
     const entry = state.prepared.get(sessionId);
     if (!entry)
         return undefined;
     state.prepared.discard(sessionId);
+    const release = holdAdoption(state, sessionId);
+    try {
+        return await adoptEntry(args, entry, base);
+    }
+    finally {
+        release();
+    }
+}
+/**
+ * Another turn of the session is adopting its prepared prefix (two turns waited for the same
+ * preparation): wait for it to finish, so this turn plans on the prefix it installs instead of
+ * compressing again (Codex r1 P1, release 1.0.33). Counted as preparation wait, so a human
+ * turn plans again after it.
+ */
+async function awaitAdoption(state, sessionId, compaction) {
+    const adopting = state.adoptingPrepared.get(sessionId);
+    if (!adopting)
+        return;
+    const started = Date.now();
+    await adopting;
+    compaction.preparedWaitMs = (compaction.preparedWaitMs ?? 0) + (Date.now() - started);
+}
+/** Mark the session's prepared prefix as being adopted; the returned function ends it. */
+function holdAdoption(state, sessionId) {
+    let done;
+    const adopting = new Promise((resolve) => { done = resolve; });
+    state.adoptingPrepared.set(sessionId, adopting);
+    return () => {
+        if (state.adoptingPrepared.get(sessionId) === adopting)
+            state.adoptingPrepared.delete(sessionId);
+        done();
+    };
+}
+/** adoptPreparedPrefix's check and install of the entry it took. */
+async function adoptEntry(args, entry, base) {
+    const { state, sessionId } = args;
     const fit = await preparedFit(args, entry);
     // Another request installed a prefix, or `/memtree-compact` asked for its
     // own target, while this one waited or counted: that wins.
@@ -3483,17 +3815,98 @@ function maybePrepareCompression(args) {
     });
     boundedSet(state.preparing, sessionId, pending);
 }
+/**
+ * A subagent's share of its budget from which it is indexed on every tool turn, as the
+ * main thread is; below it, only once, when it ends. 2026-10-30: 29 subagents ran ~32
+ * index jobs each ($45.63 a week for one session), and none came near its budget, so no
+ * subagent tree was ever used to compress. Its tree is still built (at SubagentStop, or
+ * at exit), so MemTree search and the page still find it.
+ */
+const AGENT_PER_TURN_INDEX_SHARE = 0.5;
+/** Subagents whose unsent index is kept; the oldest past this is sent at once. */
+const DEFERRED_AGENT_INDEX_MAX = 64;
+/**
+ * A tool turn's background index call: now on the main thread and for a subagent past
+ * AGENT_PER_TURN_INDEX_SHARE of its budget; otherwise kept, replacing the subagent's
+ * previous one, until it ends (sendDeferredAgentIndex).
+ */
+function indexTurn(args) {
+    const { opts, state, req, sessionId } = args;
+    const send = (mode) => opts.memtree.indexInBackground(args.hash, args.msgsForMemtree, args.modelContextLimit, sessionId, args.clientMeta, transcriptTimesFor(opts, sessionId, agentAttributionId(req)), mode === "final" ? { finalIndex: true } : mode === "flush" ? { force: true } : {});
+    // Only a request with its own agent id (the one SubagentStop names) waits for its end; one
+    // attributed by its parent's id only is indexed per turn as before.
+    const agentId = firstNonEmptyHeader(req, "x-claude-code-agent-id");
+    if (agentId === undefined || sessionId === undefined)
+        return send();
+    const compaction = args.rec.compaction;
+    if (compaction?.estimatedTokens !== undefined &&
+        compaction.estimatedTokens >= compaction.budgetTokens * AGENT_PER_TURN_INDEX_SHARE) {
+        send();
+        // Kept too: its last turns under the text minimum still go at its end (forced).
+        keepDeferredIndex(state, deferredIndexKey(agentId, args.msgsForMemtree), { messages: args.msgsForMemtree, send });
+        return;
+    }
+    // Per agent and conversation: a side request made under the subagent's (or its parent's)
+    // id is another conversation and must not replace the subagent's own.
+    keepDeferredIndex(state, deferredIndexKey(agentId, args.msgsForMemtree), { messages: args.msgsForMemtree, send });
+}
+/** Keep `entry` as its key's newest unsent index call (bounded). */
+function keepDeferredIndex(state, key, entry) {
+    const kept = state.deferredAgentIndexes.get(key);
+    // A rewind or another branch: the kept history is not part of this one, so it goes now.
+    // So does one holding media Claude Code has evicted since (never uploaded otherwise).
+    if (kept && (!extendsHistory(entry.messages, kept.messages) ||
+        losesMedia(kept.messages, entry.messages)))
+        sendDeferredIndex(state, key, "flush");
+    state.deferredAgentIndexes.delete(key);
+    state.deferredAgentIndexes.set(key, entry);
+    while (state.deferredAgentIndexes.size > DEFERRED_AGENT_INDEX_MAX) {
+        const oldest = state.deferredAgentIndexes.keys().next().value;
+        if (oldest === undefined)
+            break;
+        sendDeferredIndex(state, oldest, "flush");
+    }
+}
+/** A deferred index's key: the agent id and its conversation's first message. */
+function deferredIndexKey(agentId, messages) {
+    const first = messages.find((message) => message.role !== "system");
+    return JSON.stringify([agentId, first ? mediaFreeMessageHash(first) : ""]);
+}
+/** A subagent ended: send each of its conversations' kept index call, whatever its size. */
+function sendDeferredAgentIndex(state, agentId) {
+    for (const key of [...state.deferredAgentIndexes.keys()]) {
+        if (JSON.parse(key)[0] === agentId)
+            sendDeferredIndex(state, key, "final");
+    }
+}
+function sendDeferredIndex(state, key, mode) {
+    const kept = state.deferredAgentIndexes.get(key);
+    state.deferredAgentIndexes.delete(key);
+    kept?.send(mode);
+}
+/** At exit: every subagent's kept index calls. */
+function sendDeferredAgentIndexes(state) {
+    for (const key of [...state.deferredAgentIndexes.keys()])
+        sendDeferredIndex(state, key, "final");
+}
 /** The background prepare call and the prefix it yields (maybePrepareCompression). */
 async function prepareInBackground(args) {
-    const { opts, state, body, msgsForMemtree, modelContextLimit, sessionId } = args;
+    const { opts, state, body, msgsForMemtree, modelContextLimit } = args;
     const result = await opts.memtree.compress(args.hash, msgsForMemtree, modelContextLimit, state.backgroundSignal, preparedCompressMeta(args));
     noteServerBudget(state, body.model, modelContextLimit, result);
     if (!result)
         return undefined;
     state.prepared.noteServerAnswer(result.prepared === true);
-    if (result.prepared !== true || !didMemtreeCompress(result) ||
-        !checkCompressedHistory(result, msgsForMemtree).usable)
+    if (result.prepared !== true)
+        return undefined;
+    return preparedFromResult(args, result);
+}
+/** A compressed answer for a session's history, as its prepared prefix (or undefined). */
+function preparedFromResult(args, result) {
+    const { body, sessionId, modelContextLimit } = args;
+    if (!didMemtreeCompress(result) || !checkCompressedHistory(result, args.msgsForMemtree).usable) {
         return undefined;
+    }
     const built = buildCompressedBody(body, result);
     if (!built)
         return undefined;
@@ -3508,11 +3921,83 @@ async function prepareInBackground(args) {
         explicitTarget: args.explicitTarget,
         modelContextLimit,
     };
-    const source = result.memtreeUrl && result.memtreeIndex
+    const source = result.memtreeUrl && result.memtreeIndex && args.linkSeq !== undefined
         ? { url: result.memtreeUrl, index: result.memtreeIndex, seq: args.linkSeq } : undefined;
     return { prefix, atTokens: args.tokens, triggerTokens: args.triggerTokens,
         ...(source ? { source } : {}) };
 }
+/**
+ * Whether a main-thread compaction is a budget crossing at the automatic target where
+ * preparations exist: the turns that may race one (a dropped crossing turn and the next
+ * prompt) are serialized on its lane, as carryFor carries it.
+ */
+function isAutoCrossing(rec, model, modelContextLimit) {
+    const compaction = rec.compaction;
+    return compaction?.mode === "auto" &&
+        (compaction.reason === "budget" || compaction.reason === "prefix-mismatch") &&
+        preparesCompression(model, modelContextLimit);
+}
+/** A main-thread compaction's CarryOver, when its plan has the automatic target. */
+function carryFor(args) {
+    const compaction = args.rec.compaction;
+    // Where prepared prefixes exist (preparesCompression): the turn after rides it. Not a
+    // /memtree-compact (adoption refuses it) nor beside a preparation (the carry would be
+    // refused, its call left running for nothing).
+    if (!args.isMainRequest || args.sessionId === undefined || args.explicitTarget !== false ||
+        args.targetTokens === undefined || compaction?.mode !== "auto" ||
+        // A crossing only: a call the server decides (maybe a passthrough) is not waited for.
+        (compaction.reason !== "budget" && compaction.reason !== "prefix-mismatch") || args.state.compactNow.has(args.sessionId) ||
+        args.state.preparing.has(args.sessionId) || args.state.prepared.isInFlight(args.sessionId) ||
+        args.state.backgroundSignal.aborted ||
+        !preparesCompression(args.body.model, args.modelContextLimit))
+        return undefined;
+    return { body: args.body, messages: args.messages, msgsForMemtree: args.msgsForMemtree,
+        sessionId: args.sessionId, modelContextLimit: args.modelContextLimit,
+        tokens: compaction.estimatedTokens ?? 0, triggerTokens: compaction.budgetTokens,
+        targetTokens: args.targetTokens, explicitTarget: false,
+        ...(args.linkSeq !== undefined ? { linkSeq: args.linkSeq } : {}),
+        base: args.state.stablePrefixes.get(args.sessionId) };
+}
+/**
+ * A main-thread compaction its turn stopped waiting for (its budget ran out) becomes the
+ * session's preparation: it runs on to the long budget, the session's next turn at the
+ * budget waits for it (awaitPreparation) instead of starting another, and rides its
+ * answer as a prepared prefix. Before, each turn gave up on its call and started a new
+ * 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) {
+    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) ||
+        state.stablePrefixes.get(sessionId) !== base ||
+        !state.prepared.begin(sessionId, carry.tokens, carry.triggerTokens))
+        return false;
+    const done = pending
+        .then((result) => {
+        // A late answer clears the cooldown; a late failure is no new outage evidence (a
+        // refusal or a slow server's timeout must not arm it, as runBlockingCompression).
+        if (result)
+            noteMemtreeHealth(state, { result, liveHealth: "success" });
+        return result ? preparedFromResult(carry, result) : undefined;
+    })
+        .catch(() => undefined)
+        .then((prepared) => {
+        // A prefix installed meanwhile supersedes it.
+        const current = state.stablePrefixes.get(sessionId) === base;
+        state.prepared.finish(sessionId, current ? prepared : undefined);
+        if (state.preparing.get(sessionId) === done)
+            state.preparing.delete(sessionId);
+    });
+    boundedSet(state.preparing, sessionId, done);
+    return true;
+}
+/** 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;
+function carriedBudgetMs(opts, scaledMs) {
+    return Math.min(MAX_LONG_COMPRESS_WAIT_MS, Math.max(opts.memtree.longCompressBudgetMs, scaledMs));
+}
 /** What a prepare call sends: a forced compression to the target, no threshold. */
 function preparedCompressMeta(args) {
     const { opts, body, sessionId, msgsForMemtree, modelContextLimit } = args;
@@ -3548,7 +4033,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;
         }
     }
@@ -3912,6 +4397,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
@@ -3922,7 +4555,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);
@@ -3931,9 +4564,13 @@ async function runBlockingCompression(args) {
         : undefined;
     const messageTimes = transcriptTimesFor(opts, args.sessionId, args.agentId)?.(msgsForMemtree);
     const compressStarted = Date.now();
-    // The upload is about the request's size: the budget grows with it.
-    const budgetMs = Math.min(args.longBudget ? MAX_LONG_COMPRESS_WAIT_MS : MAX_COMPRESS_WAIT_MS, args.longBudget ? opts.memtree.longCompressBudgetMs
-        : opts.memtree.compressBudgetForBytes(rec.requestBytes));
+    // 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);
+    // 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;
     const compressMeta = {
         // Model + tools drive the server's model-based memory budget
         // (e.g. 800k whole-request target for Fable / Opus 5). Omitting
@@ -3962,8 +4599,8 @@ async function runBlockingCompression(args) {
         ...(args.sessionId !== undefined ? { sessionId: args.sessionId } : {}),
         ...(args.clientMeta ? { clientMeta: args.clientMeta } : {}),
         // The deadline this wait uses (the upload-scaled budget included), so the
-        // call and its waiters end together.
-        timeoutMs: budgetMs,
+        // call and its waiters end together; a carried call runs on to the long one.
+        timeoutMs: carry ? Math.max(budgetMs, carriedBudgetMs(opts, scaledMs)) : budgetMs,
     };
     // Sampled BEFORE the call, while it still describes this call: after the
     // await the hash is in the cache regardless of who put it there.
@@ -3972,12 +4609,21 @@ async function runBlockingCompression(args) {
     // Keep foreground work finite even if a transport ignores its abort signal.
     let deadline;
     const maximumWait = Math.min(args.longBudget ? MAX_LONG_COMPRESS_WAIT_MS : MAX_COMPRESS_WAIT_MS, Math.max(1, Number.isFinite(budgetMs) ? budgetMs : 15_000));
+    let settled = false;
+    // A refused carry is not aborted: the call may be shared (in-flight join) with a
+    // request that carried it.
+    const call = opts.memtree.compress(hash, msgsForMemtree, modelContextLimit, args.signal ?? state.shutdownSignal, compressMeta);
+    const settle = () => { settled = true; };
+    call.then(settle, settle);
     const result = await Promise.race([
-        opts.memtree.compress(hash, msgsForMemtree, modelContextLimit, args.signal ?? state.shutdownSignal, compressMeta),
+        call,
         new Promise((resolve) => { deadline = setTimeout(() => resolve(null), maximumWait); }),
     ]).finally(() => { if (deadline)
         clearTimeout(deadline); });
     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);
     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.
@@ -3985,6 +4631,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
@@ -3993,17 +4641,23 @@ async function runBlockingCompression(args) {
     // Budget-consumed heuristic: the client maps every failure to null, so a
     // null that took (roughly) the whole abort budget was almost certainly
     // the AbortSignal timeout, not a fast server error.
-    const timedOut = result === null && compressMs >= Math.min(budgetMs, maximumWait);
+    // A few ms of slack: a timer can fire a millisecond early by the wall clock (CI flake).
+    const timedOut = result === null &&
+        compressMs + TIMER_SLACK_MS >= Math.min(budgetMs, maximumWait);
     // A timeout while other compress calls answered (one succeeded after this
     // one started) is this call's size or the server's slow reply, not an outage: it arms no cooldown (2026-10-23:
     // healthy-server timeouts kept the fuse lit and a screenshot turn was refused).
     const othersAnswered = timedOut && (opts.memtree.lastCompressSuccessAt ?? 0) >= compressStarted;
-    const hadLiveFailure = !cached && result === null && failureArming && !othersAnswered;
+    // A carried call has not failed: it is still running (its answer reports its health).
+    const hadLiveFailure = !cached && result === null && failureArming && !othersAnswered && !carried;
     rec.compress = {
         ms: compressMs,
         ok: result !== null,
         timedOut,
-        ...(!cached && failureStatus === OVER_CONTEXT_STATUS ? { refused: true } : {}),
+        ...(carried ? { carriedOver: 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,
@@ -4013,6 +4667,7 @@ async function runBlockingCompression(args) {
             : hadLiveFailure
                 ? "failure"
                 : "none",
+        ...(indexWaitSeconds !== undefined ? { indexWaitSeconds } : {}),
     };
 }
 /**
@@ -4127,6 +4782,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);
@@ -4189,8 +4848,15 @@ async function recoverToolRouteMiss(args) {
     };
     res.once("close", markDownstreamClosed);
     const linkSeq = isMainRequest ? nextMemtreeCallSeq(state) : undefined;
+    const toolCarry = stable ? carryFor({ state, isMainRequest, sessionId, body, messages,
+        msgsForMemtree,
+        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,
@@ -4205,7 +4871,8 @@ 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 } : {}),
         });
     }
     catch {
@@ -4227,9 +4894,11 @@ async function recoverToolRouteMiss(args) {
     if (downstreamClosedDuringCompression ||
         (res.destroyed && !res.writableFinished)) {
         // The MemTree work keeps its cache/index value, but a dead client gets
-        // no Anthropic request and no route.
+        // no Anthropic request and no route. The session's next turn rides it.
         rec.routeRecovery = { conversationBytes, outcome: "client-closed" };
         releaseOwnReservation();
+        if (result && toolCarry)
+            carryOverCompression(state, toolCarry, Promise.resolve(result));
         // Same hazard class as the post-forward fates "upstream-failed" /
         // "client-aborted": no route was installed and the client's identical
         // retry is imminent, so no backoff is set and the attempt mark is
@@ -4245,11 +4914,18 @@ 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)
         // or a shutting-down proxy gets no retry.
+        // A carried compression still runs on this history (and indexes it): no upload beside it.
         if (!state.shutdownSignal.aborted &&
+            rec.compress?.carriedOver !== true &&
             opts.memtree.paymentRequiredDetail === null &&
             !opts.memtree.keyInvalid // a refused key refuses the index too
         ) {
@@ -4780,6 +5456,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")
@@ -4850,6 +5529,40 @@ function lateRecoveryPlan(state, rec, preferred, measured, limits, routeKey) {
     return preferred.kind === "original" && !fitsMeasured(measured, limits)
         ? { tokens: measured.tokens } : undefined;
 }
+/**
+ * Wait (up to `maxMs`, or until `signal` aborts) for the lane's in-flight compression to
+ * end; the milliseconds waited.
+ */
+async function waitForLaneIdle(state, routeKey, maxMs, signal) {
+    const started = Date.now();
+    while (state.toolRecoveryAttemptedLanes.get(routeKey)?.inFlight && !signal.aborted &&
+        !state.shutdownSignal.aborted && !state.backgroundSignal.aborted &&
+        Date.now() - started < maxMs) {
+        // Unref'd: a wait never holds the process open.
+        await new Promise((resolve) => setTimeout(resolve, LANE_WAIT_POLL_MS).unref());
+    }
+    return Date.now() - started;
+}
+/**
+ * The ride the lane's current memory route gives this request, read afresh (after a wait):
+ * undefined when there is none, it does not match this history, or (main lane) a newer
+ * stable prefix superseded it, which the planner then rides itself.
+ */
+function currentLaneRide(state, routeKey, body, messages, sessionId, isMainRequest) {
+    const route = getMemoryRoute(state, routeKey);
+    if (!route)
+        return undefined;
+    if (isMainRequest && sessionId !== undefined &&
+        route.stablePrefix !== state.stablePrefixes.get(sessionId))
+        return undefined;
+    const raw = memoryRoutedToolBody(body, messages, route, state.mainRouteEpoch, sessionId);
+    return raw ? { raw, turnType: "tool-memory", sizeHolder: route.stablePrefix ?? route }
+        : undefined;
+}
+/** Wall-clock slack when judging whether a call ran its whole budget (timers fire early). */
+const TIMER_SLACK_MS = 5;
+/** How often a turn waiting for its lane's compression looks again. */
+const LANE_WAIT_POLL_MS = 100;
 /**
  * Run a delivery-time compression as the lane's in-flight operation, so a
  * concurrent request of the lane neither starts its own (planning sees
@@ -4909,9 +5622,13 @@ 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 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) });
     args.rec.forwardedBytes = 0;
     args.rec.approxInputTokens = 0;
     // Nothing went out uncompressed: Claude Code retries it (2026-10-28).
@@ -4923,7 +5640,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,
@@ -4936,6 +5654,7 @@ 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 } : {}),
     };
     if (unpaid !== null || keyInvalid)
         cancelPausedNotice(args.state, args.rec);
@@ -4951,6 +5670,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.
@@ -5227,6 +5977,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");
@@ -5485,7 +6236,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);
         });
@@ -5637,6 +6388,7 @@ function passThroughStreaming(req, res, upstream, shutdownSignal) {
                 upstreamRes.destroy();
                 return;
             }
+            upstream.unreachable = undefined;
             activeUpstreamRes = upstreamRes;
             const onUpstreamResponseEnd = () => {
                 upstreamResponseEnded = true;
@@ -5682,7 +6434,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();
         });
@@ -5716,6 +6468,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) {