codex-copilot-dx 0.4.30 → 0.4.31

package/README.md

@@ -87,7 +87,7 @@ Or set:
 CCDX_CONFIGURE_CLAUDE_DESKTOP=1 npx codex-copilot-dx@latest
 ```
 
-This writes a local Claude App 3P gateway profile that points to the adapter root URL, such as `http://127.0.0.1:2026`. The profile uses a generated local bearer key unless `CCDX_CLAUDE_DESKTOP_API_KEY` is set. Restart Claude App after running the command.
+This writes a local Claude App 3P gateway profile that points to the adapter root URL, such as `http://127.0.0.1:2026`. The profile uses a generated local bearer key unless `CCDX_CLAUDE_DESKTOP_API_KEY` is set. Later starts restore that key only from the active managed profile when its gateway URL matches the adapter. Restart Claude App after running the command.
 
 When reusing an already-running adapter, Claude App profile updates require `CCDX_CLAUDE_DESKTOP_API_KEY` or `CCDX_PROXY_API_KEY` so the profile key matches the running process. Otherwise the existing adapter is left untouched.
 
@@ -120,7 +120,7 @@ Environment variables:
 | `CCDX_IMG_MAX_INPUT_PIXELS` | `40000000` | Maximum decoded pixels accepted by `sharp` for one image |
 | `CCDX_DISABLE_IMG_OPT` | unset | Set to `1` to disable image optimization |
 | `CCDX_CONFIGURE_CLAUDE_DESKTOP` | unset | Set to `1` to write the Claude App 3P gateway profile during startup |
-| `CCDX_CLAUDE_DESKTOP_API_KEY` | generated for opt-in setup | Bearer key written into the Claude App profile and recognized by the adapter for model discovery |
+| `CCDX_CLAUDE_DESKTOP_API_KEY` | managed profile or generated for opt-in setup | Explicit bearer key written into the Claude App profile and recognized by the adapter for model discovery |
 | `CCDX_CLAUDE_MODEL_ALIASES` | built-in Claude aliases | Comma-separated Desktop-to-upstream aliases, for example `claude-sonnet-4-6=claude-sonnet-4.6` |
 | `CCDX_GITHUB_TOKEN` | unset | Explicit GitHub Copilot OAuth token to validate and import before device login |
 | `CCDX_GITHUB_TOKEN_PATH` | unset | Explicit file containing a GitHub Copilot OAuth token to validate and import before device login |
@@ -130,7 +130,7 @@ Environment variables:
 | `CCDX_TOKEN_LOCK_TIMEOUT_MS` | `600000` | Maximum time to wait for another local process to finish GitHub token login/import |
 | `CCDX_TOKEN_LOCK_STALE_MS` | `900000` | Age after which a stale GitHub token lock file can be removed |
 | `CCDX_EXISTING_ADAPTER_TIMEOUT_MS` | `500` | Timeout for detecting an already-running local adapter during startup |
-| `CCDX_MODEL_REFRESH_INTERVAL_MS` | `1800000` | Interval for refreshing Copilot model metadata; successful lists are cached locally as last-known-good data |
+| `CCDX_MODEL_REFRESH_INTERVAL_MS` | `7200000` | Interval for refreshing Copilot model metadata; successful lists are cached locally as last-known-good data |
 | `CCDX_RESPONSE_HISTORY_MAX_BYTES` | `67108864` | Total in-memory byte budget for locally expanded Responses history |
 | `CCDX_RESPONSE_HISTORY_MAX_ENTRIES` | `4096` | Maximum stored incremental Responses history nodes |
 | `CCDX_USAGE_PATH` | `~/.local/share/codex-copilot-dx/usage.jsonl` | Local JSONL token usage log |

package/bin/cli.mjs

@@ -3,7 +3,7 @@
 import { ensureAuth, openCodex } from "../src/launcher.mjs";
 import { ensureCodexConfig } from "../src/config.mjs";
 import { ensureClaudeConfig } from "../src/claude-config.mjs";
-import { applyClaudeDesktopConfig, formatClaudeDesktopApplyResult, generatedClaudeDesktopApiKey } from "../src/claude-desktop-config.mjs";
+import { applyClaudeDesktopConfig, formatClaudeDesktopApplyResult, generatedClaudeDesktopApiKey, loadManagedClaudeDesktopApiKey } from "../src/claude-desktop-config.mjs";
 import { startAdapter } from "../src/adapter.mjs";
 import { cacheModelEndpoints, listModels, refreshVSCodeVersion } from "../src/copilot.mjs";
 import { claudeDesktopModelDefsFromCopilotModels, claudeDesktopModelIds, gptModelIdsFromCopilotModels, parseModelAliasEnv } from "../src/models.mjs";
@@ -14,7 +14,7 @@ import { checkForUpdate, localPackageVersion } from "../src/version.mjs";
 import { runDoctor } from "../src/doctor.mjs";
 import { checkRunningAdapter } from "../src/running-adapter.mjs";
 import { assertSafeAdapterHost, isLoopbackHost } from "../src/security.mjs";
-import { loadModelCache, saveModelCache } from "../src/model-cache.mjs";
+import { isValidModelList, loadModelCache, saveModelCache } from "../src/model-cache.mjs";
 import { initializeModelRegistry, runInBackground } from "../src/startup.mjs";
 import { cliHelp, parseCliArgs, parseRuntimeOptions } from "../src/cli-options.mjs";
 import { closeHttpServer } from "../src/shutdown.mjs";
@@ -57,7 +57,7 @@ const MODEL_REFRESH_TIMEOUT_MS = RUNTIME.modelRefreshTimeoutMs;
 const EXISTING_ADAPTER_TIMEOUT_MS = RUNTIME.existingAdapterTimeoutMs;
 const CONFIGURE_CLAUDE_DESKTOP = CLI.configureClaudeDesktop || process.env.CCDX_CONFIGURE_CLAUDE_DESKTOP === "1";
 const LOGGING = configureLogging();
-const MODEL_REGISTRY = { modelDefs: undefined, source: "built-in" };
+const MODEL_REGISTRY = { modelDefs: undefined, models: undefined, source: "built-in" };
 let activeServer = null;
 let modelRefreshTimer = null;
 let shuttingDown = false;
@@ -68,13 +68,16 @@ if (LOGGING.filePath) {
 }
 
 function applyModelsToRegistry(models, source, { updateClaudeModels = true } = {}) {
+  if (!isValidModelList(models)) throw new Error("Copilot models response contained no valid models");
   const modelDefs = updateClaudeModels
     ? claudeDesktopModelDefsFromCopilotModels(models)
     : MODEL_REGISTRY.modelDefs;
-  if (updateClaudeModels && !modelDefs.length) throw new Error("Copilot models response contained no Claude models");
   cacheModelEndpoints(models);
-  if (updateClaudeModels) MODEL_REGISTRY.modelDefs = modelDefs;
-  MODEL_REGISTRY.source = source;
+  MODEL_REGISTRY.models = models;
+  if (updateClaudeModels && modelDefs.length) {
+    MODEL_REGISTRY.modelDefs = modelDefs;
+    MODEL_REGISTRY.source = source;
+  }
   return modelDefs;
 }
 
@@ -116,8 +119,10 @@ async function refreshClaudeDesktopModelDefs() {
     }
     if (customAliases) {
       console.log(status("info", "Using CCDX_CLAUDE_MODEL_ALIASES for Claude models"));
-    } else {
+    } else if (modelDefs?.length) {
       console.log(status("ok", `Refreshed Claude models from GitHub Copilot: ${modelDefs.map((model) => model.id).join(", ")}`));
+    } else {
+      console.log(status("warn", "Copilot models response contained no Claude models; using built-in Claude models"));
     }
     return modelDefs;
   } catch (e) {
@@ -130,7 +135,7 @@ async function refreshClaudeDesktopModelDefs() {
 }
 
 function currentClaudeDesktopApiKey() {
-  return process.env.CCDX_CLAUDE_DESKTOP_API_KEY || process.env.CCDX_PROXY_API_KEY || "";
+  return String(process.env.CCDX_CLAUDE_DESKTOP_API_KEY || process.env.CCDX_PROXY_API_KEY || "").trim();
 }
 
 async function reuseRunningAdapterIfAvailable() {
@@ -222,9 +227,17 @@ try {
     console.log(status("warn", `ADAPTER_HOST=${ADAPTER_HOST} exposes the adapter beyond loopback because CCDX_ALLOW_LAN=1 is set. Use only on trusted networks.`));
   }
 
-  const claudeDesktopApiKey = CONFIGURE_CLAUDE_DESKTOP
-    ? (currentClaudeDesktopApiKey() || generatedClaudeDesktopApiKey())
-    : currentClaudeDesktopApiKey();
+  const configuredClaudeDesktopApiKey = currentClaudeDesktopApiKey();
+  const restoredClaudeDesktopApiKey = configuredClaudeDesktopApiKey ? "" : loadManagedClaudeDesktopApiKey({
+    port: ADAPTER_PORT,
+    host: ADAPTER_HOST,
+  });
+  if (restoredClaudeDesktopApiKey) {
+    console.log(status("ok", "Restored Claude App gateway key from the managed profile"));
+  }
+  const claudeDesktopApiKey = configuredClaudeDesktopApiKey
+    || restoredClaudeDesktopApiKey
+    || (CONFIGURE_CLAUDE_DESKTOP ? generatedClaudeDesktopApiKey() : "");
 
   // Start the in-process adapter.
   activeServer = await startAdapter(ADAPTER_PORT, ADAPTER_HOST, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.4.30",
+  "version": "0.4.31",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "type": "module",
   "bin": {

package/src/adapter.mjs

@@ -4,6 +4,7 @@ import { chatCompletions, listModels, responses as copilotResponses, responsesCo
 import { webStreamLines } from "./stream.mjs";
 import { anthropicToChat, chatToAnthropic, streamAnthropicFromLines, countTokens } from "./anthropic.mjs";
 import { CODEX_AUTO_REVIEW_MODEL, claudeDesktopModelsResponse, resolveAnthropicModel, resolveOpenAIModel, modelIsResponsesOnly, modelSupportsChatCompletions } from "./models.mjs";
+import { isValidModelList } from "./model-cache.mjs";
 import { status } from "./status.mjs";
 import { recordAnthropicUsage, recordResponsesUsage } from "./usage.mjs";
 import { ADAPTER_HEALTH_PATH, adapterHealthPayload } from "./running-adapter.mjs";
@@ -102,6 +103,20 @@ export function shouldServeClaudeDesktopModels(req, claudeDesktopApiKey) {
   return token === claudeDesktopApiKey || xApiKey === claudeDesktopApiKey;
 }
 
+function modelListCanUseLastKnownGood(statusCode) {
+  return [408, 425, 429].includes(statusCode) || statusCode >= 500;
+}
+
+function sendLastKnownGoodModels(res, modelRegistry) {
+  if (!isValidModelList(modelRegistry?.models) || res.destroyed || res.writableEnded) return false;
+  res.writeHead(200, {
+    "Content-Type": "application/json",
+    "X-CCDX-Model-Source": "last-known-good",
+  });
+  res.end(JSON.stringify(modelRegistry.models));
+  return true;
+}
+
 function responsesInputItems(input, { clone = true } = {}) {
   if (input === undefined || input === null) return [];
   if (typeof input === "string") {
@@ -784,16 +799,13 @@ export function createAdapterHandler(options = {}) {
                 res.end(JSON.stringify(resp));
               } catch (e) {
                 logRequestFailure("Responses", e, abort);
-                if (!res.destroyed && !res.writableEnded) {
-                  if (!res.headersSent) res.writeHead(e?.statusCode || 502);
-                  res.end("Bad Gateway");
-                }
+                sendJsonError(res, e, 502);
               }
             }
           }
         } catch (e) {
           logRequestFailure("Responses", e, abort);
-          sendJsonError(res, e);
+          sendJsonError(res, e, 502);
         } finally {
           abort.cleanup();
         }
@@ -823,7 +835,7 @@ export function createAdapterHandler(options = {}) {
           });
         } catch (e) {
           logRequestFailure("Responses compact", e, abort);
-          sendJsonError(res, e);
+          sendJsonError(res, e, 502);
         } finally {
           abort.cleanup();
         }
@@ -840,9 +852,29 @@ export function createAdapterHandler(options = {}) {
       const abort = createRequestAbort(req, res);
       abort.setTimeout(upstreamTimeoutMs);
       listModelsFn({ signal: abort.signal })
-        .then(({ status, body }) => { res.writeHead(status, { "Content-Type": "application/json" }); res.end(body); })
+        .then(({ status, body }) => {
+          if (status >= 200 && status < 300) {
+            let models;
+            try { models = JSON.parse(body); } catch {}
+            if (isValidModelList(models)) {
+              if (options.modelRegistry) {
+                options.modelRegistry.models = models;
+              }
+              res.writeHead(status, { "Content-Type": "application/json" });
+              res.end(body);
+              return;
+            }
+            if (sendLastKnownGoodModels(res, options.modelRegistry)) return;
+            sendJsonError(res, httpError("Copilot models response contained no valid models", 502), 502);
+            return;
+          }
+          if (modelListCanUseLastKnownGood(status) && sendLastKnownGoodModels(res, options.modelRegistry)) return;
+          res.writeHead(status, { "Content-Type": "application/json" });
+          res.end(body);
+        })
         .catch((e) => {
           logRequestFailure("Models", e, abort);
+          if (sendLastKnownGoodModels(res, options.modelRegistry)) return;
           if (!res.destroyed && !res.writableEnded) {
             if (!res.headersSent) res.writeHead(e?.statusCode || 502);
             res.end(JSON.stringify({ error: e.message }));
@@ -927,7 +959,7 @@ export function createAdapterHandler(options = {}) {
           }
         } catch (e) {
           logRequestFailure("Messages", e, abort);
-          sendJsonError(res, e);
+          sendJsonError(res, e, 502);
         } finally {
           abort.cleanup();
         }

package/src/anthropic.mjs

@@ -161,6 +161,7 @@ export async function streamAnthropicFromLines(lineIterator, emit, model, option
   let finishReason = null;
   const toolBlocks = {}; // openaiIndex -> { anthropicIndex }
   let sawToolUse = false;
+  const trailingTextChunks = [];
   let outputTokens = 0;
 
   const ensureStart = async () => {
@@ -199,10 +200,14 @@ export async function streamAnthropicFromLines(lineIterator, emit, model, option
     const delta = choice.delta || {};
     await ensureStart();
 
-    if (delta.content && !sawToolUse) {
-      await openText();
-      await emit("content_block_delta", { type: "content_block_delta", index: blockIndex,
-        delta: { type: "text_delta", text: delta.content } });
+    if (delta.content) {
+      if (sawToolUse) {
+        trailingTextChunks.push(delta.content);
+      } else {
+        await openText();
+        await emit("content_block_delta", { type: "content_block_delta", index: blockIndex,
+          delta: { type: "text_delta", text: delta.content } });
+      }
     }
 
     if (Array.isArray(delta.tool_calls)) {
@@ -231,6 +236,14 @@ export async function streamAnthropicFromLines(lineIterator, emit, model, option
   for (const oi of Object.keys(toolBlocks)) {
     await emit("content_block_stop", { type: "content_block_stop", index: toolBlocks[oi].anthropicIndex });
   }
+  if (trailingTextChunks.length) {
+    await openText();
+    for (const text of trailingTextChunks) {
+      await emit("content_block_delta", { type: "content_block_delta", index: blockIndex,
+        delta: { type: "text_delta", text } });
+    }
+    await closeText();
+  }
 
   const stop_reason = finishReason ? mapStopReason(finishReason) : (sawToolUse ? "tool_use" : "end_turn");
   await emit("message_delta", { type: "message_delta", delta: { stop_reason, stop_sequence: null },

package/src/claude-desktop-config.mjs

@@ -159,6 +159,34 @@ function readActiveProfile(paths) {
   return readJsonFile(path.join(paths.configLibraryPath, `${appliedId}.json`), {});
 }
 
+export function loadManagedClaudeDesktopApiKey({
+  port = 2026,
+  host = "127.0.0.1",
+  home = os.homedir(),
+  platform = process.platform,
+  env = process.env,
+} = {}) {
+  try {
+    const paths = claudeDesktopPaths(home, platform, env);
+    const meta = readJsonFile(paths.metaPath, {});
+    if (String(meta.appliedId || "").trim() !== DEFAULT_CLAUDE_DESKTOP_PROFILE_ID) return "";
+
+    const profilePath = path.join(paths.configLibraryPath, `${DEFAULT_CLAUDE_DESKTOP_PROFILE_ID}.json`);
+    const profile = readJsonFile(profilePath, {});
+    if (profile.inferenceProvider !== "gateway") return "";
+    if (String(profile.inferenceGatewayAuthScheme || "").trim().toLowerCase() !== "bearer") return "";
+
+    const profileBaseUrl = String(profile.inferenceGatewayBaseUrl || "").trim();
+    validateClaudeDesktopBaseUrl(profileBaseUrl);
+    if (new URL(profileBaseUrl).href !== new URL(localGatewayBaseUrl(host, port)).href) return "";
+
+    const apiKey = String(profile.inferenceGatewayApiKey || "").trim();
+    return apiKey && apiKey !== "dummy" ? apiKey : "";
+  } catch {
+    return "";
+  }
+}
+
 export function applyClaudeDesktopConfig({
   port = 2026,
   host = "127.0.0.1",

package/src/cli-options.mjs

@@ -51,7 +51,7 @@ export function parseRuntimeOptions(env = process.env) {
     adapterHost: String(env.ADAPTER_HOST || "127.0.0.1").trim() || "127.0.0.1",
     modelRefreshTimeoutMs: integerEnv(env, "CCDX_MODEL_REFRESH_TIMEOUT_MS", 5000, { min: 1 }),
     existingAdapterTimeoutMs: integerEnv(env, "CCDX_EXISTING_ADAPTER_TIMEOUT_MS", 500, { min: 1 }),
-    modelRefreshIntervalMs: integerEnv(env, "CCDX_MODEL_REFRESH_INTERVAL_MS", 30 * 60 * 1000, { min: 0 }),
+    modelRefreshIntervalMs: integerEnv(env, "CCDX_MODEL_REFRESH_INTERVAL_MS", 2 * 60 * 60 * 1000, { min: 0 }),
     upstreamTimeoutMs: integerEnv(env, "CCDX_UPSTREAM_TIMEOUT_MS", 120000, { min: 1 }),
     streamHandshakeTimeoutMs: integerEnv(env, "CCDX_STREAM_HANDSHAKE_TIMEOUT_MS", 120000, { min: 1 }),
     streamIdleTimeoutMs: integerEnv(env, "CCDX_STREAM_IDLE_TIMEOUT_MS", 120000, { min: 1 }),

package/src/http-transport.mjs

@@ -101,10 +101,10 @@ async function decodeRequestBuffer(buffer, contentEncoding, maxBytes) {
     } else if (encoding === "br") {
       decoded = await decompressBody(brotliDecompressAsync, decoded, maxBytes);
     } else if (encoding === "zstd") {
-      if (!zstdDecompressAsync) throw new Error("Unsupported Content-Encoding: zstd");
+      if (!zstdDecompressAsync) throw httpError("Unsupported Content-Encoding: zstd", 415);
       decoded = await decompressBody(zstdDecompressAsync, decoded, maxBytes);
     } else {
-      throw new Error(`Unsupported Content-Encoding: ${encoding}`);
+      throw httpError(`Unsupported Content-Encoding: ${encoding}`, 415);
     }
     if (decoded.length > maxBytes) throw payloadTooLarge("Decoded", maxBytes);
   }
@@ -112,17 +112,31 @@ async function decodeRequestBuffer(buffer, contentEncoding, maxBytes) {
   return decoded;
 }
 
+function parseRequestJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    throw httpError(`Invalid JSON request body: ${e.message}`, 400);
+  }
+}
+
 export async function readJsonBody(req, {
   maxBodyBytes = MAX_BODY_BYTES,
   maxDecodedBodyBytes = MAX_DECODED_BODY_BYTES,
 } = {}) {
   const encodings = contentEncodings(req.headers?.["content-encoding"]);
   if (encodings.every((encoding) => encoding === "identity")) {
-    return JSON.parse(await readIdentityText(req, maxBodyBytes, maxDecodedBodyBytes));
+    return parseRequestJson(await readIdentityText(req, maxBodyBytes, maxDecodedBodyBytes));
   }
   const buffer = await readRequestBuffer(req, maxBodyBytes);
-  const decoded = await decodeRequestBuffer(buffer, req.headers?.["content-encoding"], maxDecodedBodyBytes);
-  return JSON.parse(decoded.toString("utf8"));
+  let decoded;
+  try {
+    decoded = await decodeRequestBuffer(buffer, req.headers?.["content-encoding"], maxDecodedBodyBytes);
+  } catch (e) {
+    if (e?.statusCode) throw e;
+    throw httpError(`Invalid compressed request body: ${e.message}`, 400);
+  }
+  return parseRequestJson(decoded.toString("utf8"));
 }
 
 export function sendJsonError(res, err, fallbackStatus = 400) {
@@ -167,7 +181,7 @@ export function isAbortLikeError(err) {
 export function abortErrorStatusCode(reason) {
   if (["upstream_timeout", "stream_handshake_timeout", "stream_idle_timeout"].includes(reason)) return 504;
   if (reason === "client_aborted" || reason === "client_closed") return 499;
-  return 400;
+  return 502;
 }
 
 export function createRequestAbort(req, res) {

package/src/model-cache.mjs

@@ -10,7 +10,12 @@ export function modelCachePath(home = os.homedir()) {
 
 function modelData(models) {
   const data = Array.isArray(models) ? models : models?.data;
-  return Array.isArray(data) ? data : null;
+  if (!Array.isArray(data) || !data.some((model) => String(model?.id || "").trim())) return null;
+  return data;
+}
+
+export function isValidModelList(models) {
+  return modelData(models) !== null;
 }
 
 export function loadModelCache({
@@ -22,7 +27,7 @@ export function loadModelCache({
     const parsed = JSON.parse(fs.readFileSync(modelCachePath(home), "utf8"));
     const savedAt = Date.parse(parsed.saved_at);
     if (!Number.isFinite(savedAt) || now() - savedAt > maxAgeMs) return null;
-    if (!modelData(parsed.models)) return null;
+    if (!isValidModelList(parsed.models)) return null;
     return parsed.models;
   } catch {
     return null;
@@ -30,7 +35,7 @@ export function loadModelCache({
 }
 
 export function saveModelCache(models, { home = os.homedir() } = {}) {
-  if (!modelData(models)) return false;
+  if (!isValidModelList(models)) return false;
   const filePath = modelCachePath(home);
   const tempPath = `${filePath}.${process.pid}.tmp`;
   fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });

package/src/response-history.mjs

@@ -73,6 +73,7 @@ function jsonByteLength(value, seen = new Set()) {
 
 const histories = new Map();
 const childrenById = new Map();
+const treeLru = new Map();
 const evictedIds = new Set();
 let totalBytes = 0;
 let maxBytes = positiveInt(process.env.CCDX_RESPONSE_HISTORY_MAX_BYTES, DEFAULT_MAX_BYTES);
@@ -83,6 +84,12 @@ function rememberEvictedId(id) {
   while (evictedIds.size > 256) evictedIds.delete(evictedIds.values().next().value);
 }
 
+function touchTree(rootId) {
+  if (!rootId) return;
+  treeLru.delete(rootId);
+  treeLru.set(rootId, true);
+}
+
 function linkChild(parentId, id) {
   if (!parentId) return;
   let children = childrenById.get(parentId);
@@ -104,6 +111,7 @@ function unlinkChild(parentId, id) {
 function removeSubtree(rootId) {
   const pending = [rootId];
   const removed = new Set();
+  const affectedRoots = new Set();
   while (pending.length) {
     const id = pending.pop();
     if (removed.has(id)) continue;
@@ -114,25 +122,46 @@ function removeSubtree(rootId) {
   for (const id of removed) {
     const entry = histories.get(id);
     if (!entry) continue;
+    affectedRoots.add(entry.rootId);
     unlinkChild(entry.parentId, id);
     childrenById.delete(id);
     totalBytes -= entry.bytes;
     histories.delete(id);
     rememberEvictedId(id);
   }
+  for (const affectedRoot of affectedRoots) {
+    const entry = histories.get(affectedRoot);
+    if (!entry || entry.rootId !== affectedRoot) treeLru.delete(affectedRoot);
+  }
+  if (!histories.has(rootId)) treeLru.delete(rootId);
+}
+
+function assignSubtreeRoot(id, rootId) {
+  const pending = [id];
+  const seen = new Set();
+  while (pending.length) {
+    const currentId = pending.pop();
+    if (seen.has(currentId)) continue;
+    seen.add(currentId);
+    const entry = histories.get(currentId);
+    if (entry) entry.rootId = rootId;
+    const children = childrenById.get(currentId);
+    if (children) pending.push(...children);
+  }
 }
 
 function enforceLimits() {
   while (histories.size > maxEntries || totalBytes > maxBytes) {
-    const oldestId = histories.keys().next().value;
-    if (!oldestId) break;
-    removeSubtree(oldestId);
+    const oldestRootId = treeLru.keys().next().value;
+    if (!oldestRootId) break;
+    removeSubtree(oldestRootId);
   }
 }
 
 export function clearResponseHistoryForTests() {
   histories.clear();
   childrenById.clear();
+  treeLru.clear();
   evictedIds.clear();
   totalBytes = 0;
   maxBytes = DEFAULT_MAX_BYTES;
@@ -163,9 +192,12 @@ export function materializeResponseHistory(responseId) {
     chain.push(entry);
     currentId = entry.parentId;
   }
+  const rootId = chain[0]?.rootId;
   const items = [];
   for (const entry of chain.reverse()) items.push(...entry.inputItems, ...entry.outputItems);
-  return cloneJson(items);
+  const materialized = cloneJson(items);
+  touchTree(rootId);
+  return materialized;
 }
 
 export function rememberResponseHistoryNode({ id, parentId, inputItems, outputItems, takeOwnership = false }) {
@@ -176,20 +208,30 @@ export function rememberResponseHistoryNode({ id, parentId, inputItems, outputIt
     rememberEvictedId(id);
     return;
   }
+  const existing = histories.get(id);
+  const parentEntry = parentId ? histories.get(parentId) : null;
+  const rootId = parentEntry?.rootId || (parentId ? existing?.rootId : id) || id;
   const entry = {
     parentId: parentId || null,
+    rootId,
     inputItems: takeOwnership ? inputItems : cloneJson(inputItems),
     outputItems: takeOwnership ? outputItems : cloneJson(outputItems),
     bytes,
   };
-  const existing = histories.get(id);
+  const oldRootId = existing?.rootId;
   if (existing) {
     totalBytes -= existing.bytes;
     unlinkChild(existing.parentId, id);
   }
   histories.set(id, entry);
   linkChild(entry.parentId, id);
+  if (oldRootId && oldRootId !== rootId) {
+    assignSubtreeRoot(id, rootId);
+    const oldRoot = histories.get(oldRootId);
+    if (!oldRoot || oldRoot.rootId !== oldRootId) treeLru.delete(oldRootId);
+  }
   totalBytes += entry.bytes;
   evictedIds.delete(id);
+  touchTree(rootId);
   enforceLimits();
 }