billion-context 0.1.32 → 0.1.34

package/dist/index.js

@@ -43736,7 +43736,7 @@ function defaultConfig(modelContextLimit, overrides = {}) {
       iterationThreshold: 15,
       force: "soft",
       growthRatio: 0.05,
-      growthFloor: Math.max(2e4, Math.round(modelContextLimit * 0.05)),
+      growthFloor: 5e4,
       growthCap: 5e4,
       minGrowthFloor: 2e4,
       minGrowthRatio: 0.45,
@@ -43930,14 +43930,49 @@ function truncateLargeToolOutputs(messages, tokenCount, config, countTokens, opt
   return { messages: updated, truncatedCount, savedTokens };
 }
 var KEEP_LAST_ORPHANED = 0;
+function rangeKey(startRef, endRef) {
+  return `${startRef}::${endRef}`;
+}
+function rewriteCompressText(text, liveKeys) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text ?? "");
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const obj = parsed;
+  const content = obj.content;
+  if (!Array.isArray(content) || content.length === 0) return null;
+  const kept = content.filter((entry) => {
+    if (!entry || typeof entry !== "object") return false;
+    const s3 = typeof entry.startId === "string" ? entry.startId : typeof entry.messageId === "string" ? entry.messageId : "";
+    const e = typeof entry.endId === "string" ? entry.endId : typeof entry.messageId === "string" ? entry.messageId : "";
+    return liveKeys.has(rangeKey(s3, e));
+  });
+  if (kept.length === content.length || kept.length === 0) return null;
+  return JSON.stringify({ ...obj, content: kept });
+}
 function hideConsumedCompressCalls(state, messages) {
-  const activeCallIds = /* @__PURE__ */ new Set();
   const allBlockCallIds = /* @__PURE__ */ new Set();
+  const activeCallIds = /* @__PURE__ */ new Set();
+  const liveRangeKeysByCallId = /* @__PURE__ */ new Map();
+  const legacyLiveByCallId = /* @__PURE__ */ new Set();
   for (const block of state.blocks) {
-    if (block.compressCallId) {
-      allBlockCallIds.add(block.compressCallId);
-      if (block.active) activeCallIds.add(block.compressCallId);
+    if (!block.compressCallId) continue;
+    allBlockCallIds.add(block.compressCallId);
+    if (!block.active) continue;
+    activeCallIds.add(block.compressCallId);
+    if (block.startRef === void 0 || block.endRef === void 0) {
+      legacyLiveByCallId.add(block.compressCallId);
+      continue;
     }
+    let keys = liveRangeKeysByCallId.get(block.compressCallId);
+    if (!keys) {
+      keys = /* @__PURE__ */ new Set();
+      liveRangeKeysByCallId.set(block.compressCallId, keys);
+    }
+    keys.add(rangeKey(block.startRef, block.endRef));
   }
   const lastOrphanedCallIds = [];
   for (let i = messages.length - 1; i >= 0 && lastOrphanedCallIds.length < KEEP_LAST_ORPHANED; i--) {
@@ -43966,6 +44001,16 @@ function hideConsumedCompressCalls(state, messages) {
       hidden++;
       continue;
     }
+    if (message.toolName === "compress" && message.contentType === "tool-call" && message.toolCallId && keepCallIds.has(message.toolCallId)) {
+      const liveKeys = liveRangeKeysByCallId.get(message.toolCallId);
+      if (liveKeys && liveKeys.size > 0 && !legacyLiveByCallId.has(message.toolCallId)) {
+        const rewritten = rewriteCompressText(message.text, liveKeys);
+        if (rewritten !== null) {
+          result.push({ ...message, text: rewritten });
+          continue;
+        }
+      }
+    }
     result.push(message);
   }
   return { messages: result, hidden };
@@ -44199,8 +44244,8 @@ function refNum(ref) {
   const n = parseInt(ref.slice(1), 10);
   return Number.isNaN(n) ? -1 : n;
 }
-function estimateMessageTokens(message) {
-  return Math.ceil((message.text ?? "").length / 4);
+function estimateTextTokens(text) {
+  return Math.ceil(text.length / 4);
 }
 function isToolMessage(message) {
   return message.contentType === "tool-call" || message.contentType === "tool-result";
@@ -44212,7 +44257,7 @@ function isSyntheticOrPruned(message, state) {
   }
   return false;
 }
-function computeProtectedRefs(messages, state, config) {
+function computeProtectedRefs(messages, state, config, countTokens = estimateTextTokens) {
   const preserveN = config.preserveRecentMessages;
   const preserveTokens = config.preserveRecentTokens;
   const result = /* @__PURE__ */ new Set();
@@ -44222,7 +44267,7 @@ function computeProtectedRefs(messages, state, config) {
     if (isNeverPreserveRecent(msg2)) continue;
     const ref = state.messageRefs.byRaw[msg2.id];
     if (!ref || ref === "BLOCKED") continue;
-    visible.push({ ref, tokens: estimateMessageTokens(msg2) });
+    visible.push({ ref, tokens: countTokens(msg2.text ?? "") });
   }
   if (preserveN > 0) {
     for (const m2 of visible.slice(-preserveN)) {
@@ -44247,7 +44292,7 @@ function computeProtectedRefs(messages, state, config) {
   }
   return result;
 }
-function buildCompressibleRanges(messages, state, config, protectedZoneRefs) {
+function buildCompressibleRanges(messages, state, config, protectedZoneRefs, countTokens = estimateTextTokens) {
   const compressibleMsgs = [];
   const protectedMsgs = [];
   const protectedCallIds = collectProtectedToolCallIds(messages, config);
@@ -44260,7 +44305,7 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs) {
       protectedMsgs.push({
         ref,
         refNum: rn2,
-        tokens: estimateMessageTokens(msg2),
+        tokens: countTokens(msg2.text ?? ""),
         tools: msg2.toolName ? [msg2.toolName] : []
       });
       continue;
@@ -44271,7 +44316,7 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs) {
     compressibleMsgs.push({
       ref,
       refNum: rn2,
-      tokens: estimateMessageTokens(msg2),
+      tokens: countTokens(msg2.text ?? ""),
       isTool: isToolMessage(msg2),
       isUser: msg2.role === "user"
     });
@@ -44358,7 +44403,7 @@ function createCore(ports = {}) {
     let tokensCompressed = 0;
     const errors = [];
     const warnings = [];
-    const protectedMessageIds = input.protectedMessageIds ?? computeProtectedRefs(input.messages, input.state, input.config);
+    const protectedMessageIds = input.protectedMessageIds ?? computeProtectedRefs(input.messages, input.state, input.config, countTokens);
     const preExistingCoverage = collectCoverage(state);
     const rangeIndexSets = [];
     for (const spec of input.ranges) {
@@ -44383,29 +44428,25 @@ function createCore(ports = {}) {
       const bMin = b2.indices.length > 0 ? Math.min(...b2.indices) : Infinity;
       return aMin - bMin;
     });
-    for (let i = 1; i < sortedRanges.length; i++) {
-      const prev = sortedRanges[i - 1];
-      const curr = sortedRanges[i];
-      const prevMax = prev.indices.length > 0 ? Math.max(...prev.indices) : -1;
-      const currMin = curr.indices.length > 0 ? Math.min(...curr.indices) : -1;
-      if (prevMax >= currMin && prevMax >= 0) {
-        return {
-          state: input.state,
-          result: {
-            blocksCreated: 0,
-            tokensCompressed: 0,
-            errors: [
-              `content: range (${prev.spec.startRef}..${prev.spec.endRef}) overlaps (${curr.spec.startRef}..${curr.spec.endRef}). Overlapping ranges cannot be compressed in the same batch.`
-            ],
-            warnings: []
-          }
-        };
+    const skipSpecs = /* @__PURE__ */ new Set();
+    let acceptedMaxIndex = -1;
+    for (const entry of sortedRanges) {
+      const entryMax = entry.indices.length > 0 ? Math.max(...entry.indices) : -1;
+      const entryMin = entry.indices.length > 0 ? Math.min(...entry.indices) : -1;
+      if (entryMin >= 0 && entryMin <= acceptedMaxIndex) {
+        skipSpecs.add(entry.spec);
+        warnings.push(
+          `Skipped range (${entry.spec.startRef}..${entry.spec.endRef}) \u2014 overlaps an earlier range in the batch; the earlier range takes precedence. Keep ranges disjoint.`
+        );
+        continue;
       }
+      if (entryMax > acceptedMaxIndex) acceptedMaxIndex = entryMax;
     }
     if (input.config.compress.minCompressRange > 0 && input.ranges.length > 0) {
       let totalRangeChars = 0;
       let hasBlockBoundaryRange = false;
       for (const spec of input.ranges) {
+        if (skipSpecs.has(spec)) continue;
         let resolved;
         try {
           resolved = resolveBoundaries({
@@ -44441,6 +44482,7 @@ function createCore(ports = {}) {
       }
     }
     for (const spec of input.ranges) {
+      if (skipSpecs.has(spec)) continue;
       try {
         const outcome = applySingleRange({
           spec,
@@ -44581,13 +44623,15 @@ var recommendNode = {
     const protectedRefs = computeProtectedRefs(
       io2.messages,
       io2.state,
-      ctx.config
+      ctx.config,
+      ctx.countTokens
     );
     const contextRanges = buildCompressibleRanges(
       io2.messages,
       io2.state,
       ctx.config,
-      protectedRefs
+      protectedRefs,
+      ctx.countTokens
     );
     const nothingToCompress = contextRanges.compressible.length === 0;
     const recommendation = {
@@ -44765,7 +44809,9 @@ function applySingleRange(input) {
     survivedCount: 0,
     generation: "young",
     active: true,
-    compressCallId: input.spec.compressCallId
+    compressCallId: input.spec.compressCallId,
+    startRef: input.spec.startRef,
+    endRef: input.spec.endRef
   };
   input.state.blocks.push(block);
   for (const consumedId of consumedBlockIds) {
@@ -45256,7 +45302,7 @@ function renderNudgeText(decision) {
         breakdownStr,
         "",
         `[TIER ${decision.tier} ${isT2 ? "DISTILLATION" : "CONDENSATION"} TRIGGER]`,
-        isT2 ? `Your tier-1 compression summaries have accumulated. Distill them into a single denser tier-2 summary. Use block IDs as boundaries.` : `Your tier-2 compression summaries have accumulated. Condense them further into a tier-3 ultra-condensed summary. Use block IDs as boundaries.`,
+        isT2 ? `Your tier-1 compression summaries have accumulated. Distill them into a single denser tier-2 summary. Use block IDs as boundaries (startId and endId as bN). Any raw (uncompressed) messages sitting between the boundary blocks are absorbed into the tier-2 block as well \u2014 apply HOW TO COMPRESS to those raw messages and the TIER 2 distillation rules to the existing summaries, so the whole span is covered and nothing is lost.` : `Your tier-2 compression summaries have accumulated. Condense them further into a tier-3 ultra-condensed summary. Use block IDs as boundaries (startId and endId as bN). Any raw (uncompressed) messages sitting between the boundary blocks are absorbed into the tier-3 block as well \u2014 apply HOW TO COMPRESS to those raw messages and the TIER 3 condensation rules to the existing summaries, so the whole span is covered and nothing is lost.`,
         blockList,
         `Example: compress({ content: [{ startId: "${startId}", endId: "${endId}", summary: "..." }] })`,
         "",
@@ -46045,7 +46091,7 @@ function resolveProxyDecision(routes, globalProxy, upstreamUrl, fallback = {}) {
       return { proxy: parsed.url, source: "provider" };
     }
   }
-  if (globalProxy === "") return { source: "direct" };
+  if (globalProxy === "" && fallback.explicitDirect) return { source: "direct" };
   const explicit = parseHttpProxy(globalProxy, fallback.biliPort)?.url;
   if (explicit) return { proxy: explicit, source: fallback.globalSource ?? "global" };
   if (target && matchesNoProxy(target, fallback.noProxy)) return { source: "no-proxy" };
@@ -46283,34 +46329,19 @@ function loadRoutes(env = process.env) {
 function loadOptions(env = process.env) {
   const fileConfig = loadConfigFile();
   const port = parseInt(env.ACP_PORT ?? env.PORT ?? `${fileConfig.port ?? 8787}`, 10);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port ${Number.isNaN(port) ? "(not a number)" : port}; must be 1-65535`);
+  }
   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 (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      for (const [k2, v2] of Object.entries(parsed)) {
-        rejectLegacyRoute(k2, v2);
-        const route = parseRouteEntry(v2);
-        if (route) routes[normalizeUrlKey(k2)] = route;
-      }
-    }
-  }
-  if (fileConfig.providers) {
-    for (const [k2, v2] of Object.entries(fileConfig.providers)) {
-      rejectLegacyRoute(k2, v2);
-      const route = parseRouteEntry(v2);
-      if (route && !routes[normalizeUrlKey(k2)]) routes[normalizeUrlKey(k2)] = route;
-    }
-  }
+  const routes = loadRoutes(env);
   const modelContextLimit = parseInt(env.ACP_MODEL_CONTEXT_LIMIT ?? `${fileConfig.modelContextLimit ?? 2e5}`, 10);
   const biliProxy = nonEmpty(env.BILI_UPSTREAM_PROXY);
   const webProxy = nonEmpty(fileConfig.upstreamProxy);
   const configProxy = nonEmpty(fileConfig.proxy);
-  const proxyMode = parseUpstreamProxyMode(
-    env.BILI_UPSTREAM_PROXY_MODE ?? fileConfig.upstreamProxyMode ?? (webProxy ? "manual" : void 0)
-  );
+  const rawProxyMode = env.BILI_UPSTREAM_PROXY_MODE ?? fileConfig.upstreamProxyMode ?? (webProxy ? "manual" : void 0);
+  const proxyMode = parseUpstreamProxyMode(rawProxyMode);
+  const explicitDirect = proxyMode === "direct" && rawProxyMode === "direct";
   const proxy = biliProxy ?? (proxyMode === "direct" ? "" : proxyMode === "manual" ? webProxy ?? configProxy : configProxy);
   const proxySource = biliProxy ? "bili-env" : proxyMode === "direct" ? "direct" : proxyMode === "manual" && webProxy ? "web-manual" : configProxy ? "config" : "auto";
   const httpProxy = nonEmpty(env.HTTP_PROXY ?? env.http_proxy);
@@ -46322,8 +46353,9 @@ function loadOptions(env = process.env) {
     ...httpsProxy ? { httpsProxy } : {},
     ...allProxy ? { allProxy } : {},
     ...noProxy ? { noProxy } : {},
-    biliPort: Number.isFinite(port) ? port : 8787,
-    globalSource: proxySource
+    biliPort: port,
+    globalSource: proxySource,
+    explicitDirect
   };
   validateHttpProxy(proxy, proxyFallback.biliPort);
   for (const [url, route] of Object.entries(routes)) {
@@ -46334,7 +46366,7 @@ function loadOptions(env = process.env) {
     }
   }
   return {
-    port: Number.isFinite(port) ? port : 8787,
+    port,
     host,
     upstream,
     routes,
@@ -46544,15 +46576,30 @@ async function contextFromRegistry(model, host) {
 // src/fetch-util.ts
 var MAX_REQUEST_BYTES = 100 * 1024 * 1024;
 var UPSTREAM_TIMEOUT_MS = 10 * 60 * 1e3;
-async function fetchWithTimeout(url, opts, timeoutMs = UPSTREAM_TIMEOUT_MS) {
+async function fetchWithTimeout(url, opts, timeoutMs = UPSTREAM_TIMEOUT_MS, externalSignal) {
   const controller = new AbortController();
   const timer2 = setTimeout(() => controller.abort(), timeoutMs);
+  let onExternalAbort = null;
+  if (externalSignal) {
+    if (externalSignal.aborted) controller.abort();
+    else {
+      onExternalAbort = () => controller.abort();
+      externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+    }
+  }
   try {
     const finalOpts = { ...opts, signal: controller.signal };
     const response = await fetch(url, finalOpts);
-    return { response, clearTimer: () => clearTimeout(timer2) };
+    return {
+      response,
+      clearTimer: () => {
+        clearTimeout(timer2);
+        if (onExternalAbort && externalSignal) externalSignal.removeEventListener("abort", onExternalAbort);
+      }
+    };
   } catch (e) {
     clearTimeout(timer2);
+    if (onExternalAbort && externalSignal) externalSignal.removeEventListener("abort", onExternalAbort);
     throw e;
   }
 }
@@ -47562,7 +47609,7 @@ function getStore() {
 
 // src/session.ts
 var sessions = /* @__PURE__ */ new Map();
-var MAX_SESSIONS = Number.parseInt(process.env.BILI_MAX_SESSIONS ?? "256", 10) || 256;
+var MAX_SESSIONS = Math.max(1, Number.parseInt(process.env.BILI_MAX_SESSIONS ?? "256", 10) || 256);
 var initialized = false;
 async function initSessions() {
   if (initialized) return;
@@ -47597,7 +47644,12 @@ function getSession(id, meta) {
     sessions.set(id, reloaded);
     return reloaded;
   }
-  if (sessions.size >= MAX_SESSIONS) evictOldest();
+  if (sessions.size >= MAX_SESSIONS) {
+    const evicted = evictOldest();
+    if (!evicted) {
+      throw new Error(`session pool exhausted (MAX_SESSIONS=${MAX_SESSIONS}; all in-flight)`);
+    }
+  }
   const session = {
     id,
     meta: { protocol: meta?.protocol, upstreamOrigin: meta?.upstreamOrigin, label: meta?.label },
@@ -47681,13 +47733,14 @@ function evictOldest() {
       oldestId = id;
     }
   }
-  if (!oldestId) return;
+  if (!oldestId) return false;
   const s3 = sessions.get(oldestId);
   const ok = getStore().flushSync(s3);
   if (!ok && !s3.persisted) {
-    return;
+    return false;
   }
   sessions.delete(oldestId);
+  return true;
 }
 async function flushAllSessions() {
   await getStore().flushAll(sessions.values());
@@ -47968,15 +48021,38 @@ var MUTATING_PROXY_TOOLS = /* @__PURE__ */ new Set([
   COMPRESS_TOOL_NAME,
   DECOMPRESS_TOOL_NAME
 ]);
-var READONLY_PROXY_TOOLS = /* @__PURE__ */ new Set([
-  SEARCH_CONTEXT_TOOL_NAME,
-  ACP_STATUS_TOOL_NAME
-]);
 
 // src/decompress-shared.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { mkdirSync as mkdirSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname3, join as join2 } from "path";
 import { tmpdir } from "os";
+var trackedTempFiles = [];
+function getDecompressTmpCap() {
+  const raw = process.env.BILI_DECOMPRESS_TMP_CAP;
+  const parsed = raw ? Number.parseInt(raw, 10) : NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 50;
+}
+function reapTempFiles() {
+  const cap = getDecompressTmpCap();
+  while (trackedTempFiles.length > cap) {
+    trackedTempFiles.sort((a, b2) => a.mtimeMs - b2.mtimeMs);
+    const oldest = trackedTempFiles.shift();
+    if (!oldest) break;
+    try {
+      unlinkSync2(oldest.path);
+    } catch {
+    }
+  }
+}
+process.on("beforeExit", () => {
+  for (const f2 of trackedTempFiles) {
+    try {
+      unlinkSync2(f2.path);
+    } catch {
+    }
+  }
+  trackedTempFiles.length = 0;
+});
 function resolveDecompress(args, ctx) {
   const rawBlockId = args.blockId;
   if (typeof rawBlockId !== "string" || rawBlockId.length === 0) {
@@ -48009,6 +48085,8 @@ function resolveDecompress(args, ctx) {
     try {
       mkdirSync4(dirname3(outPath), { recursive: true });
       writeFileSync3(outPath, body, "utf8");
+      trackedTempFiles.push({ path: outPath, mtimeMs: Date.now() });
+      reapTempFiles();
       return `${header}
 Content (${body.length} chars) written to: ${outPath}
 Use the read tool to access it.`;
@@ -48022,12 +48100,6 @@ ${body.slice(0, 4e3)}...`;
 ${body}`;
 }
 
-// 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
 function executeAnthropicProxyTool(toolName, args, ctx) {
   if (toolName === COMPRESS_TOOL_NAME) {
@@ -48191,7 +48263,7 @@ function renderPage(origin, version2) {
 }
 
 // src/web/api.ts
-import { closeSync, fsyncSync, mkdirSync as mkdirSync5, openSync, renameSync as renameSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
+import { closeSync, fsyncSync, mkdirSync as mkdirSync5, openSync, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname4 } from "path";
 import { randomUUID } from "crypto";
 function readConfig() {
@@ -48224,7 +48296,7 @@ function atomicWriteConfig(config) {
   } catch (error) {
     if (descriptor !== void 0) closeSync(descriptor);
     try {
-      unlinkSync2(tempPath);
+      unlinkSync3(tempPath);
     } catch {
     }
     throw error;
@@ -48372,122 +48444,6 @@ function reapOrphanBlocks(session, visible, deactivate) {
 }
 
 // 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;
-    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((b2) => {
-      const topic = b2.topic ?? "(no topic)";
-      const preview = b2.summary.length > 200 ? b2.summary.slice(0, 200) + "..." : b2.summary;
-      return `${b2.blockId} (T${b2.tier}) "${topic}"
-  ${preview}`;
-    });
-    return `Found ${blocks.length} block(s) for "${query}":
-
-${lines.join("\n\n")}`;
-  }
-  if (toolName === "acp_status") {
-    return buildStatusReport(ctx.session.state, ctx.messages, estimateTokensFast);
-  }
-  return `[Unknown proxy tool: ${toolName}]`;
-}
-function classifySseEvent(eventStr) {
-  const dataLine = eventStr.split("\n").find((l) => l.startsWith("data:"));
-  if (!dataLine) return {};
-  const jsonStr = dataLine.slice(5).trim();
-  if (jsonStr === "[DONE]") return { done: true };
-  let parsed;
-  try {
-    parsed = JSON.parse(jsonStr);
-  } catch {
-    return {};
-  }
-  const choices = parsed.choices;
-  const choice = choices?.[0];
-  if (!choice) return {};
-  const delta = choice.delta;
-  const finishReason = choice.finish_reason;
-  const out = {};
-  if (finishReason) {
-    out.finishReason = finishReason;
-    out.usage = parsed.usage ?? null;
-  }
-  if (!delta) return out;
-  if (delta.tool_calls) {
-    const tcs = delta.tool_calls;
-    const toolCalls = [];
-    for (const tc of tcs) {
-      const idx = typeof tc.index === "number" ? tc.index : 0;
-      const fn = tc.function;
-      const name = typeof fn?.name === "string" ? fn.name : "";
-      const id = typeof tc.id === "string" ? tc.id : "";
-      const args = typeof fn?.arguments === "string" ? fn.arguments : "";
-      toolCalls.push({ index: idx, id, name, arguments: args });
-    }
-    if (typeof delta.content === "string" && delta.content.length > 0) {
-      out.contentDelta = delta.content;
-    }
-    out.toolCalls = toolCalls;
-    return out;
-  }
-  if (typeof delta.content === "string" && delta.content.length > 0) {
-    out.contentDelta = delta.content;
-    out.yieldChunk = Buffer.from(eventStr + "\n\n", "utf8");
-    return out;
-  }
-  if (delta.role || Object.keys(delta).length === 0 && !finishReason) {
-    out.yieldChunk = Buffer.from(eventStr + "\n\n", "utf8");
-  }
-  return out;
-}
-function buildToolCallSse(base, tc) {
-  return `data: ${JSON.stringify({
-    ...base,
-    choices: [{
-      index: 0,
-      delta: {
-        tool_calls: [{
-          index: tc.index,
-          id: tc.id,
-          type: "function",
-          function: { name: tc.name, arguments: tc.arguments }
-        }]
-      },
-      finish_reason: null
-    }]
-  })}
-
-`;
-}
-function buildFinishSse(base, finishReason, usage) {
-  return `data: ${JSON.stringify({
-    ...base,
-    choices: [{ index: 0, delta: {}, finish_reason: finishReason }],
-    ...usage ? { usage } : {}
-  })}
-
-`;
-}
-function buildContentSse(id, model, content) {
-  return `data: ${JSON.stringify({
-    id,
-    object: "chat.completion.chunk",
-    created: Date.now(),
-    model,
-    choices: [{ index: 0, delta: { content }, finish_reason: null }]
-  })}
-
-`;
-}
 function buildVisibilityMarker(toolName, result) {
   const lines = result.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
   const failed = lines.some(
@@ -48500,10 +48456,10 @@ function buildVisibilityMarker(toolName, result) {
     acp_status: "\u{1F4CA}"
   };
   const icon = failed ? "\u274C" : icons[toolName] ?? "\u{1F4E6}";
-  if (toolName === "acp_status" && lines.length >= 2) {
-    const dataLine = lines.slice(0, 3).join(" | ").replace(/\s+/g, " ");
+  if (toolName === "acp_status") {
     return `
-${icon} [ACP] ${dataLine}
+${icon} [ACP] acp_status result:
+${result.trim()}
 `;
   }
   const inner = (lines[0] ?? "").replace(/^\[/, "").replace(/\]$/, "").trim();
@@ -48511,250 +48467,12 @@ ${icon} [ACP] ${dataLine}
 ${icon} [ACP] ${inner}
 `;
 }
-async function* compressLoopStream(initialUpstream, ctx, requestBody, requestOptions) {
-  let upstream = initialUpstream;
-  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 p2 = JSON.parse(dataLine.slice(5).trim());
-                      if (typeof p2.id === "string") responseId = p2.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, b2) => a - b2);
-      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 mutatingProxy = proxyCalls.filter((tc) => MUTATING_PROXY_TOOLS.has(tc.name));
-      const readonlyProxy = proxyCalls.filter((tc) => READONLY_PROXY_TOOLS.has(tc.name));
-      const hasMutatingOnly = mutatingProxy.length > 0 && realCalls.length === 0;
-      if (usage) {
-        const prompt = usage.prompt_tokens ?? usage.input_tokens;
-        const det = usage.prompt_tokens_details ?? usage.prompt_cache_hit_tokens;
-        const cached = det?.cached_tokens ?? usage.prompt_cache_hit_tokens;
-        const out = usage.completion_tokens ?? usage.output_tokens;
-        if (typeof prompt === "number") {
-          const ch = typeof cached === "number" ? cached : 0;
-          log("info", `[acp-usage] round ${loopCount} input=${prompt} cached=${typeof cached === "number" ? cached : "?"} output=${out ?? "?"}${ch > 0 ? ` (cache hit ${Math.round(ch / prompt * 100)}%)` : ""}`);
-          ctx.session.stats.inputTokens += prompt;
-          ctx.session.stats.lastInputTokens = prompt + (typeof cached === "number" ? cached : 0);
-          if (typeof cached === "number") ctx.session.stats.cachedTokens += cached;
-          if (typeof out === "number") ctx.session.stats.outputTokens += out;
-          ctx.session.stats.cacheSamples += 1;
-        }
-      }
-      if (!hasMutatingOnly) {
-        for (const tc of readonlyProxy) {
-          let args = {};
-          try {
-            args = JSON.parse(tc.arguments);
-          } catch {
-            args = {};
-          }
-          let result;
-          try {
-            result = executeProxyTool(tc.name, args, ctx);
-          } catch (e) {
-            result = `[${tc.name} FAILED: ${e instanceof Error ? e.message : String(e)}]`;
-          }
-          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"
-          );
-        }
-        for (const tc of realCalls) {
-          yield Buffer.from(buildToolCallSse(makeBase(), tc), "utf8");
-        }
-        const fr2 = realCalls.length > 0 ? "tool_calls" : finishReason ?? "stop";
-        yield Buffer.from(buildFinishSse(makeBase(), fr2, 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),
-        ...ctx.proxyUrl ? { dispatcher: proxyDispatcher(ctx.proxyUrl) } : {}
-      });
-      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-anthropic.ts
-function executeProxyTool2(toolName, args, ctx) {
+// src/loop/core.ts
+var MAX_LOOP_ROUNDS = 10;
+function executeProxyTool(toolName, args, ctx, callId) {
   if (toolName === "compress") {
-    return applyRanges(parseCompressInput(args), ctx);
+    return applyRanges(parseCompressInput(args, callId), ctx);
   }
   if (toolName === "decompress") {
     return resolveDecompress(args, ctx);
@@ -48776,941 +48494,62 @@ function executeProxyTool2(toolName, args, ctx) {
 ${lines.join("\n\n")}`;
   }
   if (toolName === "acp_status") {
-    return buildStatusReport(ctx.session.state, ctx.messages, estimateTokensFast);
+    return handleAcpStatus(args, ctx);
   }
   return `[Unknown proxy tool: ${toolName}]`;
 }
-function parseAnthropicSse(eventStr) {
-  const lines = eventStr.split("\n");
-  let type = "";
-  const dataLines = [];
-  for (const l of lines) {
-    if (l.startsWith("event:")) {
-      type = l.slice(6).trim();
-    } else if (l.startsWith("data:")) {
-      dataLines.push(l.slice(5).replace(/^ /, ""));
-    }
-  }
-  if (!type) return null;
-  const jsonStr = dataLines.join("\n").trim();
-  if (!jsonStr) return { type, data: {} };
-  try {
-    return { type, data: JSON.parse(jsonStr) };
-  } catch {
-    return { type, data: {} };
+function handleAcpStatus(args, ctx) {
+  const scope = typeof args.scope === "string" ? args.scope : void 0;
+  const view = typeof args.view === "string" ? args.view : void 0;
+  const tool = typeof args.tool === "string" ? args.tool : void 0;
+  const sort = typeof args.sort === "string" ? args.sort : void 0;
+  const limit = typeof args.limit === "number" ? args.limit : void 0;
+  const base = buildStatusReport(ctx.session.state, ctx.messages, estimateTokensFast, { scope, view, tool, sort, limit });
+  if (scope) return base;
+  const nudge = ctx.nudge;
+  const ranges = nudge?.compressibleRanges ?? [];
+  const protectedRanges = nudge?.protectedRanges ?? [];
+  const extra = [];
+  if (nudge) {
+    extra.push("");
+    extra.push(nudge.shouldInject ? `Nudge: ACTIVE \u2014 ${nudge.reason}` : `Nudge: idle \u2014 ${nudge.reason}`);
+  }
+  if (ranges.length > 0 || protectedRanges.length > 0) {
+    extra.push("");
+    extra.push(formatRanges(ranges, protectedRanges));
+  }
+  return extra.length > 0 ? `${base}
+${extra.join("\n")}` : base;
+}
+function recordUsage(ctx, usage, round) {
+  const prompt = usage.inputTokens;
+  const cached = usage.cachedTokens;
+  const out = usage.outputTokens;
+  if (typeof prompt === "number") ctx.session.stats.inputTokens += prompt;
+  ctx.session.stats.lastInputTokens = (typeof prompt === "number" ? prompt : 0) + (typeof cached === "number" ? cached : 0);
+  if (typeof cached === "number") {
+    ctx.session.stats.cachedTokens += cached;
+    ctx.session.stats.cacheSamples += 1;
   }
+  if (typeof out === "number") ctx.session.stats.outputTokens += out;
+  const hitPct = typeof prompt === "number" && typeof cached === "number" && prompt + cached > 0 ? Math.round(cached / (prompt + cached) * 100) : 0;
+  ctx.log(
+    `[acp-usage] round ${round} input=${ctx.session.stats.lastInputTokens} cached=${cached ?? 0} (cache hit ${hitPct}%)`
+  );
 }
-function buildTextBlockSse(index, text) {
-  return `event: content_block_start
-data: ${JSON.stringify({ type: "content_block_start", index, content_block: { type: "text", text: "" } })}
-
-event: content_block_delta
-data: ${JSON.stringify({ type: "content_block_delta", index, delta: { type: "text_delta", text } })}
-
-event: content_block_stop
-data: ${JSON.stringify({ type: "content_block_stop", index })}
-
-`;
-}
-function buildTerminalSse(stopReason, outputTokens, inputTokens, cachedTokens, messageId, model) {
-  const usage = {
-    input_tokens: inputTokens,
-    output_tokens: outputTokens,
-    cache_read_input_tokens: cachedTokens
-  };
-  const extra = {};
-  if (messageId) extra.id = messageId;
-  if (model) extra.model = model;
-  return `event: message_delta
-data: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: stopReason, stop_sequence: null }, usage, ...extra })}
-
-event: message_stop
-data: ${JSON.stringify({ type: "message_stop" })}
-
-`;
-}
-function remapIndex(json, oldIndex, newIndex) {
-  return json.replaceAll(`"index":${oldIndex}`, `"index":${newIndex}`).replaceAll(`"index": ${oldIndex}`, `"index": ${newIndex}`);
-}
-function safeParse2(s3) {
-  try {
-    const v2 = JSON.parse(s3);
-    return typeof v2 === "object" && v2 ? v2 : {};
-  } catch {
-    return {};
-  }
-}
-async function* compressLoopAnthropicStream(initialUpstream, ctx, requestBody, requestOptions) {
-  let upstream = initialUpstream;
-  let activeClearTimer = null;
-  try {
-    const model = requestBody.model ?? void 0;
-    let messageId;
-    let clientIndex = 0;
-    let totalOutputTokens = 0;
-    let totalInputTokens = 0;
-    let totalCachedTokens = 0;
-    for (let loopCount = 1; ; loopCount++) {
-      if (loopCount > 10) {
-        ctx.log("[acp-proxy: anthropic compress loop limit (10) reached, finishing]");
-        yield Buffer.from(buildTerminalSse("end_turn", totalOutputTokens, totalInputTokens, totalCachedTokens, messageId, model), "utf8");
-        return;
-      }
-      const isFirstRound = loopCount === 1;
-      const state = { clientIndex, toolBlocks: /* @__PURE__ */ new Map(), indexMap: /* @__PURE__ */ new Map() };
-      let hasRealToolUse = false;
-      let roundText = "";
-      let roundStopReason;
-      const reader = upstream.getReader();
-      const decoder = new TextDecoder("utf-8");
-      let sseBuffer = "";
-      const cbs = {
-        onRealToolUse: () => {
-          hasRealToolUse = true;
-        },
-        onText: (t) => {
-          roundText += t;
-        },
-        onOutputTokens: (n) => {
-          totalOutputTokens += n;
-        },
-        onMessageId: (id) => {
-          if (!messageId) messageId = id;
-        },
-        onStopReason: (r) => {
-          roundStopReason = r;
-        },
-        onCacheUsage: (input, cached) => {
-          if (typeof input === "number") {
-            ctx.session.stats.inputTokens += input;
-            ctx.session.stats.lastInputTokens = input + (typeof cached === "number" ? cached : 0);
-            totalInputTokens += input;
-          }
-          if (typeof cached === "number") {
-            ctx.session.stats.cachedTokens += cached;
-            ctx.session.stats.cacheSamples += 1;
-            totalCachedTokens += cached;
-          }
-        }
-      };
-      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;
-            for (const b2 of routeAnthropicEvent(eventStr, isFirstRound, state, cbs)) {
-              yield b2;
-            }
-          }
-        }
-        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;
-          for (const b2 of routeAnthropicEvent(eventStr, isFirstRound, state, cbs)) {
-            yield b2;
-          }
-        }
-      } finally {
-        reader.releaseLock();
-      }
-      clientIndex = state.clientIndex;
-      const proxyCalls = [...state.toolBlocks.values()].filter((b2) => PROXY_TOOL_NAMES.has(b2.name));
-      const mutatingProxy = proxyCalls.filter((b2) => MUTATING_PROXY_TOOLS.has(b2.name));
-      const readonlyProxy = proxyCalls.filter((b2) => READONLY_PROXY_TOOLS.has(b2.name));
-      const hasMutatingOnly = mutatingProxy.length > 0 && !hasRealToolUse;
-      if (!hasMutatingOnly) {
-        for (const tc of readonlyProxy) {
-          const args = safeParse2(tc.json);
-          let result;
-          try {
-            result = executeProxyTool2(tc.name, args, ctx);
-          } catch (e) {
-            result = `[${tc.name} FAILED: ${e instanceof Error ? e.message : String(e)}]`;
-          }
-          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(buildTextBlockSse(clientIndex, buildVisibilityMarker(tc.name, result)), "utf8");
-          clientIndex++;
-        }
-        const stop = hasRealToolUse ? "tool_use" : roundStopReason ?? "end_turn";
-        yield Buffer.from(buildTerminalSse(stop, totalOutputTokens, totalInputTokens, totalCachedTokens, messageId, model), "utf8");
-        return;
-      }
-      const names = proxyCalls.map((c) => c.name).join(", ");
-      ctx.log(`[acp-proxy: anthropic round ${loopCount} \u2014 ${proxyCalls.length} proxy call(s): ${names}]`);
-      const messages = requestBody.messages ?? [];
-      const assistantContent = [];
-      if (roundText.length > 0) {
-        assistantContent.push({ type: "text", text: roundText });
-      }
-      for (const tc of proxyCalls) {
-        assistantContent.push({ type: "tool_use", id: tc.id, name: tc.name, input: safeParse2(tc.json) });
-      }
-      messages.push({ role: "assistant", content: assistantContent });
-      for (const tc of proxyCalls) {
-        const args = safeParse2(tc.json);
-        const result = executeProxyTool2(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(buildTextBlockSse(clientIndex, buildVisibilityMarker(tc.name, result)), "utf8");
-        clientIndex++;
-        messages.push({
-          role: "user",
-          content: [{ type: "tool_result", tool_use_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),
-        ...ctx.proxyUrl ? { dispatcher: proxyDispatcher(ctx.proxyUrl) } : {}
-      });
-      if (!resp.ok || !resp.body) {
-        const errText = await resp.text().catch(() => "upstream error");
-        ctx.log(`[acp-proxy: anthropic compress loop upstream error ${resp.status}: ${errText.slice(0, 200)}]`);
-        yield Buffer.from(buildTextBlockSse(clientIndex, `
-[acp-proxy: upstream error ${resp.status}: ${errText.slice(0, 200)}]
-`), "utf8");
-        yield Buffer.from(buildTerminalSse("end_turn", totalOutputTokens, totalInputTokens, totalCachedTokens, messageId, model), "utf8");
-        return;
-      }
-      upstream = resp.body;
-      if (activeClearTimer) activeClearTimer();
-      activeClearTimer = clearTimer;
-    }
-  } finally {
-    if (activeClearTimer) {
-      activeClearTimer();
-      activeClearTimer = null;
-    }
-  }
-}
-function routeAnthropicEvent(eventStr, isFirstRound, state, cb) {
-  const parsed = parseAnthropicSse(eventStr);
-  if (!parsed) return [];
-  const { type, data } = parsed;
-  if (type === "message_start") {
-    const msg2 = data.message ?? {};
-    if (typeof msg2.id === "string") cb.onMessageId(msg2.id);
-    const u2 = msg2.usage ?? {};
-    cb.onCacheUsage(u2.input_tokens, u2.cache_read_input_tokens);
-    return isFirstRound ? [Buffer.from(eventStr + "\n\n", "utf8")] : [];
-  }
-  if (type === "ping") {
-    return [Buffer.from(eventStr + "\n\n", "utf8")];
-  }
-  if (type === "content_block_start") {
-    const upstreamIndex = data.index ?? 0;
-    const block = data.content_block ?? {};
-    if (block.type === "tool_use") {
-      const name = typeof block.name === "string" ? block.name : "";
-      const id = typeof block.id === "string" ? block.id : `toolu_${upstreamIndex}`;
-      if (PROXY_TOOL_NAMES.has(name)) {
-        state.toolBlocks.set(upstreamIndex, { id, name, json: "" });
-        return [];
-      }
-      cb.onRealToolUse();
-    }
-    const ci2 = state.clientIndex++;
-    state.indexMap.set(upstreamIndex, ci2);
-    if (isFirstRound) return [Buffer.from(eventStr + "\n\n", "utf8")];
-    return [Buffer.from(remapIndex(eventStr + "\n\n", upstreamIndex, ci2), "utf8")];
-  }
-  if (type === "content_block_delta") {
-    const upstreamIndex = data.index ?? 0;
-    const delta = data.delta ?? {};
-    if (state.toolBlocks.has(upstreamIndex)) {
-      if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
-        state.toolBlocks.get(upstreamIndex).json += delta.partial_json;
-      }
-      return [];
-    }
-    if (delta.type === "text_delta" && typeof delta.text === "string") cb.onText(delta.text);
-    if (isFirstRound) return [Buffer.from(eventStr + "\n\n", "utf8")];
-    const ci2 = state.indexMap.get(upstreamIndex) ?? upstreamIndex;
-    return [Buffer.from(remapIndex(eventStr + "\n\n", upstreamIndex, ci2), "utf8")];
-  }
-  if (type === "content_block_stop") {
-    const upstreamIndex = data.index ?? 0;
-    if (state.toolBlocks.has(upstreamIndex)) return [];
-    if (isFirstRound) return [Buffer.from(eventStr + "\n\n", "utf8")];
-    const ci2 = state.indexMap.get(upstreamIndex) ?? upstreamIndex;
-    return [Buffer.from(remapIndex(eventStr + "\n\n", upstreamIndex, ci2), "utf8")];
-  }
-  if (type === "message_delta") {
-    const u2 = data.usage ?? {};
-    const out = u2.output_tokens;
-    if (typeof out === "number") cb.onOutputTokens(out);
-    cb.onCacheUsage(
-      u2.input_tokens,
-      u2.cache_read_input_tokens
-    );
-    const d = data.delta ?? {};
-    if (typeof d.stop_reason === "string") cb.onStopReason(d.stop_reason);
-    return [];
-  }
-  if (type === "message_stop") {
-    return [];
-  }
-  return isFirstRound ? [Buffer.from(eventStr + "\n\n", "utf8")] : [];
-}
-
-// src/compress-loop-responses.ts
-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 executeProxyTool3(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((b2) => {
-      const topic = b2.topic ?? "(no topic)";
-      const preview = b2.summary.length > 200 ? b2.summary.slice(0, 200) + "..." : b2.summary;
-      return `${b2.blockId} (T${b2.tier}) "${topic}"
-  ${preview}`;
-    });
-    return `Found ${blocks.length} block(s) for "${query}":
-
-${lines.join("\n\n")}`;
-  }
-  if (toolName === "acp_status") {
-    return buildStatusReport(ctx.session.state, ctx.messages, estimateTokensFast);
-  }
-  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 v2 = l.slice(5);
-      if (v2.startsWith(" ")) v2 = v2.slice(1);
-      parts.push(v2);
-    }
-  }
-  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;
-      }
-      if (item?.type === "custom_tool_call") out.noBuffer = true;
-      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;
-      }
-      if (item?.type === "custom_tool_call") {
-        out.noBuffer = true;
-        out.customToolCallDone = true;
-      }
-      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:
-      if (type.startsWith("response.custom_tool_call.")) out.noBuffer = true;
-      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
-  })}
-
-`;
-}
-function buildFailed(responseObj) {
-  const id = responseObj?.id ?? `resp-failed-${Date.now()}`;
-  const resp = { ...responseObj ?? {}, id, status: "failed", error: { code: "server_error", message: "upstream returned empty response" } };
-  return `event: response.failed
-data: ${JSON.stringify({
-    type: "response.failed",
-    response: resp
-  })}
-
-`;
-}
-function responsesJsonOutput(response) {
-  const textParts = [];
-  const calls = [];
-  for (const item of Array.isArray(response.output) ? response.output : []) {
-    if (!item || typeof item !== "object") continue;
-    const value = item;
-    if (value.type === "message") {
-      for (const part of Array.isArray(value.content) ? value.content : []) {
-        if (part && typeof part === "object" && part.type === "output_text") {
-          textParts.push(part);
-        }
-      }
-    } else if (value.type === "function_call") {
-      calls.push({
-        itemId: typeof value.id === "string" ? value.id : "",
-        callId: typeof value.call_id === "string" ? value.call_id : "",
-        name: typeof value.name === "string" ? value.name : "",
-        arguments: typeof value.arguments === "string" ? value.arguments : ""
-      });
-    }
-  }
-  return {
-    text: textParts.map((part) => typeof part.text === "string" ? part.text : "").join(""),
-    textParts,
-    calls
-  };
-}
-function replaceResponsesJsonText(parts, text) {
-  parts.forEach((part, index) => {
-    part.text = index === 0 ? text : "";
-  });
-}
-function surfaceReadonlyJson(current, proxyCalls, ctx) {
-  const markers = [];
-  for (const call of proxyCalls) {
-    if (MUTATING_PROXY_TOOLS.has(call.name)) continue;
-    let args = {};
-    try {
-      args = JSON.parse(call.arguments);
-    } catch {
-      args = {};
-    }
-    let result;
-    try {
-      result = executeProxyTool3(call.name, args, ctx);
-      ctx.log(`[acp-proxy: responses JSON ${call.name} (read-only) \u2192 ${result.slice(0, 120).replace(/\n/g, " ")}]`);
-    } catch (e) {
-      result = `\u274C [ACP] ${call.name} FAILED: ${String(e)}`;
-      ctx.log(`[acp-proxy: responses JSON ${call.name} (read-only) FAILED: ${String(e)}]`);
-    }
-    markers.push(buildVisibilityMarker(call.name, result));
-  }
-  if (markers.length === 0) return current;
-  const out = Array.isArray(current.output) ? [...current.output] : [];
-  out.push({ type: "message", id: `msg_acp_ro_${Date.now()}_${markers.length}`, role: "assistant", content: [{ type: "output_text", text: markers.join("\n") }] });
-  return { ...current, output: out };
-}
-async function compressLoopResponsesJson(initialResponse, ctx, requestBody, requestOptions) {
-  let current = initialResponse;
-  for (let loopCount = 1; loopCount <= 5; loopCount++) {
-    const output = responsesJsonOutput(current);
-    const extracted = extractTextTriggers(output.text);
-    const allCalls = [...output.calls, ...extracted.calls].filter((call) => call.name.length > 0);
-    const proxyCalls = allCalls.filter((call) => PROXY_TOOL_NAMES.has(call.name));
-    const realCalls = allCalls.filter((call) => !PROXY_TOOL_NAMES.has(call.name));
-    const mutatingProxy = proxyCalls.filter((call) => MUTATING_PROXY_TOOLS.has(call.name));
-    if (mutatingProxy.length === 0 || realCalls.length > 0) {
-      if (proxyCalls.length > 0) {
-        replaceResponsesJsonText(output.textParts, extracted.clean);
-        current = surfaceReadonlyJson(current, proxyCalls, ctx);
-      }
-      return current;
-    }
-    const inputItems = Array.isArray(requestBody.input) ? [...requestBody.input] : [];
-    if (extracted.clean.trim()) {
-      inputItems.push({ type: "message", role: "assistant", content: [{ type: "output_text", text: extracted.clean }] });
-    }
-    for (const call of proxyCalls) {
-      let args = {};
-      try {
-        args = JSON.parse(call.arguments);
-      } catch (error) {
-        log("warn", `[acp-compress-args] ${call.name} JSON.parse failed: ${String(error)}`);
-      }
-      const result = executeProxyTool3(call.name, args, ctx);
-      ctx.log(`[acp-proxy: responses JSON ${call.name} \u2192 ${result.slice(0, 120).replace(/\n/g, " ")}]`);
-      inputItems.push({ type: "message", role: "user", content: buildVisibilityMarker(call.name, result) });
-    }
-    requestBody.input = inputItems;
-    const { response, clearTimer } = await fetchWithTimeout(requestOptions.url, {
-      method: "POST",
-      headers: requestOptions.headers,
-      body: JSON.stringify(requestBody),
-      ...ctx.proxyUrl ? { dispatcher: proxyDispatcher(ctx.proxyUrl) } : {}
-    });
-    try {
-      if (!response.ok) {
-        const detail = await response.text().catch(() => "upstream error");
-        throw new Error(`responses compress loop upstream error ${response.status}: ${detail.slice(0, 200)}`);
-      }
-      current = await response.json();
-    } finally {
-      clearTimer();
-    }
-  }
-  ctx.log("[acp-proxy: responses JSON compress loop limit (5) reached]");
-  return current;
-}
-async function* compressLoopResponsesStream(initialUpstream, ctx, requestBody, requestOptions) {
-  const textProtocol = ctx.textProtocol ?? TEXT_PROTOCOL;
-  let upstream = initialUpstream;
-  let loopCount = 0;
-  let responseObj = null;
-  let activeClearTimer = null;
-  let nextOutputIndex = 0;
-  for (; ; ) {
-    loopCount++;
-    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 fcByItemId = /* @__PURE__ */ new Map();
-    let contentText = "";
-    let customToolCalls = 0;
-    let completed = false;
-    let terminalKind = null;
-    let terminalRaw = 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 });
-        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 = classifyResponsesSseEvent(eventStr);
-          if (d.yieldChunk && (isFirstRound || !d.isMeta) && !(textProtocol && !d.isMeta && !d.noBuffer)) {
-            yield d.yieldChunk;
-          }
-          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.customToolCallDone) customToolCalls++;
-          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 ?? "?";
-              log("info", `[acp-usage] round ${loopCount} input=${prompt} cached=${cached} output=${out}${cached !== "?" && cached !== 0 && prompt !== "?" ? ` (cache hit ${Math.round(Number(cached) / Number(prompt) * 100)}%)` : ""}`);
-              if (typeof prompt === "number") {
-                ctx.session.stats.inputTokens += prompt;
-                ctx.session.stats.lastInputTokens = prompt + (typeof cached === "number" ? cached : 0);
-                if (typeof cached === "number") ctx.session.stats.cachedTokens += cached;
-                if (typeof out === "number") ctx.session.stats.outputTokens += out;
-                ctx.session.stats.cacheSamples += 1;
-              }
-            }
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-      if (activeClearTimer) {
-        activeClearTimer();
-        activeClearTimer = null;
-      }
-    }
-    if (textProtocol) {
-      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 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));
-    const readonlyProxy = proxyCalls.filter((c) => READONLY_PROXY_TOOLS.has(c.name));
-    log("debug", `[acp-diag] round ${loopCount} allCalls=[${allCalls.map((c) => c.name).join(",")}] realCalls=[${realCalls.map((c) => c.name).join(",")}] customToolCalls=${customToolCalls} text=${JSON.stringify(contentText.slice(0, 120))}`);
-    const hasMutatingOnly = proxyCalls.some((c) => MUTATING_PROXY_TOOLS.has(c.name)) && realCalls.length === 0;
-    if (!hasMutatingOnly) {
-      for (const fc of readonlyProxy) {
-        let args = {};
-        try {
-          args = JSON.parse(fc.arguments);
-        } catch (e) {
-          log("warn", `[acp-compress-args] ${fc.name} JSON.parse failed: ${String(e)}`);
-          args = {};
-        }
-        let result;
-        try {
-          result = executeProxyTool3(fc.name, args, ctx);
-          const preview = result.length > 120 ? result.slice(0, 120) + "..." : result;
-          ctx.log(`[acp-proxy: responses ${fc.name} (read-only) (${fc.callId}) \u2192 ${preview.replace(/\n/g, " ")}]`);
-        } catch (e) {
-          result = `\u274C [ACP] ${fc.name} FAILED: ${String(e)}`;
-          ctx.log(`[acp-proxy: responses ${fc.name} (read-only) (${fc.callId}) FAILED: ${String(e)}]`);
-        }
-        const markerItemId = `msg_acp_ro_${Date.now()}_${nextOutputIndex}`;
-        yield Buffer.from(buildMessageItemSequence(markerItemId, nextOutputIndex++, buildVisibilityMarker(fc.name, result)), "utf8");
-      }
-      let oi2 = nextOutputIndex;
-      for (const fc of realCalls) {
-        yield Buffer.from(buildFunctionCallEvents(fc, oi2), "utf8");
-        oi2++;
-      }
-      nextOutputIndex = oi2;
-      if (terminalKind && terminalKind !== "completed" && terminalRaw) {
-        yield Buffer.from(terminalRaw + "\n\n", "utf8");
-        return;
-      }
-      const hasUsage = !!responseObj?.usage;
-      const emittedReadonly = readonlyProxy.length > 0;
-      if (contentText.length === 0 && realCalls.length === 0 && customToolCalls === 0 && !emittedReadonly && !hasUsage) {
-        ctx.log("[acp-proxy: empty upstream response (no content/usage) \u2014 injecting response.failed for client retry]");
-        yield Buffer.from(buildFailed(responseObj), "utf8");
-        return;
-      }
-      if (!completed) {
-        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: 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 }]
-      });
-    }
-    if (!textProtocol) {
-      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(fc.arguments);
-      } catch (e) {
-        log("warn", `[acp-compress-args] ${fc.name} JSON.parse failed: ${String(e)}. raw arguments (len=${fc.arguments.length}): ${fc.arguments.slice(0, 300)}`);
-        args = {};
-      }
-      if (fc.name === "compress") {
-        log("debug", `[acp-compress-args] compress args parsed: ${JSON.stringify(args).slice(0, 400)}`);
-      }
-      const result = executeProxyTool3(fc.name, args, ctx);
-      const preview = result.length > 120 ? result.slice(0, 120) + "..." : result;
-      ctx.log(`[acp-proxy: responses ${fc.name} (${fc.callId}) \u2192 ${preview.replace(/\n/g, " ")}]`);
-      const markerItemId = `msg_acp_${Date.now()}_${nextOutputIndex}`;
-      yield Buffer.from(
-        buildMessageItemSequence(markerItemId, nextOutputIndex++, buildVisibilityMarker(fc.name, result)),
-        "utf8"
-      );
-      inputItems.push(textProtocol ? { type: "message", role: "user", content: buildVisibilityMarker(fc.name, result) } : { type: "function_call_output", call_id: fc.callId || `call_${Date.now()}`, output: result });
-    }
-    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),
-      ...ctx.proxyUrl ? { dispatcher: proxyDispatcher(ctx.proxyUrl) } : {}
-    });
-    if (!resp.ok || !resp.body) {
-      clearTimer();
-      const errText = await resp.text().catch(() => "upstream error");
-      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(
-        buildMessageItemSequence(errItemId, nextOutputIndex++, `
-[acp-proxy: upstream error ${resp.status}: ${errText.slice(0, 200)}]
-`),
-        "utf8"
-      );
-      yield Buffer.from(buildCompleted(responseObj), "utf8");
-      return;
-    }
-    upstream = resp.body;
-    if (activeClearTimer) activeClearTimer();
-    activeClearTimer = clearTimer;
-  }
-}
-
-// src/loop/core.ts
-var MAX_LOOP_ROUNDS = 10;
-function executeProxyTool4(toolName, args, ctx, callId) {
-  if (toolName === "compress") {
-    return applyRanges(parseCompressInput(args, callId), 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((b2) => {
-      const topic = b2.topic ?? "(no topic)";
-      const preview = b2.summary.length > 200 ? b2.summary.slice(0, 200) + "..." : b2.summary;
-      return `${b2.blockId} (T${b2.tier}) "${topic}"
-  ${preview}`;
-    });
-    return `Found ${blocks.length} block(s) for "${query}":
-
-${lines.join("\n\n")}`;
-  }
-  if (toolName === "acp_status") {
-    return buildStatusReport(ctx.session.state, ctx.messages, estimateTokensFast);
-  }
-  return `[Unknown proxy tool: ${toolName}]`;
-}
-function recordUsage(ctx, usage, round) {
-  const prompt = usage.inputTokens;
-  const cached = usage.cachedTokens;
-  const out = usage.outputTokens;
-  if (typeof prompt === "number") ctx.session.stats.inputTokens += prompt;
-  ctx.session.stats.lastInputTokens = (typeof prompt === "number" ? prompt : 0) + (typeof cached === "number" ? cached : 0);
-  if (typeof cached === "number") ctx.session.stats.cachedTokens += cached;
-  if (typeof out === "number") ctx.session.stats.outputTokens += out;
-  ctx.session.stats.cacheSamples += 1;
-  const hitPct = typeof prompt === "number" && typeof cached === "number" && prompt + cached > 0 ? Math.round(cached / (prompt + cached) * 100) : 0;
-  ctx.log(
-    `[acp-usage] round ${round} input=${ctx.session.stats.lastInputTokens} cached=${cached ?? 0} (cache hit ${hitPct}%)`
-  );
-}
-async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adapter, systemPrompt) {
+async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adapter, systemPrompt, signal) {
   let activeClearTimer = null;
   let currentUpstream = upstream;
   const coreMessages = [...ctx.messages];
   try {
     for (let round = 1; round <= MAX_LOOP_ROUNDS; round++) {
+      if (signal?.aborted) break;
       let assistantText = "";
       const calls = [];
       let usage = {};
       let finishReason;
       for await (const ev of adapter.parseStream(currentUpstream, round)) {
+        if (signal?.aborted) break;
         if (ev.kind === "text") {
           assistantText += ev.delta;
           if (!ctx.textProtocol && round === 1 && ev.raw) {
@@ -49758,7 +48597,7 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
           } catch {
             parsedArgs = {};
           }
-          const result = executeProxyTool4(call.name, parsedArgs, ctx, call.callId);
+          const result = executeProxyTool(call.name, parsedArgs, ctx, call.callId);
           proxyResults.push({ name: call.name, callId: call.callId, result, arguments: call.arguments });
           yield adapter.emitMarker(call.name, result);
         } else {
@@ -49791,7 +48630,7 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
           if (ctx.textProtocol) {
             coreMessages.push({
               id: `acp_loop_r${round}_marker_${pr2.callId}`,
-              role: "user",
+              role: "system",
               contentType: "text",
               text: buildVisibilityMarker(pr2.name, pr2.result)
             });
@@ -49837,6 +48676,7 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
         return;
       }
       ctx.log(`[acp-loop] round ${round} saw mutating proxy tool; re-requesting`);
+      if (signal?.aborted) break;
       const newBody = adapter.buildRequest(coreMessages, systemPrompt, requestBody);
       if (process.env.ACP_DUMP_REQ !== "0" && ctx.debug) {
         try {
@@ -49848,12 +48688,17 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
         } catch {
         }
       }
-      const { response: resp, clearTimer } = await fetchWithTimeout(requestOptions.url, {
-        method: "POST",
-        headers: requestOptions.headers,
-        body: JSON.stringify(newBody),
-        ...ctx.proxyUrl ? { dispatcher: proxyDispatcher(ctx.proxyUrl) } : {}
-      });
+      const { response: resp, clearTimer } = await fetchWithTimeout(
+        requestOptions.url,
+        {
+          method: "POST",
+          headers: requestOptions.headers,
+          body: JSON.stringify(newBody),
+          ...ctx.proxyUrl ? { dispatcher: proxyDispatcher(ctx.proxyUrl) } : {}
+        },
+        void 0,
+        signal
+      );
       if (!resp.ok || !resp.body) {
         clearTimer();
         const errText = await resp.text().catch(() => "upstream error");
@@ -49902,13 +48747,13 @@ async function* iterSseEvents(stream2) {
     reader.releaseLock();
   }
 }
-function extractEventType2(rawEvent) {
+function extractEventType(rawEvent) {
   for (const l of rawEvent.split("\n")) {
     if (l.startsWith("event:")) return l.slice(6).trim();
   }
   return null;
 }
-function extractDataLine2(rawEvent) {
+function extractDataLine(rawEvent) {
   const parts = [];
   for (const l of rawEvent.split("\n")) {
     if (l.startsWith("data:")) {
@@ -49919,7 +48764,7 @@ function extractDataLine2(rawEvent) {
   }
   return parts.length ? parts.join("\n") : null;
 }
-function buildMessageItemSequence2(itemId, outputIndex, text) {
+function buildMessageItemSequence(itemId, outputIndex, text) {
   const item = { type: "message", id: itemId, role: "assistant", content: [] };
   const part = { type: "output_text", text: "" };
   const doneItem = {
@@ -49958,7 +48803,7 @@ data: ${JSON.stringify({ type: "response.output_item.done", output_index: output
     "utf8"
   );
 }
-function buildFunctionCallEvents2(fc, itemId, outputIndex) {
+function buildFunctionCallEvents(fc, itemId, outputIndex) {
   return Buffer.from(
     [
       `event: response.output_item.added
@@ -49997,7 +48842,7 @@ data: ${JSON.stringify({
     "utf8"
   );
 }
-function buildCompleted2(responseObj) {
+function buildCompleted(responseObj) {
   const resp = responseObj ?? { id: `resp-proxy-${Date.now()}`, status: "completed", output: [] };
   return Buffer.from(
     `event: response.completed
@@ -50041,8 +48886,8 @@ function createResponsesAdapter(textProtocol, projection) {
     async *parseStream(upstream, round) {
       const pending = /* @__PURE__ */ new Map();
       for await (const eventStr of iterSseEvents(upstream)) {
-        const type = extractEventType2(eventStr);
-        const dataLine = extractDataLine2(eventStr);
+        const type = extractEventType(eventStr);
+        const dataLine = extractDataLine(eventStr);
         if (!type || !dataLine) continue;
         let obj;
         try {
@@ -50140,15 +48985,15 @@ function createResponsesAdapter(textProtocol, projection) {
       }
     },
     emitText(delta) {
-      return buildMessageItemSequence2(`msg-proxy-${Date.now()}-${outputIndex}`, outputIndex++, delta);
+      return buildMessageItemSequence(`msg-proxy-${Date.now()}-${outputIndex}`, outputIndex++, delta);
     },
     emitToolCall(call) {
-      const buf = buildFunctionCallEvents2(call, `fc-proxy-${Date.now()}-${outputIndex}`, outputIndex);
+      const buf = buildFunctionCallEvents(call, `fc-proxy-${Date.now()}-${outputIndex}`, outputIndex);
       outputIndex += 1;
       return buf;
     },
     emitMarker(toolName, result) {
-      return buildMessageItemSequence2(
+      return buildMessageItemSequence(
         `marker-${Date.now()}-${outputIndex}`,
         outputIndex++,
         buildVisibilityMarker(toolName, result)
@@ -50187,7 +49032,7 @@ data: ${JSON.stringify({ type: "response.failed", response: failed })}
         }
         resp = { ...resp, usage };
       }
-      return buildCompleted2(resp);
+      return buildCompleted(resp);
     },
     emitError(message) {
       const resp = {
@@ -50482,7 +49327,7 @@ async function* iterSseEvents2(stream2) {
     reader.releaseLock();
   }
 }
-function parseAnthropicSse2(eventStr) {
+function parseAnthropicSse(eventStr) {
   const lines = eventStr.split("\n");
   let type = "";
   const dataLines = [];
@@ -50592,7 +49437,7 @@ ${systemPrompt}` : systemPrompt;
       let usageYielded = false;
       const indexMap = /* @__PURE__ */ new Map();
       for await (const eventStr of iterSseEvents2(upstream)) {
-        const parsed = parseAnthropicSse2(eventStr);
+        const parsed = parseAnthropicSse(eventStr);
         if (!parsed) continue;
         const { type, data } = parsed;
         const rawBuf = Buffer.from(eventStr + "\n\n", "utf8");
@@ -50720,6 +49565,184 @@ function pickAdapter(protocol, requestBody, textProtocol, responsesProjection, a
   throw new Error(`[acp-loop] unknown protocol: ${protocol}`);
 }
 
+// src/compress-loop-responses.ts
+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((b2) => {
+      const topic = b2.topic ?? "(no topic)";
+      const preview = b2.summary.length > 200 ? b2.summary.slice(0, 200) + "..." : b2.summary;
+      return `${b2.blockId} (T${b2.tier}) "${topic}"
+  ${preview}`;
+    });
+    return `Found ${blocks.length} block(s) for "${query}":
+
+${lines.join("\n\n")}`;
+  }
+  if (toolName === "acp_status") {
+    return buildStatusReport(ctx.session.state, ctx.messages, estimateTokensFast);
+  }
+  return `[Unknown proxy tool: ${toolName}]`;
+}
+function responsesJsonOutput(response) {
+  const textParts = [];
+  const calls = [];
+  for (const item of Array.isArray(response.output) ? response.output : []) {
+    if (!item || typeof item !== "object") continue;
+    const value = item;
+    if (value.type === "message") {
+      for (const part of Array.isArray(value.content) ? value.content : []) {
+        if (part && typeof part === "object" && part.type === "output_text") {
+          textParts.push(part);
+        }
+      }
+    } else if (value.type === "function_call") {
+      calls.push({
+        itemId: typeof value.id === "string" ? value.id : "",
+        callId: typeof value.call_id === "string" ? value.call_id : "",
+        name: typeof value.name === "string" ? value.name : "",
+        arguments: typeof value.arguments === "string" ? value.arguments : ""
+      });
+    }
+  }
+  return {
+    text: textParts.map((part) => typeof part.text === "string" ? part.text : "").join(""),
+    textParts,
+    calls
+  };
+}
+function replaceResponsesJsonText(parts, text) {
+  parts.forEach((part, index) => {
+    part.text = index === 0 ? text : "";
+  });
+}
+function surfaceReadonlyJson(current, proxyCalls, ctx) {
+  const markers = [];
+  for (const call of proxyCalls) {
+    if (MUTATING_PROXY_TOOLS.has(call.name)) continue;
+    let args = {};
+    try {
+      args = JSON.parse(call.arguments);
+    } catch {
+      args = {};
+    }
+    let result;
+    try {
+      result = executeProxyTool2(call.name, args, ctx);
+      ctx.log(`[acp-proxy: responses JSON ${call.name} (read-only) \u2192 ${result.slice(0, 120).replace(/\n/g, " ")}]`);
+    } catch (e) {
+      result = `\u274C [ACP] ${call.name} FAILED: ${String(e)}`;
+      ctx.log(`[acp-proxy: responses JSON ${call.name} (read-only) FAILED: ${String(e)}]`);
+    }
+    markers.push(buildVisibilityMarker(call.name, result));
+  }
+  if (markers.length === 0) return current;
+  const out = Array.isArray(current.output) ? [...current.output] : [];
+  out.push({ type: "message", id: `msg_acp_ro_${Date.now()}_${markers.length}`, role: "assistant", content: [{ type: "output_text", text: markers.join("\n") }] });
+  return { ...current, output: out };
+}
+async function compressLoopResponsesJson(initialResponse, ctx, requestBody, requestOptions) {
+  let current = initialResponse;
+  for (let loopCount = 1; loopCount <= MAX_LOOP_ROUNDS; loopCount++) {
+    const output = responsesJsonOutput(current);
+    const extracted = extractTextTriggers(output.text);
+    const allCalls = [...output.calls, ...extracted.calls].filter((call) => call.name.length > 0);
+    const proxyCalls = allCalls.filter((call) => PROXY_TOOL_NAMES.has(call.name));
+    const realCalls = allCalls.filter((call) => !PROXY_TOOL_NAMES.has(call.name));
+    const mutatingProxy = proxyCalls.filter((call) => MUTATING_PROXY_TOOLS.has(call.name));
+    if (mutatingProxy.length === 0 || realCalls.length > 0) {
+      if (proxyCalls.length > 0) {
+        replaceResponsesJsonText(output.textParts, extracted.clean);
+        current = surfaceReadonlyJson(current, proxyCalls, ctx);
+      }
+      return current;
+    }
+    const inputItems = Array.isArray(requestBody.input) ? [...requestBody.input] : [];
+    if (extracted.clean.trim()) {
+      inputItems.push({ type: "message", role: "assistant", content: [{ type: "output_text", text: extracted.clean }] });
+    }
+    let mutatedThisTurn = false;
+    for (const call of proxyCalls) {
+      let args = {};
+      try {
+        args = JSON.parse(call.arguments);
+      } catch (error) {
+        log("warn", `[acp-compress-args] ${call.name} JSON.parse failed: ${String(error)}`);
+      }
+      let result;
+      if (MUTATING_PROXY_TOOLS.has(call.name) && mutatedThisTurn) {
+        result = `Already ${call.name}ed once this turn. Do not ${call.name} again; generate your normal response now.`;
+        ctx.log(`[acp-proxy: responses JSON ${call.name} skipped (state already mutated this turn)]`);
+      } else {
+        result = executeProxyTool2(call.name, args, ctx);
+        if (MUTATING_PROXY_TOOLS.has(call.name)) mutatedThisTurn = true;
+        ctx.log(`[acp-proxy: responses JSON ${call.name} \u2192 ${result.slice(0, 120).replace(/\n/g, " ")}]`);
+      }
+      inputItems.push({ type: "message", role: "developer", content: buildVisibilityMarker(call.name, result) });
+    }
+    requestBody.input = inputItems;
+    const { response, clearTimer } = await fetchWithTimeout(requestOptions.url, {
+      method: "POST",
+      headers: requestOptions.headers,
+      body: JSON.stringify(requestBody),
+      ...ctx.proxyUrl ? { dispatcher: proxyDispatcher(ctx.proxyUrl) } : {}
+    });
+    try {
+      if (!response.ok) {
+        const detail = await response.text().catch(() => "upstream error");
+        throw new Error(`responses compress loop upstream error ${response.status}: ${detail.slice(0, 200)}`);
+      }
+      current = await response.json();
+    } finally {
+      clearTimer();
+    }
+  }
+  ctx.log(`[acp-proxy: responses JSON compress loop limit (${MAX_LOOP_ROUNDS}) reached]`);
+  return current;
+}
+
 // src/stream-openai.ts
 function rewriteOpenaiJsonResponse(body, ctx) {
   if (!body || typeof body !== "object") return body;
@@ -50763,7 +49786,7 @@ ${note}` : note;
 }
 
 // src/stream-responses.ts
-var TEXT_PROTOCOL2 = process.env.ACP_COMPRESS_PROTOCOL === "text";
+var TEXT_PROTOCOL = process.env.ACP_COMPRESS_PROTOCOL === "text";
 function rewriteResponsesJsonResponse(body, ctx) {
   if (!body || typeof body !== "object") return body;
   const b2 = body;
@@ -51795,6 +50818,15 @@ var UPSTREAM_HOP_HEADERS = /* @__PURE__ */ new Set([
   // streamed from fetch, otherwise clients try to decompress plain bytes.
   "content-encoding"
 ]);
+function buildForwardHeaders(headers) {
+  const out = {};
+  for (const [k2, v2] of Object.entries(headers)) {
+    if (k2.toLowerCase() === "content-length" || k2.toLowerCase() === "host") continue;
+    out[k2] = v2;
+  }
+  out["content-type"] = "application/json";
+  return out;
+}
 function resolveUpstream(_opts, reqUrl, req) {
   const mitmUpstream = readMitmUpstream(req?.socket);
   if (mitmUpstream) {
@@ -52018,11 +51050,24 @@ async function handle(req, res, opts, core, config, log2) {
     return;
   }
   let bodyBuffer;
+  let urlPath;
+  let responsesCompact;
+  let route;
+  let upstreamOrigin;
+  let protocol;
   try {
     bodyBuffer = await readBody(req);
-    const decoded = await decodeRequestBody(headerValue(req, "content-encoding"), bodyBuffer, MAX_REQUEST_BYTES);
-    bodyBuffer = decoded.body;
-    if (decoded.decoded) delete req.headers["content-encoding"];
+    const url = req.url ?? "";
+    urlPath = url.split("?", 2)[0];
+    responsesCompact = urlPath.endsWith("/responses/compact");
+    route = resolveUpstream(opts, req.url ?? "", req);
+    upstreamOrigin = route ? route.upstream : opts.upstream;
+    protocol = route?.explicitProtocol ?? (req.method === "POST" && bodyBuffer.length > 0 ? urlPath.endsWith("/chat/completions") ? "openai" : urlPath.endsWith("/v1/messages") || urlPath.endsWith("/messages") ? "anthropic" : urlPath.endsWith("/responses") || responsesCompact ? "responses" : null : null);
+    if (protocol !== null && bodyBuffer.length > 0) {
+      const decoded = await decodeRequestBody(headerValue(req, "content-encoding"), bodyBuffer, MAX_REQUEST_BYTES);
+      bodyBuffer = decoded.body;
+      if (decoded.decoded) delete req.headers["content-encoding"];
+    }
   } catch (err2) {
     if (err2 instanceof BodyTooLargeError) {
       log2("warn", `413: request body exceeds ${err2.limit} bytes`);
@@ -52035,13 +51080,7 @@ async function handle(req, res, opts, core, config, log2) {
     res.end(JSON.stringify({ error: { type: "invalid_request", message: String(err2) } }));
     return;
   }
-  const url = req.url ?? "";
-  const urlPath = url.split("?", 2)[0];
-  const responsesCompact = urlPath.endsWith("/responses/compact");
   const countTokens = isCountTokensRequest(req.method ?? "GET", urlPath, bodyBuffer.length > 0);
-  const route = resolveUpstream(opts, req.url ?? "", req);
-  const upstreamOrigin = route ? route.upstream : opts.upstream;
-  const protocol = route?.explicitProtocol ?? (req.method === "POST" && bodyBuffer.length > 0 ? urlPath.endsWith("/chat/completions") ? "openai" : urlPath.endsWith("/v1/messages") || urlPath.endsWith("/messages") ? "anthropic" : urlPath.endsWith("/responses") || responsesCompact ? "responses" : null : null);
   let parsed = null;
   if (protocol && bodyBuffer.length > 0) {
     try {
@@ -52086,19 +51125,19 @@ async function handle(req, res, opts, core, config, log2) {
     });
     const clientLabel = responsesIdentity?.clientProvided ? responsesIdentity.value : clientConversationHeader(req.headers);
     const session = getSession(sessionId, { protocol, upstreamOrigin, label: clientLabel ?? void 0 });
-    await withSessionLock(session, async () => {
-      prepared = countTokens ? prepareCountTokens(parsed, core, reqConfig, log2, session) : protocol === "anthropic" ? prepareAnthropic(parsed, req, opts, core, reqConfig, log2, session) : protocol === "openai" ? prepareOpenai(parsed, req, opts, core, reqConfig, log2, session) : responsesCompact ? prepareResponsesCompact(bodyBuffer, parsed, session) : prepareResponses(parsed, req, opts, core, reqConfig, log2, session, responsesIdentity);
-      acquireInFlight(session);
-      try {
+    acquireInFlight(session);
+    try {
+      await withSessionLock(session, async () => {
+        prepared = countTokens ? prepareCountTokens(parsed, core, reqConfig, log2, session) : protocol === "anthropic" ? prepareAnthropic(parsed, req, opts, core, reqConfig, log2, session) : protocol === "openai" ? prepareOpenai(parsed, req, opts, core, reqConfig, log2, session) : responsesCompact ? prepareResponsesCompact(bodyBuffer, parsed, session) : prepareResponses(parsed, req, opts, core, reqConfig, log2, session, responsesIdentity);
         await forward(req, res, opts, prepared.body, prepared, core, reqConfig, log2, route, affinity);
-      } finally {
-        releaseInFlight(session);
-      }
-    });
+      });
+    } finally {
+      releaseInFlight(session);
+    }
   }
   if (!prepared) {
     if (protocol === null && !opts.passthrough) {
-      log2("warn", `unrecognized path ${url} \u2014 not a known protocol (/chat/completions, /v1/messages, /responses, /responses/compact); forwarding unchanged`);
+      log2("warn", `unrecognized path ${req.url ?? ""} \u2014 not a known protocol (/chat/completions, /v1/messages, /responses, /responses/compact); forwarding unchanged`);
     }
     await forward(req, res, opts, bodyBuffer, null, core, reqConfig, log2, route, void 0);
   }
@@ -52134,6 +51173,7 @@ function prepareAnthropic(parsed, req, opts, core, config, log2, session) {
   ++session.stats.requests;
   let processedMessages = [];
   let originalMessages = [];
+  let nudge;
   let rebuiltMessages = parsed.messages;
   let systemOut = parsed.system;
   let toolsOut = parsed.tools;
@@ -52144,6 +51184,7 @@ function prepareAnthropic(parsed, req, opts, core, config, log2, session) {
     const tokenCount = session.stats.lastInputTokens;
     const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: "text-only" });
     session.state = turn.state;
+    nudge = turn.nudge;
     session.stats.contextTokens = tokenCount;
     if (!session.meta.title) {
       const t = deriveTitle(msgs);
@@ -52173,7 +51214,7 @@ function prepareAnthropic(parsed, req, opts, core, config, log2, session) {
   }
   const rebuilt = { ...parsed, messages: rebuiltMessages, system: systemOut, tools: toolsOut };
   markDirty(session);
-  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, anthropicSystem: parsed.system, protocol: "anthropic", stream: stream2, compressInjected: opts.compress.injectTool };
+  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, anthropicSystem: parsed.system, protocol: "anthropic", stream: stream2, compressInjected: opts.compress.injectTool, nudge };
 }
 function prepareOpenai(parsed, req, opts, core, config, log2, session) {
   const sessionId = session.id;
@@ -52181,6 +51222,7 @@ function prepareOpenai(parsed, req, opts, core, config, log2, session) {
   ++session.stats.requests;
   let processedMessages = [];
   let originalMessages = [];
+  let nudge;
   let rebuiltMessages = parsed.messages;
   let toolsOut = parsed.tools;
   const maxTokens = typeof parsed.max_tokens === "number" ? parsed.max_tokens : 8192;
@@ -52192,6 +51234,7 @@ function prepareOpenai(parsed, req, opts, core, config, log2, session) {
     const tokenCount = session.stats.lastInputTokens;
     const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: "text-only" });
     session.state = turn.state;
+    nudge = turn.nudge;
     session.stats.contextTokens = tokenCount;
     if (!session.meta.title) {
       const t = deriveTitle(msgs);
@@ -52226,7 +51269,7 @@ function prepareOpenai(parsed, req, opts, core, config, log2, session) {
     rebuilt.stream_options = { include_usage: true };
   }
   markDirty(session);
-  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, protocol: "openai", stream: stream2, compressInjected: shouldInject };
+  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, protocol: "openai", stream: stream2, compressInjected: shouldInject, nudge };
 }
 function prepareResponses(parsed, req, opts, core, config, log2, session, identity) {
   const sessionId = session.id;
@@ -52237,6 +51280,7 @@ function prepareResponses(parsed, req, opts, core, config, log2, session, identi
   }
   let processedMessages = [];
   let originalMessages = [];
+  let nudge;
   let responsesProjection;
   let rebuiltInput = parsed.input;
   let toolsOut = parsed.tools;
@@ -52253,6 +51297,7 @@ function prepareResponses(parsed, req, opts, core, config, log2, session, identi
     const tokenCount = session.stats.lastInputTokens;
     const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: process.env.ACP_RENDER_NONE ? "none" : "text-only" });
     session.state = turn.state;
+    nudge = turn.nudge;
     session.stats.contextTokens = tokenCount;
     if (!session.meta.title) {
       const t = deriveTitle(msgs);
@@ -52314,7 +51359,8 @@ function prepareResponses(parsed, req, opts, core, config, log2, session, identi
     protocol: "responses",
     stream: stream2,
     compressInjected: shouldInject,
-    responsesTextProtocol
+    responsesTextProtocol,
+    nudge
   };
 }
 function isCountTokensRequest(method, urlPath, hasBody) {
@@ -52557,105 +51603,39 @@ async function forward(req, res, opts, body, prepared, core, config, log2, route
       dumpRaw = dumpStreamToFile(b2, opts.dumpSse, `${Date.now()}-${prepared.session.id}-raw.sse`);
     }
     try {
-      if (process.env.ACP_LOOP_V2 !== "0") {
-        const parsedReq = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
-        const reqHeaders = {};
-        for (const [k2, v2] of Object.entries(headers)) {
-          if (k2.toLowerCase() === "content-length" || k2.toLowerCase() === "host") continue;
-          reqHeaders[k2] = v2;
-        }
-        reqHeaders["content-type"] = "application/json";
-        const textProtocol = prepared.protocol === "responses" && !!prepared.responsesTextProtocol;
-        const systemPrompt = textProtocol ? buildCompressTextSystemPrompt() : buildCompressSystemPrompt();
-        const adapter = pickAdapter(prepared.protocol, parsedReq, textProtocol, prepared.responsesProjection, prepared.anthropicSystem);
-        const loop = runCompressLoop(
-          streamToRead,
-          { core, config, messages: prepared.processedMessages.length > 0 ? prepared.processedMessages : prepared.originalMessages, session: prepared.session, log: ctx.log, proxyUrl, textProtocol, debug: opts.debug },
-          parsedReq,
-          { url: upstreamUrl, headers: reqHeaders },
-          adapter,
-          systemPrompt
-        );
-        for await (const chunk of loop) {
-          {
-            const s3 = chunk.toString("utf8");
-            if (s3.includes("<acp ") || s3.includes("</acp")) {
-              log2("warn", `[${prepared.session.id}] tag echo: ${prepared.protocol} response stream contains <acp tag`);
-            }
-          }
-          res.write(chunk);
-          if (res.writableNeedDrain) await new Promise((r) => res.once("drain", () => r()));
-        }
-        res.end();
-      } else if (prepared.protocol === "openai") {
-        const parsedReq = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
-        const reqHeaders = {};
-        for (const [k2, v2] of Object.entries(headers)) {
-          if (k2.toLowerCase() === "content-length" || k2.toLowerCase() === "host") continue;
-          reqHeaders[k2] = v2;
-        }
-        reqHeaders["content-type"] = "application/json";
-        const loop = compressLoopStream(
-          streamToRead,
-          { core, config, messages: prepared.originalMessages, session: prepared.session, log: ctx.log, proxyUrl },
-          parsedReq,
-          { url: upstreamUrl, headers: reqHeaders }
-        );
-        for await (const chunk of loop) {
-          {
-            const s3 = chunk.toString("utf8");
-            if (s3.includes("<acp ") || s3.includes("</acp")) {
-              log2("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 [k2, v2] of Object.entries(headers)) {
-          if (k2.toLowerCase() === "content-length" || k2.toLowerCase() === "host") continue;
-          reqHeaders[k2] = v2;
-        }
-        reqHeaders["content-type"] = "application/json";
-        const loop = compressLoopResponsesStream(
-          streamToRead,
-          { core, config, messages: prepared.originalMessages, session: prepared.session, log: ctx.log, proxyUrl, textProtocol: prepared.responsesTextProtocol },
-          parsedReq,
-          { url: upstreamUrl, headers: reqHeaders }
-        );
-        for await (const chunk of loop) {
-          {
-            const s3 = chunk.toString("utf8");
-            if (s3.includes("<acp ") || s3.includes("</acp")) {
-              log2("warn", `[${prepared.session.id}] tag echo: responses response stream contains <acp tag`);
-            }
+      const parsedReq = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
+      const reqHeaders = buildForwardHeaders(headers);
+      const textProtocol = prepared.protocol === "responses" && !!prepared.responsesTextProtocol;
+      const systemPrompt = textProtocol ? buildCompressTextSystemPrompt() : buildCompressSystemPrompt();
+      const adapter = pickAdapter(prepared.protocol, parsedReq, textProtocol, prepared.responsesProjection, prepared.anthropicSystem);
+      const abortCtrl = new AbortController();
+      req.on("close", () => {
+        if (!res.writableEnded) abortCtrl.abort();
+      });
+      const loop = runCompressLoop(
+        streamToRead,
+        { core, config, messages: prepared.processedMessages.length > 0 ? prepared.processedMessages : prepared.originalMessages, session: prepared.session, log: ctx.log, proxyUrl, textProtocol, debug: opts.debug, nudge: prepared.nudge },
+        parsedReq,
+        { url: upstreamUrl, headers: reqHeaders },
+        adapter,
+        systemPrompt,
+        abortCtrl.signal
+      );
+      for await (const chunk of loop) {
+        {
+          const s3 = chunk.toString("utf8");
+          if (s3.includes("<acp ") || s3.includes("</acp")) {
+            log2("warn", `[${prepared.session.id}] tag echo: ${prepared.protocol} response stream contains <acp tag`);
           }
-          if (!res.write(chunk)) await new Promise((r) => res.once("drain", () => r()));
         }
-      } else {
-        const parsedReq = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
-        const reqHeaders = {};
-        for (const [k2, v2] of Object.entries(headers)) {
-          if (k2.toLowerCase() === "content-length" || k2.toLowerCase() === "host") continue;
-          reqHeaders[k2] = v2;
-        }
-        reqHeaders["content-type"] = "application/json";
-        const loop = compressLoopAnthropicStream(
-          streamToRead,
-          { core, config, messages: prepared.originalMessages, session: prepared.session, log: ctx.log, proxyUrl },
-          parsedReq,
-          { url: upstreamUrl, headers: reqHeaders }
-        );
-        for await (const chunk of loop) {
-          {
-            const s3 = chunk.toString("utf8");
-            if (s3.includes("<acp ") || s3.includes("</acp")) {
-              log2("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.write(chunk);
+        if (res.writableNeedDrain) {
+          await Promise.race([
+            new Promise((r) => res.once("drain", () => r())),
+            new Promise((r) => res.once("close", () => r()))
+          ]);
         }
+        if (res.destroyed || res.writableEnded) break;
       }
       res.end();
     } catch (e) {
@@ -52672,12 +51652,7 @@ async function forward(req, res, opts, body, prepared, core, config, log2, route
         let json = JSON.parse(text);
         if (prepared.protocol === "responses" && prepared.responsesTextProtocol) {
           const requestBody = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
-          const requestHeaders = {};
-          for (const [key, value] of Object.entries(headers)) {
-            if (key.toLowerCase() === "content-length" || key.toLowerCase() === "host") continue;
-            requestHeaders[key] = value;
-          }
-          requestHeaders["content-type"] = "application/json";
+          const requestHeaders = buildForwardHeaders(headers);
           json = await compressLoopResponsesJson(
             json,
             { core, config, messages: prepared.originalMessages, session: prepared.session, log: ctx.log, proxyUrl, textProtocol: true },
@@ -52814,6 +51789,7 @@ function readBody(req) {
       size += c.length;
       if (size > MAX_REQUEST_BYTES) {
         aborted = true;
+        req.destroy();
         reject(new BodyTooLargeError(MAX_REQUEST_BYTES));
         return;
       }