claude-use 11.4.0 → 11.5.0

package/dist/cli.cjs

@@ -23007,7 +23007,7 @@ var require_dumper = __commonJS({
       }
       return false;
     }
-    function isWhitespace(c10) {
+    function isWhitespace2(c10) {
       return c10 === CHAR_SPACE || c10 === CHAR_TAB;
     }
     function isPrintable(c10) {
@@ -23019,19 +23019,19 @@ var require_dumper = __commonJS({
     }
     function isPlainSafe(c10, prev, inblock) {
       const cIsNsCharOrWhitespace = isNsCharOrWhitespace(c10);
-      const cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c10);
+      const cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace2(c10);
       return (
         // ns-plain-safe
         (inblock ? cIsNsCharOrWhitespace : cIsNsCharOrWhitespace && // - c-flow-indicator
         c10 !== CHAR_COMMA && c10 !== CHAR_LEFT_SQUARE_BRACKET && c10 !== CHAR_RIGHT_SQUARE_BRACKET && c10 !== CHAR_LEFT_CURLY_BRACKET && c10 !== CHAR_RIGHT_CURLY_BRACKET) && // ns-plain-char
         c10 !== CHAR_SHARP && // false on '#'
         !(prev === CHAR_COLON && !cIsNsChar) || // false on ': '
-        isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c10 === CHAR_SHARP || // change to true on '[^ ]#'
+        isNsCharOrWhitespace(prev) && !isWhitespace2(prev) && c10 === CHAR_SHARP || // change to true on '[^ ]#'
         prev === CHAR_COLON && cIsNsChar
       );
     }
     function isPlainSafeFirst(c10) {
-      return isPrintable(c10) && c10 !== CHAR_BOM && !isWhitespace(c10) && // - s-white
+      return isPrintable(c10) && c10 !== CHAR_BOM && !isWhitespace2(c10) && // - s-white
       // - (c-indicator ::=
       // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
       c10 !== CHAR_MINUS && c10 !== CHAR_QUESTION && c10 !== CHAR_COLON && c10 !== CHAR_COMMA && c10 !== CHAR_LEFT_SQUARE_BRACKET && c10 !== CHAR_RIGHT_SQUARE_BRACKET && c10 !== CHAR_LEFT_CURLY_BRACKET && c10 !== CHAR_RIGHT_CURLY_BRACKET && // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"”
@@ -23039,7 +23039,7 @@ var require_dumper = __commonJS({
       c10 !== CHAR_PERCENT && c10 !== CHAR_COMMERCIAL_AT && c10 !== CHAR_GRAVE_ACCENT;
     }
     function isPlainSafeLast(c10) {
-      return !isWhitespace(c10) && c10 !== CHAR_COLON;
+      return !isWhitespace2(c10) && c10 !== CHAR_COLON;
     }
     function codePointAt(string4, pos) {
       const first = string4.charCodeAt(pos);
@@ -27111,7 +27111,7 @@ var init_schema = __esm({
         context.addIssue({ code: "custom", path: ["readMaturation"], message: "readMaturation needs rolloutChannel beta or dev" });
       }
     });
-    HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@ca7589c574bfd52919503a74f09f4d1fe5ecf106";
+    HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@2dfa958e47814533751cdd0c5362d8f352ec5b75";
     HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES = 15;
     FRONTDOOR_DEFAULT_IDLE_SHUTDOWN_MINUTES = 15;
     FrontDoorGlobalConfigSchema = external_exports.strictObject({
@@ -31952,9 +31952,9 @@ function referencesFact(when, key) {
   if (when === void 0 || !("kind" in when)) {
     return false;
   }
-  const walk = (node2) => {
+  const walk2 = (node2) => {
     if (Array.isArray(node2)) {
-      return node2.some(walk);
+      return node2.some(walk2);
     }
     if (typeof node2 !== "object" || node2 === null) {
       return false;
@@ -31962,9 +31962,9 @@ function referencesFact(when, key) {
     if ("kind" in node2 && node2.kind === "reference" && "key" in node2 && node2.key === key) {
       return true;
     }
-    return Object.values(node2).some(walk);
+    return Object.values(node2).some(walk2);
   };
-  return walk(when);
+  return walk2(when);
 }
 function isVacuousWhen(when) {
   return when !== void 0 && !("kind" in when) && Object.keys(when).length === 0;
@@ -33976,7 +33976,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.4.0",
+      version: "11.5.0",
       description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
       license: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -34635,7 +34635,7 @@ function createUsageMiddleware(deps) {
       const endedAt = deps.now();
       deps.defer(() => {
         try {
-          deps.record(buildRecord(event, { headAt, endedAt, outcome, scan: scanning && scanner !== void 0 ? scanner.result() : void 0 }));
+          deps.record(buildRecord(event, { headAt, endedAt, outcome, scan: scanning && scanner !== void 0 ? scanner.result() : void 0 }), event);
         } catch (error63) {
           deps.log(`usage: could not record ${event.method} ${event.path} (${String(event.status)}): ${error63 instanceof Error ? error63.message : String(error63)}`);
         }
@@ -40329,7 +40329,7 @@ var require_webidl = __commonJS({
     var { runtimeFeatures } = require_runtime_features();
     var UNDEFINED = 1;
     var BOOLEAN = 2;
-    var STRING = 3;
+    var STRING2 = 3;
     var SYMBOL = 4;
     var NUMBER = 5;
     var BIGINT = 6;
@@ -40400,7 +40400,7 @@ var require_webidl = __commonJS({
         case "boolean":
           return BOOLEAN;
         case "string":
-          return STRING;
+          return STRING2;
         case "symbol":
           return SYMBOL;
         case "number":
@@ -40419,7 +40419,7 @@ var require_webidl = __commonJS({
     webidl.util.Types = {
       UNDEFINED,
       BOOLEAN,
-      STRING,
+      STRING: STRING2,
       SYMBOL,
       NUMBER,
       BIGINT,
@@ -40432,7 +40432,7 @@ var require_webidl = __commonJS({
           return "Undefined";
         case BOOLEAN:
           return "Boolean";
-        case STRING:
+        case STRING2:
           return "String";
         case SYMBOL:
           return "Symbol";
@@ -40518,7 +40518,7 @@ var require_webidl = __commonJS({
           return `Symbol(${V7.description})`;
         case OBJECT:
           return inspect(V7);
-        case STRING:
+        case STRING2:
           return `"${V7}"`;
         case BIGINT:
           return `${V7}n`;
@@ -60955,8 +60955,8 @@ var require_eventsource_stream = __commonJS({
     var BOM = [239, 187, 191];
     var LF3 = 10;
     var CR3 = 13;
-    var COLON = 58;
-    var SPACE2 = 32;
+    var COLON2 = 58;
+    var SPACE3 = 32;
     var DATA = Buffer.from("data");
     var EVENT = Buffer.from("event");
     var ID2 = Buffer.from("id");
@@ -61101,7 +61101,7 @@ var require_eventsource_stream = __commonJS({
         if (line.length === 0) {
           return;
         }
-        const colonPosition = line.indexOf(COLON);
+        const colonPosition = line.indexOf(COLON2);
         if (colonPosition === 0) {
           return;
         }
@@ -61110,7 +61110,7 @@ var require_eventsource_stream = __commonJS({
         if (colonPosition !== -1) {
           fieldLength = colonPosition;
           valueStart = colonPosition + 1;
-          if (line[valueStart] === SPACE2) {
+          if (line[valueStart] === SPACE3) {
             ++valueStart;
           }
         }
@@ -61304,7 +61304,7 @@ var require_eventsource = __commonJS({
     var experimentalWarned = false;
     var defaultReconnectionTime = 3e3;
     var CONNECTING = 0;
-    var OPEN = 1;
+    var OPEN2 = 1;
     var CLOSED = 2;
     var ANONYMOUS = "anonymous";
     var USE_CREDENTIALS = "use-credentials";
@@ -61437,7 +61437,7 @@ var require_eventsource = __commonJS({
             this.dispatchEvent(new Event("error"));
             return;
           }
-          this.#readyState = OPEN;
+          this.#readyState = OPEN2;
           this.dispatchEvent(new Event("open"));
           this.#state.origin = response.urlList[response.urlList.length - 1].origin;
           const eventSourceStream = new EventSourceStream({
@@ -61547,7 +61547,7 @@ var require_eventsource = __commonJS({
         __proto__: null,
         configurable: false,
         enumerable: true,
-        value: OPEN,
+        value: OPEN2,
         writable: false
       },
       CLOSED: {
@@ -62357,7 +62357,7 @@ function isAnthropicUsageStale(member, nowMs) {
 function poolIdentityNames(pools, poolName) {
   const seenPools = /* @__PURE__ */ new Set();
   const identities = /* @__PURE__ */ new Set();
-  const walk = (name) => {
+  const walk2 = (name) => {
     const pool = pools[name];
     if (pool === void 0 || seenPools.has(name)) {
       return;
@@ -62369,11 +62369,11 @@ function poolIdentityNames(pools, poolName) {
       if (nested === void 0) {
         identities.add(member);
       } else {
-        walk(nested);
+        walk2(nested);
       }
     }
   };
-  walk(poolName);
+  walk2(poolName);
   return [...identities];
 }
 function describeError(error63) {
@@ -109499,7 +109499,7 @@ function writePools(paths, pools) {
   applyPatch(paths.globalConfigFile, GlobalConfigSchema, { pools }, { defaults: {} });
 }
 function poolCycleOf(pools, name) {
-  const walk = (current, path59) => {
+  const walk2 = (current, path59) => {
     for (const entry of pools[current]?.identities ?? []) {
       const nested = poolNameOf(poolMemberIdentity(entry));
       if (nested === void 0) {
@@ -109511,14 +109511,14 @@ function poolCycleOf(pools, name) {
       if (path59.includes(nested)) {
         continue;
       }
-      const found = walk(nested, [...path59, nested]);
+      const found = walk2(nested, [...path59, nested]);
       if (found !== void 0) {
         return found;
       }
     }
     return void 0;
   };
-  return walk(name, [name]);
+  return walk2(name, [name]);
 }
 function validateMembers(pools, name, members2) {
   for (const entry of members2) {
@@ -112452,7 +112452,7 @@ function registerCodexCommand(program2, deps) {
 }
 
 // src/frontdoor/commands.ts
-var import_node_crypto20 = require("node:crypto");
+var import_node_crypto21 = require("node:crypto");
 var import_node_path51 = __toESM(require("node:path"), 1);
 var import_node_fs18 = __toESM(require("node:fs"), 1);
 init_commandDeps();
@@ -113671,8 +113671,11 @@ function createRoutingSettingReader(paths) {
 
 // src/frontdoor/headroomDecision.ts
 init_pick();
+var CONSECUTIVE_PREFIX_MISSES = 2;
+var SHORTEST_PROMPT_CACHE_TTL_MS = 3e5;
 function createHeadroomDecision(setting) {
   const sessions = /* @__PURE__ */ new Map();
+  const threads = /* @__PURE__ */ new Map();
   return {
     decide: async (sessionId, launchFlag, nowMs, available) => {
       const choice = choiceFor(setting(), sessionId);
@@ -113683,29 +113686,46 @@ function createHeadroomDecision(setting) {
       const state = sessions.get(sessionId);
       const forced = choice?.force !== void 0 && choice.force !== state?.appliedForce;
       const atBoundary = forced || state === void 0 || nowMs - state.lastEndedAtMs > PROMPT_CACHE_TTL_MS || state.cacheSurplusTokens <= 0;
-      const viaHeadroom = atBoundary ? wanted && await available() : state.viaHeadroom;
+      const prefixBroken = state?.prefixBroken ?? false;
+      const viaHeadroom = atBoundary ? wanted && !prefixBroken && await available() : state.viaHeadroom;
       sessions.set(sessionId, {
         viaHeadroom,
         lastEndedAtMs: state?.lastEndedAtMs ?? nowMs,
         cacheSurplusTokens: state?.cacheSurplusTokens ?? 0,
-        appliedForce: choice?.force ?? state?.appliedForce
+        appliedForce: choice?.force ?? state?.appliedForce,
+        prefixMisses: state?.prefixMisses ?? 0,
+        prefixBroken
       });
       return viaHeadroom;
     },
-    observe: ({ sessionId, endedAtMs, cache }) => {
+    observe: ({ sessionId, startedAtMs, endedAtMs, viaHeadroom, lineage, cache }) => {
       if (sessionId === void 0 || cache === void 0) {
         return;
       }
       const cacheSurplusTokens = cache.readTokens - cache.writtenTokens - cache.uncachedTokens;
       const state = sessions.get(sessionId);
+      let { prefixMisses, prefixBroken } = state ?? { prefixMisses: 0, prefixBroken: false };
+      if (lineage !== void 0) {
+        const previous = lineage.parentKey === void 0 ? void 0 : threads.get(`${sessionId}:${lineage.parentKey}`);
+        if (previous !== void 0 && previous.viaHeadroom && viaHeadroom && startedAtMs - previous.endedAtMs <= SHORTEST_PROMPT_CACHE_TTL_MS) {
+          prefixMisses = cache.readTokens < previous.cachedTokens ? prefixMisses + 1 : 0;
+          prefixBroken = prefixBroken || prefixMisses >= CONSECUTIVE_PREFIX_MISSES;
+        }
+        threads.set(`${sessionId}:${lineage.ownKey}`, { cachedTokens: cache.readTokens + cache.writtenTokens, endedAtMs, viaHeadroom });
+      }
       if (state !== void 0) {
-        sessions.set(sessionId, { ...state, lastEndedAtMs: endedAtMs, cacheSurplusTokens });
+        sessions.set(sessionId, { ...state, lastEndedAtMs: endedAtMs, cacheSurplusTokens, prefixMisses, prefixBroken });
       }
       for (const [id2, held] of sessions) {
         if (endedAtMs - held.lastEndedAtMs > PROMPT_CACHE_TTL_MS) {
           sessions.delete(id2);
         }
       }
+      for (const [id2, point] of threads) {
+        if (endedAtMs - point.endedAtMs > PROMPT_CACHE_TTL_MS) {
+          threads.delete(id2);
+        }
+      }
     }
   };
 }
@@ -126414,6 +126434,212 @@ function createLaunchEventPublisher(hub, now) {
 var http4 = __toESM(require("node:http"), 1);
 var import_consumers = require("node:stream/consumers");
 init_route();
+
+// src/frontdoor/lineage.ts
+var import_node_crypto18 = require("node:crypto");
+var CACHE_MARKER_KEY = '"cache_control"';
+var THREAD_MEMBER_KEYS = /* @__PURE__ */ new Set(['"model"', '"system"', '"tools"']);
+var MESSAGES_KEY = '"messages"';
+var NESTING_DEPTH_LIMIT = 64;
+var MESSAGES_PER_REQUEST_LIMIT = 1e5;
+var CONTEXT_WINDOW_TOKENS = 1e6;
+var BYTES_PER_TOKEN = 4;
+var LINEAGE_BODY_BYTES_LIMIT = CONTEXT_WINDOW_TOKENS * BYTES_PER_TOKEN;
+var MESSAGES_ARRAY_DEPTH = 2;
+var MESSAGES_PER_TURN = 2;
+var QUOTE = 34;
+var BACKSLASH = 92;
+var OPEN_BRACE = 123;
+var CLOSE_BRACE = 125;
+var OPEN_BRACKET = 91;
+var CLOSE_BRACKET = 93;
+var COLON = 58;
+var COMMA = 44;
+var SEPARATOR = Buffer.from([0]);
+var SPACE2 = 32;
+var TAB = 9;
+var LINE_FEED2 = 10;
+var CARRIAGE_RETURN = 13;
+function isWhitespace(byte) {
+  return byte === SPACE2 || byte === TAB || byte === LINE_FEED2 || byte === CARRIAGE_RETURN;
+}
+var STRING = 1;
+var OPEN = 2;
+var CLOSE = 3;
+var COLON_TOKEN = 4;
+var COMMA_TOKEN = 5;
+var SCALAR = 6;
+var END = 0;
+var tokenStart = 0;
+var tokenEnd = 0;
+function nextToken(body, from) {
+  let index = from;
+  while (index < body.length && isWhitespace(body[index] ?? 0)) {
+    index += 1;
+  }
+  if (index >= body.length) {
+    return END;
+  }
+  tokenStart = index;
+  const byte = body[index] ?? 0;
+  if (byte === QUOTE) {
+    let end = index + 1;
+    while (end < body.length && body[end] !== QUOTE) {
+      end += body[end] === BACKSLASH ? 2 : 1;
+    }
+    tokenEnd = Math.min(end + 1, body.length);
+    return STRING;
+  }
+  tokenEnd = index + 1;
+  if (byte === OPEN_BRACE || byte === OPEN_BRACKET) {
+    return OPEN;
+  }
+  if (byte === CLOSE_BRACE || byte === CLOSE_BRACKET) {
+    return CLOSE;
+  }
+  if (byte === COLON) {
+    return COLON_TOKEN;
+  }
+  if (byte === COMMA) {
+    return COMMA_TOKEN;
+  }
+  while (tokenEnd < body.length) {
+    const next = body[tokenEnd] ?? 0;
+    if (isWhitespace(next) || next === COMMA || next === CLOSE_BRACE || next === CLOSE_BRACKET || next === COLON) {
+      break;
+    }
+    tokenEnd += 1;
+  }
+  return SCALAR;
+}
+function walk(body, hashing, parentAfter) {
+  const thread = (0, import_node_crypto18.createHash)("sha256");
+  const messages = (0, import_node_crypto18.createHash)("sha256");
+  let parentDigest;
+  let elements = 0;
+  let depth = 0;
+  let topKey;
+  let inMessages = false;
+  let sawMessages = false;
+  const expectKey = [];
+  let skipUntilDepth;
+  let skipNextValue = false;
+  const elementEnded = () => {
+    elements += 1;
+    if (hashing && parentAfter !== void 0 && elements === parentAfter) {
+      parentDigest = messages.copy().digest("hex");
+    }
+    return elements > MESSAGES_PER_REQUEST_LIMIT;
+  };
+  const overLimit = () => ({ abandoned: true, sawMessages, elements, threadDigest: "", messagesDigest: "", parentDigest: void 0 });
+  let cursor3 = 0;
+  let lexicalTokens = 0;
+  for (; ; ) {
+    const kind = nextToken(body, cursor3);
+    if (kind === END) {
+      break;
+    }
+    lexicalTokens += 1;
+    if (lexicalTokens > CONTEXT_WINDOW_TOKENS) {
+      return overLimit();
+    }
+    const start = tokenStart;
+    const end = tokenEnd;
+    cursor3 = end;
+    if (skipUntilDepth !== void 0) {
+      if (kind === OPEN) {
+        depth += 1;
+      } else if (kind === CLOSE) {
+        depth -= 1;
+        if (depth === skipUntilDepth) {
+          skipUntilDepth = void 0;
+        }
+      }
+      continue;
+    }
+    if (kind === COMMA_TOKEN) {
+      if (depth >= 1) {
+        expectKey[depth - 1] = true;
+      }
+      continue;
+    }
+    if (kind === COLON_TOKEN) {
+      if (depth >= 1) {
+        expectKey[depth - 1] = false;
+      }
+      if (skipNextValue) {
+        skipNextValue = false;
+        const valueKind = nextToken(body, cursor3);
+        if (valueKind !== END) {
+          cursor3 = tokenEnd;
+          if (valueKind === OPEN) {
+            skipUntilDepth = depth;
+            depth += 1;
+          }
+        }
+      }
+      continue;
+    }
+    const isKey = kind === STRING && depth >= 1 && expectKey[depth - 1] === true;
+    const text2 = isKey ? body.toString("latin1", start, end) : void 0;
+    if (isKey && text2 === CACHE_MARKER_KEY) {
+      skipNextValue = true;
+      continue;
+    }
+    if (depth === 1 && isKey) {
+      topKey = text2;
+    }
+    const closesMessages = kind === CLOSE && inMessages && depth === MESSAGES_ARRAY_DEPTH;
+    if (hashing && !closesMessages && !(depth === 1 && isKey && !THREAD_MEMBER_KEYS.has(text2 ?? ""))) {
+      const target = inMessages ? messages : depth >= 1 && topKey !== void 0 && THREAD_MEMBER_KEYS.has(topKey) ? thread : void 0;
+      if (target !== void 0) {
+        target.update(body.subarray(start, end));
+        target.update(SEPARATOR);
+      }
+    }
+    if (kind === OPEN) {
+      if (depth >= NESTING_DEPTH_LIMIT) {
+        return { abandoned: true, sawMessages, elements, threadDigest: "", messagesDigest: "", parentDigest: void 0 };
+      }
+      const startsMessages = depth === 1 && topKey === MESSAGES_KEY && body[start] === OPEN_BRACKET && !sawMessages;
+      depth += 1;
+      expectKey.push(body[start] === OPEN_BRACE);
+      if (startsMessages) {
+        inMessages = true;
+        sawMessages = true;
+      }
+    } else if (kind === CLOSE) {
+      expectKey.pop();
+      depth -= 1;
+      if (inMessages && depth === 1) {
+        inMessages = false;
+      } else if (inMessages && depth === 2 && elementEnded()) {
+        return overLimit();
+      }
+    } else if (inMessages && depth === 2 && kind === SCALAR && elementEnded()) {
+      return overLimit();
+    }
+    if (depth < 0) {
+      break;
+    }
+  }
+  return { abandoned: false, sawMessages, elements, threadDigest: thread.digest("hex"), messagesDigest: messages.digest("hex"), parentDigest };
+}
+function lineageOf(body) {
+  if (body.length > LINEAGE_BODY_BYTES_LIMIT) {
+    return void 0;
+  }
+  const counted = walk(body, false, void 0);
+  if (counted.abandoned || !counted.sawMessages) {
+    return void 0;
+  }
+  const parentAfter = counted.elements > MESSAGES_PER_TURN ? counted.elements - MESSAGES_PER_TURN : void 0;
+  const hashed = walk(body, true, parentAfter);
+  const combine = (messagesDigest) => (0, import_node_crypto18.createHash)("sha256").update(hashed.threadDigest).update(messagesDigest).digest("hex");
+  return { ownKey: combine(hashed.messagesDigest), parentKey: hashed.parentDigest === void 0 ? void 0 : combine(hashed.parentDigest) };
+}
+
+// src/frontdoor/headroomHop.ts
 var HTTP_BAD_GATEWAY2 = HTTP_STATUS.badGateway;
 function responseHeaders(headers) {
   const result = {};
@@ -126425,7 +126651,7 @@ function responseHeaders(headers) {
   }
   return result;
 }
-async function applyHeadroomHop(request7, response, upstream, deps) {
+async function applyHeadroomHop(request7, response, upstream, deps, onThread) {
   const target = deps.headroomSocket();
   if (target === void 0) {
     await answerBadGateway(response, "agent-shim front door: the headroom daemon is restarting");
@@ -126461,7 +126687,7 @@ async function applyHeadroomHop(request7, response, upstream, deps) {
   }
   headers[HOP_SECRET_HEADER] = deps.hopSecret;
   try {
-    await forwardThroughHeadroom(request7, response, { socketPath, headers, log: deps.log });
+    await forwardThroughHeadroom(request7, response, { socketPath, headers, log: deps.log, onThread });
   } finally {
     if (hopId !== void 0) {
       deps.custody.release(hopId);
@@ -126503,19 +126729,59 @@ async function headroomReady(deps, signal) {
 }
 var HOP_RESET_RETRIES = 1;
 var HOP_RESET_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "EPIPE"]);
-async function collectBody(request7) {
-  try {
-    return await (0, import_consumers.buffer)(request7.body);
-  } catch {
-    return void 0;
-  }
+var BYTES_PER_MIB = 1048576;
+var MESSAGES_API_LIMIT_MIB = 32;
+var MAX_BODY_BYTES = MESSAGES_API_LIMIT_MIB * BYTES_PER_MIB;
+async function collectBody(body) {
+  return await new Promise((resolve2) => {
+    const chunks = [];
+    let size = 0;
+    let settled = false;
+    const settle2 = (result) => {
+      if (!settled) {
+        settled = true;
+        resolve2(result);
+      }
+    };
+    body.on("data", (chunk) => {
+      if (settled) {
+        return;
+      }
+      const piece = typeof chunk === "string" ? Buffer.from(chunk) : chunk instanceof Uint8Array ? Buffer.from(chunk) : void 0;
+      if (piece === void 0) {
+        settle2({ kind: "failed" });
+        return;
+      }
+      size += piece.length;
+      if (size > MAX_BODY_BYTES) {
+        chunks.length = 0;
+        settle2({ kind: "too-large" });
+        return;
+      }
+      chunks.push(piece);
+    });
+    body.on("end", () => {
+      settle2({ kind: "body", body: Buffer.concat(chunks) });
+    });
+    body.on("error", () => {
+      settle2({ kind: "failed" });
+    });
+  });
 }
 async function forwardThroughHeadroom(request7, response, target) {
-  const body = await collectBody(request7);
-  if (body === void 0) {
+  const collected = await collectBody(request7.body);
+  if (collected.kind === "failed") {
     response.destroy();
     return;
   }
+  if (collected.kind === "too-large") {
+    response.start(HTTP_STATUS.payloadTooLarge, { "Content-Type": "application/json" });
+    await response.write(JSON.stringify({ type: "error", error: { type: "request_too_large", message: "agent-shim front door: the request body is larger than the Messages API accepts" } }));
+    response.end();
+    return;
+  }
+  const { body } = collected;
+  target.onThread(lineageOf(body));
   for (let retriesLeft = HOP_RESET_RETRIES; ; retriesLeft -= 1) {
     const outcome = await hopOnce(request7, response, target, body, retriesLeft > 0);
     if (outcome === "settled") {
@@ -126655,7 +126921,7 @@ function createRoutedResponse(response, context) {
     start: (status, headers) => {
       for (const observe of deps.responseObservers) {
         try {
-          const body = observe({ session, route, method: request7.method, path: request7.path, receivedAt: request7.receivedAt, viaHeadroom: request7.viaHeadroom, status, headers });
+          const body = observe({ session, route, method: request7.method, path: request7.path, receivedAt: request7.receivedAt, viaHeadroom: request7.viaHeadroom, lineage: request7.thread.lineage, status, headers });
           if (body !== void 0) {
             bodyObservers.push(body);
           }
@@ -126696,7 +126962,7 @@ function createRoutedResponse(response, context) {
   };
 }
 async function serveRouted(request7, deps) {
-  const observed = { method: request7.method, path: pathOf(request7.url), receivedAt: deps.now(), viaHeadroom: false };
+  const observed = { method: request7.method, path: pathOf(request7.url), receivedAt: deps.now(), viaHeadroom: false, thread: { lineage: void 0 } };
   const identified = identifyRequest(request7.headers);
   const admission = deps.admit({ url: request7.url, headers: request7.headers, forwardable: identified.forwardableHeaders });
   if (!admission.ok) {
@@ -126723,12 +126989,14 @@ async function serveRouted(request7, deps) {
     return;
   }
   const { headroom } = deps;
-  const wantsHeadroom = await deps.headroomDecision.decide(identified.session.sessionId, identified.session.headroom, deps.now(), async () => headroom !== void 0 && await headroomReady(headroom, request7.signal));
+  const wantsHeadroom = headroom !== void 0 && await deps.headroomDecision.decide(identified.session.sessionId, identified.session.headroom, deps.now(), async () => await headroomReady(headroom, request7.signal));
   const viaHeadroom = wantsHeadroom && resolution.route.headroomEligible && deps.headroom !== void 0;
   const response = createRoutedResponse(request7.response, { deps, session: identified.session, route: resolution.route.name, request: { ...observed, viaHeadroom } });
   try {
     if (viaHeadroom) {
-      await applyHeadroomHop(routed, response, resolution.route.headroomUpstream, deps.headroom);
+      await applyHeadroomHop(routed, response, resolution.route.headroomUpstream, deps.headroom, (lineage) => {
+        observed.thread.lineage = lineage;
+      });
     } else {
       await resolution.route.serve(routed, response);
     }
@@ -126752,7 +127020,7 @@ init_load();
 init_schema();
 
 // src/codex/translate.ts
-var import_node_crypto18 = require("node:crypto");
+var import_node_crypto19 = require("node:crypto");
 init_schema();
 
 // src/codex/anthropic.ts
@@ -126867,7 +127135,7 @@ function shortToolName(name, names) {
   if (name.length <= CODEX_TOOL_NAME_LIMIT) {
     return name;
   }
-  const hash2 = (0, import_node_crypto18.createHash)("sha256").update(name).digest("hex").slice(0, TOOL_NAME_HASH_CHARS);
+  const hash2 = (0, import_node_crypto19.createHash)("sha256").update(name).digest("hex").slice(0, TOOL_NAME_HASH_CHARS);
   const shortened = `${name.slice(0, CODEX_TOOL_NAME_LIMIT - TOOL_NAME_HASH_CHARS - 1)}_${hash2}`;
   names.set(shortened, name);
   return shortened;
@@ -127914,7 +128182,7 @@ function attachingProviderCredential(route, deps) {
 init_realFrontDoorPort();
 
 // src/frontdoor/rcCommands.ts
-var import_node_crypto19 = require("node:crypto");
+var import_node_crypto20 = require("node:crypto");
 init_commandDeps();
 init_cliError();
 init_realPorts();
@@ -128521,8 +128789,8 @@ function registerRcCommand(frontdoor, paths) {
         identitiesDir: paths.identitiesDir,
         frontdoorDir: paths.frontdoorDir,
         identity,
-        newUuid: import_node_crypto19.randomUUID,
-        randomToken: () => (0, import_node_crypto19.randomBytes)(MINTED_TOKEN_RANDOM_BYTES).toString("base64url"),
+        newUuid: import_node_crypto20.randomUUID,
+        randomToken: () => (0, import_node_crypto20.randomBytes)(MINTED_TOKEN_RANDOM_BYTES).toString("base64url"),
         force: options.force === true,
         now: () => Date.now()
       });
@@ -130775,8 +131043,8 @@ function realFrontDoorSupervisorPorts(paths) {
   };
   const rcSelfHostSurface = rcSelfHost ? createRcSelfHostSurface({
     now: () => Date.now(),
-    newUuid: import_node_crypto20.randomUUID,
-    randomToken: () => (0, import_node_crypto20.randomBytes)(MINTED_TOKEN_RANDOM_BYTES).toString("base64url"),
+    newUuid: import_node_crypto21.randomUUID,
+    randomToken: () => (0, import_node_crypto21.randomBytes)(MINTED_TOKEN_RANDOM_BYTES).toString("base64url"),
     credentialRecord: () => readRcSelfHostRecord(realFarmFs, paths.frontdoorDir),
     webFetch: realRcWebFetch({ allowPrivate: rcWebFetchAllowsPrivateFromEnv(process.env) }),
     log
@@ -130799,7 +131067,7 @@ function realFrontDoorSupervisorPorts(paths) {
     saveSequenceNum: rcCredentialStore.writeCursor,
     dial: rcSelfHost ? lateRcStreamDial(rcSelfHostDialTarget) : realRcStreamDial(),
     fanout: rcFanout,
-    newClientId: import_node_crypto20.randomUUID,
+    newClientId: import_node_crypto21.randomUUID,
     backoffMs: RC_STREAM_BACKOFF_MS,
     sleep: async (ms2) => {
       await new Promise((resolve2) => {
@@ -130811,7 +131079,7 @@ function realFrontDoorSupervisorPorts(paths) {
     }
   });
   const routingSnapshots = /* @__PURE__ */ new Map();
-  const rcControlToken = (0, import_node_crypto20.randomUUID)();
+  const rcControlToken = (0, import_node_crypto21.randomUUID)();
   const resolveRoute = rcObservingResolver(
     createProviderRouteResolver({
       fs: realFsPort,
@@ -130902,10 +131170,13 @@ function realFrontDoorSupervisorPorts(paths) {
   const recordUsage = withQuotaRefresh(usageStore.record, quotaRefresher);
   const usageMiddleware = createUsageMiddleware({
     // Each finished response also tells the per-session headroom decision when the session's cache was last touched and whether it read from it.
-    record: (record2) => {
+    record: (record2, event) => {
       const { usage } = record2;
       headroomDecision.observe({
         sessionId: record2.sessionId,
+        startedAtMs: Date.parse(record2.at),
+        viaHeadroom: record2.viaHeadroom === true,
+        lineage: event.lineage,
         endedAtMs: Date.parse(record2.at) + record2.durationMs,
         cache: usage === void 0 ? void 0 : { readTokens: usage.cacheReadInputTokens ?? 0, writtenTokens: usage.cacheCreationInputTokens ?? 0, uncachedTokens: usage.inputTokens ?? 0 }
       });
@@ -130924,9 +131195,9 @@ function realFrontDoorSupervisorPorts(paths) {
     now: () => Date.now(),
     headroomSocket: () => headroomSocketTarget(realFarmFs, realHeadroomSocketTrust, paths),
     // The per-generation capability the direct listener demands: held only in this process's memory, so a loopback process that discovers the direct port still cannot use it.
-    hopSecret: (0, import_node_crypto20.randomUUID)(),
+    hopSecret: (0, import_node_crypto21.randomUUID)(),
     headroomDecision,
-    custody: createCredentialCustody(() => (0, import_node_crypto20.randomUUID)()),
+    custody: createCredentialCustody(() => (0, import_node_crypto21.randomUUID)()),
     log
   });
   const onListenerError = (name) => (error63) => {
@@ -130949,9 +131220,9 @@ function realFrontDoorSupervisorPorts(paths) {
     startProviderListener: async (preferredPort) => {
       const authority = loadCa();
       const rcDial = rcSelfHost ? lateRcEventDial(rcSelfHostDialTarget) : realRcEventDial();
-      const rcInject = async (sessionId, text2) => await injectRcUserMessage({ credentialOf: rcTracker.credentialOf, noteSequenceNums: rcTracker.noteSequenceNums, dial: rcDial, newUuid: import_node_crypto20.randomUUID }, sessionId, text2);
+      const rcInject = async (sessionId, text2) => await injectRcUserMessage({ credentialOf: rcTracker.credentialOf, noteSequenceNums: rcTracker.noteSequenceNums, dial: rcDial, newUuid: import_node_crypto21.randomUUID }, sessionId, text2);
       const rcAnswer = async (sessionId, requestId, decision) => await answerRcControlRequest({ credentialOf: rcTracker.credentialOf, pendingOf: (id2) => rcTracker.pendingOf(id2), completePending: rcTracker.completePending, noteSequenceNums: rcTracker.noteSequenceNums, dial: rcDial }, sessionId, requestId, decision);
-      const rcControlRequestDeps = { credentialOf: rcTracker.credentialOf, noteSequenceNums: rcTracker.noteSequenceNums, dial: rcDial, newUuid: import_node_crypto20.randomUUID };
+      const rcControlRequestDeps = { credentialOf: rcTracker.credentialOf, noteSequenceNums: rcTracker.noteSequenceNums, dial: rcDial, newUuid: import_node_crypto21.randomUUID };
       const rcInterrupt = async (sessionId) => await interruptRcSession(rcControlRequestDeps, sessionId);
       const rcSetModel = async (sessionId, model) => await setRcSessionModel(rcControlRequestDeps, sessionId, model);
       const rcSetPermissionMode = async (sessionId, mode) => await setRcSessionPermissionMode(rcControlRequestDeps, sessionId, mode);
@@ -131050,7 +131321,7 @@ function realFrontDoorSupervisorPorts(paths) {
     },
     startConnectListener: async (preferredPort) => {
       const wantedTransparentPort = process.env.AGENT_SHIM_TRANSPARENT_SURFACE === void 0 ? void 0 : Number(process.env.AGENT_SHIM_TRANSPARENT_SURFACE);
-      const transparentCapability = wantedTransparentPort === void 0 || Number.isNaN(wantedTransparentPort) ? void 0 : (0, import_node_crypto20.randomUUID)();
+      const transparentCapability = wantedTransparentPort === void 0 || Number.isNaN(wantedTransparentPort) ? void 0 : (0, import_node_crypto21.randomUUID)();
       if (transparentCapability !== void 0) {
         writeFrontDoorSession(realFarmFs, paths.frontdoorSessionsDir, { pid: process.pid, startedAt: Date.now(), token: transparentCapability });
       }

package/dist/index.cjs

@@ -472,7 +472,7 @@ var init_schema = __esm({
         context.addIssue({ code: "custom", path: ["readMaturation"], message: "readMaturation needs rolloutChannel beta or dev" });
       }
     });
-    HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@ca7589c574bfd52919503a74f09f4d1fe5ecf106";
+    HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@2dfa958e47814533751cdd0c5362d8f352ec5b75";
     HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES = 15;
     FrontDoorGlobalConfigSchema = import_zod.z.strictObject({
       /** How long the front door may sit with no registered sessions before it closes and exits. Defaults to FRONTDOOR_DEFAULT_IDLE_SHUTDOWN_MINUTES. */
@@ -2758,7 +2758,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.4.0",
+      version: "11.5.0",
       description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
       license: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",

package/dist/index.mjs

@@ -450,7 +450,7 @@ var init_schema = __esm({
         context.addIssue({ code: "custom", path: ["readMaturation"], message: "readMaturation needs rolloutChannel beta or dev" });
       }
     });
-    HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@ca7589c574bfd52919503a74f09f4d1fe5ecf106";
+    HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@2dfa958e47814533751cdd0c5362d8f352ec5b75";
     HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES = 15;
     FrontDoorGlobalConfigSchema = z.strictObject({
       /** How long the front door may sit with no registered sessions before it closes and exits. Defaults to FRONTDOOR_DEFAULT_IDLE_SHUTDOWN_MINUTES. */
@@ -2734,7 +2734,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.4.0",
+      version: "11.5.0",
       description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
       license: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",

package/dist/types/index.d.ts

@@ -5656,6 +5656,7 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
                 kind: zod.ZodLiteral<"profile">;
                 name: zod.ZodString;
                 value: zod.ZodObject<{
+                    description: zod.ZodOptional<zod.ZodString>;
                     entries: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodBoolean, zod.ZodObject<{
                         value: zod.ZodBoolean;
                         when: zod.ZodUnion<readonly [zod.ZodObject<{
@@ -5731,7 +5732,6 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
                             key: zod.ZodType<trilean.JsonValue, unknown, zod_v4_core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
                         }, zod_v4_core.$strip>], "kind">]>;
                     }, zod_v4_core.$strict>]>>>;
-                    description: zod.ZodOptional<zod.ZodString>;
                     extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
                     categories: zod.ZodOptional<zod.ZodPipe<zod.ZodObject<{
                         all: zod.ZodOptional<zod.ZodBoolean>;
@@ -5775,6 +5775,7 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
                 kind: zod.ZodLiteral<"profile">;
                 name: zod.ZodString;
                 value: zod.ZodObject<{
+                    description: zod.ZodOptional<zod.ZodString>;
                     entries: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodBoolean, zod.ZodObject<{
                         value: zod.ZodBoolean;
                         when: zod.ZodUnion<readonly [zod.ZodObject<{
@@ -5850,7 +5851,6 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
                             key: zod.ZodType<trilean.JsonValue, unknown, zod_v4_core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
                         }, zod_v4_core.$strip>], "kind">]>;
                     }, zod_v4_core.$strict>]>>>;
-                    description: zod.ZodOptional<zod.ZodString>;
                     extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
                     categories: zod.ZodOptional<zod.ZodPipe<zod.ZodObject<{
                         all: zod.ZodOptional<zod.ZodBoolean>;
@@ -8606,6 +8606,7 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
                 kind: zod.ZodLiteral<"profile">;
                 name: zod.ZodString;
                 value: zod.ZodObject<{
+                    description: zod.ZodOptional<zod.ZodString>;
                     entries: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodBoolean, zod.ZodObject<{
                         value: zod.ZodBoolean;
                         when: zod.ZodUnion<readonly [zod.ZodObject<{
@@ -8681,7 +8682,6 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
                             key: zod.ZodType<trilean.JsonValue, unknown, zod_v4_core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
                         }, zod_v4_core.$strip>], "kind">]>;
                     }, zod_v4_core.$strict>]>>>;
-                    description: zod.ZodOptional<zod.ZodString>;
                     extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
                     categories: zod.ZodOptional<zod.ZodPipe<zod.ZodObject<{
                         all: zod.ZodOptional<zod.ZodBoolean>;
@@ -8725,6 +8725,7 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
                 kind: zod.ZodLiteral<"profile">;
                 name: zod.ZodString;
                 value: zod.ZodObject<{
+                    description: zod.ZodOptional<zod.ZodString>;
                     entries: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodBoolean, zod.ZodObject<{
                         value: zod.ZodBoolean;
                         when: zod.ZodUnion<readonly [zod.ZodObject<{
@@ -8800,7 +8801,6 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
                             key: zod.ZodType<trilean.JsonValue, unknown, zod_v4_core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
                         }, zod_v4_core.$strip>], "kind">]>;
                     }, zod_v4_core.$strict>]>>>;
-                    description: zod.ZodOptional<zod.ZodString>;
                     extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
                     categories: zod.ZodOptional<zod.ZodPipe<zod.ZodObject<{
                         all: zod.ZodOptional<zod.ZodBoolean>;
@@ -10714,6 +10714,7 @@ declare const ConfigProfileAddOutputSchema: z.ZodObject<{
     kind: z.ZodLiteral<"profile">;
     name: z.ZodString;
     value: z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
         entries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
             value: z.ZodBoolean;
             when: z.ZodUnion<readonly [z.ZodObject<{
@@ -10789,7 +10790,6 @@ declare const ConfigProfileAddOutputSchema: z.ZodObject<{
                 key: z.ZodType<trilean.JsonValue, unknown, z.core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
             }, z.core.$strip>], "kind">]>;
         }, z.core.$strict>]>>>;
-        description: z.ZodOptional<z.ZodString>;
         extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
         categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
             all: z.ZodOptional<z.ZodBoolean>;
@@ -10835,6 +10835,7 @@ declare const ConfigProfileSetOutputSchema: z.ZodObject<{
     kind: z.ZodLiteral<"profile">;
     name: z.ZodString;
     value: z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
         entries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
             value: z.ZodBoolean;
             when: z.ZodUnion<readonly [z.ZodObject<{
@@ -10910,7 +10911,6 @@ declare const ConfigProfileSetOutputSchema: z.ZodObject<{
                 key: z.ZodType<trilean.JsonValue, unknown, z.core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
             }, z.core.$strip>], "kind">]>;
         }, z.core.$strict>]>>>;
-        description: z.ZodOptional<z.ZodString>;
         extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
         categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
             all: z.ZodOptional<z.ZodBoolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-use",
-  "version": "11.4.0",
+  "version": "11.5.0",
   "description": "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   "license": "MIT",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",