billion-context 0.1.65 → 0.1.66-pr.373.227

package/README.md

@@ -307,6 +307,23 @@ recommended** for many concurrent conversations because of the collision
 risk — until pi grows its own session-id signal. For pi multi-agent use,
 pass an explicit `x-acp-session` header per conversation to avoid collisions.
 
+### Windows: exclude the sessions dir from antivirus (#362)
+
+The proxy persists each session's compression state to the sessions dir
+(`%USERPROFILE%\.local\share\billion-context\` by default) and rewrites the
+file every turn of a long session. On Windows, real-time antivirus (Windows
+Defender), the search indexer, or a sync tool (OneDrive) can lock that
+directory mid-write, so the rename fails with `EPERM` and every persist for
+that session fails until the lock clears.
+
+When the same session fails N consecutive writes (default `5`), the proxy
+logs a one-time, actionable alert naming the directory to exclude. To fix it
+at the root: add `%USERPROFILE%\.local\share\billion-context\` to your
+antivirus **exclusions** (Windows Defender: Settings → Virus & threat
+protection → Manage settings → Exclusions → Add an exclusion → Folder) and
+make sure no sync tool (OneDrive / Dropbox / …) is syncing that path. Full
+steps in [CONFIGURATION.md](CONFIGURATION.md#windows-exclude-the-sessions-dir-from-antivirus-362).
+
 ## Status
 
 Early. Protocol handling and compression work against mock tests (500+ passing). Real-model integration testing is the next milestone. Expect rough edges.

package/README.zh-CN.md

@@ -254,6 +254,12 @@ Windows 下会自动发现常见 Clash/Mihomo 静态系统代理;Web UI 会显
 
 **建议:** Codex 和 OpenCode 可以安全地通过代理并发跑很多会话。pi 单个 agent 没问题,但因碰撞风险**不建议**并发多会话 —— 直到 pi 自己长出 session-id 信号。pi 多 agent 场景下,每个会话发一个显式 `x-acp-session` header 来避免碰撞。
 
+### Windows：把会话目录加入杀软排除项（#362）
+
+代理把每个会话的压缩状态持久化到会话目录（默认 `%USERPROFILE%\.local\share\billion-context\`），长会话每一轮都会重写该文件。在 Windows 上，实时杀毒（Windows Defender）、搜索索引器或同步工具（OneDrive）可能在写入中途锁住该目录，导致 rename 以 `EPERM` 失败，在锁解除前该会话的每次持久化都会失败。
+
+当同一会话连续 N 次写失败（默认 `5`）时，代理会打一条一次性、可操作的告警，明确指出要排除的目录。要从根上修复：把 `%USERPROFILE%\.local\share\billion-context\` 加入杀软**排除项**（Windows Defender：设置 → 病毒和威胁防护 → 管理设置 → 排除项 → 添加排除 → 文件夹），并确认没有同步工具（OneDrive / Dropbox / …）在同步该路径。完整步骤见 [CONFIGURATION.zh-CN.md](CONFIGURATION.zh-CN.md) 的「Windows：把会话目录加入杀软排除项」章节。
+
 ## 状态
 
 早期。协议处理和压缩已通过 mock 测试(500+ 项通过)。真实模型集成测试是下一里程碑。预期会有粗糙的地方。

package/dist/index.js

@@ -46551,9 +46551,9 @@ function parseObjectValue(value, callId, diag) {
   const content = value["content"];
   if (content === void 0) {
     const single = validateEntry(value, callId);
-    if (single) {
+    if ("range" in single) {
       diag.kind = "ok";
-      return finish([single], diag);
+      return finish([single.range], diag);
     }
     diag.kind = "missing-content";
     return finish([], diag);
@@ -46574,7 +46574,7 @@ function parseObjectValue(value, callId, diag) {
     diag.kind = "content-not-array";
     return finish([], diag);
   }
-  const { ranges, invalid } = validateEntries(entries, callId);
+  const { ranges, invalid, reasons } = validateEntries(entries, callId);
   const topTopic = stringOr(value["topic"]);
   const topMaxChars = value["summaryMaxChars"];
   const hasTopMaxChars = typeof topMaxChars === "number" && Number.isFinite(topMaxChars);
@@ -46585,6 +46585,7 @@ function parseObjectValue(value, callId, diag) {
     }
   }
   diag.invalidItems = invalid;
+  if (reasons.length > 0) diag.invalidReasons = reasons;
   diag.kind = salvaged ? "truncated" : ranges.length > 0 ? "ok" : "no-valid-ranges";
   return finish(ranges, diag);
 }
@@ -46608,36 +46609,43 @@ function finish(ranges, diag) {
   return { ranges, diagnostics: diag };
 }
 function finishSalvage(entries, callId, diag, truncatedShape) {
-  const { ranges, invalid } = validateEntries(entries, callId);
+  const { ranges, invalid, reasons } = validateEntries(entries, callId);
   diag.invalidItems = invalid;
+  if (reasons.length > 0) diag.invalidReasons = reasons;
   diag.kind = entries.length > 0 || truncatedShape ? "truncated" : "malformed-json";
   return finish(ranges, diag);
 }
 function validateEntries(entries, callId) {
   const ranges = [];
+  const reasons = [];
   let invalid = 0;
-  for (const entry of entries) {
-    const range = validateEntry(entry, callId);
-    if (range !== null) ranges.push(range);
-    else invalid++;
+  for (let i = 0; i < entries.length; i++) {
+    const outcome = validateEntry(entries[i], callId);
+    if ("range" in outcome) ranges.push(outcome.range);
+    else {
+      invalid++;
+      reasons.push(`entry ${i}: ${outcome.reason}`);
+    }
   }
-  return { ranges, invalid };
+  return { ranges, invalid, reasons };
 }
 function validateEntry(entry, callId) {
-  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return null;
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return { reason: "not an object" };
   const e = entry;
   const start = stringOr(e["startRef"]) ?? stringOr(e["startId"]) ?? stringOr(e["messageId"]);
   const end = stringOr(e["endRef"]) ?? stringOr(e["endId"]) ?? stringOr(e["messageId"]);
-  if (start === void 0 || end === void 0) return null;
+  if (start === void 0 || end === void 0) {
+    return { reason: "missing range bounds (need startRef/startId and endRef/endId)" };
+  }
   const summary = stringOr(e["summary"]);
-  if (summary === void 0) return null;
+  if (summary === void 0) return { reason: "missing summary" };
   const range = { startRef: start, endRef: end, summary };
   const topic = stringOr(e["topic"]);
   if (topic !== void 0) range.topic = topic;
   const maxChars = e["summaryMaxChars"];
   if (typeof maxChars === "number" && Number.isFinite(maxChars)) range.summaryMaxChars = maxChars;
   if (callId !== void 0) range.compressCallId = callId;
-  return range;
+  return { range };
 }
 function stringOr(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
@@ -49260,11 +49268,16 @@ var StateStore = class {
   legacyFn;
   relPathFn;
   validateFn;
+  retryAttempts;
+  retryBaseMs;
+  retryMaxMs;
   timers = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
   writeChains = /* @__PURE__ */ new Map();
   /** id → absolute path, populated by writes and loadAll. */
   discovered = /* @__PURE__ */ new Map();
+  /** id → cumulative write-failure count, for rate-limited alerting. */
+  failCounts = /* @__PURE__ */ new Map();
   /** Monotonic counter for unique temp filenames within a process. */
   tmpSeq = 0;
   constructor(opts) {
@@ -49277,6 +49290,9 @@ var StateStore = class {
     this.relPathFn = opts.relPath;
     this.legacyFn = opts.legacy;
     this.validateFn = opts.validate ?? defaultValidate;
+    this.retryAttempts = Math.max(1, opts.retryAttempts ?? 6);
+    this.retryBaseMs = Math.max(1, opts.retryBaseMs ?? 50);
+    this.retryMaxMs = Math.max(this.retryBaseMs, opts.retryMaxMs ?? 1600);
   }
   /** Debounced save. Coalesces bursts; the builder runs at write time, so
    *  the freshest state is always persisted. Never throws. */
@@ -49336,32 +49352,42 @@ var StateStore = class {
     } catch (e) {
       this.log("warn", `[persist] could not create dir ${path4.dirname(file)}: ${errText(e)}`);
     }
-    const tmp = this.tempPath(file);
-    try {
-      fs.writeFileSync(tmp, data, "utf8");
-      let lastErr;
-      for (let attempt = 0; attempt < 3; attempt++) {
+    let lastErr;
+    for (let attempt = 0; attempt < this.retryAttempts; attempt++) {
+      const tmp = this.tempPath(file);
+      try {
+        fs.writeFileSync(tmp, data, "utf8");
+        fs.renameSync(tmp, file);
+        lastErr = void 0;
+        break;
+      } catch (e) {
+        lastErr = e;
         try {
-          fs.renameSync(tmp, file);
-          lastErr = void 0;
-          break;
-        } catch (e) {
-          lastErr = e;
-          const code = e.code;
-          if (code !== "EPERM" && code !== "EBUSY" && code !== "EACCES") break;
-          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20 * (attempt + 1));
+          fs.unlinkSync(tmp);
+        } catch {
         }
+        const code = e.code;
+        if (code !== "EPERM" && code !== "EBUSY" && code !== "EACCES") break;
+        if (attempt === this.retryAttempts - 1) break;
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, this.backoffMs(attempt));
       }
-      if (lastErr) throw lastErr;
+    }
+    if (!lastErr) {
+      this.discovered.set(id, file);
+      this.clearFailure(id);
+      this.removeSpillSync(file);
       return true;
-    } catch (e) {
-      this.log("error", `[persist] flushSync failed for ${id}: ${errText(e)}`);
-      try {
-        fs.unlinkSync(tmp);
-      } catch {
-      }
-      return false;
     }
+    let spillPath = null;
+    try {
+      const spill = this.spillPathFor(file);
+      fs.writeFileSync(spill, data, "utf8");
+      spillPath = spill;
+      this.discovered.set(id, spill);
+    } catch {
+    }
+    this.recordFailure(id, lastErr, spillPath);
+    return spillPath !== null;
   }
   /** Load one record. Checks the discovered path (from a prior
    *  write/loadAll), an optional relative-path hint, and the flat default
@@ -49395,13 +49421,27 @@ var StateStore = class {
     for (const file of files) {
       const envelope = this.readEnvelope(file);
       if (!envelope) continue;
-      const expected = path4.basename(this.relPathOf(envelope.id, envelope.payload)) === path4.basename(file) || flatFileNameFor(envelope.id) === path4.basename(file);
-      if (!expected) {
+      const base = path4.basename(file);
+      const relBase = path4.basename(this.relPathOf(envelope.id, envelope.payload));
+      const flatBase = flatFileNameFor(envelope.id);
+      let owner = null;
+      if (base === relBase || base === flatBase) {
+        owner = envelope.id;
+      } else if (base.endsWith(".fb.json")) {
+        const canonicalBase = `${base.slice(0, -".fb.json".length)}.json`;
+        if (canonicalBase === relBase || canonicalBase === flatBase) {
+          owner = envelope.id;
+        }
+      }
+      if (owner === null) {
         this.log("warn", `[persist] skipping ${rel(file, this.dir)}: filename does not match record id`);
         continue;
       }
-      this.discovered.set(envelope.id, file);
-      out.set(envelope.id, envelope);
+      const existing = out.get(owner);
+      if (!existing || envelope.savedAt >= existing.savedAt) {
+        out.set(owner, envelope);
+        this.discovered.set(owner, file);
+      }
     }
     return out;
   }
@@ -49455,14 +49495,25 @@ var StateStore = class {
       this.log("warn", `[persist] could not create dir ${path4.dirname(file)}: ${errText(e)}`);
     }
     const tmp = this.tempPath(file);
+    const env = this.envelope(id, payload);
     try {
-      await fsp.writeFile(tmp, JSON.stringify(this.envelope(id, payload)), "utf8");
-      await renameWithRetry(tmp, file);
+      await fsp.writeFile(tmp, JSON.stringify(env), "utf8");
+      await this.renameWithRetry(tmp, file);
       this.discovered.set(id, file);
+      this.clearFailure(id);
+      await this.removeSpill(file);
     } catch (e) {
       await fsp.unlink(tmp).catch(() => {
       });
-      this.log("error", `[persist] write failed for ${id}: ${errText(e)}`);
+      let spillPath = null;
+      try {
+        const spill = this.spillPathFor(file);
+        await fsp.writeFile(spill, JSON.stringify(env), "utf8");
+        spillPath = spill;
+        this.discovered.set(id, spill);
+      } catch {
+      }
+      this.recordFailure(id, e, spillPath);
       throw e;
     }
   }
@@ -49490,6 +49541,67 @@ var StateStore = class {
     const seq = this.tmpSeq++;
     return path4.join(path4.dirname(dest), `.tmp-${path4.basename(dest, ".json")}-${process.pid}-${seq}`);
   }
+  backoffMs(attempt) {
+    return Math.min(this.retryBaseMs * 2 ** attempt, this.retryMaxMs);
+  }
+  /** Side file for a record whose canonical write keeps failing: the
+   *  canonical name with a `.fb` (fallback) infix, e.g. `a.json` →
+   *  `a.fb.json`. One slot per id, overwritten on each spill, so a stuck
+   *  lock never accumulates files. Ends in `.json` so loadAll discovers it. */
+  spillPathFor(file) {
+    const base = path4.basename(file);
+    const dot = base.lastIndexOf(".");
+    const stem2 = dot > 0 ? base.slice(0, dot) : base;
+    const ext = dot > 0 ? base.slice(dot) : ".json";
+    return path4.join(path4.dirname(file), `${stem2}.fb${ext}`);
+  }
+  /** Remove a stale spill after a successful canonical write (best-effort). */
+  async removeSpill(file) {
+    await fsp.unlink(this.spillPathFor(file)).catch(() => {
+    });
+  }
+  removeSpillSync(file) {
+    try {
+      fs.unlinkSync(this.spillPathFor(file));
+    } catch {
+    }
+  }
+  /** Rate-limited failure alerting: log on the first failure and at each
+   *  power-of-two count (1,2,4,8,…), so a long lock yields ~log2(N) lines
+   *  instead of one per write. Includes the spill path so the operator can
+   *  see where the data landed. */
+  recordFailure(id, err2, spillPath) {
+    const count = (this.failCounts.get(id) ?? 0) + 1;
+    this.failCounts.set(id, count);
+    const alertAt = count === 1 || count >= 2 && (count & count - 1) === 0;
+    if (!alertAt) return;
+    const where = spillPath ? `; data spilled to ${rel(spillPath, this.dir)}` : "; SPILLOVER ALSO FAILED \u2014 data at risk";
+    this.log(count === 1 ? "error" : "warn", `[persist] write failed for ${id} (total ${count}x): ${errText(err2)}${where}`);
+  }
+  clearFailure(id) {
+    this.failCounts.delete(id);
+  }
+  /** fs.rename with exponential-backoff retries on Windows transient locks
+   *  (EPERM/EBUSY/EACCES from AV scan, search indexer, SMB). Other errors
+   *  are real and rethrown immediately. */
+  async renameWithRetry(src, dest) {
+    let lastErr;
+    for (let attempt = 0; attempt < this.retryAttempts; attempt++) {
+      try {
+        await fsp.rename(src, dest);
+        return;
+      } catch (e) {
+        lastErr = e;
+        const code = e.code;
+        if (code !== "EPERM" && code !== "EBUSY" && code !== "EACCES") throw e;
+        if (attempt === this.retryAttempts - 1) throw e;
+        const { promise, resolve } = Promise.withResolvers();
+        setTimeout(resolve, this.backoffMs(attempt));
+        await promise;
+      }
+    }
+    throw lastErr;
+  }
   /** Parse + validate one file. Corrupt or invalid records return null
    *  (logged) instead of throwing — load paths must never block boot. */
   readEnvelope(file) {
@@ -49565,23 +49677,6 @@ function isEnvelopeLike(value) {
 function flatFileNameFor(id) {
   return createHash2("sha256").update(id, "utf8").digest("hex").slice(0, 24) + ".json";
 }
-async function renameWithRetry(src, dest) {
-  let lastErr;
-  for (let attempt = 0; attempt < 3; attempt++) {
-    try {
-      await fsp.rename(src, dest);
-      return;
-    } catch (e) {
-      lastErr = e;
-      const code = e.code;
-      if (code !== "EPERM" && code !== "EBUSY" && code !== "EACCES") throw e;
-      const { promise, resolve } = Promise.withResolvers();
-      setTimeout(resolve, 20 * (attempt + 1));
-      await promise;
-    }
-  }
-  throw lastErr;
-}
 function errText(e) {
   return e instanceof Error ? e.message : String(e);
 }
@@ -49590,6 +49685,57 @@ function rel(p2, base) {
   return r && !r.startsWith("..") ? r : p2;
 }
 
+// src/persist-eperm.ts
+var LOCK_CODES = /\b(EPERM|EBUSY|EACCES)\b/;
+var WRITE_FAIL_RE = /^\[persist\] write failed for (.+?) \(total (\d+)x\): (.+)$/;
+var PersistEpermAlert = class {
+  dir;
+  threshold;
+  repeatMs;
+  platform;
+  now;
+  onAlert;
+  hasAlerted = false;
+  alertedAt = 0;
+  constructor(opts) {
+    this.dir = opts.dir;
+    this.threshold = opts.threshold ?? 5;
+    this.repeatMs = opts.repeatMs ?? 0;
+    this.platform = opts.platform ?? process.platform;
+    this.now = opts.now ?? Date.now;
+    this.onAlert = opts.onAlert ?? ((d, c) => log("warn", buildAlertMessage(d, c)));
+  }
+  // Returns true iff an alert was emitted. Runs on every kernel log line, so
+  // the non-matching cases bail before any allocation.
+  observe(level, msg) {
+    if (this.platform !== "win32") return false;
+    if (level !== "error" && level !== "warn") return false;
+    const m2 = WRITE_FAIL_RE.exec(msg);
+    if (!m2) return false;
+    const count = Number(m2[2]);
+    if (count < this.threshold) return false;
+    if (!LOCK_CODES.test(m2[3])) return false;
+    if (!this.shouldAlert()) return false;
+    this.hasAlerted = true;
+    this.alertedAt = this.now();
+    this.onAlert(this.dir, count);
+    return true;
+  }
+  shouldAlert() {
+    if (!this.hasAlerted) return true;
+    if (this.repeatMs <= 0) return false;
+    return this.now() - this.alertedAt >= this.repeatMs;
+  }
+};
+function buildAlertMessage(dir, count) {
+  return [
+    `[persist] session dir ${dir} failed ${count} consecutive writes (EPERM \u2014 rename is locked).`,
+    "Likely cause: Windows Defender / antivirus / indexer / a sync tool is locking the directory.",
+    `Fix: add ${dir} to Windows Defender exclusions (Settings \u2192 Virus & threat protection \u2192 Manage settings \u2192 Exclusions \u2192 Add an exclusion),`,
+    "and make sure no OneDrive / sync tool is syncing this path."
+  ].join("\n");
+}
+
 // src/persist.ts
 var PERSIST_VERSION = 3;
 function mergeState(parsed) {
@@ -49626,12 +49772,21 @@ var SessionStore = class {
     const debounceMs = opts?.debounceMs ?? defaultDebounce();
     this.enabled = (opts?.enabled ?? true) && debounceMs >= 0;
     this.dir = opts?.dir ?? defaultDir();
+    const baseLog = opts?.log ?? defaultLogger;
+    const epermAlert = new PersistEpermAlert({
+      dir: this.dir,
+      threshold: epermAlertThreshold(),
+      repeatMs: epermAlertRepeatMs()
+    });
     this.store = new StateStore({
       dir: this.dir,
       version: PERSIST_VERSION,
       debounceMs: Math.max(0, debounceMs),
       enabled: this.enabled,
-      log: opts?.log ?? defaultLogger,
+      log: (level, msg) => {
+        epermAlert.observe(level, msg);
+        baseLog(level, msg);
+      },
       relPath: (id, payload) => relPathFor(id, payload.meta?.protocol ?? payload.protocol, payload.meta?.upstreamOrigin ?? payload.upstreamOrigin),
       // Adopt the pre-envelope flat format this store itself wrote
       // before the kernel extraction (and every v1/v2 file before it).
@@ -49840,6 +49995,22 @@ function persistEnabled() {
   if (env === "0" || env === "false") return false;
   return true;
 }
+function epermAlertThreshold() {
+  const env = process.env.BILI_PERSIST_EPERM_ALERT_THRESHOLD;
+  if (env) {
+    const n = Number.parseInt(env, 10);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return 5;
+}
+function epermAlertRepeatMs() {
+  const env = process.env.BILI_PERSIST_EPERM_ALERT_REPEAT_MS;
+  if (env) {
+    const n = Number.parseInt(env, 10);
+    if (Number.isFinite(n) && n >= 0) return n;
+  }
+  return 0;
+}
 function defaultLogger(level, m2) {
   log(level, m2);
 }
@@ -50005,9 +50176,9 @@ async function flushAllSessions() {
 function parseCompressInput(input, callId) {
   const { ranges, diagnostics } = parseCompressArgs(input, { callId });
   if (!diagnostics.ok && diagnostics.kind !== "ok") {
-    log("warn", `[acp-compress-input] rejected: kind=${diagnostics.kind} invalidItems=${diagnostics.invalidItems}${diagnostics.keys ? ` keys=[${diagnostics.keys.join(",")}]` : ""}${diagnostics.length !== void 0 ? ` len=${diagnostics.length}` : ""}`);
+    log("warn", `[acp-compress-input] rejected: kind=${diagnostics.kind} invalidItems=${diagnostics.invalidItems}${diagnostics.keys ? ` keys=[${diagnostics.keys.join(",")}]` : ""}${diagnostics.length !== void 0 ? ` len=${diagnostics.length}` : ""}${diagnostics.invalidReasons && diagnostics.invalidReasons.length > 0 ? ` reasons=[${diagnostics.invalidReasons.join(" | ")}]` : ""}`);
   }
-  return ranges;
+  return { ranges, diagnostics };
 }
 var STAGED_COMPRESS_GUIDANCE = "\n\n[Smooth-transition guidance: when you compress, prefer a SMALLER, TAIL-biased range \u2014 compress the most recent large content and keep the stable prefix (the earliest messages) intact. A large single rewrite changes the request shape sharply and can trip provider risk-control; smaller tail-biased folds keep the prefix cache alive and the transition gentle.]";
 function withStagedCompressGuidance(text) {
@@ -50103,17 +50274,23 @@ function normalizeSseLineEndings(buf) {
 var PAIRED = /\x3cacp\s[^<>]{0,256}>([^<>]{0,64})<\/acp>/;
 var LONE_OPEN = /\x3cacp(?:\s[^<>]{0,256})?>/;
 var LONE_CLOSE = /<\/acp(?=[\s>])[^<>]{0,32}>/;
-var PARTIAL_TAIL = /(\x3cacp\s[^<>]*|<\/?a?c?p?)$/;
+var PARTIAL_TAIL = /(\x3cacp\s[^<>]*|\x3c\/acp(?:\s[^<>]*)?|<\/?a?c?p?)$/;
 var TRUNC_OPEN = /\x3cacp\s[^<>]*$/;
+var TRUNC_CLOSE = /\x3c\/acp(?:\s[^<>]*)?$/;
 var CLOSE_TAG = "</acp";
 var HOLD_LIMIT = 128;
 var TAG_OPEN_CAP = 4096;
 var SWALLOW_CAP = 80;
 function stripAcpTags(text) {
-  return text.replace(new RegExp(PAIRED.source, "g"), "").replace(new RegExp(LONE_OPEN.source, "g"), "").replace(new RegExp(LONE_CLOSE.source, "g"), "").replace(new RegExp(TRUNC_OPEN.source), "");
+  return text.replace(new RegExp(PAIRED.source, "g"), "").replace(new RegExp(LONE_OPEN.source, "g"), "").replace(new RegExp(LONE_CLOSE.source, "g"), "").replace(new RegExp(TRUNC_OPEN.source), "").replace(new RegExp(TRUNC_CLOSE.source), "");
 }
+var RENDER_TAG_DETECT = /\x3c\/?acp(?=[\s>])|\\u003c\/?acp(?=[\s>\\])/;
 function containsRenderTagText(s3) {
-  return /\x3c\/?acp(?=[\s>])/.test(s3) || /\\u003c\/?acp(?=[\s>\\])/.test(s3);
+  return RENDER_TAG_DETECT.test(s3);
+}
+var TOOL_CALL_XML = /\x3c\/?(?:antml:)?(invoke|tool_calls|tool_call|parameter|parameters)\b[^<>]*\x3e|\\u003c\/?(?:antml:)?(invoke|tool_calls|tool_call|parameter|parameters)\b|\x3c\/?antml:[a-z_]+/i;
+function containsToolCallXmlFragment(s3) {
+  return TOOL_CALL_XML.test(s3);
 }
 function createTagEchoFilter(onDrop) {
   let held = "";
@@ -50162,7 +50339,7 @@ function createTagEchoFilter(onDrop) {
       if (!m2) {
         const t = PARTIAL_TAIL.exec(buf);
         if (t) {
-          const definite = /^\x3cacp\s/.test(t[0]);
+          const definite = /^\x3cacp\s/.test(t[0]) || /^\x3c\/acp/.test(t[0]);
           const cap = definite ? TAG_OPEN_CAP : HOLD_LIMIT;
           if (t[0].length <= cap) {
             held = t[0];
@@ -50209,6 +50386,11 @@ function createTagEchoFilter(onDrop) {
         drop(t[0]);
         return rest.slice(0, t.index);
       }
+      const tc = new RegExp(TRUNC_CLOSE.source).exec(rest);
+      if (tc) {
+        drop(tc[0]);
+        return rest.slice(0, tc.index);
+      }
       return rest;
     },
     dropped() {
@@ -50291,10 +50473,15 @@ ${lines.join("\n\n")}`;
 function refNum2(ref) {
   return Number(ref.replace(/\D/g, "")) || 0;
 }
-function applyRanges(ranges, ctx) {
+function applyRanges(parsed, ctx) {
+  const { ranges, diagnostics } = parsed;
   if (ranges.length === 0) {
     ctx.log("[acp-proxy: compress call had no valid ranges; nothing compressed.]");
-    return "[Compression FAILED: no valid ranges parsed. compress requires a non-empty 'content' array of {startId, endId, summary} ranges, where startId/endId are mNNNNN message refs from the conversation. Re-issue the compress call with a valid content array.]";
+    const reasons = diagnostics.invalidReasons?.slice(0, 8).map((r) => r.length > 200 ? r.slice(0, 200) + "..." : r) ?? [];
+    const why = reasons.length > 0 ? ` Rejected entries:
+${reasons.map((r) => `- ${r}`).join("\n")}` : "";
+    return `[Compression FAILED: no valid ranges parsed (kind=${diagnostics.kind}, dropped=${diagnostics.invalidItems}).${why}
+ compress requires a non-empty 'content' array of {startId, endId, summary} ranges, where startId/endId are mNNNNN message refs from the conversation. Re-issue the compress call with a valid content array.]`;
   }
   ctx.log(`[acp-proxy: compress requested ${ranges.length} range(s): ${ranges.map((r) => `${r.startRef}\u2013${r.endRef}`).join(", ")}]`);
   ctx.log(`[acp-proxy: ctx has ${ctx.messages.length} message(s), state has ${ctx.session.state.messageRefs?.byRef?.size ?? "?"} ref(s) mapped]`);
@@ -55420,6 +55607,28 @@ async function decodeRequestBody(contentEncoding, input, maxOutputBytes) {
 function bodyDumpEnabled() {
   return process.env.ACP_DUMP_BODY === "1";
 }
+var dumpFailCount = 0;
+var lastDumpFailLog = 0;
+function logDumpFailure(where, err2) {
+  dumpFailCount++;
+  const now = Date.now();
+  if (dumpFailCount === 1 || now - lastDumpFailLog >= 6e4) {
+    lastDumpFailLog = now;
+    const msg = err2 instanceof Error ? err2.message : String(err2);
+    log("warn", `[dump] ${where} failed (total ${dumpFailCount}x): ${msg}`);
+  }
+}
+var unrecognizedPathCounts = /* @__PURE__ */ new Map();
+function logUnrecognizedPath(log2, url) {
+  const key = maskUrlsInText(url.split("?")[0]);
+  const n = (unrecognizedPathCounts.get(key) ?? 0) + 1;
+  unrecognizedPathCounts.set(key, n);
+  if (n <= 3) {
+    log2("warn", `unrecognized path ${key} \u2014 not a known protocol (/chat/completions, /v1/messages, /responses, /responses/compact); forwarding unchanged`);
+  } else if (n === 4) {
+    log2("info", `unrecognized path ${key}: forwarding unchanged; further occurrences suppressed`);
+  }
+}
 var BILI_HOP_HEADER = "x-bili-hop";
 function parseLauncherModelWindows(raw) {
   if (!raw) return {};
@@ -55867,7 +56076,8 @@ async function handle(req, res, opts, core, config, log2, instanceId) {
 ${hdrText}
 
 ${bodyBuffer.toString("utf8")}`);
-    } catch {
+    } catch (err2) {
+      logDumpFailure("INCOMING dump", err2);
     }
   }
   let reqConfig = config;
@@ -56072,7 +56282,7 @@ ${bodyBuffer.toString("utf8")}`);
   }
   if (!prepared) {
     if (protocol === null && !opts.passthrough) {
-      log2("warn", `unrecognized path ${maskUrlsInText(req.url ?? "")} \u2014 not a known protocol (/chat/completions, /v1/messages, /responses, /responses/compact); forwarding unchanged`);
+      logUnrecognizedPath(log2, req.url ?? "");
     }
     await forward(req, res, opts, bodyBuffer, null, core, reqConfig, log2, route, instanceId, void 0);
   }
@@ -56697,7 +56907,8 @@ ${hdrText}
 
 ${bodyText}`);
       log2("info", `[debug] RAW request dump: ${reqPath}`);
-    } catch {
+    } catch (err2) {
+      logDumpFailure("REQ dump", err2);
     }
   }
   const dispatcher = proxyDispatcher(proxyUrl);
@@ -56745,7 +56956,8 @@ ${bodyText}`);
 ${hdrText}
 `);
       log2("info", `[debug] RAW response dump: ${resPath}`);
-    } catch {
+    } catch (err2) {
+      logDumpFailure("RES dump", err2);
     }
   }
   if (!upstream.ok) {
@@ -56881,12 +57093,16 @@ ${hdrText}
         systemPrompt,
         clientAbort.signal
       );
+      let protocolFragmentWarned = false;
       for await (const chunk of loop) {
         if (res.destroyed || res.writableEnded) break;
         {
           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`);
+          } else if (!protocolFragmentWarned && containsToolCallXmlFragment(s3)) {
+            protocolFragmentWarned = true;
+            log2("warn", `[${prepared.session.id}] tag echo: ${prepared.protocol} response stream contains tool-call XML fragment (possible tag echo; not stripped)`);
           }
         }
         res.write(chunk);
@@ -56994,7 +57210,7 @@ async function dumpStreamToFile(stream2, dir, name) {
     mkdirSync6(dir, { recursive: true });
     const ws2 = createWriteStream2(join4(dir, name));
     ws2.on("error", (e) => {
-      log("debug", `[dump] write stream error: ${e.message ?? e}`);
+      logDumpFailure("SSE stream dump", e);
     });
     const reader = stream2.getReader();
     try {
@@ -57007,7 +57223,8 @@ async function dumpStreamToFile(stream2, dir, name) {
       reader.releaseLock();
       ws2.end();
     }
-  } catch {
+  } catch (err2) {
+    logDumpFailure("SSE stream dump", err2);
   }
 }
 function deriveTitle(messages) {