billion-context 0.1.62 → 0.1.63-pr.338.192

package/dist/index.js

@@ -47900,7 +47900,7 @@ function rejectLegacyRoute(key, value) {
 // src/server.ts
 import http from "http";
 import fs6 from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/compress-settings.ts
 function resolveContextLimitValue(raw, nativeLimit) {
@@ -48297,6 +48297,213 @@ function registryLookup(reg, model, host) {
   return void 0;
 }
 
+// src/codex-models-snapshot.json
+var codex_models_snapshot_default = {
+  source: "openai/codex main (commit 868c9ed) \u2014 codex-rs/models-manager/models.json",
+  fetchedAt: "2026-08-28T17:09:46Z",
+  count: 10,
+  models: [
+    {
+      slug: "gpt-5.6-sol",
+      contextWindow: 272e3,
+      maxContextWindow: 872e3
+    },
+    {
+      slug: "gpt-5.6-terra",
+      contextWindow: 272e3,
+      maxContextWindow: 872e3
+    },
+    {
+      slug: "gpt-5.6-luna",
+      contextWindow: 272e3,
+      maxContextWindow: 872e3
+    },
+    {
+      slug: "gpt-daybreak-blue-latest",
+      contextWindow: 272e3,
+      maxContextWindow: 872e3
+    },
+    {
+      slug: "gpt-daybreak-red-latest",
+      contextWindow: 372e3,
+      maxContextWindow: 372e3
+    },
+    {
+      slug: "gpt-5.5",
+      contextWindow: 272e3,
+      maxContextWindow: 272e3
+    },
+    {
+      slug: "gpt-5.4",
+      contextWindow: 272e3,
+      maxContextWindow: 1e6
+    },
+    {
+      slug: "gpt-5.4-mini",
+      contextWindow: 272e3,
+      maxContextWindow: 272e3
+    },
+    {
+      slug: "gpt-5.2",
+      contextWindow: 272e3,
+      maxContextWindow: 272e3
+    },
+    {
+      slug: "codex-auto-review",
+      contextWindow: 272e3,
+      maxContextWindow: 872e3
+    }
+  ]
+};
+
+// src/codex-compact.ts
+import { randomUUID } from "crypto";
+var CODEX_COMPACT_ID_PREFIX = "fc_bili_";
+var CODEX_COMPACT_SENTINEL = "bili:acp:";
+var CODEX_UA_PREFIXES = ["codex_cli_rs/", "codex_exec/"];
+function codexCompactMode() {
+  const v2 = process.env.BILI_CODEX_COMPACT?.trim().toLowerCase();
+  return v2 === "pass" ? "pass" : "intercept";
+}
+function isCodexClient(headers) {
+  const ua = headers["user-agent"];
+  if (!ua) return false;
+  const s3 = Array.isArray(ua) ? ua[0] : ua;
+  return typeof s3 === "string" && CODEX_UA_PREFIXES.some((p2) => s3.startsWith(p2));
+}
+function hasCompactionTrigger(input) {
+  if (!Array.isArray(input)) return false;
+  const last = input[input.length - 1];
+  return last?.type === "compaction_trigger";
+}
+function isBiliCompactionItem(item) {
+  const it2 = item;
+  if (!it2 || it2.type !== "compaction") return false;
+  if (typeof it2.id === "string" && it2.id.startsWith(CODEX_COMPACT_ID_PREFIX)) return true;
+  if (typeof it2.encrypted_content === "string" && it2.encrypted_content.startsWith(CODEX_COMPACT_SENTINEL)) return true;
+  return false;
+}
+function stripBiliCompactionItems(input) {
+  return input.filter((item) => !isBiliCompactionItem(item));
+}
+function extractBiliSummary(item) {
+  const it2 = item;
+  if (!it2 || typeof it2.encrypted_content !== "string") return void 0;
+  if (!it2.encrypted_content.startsWith(CODEX_COMPACT_SENTINEL)) return void 0;
+  const text = it2.encrypted_content.slice(CODEX_COMPACT_SENTINEL.length);
+  return text.length > 0 ? text : void 0;
+}
+function replaceBiliCompactionItems(input) {
+  const items = [];
+  let replaced = 0;
+  let dropped = 0;
+  for (const item of input) {
+    if (!isBiliCompactionItem(item)) {
+      items.push(item);
+      continue;
+    }
+    const summary = extractBiliSummary(item);
+    if (summary === void 0) {
+      dropped++;
+      continue;
+    }
+    items.push({
+      type: "message",
+      role: "user",
+      content: [{ type: "input_text", text: `[bili] context summary after compaction:
+${summary}` }]
+    });
+    replaced++;
+  }
+  return { items, replaced, dropped };
+}
+function codexCompactGate(session, effectiveLimit, transformOk) {
+  if (!transformOk || effectiveLimit <= 0) return false;
+  if (session.stats.lastInputTokens >= effectiveLimit * 0.9) return false;
+  return session.state.blocks.some((b2) => b2.active);
+}
+function buildTriggerForgeBody(summaryText, usage, stream2) {
+  const compactionItem = {
+    type: "compaction",
+    id: `${CODEX_COMPACT_ID_PREFIX}${randomUUID()}`,
+    encrypted_content: `${CODEX_COMPACT_SENTINEL}${summaryText}`
+  };
+  const usageJson = {
+    input_tokens: usage.inputTokens,
+    output_tokens: usage.outputTokens,
+    total_tokens: usage.totalTokens
+  };
+  const id = `resp_bili_${randomUUID()}`;
+  if (!stream2) {
+    return {
+      body: JSON.stringify({ id, output: [compactionItem], usage: usageJson }),
+      contentType: "application/json"
+    };
+  }
+  const frame1 = `data: ${JSON.stringify({ type: "response.output_item.done", item: compactionItem })}
+
+`;
+  const frame2 = `data: ${JSON.stringify({ type: "response.completed", response: { id, usage: usageJson } })}
+
+`;
+  return { body: frame1 + frame2, contentType: "text/event-stream" };
+}
+var FORGED_SUMMARY_HEADER = "[Compressed conversation section]";
+function renderForgedSummary(block) {
+  const body = block.summary.trim();
+  const topicLine = block.topic ? `${FORGED_SUMMARY_HEADER} \u2014 ${block.topic}` : FORGED_SUMMARY_HEADER;
+  return body.length === 0 ? topicLine : `${topicLine}
+${body}`;
+}
+function mergeForgedSummaries(existing, blocks) {
+  const merged = existing ? [...existing] : [];
+  for (const block of blocks) {
+    if (!block.active) continue;
+    const rendered = renderForgedSummary(block);
+    if (!merged.includes(rendered)) merged.push(rendered);
+  }
+  return merged;
+}
+
+// src/codex-models.ts
+var SNAPSHOT = codex_models_snapshot_default;
+var TABLE = SNAPSHOT.models;
+var CODEX_FALLBACK_CONTEXT_WINDOW = 272e3;
+function resolvedWindow(m2) {
+  return m2.contextWindow ?? m2.maxContextWindow ?? CODEX_FALLBACK_CONTEXT_WINDOW;
+}
+function lookupWindow(model) {
+  const direct = longestPrefixMatch(model);
+  if (direct) return resolvedWindow(direct);
+  const slash = model.indexOf("/");
+  if (slash > 0) {
+    const namespace = model.slice(0, slash);
+    const suffix = model.slice(slash + 1);
+    if (!suffix.includes("/") && /^[A-Za-z0-9_-]+$/.test(namespace)) {
+      const m2 = longestPrefixMatch(suffix);
+      if (m2) return resolvedWindow(m2);
+    }
+  }
+  return CODEX_FALLBACK_CONTEXT_WINDOW;
+}
+function longestPrefixMatch(model) {
+  let best;
+  for (const m2 of TABLE) {
+    if (!model.startsWith(m2.slug)) continue;
+    if (!best || m2.slug.length > best.slug.length) best = m2;
+  }
+  return best;
+}
+function codexWindowForModel(model) {
+  return lookupWindow(model);
+}
+function codexAlignedWindow(limit, model, headers) {
+  if (!isCodexClient(headers)) return { limit, clamped: false };
+  const w2 = codexWindowForModel(model);
+  if (limit > w2) return { limit: w2, clamped: true };
+  return { limit, clamped: false };
+}
+
 // node_modules/acp-kernel/dist/wire/index.js
 import { createHash } from "crypto";
 function hashId(s3) {
@@ -50474,7 +50681,7 @@ function renderPage(origin, version2) {
 // src/web/api.ts
 import { closeSync, existsSync as existsSync3, fsyncSync, mkdirSync as mkdirSync4, openSync, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname3 } from "path";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function readConfig() {
   const parsed = safeReadJson(configFile());
   return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
@@ -50499,7 +50706,7 @@ function readUpstreamSettings() {
 function atomicWriteConfig(config) {
   const filePath = configFile();
   mkdirSync4(dirname3(filePath), { recursive: true });
-  const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  const tempPath = `${filePath}.${process.pid}.${randomUUID2()}.tmp`;
   let descriptor;
   try {
     descriptor = openSync(tempPath, "wx", 384);
@@ -52605,6 +52812,105 @@ function rewriteResponsesJsonResponse(body, ctx) {
   return body;
 }
 
+// src/stream-terminal.ts
+var SUCCEEDED = "response.completed";
+var FAILED_EVENTS = /* @__PURE__ */ new Set(["response.failed", "response.incomplete"]);
+var MAX_JSON_BYTES = 16 << 20;
+async function observeResponsesTerminalState(stream2, isStream) {
+  return isStream ? observeSseTerminalState(stream2) : observeJsonTerminalState(stream2);
+}
+function terminalFromSseLine(line) {
+  if (line.startsWith("event:")) {
+    const name = line.slice(6).trim();
+    if (name === SUCCEEDED) return "completed";
+    if (FAILED_EVENTS.has(name)) return "failed";
+    return null;
+  }
+  if (line.startsWith("data:")) {
+    const data = line.slice(5).trim();
+    if (!data.startsWith("{")) return null;
+    try {
+      const type = JSON.parse(data).type;
+      if (type === SUCCEEDED) return "completed";
+      if (type === "response.failed" || type === "response.incomplete") return "failed";
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function observeSseTerminalState(stream2) {
+  const reader = stream2.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  let state = "unknown";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      let nl;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, nl).replace(/\r$/, "");
+        buf = buf.slice(nl + 1);
+        const next = terminalFromSseLine(line);
+        if (next !== null) {
+          state = next;
+          break;
+        }
+      }
+      if (state !== "unknown") {
+        await reader.cancel().catch(() => {
+        });
+        break;
+      }
+    }
+  } catch {
+    return "unknown";
+  } finally {
+    reader.releaseLock();
+  }
+  return state;
+}
+async function observeJsonTerminalState(stream2) {
+  const reader = stream2.getReader();
+  const chunks = [];
+  let size = 0;
+  let overflow = false;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!overflow) {
+        size += value.length;
+        if (size <= MAX_JSON_BYTES) {
+          chunks.push(Buffer.from(value));
+        } else {
+          overflow = true;
+        }
+      }
+    }
+  } catch {
+    return "unknown";
+  } finally {
+    reader.releaseLock();
+  }
+  if (overflow) return "unknown";
+  const text = Buffer.concat(chunks).toString("utf8").trim();
+  if (!text) return "unknown";
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    return "unknown";
+  }
+  if (typeof body !== "object" || body === null) return "unknown";
+  const rec = body;
+  if (rec.error !== void 0) return "failed";
+  if (Array.isArray(rec.output)) return "completed";
+  return "unknown";
+}
+
 // src/stream-error.ts
 function safeWrite(res, chunk) {
   try {
@@ -52700,12 +53006,38 @@ function preferPromptCacheKeyIdentity(identity, body) {
   if (pck.length === 0) return identity;
   return { ...identity, value: pck, source: "prompt-cache-key", clientProvided: true };
 }
+function codexTurnIdentity(headers) {
+  const raw = headers["x-codex-turn-metadata"];
+  if (typeof raw !== "string" || raw.trim().length === 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+  const record = parsed;
+  const threadSource = record["thread_source"];
+  if (typeof threadSource !== "string" || threadSource.trim().length === 0) return void 0;
+  const metaThreadId = record["thread_id"];
+  if (typeof metaThreadId !== "string" || metaThreadId.trim().length === 0) return void 0;
+  const threadHeader = headers["thread-id"];
+  if (typeof threadHeader !== "string" || threadHeader.trim() !== metaThreadId.trim()) return void 0;
+  if (threadSource.trim() === "user") {
+    return void 0;
+  }
+  return { value: threadHeader.trim(), threadSource };
+}
 
 // src/prefix-affinity.ts
 import { createHash as createHash5 } from "crypto";
 var MIN_CANONICAL_BYTES = 24;
 var MAX_TRACKED_SESSIONS = 256;
 var TTL_MS2 = 7 * 24 * 60 * 60 * 1e3;
+var TAIL_WINDOW = 8;
+var MIN_TAIL_MATCH = 3;
+var MAX_STORED_ITEMS = 128;
+var MIN_FORK_PREFIX = 3;
 function stableStringify(value) {
   return JSON.stringify(sortKeys(value));
 }
@@ -52737,6 +53069,15 @@ function chainHashes(messages) {
   }
   return bytes >= MIN_CANONICAL_BYTES ? hashes : [];
 }
+function perItemHashes(messages) {
+  return messages.map((m2) => sha256(stableStringify(m2)));
+}
+function lcpLength(a, b2) {
+  const n = Math.min(a.length, b2.length);
+  let i = 0;
+  while (i < n && a[i] === b2[i]) i++;
+  return i;
+}
 var PrefixAffinityResolver = class {
   trackedChains = /* @__PURE__ */ new Map();
   /**
@@ -52747,12 +53088,15 @@ var PrefixAffinityResolver = class {
   resolve(messages) {
     const hashes = chainHashes(messages);
     if (hashes.length === 0 || !hasUserMessage(messages)) return null;
-    const tailHash = hashes[hashes.length - 1];
+    const incomingDepth = hashes.length;
+    const tailHash = hashes[incomingDepth - 1];
+    const incItemHashes = perItemHashes(messages);
+    const storedItemHashes = incItemHashes.slice(-MAX_STORED_ITEMS);
     const tracked = this.trackedChains;
     this.expire(tracked);
     let best;
     for (const entry of tracked.values()) {
-      if (entry.depth > hashes.length) continue;
+      if (entry.depth > incomingDepth) continue;
       if (hashes[entry.depth - 1] !== entry.tailHash) continue;
       if (!best || entry.depth > best.depth || entry.depth === best.depth && entry.lastSeen > best.lastSeen) best = entry;
     }
@@ -52761,19 +53105,79 @@ var PrefixAffinityResolver = class {
         sessionId: best.sessionId,
         matchedDepth: best.depth,
         storedDepth: best.depth,
-        incomingDepth: hashes.length,
-        tailHash
+        incomingDepth,
+        tailHash,
+        via: "prefix",
+        itemHashes: storedItemHashes
       };
     }
-    const sessionId = `pfa-${sha256(`${tailHash}\0${hashes.length}`).slice(0, 16)}`;
-    return { sessionId, matchedDepth: 0, storedDepth: 0, incomingDepth: hashes.length, tailHash };
+    const w2 = Math.min(TAIL_WINDOW, incomingDepth);
+    const candidates = [];
+    if (w2 >= MIN_TAIL_MATCH) {
+      for (const entry of tracked.values()) {
+        const stored = entry.itemHashes;
+        for (let j2 = 1; j2 + w2 <= stored.length; j2++) {
+          let match = true;
+          for (let i = 0; i < w2; i++) {
+            if (incItemHashes[i] !== stored[j2 + i]) {
+              match = false;
+              break;
+            }
+          }
+          if (match) {
+            candidates.push(entry);
+            break;
+          }
+        }
+      }
+    }
+    if (candidates.length === 1) {
+      const entry = candidates[0];
+      const w3 = Math.min(TAIL_WINDOW, incomingDepth, entry.depth);
+      return {
+        sessionId: entry.sessionId,
+        matchedDepth: w3,
+        storedDepth: entry.depth,
+        incomingDepth,
+        tailHash,
+        via: "tail-window",
+        itemHashes: storedItemHashes
+      };
+    }
+    let lineage;
+    if (candidates.length > 1) {
+      lineage = { parents: candidates.map((c) => c.sessionId), reason: "truncated" };
+    } else {
+      let forkParent;
+      let forkLcp = 0;
+      for (const entry of tracked.values()) {
+        if (entry.depth > MAX_STORED_ITEMS) continue;
+        const lcp = lcpLength(incItemHashes, entry.itemHashes);
+        if (lcp >= MIN_FORK_PREFIX && lcp > forkLcp) {
+          forkLcp = lcp;
+          forkParent = entry;
+        }
+      }
+      if (forkParent) lineage = { parents: [forkParent.sessionId], reason: "forked", sharedPrefix: forkLcp };
+    }
+    const sessionId = `pfa-${sha256(`${tailHash}\0${incomingDepth}`).slice(0, 16)}`;
+    return {
+      sessionId,
+      matchedDepth: 0,
+      storedDepth: 0,
+      incomingDepth,
+      tailHash,
+      via: "new",
+      itemHashes: storedItemHashes,
+      ...lineage ? { lineage } : {}
+    };
   }
   /** Record the chain of a session (on creation and after every anonymous
    *  request — the incoming history is the truth, appends extend it). */
-  note(sessionId, depth, tailHash) {
+  note(sessionId, depth, tailHash, itemHashes) {
     const tracked = this.trackedChains;
     tracked.delete(sessionId);
-    tracked.set(sessionId, { sessionId, depth, tailHash, lastSeen: Date.now() });
+    tracked.set(sessionId, { sessionId, depth, tailHash, itemHashes, lastSeen: Date.now() });
     while (tracked.size > MAX_TRACKED_SESSIONS) {
       const oldest = [...tracked.values()].sort((a, b2) => a.lastSeen - b2.lastSeen)[0];
       if (!oldest) break;
@@ -53686,16 +54090,31 @@ function readClaudeSettings(homeDir, cwd, env = process.env) {
     path8.join(cwd, ".claude", "settings.json")
   ];
   let anthropicBaseUrl;
+  let model;
+  let autoCompactWindow;
   for (const f2 of files) {
     const obj = readJsonObject(f2);
     const settingsEnv = obj?.env;
     if (settingsEnv && typeof settingsEnv === "object" && !Array.isArray(settingsEnv)) {
-      const v2 = settingsEnv.ANTHROPIC_BASE_URL;
+      const e = settingsEnv;
+      const v2 = e.ANTHROPIC_BASE_URL;
       if (nonEmpty2(v2)) anthropicBaseUrl = v2;
+      const m2 = e.ANTHROPIC_MODEL;
+      if (nonEmpty2(m2)) model = String(m2);
+      const acw = Number(e.CLAUDE_CODE_AUTO_COMPACT_WINDOW);
+      if (Number.isFinite(acw) && acw > 0) autoCompactWindow = acw;
     }
+    const tm = obj?.model;
+    if (nonEmpty2(tm) && model === void 0) model = String(tm);
+    const tacw = Number(obj?.autoCompactWindow);
+    if (Number.isFinite(tacw) && tacw > 0 && autoCompactWindow === void 0) autoCompactWindow = tacw;
   }
   if (!anthropicBaseUrl && nonEmpty2(env.ANTHROPIC_BASE_URL)) anthropicBaseUrl = env.ANTHROPIC_BASE_URL;
-  return anthropicBaseUrl ? { anthropicBaseUrl } : {};
+  return {
+    ...anthropicBaseUrl ? { anthropicBaseUrl } : {},
+    ...model ? { model } : {},
+    ...autoCompactWindow ? { autoCompactWindow } : {}
+  };
 }
 function parseCodexToml(text) {
   const result = { providers: {} };
@@ -53703,6 +54122,7 @@ function parseCodexToml(text) {
   let curProvider = null;
   let codexModel;
   let codexContextWindow;
+  let codexAutoCompactLimit;
   for (const rawLine of text.split(/\r?\n/)) {
     const line = rawLine.trim();
     if (!line || line.startsWith("#")) continue;
@@ -53727,10 +54147,14 @@ function parseCodexToml(text) {
       } else if (curProvider && key === "base_url") {
         result.providers[curProvider].baseUrl = val;
       }
-    } else if (numMatch && table === "" && numMatch[1] === "model_context_window") {
-      codexContextWindow = Number(numMatch[2]);
+    } else if (numMatch && table === "") {
+      if (numMatch[1] === "model_context_window") codexContextWindow = Number(numMatch[2]);
+      else if (numMatch[1] === "model_auto_compact_token_limit") codexAutoCompactLimit = Number(numMatch[2]);
     }
   }
+  if (codexModel) result.model = codexModel;
+  if (codexContextWindow) result.contextWindow = codexContextWindow;
+  if (codexAutoCompactLimit) result.autoCompactLimit = codexAutoCompactLimit;
   const win = toModelWindow(codexModel, codexContextWindow);
   if (win) result.modelWindows = [win];
   return result;
@@ -55063,7 +55487,7 @@ async function startServer(opts) {
   const core = createCore();
   const config = opts.kernelConfig;
   const log2 = (level, msg) => logMsg(opts, level, msg);
-  const instanceId = randomUUID2();
+  const instanceId = randomUUID3();
   await initSessions();
   loadConversations();
   log2("info", `[persist] ${getStore().enabled ? "enabled" : "disabled"}`);
@@ -55424,6 +55848,13 @@ ${bodyBuffer.toString("utf8")}`);
         if (native) nativeFromFallback = false;
       }
       reqConfig = resolveRequestConfig(config, opts.routes, embeddedUrl, model, native, opts.compress);
+      const aligned = operatorWindowTuned ? { limit: reqConfig.modelContextLimit, clamped: false } : codexAlignedWindow(reqConfig.modelContextLimit, model, req.headers);
+      if (aligned.clamped) {
+        const before = reqConfig.modelContextLimit;
+        reqConfig = { ...reqConfig, modelContextLimit: aligned.limit };
+        nativeFromFallback = false;
+        log2("info", `[codex] effective window clamped ${before} \u2192 ${aligned.limit} (codex's own perception for model=${model}; ACP now compresses before codex's native auto-compact)`);
+      }
       reqPrompts = resolveCompressPrompts(resolveCompress(opts.routes, embeddedUrl, model, opts.compress));
     }
   }
@@ -55434,7 +55865,8 @@ ${bodyBuffer.toString("utf8")}`);
     let pluginConversation = pluginConversationHeader(req.headers);
     const clientConv = clientConversationHeader(req.headers);
     const convHeader = clientConv ?? sessionHeader;
-    const responsesIdentity = protocol === "responses" ? preferPromptCacheKeyIdentity(
+    const codexTurn = protocol === "responses" ? codexTurnIdentity(req.headers) : void 0;
+    const responsesIdentity = protocol === "responses" ? codexTurn ? { value: codexTurn.value, source: "header", clientProvided: true } : preferPromptCacheKeyIdentity(
       conversationIdentityResponses(parsed, convHeader),
       parsed
     ) : void 0;
@@ -55443,7 +55875,7 @@ ${bodyBuffer.toString("utf8")}`);
       convHeader ? { value: openaiSignal, source: "header", clientProvided: true } : { value: openaiSignal, source: "content-fingerprint", clientProvided: false },
       parsed
     ) : void 0;
-    const conversation = protocol === "anthropic" ? conversationSignalAnthropic(parsed, convHeader) : protocol === "openai" ? openaiIdentity?.value ?? openaiSignal : subagentNamespace(
+    const conversation = protocol === "anthropic" ? conversationSignalAnthropic(parsed, convHeader) : protocol === "openai" ? openaiIdentity?.value ?? openaiSignal : codexTurn ? codexTurn.value : subagentNamespace(
       responsesIdentity?.value ?? conversationSignalResponses(parsed, convHeader),
       parsed.instructions
     );
@@ -55458,12 +55890,16 @@ ${bodyBuffer.toString("utf8")}`);
         res.end(JSON.stringify(protocol === "anthropic" ? { type: "error", error: { type: "invalid_request_error", message: NO_IDENTITY_MESSAGE } } : { error: { type: "invalid_request_error", message: NO_IDENTITY_MESSAGE } }));
         return;
       }
-      if (anonAffinity.matchedDepth > 0) {
+      if (anonAffinity.via === "tail-window") {
+        log2("info", `[prefix-affinity] anonymous ${protocol} request \u2192 session ${anonAffinity.sessionId} (tail-window reattach window=${anonAffinity.matchedDepth}/${anonAffinity.incomingDepth}, tail=${anonAffinity.tailHash.slice(0, 8)}; truncated replay reattached, kernel reconciles by message id)`);
+        log("info", `[prefix-affinity] session ${anonAffinity.sessionId} reattached via tail-window (window ${anonAffinity.matchedDepth}/${anonAffinity.incomingDepth}, tail=${anonAffinity.tailHash.slice(0, 8)})`);
+      } else if (anonAffinity.matchedDepth > 0) {
         log2("info", `[prefix-affinity] anonymous ${protocol} request \u2192 session ${anonAffinity.sessionId} (prefix match depth=${anonAffinity.matchedDepth}/${anonAffinity.incomingDepth}, tail=${anonAffinity.tailHash.slice(0, 8)}; fork semantics: diverged histories split on their next request)`);
         log("info", `[prefix-affinity] session ${anonAffinity.sessionId} matched at depth ${anonAffinity.matchedDepth}/${anonAffinity.incomingDepth} (tail=${anonAffinity.tailHash.slice(0, 8)})`);
       } else {
-        log2("info", `[prefix-affinity] new anonymous session ${anonAffinity.sessionId} (depth=${anonAffinity.incomingDepth}, tail=${anonAffinity.tailHash.slice(0, 8)})`);
-        log("info", `[prefix-affinity] new session ${anonAffinity.sessionId} at depth ${anonAffinity.incomingDepth} (tail=${anonAffinity.tailHash.slice(0, 8)})`);
+        const lineage = anonAffinity.lineage ? `; lineage=${anonAffinity.lineage.reason} of ${anonAffinity.lineage.parents.join(",")}` : "";
+        log2("info", `[prefix-affinity] new anonymous session ${anonAffinity.sessionId} (depth=${anonAffinity.incomingDepth}, tail=${anonAffinity.tailHash.slice(0, 8)}${lineage})`);
+        log("info", `[prefix-affinity] new session ${anonAffinity.sessionId} at depth ${anonAffinity.incomingDepth} (tail=${anonAffinity.tailHash.slice(0, 8)}${lineage})`);
       }
     }
     const sessionId = anonAffinity ? anonAffinity.sessionId : conversation;
@@ -55476,10 +55912,12 @@ ${bodyBuffer.toString("utf8")}`);
     const clientLabel = bodyIdentity?.clientProvided ? bodyIdentity.value : clientConversationHeader(req.headers);
     const session = getSession(sessionId, { protocol, upstreamOrigin, label: clientLabel ?? (anonAffinity ? "prefix-affinity" : void 0) });
     if (anonAffinity) {
-      prefixAffinity.note(sessionId, anonAffinity.incomingDepth, anonAffinity.tailHash);
+      prefixAffinity.note(sessionId, anonAffinity.incomingDepth, anonAffinity.tailHash, anonAffinity.itemHashes);
       session.metadata.anonymousPrefixAffinity = {
         depth: anonAffinity.incomingDepth,
-        tailHash: anonAffinity.tailHash
+        tailHash: anonAffinity.tailHash,
+        via: anonAffinity.via,
+        ...anonAffinity.lineage ? { lineage: anonAffinity.lineage } : {}
       };
     }
     if (!pluginAgent && !anonAffinity) {
@@ -55489,7 +55927,7 @@ ${bodyBuffer.toString("utf8")}`);
         pluginConversation = clientConv ?? conversation;
       }
     }
-    if (!pluginAgent && session.stats.requests === 0) {
+    if (!pluginAgent && session.stats.requests === 0 && codexTurnIdentity(req.headers) === void 0) {
       const pending = takePendingPluginRegister();
       if (pending) {
         pluginAgent = pending.agent;
@@ -55533,7 +55971,7 @@ ${bodyBuffer.toString("utf8")}`);
     acquireInFlight(session);
     try {
       await withSessionLock(session, async () => {
-        const runPrepare = () => countTokens ? prepareCountTokens(parsed, core, reqConfig, log2, session) : protocol === "anthropic" ? prepareAnthropic(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode) : protocol === "openai" ? prepareOpenai(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode) : responsesCompact ? prepareResponsesCompact(bodyBuffer, parsed, session) : prepareResponses(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, responsesIdentity, pluginMode, upstreamOrigin);
+        const runPrepare = () => countTokens ? prepareCountTokens(parsed, core, reqConfig, log2, session) : protocol === "anthropic" ? prepareAnthropic(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode) : protocol === "openai" ? prepareOpenai(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode) : responsesCompact ? prepareResponsesCompact(bodyBuffer, parsed, session, req, core, reqConfig, log2) : prepareResponses(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, responsesIdentity, pluginMode, upstreamOrigin);
         prepared = runPrepare();
         if (!countTokens && !responsesCompact) {
           const outcome = await preflightCompressIfNeeded(
@@ -55744,12 +56182,22 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
   if (reconcileNativeCompactionBoundary(session)) {
     log2("info", `[${sessionId}] reconciled ACP state after native Responses compact boundary`);
   }
+  let echoReplaced = false;
+  if (Array.isArray(parsed.input)) {
+    const { items, replaced, dropped } = replaceBiliCompactionItems(parsed.input);
+    if (replaced > 0 || dropped > 0) {
+      echoReplaced = true;
+      log2("info", `[${sessionId}] replaced ${replaced} echoed bili compaction item(s) with summary handoff message(s)${dropped > 0 ? `, dropped ${dropped} legacy marker item(s)` : ""}`);
+      parsed.input = items;
+    }
+  }
   let processedMessages = [];
   let originalMessages = [];
   let nudge;
   let responsesProjection;
   let rebuiltInput = parsed.input;
   let toolsOut = parsed.tools;
+  let transformOk = false;
   const typedItems = normalizeResponsesMessageItems(parsed.input);
   if (typedItems > 0) {
     log2("info", `[${sessionId}] stamped type:"message" on ${typedItems} type-less input item(s) before projection (omp wire form)`);
@@ -55761,6 +56209,7 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
   }
   const shouldInject = opts.compress.injectTool;
   const injectTools = shouldInject && !pluginMode;
+  const isCompactionTrigger = hasCompactionTrigger(parsed.input);
   const responsesTextProtocol = FORCE_TEXT_PROTOCOL || resolveCompressProtocol(opts.routes, upstreamOrigin) === "marker";
   try {
     const projection = responsesToCore(parsed);
@@ -55771,7 +56220,7 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
       log2("info", `[${sessionId}] input items: ${Array.isArray(parsed.input) ? parsed.input.map((i) => i.type).join(",") : "(string)"}`);
     }
     const tokenCount = session.stats.lastInputTokens;
-    const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: process.env.ACP_RENDER_NONE ? "none" : "text-only" });
+    const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: process.env.ACP_RENDER_NONE || isCompactionTrigger ? "none" : "text-only" });
     session.state = turn.state;
     session.stats.compressCreditTokens = 0;
     if (turn.nudge) turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
@@ -55786,18 +56235,19 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
     processedMessages = stripKernelSummaries(turn.messages, turn.state);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltInput = patchResponsesInput(projection, processedMessages);
-    if (shouldInject && !process.env.ACP_NO_COMPRESS_PROMPT) {
+    const forgedSummaries = echoReplaced ? [] : session.metadata.codexForgedSummaries ?? [];
+    if (shouldInject && !isCompactionTrigger && !process.env.ACP_NO_COMPRESS_PROMPT) {
       const prompt = responsesTextProtocol ? buildCompressHybridSystemPrompt(prompts) : buildCompressSystemPrompt(prompts);
-      const devContent = [...projection.systemParts, prompt].join("\n\n---\n\n");
+      const devContent = [...projection.systemParts, ...forgedSummaries, prompt].join("\n\n---\n\n");
       rebuiltInput = injectResponsesDeveloperMessage(rebuiltInput, devContent);
       if (!process.env.ACP_NO_INJECT_TOOL && injectTools) {
         toolsOut = responsesTextProtocol ? injectResponsesTool(parsed.tools, ACP_READONLY_TOOLS_RESPONSES) : injectResponsesTool(parsed.tools);
       }
-    } else if (projection.systemParts.length > 0) {
-      rebuiltInput = injectResponsesDeveloperMessage(rebuiltInput, projection.systemParts.join("\n\n---\n\n"));
+    } else if (projection.systemParts.length > 0 || forgedSummaries.length > 0) {
+      const devContent = [...projection.systemParts, ...forgedSummaries].join("\n\n---\n\n");
+      rebuiltInput = injectResponsesDeveloperMessage(rebuiltInput, devContent);
     }
-    const triggerFinal = Array.isArray(rebuiltInput) && rebuiltInput.length > 0 && rebuiltInput[rebuiltInput.length - 1].type === "compaction_trigger";
-    if (opts.compress.injectNudge && turn.nudge?.shouldInject && shouldInject && !triggerFinal) {
+    if (opts.compress.injectNudge && turn.nudge?.shouldInject && shouldInject && !isCompactionTrigger) {
       try {
         const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {
@@ -55808,10 +56258,28 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
       } catch {
       }
     }
+    transformOk = true;
   } catch (err2) {
     log2("warn", `[${sessionId}] kernel transform failed, forwarding unchanged: ${String(err2)}`);
     processedMessages = [];
   }
+  let codexForge;
+  if (transformOk && codexCompactMode() === "intercept" && isCodexClient(req.headers) && hasCompactionTrigger(parsed.input) && codexCompactGate(session, config.modelContextLimit, transformOk)) {
+    const summaries = session.state.blocks.filter((b2) => b2.active).map((b2) => b2.summary);
+    const prevForged = session.metadata.codexForgedSummaries;
+    const captured = mergeForgedSummaries(prevForged, session.state.blocks);
+    if (captured.length !== (prevForged?.length ?? 0)) {
+      session.metadata.codexForgedSummaries = captured;
+      markDirty(session);
+    }
+    const est = defaultCountTokens(typeof parsed.input === "string" ? parsed.input : JSON.stringify(parsed.input ?? ""));
+    const total = Math.max(session.stats.lastInputTokens, est, 1);
+    codexForge = {
+      kind: "trigger",
+      ...buildTriggerForgeBody(summaries.join("\n\n"), { inputTokens: total, outputTokens: 0, totalTokens: total }, stream2)
+    };
+    log2("info", `[${sessionId}] codex compact intercepted (trigger); forged SSE with ${summaries.length} block summary(s), upstream not contacted`);
+  }
   const rebuilt = { ...parsed, input: rebuiltInput, tools: toolsOut };
   const promptCacheKey = resolvePromptCacheKey(
     rebuilt.prompt_cache_key,
@@ -55841,11 +56309,13 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
     responsesProjection,
     protocol: "responses",
     stream: stream2,
-    compressInjected: injectTools,
+    compressInjected: injectTools && !isCompactionTrigger,
     pluginMode,
     responsesTextProtocol,
     nudge,
-    prompts
+    prompts,
+    resetAfterSuccess: isCompactionTrigger,
+    codexForge
   };
 }
 function isCountTokensRequest(method, urlPath, hasBody) {
@@ -55881,10 +56351,13 @@ function prepareCountTokens(parsed, core, config, log2, session) {
     };
   }
 }
-function prepareResponsesCompact(body, parsed, session) {
+function prepareResponsesCompact(body, parsed, session, req, core, config, log2) {
   ++session.stats.requests;
-  return {
-    body,
+  const cleaned = Array.isArray(parsed.input) ? stripBiliCompactionItems(parsed.input) : parsed.input;
+  const stripped = Array.isArray(parsed.input) && cleaned.length !== parsed.input.length;
+  const forgeBody = { ...parsed, input: cleaned };
+  const base = {
+    body: stripped ? Buffer.from(JSON.stringify(forgeBody)) : body,
     session,
     processedMessages: [],
     originalMessages: [],
@@ -55893,6 +56366,35 @@ function prepareResponsesCompact(body, parsed, session) {
     compressInjected: false,
     resetAfterSuccess: true
   };
+  if (codexCompactMode() !== "intercept" || !isCodexClient(req.headers) || !Array.isArray(parsed.input)) {
+    return base;
+  }
+  const prevState = session.state;
+  let transformOk = false;
+  try {
+    const projection = responsesToCore(forgeBody);
+    const turn = core.processTurn({ messages: projection.msgs, state: session.state, config, tokenCount: session.stats.lastInputTokens, renderTags: process.env.ACP_RENDER_NONE ? "none" : "text-only" });
+    session.state = turn.state;
+    transformOk = true;
+    if (!codexCompactGate(session, config.modelContextLimit, transformOk)) {
+      session.state = prevState;
+      return base;
+    }
+    const processed = stripKernelSummaries(turn.messages, turn.state);
+    const output = patchResponsesInput(projection, processed);
+    if (typeof output === "string") {
+      session.state = prevState;
+      return base;
+    }
+    snapshotMessages(session, projection.msgs);
+    markDirty(session);
+    log2("info", `[${session.id}] codex compact intercepted (endpoint); forged history with ${output.length} item(s), upstream not contacted`);
+    return { ...base, codexForge: { kind: "endpoint", body: JSON.stringify({ output }), contentType: "application/json" } };
+  } catch (err2) {
+    session.state = prevState;
+    log2("warn", `[${session.id}] codex compact forge failed (${String(err2)}); passing through to upstream`);
+    return base;
+  }
 }
 function shouldInjectPromptCacheKey(routing, upstream) {
   if (routing === "enabled") return true;
@@ -56032,6 +56534,12 @@ async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, c
   return failFast(status, f2?.detail ?? "unknown reason", status === 503);
 }
 async function forward(req, res, opts, body, prepared, core, config, log2, route, instanceId, affinity) {
+  if (prepared?.codexForge) {
+    log2("info", `[${prepared.session.id}] codex compact served locally (${prepared.codexForge.kind}); upstream not contacted`);
+    res.writeHead(200, { "content-type": prepared.codexForge.contentType });
+    res.end(prepared.codexForge.body);
+    return;
+  }
   const { upstreamUrl, headers, proxyUrl } = buildForwardTarget(req, opts, route, affinity, prepared !== null ? instanceId : void 0);
   log2("info", `forward ${req.method} \u2192 ${maskUrlForLog(upstreamUrl)}`);
   if (process.env.ACP_DEBUG && prepared) {
@@ -56221,8 +56729,7 @@ ${hdrText}
     res.end();
     clearUpstreamTimer();
     if (prepared?.resetAfterSuccess) {
-      markNativeCompactionBoundary(prepared.session);
-      log2("info", `[${prepared.session.id}] native Responses compact completed; rebase scheduled for next Responses turn`);
+      log2("warn", `[${prepared.session.id}] native compact response had no body; rebase NOT scheduled`);
     }
     return;
   }
@@ -56241,11 +56748,21 @@ ${hdrText}
   }
   const useRewriter = prepared !== null && prepared.compressInjected && prepared.processedMessages.length > 0;
   if (!useRewriter || prepared === null) {
-    await pipeThrough(upstream.body, res);
-    clearUpstreamTimer();
-    if (prepared?.resetAfterSuccess) {
-      markNativeCompactionBoundary(prepared.session);
-      log2("info", `[${prepared.session.id}] native Responses compact completed; rebase scheduled for next Responses turn`);
+    if (prepared && prepared.resetAfterSuccess) {
+      const [toClient, toObserve] = upstream.body.tee();
+      const observed = observeResponsesTerminalState(toObserve, prepared.stream);
+      await pipeThrough(toClient, res);
+      clearUpstreamTimer();
+      const terminal = await observed;
+      if (terminal === "completed") {
+        markNativeCompactionBoundary(prepared.session);
+        log2("info", `[${prepared.session.id}] native Responses compact completed; rebase scheduled for next Responses turn`);
+      } else {
+        log2("warn", `[${prepared.session.id}] native compact response terminal=${terminal}; rebase NOT scheduled`);
+      }
+    } else {
+      await pipeThrough(upstream.body, res);
+      clearUpstreamTimer();
     }
     return;
   }
@@ -59493,6 +60010,9 @@ function isNewer(latest, current) {
   }
   return false;
 }
+function staleInstallStatus(diskVersion, runningVersion) {
+  return diskVersion !== void 0 && isNewer(diskVersion, runningVersion) ? "restart" : "current";
+}
 async function readLastCheck() {
   try {
     const data = await readFile2(THROTTLE_FILE, "utf-8");
@@ -59697,7 +60217,11 @@ async function checkForUpdate(opts, force = false) {
     const diskVersion = installDir ? await readDiskVersion(installDir) : void 0;
     const currentVersion = diskVersion ?? opts.currentVersion;
     if (!isNewer(latest, currentVersion)) {
-      log("info", `[update] current=${currentVersion} latest=${latest} (up to date)`);
+      if (staleInstallStatus(diskVersion, opts.currentVersion) === "restart") {
+        log("warn", `[update] running v${opts.currentVersion} but v${diskVersion} is installed \u2014 restart bili to activate (auto-update replaced the on-disk install; this process is still on the old code)`);
+      } else {
+        log("info", `[update] current=${currentVersion} latest=${latest} (up to date)`);
+      }
       return;
     }
     const tarballUrl = data.dist?.tarball;
@@ -60372,7 +60896,7 @@ function pluginStatusAll() {
 }
 
 // src/launcher.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import fs10 from "fs";
 import net2 from "net";
 import os5 from "os";
@@ -60537,6 +61061,37 @@ function buildCodexArgs(origin, httpRewrites, httpsRewrites, extra) {
   args.push(...extra);
   return args;
 }
+async function resolveLauncherWindow(model, routes, upstreamUrl) {
+  if (!model) return void 0;
+  let host;
+  if (upstreamUrl) {
+    try {
+      host = new URL(upstreamUrl).hostname;
+    } catch {
+      host = void 0;
+    }
+  }
+  return resolveConfiguredContextLimit(routes, upstreamUrl, model) ?? lookupContextLimit(model) ?? await contextFromRegistry(model, host);
+}
+function codexUpstreamUrl(codex) {
+  const provider = codex?.modelProvider ? codex?.providers?.[codex.modelProvider]?.baseUrl : void 0;
+  return provider ?? codex?.openaiBaseUrl ?? "https://api.openai.com/v1";
+}
+async function resolveCodexBudgetArgs(opts) {
+  const { model, clientWindow, clientAutoCompactLimit, routes, upstreamUrl } = opts;
+  if (!model || clientWindow) return [];
+  const window2 = await resolveLauncherWindow(model, routes, upstreamUrl);
+  if (!window2) return [];
+  const limit = clientAutoCompactLimit ?? window2;
+  return ["-c", `model_context_window=${window2}`, "-c", `model_auto_compact_token_limit=${limit}`];
+}
+async function resolveClaudeBudgetEnv(opts) {
+  const { model, userAutoCompactWindow, shellAutoCompactWindow, routes, upstreamUrl } = opts;
+  if (!model || userAutoCompactWindow !== void 0 || nonEmpty2(shellAutoCompactWindow)) return {};
+  const window2 = await resolveLauncherWindow(model, routes, upstreamUrl);
+  if (!window2) return {};
+  return { CLAUDE_CODE_AUTO_COMPACT_WINDOW: String(window2) };
+}
 function buildClaudeEnv(origin, caPath, httpRewrites, httpsRewrites, baseEnv) {
   const env = { ...baseEnv, HTTPS_PROXY: origin, NODE_EXTRA_CA_CERTS: caPath, BILLION_CONTEXT_PROXY: origin };
   const r = httpRewrites.find((rw) => rw.key === "ANTHROPIC_BASE_URL");
@@ -60548,8 +61103,49 @@ function buildClaudeEnv(origin, caPath, httpRewrites, httpsRewrites, baseEnv) {
 function launcherDirectUrl(env) {
   return env.BILI_LAUNCHER_DIRECT === "1";
 }
-function launcherInjectMcp(env, base) {
-  return base !== "pi" && base !== "omp" && base !== "opencode" && base !== "hermes" && base !== "dsh" && env.BILI_LAUNCHER_PLUGIN !== "0";
+function isPrivateUpstreamHost(raw) {
+  let host;
+  try {
+    host = new URL(raw).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (host === "localhost" || host.endsWith(".local") || host.endsWith(".lan") || host.endsWith(".internal")) return true;
+  if (host.startsWith("[")) host = host.slice(1, -1);
+  if (host.includes(":")) {
+    if (host === "::1" || host === "::") return true;
+    const first = host.split(":")[0] ?? "";
+    if (/^f[cd]/.test(first)) return true;
+    if (/^fe[89ab]/.test(first)) return true;
+    const dotted = /::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(host);
+    if (dotted && isPrivateIPv4(dotted[1])) return true;
+    const hex = /::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(host);
+    if (hex) {
+      const w1 = Number.parseInt(hex[1], 16);
+      const w2 = Number.parseInt(hex[2], 16);
+      if (isPrivateIPv4(`${w1 >> 8}.${w1 & 255}.${w2 >> 8}.${w2 & 255}`)) return true;
+    }
+    return false;
+  }
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(host)) return isPrivateIPv4(host);
+  return false;
+}
+function isPrivateIPv4(host) {
+  const a = Number.parseInt(host.split(".")[0] ?? "", 10);
+  const b2 = Number.parseInt(host.split(".")[1] ?? "", 10);
+  if (a === 127 || a === 10 || a === 0) return true;
+  if (a === 172 && b2 >= 16 && b2 <= 31) return true;
+  if (a === 192 && b2 === 168) return true;
+  if (a === 169 && b2 === 254) return true;
+  return false;
+}
+function launcherInjectMcp(env, base, codexUpstream) {
+  if (base === "pi" || base === "omp" || base === "opencode" || base === "hermes" || base === "dsh") return false;
+  if (env.BILI_LAUNCHER_PLUGIN === "0") return false;
+  if (base === "codex" && env.BILI_LAUNCHER_PLUGIN === void 0 && codexUpstream !== void 0 && isPrivateUpstreamHost(codexUpstream)) {
+    return false;
+  }
+  return true;
 }
 function buildMcpConfig(origin) {
   const script = selfDistFile("mcp.js");
@@ -61259,6 +61855,7 @@ async function runLaunch(params, deps = {}) {
   const config = loadClientConfig(process.env, process.cwd());
   const base = baseClientName(params.client);
   const routes = discoverRoutes(base, config);
+  const biliRoutes = loadRoutes(process.env);
   const domains = dedupeInOrder([...routes.httpsDomains, ...params.mitmDomains ?? []]);
   const handle2 = await ensureProxyRunning({ host, port, passthrough, debug, mitmDomains: domains, modelWindows: collectModelWindows(config) }, deps);
   console.error(
@@ -61288,11 +61885,16 @@ async function runLaunch(params, deps = {}) {
       );
     }
   }
-  const injectMcp = launcherInjectMcp(process.env, base);
+  const codexUpstream = base === "codex" ? codexUpstreamUrl(config.codex) : void 0;
+  const injectMcp = launcherInjectMcp(process.env, base, codexUpstream);
   if (injectMcp) {
     console.error(`bili: injecting native bili MCP tools for ${base} (disable with BILI_LAUNCHER_PLUGIN=0).`);
   } else if (base === "claude" || base === "codex") {
-    console.error("bili: native MCP tools disabled (BILI_LAUNCHER_PLUGIN=0) \u2014 running in pure wire mode.");
+    if (process.env.BILI_LAUNCHER_PLUGIN === "0") {
+      console.error("bili: native MCP tools disabled (BILI_LAUNCHER_PLUGIN=0) \u2014 running in pure wire mode.");
+    } else {
+      console.error(`bili: codex upstream ${codexUpstream} is local/private \u2014 self-hosted models cannot see codex namespace MCP tools; using wire-injected flat tools instead (force MCP with BILI_LAUNCHER_PLUGIN=1).`);
+    }
   }
   const origin = handle2.origin;
   if (base === "pi") {
@@ -61352,18 +61954,40 @@ async function runLaunch(params, deps = {}) {
     const dshAcpPatch = writeDshAcpPatch(dshHomeDir);
     if (dshAcpPatch) clientArgs = dshArgsWithPatch(clientArgs, dshAcpPatch);
   } else if (base === "codex") {
-    const codexConversationId = injectMcp ? randomUUID3() : void 0;
+    const codexConversationId = injectMcp ? randomUUID4() : void 0;
     if (directUrl) {
       env = { ...process.env, BILLION_CONTEXT_PROXY: origin };
       if (codexConversationId) clientArgs = [...buildCodexMcpArgs(origin, codexConversationId), ...clientArgs];
     } else {
       env = buildCodexEnv(origin, resolveCombinedCaPath(process.env), process.env);
       clientArgs = buildCodexArgs(origin, routes.httpRewrites, routes.httpsRewrites, clientArgs);
+      const budgetArgs = await resolveCodexBudgetArgs({
+        model: config.codex?.model,
+        clientWindow: config.codex?.contextWindow,
+        clientAutoCompactLimit: config.codex?.autoCompactLimit,
+        routes: biliRoutes,
+        upstreamUrl: codexUpstreamUrl(config.codex)
+      });
+      if (budgetArgs.length > 0) {
+        clientArgs = [...budgetArgs, ...clientArgs];
+        console.error(`bili: codex budget aligned \u2014 ${budgetArgs.slice(2).join(", ")} (model: ${config.codex?.model})`);
+      }
       if (injectMcp && codexConversationId) clientArgs = [...buildCodexMcpArgs(origin, codexConversationId), ...clientArgs];
     }
   } else {
     env = directUrl ? buildClaudePluginEnv(origin, true, process.env) : buildClaudeEnv(origin, ca, routes.httpRewrites, routes.httpsRewrites, process.env);
     if (directUrl) env.BILLION_CONTEXT_PROXY = origin;
+    const claudeBudget = await resolveClaudeBudgetEnv({
+      model: nonEmpty2(process.env.ANTHROPIC_MODEL) ? process.env.ANTHROPIC_MODEL : config.claude?.model,
+      userAutoCompactWindow: config.claude?.autoCompactWindow,
+      shellAutoCompactWindow: process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW,
+      routes: biliRoutes,
+      upstreamUrl: config.claude?.anthropicBaseUrl ?? "https://api.anthropic.com"
+    });
+    Object.assign(env, claudeBudget);
+    if (claudeBudget.CLAUDE_CODE_AUTO_COMPACT_WINDOW !== void 0) {
+      console.error(`bili: claude budget aligned \u2014 CLAUDE_CODE_AUTO_COMPACT_WINDOW=${claudeBudget.CLAUDE_CODE_AUTO_COMPACT_WINDOW}`);
+    }
     if (injectMcp) {
       const mcpFile = path13.join(os5.tmpdir(), `bili-mcp-${Date.now()}.json`);
       fs10.writeFileSync(mcpFile, JSON.stringify(buildMcpConfig(origin)));