billion-context 0.1.0 → 0.1.2

package/dist/index.js

@@ -3,28 +3,105 @@
 // src/config.ts
 import { defaultConfig } from "acp-kernel";
 import { readFileSync } from "fs";
-function safeReadJson(path) {
+
+// src/paths.ts
+import { homedir } from "os";
+import path from "path";
+function xdg(envVar, fallback) {
+  const v = process.env[envVar];
+  if (v && v.length > 0) return path.resolve(v);
+  return path.join(homedir(), fallback);
+}
+function configDir() {
+  return path.join(xdg("XDG_CONFIG_HOME", ".config"), "billion-context");
+}
+function configFile() {
+  const env = process.env.BILI_CONFIG_FILE;
+  if (env && env.length > 0) return path.resolve(env);
+  return path.join(configDir(), "billion-context.json");
+}
+function dataDir() {
+  return path.join(xdg("XDG_DATA_HOME", ".local/share"), "billion-context");
+}
+function sessionsDir() {
+  const env = process.env.BILI_SESSIONS_DIR;
+  if (env && env.length > 0) return path.resolve(env);
+  return path.join(dataDir(), "sessions");
+}
+
+// src/config.ts
+function safeReadJson(path4) {
   try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
+    return JSON.parse(readFileSync(path4, "utf8"));
+  } catch (e) {
+    if (e.code !== "ENOENT") {
+      console.error(`[acp-config] failed to parse ${path4}: ${String(e)}`);
+    }
     return void 0;
   }
 }
+var CONTEXT_LIMIT_TABLE = [
+  { match: /^claude-/i, limit: 2e5 },
+  { match: /^gpt-5/i, limit: 4e5 },
+  { match: /^gpt-4\.1/i, limit: 1e6 },
+  { match: /^gpt-4o/i, limit: 128e3 },
+  { match: /^gpt-4-turbo/i, limit: 128e3 },
+  { match: /^o[13]-/i, limit: 2e5 },
+  { match: /^gemini-2\.5/i, limit: 1e6 },
+  { match: /^gemini-1\.5/i, limit: 1e6 },
+  { match: /^glm-4\.6/i, limit: 128e3 },
+  { match: /^glm-5/i, limit: 1e6 },
+  { match: /^glm-/i, limit: 128e3 },
+  { match: /^deepseek/i, limit: 64e3 },
+  { match: /^qwen/i, limit: 128e3 },
+  { match: /^kimi/i, limit: 128e3 },
+  { match: /^llama-/i, limit: 128e3 }
+];
+function lookupContextLimit(model) {
+  if (!model) return void 0;
+  for (const entry of CONTEXT_LIMIT_TABLE) {
+    if (entry.match.test(model)) return entry.limit;
+  }
+  return void 0;
+}
+function resolveContextLimit(routes, provider, model) {
+  if (!model) return void 0;
+  if (provider) {
+    const route = routes[provider];
+    if (route?.models) {
+      const m = route.models[model];
+      if (m?.context && m.context > 0) return m.context;
+    }
+  }
+  return lookupContextLimit(model);
+}
 function loadOptions(env = process.env) {
-  const port = parseInt(env.ACP_PORT ?? env.PORT ?? "8787", 10);
-  const host = env.ACP_HOST ?? "127.0.0.1";
-  const upstream = (env.ACP_UPSTREAM ?? "https://api.anthropic.com").replace(/\/$/, "");
-  let routes = [];
-  const routesPath = env.ACP_PROVIDERS ?? "";
+  const fileConfig = loadConfigFile();
+  const port = parseInt(env.ACP_PORT ?? env.PORT ?? `${fileConfig.port ?? 8787}`, 10);
+  const host = env.ACP_HOST ?? fileConfig.host ?? "127.0.0.1";
+  const upstream = (env.ACP_UPSTREAM ?? fileConfig.upstream ?? "https://api.anthropic.com").replace(/\/$/, "");
+  let routes = {};
+  const routesPath = env.ACP_PROVIDERS ?? fileConfig.providersPath ?? "";
   if (routesPath) {
     const parsed = safeReadJson(routesPath);
-    if (Array.isArray(parsed)) routes = parsed.filter((r) => r && typeof r.baseURL === "string");
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      for (const [k, v] of Object.entries(parsed)) {
+        const route = parseRouteEntry(v);
+        if (route) routes[k] = route;
+      }
+    }
+  }
+  if (fileConfig.providers) {
+    for (const [k, v] of Object.entries(fileConfig.providers)) {
+      const route = parseRouteEntry(v);
+      if (route && !routes[k]) routes[k] = route;
+    }
   }
-  const modelContextLimit = parseInt(env.ACP_MODEL_CONTEXT_LIMIT ?? "200000", 10);
-  const enabled = (env.ACP_CONDENSE_ENABLED ?? "1") !== "0";
-  const keepRecentToolResults = parseInt(env.ACP_KEEP_RECENT_TOOL_RESULTS ?? "6", 10);
-  const minCharsToCondense = parseInt(env.ACP_MIN_CHARS_TO_CONDENSE ?? "1500", 10);
-  const maxKeptChars = parseInt(env.ACP_MAX_KEPT_CHARS ?? "400", 10);
+  const modelContextLimit = parseInt(env.ACP_MODEL_CONTEXT_LIMIT ?? `${fileConfig.modelContextLimit ?? 2e5}`, 10);
+  const enabled = (env.ACP_CONDENSE_ENABLED ?? (fileConfig.condense?.enabled === false ? "0" : "1")) !== "0";
+  const keepRecentToolResults = parseInt(env.ACP_KEEP_RECENT_TOOL_RESULTS ?? `${fileConfig.condense?.keepRecentToolResults ?? 6}`, 10);
+  const minCharsToCondense = parseInt(env.ACP_MIN_CHARS_TO_CONDENSE ?? `${fileConfig.condense?.minCharsToCondense ?? 1500}`, 10);
+  const maxKeptChars = parseInt(env.ACP_MAX_KEPT_CHARS ?? `${fileConfig.condense?.maxKeptChars ?? 400}`, 10);
   return {
     port: Number.isFinite(port) ? port : 8787,
     host,
@@ -34,23 +111,83 @@ function loadOptions(env = process.env) {
     kernelConfig: defaultConfig(modelContextLimit),
     condense: { enabled, keepRecentToolResults, minCharsToCondense, maxKeptChars },
     compress: {
-      injectTool: (env.ACP_COMPRESS_TOOL ?? "1") !== "0",
-      injectNudge: (env.ACP_COMPRESS_NUDGE ?? "1") !== "0"
+      injectTool: (env.ACP_COMPRESS_TOOL ?? (fileConfig.compress?.injectTool === false ? "0" : "1")) !== "0",
+      injectNudge: (env.ACP_COMPRESS_NUDGE ?? (fileConfig.compress?.injectNudge === false ? "0" : "1")) !== "0"
     },
-    sessionHeader: env.ACP_SESSION_HEADER ?? "x-acp-session",
-    log: env.ACP_LOG !== "0",
-    debug: (env.ACP_DEBUG ?? "0") === "1",
-    dumpSse: env.ACP_DUMP_SSE || void 0,
-    passthrough: (env.ACP_PASSTHROUGH ?? "0") === "1"
+    sessionHeader: env.ACP_SESSION_HEADER ?? fileConfig.sessionHeader ?? "x-acp-session",
+    log: env.ACP_LOG !== "0" && fileConfig.log !== false,
+    debug: (env.ACP_DEBUG ?? (fileConfig.debug ? "1" : "0")) === "1",
+    dumpSse: env.ACP_DUMP_SSE || fileConfig.dumpSse || void 0,
+    passthrough: (env.ACP_PASSTHROUGH ?? (fileConfig.passthrough ? "1" : "0")) === "1"
   };
 }
+function loadConfigFile() {
+  const parsed = safeReadJson(configFile());
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    return parsed;
+  }
+  return {};
+}
+function parseRouteEntry(v) {
+  if (typeof v === "string" && v.length > 0) {
+    return { url: v.replace(/\/$/, "") };
+  }
+  if (v && typeof v === "object" && !Array.isArray(v) && typeof v.url === "string" && v.url.length > 0) {
+    const obj = v;
+    return { url: obj.url.replace(/\/$/, ""), models: obj.models };
+  }
+  return void 0;
+}
 
 // src/server.ts
 import http from "http";
-import fs from "fs";
-import { createCore, estimateTokensFast as estimateTokensFast2, renderNudgeText } from "acp-kernel";
+import fs2 from "fs";
+import { createCore, estimateTokensFast as estimateTokensFast3, renderNudgeText, deactivateBlock as deactivateBlock4 } from "acp-kernel";
+
+// src/fetch-util.ts
+var MAX_REQUEST_BYTES = 100 * 1024 * 1024;
+var UPSTREAM_TIMEOUT_MS = 10 * 60 * 1e3;
+async function fetchWithTimeout(url, init, timeoutMs = UPSTREAM_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { ...init, signal: controller.signal });
+    return { response, clearTimer: () => clearTimeout(timer) };
+  } catch (e) {
+    clearTimeout(timer);
+    throw e;
+  }
+}
+
+// src/util.ts
+import { createHash } from "crypto";
+function hashId(s) {
+  return createHash("sha256").update(s, "utf8").digest("hex").slice(0, 16);
+}
+function safeJsonParse(s) {
+  try {
+    return s ? JSON.parse(s) : {};
+  } catch {
+    return {};
+  }
+}
+
+// src/message-id.ts
+function deriveMessageId(role, contentType, text, options = {}) {
+  const seed = `${role}|${contentType}|${options.toolCallId ?? ""}|${options.toolName ?? ""}|${text}`;
+  return "h_" + hashId(seed);
+}
+var ClusterCounter = class {
+  counts = /* @__PURE__ */ new Map();
+  next(baseId) {
+    const n = this.counts.get(baseId) ?? 0;
+    this.counts.set(baseId, n + 1);
+    return n === 0 ? baseId : `${baseId}_${n}`;
+  }
+};
 
 // src/anthropic.ts
+var CONDENSED_TAG = "[acp-proxy: condensed";
 function extractSystem(system) {
   if (!system) return "";
   if (typeof system === "string") return system;
@@ -65,19 +202,23 @@ function buildSystem(text, original) {
 }
 function anthropicToCore(body) {
   const msgs = [];
-  let idx = 0;
+  const clusters = new ClusterCounter();
   for (const m of body.messages) {
     const blocks = typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content;
     for (const b of blocks) {
-      const id = `raw-${idx}`;
-      idx++;
       switch (b.type) {
-        case "text":
-          msgs.push({ id, role: m.role, contentType: "text", text: b.text });
+        case "text": {
+          const base = deriveMessageId(m.role, "text", b.text);
+          msgs.push({ id: clusters.next(base), role: m.role, contentType: "text", text: b.text });
           break;
-        case "tool_use":
+        }
+        case "tool_use": {
+          const base = deriveMessageId("assistant", "tool-call", safeStringify(b.input), {
+            toolCallId: b.id,
+            toolName: b.name
+          });
           msgs.push({
-            id,
+            id: clusters.next(base),
             role: "assistant",
             contentType: "tool-call",
             toolName: b.name,
@@ -85,10 +226,12 @@ function anthropicToCore(body) {
             text: safeStringify(b.input)
           });
           break;
+        }
         case "tool_result": {
           const text = typeof b.content === "string" ? b.content : b.content.map((c) => c.text).join("\n");
+          const base = deriveMessageId("tool", "tool-result", text, { toolCallId: b.tool_use_id });
           msgs.push({
-            id,
+            id: clusters.next(base),
             role: "tool",
             contentType: "tool-result",
             toolCallId: b.tool_use_id,
@@ -96,12 +239,16 @@ function anthropicToCore(body) {
           });
           break;
         }
-        case "thinking":
-          msgs.push({ id, role: "assistant", contentType: "reasoning", text: b.thinking });
+        case "thinking": {
+          const base = deriveMessageId("assistant", "reasoning", b.thinking);
+          msgs.push({ id: clusters.next(base), role: "assistant", contentType: "reasoning", text: b.thinking });
           break;
-        case "image":
-          msgs.push({ id, role: m.role, contentType: "text", text: "[image]" });
+        }
+        case "image": {
+          const base = deriveMessageId(m.role, "text", "[image]");
+          msgs.push({ id: clusters.next(base), role: m.role, contentType: "text", text: "[image]" });
           break;
+        }
       }
     }
   }
@@ -149,11 +296,38 @@ function coreToAnthropic(messages) {
   flush();
   return out;
 }
-function deriveSessionId(body, headerValue2) {
+function condenseOldToolResults(messages, opts) {
+  if (!opts.enabled) return { messages, condensedCount: 0, charsSaved: 0 };
+  const toolResultIndices = [];
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    if (m && m.contentType === "tool-result") toolResultIndices.push(i);
+  }
+  if (toolResultIndices.length <= opts.keepRecent) {
+    return { messages, condensedCount: 0, charsSaved: 0 };
+  }
+  const toCondense = new Set(toolResultIndices.slice(0, toolResultIndices.length - opts.keepRecent));
+  let condensedCount = 0;
+  let charsSaved = 0;
+  const out = messages.map((m, i) => {
+    if (!toCondense.has(i)) return m;
+    const text = m.text ?? "";
+    if (text.length < opts.minChars) return m;
+    const head = text.slice(0, opts.maxKeptChars);
+    const stub = `${CONDENSED_TAG} ${text.length.toLocaleString()} chars]
+${head}
+[/acp-proxy]`;
+    charsSaved += text.length - stub.length;
+    condensedCount++;
+    return { ...m, text: stub };
+  });
+  return { messages: out, condensedCount, charsSaved };
+}
+function conversationSignalAnthropic(body, headerValue2) {
   if (headerValue2 && headerValue2.trim()) return headerValue2.trim();
   const firstUser = body.messages.find((m) => m.role === "user");
   const seed = firstUser ? JSON.stringify(firstUser.content).slice(0, 200) : "default";
-  return hash(seed);
+  return hashId(seed);
 }
 function safeStringify(v) {
   try {
@@ -170,62 +344,59 @@ function safeParse(s) {
     return {};
   }
 }
-function hash(s) {
-  let h = 2166136261;
-  for (let i = 0; i < s.length; i++) {
-    h ^= s.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return (h >>> 0).toString(36);
-}
 
 // src/openai.ts
 function openaiToCore(body) {
   const msgs = [];
-  let idx = 0;
+  const clusters = new ClusterCounter();
   for (const m of body.messages) {
     switch (m.role) {
       case "system":
       case "developer": {
-        msgs.push({ id: `raw-${idx}`, role: "system", contentType: "text", text: stringContent(m.content) });
-        idx++;
+        const base = deriveMessageId(m.role, "text", stringContent(m.content));
+        msgs.push({ id: clusters.next(base), role: "system", contentType: "text", text: stringContent(m.content) });
         break;
       }
       case "user": {
-        msgs.push({ id: `raw-${idx}`, role: "user", contentType: "text", text: stringContent(m.content) });
-        idx++;
+        const base = deriveMessageId("user", "text", stringContent(m.content));
+        msgs.push({ id: clusters.next(base), role: "user", contentType: "text", text: stringContent(m.content) });
         break;
       }
       case "assistant": {
         const text = stringContent(m.content);
         if (text) {
-          msgs.push({ id: `raw-${idx}`, role: "assistant", contentType: "text", text });
-          idx++;
+          const base = deriveMessageId("assistant", "text", text);
+          msgs.push({ id: clusters.next(base), role: "assistant", contentType: "text", text });
         }
         if (Array.isArray(m.tool_calls)) {
           for (const tc of m.tool_calls) {
+            const base = deriveMessageId("assistant", "tool-call", tc.function.arguments ?? "", {
+              toolCallId: tc.id,
+              toolName: tc.function.name
+            });
             msgs.push({
-              id: `raw-${idx}`,
+              id: clusters.next(base),
               role: "assistant",
               contentType: "tool-call",
               toolName: tc.function.name,
               toolCallId: tc.id,
               text: tc.function.arguments ?? ""
             });
-            idx++;
           }
         }
         break;
       }
       case "tool": {
+        const base = deriveMessageId("tool", "tool-result", stringContent(m.content), {
+          toolCallId: m.tool_call_id ?? ""
+        });
         msgs.push({
-          id: `raw-${idx}`,
+          id: clusters.next(base),
           role: "tool",
           contentType: "tool-result",
           toolCallId: m.tool_call_id ?? "",
           text: stringContent(m.content)
         });
-        idx++;
         break;
       }
     }
@@ -289,11 +460,11 @@ ${extra}` : extra;
   }
   return [{ role: "system", content: extra }, ...messages];
 }
-function deriveSessionIdOpenai(body, headerValue2) {
+function conversationSignalOpenai(body, headerValue2) {
   if (headerValue2 && headerValue2.trim()) return headerValue2.trim();
   const firstUser = body.messages.find((m) => m.role === "user");
   const seed = firstUser ? stringContent(firstUser.content).slice(0, 200) : "default";
-  return hash2(seed);
+  return hashId(seed);
 }
 function stringContent(content) {
   if (content == null) return "";
@@ -303,56 +474,623 @@ function stringContent(content) {
   }
   return "";
 }
-function hash2(s) {
-  let h = 2166136261;
-  for (let i = 0; i < s.length; i++) {
-    h ^= s.charCodeAt(i);
-    h = Math.imul(h, 16777619);
+
+// src/responses.ts
+var OPAQUE_ITEM_TYPES = /* @__PURE__ */ new Set([
+  "additional_tools",
+  "reasoning",
+  "computer_call",
+  "computer_call_output",
+  "file_search_call",
+  "web_search_call",
+  "image_generation_call",
+  "code_interpreter_call",
+  "mcp_list_tools",
+  "mcp_call"
+]);
+function isOpaqueItem(it) {
+  return OPAQUE_ITEM_TYPES.has(it.type);
+}
+function partText(p) {
+  if (p.type === "input_text" || p.type === "output_text") {
+    const t = p.text;
+    return typeof t === "string" ? t : "";
+  }
+  return "";
+}
+function messageContent(c) {
+  if (typeof c === "string") return c;
+  if (Array.isArray(c)) return c.map(partText).join("\n");
+  return "";
+}
+function responsesToCore(body) {
+  const msgs = [];
+  const systemParts = [];
+  const preamble = [];
+  const customToolCallIds = /* @__PURE__ */ new Set();
+  if (typeof body.instructions === "string" && body.instructions.trim()) {
+    systemParts.push(body.instructions);
+  }
+  let idx = 0;
+  const clusters = new ClusterCounter();
+  const items = Array.isArray(body.input) ? body.input : [];
+  if (typeof body.input === "string") {
+    const base = deriveMessageId("user", "text", body.input);
+    msgs.push({ id: clusters.next(base), role: "user", contentType: "text", text: body.input });
+    idx++;
+    return { msgs, systemParts, preamble, customToolCallIds };
+  }
+  for (const it of items) {
+    if (isOpaqueItem(it)) {
+      preamble.push(it);
+      continue;
+    }
+    switch (it.type) {
+      case "message": {
+        const m = it;
+        const text = messageContent(m.content);
+        if (m.role === "system" || m.role === "developer") {
+          systemParts.push(text);
+        } else if (m.role === "user") {
+          const base = deriveMessageId("user", "text", text);
+          msgs.push({ id: clusters.next(base), role: "user", contentType: "text", text });
+          idx++;
+        } else if (m.role === "assistant") {
+          if (text) {
+            const base = deriveMessageId("assistant", "text", text);
+            msgs.push({ id: clusters.next(base), role: "assistant", contentType: "text", text });
+            idx++;
+          }
+        }
+        break;
+      }
+      case "function_call": {
+        const fc = it;
+        const base = deriveMessageId("assistant", "tool-call", fc.arguments ?? "", {
+          toolCallId: fc.call_id,
+          toolName: fc.name
+        });
+        msgs.push({
+          id: clusters.next(base),
+          role: "assistant",
+          contentType: "tool-call",
+          toolName: fc.name,
+          toolCallId: fc.call_id,
+          text: fc.arguments ?? ""
+        });
+        idx++;
+        break;
+      }
+      case "function_call_output": {
+        const fco = it;
+        const outText = typeof fco.output === "string" ? fco.output : JSON.stringify(fco.output);
+        const base = deriveMessageId("tool", "tool-result", outText, { toolCallId: fco.call_id });
+        msgs.push({
+          id: clusters.next(base),
+          role: "tool",
+          contentType: "tool-result",
+          toolCallId: fco.call_id,
+          text: outText
+        });
+        idx++;
+        break;
+      }
+      case "custom_tool_call": {
+        const ctc = it;
+        const callId = ctc.call_id ?? `call_${idx}`;
+        customToolCallIds.add(callId);
+        const argText = ctc.input ?? ctc.arguments ?? "";
+        const base = deriveMessageId("assistant", "tool-call", argText, {
+          toolCallId: callId,
+          toolName: ctc.name ?? "custom"
+        });
+        msgs.push({
+          id: clusters.next(base),
+          role: "assistant",
+          contentType: "tool-call",
+          toolName: ctc.name ?? "custom",
+          toolCallId: callId,
+          text: argText
+        });
+        idx++;
+        break;
+      }
+      case "custom_tool_call_output": {
+        const ctco = it;
+        const callId = ctco.call_id ?? `call_${idx}`;
+        customToolCallIds.add(callId);
+        const outText = typeof ctco.output === "string" ? ctco.output : JSON.stringify(ctco.output ?? "");
+        const base = deriveMessageId("tool", "tool-result", outText, { toolCallId: callId });
+        msgs.push({
+          id: clusters.next(base),
+          role: "tool",
+          contentType: "tool-result",
+          toolCallId: callId,
+          text: outText
+        });
+        idx++;
+        break;
+      }
+      default:
+        preamble.push(it);
+        break;
+    }
+  }
+  return { msgs, systemParts, preamble, customToolCallIds };
+}
+function coreToResponses(messages, customToolCallIds = /* @__PURE__ */ new Set()) {
+  const out = [];
+  for (const m of messages) {
+    if (m.role === "system") {
+      out.push({ type: "message", role: "developer", content: m.text ?? "" });
+    } else if (m.role === "user") {
+      out.push({ type: "message", role: "user", content: m.text ?? "" });
+    } else if (m.role === "assistant") {
+      if (m.contentType === "text") {
+        out.push({ type: "message", role: "assistant", content: m.text ?? "" });
+      } else if (m.contentType === "tool-call") {
+        const callId = m.toolCallId ?? `call_${m.id}`;
+        if (customToolCallIds.has(callId)) {
+          out.push({
+            type: "custom_tool_call",
+            call_id: callId,
+            name: m.toolName ?? "unknown",
+            input: m.text ?? "",
+            status: "completed"
+          });
+        } else {
+          out.push({
+            type: "function_call",
+            call_id: callId,
+            name: m.toolName ?? "unknown",
+            arguments: m.text ?? ""
+          });
+        }
+      }
+    } else if (m.role === "tool") {
+      const callId = m.toolCallId ?? "";
+      if (customToolCallIds.has(callId)) {
+        out.push({
+          type: "custom_tool_call_output",
+          call_id: callId,
+          output: m.text ?? ""
+        });
+      } else {
+        out.push({
+          type: "function_call_output",
+          call_id: callId,
+          output: m.text ?? ""
+        });
+      }
+    }
   }
-  return (h >>> 0).toString(36);
+  return out;
+}
+function conversationSignalResponses(body, headerValue2) {
+  if (headerValue2 && headerValue2.trim()) return headerValue2.trim();
+  if (typeof body.session_id === "string" && body.session_id.length > 0) {
+    return `codex-${body.session_id}`;
+  }
+  if (typeof body.previous_response_id === "string" && body.previous_response_id.length > 0) {
+    return `resp-${body.previous_response_id}`;
+  }
+  let seed = "default";
+  if (Array.isArray(body.input)) {
+    const firstUser = body.input.find(
+      (i) => i.type === "message" && i.role === "user"
+    );
+    if (firstUser) seed = messageContent(firstUser.content).slice(0, 200);
+  } else if (typeof body.input === "string") {
+    seed = body.input.slice(0, 200);
+  }
+  return hashId(seed);
 }
 
 // src/session.ts
+import { createInitialState as createInitialState2 } from "acp-kernel";
+
+// src/persist.ts
+import { promises as fs } from "fs";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync } from "fs";
+import { createHash as createHash2 } from "crypto";
+import * as path2 from "path";
 import { createInitialState } from "acp-kernel";
+var PERSIST_VERSION = 1;
+function mergeState(parsed) {
+  const fresh = createInitialState();
+  return {
+    blocks: parsed.blocks ?? fresh.blocks,
+    messageRefs: parsed.messageRefs ?? fresh.messageRefs,
+    nudge: { ...fresh.nudge, ...parsed.nudge ?? {} },
+    stats: { ...fresh.stats, ...parsed.stats ?? {} },
+    nextBlockId: parsed.nextBlockId ?? fresh.nextBlockId,
+    nextRunId: parsed.nextRunId ?? fresh.nextRunId
+  };
+}
+function hostLabel(upstreamOrigin) {
+  if (!upstreamOrigin) return "unknown";
+  try {
+    const host = new URL(upstreamOrigin).hostname || "unknown";
+    return host.replace(/[^a-zA-Z0-9.-]/g, "-").slice(0, 48) || "unknown";
+  } catch {
+    return "unknown-" + createHash2("sha256").update(upstreamOrigin, "utf8").digest("hex").slice(0, 6);
+  }
+}
+function relPathFor(id, protocol, upstreamOrigin) {
+  const proto = protocol ?? "_unknown";
+  const host = protocol ? hostLabel(upstreamOrigin) + "_" : "";
+  return path2.join(proto, `${host}${createHash2("sha256").update(id, "utf8").digest("hex").slice(0, 24)}.json`);
+}
+function legacyFileNameFor(id) {
+  return createHash2("sha256").update(id, "utf8").digest("hex").slice(0, 24) + ".json";
+}
+var SessionStore = class {
+  dir;
+  debounceMs;
+  enabled;
+  timers = /* @__PURE__ */ new Map();
+  /** Monotonic counter for unique temp filenames within a process. */
+  tmpSeq = 0;
+  log;
+  constructor(opts) {
+    this.dir = opts?.dir ?? defaultDir();
+    this.debounceMs = opts?.debounceMs ?? defaultDebounce();
+    this.enabled = (opts?.enabled ?? true) && this.debounceMs >= 0;
+    this.log = opts?.log ?? defaultLogger;
+  }
+  filePath(id, protocol, upstreamOrigin) {
+    return path2.join(this.dir, relPathFor(id, protocol, upstreamOrigin));
+  }
+  /** A unique temp path per write (per process). Two overlapping writes for
+   *  the same session must not share a temp file, or one rename invalidates
+   *  the other. */
+  tempPath(id) {
+    return path2.join(this.dir, `.tmp-${legacyFileNameFor(id)}-${process.pid}-${this.tmpSeq++}`);
+  }
+  /** Bulk-load every persisted session from disk into a map keyed by the
+   *  REAL session id (read from the file body, not the filename). Called once
+   *  at startup before the server accepts traffic. Corrupt individual files
+   *  are skipped (logged) — one bad file never blocks boot. */
+  async loadAll() {
+    const out = /* @__PURE__ */ new Map();
+    if (!this.enabled) return out;
+    try {
+      await fs.mkdir(this.dir, { recursive: true });
+    } catch {
+      return out;
+    }
+    const files = [];
+    const walk = async (dir) => {
+      let entries;
+      try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const e of entries) {
+        if (e.name.startsWith(".tmp-")) continue;
+        const full = path2.join(dir, e.name);
+        if (e.isDirectory()) {
+          await walk(full);
+        } else if (e.isFile() && e.name.endsWith(".json")) {
+          files.push(full);
+        }
+      }
+    };
+    await walk(this.dir);
+    for (const full of files) {
+      const name = path2.basename(full);
+      try {
+        const parsed = JSON.parse(await fs.readFile(full, "utf8"));
+        if (!isValidRecord(parsed)) continue;
+        const proto = parsed.protocol;
+        const origin = parsed.upstreamOrigin;
+        const expectedNamespaced = path2.basename(relPathFor(parsed.id, proto, origin));
+        const expectedLegacy = legacyFileNameFor(parsed.id);
+        if (name !== expectedNamespaced && name !== expectedLegacy) {
+          this.log("warn", `[persist] skipping ${full}: filename does not match body id (expected ${expectedNamespaced})`);
+          continue;
+        }
+        out.set(parsed.id, buildSession(parsed));
+      } catch (e) {
+        this.log("warn", `[persist] skipping corrupt session file ${full}: ${msg(e)}`);
+      }
+    }
+    return out;
+  }
+  /** Synchronous reload of a single session. Used on a memory miss (after
+   *  LRU eviction). Sync fs is acceptable here because a miss is rare and
+   *  reads a single small file (~1ms). Returns null if missing/corrupt or the
+   *  body id does not match what we asked for. */
+  loadSync(id, meta) {
+    if (!this.enabled) return null;
+    const candidates = [this.filePath(id, meta?.protocol, meta?.upstreamOrigin)];
+    if (meta?.protocol) candidates.push(this.filePath(id));
+    for (const file of candidates) {
+      if (!existsSync(file)) continue;
+      try {
+        const parsed = JSON.parse(readFileSync2(file, "utf8"));
+        if (!isValidRecord(parsed) || parsed.id !== id) continue;
+        return buildSession(parsed);
+      } catch (e) {
+        this.log("warn", `[persist] failed to load session ${id}: ${msg(e)}`);
+      }
+    }
+    return null;
+  }
+  /** Schedule a debounced write for a session. Multiple calls within the
+   *  window coalesce. Safe to call on the hot path. No-op if disabled. */
+  scheduleSave(session) {
+    if (!this.enabled) return;
+    const existing = this.timers.get(session.id);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      this.timers.delete(session.id);
+      void this.writeNow(session).catch((e) => {
+        this.log("error", `[persist] debounced write failed for ${session.id}: ${msg(e)}`);
+      });
+    }, this.debounceMs);
+    timer.unref?.();
+    this.timers.set(session.id, timer);
+  }
+  /** Asynchronously persist a session right now (skips the debounce). Throws
+   *  on write failure so callers can react (e.g. avoid evicting). */
+  async writeNow(session) {
+    if (!this.enabled) return;
+    const record = buildRecord(session);
+    const file = this.filePath(session.id, session.protocol, session.upstreamOrigin);
+    try {
+      await fs.mkdir(path2.dirname(file), { recursive: true });
+    } catch (e) {
+      this.log("warn", `[persist] could not create session dir ${this.dir}: ${msg(e)}`);
+    }
+    const tmp = this.tempPath(session.id);
+    const data = JSON.stringify(record);
+    await fs.writeFile(tmp, data, "utf8");
+    await fs.rename(tmp, file);
+  }
+  /** Synchronous flush for a single session. Used on memory eviction so a
+   *  dirty evicted session is not lost. Sync because eviction runs in the
+   *  sync getSession path; a single small write is acceptable.
+   *  Returns true on success, false on failure (caller must NOT evict on
+   *  failure for a never-persisted session or it is lost permanently). */
+  flushSync(session) {
+    if (!this.enabled) return true;
+    const existing = this.timers.get(session.id);
+    if (existing) {
+      clearTimeout(existing);
+      this.timers.delete(session.id);
+    }
+    const record = buildRecord(session);
+    const file = this.filePath(session.id, session.protocol, session.upstreamOrigin);
+    try {
+      mkdirSync(path2.dirname(file), { recursive: true });
+    } catch (e) {
+      this.log("warn", `[persist] could not create session dir ${this.dir}: ${msg(e)}`);
+    }
+    const tmp = this.tempPath(session.id);
+    try {
+      writeFileSync(tmp, JSON.stringify(record), "utf8");
+      renameSync(tmp, file);
+      return true;
+    } catch (e) {
+      this.log("error", `[persist] flushSync FAILED for ${session.id}: ${msg(e)} \u2014 session NOT evicted to prevent loss`);
+      try {
+        unlinkSync(tmp);
+      } catch {
+      }
+      return false;
+    }
+  }
+  /** Flush all dirty sessions with a pending debounce timer. Called on
+   *  SIGTERM/SIGINT for graceful shutdown. Clears timers first, then writes
+   *  every session that had a pending write. */
+  async flushAll(sessions2) {
+    if (!this.enabled) return;
+    const dirty = new Set(this.timers.keys());
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+    const pending = [];
+    for (const s of sessions2) {
+      if (!dirty.has(s.id)) continue;
+      pending.push(
+        this.writeNow(s).catch((e) => {
+          this.log("error", `[persist] shutdown flush failed for ${s.id}: ${msg(e)}`);
+        })
+      );
+    }
+    await Promise.all(pending);
+  }
+  /** Whether a write is currently pending (debounce timer armed) for a id. */
+  hasPending(id) {
+    return this.timers.has(id);
+  }
+  /** Cancel all pending writes without flushing (e.g. for tests). */
+  cancelAll() {
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+  }
+};
+function buildRecord(session) {
+  return {
+    version: PERSIST_VERSION,
+    savedAt: Date.now(),
+    id: session.id,
+    protocol: session.protocol,
+    upstreamOrigin: session.upstreamOrigin,
+    createdAt: session.createdAt,
+    requests: session.requests,
+    condensedToolResults: session.condensedToolResults,
+    tokensSaved: session.tokensSaved,
+    state: session.state,
+    blockContents: Object.fromEntries(session.blockContents)
+  };
+}
+function buildSession(parsed) {
+  const blockContents = /* @__PURE__ */ new Map();
+  for (const [bid, content] of Object.entries(parsed.blockContents ?? {})) {
+    if (content && typeof content === "object") blockContents.set(bid, content);
+  }
+  return {
+    id: parsed.id,
+    protocol: parsed.protocol,
+    upstreamOrigin: parsed.upstreamOrigin,
+    state: mergeState(parsed.state),
+    createdAt: parsed.createdAt ?? Date.now(),
+    lastSeen: Date.now(),
+    requests: parsed.requests ?? 0,
+    condensedToolResults: parsed.condensedToolResults ?? 0,
+    tokensSaved: parsed.tokensSaved ?? 0,
+    blockContents,
+    inFlight: 0,
+    persisted: true
+  };
+}
+function isValidRecord(parsed) {
+  if (!parsed || typeof parsed !== "object") return false;
+  const r = parsed;
+  return typeof r.id === "string" && typeof r.state === "object" && r.state !== null && Array.isArray(r.state.blocks);
+}
+function msg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function defaultDir() {
+  return sessionsDir();
+}
+function defaultDebounce() {
+  const env = process.env.BILI_PERSIST_DEBOUNCE_MS;
+  if (env) {
+    const n = Number.parseInt(env, 10);
+    if (Number.isFinite(n) && n >= 0) return n;
+  }
+  return 500;
+}
+function persistEnabled() {
+  const env = process.env.BILI_PERSIST;
+  if (env === "0" || env === "false") return false;
+  return true;
+}
+function defaultLogger(level, m) {
+  console.error(`[${level}] ${m}`);
+}
+var _store = null;
+function getStore() {
+  if (!_store) {
+    _store = new SessionStore({ enabled: persistEnabled() });
+  }
+  return _store;
+}
+
+// src/session.ts
 var sessions = /* @__PURE__ */ new Map();
-var MAX_SESSIONS = 256;
-function getSession(id) {
+var MAX_SESSIONS = Number.parseInt(process.env.BILI_MAX_SESSIONS ?? "256", 10) || 256;
+var initialized = false;
+async function initSessions() {
+  if (initialized) return;
+  initialized = true;
+  const store = getStore();
+  if (!store.enabled) return;
+  const loaded = await store.loadAll();
+  if (loaded.size > MAX_SESSIONS) {
+    const entries = [...loaded.entries()].sort((a, b) => (b[1].createdAt ?? 0) - (a[1].createdAt ?? 0));
+    for (const [id, s] of entries) {
+      if (sessions.size >= MAX_SESSIONS) break;
+      sessions.set(id, s);
+    }
+  } else {
+    for (const [id, s] of loaded) sessions.set(id, s);
+  }
+}
+function getSession(id, meta) {
   const existing = sessions.get(id);
   if (existing) {
     existing.lastSeen = Date.now();
+    if (meta?.protocol && !existing.protocol) existing.protocol = meta.protocol;
+    if (meta?.upstreamOrigin && !existing.upstreamOrigin) existing.upstreamOrigin = meta.upstreamOrigin;
     return existing;
   }
+  const store = getStore();
+  const reloaded = store.loadSync(id, meta);
+  if (reloaded) {
+    reloaded.lastSeen = Date.now();
+    reloaded.persisted = true;
+    sessions.set(id, reloaded);
+    return reloaded;
+  }
   if (sessions.size >= MAX_SESSIONS) evictOldest();
   const session = {
     id,
-    state: createInitialState(),
+    protocol: meta?.protocol,
+    upstreamOrigin: meta?.upstreamOrigin,
+    state: createInitialState2(),
     createdAt: Date.now(),
     lastSeen: Date.now(),
     requests: 0,
     condensedToolResults: 0,
-    tokensSaved: 0
+    tokensSaved: 0,
+    blockContents: /* @__PURE__ */ new Map(),
+    inFlight: 0,
+    persisted: false
   };
   sessions.set(id, session);
   return session;
 }
+function acquireInFlight(session) {
+  session.inFlight++;
+}
+function releaseInFlight(session) {
+  if (session.inFlight > 0) session.inFlight--;
+}
+async function withSessionLock(session, fn) {
+  const prev = session.lockChain ?? Promise.resolve();
+  let release;
+  const done = new Promise((resolve) => {
+    release = resolve;
+  });
+  session.lockChain = prev.then(() => done);
+  await prev;
+  try {
+    return await fn();
+  } finally {
+    release();
+  }
+}
 function listSessions() {
   return [...sessions.values()].sort((a, b) => b.lastSeen - a.lastSeen);
 }
+function markDirty(session) {
+  getStore().scheduleSave(session);
+}
+function cacheBlockContent(session, blockId, content) {
+  session.blockContents.set(blockId, content);
+}
 function evictOldest() {
   let oldestId;
   let oldestSeen = Infinity;
-  for (const [id, s] of sessions) {
-    if (s.lastSeen < oldestSeen) {
-      oldestSeen = s.lastSeen;
+  for (const [id, s2] of sessions) {
+    if (s2.inFlight > 0) continue;
+    if (s2.lastSeen < oldestSeen) {
+      oldestSeen = s2.lastSeen;
       oldestId = id;
     }
   }
-  if (oldestId) sessions.delete(oldestId);
+  if (!oldestId) return;
+  const s = sessions.get(oldestId);
+  const ok = getStore().flushSync(s);
+  if (!ok && !s.persisted) {
+    return;
+  }
+  sessions.delete(oldestId);
+}
+async function flushAllSessions() {
+  await getStore().flushAll(sessions.values());
 }
 
 // src/compress-tool.ts
 import { COMPRESS_PHILOSOPHY, HOW_TO_COMPRESS_RULES } from "acp-kernel";
 var COMPRESS_TOOL_NAME = "compress";
+var ACP_TEXT_OPEN = "<acp_compress>";
+var ACP_TEXT_CLOSE = "</acp_compress>";
 var COMPRESS_TOOL = {
   name: COMPRESS_TOOL_NAME,
   description: "Replace a contiguous range of older conversation with a detailed summary you write. Use when content is genuinely consumed. Batch form: content=[{startId,endId,summary,topic?}].",
@@ -378,12 +1116,18 @@ var COMPRESS_TOOL = {
   }
 };
 function parseCompressInput(input) {
-  if (!input || typeof input !== "object") return [];
+  if (!input || typeof input !== "object") {
+    console.error(`[acp-compress-input] rejected: not object (${typeof input})`);
+    return [];
+  }
   const obj = input;
   if (Array.isArray(obj.content)) {
-    return obj.content.map((r) => toRange(r)).filter((r) => r !== null);
+    const out = obj.content.map((r) => toRange(r)).filter((r) => r !== null);
+    if (out.length === 0) console.error(`[acp-compress-input] content array but 0 valid ranges. keys per item: ${obj.content.map((c) => Object.keys(c ?? {}).join(",")).join(" | ")}`);
+    return out;
   }
   const single = toRange(obj);
+  if (!single) console.error(`[acp-compress-input] no content array, single-parse failed. top keys: ${Object.keys(obj).join(",")}`);
   return single ? [single] : [];
 }
 function toRange(r) {
@@ -436,7 +1180,7 @@ ${HOW_TO_COMPRESS_RULES}
 
 ACP TAGS
 
-Each message in the conversation is annotated with a <acp tokens="2.1K" type="tool:bash">m00175</acp> tag showing its reference ID, approximate token size, and content type. Use these annotations to assess which messages are consuming the most context and prioritize compression accordingly. The token size is approximate \u2014 treat it as a relative guide, not an exact count.
+Each message in the conversation is annotated with a <acp tokens="2.1K" type="tool:bash">m00175</acp> tag showing its reference ID, approximate token size, and content type. These tags are system metadata injected by the proxy. NEVER echo, repeat, or reference these XML tags in your responses \u2014 the tags must not appear in your output. Use only the ref ID (e.g. m00005) inside compress calls, never the XML wrapper. The token size is approximate \u2014 treat it as a relative guide, not an exact count.
 
 TOOLS
 
@@ -506,6 +1250,36 @@ var ACP_TOOLS_OPENAI = [
   SEARCH_CONTEXT_TOOL_OPENAI,
   ACP_STATUS_TOOL_OPENAI
 ];
+var COMPRESS_TOOL_RESPONSES = {
+  type: "function",
+  name: COMPRESS_TOOL_NAME,
+  description: COMPRESS_TOOL.description,
+  parameters: COMPRESS_TOOL_OPENAI.function.parameters
+};
+var DECOMPRESS_TOOL_RESPONSES = {
+  type: "function",
+  name: DECOMPRESS_TOOL_OPENAI.function.name,
+  description: DECOMPRESS_TOOL_OPENAI.function.description,
+  parameters: DECOMPRESS_TOOL_OPENAI.function.parameters
+};
+var SEARCH_CONTEXT_TOOL_RESPONSES = {
+  type: "function",
+  name: SEARCH_CONTEXT_TOOL_OPENAI.function.name,
+  description: SEARCH_CONTEXT_TOOL_OPENAI.function.description,
+  parameters: SEARCH_CONTEXT_TOOL_OPENAI.function.parameters
+};
+var ACP_STATUS_TOOL_RESPONSES = {
+  type: "function",
+  name: ACP_STATUS_TOOL_OPENAI.function.name,
+  description: ACP_STATUS_TOOL_OPENAI.function.description,
+  parameters: ACP_STATUS_TOOL_OPENAI.function.parameters
+};
+var ACP_TOOLS_RESPONSES = [
+  COMPRESS_TOOL_RESPONSES,
+  DECOMPRESS_TOOL_RESPONSES,
+  SEARCH_CONTEXT_TOOL_RESPONSES,
+  ACP_STATUS_TOOL_RESPONSES
+];
 var PROXY_TOOL_NAMES = /* @__PURE__ */ new Set([
   COMPRESS_TOOL_NAME,
   DECOMPRESS_TOOL_NAME,
@@ -513,6 +1287,15 @@ var PROXY_TOOL_NAMES = /* @__PURE__ */ new Set([
   ACP_STATUS_TOOL_NAME
 ]);
 
+// src/stream.ts
+import { collectBlockContent } from "acp-kernel";
+
+// src/sse-util.ts
+function normalizeSseLineEndings(buf) {
+  if (buf.indexOf("\r") === -1) return buf;
+  return buf.replace(/\r\n|\r/g, "\n");
+}
+
 // src/stream.ts
 var NOOP = /* @__PURE__ */ Symbol("noop");
 async function* rewriteSseStream(upstream, ctx) {
@@ -533,6 +1316,7 @@ async function* rewriteSseStream(upstream, ctx) {
       const { done, value } = await reader.read();
       if (done) break;
       buf += decoder.decode(value, { stream: true });
+      buf = normalizeSseLineEndings(buf);
       let idx;
       while ((idx = buf.indexOf("\n\n")) !== -1) {
         const rawEvent = buf.slice(0, idx);
@@ -581,6 +1365,10 @@ function routeEvent(ev, blocks, ctx, markConverted, markRealToolUse, getConverte
       if (typeof partial === "string") st.json += partial;
       return NOOP;
     }
+    const dt = d.delta;
+    if (dt?.text && (dt.text.includes("<acp ") || dt.text.includes("</acp"))) {
+      ctx.log(`[warn: tag echo] model emitted <acp tag in text delta: ${dt.text.slice(0, 120).replace(/\n/g, " ")}`);
+    }
     return emitEvent(ev);
   }
   if (t === "content_block_stop") {
@@ -638,7 +1426,19 @@ function applyRanges(ranges, ctx) {
       state: ctx.session.state,
       config: ctx.config
     });
+    const beforeIds = new Set(ctx.session.state.blocks.map((b) => b.blockId));
     ctx.session.state = res.state;
+    for (const b of res.state.blocks) {
+      if (beforeIds.has(b.blockId)) continue;
+      const full = collectBlockContent(res.state, b, ctx.messages, { full: true });
+      const one = collectBlockContent(res.state, b, ctx.messages, { full: false });
+      if (full.count > 0 || one.count > 0) {
+        cacheBlockContent(ctx.session, b.blockId, {
+          one: { text: one.text, count: one.count },
+          full: { text: full.text, count: full.count }
+        });
+      }
+    }
     const r = res.result;
     const detail = ranges.map((rg) => `${rg.startRef}\u2013${rg.endRef}`).join(", ");
     if (r.blocksCreated === 0) {
@@ -647,9 +1447,9 @@ function applyRanges(ranges, ctx) {
       return `[Compression FAILED: ${errs} Do not retry the same range.]`;
     }
     const warn = r.warnings.length > 0 ? ` ${r.warnings.join("; ")}` : "";
-    const msg = `[Compressed ${detail} \u2192 ${r.blocksCreated} block(s), ~${r.tokensCompressed} tokens saved.${warn}]`;
-    ctx.log(`[acp-proxy: ${msg}]`);
-    return msg;
+    const msg2 = `[Compressed ${detail} \u2192 ${r.blocksCreated} block(s), ~${r.tokensCompressed} tokens saved.${warn}]`;
+    ctx.log(`[acp-proxy: ${msg2}]`);
+    return msg2;
   } catch (err) {
     ctx.log(`[acp-proxy: compress failed: ${String(err)}]`);
     return `[Compression FAILED: ${String(err)} Do not retry the same range.]`;
@@ -703,55 +1503,109 @@ function rewriteJsonResponse(body, ctx) {
   }
   b.content = newContent;
   if (converted && !sawRealToolUse) b.stop_reason = "end_turn";
+  for (const blk of newContent) {
+    const t = blk.text;
+    if (typeof t === "string" && (t.includes("<acp ") || t.includes("</acp"))) {
+      ctx.log(`[warn: tag echo] non-stream model output contains <acp tag: ${t.slice(0, 120).replace(/\n/g, " ")}`);
+    }
+  }
   return body;
 }
 
+// src/orphan-gc.ts
+var ORPHAN_THRESHOLD = 3;
+var orphanStreaks = /* @__PURE__ */ new WeakMap();
+function reapOrphanBlocks(session, visible, deactivate) {
+  if (session.state.blocks.length === 0) return { reaped: [] };
+  const presentIds = new Set(visible.map((m) => m.id));
+  const reaped = [];
+  for (const block of session.state.blocks) {
+    if (!block.active) continue;
+    const hasHit = block.effectiveMessageIds.some((id) => presentIds.has(id));
+    if (hasHit) {
+      orphanStreaks.delete(block);
+      continue;
+    }
+    const streak = (orphanStreaks.get(block) ?? 0) + 1;
+    orphanStreaks.set(block, streak);
+    if (streak >= ORPHAN_THRESHOLD) {
+      reaped.push(block.blockId);
+    }
+  }
+  if (reaped.length === 0) return { reaped: [] };
+  session.state = deactivate(session.state, reaped);
+  for (const id of reaped) session.blockContents.delete(id);
+  return { reaped };
+}
+
 // src/compress-loop.ts
 import {
   buildStatusReport,
-  collectBlockContent,
-  deactivateBlock,
   estimateTokensFast
 } from "acp-kernel";
-import { writeFileSync, mkdirSync } from "fs";
-import { dirname, join } from "path";
+
+// src/decompress-shared.ts
+import {
+  collectBlockContent as collectBlockContent2,
+  deactivateBlock
+} from "acp-kernel";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
 import { tmpdir } from "os";
-function executeProxyTool(toolName, args, ctx) {
-  if (toolName === "compress") {
-    return applyRanges(parseCompressInput(args), ctx);
+function resolveDecompress(args, ctx) {
+  const rawBlockId = args.blockId;
+  if (typeof rawBlockId !== "string" || rawBlockId.length === 0) {
+    return "[decompress FAILED: blockId is required]";
+  }
+  const blockId = rawBlockId.trim();
+  const block = ctx.core.decompress(blockId, ctx.session.state);
+  if (!block) return `[Block ${blockId} not found]`;
+  const full = args.full === true;
+  const cached = ctx.session.blockContents.get(blockId);
+  let body;
+  let count;
+  if (cached) {
+    const view = full ? cached.full : cached.one;
+    body = view.text;
+    count = view.count;
+  } else {
+    const collected = collectBlockContent2(ctx.session.state, block, ctx.messages, { full });
+    body = collected.text || block.summary;
+    count = collected.count;
   }
-  if (toolName === "decompress") {
-    const rawBlockId = args.blockId;
-    if (typeof rawBlockId !== "string" || rawBlockId.length === 0) {
-      return "[decompress FAILED: blockId is required]";
-    }
-    const blockId = rawBlockId.trim();
-    const block = ctx.core.decompress(blockId, ctx.session.state);
-    if (!block) return `[Block ${blockId} not found]`;
-    const full = args.full === true;
-    const collected = collectBlockContent(ctx.session.state, block, ctx.messages, { full });
+  if (count > 0 || cached) {
     ctx.session.state = deactivateBlock(ctx.session.state, [blockId]);
-    const header = `[Restored block ${blockId} \u2014 ${collected.count} item(s)${full ? ", full" : ""}]`;
-    const body = collected.text || block.summary;
-    const safeBlockId = blockId.replace(/[^a-zA-Z0-9_-]/g, "-");
-    const outPath = body.length > 1e4 ? join(tmpdir(), `acp-decompress-${safeBlockId}-${Date.now()}.txt`) : null;
-    if (outPath) {
-      try {
-        mkdirSync(dirname(outPath), { recursive: true });
-        writeFileSync(outPath, body, "utf8");
-        return `${header}
+    ctx.session.blockContents.delete(blockId);
+  }
+  const header = `[Restored block ${blockId} \u2014 ${count} item(s)${full ? ", full" : ""}]`;
+  const safeBlockId = blockId.replace(/[^a-zA-Z0-9_-]/g, "-");
+  const outPath = body.length > 1e4 ? join2(tmpdir(), `acp-decompress-${safeBlockId}-${Date.now()}.txt`) : null;
+  if (outPath) {
+    try {
+      mkdirSync2(dirname2(outPath), { recursive: true });
+      writeFileSync2(outPath, body, "utf8");
+      return `${header}
 Content (${body.length} chars) written to: ${outPath}
 Use the read tool to access it.`;
-      } catch (e) {
-        return `${header}
+    } catch (e) {
+      return `${header}
 [Failed to write to ${outPath}: ${String(e)}]
 ${body.slice(0, 4e3)}...`;
-      }
     }
-    return `${header}
-${body}`;
   }
-  if (toolName === "search_context") {
+  return `${header}
+${body}`;
+}
+
+// src/compress-loop.ts
+function executeProxyTool(toolName, args, ctx) {
+  if (toolName === "compress") {
+    return applyRanges(parseCompressInput(args), ctx);
+  }
+  if (toolName === "decompress") {
+    return resolveDecompress(args, ctx);
+  }
+  if (toolName === "search_context") {
     const query = typeof args.query === "string" ? args.query : "";
     if (query.length === 0) return "[search_context FAILED: query is required]";
     const limit = typeof args.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : 5;
@@ -885,27 +1739,469 @@ ${icon} [ACP] ${inner}
 }
 async function* compressLoopStream(initialUpstream, ctx, requestBody, requestOptions) {
   let upstream = initialUpstream;
-  const model = requestBody.model ?? "unknown";
-  let responseId = `chatcmpl-proxy-${Date.now()}`;
-  const makeBase = () => ({
-    id: responseId,
-    object: "chat.completion.chunk",
-    created: Date.now(),
-    model
-  });
+  let activeClearTimer = null;
+  try {
+    const model = requestBody.model ?? "unknown";
+    let responseId = `chatcmpl-proxy-${Date.now()}`;
+    const makeBase = () => ({
+      id: responseId,
+      object: "chat.completion.chunk",
+      created: Date.now(),
+      model
+    });
+    let loopCount = 0;
+    for (; ; ) {
+      loopCount++;
+      if (loopCount > 10) {
+        ctx.log("[acp-proxy: compress loop limit (10) reached, forwarding as-is]");
+        yield Buffer.from(buildFinishSse(makeBase(), "stop", null), "utf8");
+        yield Buffer.from("data: [DONE]\n\n", "utf8");
+        return;
+      }
+      const toolCallByIndex = /* @__PURE__ */ new Map();
+      let contentText = "";
+      let finishReason = null;
+      let usage = null;
+      const isFirstRound = loopCount === 1;
+      const reader = upstream.getReader();
+      const decoder = new TextDecoder("utf-8");
+      let sseBuffer = "";
+      try {
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          sseBuffer += decoder.decode(value, { stream: true });
+          sseBuffer = normalizeSseLineEndings(sseBuffer);
+          let sep;
+          while ((sep = sseBuffer.indexOf("\n\n")) >= 0) {
+            const eventStr = sseBuffer.slice(0, sep);
+            sseBuffer = sseBuffer.slice(sep + 2);
+            if (!eventStr.trim()) continue;
+            const d = classifySseEvent(eventStr);
+            if (d.done) {
+              continue;
+            }
+            if (isFirstRound) {
+              if (d.yieldChunk) {
+                if (!responseId) {
+                  const dataLine = eventStr.split("\n").find((l) => l.startsWith("data:"));
+                  if (dataLine) {
+                    try {
+                      const p = JSON.parse(dataLine.slice(5).trim());
+                      if (typeof p.id === "string") responseId = p.id;
+                    } catch {
+                    }
+                  }
+                }
+                yield d.yieldChunk;
+              }
+            } else {
+              if (d.contentDelta) {
+                yield Buffer.from(buildContentSse(responseId, model, d.contentDelta), "utf8");
+              }
+            }
+            if (d.contentDelta) contentText += d.contentDelta;
+            if (d.finishReason) finishReason = d.finishReason;
+            if (d.usage !== void 0) usage = d.usage;
+            if (d.toolCalls) {
+              for (const tc of d.toolCalls) {
+                const existing = toolCallByIndex.get(tc.index);
+                if (existing) {
+                  if (tc.name) existing.name = tc.name;
+                  if (tc.id) existing.id = tc.id;
+                  existing.arguments += tc.arguments;
+                } else {
+                  toolCallByIndex.set(tc.index, tc);
+                }
+              }
+            }
+          }
+        }
+        sseBuffer += decoder.decode();
+        sseBuffer = normalizeSseLineEndings(sseBuffer);
+        let resSep;
+        while ((resSep = sseBuffer.indexOf("\n\n")) >= 0) {
+          const eventStr = sseBuffer.slice(0, resSep);
+          sseBuffer = sseBuffer.slice(resSep + 2);
+          if (!eventStr.trim()) continue;
+          const d = classifySseEvent(eventStr);
+          if (d.done) continue;
+          if (isFirstRound) {
+            if (d.yieldChunk) yield d.yieldChunk;
+          } else {
+            if (d.contentDelta) yield Buffer.from(buildContentSse(responseId, model, d.contentDelta), "utf8");
+          }
+          if (d.contentDelta) contentText += d.contentDelta;
+          if (d.finishReason) finishReason = d.finishReason;
+          if (d.usage !== void 0) usage = d.usage;
+          if (d.toolCalls) {
+            for (const tc of d.toolCalls) {
+              const existing = toolCallByIndex.get(tc.index);
+              if (existing) {
+                if (tc.name) existing.name = tc.name;
+                if (tc.id) existing.id = tc.id;
+                existing.arguments += tc.arguments;
+              } else {
+                toolCallByIndex.set(tc.index, tc);
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      const sortedIndices = [...toolCallByIndex.keys()].sort((a, b) => a - b);
+      const toolCalls = sortedIndices.map((i) => {
+        const tc = toolCallByIndex.get(i);
+        return { ...tc, id: tc.id || `call_${tc.index}` };
+      }).filter((tc) => tc.name.length > 0);
+      const proxyCalls = toolCalls.filter((tc) => PROXY_TOOL_NAMES.has(tc.name));
+      const realCalls = toolCalls.filter((tc) => !PROXY_TOOL_NAMES.has(tc.name));
+      const hasOnlyProxy = proxyCalls.length > 0 && realCalls.length === 0;
+      if (!hasOnlyProxy) {
+        for (const tc of realCalls) {
+          yield Buffer.from(buildToolCallSse(makeBase(), tc), "utf8");
+        }
+        const fr = realCalls.length > 0 ? "tool_calls" : finishReason ?? "stop";
+        yield Buffer.from(buildFinishSse(makeBase(), fr, usage), "utf8");
+        yield Buffer.from("data: [DONE]\n\n", "utf8");
+        return;
+      }
+      const names = proxyCalls.map((c) => c.name).join(", ");
+      ctx.log(`[acp-proxy: round ${loopCount} \u2014 ${proxyCalls.length} proxy call(s): ${names}]`);
+      const messages = requestBody.messages ?? [];
+      messages.push({
+        role: "assistant",
+        content: contentText || null,
+        tool_calls: proxyCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: tc.arguments }
+        }))
+      });
+      for (const tc of proxyCalls) {
+        let args = {};
+        try {
+          args = JSON.parse(tc.arguments);
+        } catch {
+          args = {};
+        }
+        const result = executeProxyTool(tc.name, args, ctx);
+        const preview = result.length > 120 ? result.slice(0, 120) + "..." : result;
+        ctx.log(`[acp-proxy: ${tc.name} (${tc.id}) \u2192 ${preview.replace(/\n/g, " ")}]`);
+        yield Buffer.from(
+          buildContentSse(responseId, model, buildVisibilityMarker(tc.name, result)),
+          "utf8"
+        );
+        messages.push({
+          role: "tool",
+          tool_call_id: tc.id,
+          content: result
+        });
+      }
+      requestBody.messages = messages;
+      const { response: resp, clearTimer } = await fetchWithTimeout(requestOptions.url, {
+        method: "POST",
+        headers: requestOptions.headers,
+        body: JSON.stringify(requestBody)
+      });
+      if (!resp.ok || !resp.body) {
+        const errText = await resp.text().catch(() => "upstream error");
+        ctx.log(`[acp-proxy: compress loop upstream error ${resp.status}: ${errText.slice(0, 200)}]`);
+        yield Buffer.from(
+          `data: ${JSON.stringify({
+            ...makeBase(),
+            choices: [{
+              index: 0,
+              delta: { content: `
+[acp-proxy: upstream error ${resp.status}: ${errText.slice(0, 200)}]
+` },
+              finish_reason: null
+            }]
+          })}
+
+`,
+          "utf8"
+        );
+        yield Buffer.from(buildFinishSse(makeBase(), "stop", null), "utf8");
+        yield Buffer.from("data: [DONE]\n\n", "utf8");
+        return;
+      }
+      upstream = resp.body;
+      if (activeClearTimer) activeClearTimer();
+      activeClearTimer = clearTimer;
+    }
+  } finally {
+    if (activeClearTimer) {
+      activeClearTimer();
+      activeClearTimer = null;
+    }
+  }
+}
+
+// src/compress-loop-responses.ts
+import {
+  buildStatusReport as buildStatusReport2,
+  estimateTokensFast as estimateTokensFast2
+} from "acp-kernel";
+var TEXT_PROTOCOL = process.env.ACP_COMPRESS_PROTOCOL === "text";
+function extractTextTriggers(text) {
+  const calls = [];
+  let clean = "";
+  let i = 0;
+  let n = 0;
+  while (i < text.length) {
+    const open = text.indexOf(ACP_TEXT_OPEN, i);
+    if (open === -1) {
+      clean += text.slice(i);
+      break;
+    }
+    clean += text.slice(i, open);
+    const after = open + ACP_TEXT_OPEN.length;
+    const close = text.indexOf(ACP_TEXT_CLOSE, after);
+    if (close === -1) {
+      clean += text.slice(open);
+      break;
+    }
+    const payload = text.slice(after, close).trim();
+    if (payload) {
+      const stamp = `${Date.now()}_${n++}`;
+      calls.push({
+        itemId: `fc_text_${stamp}`,
+        callId: `call_text_${stamp}`,
+        name: COMPRESS_TOOL_NAME,
+        arguments: payload
+      });
+    }
+    i = close + ACP_TEXT_CLOSE.length;
+  }
+  return { clean, calls };
+}
+function executeProxyTool2(toolName, args, ctx) {
+  if (toolName === "compress") {
+    return applyRanges(parseCompressInput(args), ctx);
+  }
+  if (toolName === "decompress") {
+    return resolveDecompress(args, ctx);
+  }
+  if (toolName === "search_context") {
+    const query = typeof args.query === "string" ? args.query : "";
+    if (query.length === 0) return "[search_context FAILED: query is required]";
+    const limit = typeof args.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : 5;
+    const blocks = ctx.core.search(query, ctx.session.state).slice(0, limit);
+    if (blocks.length === 0) return `[No blocks matched "${query}"]`;
+    const lines = blocks.map((b) => {
+      const topic = b.topic ?? "(no topic)";
+      const preview = b.summary.length > 200 ? b.summary.slice(0, 200) + "..." : b.summary;
+      return `${b.blockId} (T${b.tier}) "${topic}"
+  ${preview}`;
+    });
+    return `Found ${blocks.length} block(s) for "${query}":
+
+${lines.join("\n\n")}`;
+  }
+  if (toolName === "acp_status") {
+    return buildStatusReport2(ctx.session.state, ctx.messages, estimateTokensFast2);
+  }
+  return `[Unknown proxy tool: ${toolName}]`;
+}
+function extractEventType(rawEvent) {
+  for (const l of rawEvent.split("\n")) {
+    if (l.startsWith("event:")) return l.slice(6).trim();
+  }
+  return null;
+}
+function extractDataLine(rawEvent) {
+  const parts = [];
+  for (const l of rawEvent.split("\n")) {
+    if (l.startsWith("data:")) {
+      let v = l.slice(5);
+      if (v.startsWith(" ")) v = v.slice(1);
+      parts.push(v);
+    }
+  }
+  return parts.length ? parts.join("\n") : null;
+}
+function classifyResponsesSseEvent(eventStr) {
+  const type = extractEventType(eventStr);
+  const dataLine = extractDataLine(eventStr);
+  if (!type || !dataLine) return {};
+  let obj;
+  try {
+    obj = JSON.parse(dataLine);
+  } catch {
+    return {};
+  }
+  const out = {};
+  switch (type) {
+    case "response.created":
+    case "response.in_progress":
+      out.isMeta = true;
+      out.yieldChunk = Buffer.from(eventStr + "\n\n", "utf8");
+      return out;
+    case "response.output_item.added": {
+      const item = obj.item;
+      if (item?.type === "function_call") {
+        const name = typeof item.name === "string" ? item.name : "";
+        out.fcStart = {
+          itemId: typeof item.id === "string" ? item.id : "",
+          callId: typeof item.call_id === "string" ? item.call_id : "",
+          name
+        };
+        return out;
+      }
+      out.yieldChunk = Buffer.from(eventStr + "\n\n", "utf8");
+      return out;
+    }
+    case "response.content_part.added":
+    case "response.content_part.done":
+    case "response.output_text.done":
+      out.yieldChunk = Buffer.from(eventStr + "\n\n", "utf8");
+      return out;
+    case "response.output_text.delta": {
+      const delta = typeof obj.delta === "string" ? obj.delta : "";
+      if (delta) {
+        out.contentDelta = delta;
+        out.yieldChunk = Buffer.from(eventStr + "\n\n", "utf8");
+      }
+      return out;
+    }
+    case "response.function_call_arguments.delta": {
+      const itemId = typeof obj.item_id === "string" ? obj.item_id : "";
+      const delta = typeof obj.delta === "string" ? obj.delta : "";
+      out.fcArgs = { itemId, delta };
+      return out;
+    }
+    case "response.output_item.done": {
+      const item = obj.item;
+      if (item?.type === "function_call") {
+        out.fcDone = { itemId: typeof item.id === "string" ? item.id : "" };
+        return out;
+      }
+      out.yieldChunk = Buffer.from(eventStr + "\n\n", "utf8");
+      return out;
+    }
+    case "response.completed":
+      out.isMeta = true;
+      out.terminal = true;
+      out.terminalKind = "completed";
+      out.responseObj = obj.response ?? null;
+      return out;
+    case "response.incomplete":
+      out.isMeta = true;
+      out.terminal = true;
+      out.terminalKind = "incomplete";
+      out.terminalRaw = eventStr;
+      return out;
+    case "response.failed":
+    case "response.error":
+      out.isMeta = true;
+      out.terminal = true;
+      out.terminalKind = "failed";
+      out.terminalRaw = eventStr;
+      return out;
+    default:
+      out.yieldChunk = Buffer.from(eventStr + "\n\n", "utf8");
+      return out;
+  }
+}
+function buildMessageItemSequence(itemId, outputIndex, text) {
+  const item = { type: "message", id: itemId, role: "assistant", content: [] };
+  const part = { type: "output_text", text: "" };
+  const doneItem = { type: "message", id: itemId, role: "assistant", content: [{ type: "output_text", text }] };
+  return [
+    `event: response.output_item.added
+data: ${JSON.stringify({ type: "response.output_item.added", output_index: outputIndex, item })}
+
+`,
+    `event: response.content_part.added
+data: ${JSON.stringify({ type: "response.content_part.added", item_id: itemId, output_index: outputIndex, part })}
+
+`,
+    `event: response.output_text.delta
+data: ${JSON.stringify({ type: "response.output_text.delta", item_id: itemId, output_index: outputIndex, delta: text })}
+
+`,
+    `event: response.output_text.done
+data: ${JSON.stringify({ type: "response.output_text.done", item_id: itemId, output_index: outputIndex, text })}
+
+`,
+    `event: response.content_part.done
+data: ${JSON.stringify({ type: "response.content_part.done", item_id: itemId, output_index: outputIndex, part: { type: "output_text", text } })}
+
+`,
+    `event: response.output_item.done
+data: ${JSON.stringify({ type: "response.output_item.done", output_index: outputIndex, item: doneItem })}
+
+`
+  ].join("");
+}
+function buildFunctionCallEvents(fc, outputIndex) {
+  return [
+    `event: response.output_item.added
+data: ${JSON.stringify({
+      type: "response.output_item.added",
+      output_index: outputIndex,
+      item: { type: "function_call", id: fc.itemId, call_id: fc.callId, name: fc.name, arguments: "" }
+    })}
+
+`,
+    `event: response.function_call_arguments.delta
+data: ${JSON.stringify({
+      type: "response.function_call_arguments.delta",
+      item_id: fc.itemId,
+      delta: fc.arguments
+    })}
+
+`,
+    `event: response.function_call_arguments.done
+data: ${JSON.stringify({
+      type: "response.function_call_arguments.done",
+      item_id: fc.itemId,
+      arguments: fc.arguments
+    })}
+
+`,
+    `event: response.output_item.done
+data: ${JSON.stringify({
+      type: "response.output_item.done",
+      output_index: outputIndex,
+      item: { type: "function_call", id: fc.itemId, call_id: fc.callId, name: fc.name, arguments: fc.arguments }
+    })}
+
+`
+  ].join("");
+}
+function buildCompleted(responseObj) {
+  const resp = responseObj ?? { id: `resp-proxy-${Date.now()}`, status: "completed", output: [] };
+  return `event: response.completed
+data: ${JSON.stringify({
+    type: "response.completed",
+    response: resp
+  })}
+
+`;
+}
+async function* compressLoopResponsesStream(initialUpstream, ctx, requestBody, requestOptions) {
+  let upstream = initialUpstream;
   let loopCount = 0;
+  let responseObj = null;
+  let activeClearTimer = null;
+  let nextOutputIndex = 0;
   for (; ; ) {
     loopCount++;
-    if (loopCount > 10) {
-      ctx.log("[acp-proxy: compress loop limit (10) reached, forwarding as-is]");
-      yield Buffer.from(buildFinishSse(makeBase(), "stop", null), "utf8");
-      yield Buffer.from("data: [DONE]\n\n", "utf8");
+    if (loopCount > 5) {
+      ctx.log("[acp-proxy: responses compress loop limit (5) reached, forwarding completion as-is]");
+      const limItemId = `msg_acp_limit_${Date.now()}`;
+      yield Buffer.from(buildMessageItemSequence(limItemId, nextOutputIndex++, "\n[acp-proxy: compress loop limit reached]\n"), "utf8");
+      yield Buffer.from(buildCompleted(responseObj), "utf8");
       return;
     }
-    const toolCallByIndex = /* @__PURE__ */ new Map();
+    const fcByItemId = /* @__PURE__ */ new Map();
     let contentText = "";
-    let finishReason = null;
-    let usage = null;
+    let completed = false;
+    let terminalKind = null;
+    let terminalRaw = null;
     const isFirstRound = loopCount === 1;
     const reader = upstream.getReader();
     const decoder = new TextDecoder("utf-8");
@@ -915,156 +2211,179 @@ async function* compressLoopStream(initialUpstream, ctx, requestBody, requestOpt
         const { done, value } = await reader.read();
         if (done) break;
         sseBuffer += decoder.decode(value, { stream: true });
+        if (sseBuffer.indexOf("\r") !== -1) sseBuffer = sseBuffer.replace(/\r\n|\r/g, "\n");
         let sep;
         while ((sep = sseBuffer.indexOf("\n\n")) >= 0) {
           const eventStr = sseBuffer.slice(0, sep);
           sseBuffer = sseBuffer.slice(sep + 2);
           if (!eventStr.trim()) continue;
-          const d = classifySseEvent(eventStr);
-          if (d.done) {
-            continue;
+          const d = classifyResponsesSseEvent(eventStr);
+          if (d.yieldChunk && (isFirstRound || !d.isMeta) && !(TEXT_PROTOCOL && !d.isMeta)) {
+            yield d.yieldChunk;
           }
-          if (isFirstRound) {
-            if (d.yieldChunk) {
-              if (!responseId) {
-                const dataLine = eventStr.split("\n").find((l) => l.startsWith("data:"));
-                if (dataLine) {
-                  try {
-                    const p = JSON.parse(dataLine.slice(5).trim());
-                    if (typeof p.id === "string") responseId = p.id;
-                  } catch {
-                  }
-                }
-              }
-              yield d.yieldChunk;
-            }
-          } else {
-            if (d.contentDelta) {
-              yield Buffer.from(buildContentSse(responseId, model, d.contentDelta), "utf8");
+          if (d.contentDelta) contentText += d.contentDelta;
+          if (d.fcStart) {
+            fcByItemId.set(d.fcStart.itemId, {
+              itemId: d.fcStart.itemId,
+              callId: d.fcStart.callId,
+              name: d.fcStart.name,
+              arguments: ""
+            });
+          }
+          if (d.fcArgs) {
+            const existing = fcByItemId.get(d.fcArgs.itemId);
+            if (existing) existing.arguments += d.fcArgs.delta;
+          }
+          if (d.fcDone) {
+            const existing = fcByItemId.get(d.fcDone.itemId);
+            if (existing && !existing.arguments) {
+              const item = JSON.parse(extractDataLine(eventStr) ?? "{}").item;
+              const args = typeof item?.arguments === "string" ? item.arguments : "";
+              existing.arguments = args;
             }
           }
-          if (d.contentDelta) contentText += d.contentDelta;
-          if (d.finishReason) finishReason = d.finishReason;
-          if (d.usage !== void 0) usage = d.usage;
-          if (d.toolCalls) {
-            for (const tc of d.toolCalls) {
-              const existing = toolCallByIndex.get(tc.index);
-              if (existing) {
-                if (tc.name) existing.name = tc.name;
-                if (tc.id) existing.id = tc.id;
-                existing.arguments += tc.arguments;
-              } else {
-                toolCallByIndex.set(tc.index, tc);
-              }
+          if (d.terminal) {
+            completed = true;
+            terminalKind = d.terminalKind ?? null;
+            terminalRaw = d.terminalRaw ?? null;
+            responseObj = d.responseObj ?? responseObj;
+            const resp2 = d.responseObj ?? {};
+            const usage = resp2.usage;
+            if (usage && d.terminalKind === "completed") {
+              const prompt = usage.input_tokens ?? usage.prompt_tokens ?? "?";
+              const inDet = usage.input_tokens_details;
+              const prDet = usage.prompt_tokens_details;
+              const cached = inDet?.cached_tokens ?? prDet?.cached_tokens ?? "?";
+              const out = usage.output_tokens ?? "?";
+              console.error(`[acp-usage] round ${loopCount} input=${prompt} cached=${cached} output=${out}${cached !== "?" && cached !== 0 && prompt !== "?" ? ` (cache hit ${Math.round(Number(cached) / Number(prompt) * 100)}%)` : ""}`);
             }
           }
         }
       }
-      sseBuffer += decoder.decode();
     } finally {
       reader.releaseLock();
+      if (activeClearTimer) {
+        activeClearTimer();
+        activeClearTimer = null;
+      }
+    }
+    if (TEXT_PROTOCOL) {
+      const extracted = extractTextTriggers(contentText);
+      contentText = extracted.clean;
+      for (const c of extracted.calls) {
+        fcByItemId.set(c.itemId, c);
+      }
+      if (contentText.trim()) {
+        const textItemId = `msg_acp_text_r${loopCount}_${Date.now()}`;
+        yield Buffer.from(buildMessageItemSequence(textItemId, nextOutputIndex++, contentText), "utf8");
+      }
     }
-    const sortedIndices = [...toolCallByIndex.keys()].sort((a, b) => a - b);
-    const toolCalls = sortedIndices.map((i) => {
-      const tc = toolCallByIndex.get(i);
-      return { ...tc, id: tc.id || `call_${tc.index}` };
-    }).filter((tc) => tc.name.length > 0);
-    const proxyCalls = toolCalls.filter((tc) => PROXY_TOOL_NAMES.has(tc.name));
-    const realCalls = toolCalls.filter((tc) => !PROXY_TOOL_NAMES.has(tc.name));
+    const allCalls = [...fcByItemId.values()].filter((c) => c.name.length > 0);
+    const proxyCalls = allCalls.filter((c) => PROXY_TOOL_NAMES.has(c.name));
+    const realCalls = allCalls.filter((c) => !PROXY_TOOL_NAMES.has(c.name));
+    console.error(`[acp-diag] round ${loopCount} allCalls=[${allCalls.map((c) => c.name).join(",")}] realCalls=[${realCalls.map((c) => c.name).join(",")}] text=${JSON.stringify(contentText.slice(0, 120))}`);
     const hasOnlyProxy = proxyCalls.length > 0 && realCalls.length === 0;
     if (!hasOnlyProxy) {
-      for (const tc of realCalls) {
-        yield Buffer.from(buildToolCallSse(makeBase(), tc), "utf8");
+      let oi = nextOutputIndex;
+      for (const fc of realCalls) {
+        yield Buffer.from(buildFunctionCallEvents(fc, oi), "utf8");
+        oi++;
       }
-      const fr = realCalls.length > 0 ? "tool_calls" : finishReason ?? "stop";
-      yield Buffer.from(buildFinishSse(makeBase(), fr, usage), "utf8");
-      yield Buffer.from("data: [DONE]\n\n", "utf8");
+      nextOutputIndex = oi;
+      if (terminalKind && terminalKind !== "completed" && terminalRaw) {
+        yield Buffer.from(terminalRaw + "\n\n", "utf8");
+        return;
+      }
+      if (!completed && contentText.length === 0 && realCalls.length === 0) {
+        ctx.log("[acp-proxy: responses stream ended without completion]");
+      }
+      yield Buffer.from(buildCompleted(responseObj), "utf8");
       return;
     }
     const names = proxyCalls.map((c) => c.name).join(", ");
-    ctx.log(`[acp-proxy: round ${loopCount} \u2014 ${proxyCalls.length} proxy call(s): ${names}]`);
-    const messages = requestBody.messages ?? [];
-    messages.push({
-      role: "assistant",
-      content: contentText || null,
-      tool_calls: proxyCalls.map((tc) => ({
-        id: tc.id,
-        type: "function",
-        function: { name: tc.name, arguments: tc.arguments }
-      }))
-    });
-    for (const tc of proxyCalls) {
+    ctx.log(`[acp-proxy: responses round ${loopCount} \u2014 ${proxyCalls.length} proxy call(s): ${names}]`);
+    const inputItems = Array.isArray(requestBody.input) ? [...requestBody.input] : [];
+    if (contentText) {
+      inputItems.push({
+        type: "message",
+        role: "assistant",
+        content: [{ type: "output_text", text: contentText }]
+      });
+    }
+    for (const fc of proxyCalls) {
+      inputItems.push({
+        type: "function_call",
+        id: fc.itemId || `fc_${Date.now()}`,
+        call_id: fc.callId || `call_${Date.now()}`,
+        name: fc.name,
+        arguments: fc.arguments
+      });
+    }
+    for (const fc of proxyCalls) {
       let args = {};
       try {
-        args = JSON.parse(tc.arguments);
-      } catch {
+        args = JSON.parse(fc.arguments);
+      } catch (e) {
+        console.error(`[acp-compress-args] ${fc.name} JSON.parse failed: ${String(e)}. raw arguments (len=${fc.arguments.length}): ${fc.arguments.slice(0, 300)}`);
         args = {};
       }
-      const result = executeProxyTool(tc.name, args, ctx);
+      if (fc.name === "compress") {
+        console.error(`[acp-compress-args] compress args parsed: ${JSON.stringify(args).slice(0, 400)}`);
+      }
+      const result = executeProxyTool2(fc.name, args, ctx);
       const preview = result.length > 120 ? result.slice(0, 120) + "..." : result;
-      ctx.log(`[acp-proxy: ${tc.name} (${tc.id}) \u2192 ${preview.replace(/\n/g, " ")}]`);
+      ctx.log(`[acp-proxy: responses ${fc.name} (${fc.callId}) \u2192 ${preview.replace(/\n/g, " ")}]`);
+      const markerItemId = `msg_acp_${Date.now()}_${nextOutputIndex}`;
       yield Buffer.from(
-        buildContentSse(responseId, model, buildVisibilityMarker(tc.name, result)),
+        buildMessageItemSequence(markerItemId, nextOutputIndex++, buildVisibilityMarker(fc.name, result)),
         "utf8"
       );
-      messages.push({
-        role: "tool",
-        tool_call_id: tc.id,
-        content: result
+      inputItems.push({
+        type: "function_call_output",
+        call_id: fc.callId || `call_${Date.now()}`,
+        output: result
       });
     }
-    requestBody.messages = messages;
-    const resp = await fetch(requestOptions.url, {
+    requestBody.input = inputItems;
+    if (!("stream" in requestBody)) requestBody.stream = true;
+    const { response: resp, clearTimer } = await fetchWithTimeout(requestOptions.url, {
       method: "POST",
       headers: requestOptions.headers,
       body: JSON.stringify(requestBody)
     });
     if (!resp.ok || !resp.body) {
+      clearTimer();
       const errText = await resp.text().catch(() => "upstream error");
-      ctx.log(`[acp-proxy: compress loop upstream error ${resp.status}: ${errText.slice(0, 200)}]`);
+      ctx.log(`[acp-proxy: responses compress loop upstream error ${resp.status}: ${errText.slice(0, 200)}]`);
+      const errItemId = `msg_acp_err_${Date.now()}`;
       yield Buffer.from(
-        `data: ${JSON.stringify({
-          ...makeBase(),
-          choices: [{
-            index: 0,
-            delta: { content: `
-[acp-proxy: upstream error ${resp.status}]
-` },
-            finish_reason: null
-          }]
-        })}
-
-`,
+        buildMessageItemSequence(errItemId, nextOutputIndex++, `
+[acp-proxy: upstream error ${resp.status}: ${errText.slice(0, 200)}]
+`),
         "utf8"
       );
-      yield Buffer.from(buildFinishSse(makeBase(), "stop", null), "utf8");
-      yield Buffer.from("data: [DONE]\n\n", "utf8");
+      yield Buffer.from(buildCompleted(responseObj), "utf8");
       return;
     }
     upstream = resp.body;
+    if (activeClearTimer) activeClearTimer();
+    activeClearTimer = clearTimer;
   }
 }
 
 // src/stream-openai.ts
-function safeJsonParse(s) {
-  try {
-    return s ? JSON.parse(s) : {};
-  } catch {
-    return {};
-  }
-}
 function rewriteOpenaiJsonResponse(body, ctx) {
   if (!body || typeof body !== "object") return body;
   const b = body;
   const choice = b.choices?.[0];
-  const msg = choice?.message;
-  if (!choice || !msg) return body;
+  const msg2 = choice?.message;
+  if (!choice || !msg2) return body;
   let converted = false;
   let sawReal = false;
   const noteParts = [];
   const keepToolCalls = [];
-  const existingText = typeof msg.content === "string" ? msg.content : "";
-  const toolCalls = msg.tool_calls;
+  const existingText = typeof msg2.content === "string" ? msg2.content : "";
+  const toolCalls = msg2.tool_calls;
   if (Array.isArray(toolCalls)) {
     for (const tc of toolCalls) {
       if (tc.function?.name === COMPRESS_TOOL_NAME) {
@@ -1076,14 +2395,17 @@ function rewriteOpenaiJsonResponse(body, ctx) {
       }
     }
   }
+  if (existingText && (existingText.includes("<acp ") || existingText.includes("</acp"))) {
+    ctx.log(`[warn: tag echo] non-stream openai output contains <acp tag: ${existingText.slice(0, 120).replace(/\n/g, " ")}`);
+  }
   if (!converted) return body;
   const note = noteParts.join("\n");
-  msg.content = existingText ? `${existingText}
+  msg2.content = existingText ? `${existingText}
 ${note}` : note;
   if (keepToolCalls.length > 0) {
-    msg.tool_calls = keepToolCalls;
+    msg2.tool_calls = keepToolCalls;
   } else {
-    delete msg.tool_calls;
+    delete msg2.tool_calls;
   }
   if (!sawReal) {
     choice.finish_reason = "stop";
@@ -1091,70 +2413,300 @@ ${note}` : note;
   return body;
 }
 
+// src/stream-responses.ts
+var TEXT_PROTOCOL2 = process.env.ACP_COMPRESS_PROTOCOL === "text";
+function rewriteResponsesJsonResponse(body, ctx) {
+  if (!body || typeof body !== "object") return body;
+  const b = body;
+  if (!Array.isArray(b.output)) return body;
+  let converted = false;
+  let sawReal = false;
+  const noteParts = [];
+  const keep = [];
+  for (const item of b.output) {
+    if (item.type === "function_call" && item.name === COMPRESS_TOOL_NAME) {
+      converted = true;
+      noteParts.push(applyRanges(parseCompressInput(safeJsonParse(String(item.arguments ?? ""))), ctx));
+    } else {
+      if (item.type === "function_call") sawReal = true;
+      keep.push(item);
+    }
+  }
+  if (!converted) return body;
+  const note = noteParts.join("\n");
+  if (note) {
+    keep.unshift({
+      type: "message",
+      role: "assistant",
+      content: [{ type: "output_text", text: note }]
+    });
+  }
+  b.output = keep;
+  if (!sawReal) b.status = "completed";
+  return body;
+}
+
+// src/stream-error.ts
+function safeWrite(res, chunk) {
+  try {
+    res.write(chunk);
+  } catch {
+  }
+}
+function emitStreamError(res, protocol, message, log) {
+  const visible = `
+\u274C [ACP] stream error: ${message}`;
+  log?.(`[acp-proxy: stream aborted mid-response: ${message}]`);
+  try {
+    if (protocol === "openai") {
+      safeWrite(res, `data: ${JSON.stringify({ choices: [{ index: 0, delta: { content: visible }, finish_reason: null }] })}
+
+`);
+      safeWrite(res, `data: ${JSON.stringify({ choices: [{ index: 0, delta: {}, finish_reason: "stop" }] })}
+
+`);
+      safeWrite(res, "data: [DONE]\n\n");
+    } else if (protocol === "responses") {
+      safeWrite(res, `event: response.output_text.delta
+data: ${JSON.stringify({ type: "response.output_text.delta", delta: visible })}
+
+`);
+      safeWrite(res, `event: response.completed
+data: ${JSON.stringify({ type: "response.completed", response: { status: "completed", output: [] } })}
+
+`);
+    } else {
+      safeWrite(res, `event: content_block_delta
+data: ${JSON.stringify({ type: "content_block_delta", delta: { type: "text_delta", text: visible } })}
+
+`);
+      safeWrite(res, `event: message_delta
+data: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: "end_turn" } })}
+
+`);
+      safeWrite(res, `event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`);
+    }
+  } catch {
+  } finally {
+    try {
+      res.end();
+    } catch {
+    }
+  }
+}
+
+// src/session-id.ts
+function extractKey(headers) {
+  const auth = headers["authorization"];
+  if (typeof auth === "string" && auth.length > 0) return auth.trim().toLowerCase();
+  const apiKey = headers["x-api-key"];
+  if (typeof apiKey === "string" && apiKey.length > 0) return `key:${apiKey.trim().toLowerCase()}`;
+  return "(no-key)";
+}
+function clientConversationHeader(headers) {
+  const names = ["x-session-affinity", "x-acp-session", "x-session-id", "x-opencode-session"];
+  for (const name of names) {
+    const v = headers[name];
+    if (typeof v === "string" && v.trim().length > 0) return v.trim();
+  }
+  return void 0;
+}
+function deriveSessionId(headers, protocol, upstream, conversation) {
+  if (!conversation) throw new Error("deriveSessionId: conversation dimension is required (pass the conversationSignal* output)");
+  const key = extractKey(headers);
+  return hashId(`${protocol}|${upstream}|${key}|${conversation}`);
+}
+function affinityToken(headers, conversation) {
+  const client = clientConversationHeader(headers);
+  if (client) return client;
+  return `ses_${conversation}`;
+}
+
 // src/server.ts
 var UPSTREAM_HOP_HEADERS = /* @__PURE__ */ new Set([
   "host",
   "content-length",
   "connection",
   "keep-alive",
-  "transfer-encoding"
+  "transfer-encoding",
+  // Node's fetch transparently decodes compressed responses. Do not
+  // forward the upstream encoding marker when the body is rewritten or
+  // streamed from fetch, otherwise clients try to decompress plain bytes.
+  "content-encoding"
 ]);
-function resolveUpstream(opts2, authHeader) {
-  if (!opts2.routes.length || !authHeader) return void 0;
-  const token = authHeader.replace(/^Bearer\s+/i, "").trim();
-  if (!token) return void 0;
-  const match = opts2.routes.find((r) => r.apiKey && r.apiKey === token);
-  return match?.baseURL.replace(/\/$/, "");
-}
-function startServer(opts2) {
+function resolveUpstream(opts, reqUrl) {
+  const names = Object.keys(opts.routes);
+  if (names.length === 0) return void 0;
+  const RESERVED = /* @__PURE__ */ new Set(["v1", "v2", "v4", "chat", "completions", "messages", "models", "api"]);
+  const sorted = [...names].sort((a, b) => b.length - a.length);
+  const segments = reqUrl.split("/");
+  for (const name of sorted) {
+    if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(name)) continue;
+    if (RESERVED.has(name.toLowerCase())) continue;
+    const idx = segments.indexOf(name);
+    if (idx < 0) continue;
+    const base = opts.routes[name].url.replace(/\/$/, "");
+    const rest = [...segments.slice(0, idx), ...segments.slice(idx + 1)].join("/");
+    const rewrittenUrl = base + rest;
+    return { upstream: base, rewrittenUrl, provider: name };
+  }
+  return void 0;
+}
+async function startServer(opts) {
   const core = createCore();
-  const config = opts2.kernelConfig;
-  const log = (level, msg) => logMsg(opts2, level, msg);
-  const server2 = http.createServer(async (req, res) => {
+  const config = opts.kernelConfig;
+  const log = (level, msg2) => logMsg(opts, level, msg2);
+  await initSessions();
+  log("info", `[persist] ${getStore().enabled ? "enabled" : "disabled"}`);
+  const server = http.createServer(async (req, res) => {
     try {
-      await handle(req, res, opts2, core, config, log);
+      await handle(req, res, opts, core, config, log);
     } catch (err) {
-      log("error", String(err));
+      const msg2 = String(err);
+      log("error", msg2);
       if (!res.headersSent) {
-        res.writeHead(502, { "content-type": "application/json" });
-        res.end(JSON.stringify({ error: "acp-proxy failure", detail: String(err) }));
+        const status = msg2.includes("exceeds") ? 413 : 502;
+        res.writeHead(status, { "content-type": "application/json" });
+        res.end(JSON.stringify({ error: "acp-proxy failure", detail: msg2 }));
       } else {
         res.end();
       }
     }
   });
-  server2.listen(opts2.port, opts2.host, () => {
-    log("info", `acp-proxy listening on http://${opts2.host}:${opts2.port} \u2192 ${opts2.upstream}`);
+  server.listen(opts.port, opts.host, () => {
+    log(
+      "info",
+      `acp-proxy listening on http://${opts.host}:${opts.port}` + (Object.keys(opts.routes).length ? ` \u2014 routes: ${Object.entries(opts.routes).map(([n, u]) => `${n}=${typeof u === "string" ? u : u.url}`).join(", ")}` : ` \u2192 ${opts.upstream}`)
+    );
   });
-  return server2;
+  let shuttingDown = false;
+  const shutdown = (sig) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    log("info", `${sig} received \u2014 flushing sessions\u2026`);
+    server.close();
+    void flushAllSessions().finally(() => {
+      process.exit(0);
+    });
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  return server;
+}
+function applyCondense(messages, opts, session) {
+  const condenseOpts = {
+    enabled: opts.condense.enabled,
+    keepRecent: opts.condense.keepRecentToolResults,
+    minChars: opts.condense.minCharsToCondense,
+    maxKeptChars: opts.condense.maxKeptChars
+  };
+  const { messages: out, condensedCount, charsSaved } = condenseOldToolResults(messages, condenseOpts);
+  if (condensedCount > 0) {
+    session.condensedToolResults += condensedCount;
+    session.tokensSaved += Math.ceil(charsSaved / 4);
+  }
+  return out;
 }
-async function handle(req, res, opts2, core, config, log) {
+async function handle(req, res, opts, core, config, log) {
   if (req.method === "GET" && req.url === "/__acp/stats") return sendStats(res);
   if (req.method === "GET" && (req.url === "/" || req.url === "/__acp/health")) {
     res.writeHead(200, { "content-type": "application/json" });
-    res.end(JSON.stringify({ ok: true, upstream: opts2.upstream }));
+    res.end(JSON.stringify({ ok: true, upstream: opts.upstream }));
+    return;
+  }
+  let bodyBuffer;
+  try {
+    bodyBuffer = await readBody(req);
+  } catch (err) {
+    if (err instanceof BodyTooLargeError) {
+      log("warn", `413: request body exceeds ${err.limit} bytes`);
+      res.writeHead(413, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: { type: "request_too_large", message: err.message } }));
+      return;
+    }
+    log("warn", `read body failed: ${String(err)}`);
+    res.writeHead(400, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: { type: "invalid_request", message: String(err) } }));
     return;
   }
-  const bodyBuffer = await readBody(req);
   const url = req.url ?? "";
-  const protocol = req.method === "POST" && bodyBuffer.length > 0 ? url.endsWith("/chat/completions") ? "openai" : url.endsWith("/v1/messages") || url.endsWith("/messages") ? "anthropic" : null : null;
-  const prepared = opts2.passthrough ? null : protocol === "anthropic" ? prepareAnthropic(bodyBuffer, req, opts2, core, config, log) : protocol === "openai" ? prepareOpenai(bodyBuffer, req, opts2, core, config, log) : null;
-  const outBody = prepared ? prepared.body : bodyBuffer;
-  await forward(req, res, opts2, outBody, prepared, core, config, log);
+  const urlPath = url.split("?", 2)[0];
+  const protocol = req.method === "POST" && bodyBuffer.length > 0 ? urlPath.endsWith("/chat/completions") ? "openai" : urlPath.endsWith("/v1/messages") || urlPath.endsWith("/messages") ? "anthropic" : urlPath.endsWith("/responses") ? "responses" : null : null;
+  const route = resolveUpstream(opts, req.url ?? "");
+  const upstreamOrigin = route ? route.upstream : opts.upstream;
+  let parsed = null;
+  if (protocol && bodyBuffer.length > 0) {
+    try {
+      parsed = JSON.parse(bodyBuffer.toString("utf8"));
+    } catch {
+      parsed = null;
+    }
+  }
+  let reqConfig = config;
+  if (parsed && typeof parsed === "object") {
+    const model = parsed.model;
+    if (model) {
+      const limit = resolveContextLimit(opts.routes, route?.provider, model);
+      if (limit && limit !== config.modelContextLimit) {
+        reqConfig = { ...config, modelContextLimit: limit };
+      }
+    }
+  }
+  let prepared = null;
+  if (!opts.passthrough && protocol && parsed && typeof parsed === "object") {
+    const sessionHeader = headerValue(req, opts.sessionHeader);
+    const conversation = protocol === "anthropic" ? conversationSignalAnthropic(parsed, sessionHeader) : protocol === "openai" ? conversationSignalOpenai(parsed, sessionHeader) : conversationSignalResponses(parsed, sessionHeader);
+    const sessionId = deriveSessionId(req.headers, protocol, upstreamOrigin, conversation);
+    const session = getSession(sessionId, { protocol, upstreamOrigin });
+    const affinity = affinityToken(req.headers, conversation);
+    await withSessionLock(session, async () => {
+      prepared = protocol === "anthropic" ? prepareAnthropic(parsed, req, opts, core, reqConfig, log, session) : protocol === "openai" ? prepareOpenai(parsed, req, opts, core, reqConfig, log, session) : prepareResponses(parsed, req, opts, core, reqConfig, log, session);
+      acquireInFlight(session);
+      try {
+        await forward(req, res, opts, prepared.body, prepared, core, reqConfig, log, route, affinity);
+      } finally {
+        releaseInFlight(session);
+      }
+    });
+  }
+  if (!prepared) {
+    if (protocol === null && !opts.passthrough) {
+      log("warn", `unrecognized path ${url} \u2014 not a known protocol (/chat/completions, /v1/messages, /responses); forwarding unchanged`);
+    }
+    await forward(req, res, opts, bodyBuffer, null, core, reqConfig, log, route, void 0);
+  }
 }
-var ACP_TAG_RE = /^\x3cacp [^>]*\x3e[^\x3c]*\x3c\/acp\x3e\n?/;
-function stripToolTags(messages) {
+var ACP_TAG_MARK = "<acp ";
+function diagTagSummary(messages, sessionId, strategy) {
+  let textTagged = 0;
+  let toolTagged = 0;
   for (const m of messages) {
-    if (m.contentType === "tool-call" || m.contentType === "tool-result") {
-      m.text = (m.text ?? "").replace(ACP_TAG_RE, "");
-    }
+    const hasTag = (m.text ?? "").includes(ACP_TAG_MARK);
+    if (!hasTag) continue;
+    if (m.contentType === "tool-call" || m.contentType === "tool-result") toolTagged++;
+    else textTagged++;
   }
+  return `[${sessionId}] processTurn: ${messages.length} msgs, renderTags=${strategy}, ${textTagged} text tagged, ${toolTagged} tool tagged (should be 0 with text-only)`;
 }
-function prepareAnthropic(bodyBuffer, req, opts2, core, config, log) {
-  const parsed = JSON.parse(bodyBuffer.toString("utf8"));
+function diagNudge(turn, sessionId, tokenCount, limit) {
+  const n = turn.nudge;
+  if (!n) return `[${sessionId}] nudge: unavailable`;
+  const b = n.breakdown ?? {};
+  const pct = limit > 0 ? `${Math.round(tokenCount / limit * 100)}%` : "?";
+  const growth = b["growth"] ?? 0;
+  const floor = b["growthFloor"] ?? 0;
+  const interval = b["nudgeGrowthTokens"] ?? 0;
+  const pendingT1 = b["pendingT1"] ?? 0;
+  const ref = b["growthReference"] ?? 0;
+  const inject = n.shouldInject ? `INJECT T${n.tier ?? "?"}` : "idle";
+  return `[${sessionId}] nudge ${inject}: usage=${pct} (${tokenCount}/${limit}), growth=${growth}/${floor} (ref=${ref}, interval=${interval}), pendingT1=${pendingT1}/${interval}, reason="${n.reason.slice(0, 120)}"`;
+}
+function prepareAnthropic(parsed, req, opts, core, config, log, session) {
+  const sessionId = session.id;
   const stream = parsed.stream === true;
-  const sessionId = deriveSessionId(parsed, headerValue(req, opts2.sessionHeader));
-  const session = getSession(sessionId);
   session.requests++;
   let processedMessages = [];
   let rebuiltMessages = parsed.messages;
@@ -1162,74 +2714,148 @@ function prepareAnthropic(bodyBuffer, req, opts2, core, config, log) {
   let toolsOut = parsed.tools;
   try {
     const { msgs } = anthropicToCore(parsed);
-    const tokenCount = estimateTokensFast2(msgs.map((m) => m.text ?? "").join("\n"));
-    const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount });
+    const tokenCount = estimateTokensFast3(msgs.map((m) => m.text ?? "").join("\n"));
+    const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: "text-only" });
     session.state = turn.state;
-    stripToolTags(turn.messages);
-    processedMessages = turn.messages;
-    rebuiltMessages = coreToAnthropic(turn.messages);
-    systemOut = injectSystem(parsed, turn.nudge, opts2);
-    if (opts2.compress.injectTool) {
+    log("info", diagTagSummary(turn.messages, sessionId, "text-only"));
+    log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit));
+    processedMessages = applyCondense(turn.messages, opts, session);
+    reapOrphanBlocks(session, msgs, deactivateBlock4);
+    rebuiltMessages = coreToAnthropic(processedMessages);
+    systemOut = injectSystem(parsed, opts);
+    if (opts.compress.injectTool) {
       toolsOut = injectTool(parsed.tools);
     }
+    if (turn.nudge?.shouldInject) {
+      try {
+        const rendered = renderNudgeText(turn.nudge);
+        if (rendered.text) {
+          rebuiltMessages = [...rebuiltMessages, { role: "user", content: rendered.text }];
+        }
+      } catch {
+      }
+    }
   } catch (err) {
     log("warn", `[${sessionId}] kernel transform failed, forwarding unchanged: ${String(err)}`);
     processedMessages = [];
   }
   const rebuilt = { ...parsed, messages: rebuiltMessages, system: systemOut, tools: toolsOut };
-  return { body: JSON.stringify(rebuilt), session, processedMessages, protocol: "anthropic", stream, compressInjected: opts2.compress.injectTool };
+  markDirty(session);
+  return { body: JSON.stringify(rebuilt), session, processedMessages, protocol: "anthropic", stream, compressInjected: opts.compress.injectTool };
 }
-function prepareOpenai(bodyBuffer, req, opts2, core, config, log) {
-  const parsed = JSON.parse(bodyBuffer.toString("utf8"));
+function prepareOpenai(parsed, req, opts, core, config, log, session) {
+  const sessionId = session.id;
   const stream = parsed.stream === true;
-  const sessionId = deriveSessionIdOpenai(parsed, headerValue(req, opts2.sessionHeader));
-  const session = getSession(sessionId);
   session.requests++;
   let processedMessages = [];
   let rebuiltMessages = parsed.messages;
   let toolsOut = parsed.tools;
   const maxTokens = typeof parsed.max_tokens === "number" ? parsed.max_tokens : 8192;
   const isTitleGen = maxTokens <= 200 || parsed.messages.length <= 2;
-  const shouldInject = opts2.compress.injectTool && !isTitleGen;
+  const shouldInject = opts.compress.injectTool && !isTitleGen;
   try {
     const { msgs } = openaiToCore(parsed);
-    const tokenCount = estimateTokensFast2(msgs.map((m) => m.text ?? "").join("\n"));
-    const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount });
+    const tokenCount = estimateTokensFast3(msgs.map((m) => m.text ?? "").join("\n"));
+    const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: "text-only" });
     session.state = turn.state;
-    stripToolTags(turn.messages);
-    processedMessages = turn.messages;
-    rebuiltMessages = coreToOpenai(turn.messages);
+    log("info", diagTagSummary(turn.messages, sessionId, "text-only"));
+    log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit));
+    processedMessages = applyCondense(turn.messages, opts, session);
+    reapOrphanBlocks(session, msgs, deactivateBlock4);
+    rebuiltMessages = coreToOpenai(processedMessages);
     const sysParts = [];
     if (shouldInject) sysParts.push(buildCompressSystemPrompt());
+    rebuiltMessages = injectOpenaiSystem(rebuiltMessages, sysParts);
+    if (shouldInject) {
+      toolsOut = injectOpenaiTool(parsed.tools);
+    }
     if (turn.nudge?.shouldInject && shouldInject) {
       try {
         const rendered = renderNudgeText(turn.nudge);
-        if (rendered.text) sysParts.push(rendered.text);
+        if (rendered.text) {
+          rebuiltMessages = [...rebuiltMessages, { role: "user", content: rendered.text }];
+        }
       } catch {
       }
     }
-    rebuiltMessages = injectOpenaiSystem(rebuiltMessages, sysParts);
-    if (shouldInject) {
-      toolsOut = injectOpenaiTool(parsed.tools);
-    }
   } catch (err) {
     log("warn", `[${sessionId}] kernel transform failed, forwarding unchanged: ${String(err)}`);
     processedMessages = [];
   }
   const rebuilt = { ...parsed, messages: rebuiltMessages, tools: toolsOut };
+  markDirty(session);
   return { body: JSON.stringify(rebuilt), session, processedMessages, protocol: "openai", stream, compressInjected: shouldInject };
 }
-function injectSystem(parsed, nudge, opts2) {
-  const baseText = extractSystem(parsed.system);
-  const parts = [];
-  if (opts2.compress.injectTool) parts.push(buildCompressSystemPrompt());
-  if (nudge?.shouldInject) {
-    try {
-      const rendered = renderNudgeText(nudge);
-      if (rendered.text) parts.push(rendered.text);
-    } catch {
+function prepareResponses(parsed, req, opts, core, config, log, session) {
+  const sessionId = session.id;
+  const stream = parsed.stream === true;
+  session.requests++;
+  let processedMessages = [];
+  let rebuiltInput = parsed.input;
+  let toolsOut = parsed.tools;
+  const shouldInject = opts.compress.injectTool;
+  try {
+    const { msgs, systemParts, preamble, customToolCallIds } = responsesToCore(parsed);
+    if (process.env.ACP_DEBUG) {
+      log("info", `[${sessionId}] input items: ${Array.isArray(parsed.input) ? parsed.input.map((i) => i.type).join(",") : "(string)"}`);
     }
+    const tokenCount = estimateTokensFast3(msgs.map((m) => m.text ?? "").join("\n"));
+    const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: process.env.ACP_RENDER_NONE ? "none" : "text-only" });
+    session.state = turn.state;
+    log("info", diagTagSummary(turn.messages, sessionId, "text-only"));
+    log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit));
+    processedMessages = applyCondense(turn.messages, opts, session);
+    reapOrphanBlocks(session, msgs, deactivateBlock4);
+    const conversationItems = coreToResponses(processedMessages, customToolCallIds);
+    if (preamble.length > 0) {
+      log("info", `[${sessionId}] preserved ${preamble.length} opaque preamble item(s): ${preamble.map((p) => p.type).join(",")}`);
+    }
+    const inputItems = [...preamble];
+    if (shouldInject && !process.env.ACP_NO_COMPRESS_PROMPT) {
+      const sysParts = [...systemParts, buildCompressSystemPrompt()];
+      inputItems.push({ type: "message", role: "developer", content: sysParts.join("\n\n---\n\n") });
+      if (!process.env.ACP_NO_INJECT_TOOL) {
+        toolsOut = injectResponsesTool(parsed.tools);
+      }
+    } else if (systemParts.length > 0) {
+      inputItems.push({ type: "message", role: "developer", content: systemParts.join("\n\n---\n\n") });
+    }
+    inputItems.push(...conversationItems);
+    if (process.env.ACP_DEBUG) {
+      const ctcs = conversationItems.filter((i) => i.type === "custom_tool_call").length;
+      const ctcos = conversationItems.filter((i) => i.type === "custom_tool_call_output").length;
+      log("info", `[${sessionId}] rebuilt: msgs=${msgs.length} -> conv=${conversationItems.length} (custom_tool_call=${ctcs} custom_tool_call_output=${ctcos})`);
+    }
+    if (turn.nudge?.shouldInject && shouldInject) {
+      try {
+        const rendered = renderNudgeText(turn.nudge);
+        if (rendered.text) {
+          inputItems.push({ type: "message", role: "user", content: rendered.text });
+        }
+      } catch {
+      }
+    }
+    rebuiltInput = inputItems;
+  } catch (err) {
+    log("warn", `[${sessionId}] kernel transform failed, forwarding unchanged: ${String(err)}`);
+    processedMessages = [];
   }
+  const rebuilt = { ...parsed, input: rebuiltInput, tools: toolsOut };
+  if (process.env.ACP_DEBUG) {
+    const fwdTools = (Array.isArray(toolsOut) ? toolsOut : []).map((t) => {
+      const r = t;
+      const sub = Array.isArray(r.tools) ? `(${r.tools.length} sub)` : "";
+      return `${r.type}:${r.name ?? "?"}${sub}`;
+    });
+    log("info", `[${sessionId}] responses forward tools=[${fwdTools.join(",")}] injectTool=${shouldInject} NO_INJECT_TOOL=${!!process.env.ACP_NO_INJECT_TOOL} NO_COMPRESS_PROMPT=${!!process.env.ACP_NO_COMPRESS_PROMPT}`);
+  }
+  markDirty(session);
+  return { body: JSON.stringify(rebuilt), session, processedMessages, protocol: "responses", stream, compressInjected: shouldInject };
+}
+function injectSystem(parsed, opts) {
+  const baseText = extractSystem(parsed.system);
+  const parts = [];
+  if (opts.compress.injectTool) parts.push(buildCompressSystemPrompt());
   if (parts.length === 0) return parsed.system;
   const full = baseText ? `${baseText}
 
@@ -1251,21 +2877,44 @@ function injectOpenaiTool(tools) {
   const additions = ACP_TOOLS_OPENAI.filter((t) => !present.has(t.function.name));
   return [...tools, ...additions];
 }
-async function forward(req, res, opts2, body, prepared, core, config, log) {
-  const base = resolveUpstream(opts2, req.headers.authorization) ?? opts2.upstream;
-  const upstreamUrl = base + (req.url ?? "");
-  log("info", `forward ${req.method} ${req.url ?? ""} \u2192 ${upstreamUrl}`);
-  if (opts2.debug && typeof body === "string") {
+var TEXT_PROTOCOL3 = process.env.ACP_COMPRESS_PROTOCOL === "text";
+function injectResponsesTool(tools) {
+  if (!Array.isArray(tools)) return [...ACP_TOOLS_RESPONSES];
+  const present = new Set(
+    tools.map((t) => t?.name).filter((n) => typeof n === "string")
+  );
+  const additions = ACP_TOOLS_RESPONSES.filter((t) => !present.has(t.name));
+  return [...tools, ...additions];
+}
+async function forward(req, res, opts, body, prepared, core, config, log, route, affinity) {
+  const upstreamUrl = route ? route.rewrittenUrl : opts.upstream + (req.url ?? "");
+  log("info", `forward ${req.method} ${req.url ?? ""} \u2192 ${upstreamUrl}${route ? ` (${route.provider})` : ""}`);
+  if (process.env.ACP_DEBUG && prepared) {
+    const sid = prepared.session.id;
+    const hdrKeys = Object.keys(req.headers);
+    log("info", `[${sid}] client headers: ${hdrKeys.join(",")}`);
+    for (const k of ["authorization", "x-api-key", "x-session-id", "x-session-affinity", "x-acp-session", "x-opencode-session", "prompt-cache-key", "anthropic-beta"]) {
+      const v = req.headers[k] ?? req.headers[k.toLowerCase()];
+      if (v) {
+        const s = Array.isArray(v) ? v.join(",") : String(v);
+        const masked = /key|auth|token/i.test(k) ? s.slice(0, 8) + "..." + s.slice(-4) + ` (${s.length} chars)` : s.slice(0, 60);
+        log("info", `[${sid}] client hdr ${k}=${masked}`);
+      }
+    }
+  }
+  if (opts.debug && typeof body === "string") {
     try {
       const parsed = JSON.parse(body);
       const toolNames = (parsed.tools ?? []).map((t) => {
         const fn = t.function;
-        return fn?.name ?? "?";
+        return fn?.name ?? t.name ?? "?";
       });
       log("info", `[debug] tools=[${toolNames.join(",")}] msgs=${parsed.messages?.length ?? 0} stream=${parsed.stream ?? false} system_len=${JSON.stringify(parsed.messages?.find((m) => m.role === "system")?.content ?? "").length}`);
-      const out = `/tmp/acp-proxy-debug-req-${Date.now()}.json`;
-      fs.writeFileSync(out, body.slice(0, 5e4));
-      log("info", `[debug] forwarded body written to ${out}`);
+      if (process.env.ACP_DUMP_REQ === "1") {
+        const out = `/tmp/acp-proxy-debug-req-${Date.now()}.json`;
+        fs2.writeFileSync(out, body.slice(0, 5e4));
+        log("info", `[debug] forwarded body written to ${out}`);
+      }
     } catch {
     }
   }
@@ -1274,26 +2923,37 @@ async function forward(req, res, opts2, body, prepared, core, config, log) {
     if (UPSTREAM_HOP_HEADERS.has(k.toLowerCase()) || v === void 0) continue;
     headers[k] = Array.isArray(v) ? v.join(", ") : v;
   }
-  headers["host"] = new URL(base).host;
+  headers["host"] = new URL(route ? route.upstream : opts.upstream).host;
+  if (affinity && !clientConversationHeader(req.headers)) {
+    headers["x-session-id"] = affinity;
+  }
   const init = {
     method: req.method ?? "GET",
     headers,
     body: req.method === "GET" || req.method === "HEAD" ? void 0 : body
   };
-  const upstream = await fetch(upstreamUrl, init);
+  const { response: upstream, clearTimer: clearUpstreamTimer } = await fetchWithTimeout(upstreamUrl, init);
   const respHeaders = {};
   upstream.headers.forEach((v, k) => {
     if (UPSTREAM_HOP_HEADERS.has(k.toLowerCase())) return;
     respHeaders[k] = v;
   });
+  if (!upstream.ok) {
+    res.writeHead(upstream.status, respHeaders);
+    if (upstream.body) await pipeThrough(upstream.body, res);
+    clearUpstreamTimer();
+    return;
+  }
   res.writeHead(upstream.status, respHeaders);
   if (!upstream.body) {
     res.end();
+    clearUpstreamTimer();
     return;
   }
-  const useRewriter = prepared !== null && prepared.processedMessages.length > 0 && opts2.compress.injectTool;
+  const useRewriter = prepared !== null && prepared.compressInjected && prepared.processedMessages.length > 0;
   if (!useRewriter || prepared === null) {
     await pipeThrough(upstream.body, res);
+    clearUpstreamTimer();
     return;
   }
   const ctx = {
@@ -1301,50 +2961,83 @@ async function forward(req, res, opts2, body, prepared, core, config, log) {
     config,
     messages: prepared.processedMessages,
     session: prepared.session,
-    log: (msg) => log("info", `[${prepared.session.id}] ${msg}`),
-    debug: opts2.debug
+    log: (msg2) => log("info", `[${prepared.session.id}] ${msg2}`),
+    debug: opts.debug
   };
   if (prepared.stream) {
     let streamToRead = upstream.body;
     let dumpRaw;
-    if (opts2.dumpSse) {
+    if (opts.dumpSse) {
       const [a, b] = upstream.body.tee();
       streamToRead = a;
-      dumpRaw = dumpStreamToFile(b, opts2.dumpSse, `${Date.now()}-${prepared.session.id}-raw.sse`);
-    }
-    const ctx2 = {
-      core,
-      config,
-      messages: prepared.processedMessages,
-      session: prepared.session,
-      log: (msg) => log("info", `[${prepared.session.id}] ${msg}`),
-      debug: opts2.debug
-    };
-    if (prepared.protocol === "openai" && prepared.compressInjected) {
-      const parsedReq = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
-      const reqHeaders = {};
-      for (const [k, v] of Object.entries(headers)) {
-        if (k.toLowerCase() === "content-length" || k.toLowerCase() === "host") continue;
-        reqHeaders[k] = v;
-      }
-      reqHeaders["content-type"] = "application/json";
-      const loop = compressLoopStream(
-        streamToRead,
-        { core, config, messages: prepared.processedMessages, session: prepared.session, log: ctx2.log },
-        parsedReq,
-        { url: upstreamUrl, headers: reqHeaders }
-      );
-      for await (const chunk of loop) {
-        if (!res.write(chunk)) await new Promise((r) => res.once("drain", () => r()));
-      }
-    } else {
-      const rewriter = rewriteSseStream(streamToRead, ctx2);
-      for await (const chunk of rewriter) {
-        if (!res.write(chunk)) await new Promise((r) => res.once("drain", () => r()));
+      dumpRaw = dumpStreamToFile(b, opts.dumpSse, `${Date.now()}-${prepared.session.id}-raw.sse`);
+    }
+    try {
+      if (prepared.protocol === "openai") {
+        const parsedReq = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
+        const reqHeaders = {};
+        for (const [k, v] of Object.entries(headers)) {
+          if (k.toLowerCase() === "content-length" || k.toLowerCase() === "host") continue;
+          reqHeaders[k] = v;
+        }
+        reqHeaders["content-type"] = "application/json";
+        const loop = compressLoopStream(
+          streamToRead,
+          { core, config, messages: prepared.processedMessages, session: prepared.session, log: ctx.log },
+          parsedReq,
+          { url: upstreamUrl, headers: reqHeaders }
+        );
+        for await (const chunk of loop) {
+          {
+            const s = chunk.toString("utf8");
+            if (s.includes("<acp ") || s.includes("</acp")) {
+              log("warn", `[${prepared.session.id}] tag echo: openai response stream contains <acp tag`);
+            }
+          }
+          if (!res.write(chunk)) await new Promise((r) => res.once("drain", () => r()));
+        }
+      } else if (prepared.protocol === "responses") {
+        const parsedReq = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
+        const reqHeaders = {};
+        for (const [k, v] of Object.entries(headers)) {
+          if (k.toLowerCase() === "content-length" || k.toLowerCase() === "host") continue;
+          reqHeaders[k] = v;
+        }
+        reqHeaders["content-type"] = "application/json";
+        const loop = compressLoopResponsesStream(
+          streamToRead,
+          { core, config, messages: prepared.processedMessages, session: prepared.session, log: ctx.log },
+          parsedReq,
+          { url: upstreamUrl, headers: reqHeaders }
+        );
+        for await (const chunk of loop) {
+          {
+            const s = chunk.toString("utf8");
+            if (s.includes("<acp ") || s.includes("</acp")) {
+              log("warn", `[${prepared.session.id}] tag echo: responses response stream contains <acp tag`);
+            }
+          }
+          if (!res.write(chunk)) await new Promise((r) => res.once("drain", () => r()));
+        }
+      } else {
+        const rewriter = rewriteSseStream(streamToRead, ctx);
+        for await (const chunk of rewriter) {
+          {
+            const s = chunk.toString("utf8");
+            if (s.includes("<acp ") || s.includes("</acp")) {
+              log("warn", `[${prepared.session.id}] tag echo: anthropic response stream contains <acp tag`);
+            }
+          }
+          if (!res.write(chunk)) await new Promise((r) => res.once("drain", () => r()));
+        }
       }
+      res.end();
+    } catch (e) {
+      emitStreamError(res, prepared.protocol, e?.message ?? String(e), (m) => log("error", `[${prepared.session.id}] ${m}`));
+    } finally {
+      clearUpstreamTimer();
+      if (dumpRaw) await dumpRaw;
     }
-    res.end();
-    if (dumpRaw) await dumpRaw;
   } else {
     const buf = await upstream.arrayBuffer();
     const text = Buffer.from(buf).toString("utf8");
@@ -1352,6 +3045,8 @@ async function forward(req, res, opts2, body, prepared, core, config, log) {
       const json = JSON.parse(text);
       if (prepared.protocol === "openai") {
         rewriteOpenaiJsonResponse(json, ctx);
+      } else if (prepared.protocol === "responses") {
+        rewriteResponsesJsonResponse(json, ctx);
       } else {
         rewriteJsonResponse(json, ctx);
       }
@@ -1359,7 +3054,9 @@ async function forward(req, res, opts2, body, prepared, core, config, log) {
     } catch {
       res.end(text);
     }
+    clearUpstreamTimer();
   }
+  markDirty(prepared.session);
 }
 async function pipeThrough(stream, res) {
   const reader = stream.getReader();
@@ -1377,11 +3074,11 @@ async function pipeThrough(stream, res) {
   }
 }
 async function dumpStreamToFile(stream, dir, name) {
-  const { mkdirSync: mkdirSync2, createWriteStream } = await import("fs");
-  const { join: join2 } = await import("path");
+  const { mkdirSync: mkdirSync3, createWriteStream } = await import("fs");
+  const { join: join3 } = await import("path");
   try {
-    mkdirSync2(dir, { recursive: true });
-    const ws = createWriteStream(join2(dir, name));
+    mkdirSync3(dir, { recursive: true });
+    const ws = createWriteStream(join3(dir, name));
     const reader = stream.getReader();
     try {
       for (; ; ) {
@@ -1414,26 +3111,160 @@ function headerValue(req, name) {
   }
   return void 0;
 }
+var BodyTooLargeError = class extends Error {
+  constructor(limit) {
+    super(`request body exceeds ${limit} bytes`);
+    this.limit = limit;
+    this.name = "BodyTooLargeError";
+  }
+  limit;
+};
 function readBody(req) {
   return new Promise((resolve, reject) => {
     const chunks = [];
-    req.on("data", (c) => chunks.push(c));
-    req.on("end", () => resolve(Buffer.concat(chunks)));
-    req.on("error", reject);
+    let size = 0;
+    let aborted = false;
+    req.on("data", (c) => {
+      if (aborted) return;
+      size += c.length;
+      if (size > MAX_REQUEST_BYTES) {
+        aborted = true;
+        reject(new BodyTooLargeError(MAX_REQUEST_BYTES));
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on("end", () => {
+      if (!aborted) resolve(Buffer.concat(chunks));
+    });
+    req.on("error", (e) => {
+      if (!aborted) reject(e);
+    });
   });
 }
-function logMsg(opts2, level, msg) {
-  if (!opts2.log) return;
+function logMsg(opts, level, msg2) {
+  if (!opts.log) return;
   const ts = (/* @__PURE__ */ new Date()).toISOString();
-  console.error(`${ts} [${level}] ${msg}`);
+  console.error(`${ts} [${level}] ${msg2}`);
 }
 
-// src/index.ts
-var opts = loadOptions();
-var server = startServer(opts);
-for (const sig of ["SIGINT", "SIGTERM"]) {
-  process.on(sig, () => {
-    server.close(() => process.exit(0));
-  });
+// src/cli.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath } from "url";
+import path3 from "path";
+var VERSION = (() => {
+  try {
+    const here = fileURLToPath(import.meta.url);
+    const pkg = path3.join(path3.dirname(here), "..", "package.json");
+    return JSON.parse(readFileSync3(pkg, "utf8")).version ?? "dev";
+  } catch {
+    return "dev";
+  }
+})();
+var HELP = `bili ${VERSION} \u2014 billion-context proxy
+
+Usage:
+  bili [start] [options]        start the proxy (default: reads ${configFile()})
+  bili --version                print version
+  bili --help                   show this help
+
+Options (override config file / env):
+  --port <N>                    listen port (default 8787)
+  --host <ADDR>                 listen host (default 127.0.0.1)
+  --config <FILE>               path to config JSON (default: XDG location)
+  --debug                       verbose logging
+  --passthrough                 forward without compression
+  --no-passthrough              force compression on (overrides config)
+
+Config: ${configFile()}
+  Set port/host/debug/providers/condense/compress there. See README \xA7Configuration.
+  Env vars (ACP_*, BILI_*) also work and override the file; CLI flags win.
+
+Docs: https://github.com/ranxianglei/billion-context
+`;
+function parseArgs(argv) {
+  const overrides = {};
+  let command = "start";
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case "--help":
+      case "-h":
+        command = "help";
+        break;
+      case "--version":
+      case "-V":
+        command = "version";
+        break;
+      case "--debug":
+        overrides.ACP_DEBUG = "1";
+        break;
+      case "--passthrough":
+        overrides.ACP_PASSTHROUGH = "1";
+        break;
+      case "--no-passthrough":
+        overrides.ACP_PASSTHROUGH = "0";
+        break;
+      case "--port":
+      case "--host":
+      case "--config": {
+        const val = argv[++i];
+        if (val === void 0) {
+          console.error(`bili: ${a} requires a value`);
+          process.exit(2);
+        }
+        if (a === "--port") overrides.ACP_PORT = val;
+        else if (a === "--host") overrides.ACP_HOST = val;
+        else overrides.BILI_CONFIG_FILE = val;
+        break;
+      }
+      default:
+        if (a.startsWith("--")) {
+          const eq = a.indexOf("=");
+          if (eq > 0) {
+            argv.splice(i, 1, a.slice(0, eq), a.slice(eq + 1));
+            i--;
+            break;
+          }
+          console.error(`bili: unknown option ${a}`);
+          process.exit(2);
+        }
+        positional.push(a);
+    }
+  }
+  if (positional.length > 0) {
+    const cmd = positional[0];
+    if (cmd === "start") {
+      command = command === "help" || command === "version" ? command : "start";
+    } else {
+      console.error(`bili: unknown command "${cmd}" (try "bili --help")`);
+      process.exit(2);
+    }
+  }
+  return { command, overrides };
+}
+async function main() {
+  const { command, overrides } = parseArgs(process.argv.slice(2));
+  if (command === "help") {
+    process.stdout.write(HELP);
+    return;
+  }
+  if (command === "version") {
+    process.stdout.write(VERSION + "\n");
+    return;
+  }
+  for (const [k, v] of Object.entries(overrides)) {
+    if (v !== void 0) process.env[k] = v;
+  }
+  const opts = loadOptions();
+  await startServer(opts);
 }
+main().catch((err) => {
+  console.error("bili: failed to start:", err);
+  process.exit(1);
+});
+
+// src/index.ts
+main();
 //# sourceMappingURL=index.js.map