billion-context-omp 0.2.6 → 0.2.7

package/dist/index.js

@@ -70,6 +70,7 @@ function createInitialState() {
   return {
     blocks: [],
     messageRefs: { byRaw: {}, byRef: {} },
+    tokenSnapshot: {},
     nudge: {
       lastPerMessageNudgeTokens: 0,
       lastNudgeShownTokens: 0,
@@ -239,11 +240,23 @@ function syncBlocks(messages, state) {
       byRaw: { ...state.messageRefs.byRaw },
       byRef: { ...state.messageRefs.byRef }
     },
+    // Snapshot is keyed by ref with primitive values — shallow copy suffices.
+    tokenSnapshot: { ...state.tokenSnapshot ?? {} },
     nudge: { ...state.nudge, anchors: { ...state.nudge.anchors } },
     stats: { ...state.stats },
     nextBlockId: state.nextBlockId,
     nextRunId: state.nextRunId
   };
+  const liveRefs = new Set(
+    messages.map((m) => result.messageRefs.byRaw[m.id]).filter((r) => typeof r === "string")
+  );
+  if (Object.keys(result.tokenSnapshot).length !== liveRefs.size) {
+    const pruned = {};
+    for (const [ref, n] of Object.entries(result.tokenSnapshot)) {
+      if (liveRefs.has(ref)) pruned[ref] = n;
+    }
+    result.tokenSnapshot = pruned;
+  }
   const consumedBlockIds = /* @__PURE__ */ new Set();
   for (const block of result.blocks) {
     for (const consumedId of block.directBlockIds) {
@@ -718,7 +731,7 @@ var TAG_CLOSE = LT + "/acp" + GT;
 function acpTag(ref, tokens, type5) {
   return TAG_OPEN + 'tokens="' + formatTokens(tokens) + '" type="' + type5 + '"' + GT + ref + TAG_CLOSE;
 }
-function renderMessage(message, map, countTokens, strategy) {
+function renderMessage(message, map, countTokens, strategy, snapshot = null) {
   const ref = refForRaw(map, message.id);
   if (!ref || ref === BLOCKED_REF) return message;
   if (strategy === "none") return message;
@@ -729,7 +742,7 @@ function renderMessage(message, map, countTokens, strategy) {
     "^" + escapeRegex(TAG_OPEN) + "[^>]*" + GT + escapeRegex(ref) + escapeRegex(TAG_CLOSE) + "\\n?"
   );
   const cleanText = (message.text || "").replace(ownTagRe, "");
-  const tokens = countTokens(cleanText);
+  const tokens = snapshot ? snapshot[ref] ?? (snapshot[ref] = countTokens(cleanText)) : countTokens(cleanText);
   const type5 = classifyType(message);
   const prefix = acpTag(ref, tokens, type5) + "\n";
   if (!cleanText) return { ...message, text: prefix };
@@ -741,14 +754,27 @@ function renderVisibleRefs(messages, state, countTokens = (text) => Math.ceil(te
     (message) => renderMessage(message, map, countTokens, strategy)
   );
 }
+function renderWithSnapshot(messages, state, countTokens = (text) => Math.ceil(text.length / 4), strategy = "all") {
+  const map = state.messageRefs;
+  const snapshot = { ...state.tokenSnapshot ?? {} };
+  const rendered = messages.map(
+    (message) => renderMessage(message, map, countTokens, strategy, snapshot)
+  );
+  return { messages: rendered, tokenSnapshot: snapshot };
+}
 function createRenderRefsNode(strategy) {
   return {
     name: "render-refs",
     run(io, ctx) {
-      return {
-        ...io,
-        messages: renderVisibleRefs(io.messages, io.state, ctx.countTokens, strategy)
-      };
+      const { messages, tokenSnapshot } = renderWithSnapshot(
+        io.messages,
+        io.state,
+        ctx.countTokens,
+        strategy
+      );
+      const prev = io.state.tokenSnapshot;
+      const changed = !prev || Object.keys(tokenSnapshot).length !== Object.keys(prev).length;
+      return changed ? { ...io, messages, state: { ...io.state, tokenSnapshot } } : { ...io, messages };
     }
   };
 }
@@ -944,6 +970,7 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs, cou
       ref,
       refNum: rn,
       tokens: countTokens(msg.text ?? ""),
+      chars: (msg.text ?? "").length,
       isTool: isToolMessage(msg),
       isUser: msg.role === "user"
     });
@@ -964,6 +991,7 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs, cou
         endRef: info.ref,
         count: 1,
         tokens: info.tokens,
+        chars: info.chars,
         toolPct: info.isTool ? 100 : 0,
         textPct: info.isTool ? 0 : 100
       };
@@ -971,6 +999,7 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs, cou
       cur.endRef = info.ref;
       cur.count++;
       cur.tokens += info.tokens;
+      cur.chars = (cur.chars ?? 0) + info.chars;
       if (info.isTool) {
         cur.toolPct = Math.round((cur.toolPct * (cur.count - 1) + 100) / cur.count);
       } else {
@@ -1018,6 +1047,7 @@ function mergeBatch(batch) {
   const last = batch[batch.length - 1];
   const count = batch.reduce((s, r) => s + r.count, 0);
   const tokens = batch.reduce((s, r) => s + r.tokens, 0);
+  const chars = batch.reduce((s, r) => s + rangeChars(r), 0);
   const toolPct = Math.round(
     batch.reduce((s, r) => s + r.toolPct * r.count, 0) / count
   );
@@ -1026,6 +1056,7 @@ function mergeBatch(batch) {
     endRef: last.endRef,
     count,
     tokens,
+    chars,
     toolPct,
     textPct: 100 - toolPct
   };
@@ -1034,16 +1065,21 @@ function mergeBatch(batch) {
   }
   return merged;
 }
+function rangeChars(r) {
+  return r.chars ?? r.tokens * 4;
+}
 function mergeRangesToThreshold(ranges, minChars) {
   if (minChars <= 0 || ranges.length === 0) return ranges;
   const result = [];
   let batch = [];
+  let batchChars = 0;
   for (const r of ranges) {
     batch.push(r);
-    const batchTokens = batch.reduce((s, x) => s + x.tokens, 0);
-    if (batchTokens * 4 >= minChars) {
+    batchChars += rangeChars(r);
+    if (batchChars >= minChars) {
       result.push(mergeBatch(batch));
       batch = [];
+      batchChars = 0;
     }
   }
   if (batch.length > 0) {
@@ -1631,7 +1667,7 @@ function resolveAdaptiveGrowth(modelContextLimit, nudge) {
 function pendingByTier(state, recommendation, countTokens, minCompressRange) {
   const out = {};
   const merged = recommendation?.recommendedRanges ?? [];
-  const effective = minCompressRange > 0 ? merged.filter((r) => r.tokens * 4 >= minCompressRange) : merged;
+  const effective = minCompressRange > 0 ? merged.filter((r) => (r.chars ?? r.tokens * 4) >= minCompressRange) : merged;
   out[1] = { pending: effective.reduce((s, r) => s + r.tokens, 0), targetBlocks: [] };
   const active = activeBlocks(state);
   const t1 = active.filter((b) => b.tier === 1);
@@ -1793,6 +1829,7 @@ function cloneState(state) {
       byRaw: { ...state.messageRefs.byRaw },
       byRef: { ...state.messageRefs.byRef }
     },
+    tokenSnapshot: { ...state.tokenSnapshot ?? {} },
     nudge: { ...state.nudge, anchors: { ...state.nudge.anchors } },
     stats: { ...state.stats },
     nextBlockId: state.nextBlockId,
@@ -2757,8 +2794,12 @@ function resolveConfig(adapter, liveContextLimit) {
   if (c?.maxContextLimit !== void 0) config.nudge.maxContextLimitPct = parsePercent(c.maxContextLimit);
   if (c?.emergencyThresholdPercent !== void 0) {
     const pct2 = parsePercent(c.emergencyThresholdPercent);
-    config.nudge.emergencyThresholdPct = pct2;
-    config.truncate.threshold = pct2;
+    if (pct2 <= 0) {
+      logWarn("config", { event: "emergency-threshold-ignored", value: String(c.emergencyThresholdPercent), reason: "zero threshold would truncate every turn" });
+    } else {
+      config.nudge.emergencyThresholdPct = pct2;
+      config.truncate.threshold = pct2;
+    }
   }
   if (c?.nudgeGrowthTokens !== void 0) {
     config.nudge.growthFloor = c.nudgeGrowthTokens;
@@ -2863,8 +2904,396 @@ When context usage passes a threshold, the system appends a breakdown showing wh
 `;
 }
 
-// src/messages.ts
+// src/transform-mode.ts
+import { VERSION } from "@oh-my-pi/pi-utils";
+var PROVIDER_VIABLE_APIS = /* @__PURE__ */ new Set(["anthropic-messages", "ollama-chat"]);
+var OPENAI_COMPLETIONS_VIABLE_FROM = [17, 3, 8];
+function hostVersionAtLeast(min, version = VERSION) {
+  const m = /^(\d+)\.(\d+)\.(\d+)/.exec(version ?? "");
+  if (!m) return false;
+  const v = [Number(m[1]), Number(m[2]), Number(m[3])];
+  return v[0] > min[0] || v[0] === min[0] && (v[1] > min[1] || v[1] === min[1] && v[2] >= min[2]);
+}
+function resolveTransformMode(adapter, model, hostVersion = VERSION) {
+  if (adapter.transformMode) return adapter.transformMode;
+  const api = model?.api;
+  if (api == null) return "context";
+  if (PROVIDER_VIABLE_APIS.has(api)) return "provider";
+  if (api === "openai-completions" && hostVersionAtLeast(OPENAI_COMPLETIONS_VIABLE_FROM, hostVersion)) return "provider";
+  return "context";
+}
+
+// node_modules/acp-kernel/dist/wire/index.js
 import { createHash } from "crypto";
+function hashId(s) {
+  return createHash("sha256").update(s, "utf8").digest("hex").slice(0, 16);
+}
+function deriveMessageId(role, contentType, text, options = {}) {
+  const seed = `${role}|${contentType}|${options.toolCallId ?? ""}|${options.toolName ?? ""}|${text}`;
+  return "h_" + hashId(seed);
+}
+var ClusterCounter = class {
+  counts = /* @__PURE__ */ new Map();
+  next(baseId) {
+    const n = this.counts.get(baseId) ?? 0;
+    this.counts.set(baseId, n + 1);
+    return n === 0 ? baseId : `${baseId}_${n}`;
+  }
+};
+function anthropicToCore(body) {
+  const msgs = [];
+  const cacheControls = /* @__PURE__ */ new Map();
+  const clusters = new ClusterCounter();
+  for (const m of body.messages) {
+    const blocks = typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content;
+    for (const b of blocks) {
+      switch (b.type) {
+        case "text": {
+          const base = deriveMessageId(m.role, "text", b.text);
+          const id = clusters.next(base);
+          msgs.push({ id, role: m.role, contentType: "text", text: b.text });
+          if (b.cache_control) cacheControls.set(id, b.cache_control);
+          break;
+        }
+        case "tool_use": {
+          const base = deriveMessageId("assistant", "tool-call", safeStringify(b.input), {
+            toolCallId: b.id,
+            toolName: b.name
+          });
+          const id = clusters.next(base);
+          msgs.push({
+            id,
+            role: "assistant",
+            contentType: "tool-call",
+            toolName: b.name,
+            toolCallId: b.id,
+            text: safeStringify(b.input)
+          });
+          if (b.cache_control) cacheControls.set(id, b.cache_control);
+          break;
+        }
+        case "tool_result": {
+          const text = typeof b.content === "string" ? b.content : b.content.map((c) => c.text).join("\n");
+          const base = deriveMessageId("tool", "tool-result", text, { toolCallId: b.tool_use_id });
+          const id = clusters.next(base);
+          msgs.push({
+            id,
+            role: "tool",
+            contentType: "tool-result",
+            toolCallId: b.tool_use_id,
+            text,
+            ...b.is_error === true ? { toolIsError: true } : {}
+          });
+          if (b.cache_control) cacheControls.set(id, b.cache_control);
+          break;
+        }
+        case "thinking": {
+          const base = deriveMessageId("assistant", "reasoning", b.thinking);
+          msgs.push({
+            id: clusters.next(base),
+            role: "assistant",
+            contentType: "reasoning",
+            text: b.thinking,
+            ...b.signature ? { thinkingSignature: b.signature } : {}
+          });
+          break;
+        }
+        case "image": {
+          const base = deriveMessageId(m.role, "text", "[image]");
+          msgs.push({
+            id: clusters.next(base),
+            role: m.role,
+            contentType: "text",
+            text: "[image]",
+            rawAnthropicBlock: b
+          });
+          break;
+        }
+      }
+    }
+  }
+  return { msgs, cacheControls };
+}
+function coreToAnthropic(messages, cacheControls) {
+  const out = [];
+  let current = null;
+  const flush = () => {
+    if (current && current.blocks.length > 0) {
+      out.push({ role: current.role, content: current.blocks });
+    }
+    current = null;
+  };
+  const cc = (id) => {
+    const v = cacheControls?.get(id);
+    return v ? { cache_control: v } : {};
+  };
+  for (const m of messages) {
+    const target = m.role === "assistant" ? "assistant" : "user";
+    if (!current || current.role !== target) {
+      flush();
+      current = { role: target, blocks: [] };
+    }
+    switch (m.contentType) {
+      case "text": {
+        if (m.rawAnthropicBlock) {
+          current.blocks.push(m.rawAnthropicBlock);
+          break;
+        }
+        current.blocks.push({ type: "text", text: m.text ?? "", ...cc(m.id) });
+        break;
+      }
+      case "tool-call":
+        current.blocks.push({
+          type: "tool_use",
+          id: m.toolCallId ?? `call_${m.id}`,
+          name: m.toolName ?? "unknown",
+          input: safeParse(m.text),
+          ...cc(m.id)
+        });
+        break;
+      case "tool-result":
+        current.blocks.push({
+          type: "tool_result",
+          tool_use_id: m.toolCallId ?? "",
+          content: m.text ?? "",
+          ...m.toolIsError ? { is_error: true } : {},
+          ...cc(m.id)
+        });
+        break;
+      case "reasoning":
+        current.blocks.push({
+          type: "thinking",
+          thinking: m.text ?? "",
+          ...m.thinkingSignature ? { signature: m.thinkingSignature } : {}
+        });
+        break;
+    }
+  }
+  flush();
+  return out;
+}
+function safeStringify(v) {
+  try {
+    return JSON.stringify(v ?? {});
+  } catch {
+    return "{}";
+  }
+}
+function safeParse(s) {
+  if (!s) return {};
+  try {
+    return JSON.parse(s);
+  } catch {
+    return {};
+  }
+}
+function parseDataUrl(url) {
+  const m = /^data:([^;,]+)(?:;base64)?,(.+)$/i.exec(url);
+  if (!m) return void 0;
+  return { mediaType: m[1], base64: m[2] };
+}
+function openaiToCore(body) {
+  const msgs = [];
+  const clusters = new ClusterCounter();
+  for (const m of body.messages) {
+    switch (m.role) {
+      case "system":
+      case "developer": {
+        const base = deriveMessageId(m.role, "text", stringContent(m.content));
+        msgs.push({ id: clusters.next(base), role: "system", contentType: "text", text: stringContent(m.content), originalRole: m.role });
+        break;
+      }
+      case "user": {
+        const text = stringContent(m.content);
+        const img = firstImagePart(m.content);
+        const base = deriveMessageId("user", "text", text);
+        msgs.push({
+          id: clusters.next(base),
+          role: "user",
+          contentType: "text",
+          text,
+          ...img ? { rawOpenaiContent: img.part, imageMediaType: img.mediaType, imageBase64: img.base64 } : {}
+        });
+        break;
+      }
+      case "assistant": {
+        const reasoning = typeof m.reasoning_content === "string" ? m.reasoning_content : "";
+        if (reasoning) {
+          const base = deriveMessageId("assistant", "reasoning", reasoning);
+          msgs.push({
+            id: clusters.next(base),
+            role: "assistant",
+            contentType: "reasoning",
+            text: reasoning,
+            reasoningContent: reasoning
+          });
+        }
+        const text = stringContent(m.content);
+        if (text) {
+          const base = deriveMessageId("assistant", "text", text);
+          msgs.push({ id: clusters.next(base), role: "assistant", contentType: "text", text });
+        }
+        if (Array.isArray(m.tool_calls)) {
+          for (const tc of m.tool_calls) {
+            const base = deriveMessageId("assistant", "tool-call", tc.function.arguments ?? "", {
+              toolCallId: tc.id,
+              toolName: tc.function.name
+            });
+            msgs.push({
+              id: clusters.next(base),
+              role: "assistant",
+              contentType: "tool-call",
+              toolName: tc.function.name,
+              toolCallId: tc.id,
+              text: tc.function.arguments ?? ""
+            });
+          }
+        }
+        break;
+      }
+      case "tool": {
+        const base = deriveMessageId("tool", "tool-result", stringContent(m.content), {
+          toolCallId: m.tool_call_id ?? ""
+        });
+        msgs.push({
+          id: clusters.next(base),
+          role: "tool",
+          contentType: "tool-result",
+          toolCallId: m.tool_call_id ?? "",
+          text: stringContent(m.content)
+        });
+        break;
+      }
+    }
+  }
+  return { msgs };
+}
+function coreToOpenai(messages) {
+  const out = [];
+  let pending = null;
+  const flush = () => {
+    if (!pending) return;
+    const reasoning = pending.reasoning !== null && pending.reasoning.length > 0 ? pending.reasoning : void 0;
+    if (pending.toolCalls.length > 0) {
+      out.push({
+        role: "assistant",
+        content: pending.text ?? null,
+        tool_calls: pending.toolCalls,
+        ...reasoning ? { reasoning_content: reasoning } : {}
+      });
+    } else if (pending.text !== null) {
+      out.push({ role: "assistant", content: pending.text, ...reasoning ? { reasoning_content: reasoning } : {} });
+    } else if (reasoning) {
+      out.push({ role: "assistant", content: null, reasoning_content: reasoning });
+    }
+    pending = null;
+  };
+  for (const m of messages) {
+    if (m.role === "assistant") {
+      if (!pending) pending = { text: null, toolCalls: [], reasoning: null };
+      if (m.contentType === "reasoning") {
+        pending.reasoning = (pending.reasoning ?? "") + (m.reasoningContent ?? m.text ?? "");
+      } else if (m.contentType === "text") {
+        pending.text = (pending.text ?? "") + (m.text ?? "");
+      } else if (m.contentType === "tool-call") {
+        pending.toolCalls.push({
+          id: m.toolCallId ?? `call_${m.id}`,
+          type: "function",
+          function: { name: m.toolName ?? "unknown", arguments: m.text ?? "" }
+        });
+      }
+    } else {
+      flush();
+      if (m.role === "system") {
+        out.push({ role: m.originalRole === "developer" ? "developer" : "system", content: m.text ?? "" });
+      } else if (m.role === "user") {
+        if (m.rawOpenaiContent || m.imageBase64) {
+          const parts = [];
+          if (m.text) parts.push({ type: "text", text: m.text });
+          if (m.rawOpenaiContent) {
+            parts.push(m.rawOpenaiContent);
+          } else if (m.imageBase64 && m.imageMediaType) {
+            parts.push({ type: "image_url", image_url: { url: `data:${m.imageMediaType};base64,${m.imageBase64}` } });
+          }
+          out.push({ role: "user", content: parts });
+        } else {
+          out.push({ role: "user", content: m.text ?? "" });
+        }
+      } else if (m.role === "tool") {
+        out.push({ role: "tool", tool_call_id: m.toolCallId ?? "", content: m.text ?? "" });
+      }
+    }
+  }
+  flush();
+  return out;
+}
+function stringContent(content) {
+  if (content == null) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((p) => typeof p === "string" ? p : p.type === "text" ? p.text ?? "" : "").join("\n");
+  }
+  return "";
+}
+function firstImagePart(content) {
+  if (!Array.isArray(content)) return void 0;
+  for (const p of content) {
+    if (p && typeof p === "object" && p.type === "image_url") {
+      const iu = p.image_url;
+      const url = iu?.url;
+      if (typeof url === "string") {
+        const parsed = parseDataUrl(url);
+        if (parsed) return { part: p, mediaType: parsed.mediaType, base64: parsed.base64 };
+      }
+    }
+  }
+  return void 0;
+}
+function createSubagentNamespaces() {
+  const anchors = /* @__PURE__ */ new Map();
+  return {
+    namespaceFor(identityValue, instructions) {
+      if (typeof instructions !== "string" || instructions.trim().length === 0) return identityValue;
+      const fp = hashId(instructions);
+      const anchor = anchors.get(identityValue);
+      if (anchor === void 0) {
+        anchors.set(identityValue, fp);
+        return identityValue;
+      }
+      return anchor === fp ? identityValue : `${identityValue}|sub:${fp}`;
+    }
+  };
+}
+var defaultNamespaces = createSubagentNamespaces();
+function detectWireFormat(payload) {
+  if (payload === null || typeof payload !== "object") return void 0;
+  const p = payload;
+  if (Array.isArray(p.input)) return "responses";
+  const messages = p.messages;
+  if (!Array.isArray(messages)) return void 0;
+  if ("system" in p || "anthropic_version" in p) return "anthropic";
+  for (const m of messages) {
+    if (m === null || typeof m !== "object") continue;
+    const c = m.content;
+    if (Array.isArray(c)) {
+      for (const b of c) {
+        if (b && typeof b === "object" && typeof b.type === "string") {
+          if (b.type === "tool_use" || b.type === "tool_result" || b.type === "thinking")
+            return "anthropic";
+          if (b.type === "text" && "cache_control" in b) return "anthropic";
+        }
+      }
+    }
+    if (Array.isArray(m.tool_calls)) return "openai";
+    if (m.role === "tool" && typeof m.tool_call_id === "string")
+      return "openai";
+    if (m.role === "system" || m.role === "developer") return "openai";
+  }
+  return "openai";
+}
+
+// src/messages.ts
+import { createHash as createHash2 } from "crypto";
 var REF_TAG_SOURCE = "(?:<acp\\s[^>]*>m\\d+</acp>|\\[m\\d+\\])";
 var REF_TAG = new RegExp(`^${REF_TAG_SOURCE}\\s?\\n?`);
 var TRAILING_REF_TAG = new RegExp(`\\n*${REF_TAG_SOURCE}\\s*$`);
@@ -3004,7 +3433,7 @@ function fallbackText(msg) {
 function stringifyArgs(args) {
   if (!args) return "";
   if (typeof args === "string") return args;
-  return safeStringify(args);
+  return safeStringify2(args);
 }
 function extractText(content, stripTags = true) {
   const clean = stripTags ? stripRefTag : (s) => s;
@@ -3060,7 +3489,7 @@ function allToolCalls(content) {
   }
   return calls;
 }
-function safeStringify(value) {
+function safeStringify2(value) {
   try {
     return JSON.stringify(value);
   } catch {
@@ -3218,7 +3647,7 @@ function spanFingerprint(coreMessages, startId, endId) {
   const first = find(startId);
   const last = find(endId);
   if (!first || !last) return "";
-  return createHash("sha1").update(`${key(first)}\0${key(last)}`).digest("hex").slice(0, 8);
+  return createHash2("sha1").update(`${key(first)}\0${key(last)}`).digest("hex").slice(0, 8);
 }
 function isBlockRef(ref) {
   return /^b\d+$/i.test(ref.trim());
@@ -3247,249 +3676,179 @@ function rangeFingerprints(ranges, coreMessages, byRef, blocks) {
   });
 }
 
-// src/wire-transform.ts
-var AI = /* @__PURE__ */ Symbol("acp.streamIndex");
-function detectWireFormat(payload) {
-  if (payload === null || typeof payload !== "object") return "unknown";
-  const p = payload;
-  const messages = p.messages;
-  if (!Array.isArray(messages)) return "unknown";
-  if ("system" in p || "anthropic_version" in p) return "anthropic";
-  for (const m of messages) {
-    if (m === null || typeof m !== "object") continue;
-    const c = m.content;
-    if (Array.isArray(c)) {
-      for (const b of c) {
-        if (b && typeof b === "object" && typeof b.type === "string") {
-          if (b.type === "tool_use" || b.type === "tool_result" || b.type === "thinking") return "anthropic";
-          if (b.type === "text" && "cache_control" in b) return "anthropic";
-        }
-      }
-    }
-    if (Array.isArray(m.tool_calls)) return "openai";
-    if (m.role === "tool" && typeof m.tool_call_id === "string") return "openai";
-    if (m.role === "system" || m.role === "developer") return "openai";
+// src/wire-fold.ts
+import { createHash as createHash3 } from "crypto";
+function detectProviderWireFormat(payload) {
+  const fmt2 = detectWireFormat(payload);
+  return fmt2 === "anthropic" || fmt2 === "openai" ? fmt2 : null;
+}
+function payloadToCore(payload, fmt2) {
+  if (fmt2 === "anthropic") {
+    const { msgs: msgs2, cacheControls } = anthropicToCore(payload);
+    return { msgs: msgs2, cacheControls };
+  }
+  const { msgs } = openaiToCore(payload);
+  return { msgs };
+}
+function coreToPayloadMessages(msgs, fmt2, cacheControls) {
+  return fmt2 === "anthropic" ? coreToAnthropic(msgs, cacheControls) : coreToOpenai(msgs);
+}
+function applyWireTagContract(msgs, state) {
+  const toolResults = msgs.filter((m) => m.contentType === "tool-result");
+  const taggedTools = toolResults.length > 0 ? renderVisibleRefs(toolResults, state, defaultCountTokens, "all") : [];
+  const bySource = new Map(toolResults.map((m, i) => [m, taggedTools[i]]));
+  return msgs.map((m) => {
+    if (m.contentType === "tool-result") return bySource.get(m) ?? m;
+    if (m.contentType === "text" && m.role === "assistant") return { ...m, text: stripRefTag(m.text ?? "") };
+    return m;
+  });
+}
+function coreIdentity(msg) {
+  return JSON.stringify({
+    role: msg.role,
+    contentType: msg.contentType,
+    toolName: msg.toolName ?? null,
+    toolCallId: msg.toolCallId ?? null,
+    text: stripRefTag(msg.text ?? "")
+  });
+}
+function toolCallNames(msgs) {
+  const names = /* @__PURE__ */ new Map();
+  for (const m of msgs) {
+    if (m.contentType === "tool-call" && m.toolCallId && m.toolName) names.set(m.toolCallId, m.toolName);
   }
-  return "openai";
+  return names;
 }
-function anthropicBlocks(m) {
-  return typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content ?? [];
+function toolResultTextsCore(msgs) {
+  const results = /* @__PURE__ */ new Map();
+  for (const m of msgs) {
+    if (m.contentType !== "tool-result" || !m.toolCallId) continue;
+    results.set(m.toolCallId, m.text ?? "");
+  }
+  return results;
 }
-var assistantBase = () => ({
-  api: "anthropic",
-  provider: "anthropic",
-  model: "wire",
-  usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
-  stopReason: "stop",
-  timestamp: Date.now()
-});
-function synthesizeStream(payload, format) {
-  const messages = payload.messages ?? [];
-  const stream = [];
-  const back = [];
-  const push = (msg, wi, kind) => {
-    msg[AI] = stream.length;
-    stream.push(msg);
-    back.push({ wi, kind });
-  };
-  if (format === "anthropic") {
-    const toolNames = /* @__PURE__ */ new Map();
-    for (const raw of messages) {
-      if (raw === null || typeof raw !== "object") continue;
-      const m = raw;
-      if (m.role !== "assistant") continue;
-      for (const b of anthropicBlocks(m)) if (b.type === "tool_use" && b.id) toolNames.set(b.id, b.name ?? "");
-    }
-    messages.forEach((raw, wi) => {
-      if (raw === null || typeof raw !== "object") return;
-      const m = raw;
-      const blocks = anthropicBlocks(m);
-      if (m.role === "user") {
-        let texts = [];
-        for (const b of blocks) {
-          if (b.type === "text" && typeof b.text === "string") texts.push(b.text);
-          else if (b.type === "tool_result") {
-            if (texts.length > 0) {
-              push({ role: "user", content: texts.map((t2) => ({ type: "text", text: t2 })), timestamp: Date.now() }, wi, "text");
-              texts = [];
-            }
-            const trText = typeof b.content === "string" ? b.content : Array.isArray(b.content) ? b.content.map((c) => c.text ?? "").join("\n") : "";
-            push({
-              role: "toolResult",
-              content: [{ type: "text", text: trText }],
-              toolName: toolNames.get(b.tool_use_id ?? "") ?? "",
-              toolCallId: b.tool_use_id ?? "",
-              isError: b.is_error === true,
-              timestamp: Date.now()
-            }, wi, "toolResult");
-          }
-        }
-        if (texts.length > 0) push({ role: "user", content: texts.map((t2) => ({ type: "text", text: t2 })), timestamp: Date.now() }, wi, "text");
-        return;
-      }
-      if (m.role === "assistant") {
-        const content = [];
-        for (const b of blocks) {
-          if (b.type === "text" && typeof b.text === "string" && b.text.length > 0) content.push({ type: "text", text: b.text });
-          else if (b.type === "tool_use") content.push({ type: "toolCall", id: b.id, name: b.name, arguments: b.input ?? {} });
-        }
-        if (content.length > 0) push({ role: "assistant", ...assistantBase(), content }, wi, "toolCall");
-        return;
-      }
-      const t = blocks.map((b) => typeof b.text === "string" ? b.text : "").join("\n");
-      if (t) push({ role: "user", content: [{ type: "text", text: t }], timestamp: Date.now() }, wi, "text");
+function findCompressCallsCore(msg) {
+  if (msg.contentType !== "tool-call" || !msg.toolName) return [];
+  const args = compressToolArgs({ name: msg.toolName, arguments: msg.text });
+  if (!args) return [];
+  const content = args.content;
+  if (!Array.isArray(content)) return [];
+  const ranges = [];
+  const callTopic = typeof args.topic === "string" ? args.topic : void 0;
+  for (const item of content) {
+    const r = item;
+    if (typeof r.startId !== "string" || typeof r.endId !== "string" || typeof r.summary !== "string" || r.summary.length === 0) continue;
+    ranges.push({
+      startRef: r.startId,
+      endRef: r.endId,
+      summary: r.summary,
+      topic: typeof r.topic === "string" ? r.topic : callTopic,
+      summaryMaxChars: typeof args.summaryMaxChars === "number" ? args.summaryMaxChars : void 0,
+      compressCallId: msg.toolCallId ?? ""
     });
-    return { stream, back, format };
-  }
-  messages.forEach((raw, wi) => {
-    if (raw === null || typeof raw !== "object") return;
-    const m = raw;
-    const textOf = () => {
-      const c = m.content;
-      if (typeof c === "string") return c;
-      if (Array.isArray(c)) return c.map((p) => p.type === "text" ? p.text ?? "" : "").join("\n");
-      return "";
-    };
-    if (m.role === "system" || m.role === "developer") {
-      const t2 = textOf();
-      if (t2) push({ role: "user", content: [{ type: "text", text: t2 }], timestamp: Date.now() }, wi, "text");
-      return;
-    }
-    if (m.role === "tool") {
-      push({
-        role: "toolResult",
-        content: [{ type: "text", text: textOf() }],
-        toolName: "",
-        toolCallId: m.tool_call_id ?? "",
-        isError: false,
-        timestamp: Date.now()
-      }, wi, "toolResult");
-      return;
-    }
-    if (m.role === "assistant") {
-      const calls = m.tool_calls ?? [];
-      if (calls.length > 0) {
-        const content = [];
-        const t3 = textOf();
-        if (t3) content.push({ type: "text", text: t3 });
-        for (const c of calls) {
-          let args = {};
-          try {
-            args = c.function?.arguments ? JSON.parse(c.function.arguments) : {};
-          } catch {
-            args = { raw: c.function?.arguments ?? "" };
-          }
-          content.push({ type: "toolCall", id: c.id, name: c.function?.name ?? "", arguments: args });
-        }
-        push({ role: "assistant", ...assistantBase(), content }, wi, "toolCall");
-        return;
-      }
-      const t2 = textOf();
-      if (t2) push({ role: "assistant", ...assistantBase(), content: [{ type: "text", text: t2 }] }, wi, "text");
-      return;
-    }
-    const t = textOf();
-    if (t) push({ role: "user", content: [{ type: "text", text: t }], timestamp: Date.now() }, wi, "text");
-  });
-  return { stream, back, format };
+  }
+  return ranges.length > 0 ? [{ id: msg.toolCallId ?? "", ranges }] : [];
 }
-function rebuildWirePayload(rebuilt, payload, synth) {
-  const messages = (payload.messages ?? []).slice();
-  const out = [];
-  const agentIndexOf = (m) => m[AI];
-  for (const agent of rebuilt) {
-    const ai = agentIndexOf(agent);
-    if (ai === void 0 || ai >= synth.back.length) {
-      const text2 = extractText(agent.content, false);
-      const role = agent.role === "assistant" ? "assistant" : "user";
-      if (synth.format === "anthropic") {
-        out.push({ role, content: [{ type: "text", text: text2 }] });
-      } else {
-        out.push({ role, content: text2 });
-      }
-      continue;
-    }
-    const { wi, kind } = synth.back[ai];
-    const src = messages[wi];
-    if (!src) {
-      out.push(agent);
-      continue;
-    }
-    if (synth.format === "anthropic") {
-      const srcMsg2 = src;
-      const blocks = anthropicBlocks(srcMsg2);
-      if (kind === "toolResult") {
-        const block2 = blocks.find((b) => b.type === "tool_result" && b.tool_use_id === agent.toolCallId);
-        const text3 = extractText(agent.content, false);
-        if (block2) {
-          out.push({ role: "user", content: [{ ...block2, content: [{ type: "text", text: text3 }] }] });
-          continue;
-        }
-      }
-      if (kind === "toolCall") {
-        const callIds = new Set(
-          (agent.content ?? []).filter((b) => b.type === "toolCall" && b.id).map((b) => b.id)
-        );
-        const agentText = extractText(agent.content, false);
-        const outBlocks = [];
-        let textSeen = false;
-        for (const b of blocks) {
-          if (b.type === "tool_use") {
-            if (callIds.has(b.id ?? "")) outBlocks.push(b);
-            continue;
-          }
-          if (b.type === "text") {
-            if (!textSeen && typeof b.text === "string") {
-              outBlocks.push(b);
-              textSeen = true;
-            }
-            continue;
-          }
-          outBlocks.push(b);
-        }
-        if (agentText && !textSeen) outBlocks.unshift({ type: "text", text: agentText });
-        out.push({ role: "assistant", content: outBlocks });
-        continue;
-      }
-      const text2 = extractText(agent.content, false);
-      const block = blocks.find((b) => b.type === "text");
-      if (block) out.push({ role: srcMsg2.role, content: [{ ...block, text: text2 }] });
-      else out.push({ role: srcMsg2.role, content: [{ type: "text", text: text2 }] });
-      continue;
-    }
-    const srcMsg = src;
-    const text = extractText(agent.content, false);
-    if (kind === "toolResult") {
-      out.push({ role: "tool", tool_call_id: agent.toolCallId ?? srcMsg.tool_call_id, content: text });
-      continue;
-    }
-    if (kind === "toolCall") {
-      const callIds = new Set(
-        (agent.content ?? []).filter((b) => b.type === "toolCall" && b.id).map((b) => b.id)
-      );
-      const surviving = (srcMsg.tool_calls ?? []).filter((c) => callIds.has(c.id));
-      const entry = { role: "assistant", content: text };
-      if (surviving.length > 0) entry.tool_calls = surviving;
-      out.push(entry);
-      continue;
+function corePieceKey(cm) {
+  return `${cm.role}|${cm.contentType}|${cm.toolName ?? ""}|${(cm.text ?? "").slice(0, 4096)}`;
+}
+function spanFingerprintCoreIdx(coreMessages, startIdx, endIdx) {
+  const first = coreMessages[startIdx];
+  const last = coreMessages[endIdx];
+  if (!first || !last) return "";
+  return createHash3("sha1").update(`${corePieceKey(first)}\0${corePieceKey(last)}`).digest("hex").slice(0, 8);
+}
+function boundaryRawCore(ref, byRef, blocks, coreMessages, pick) {
+  const raw = byRef[ref];
+  if (raw) return raw;
+  const m = /^b(\d+)$/i.exec(ref.trim());
+  if (!m) return "";
+  const block = blocks.find((b) => b.blockId.toLowerCase() === `b${m[1]}`);
+  if (!block) return "";
+  const idx = (id) => coreMessages.findIndex((cm) => cm.id === (byRef[id] ?? id));
+  let best = -1;
+  for (const id of block.effectiveMessageIds) {
+    const i = idx(id);
+    if (i < 0) continue;
+    if (best < 0 || (pick === "min" ? i < best : i > best)) best = i;
+  }
+  return best < 0 ? "" : coreMessages[best]?.id ?? "";
+}
+function boundaryIndexCore(ref, byRef, blocks, coreMessages, pick, fallbackIdx = -1) {
+  const id = boundaryRawCore(ref, byRef, blocks, coreMessages, pick);
+  if (id) {
+    const i = coreMessages.findIndex((cm) => cm.id === id);
+    if (i >= 0) return i;
+  }
+  return fallbackIdx >= 0 && fallbackIdx < coreMessages.length ? fallbackIdx : -1;
+}
+function refOfPieceCore(coreMessages, idx, byRef) {
+  const id = coreMessages[idx]?.id;
+  if (!id) return "";
+  for (const [ref, mapped] of Object.entries(byRef)) if (mapped === id) return ref;
+  return "";
+}
+function staleRangeCore(r, rangeIndex, resultText, coreMessages, callIndex, byRef, blocks) {
+  const pm = resultText.match(/\[pos=([0-9,-]+)\]/);
+  const pair = pm ? pm[1].split(",")[rangeIndex] ?? "-" : "-";
+  const hinted = pair !== "-";
+  const [ps, pe] = pair === "-" ? ["", ""] : pair.split("-");
+  const fbStart = ps && ps !== "" ? Number.parseInt(ps, 10) : -1;
+  const fbEnd = pe && pe !== "" ? Number.parseInt(pe, 10) : -1;
+  const startRaw = boundaryRawCore(r.startRef, byRef, blocks, coreMessages, "min");
+  const endRaw = boundaryRawCore(r.endRef, byRef, blocks, coreMessages, "max");
+  const rawStartIdx = startRaw ? coreMessages.findIndex((cm) => cm.id === startRaw) : -1;
+  const rawEndIdx = endRaw ? coreMessages.findIndex((cm) => cm.id === endRaw) : -1;
+  const startIdx = rawStartIdx >= 0 ? rawStartIdx : fbStart >= 0 && fbStart < coreMessages.length ? fbStart : -1;
+  const endIdx = rawEndIdx >= 0 ? rawEndIdx : fbEnd >= 0 && fbEnd < coreMessages.length ? fbEnd : -1;
+  if (startIdx < 0 || endIdx < 0) {
+    if (!/^b\d+$/i.test(r.startRef.trim()) && !/^b\d+$/i.test(r.endRef.trim()))
+      return { reject: `unresolved ${r.startRef}..${r.endRef} -> ${startIdx}..${endIdx}`, ...hinted ? { hint: true } : {} };
+    return {};
+  }
+  if (endIdx > callIndex) return { reject: `end idx ${endIdx} > callIndex ${callIndex}`, ...hinted ? { hint: true } : {} };
+  const m = resultText.match(/\[fp=([0-9a-f,-]+)\]/);
+  if (m) {
+    const want = m[1].split(",")[rangeIndex];
+    if (want !== void 0 && want !== "-") {
+      const got = spanFingerprintCoreIdx(coreMessages, startIdx, endIdx);
+      if (want !== got) return { reject: `fp ${r.startRef}..${r.endRef} want ${want} got ${got} @${startIdx}..${endIdx}`, ...hinted ? { hint: true } : {} };
     }
-    out.push({ role: srcMsg.role === "assistant" ? "assistant" : srcMsg.role, content: text });
   }
-  return { ...payload, messages: out };
+  const remap = {};
+  if (/^m\d+$/i.test(r.startRef.trim()) && rawStartIdx < 0) {
+    const ref = refOfPieceCore(coreMessages, startIdx, byRef);
+    if (!ref) return { reject: `recovered ${r.startRef} @${startIdx} has no ref (protected piece)`, ...hinted ? { hint: true } : {} };
+    remap.startRef = ref;
+  }
+  if (/^m\d+$/i.test(r.endRef.trim()) && rawEndIdx < 0) {
+    const ref = refOfPieceCore(coreMessages, endIdx, byRef);
+    if (!ref) return { reject: `recovered ${r.endRef} @${endIdx} has no ref (protected piece)`, ...hinted ? { hint: true } : {} };
+    remap.endRef = ref;
+  }
+  if (!remap.startRef && !remap.endRef) return {};
+  return { remap, recovered: { pos: pair, startIdx, endIdx } };
 }
-function viewToWireStream(view, systemText) {
+function rangePositionsCore(ranges, coreMessages, byRef, blocks) {
+  return ranges.map((r) => {
+    const s = boundaryIndexCore(r.startRef, byRef, blocks, coreMessages, "min");
+    const e = s >= 0 ? boundaryIndexCore(r.endRef, byRef, blocks, coreMessages, "max") : -1;
+    return s >= 0 && e >= 0 ? `${s}-${e}` : "-";
+  });
+}
+function viewToCoreStream(view, systemText) {
   const messages = [{ role: "system", content: systemText }];
   for (const message of view) {
     const m = message;
     if (m.role === "user") {
-      const text = extractText(m.content);
+      const text = extractViewText(m.content);
       if (text) messages.push({ role: "user", content: text });
     } else if (m.role === "assistant") {
       const blocks = Array.isArray(m.content) ? m.content : [];
       const calls = blocks.filter(
         (b) => b !== null && typeof b === "object" && b.type === "toolCall"
       );
-      const text = extractText(m.content);
+      const text = extractViewText(m.content);
       if (calls.length > 0) {
         messages.push({
           role: "assistant",
@@ -3504,13 +3863,63 @@ function viewToWireStream(view, systemText) {
         messages.push({ role: "assistant", content: text });
       }
     } else if (m.role === "toolResult") {
-      messages.push({ role: "tool", tool_call_id: m.toolCallId ?? "", content: extractText(m.content) });
+      messages.push({ role: "tool", tool_call_id: m.toolCallId ?? "", content: extractViewText(m.content) });
     } else {
-      const text = extractText(m.content) || (typeof m.summary === "string" ? m.summary : "");
+      const text = extractViewText(m.content) || (typeof m.summary === "string" ? m.summary : "");
       if (text) messages.push({ role: "developer", content: text });
     }
   }
-  return synthesizeStream({ model: "prime-fold", messages }, "openai").stream;
+  const { msgs } = openaiToCore({ model: "prime-fold", messages });
+  return msgs;
+}
+function viewToAnthropicCore(view) {
+  const messages = [];
+  for (const message of view) {
+    const m = message;
+    if (m.role === "user") {
+      const text = extractViewText(m.content);
+      if (text) messages.push({ role: "user", content: [{ type: "text", text }] });
+    } else if (m.role === "assistant") {
+      const blocks = Array.isArray(m.content) ? m.content : [];
+      const calls = blocks.filter(
+        (b) => b !== null && typeof b === "object" && b.type === "toolCall"
+      );
+      const text = extractViewText(m.content);
+      const content = [];
+      if (text) content.push({ type: "text", text });
+      for (const c of calls) {
+        let input = {};
+        try {
+          input = c.arguments && typeof c.arguments === "object" ? c.arguments : JSON.parse(JSON.stringify(c.arguments ?? {}));
+        } catch {
+          input = {};
+        }
+        content.push({ type: "tool_use", id: c.id, name: c.name ?? "", input });
+      }
+      if (content.length > 0) messages.push({ role: "assistant", content });
+    } else if (m.role === "toolResult") {
+      messages.push({
+        role: "user",
+        content: [{ type: "tool_result", tool_use_id: m.toolCallId ?? "", content: extractViewText(m.content) }]
+      });
+    } else {
+      const text = extractViewText(m.content) || (typeof m.summary === "string" ? m.summary : "");
+      if (text) messages.push({ role: "user", content: [{ type: "text", text }] });
+    }
+  }
+  const { msgs, cacheControls } = anthropicToCore({ model: "prime-fold", messages });
+  void cacheControls;
+  return msgs;
+}
+function extractViewText(content) {
+  const clean = (s) => stripRefTag(s);
+  if (typeof content === "string") return clean(content);
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const b of content) {
+    if (b.type === "text" && typeof b.text === "string") parts.push(clean(b.text));
+  }
+  return parts.join("\n");
 }
 
 // src/runtime.ts
@@ -3538,6 +3947,7 @@ function createRuntime(adapter) {
   const core = createCore({ countTokens: defaultCountTokens });
   const locks = /* @__PURE__ */ new Map();
   const slots = /* @__PURE__ */ new Map();
+  const coreSlots = /* @__PURE__ */ new Map();
   let adapterRef = adapter;
   let promptsRef = defaultPrompts;
   async function acquireLock(sid) {
@@ -3567,6 +3977,14 @@ function createRuntime(adapter) {
     }
     return slot;
   }
+  function coreSlotFor(sid) {
+    let slot = coreSlots.get(sid);
+    if (!slot) {
+      slot = freshSlot();
+      coreSlots.set(sid, slot);
+    }
+    return slot;
+  }
   function sidOf(ctx) {
     return ctx.sessionManager.getSessionId();
   }
@@ -3651,8 +4069,90 @@ function createRuntime(adapter) {
     stream.forEach((message, i) => originalById.set(`p${i + 1}`, message));
     return { state: slot.state, coreMessages, originalById, streamLen: stream.length };
   }
+  function foldStreamCore(ctx, stream) {
+    const sid = sidOf(ctx);
+    let slot = coreSlotFor(sid);
+    if (slot.preview) {
+      debug.event("fold-refold", { sid, foldedLen: slot.foldedLen, lcp: 0, streamLen: stream.length, reason: "preview" });
+      slot = freshSlot(slot);
+      coreSlots.set(sid, slot);
+    }
+    const ids = stream.map(coreIdentity);
+    let lcp = 0;
+    while (lcp < Math.min(ids.length, slot.identities.length) && ids[lcp] === slot.identities[lcp]) lcp++;
+    if (lcp < slot.foldedLen) {
+      const flip = isViewFlip(slot.foldedLen, lcp);
+      debug.event("fold-refold", { sid, foldedLen: slot.foldedLen, lcp, streamLen: stream.length, flip, space: "core" });
+      slot = flip ? preserveCompressedSlot(slot) : freshSlot(slot);
+      coreSlots.set(sid, slot);
+      lcp = 0;
+    }
+    const coreMessages = stream;
+    const config = configFor(ctx);
+    const names = toolCallNames(stream);
+    const assigned = assignRefs(coreMessages, {
+      existing: slot.state.messageRefs,
+      nextIndex: highestUsedIndex(slot.state.messageRefs) + 1,
+      isProtected: (m) => {
+        if (m.role !== "tool" || !m.toolCallId) return false;
+        const name = names.get(m.toolCallId);
+        if (!name) return false;
+        if (name === "compress") return true;
+        return (config.protectedTools ?? []).includes(name);
+      }
+    });
+    slot.state = { ...slot.state, messageRefs: assigned.map };
+    const isFreshFold = slot.foldedLen === 0;
+    const resultTexts = toolResultTextsCore(stream);
+    let replayed = 0;
+    for (let i = isFreshFold ? 0 : slot.foldedLen; i < stream.length; i++) {
+      for (const call of findCompressCallsCore(stream[i])) {
+        const resultText = resultTexts.get(call.id) ?? "";
+        if (resultText.includes("No changes applied")) {
+          debug.event("fold-replay-skipped", { sid, callId: call.id });
+          continue;
+        }
+        if (slot.appliedCallIds.has(call.id) || stateHasCompressCall(slot.state, call.id)) continue;
+        const verdicts = call.ranges.map((r, ri) => staleRangeCore(r, ri, resultText, coreMessages, i, slot.state.messageRefs.byRef, slot.state.blocks));
+        const stale = verdicts.find((v) => v.reject);
+        if (stale) {
+          debug.event("fold-replay-stale", { sid, callId: call.id, reason: stale.reject });
+          const failed = verdicts.find((v) => v.hint && v.reject);
+          if (failed) logWarn("fold", { sid, event: "replay-recovery-failed", callId: call.id, reason: failed.reject });
+          continue;
+        }
+        const recovered = verdicts.find((v) => v.recovered);
+        const ranges = recovered ? call.ranges.map((r, ri) => {
+          const m = verdicts[ri].remap;
+          return m ? { ...r, startRef: m.startRef ?? r.startRef, endRef: m.endRef ?? r.endRef } : r;
+        }) : call.ranges;
+        if (recovered) {
+          logWarn("fold", { sid, event: "replay-recovered", callId: call.id, pos: recovered.recovered.pos, startIdx: recovered.recovered.startIdx, endIdx: recovered.recovered.endIdx });
+        }
+        try {
+          const applied = core.applyCompression({ ranges, messages: coreMessages, state: slot.state, config });
+          if (applied.result.errors.length === 0) {
+            slot.state = applied.state;
+            replayed++;
+            debug.event("fold-replay", { sid, callId: call.id, ranges: call.ranges.length });
+          } else {
+            logWarn("fold", { sid, event: "replay-rejected", callId: call.id, errors: applied.result.errors.slice(0, 3) });
+          }
+        } catch (e) {
+          logWarn("fold", { sid, event: "replay-failed", callId: call.id, error: e instanceof Error ? e.message : String(e) });
+        }
+        slot.appliedCallIds.add(call.id);
+      }
+    }
+    if (replayed > 0) logWarn("fold", { sid, event: "replayed", calls: replayed });
+    slot.identities = ids;
+    slot.foldedLen = ids.length;
+    slot.coreMessages = coreMessages;
+    return { state: slot.state, coreMessages, streamLen: stream.length };
+  }
   function stateFor(ctx) {
-    const slot = slotFor(sidOf(ctx));
+    const sid = sidOf(ctx);
+    const slot = slotForMode(ctx, sid);
     return Promise.resolve({ state: slot.state, coreMessages: slot.coreMessages });
   }
   function primeFold(ctx) {
@@ -3661,30 +4161,40 @@ function createRuntime(adapter) {
       const sm = ctx.sessionManager;
       const view = sm.buildSessionContext?.().messages ?? [];
       if (view.length === 0) return;
-      let stream = view;
-      let wire = false;
-      if ((adapterRef.transformMode ?? "provider") === "provider" && ctx.model?.api === "openai-completions") {
-        const base = getSystemPromptText(ctx);
-        const acp = buildAcpSystemPrompt(promptsRef);
-        stream = viewToWireStream(view, base.includes(acp) ? base : `${base}
+      if (resolveTransformMode(adapterRef, ctx.model) === "provider") {
+        const api = ctx.model?.api ?? "";
+        let stream;
+        if (api === "anthropic-messages") {
+          stream = viewToAnthropicCore(view);
+        } else {
+          const base = getSystemPromptText(ctx);
+          const acp = buildAcpSystemPrompt(promptsRef);
+          stream = viewToCoreStream(view, base.includes(acp) ? base : `${base}
 
 ${acp}`);
-        wire = true;
+        }
+        const r2 = foldStreamCore(ctx, stream);
+        coreSlotFor(sid).preview = true;
+        logInfo("fold", { sid, event: "prime-fold", msgs: stream.length, wire: true, blocks: r2.state.blocks.length });
+        return;
       }
-      const r = foldStream(ctx, stream);
+      const r = foldStream(ctx, view);
       slotFor(sid).preview = true;
-      logInfo("fold", { sid, event: "prime-fold", msgs: stream.length, wire, blocks: r.state.blocks.length });
+      logInfo("fold", { sid, event: "prime-fold", msgs: view.length, wire: false, blocks: r.state.blocks.length });
     } catch (e) {
       logWarn("fold", { sid, event: "prime-fold-failed", error: e instanceof Error ? e.message : String(e) });
     }
   }
   function forgetSession(sid) {
     slots.delete(sid);
+    coreSlots.delete(sid);
     locks.delete(sid);
   }
+  function slotForMode(ctx, sid) {
+    return resolveTransformMode(adapterRef, ctx.model) === "provider" ? coreSlotFor(sid) : slotFor(sid);
+  }
   function commitFoldState(ctx, state, toolCallId) {
-    const sid = sidOf(ctx);
-    const slot = slotFor(sid);
+    const slot = slotForMode(ctx, sidOf(ctx));
     slot.state = state;
     if (toolCallId) slot.appliedCallIds.add(toolCallId);
   }
@@ -3693,7 +4203,7 @@ ${acp}`);
     slot.lastRebuiltOutput = rebuilt.map(messageIdentity);
   }
   function noteCompressOutcome(ctx, ok) {
-    const slot = slotFor(sidOf(ctx));
+    const slot = slotForMode(ctx, sidOf(ctx));
     slot.rejectStreak = ok ? 0 : slot.rejectStreak + 1;
     return slot.rejectStreak;
   }
@@ -3714,6 +4224,7 @@ ${acp}`);
     liveContextLimit,
     configFor,
     foldStream,
+    foldStreamCore,
     stateFor,
     commitFoldState,
     recordRebuiltOutput,
@@ -3906,9 +4417,11 @@ async function handleCompress(args, runtime, ctx, toolCallId) {
       logError("compress", { sid: ctx.sessionManager.getSessionId(), event: "warnings", count: warnings.length, warnings: warnings.slice(0, 5) });
     }
     const fps = rangeFingerprints(rangeSpecs, coreMessages, applied.state.messageRefs.byRef, applied.state.blocks);
+    const positions = rangePositionsCore(rangeSpecs, coreMessages, applied.state.messageRefs.byRef, applied.state.blocks);
     const lines = [`\u25A3 ACP | ${formatTokens3(beforeTokens)} \u2192 ${formatTokens3(afterTokens)} tokens (~${formatTokens3(tokensCompressed)} reclaimed, ${blocksCreated} block${blocksCreated > 1 ? "s" : ""})`];
     if (warnings.length > 0) lines.push("\u26A0\uFE0F " + warnings.join("; "));
     if (fps.some((fp) => fp !== "-")) lines.push(`[fp=${fps.join(",")}]`);
+    if (positions.some((p) => p !== "-")) lines.push(`[pos=${positions.join(",")}]`);
     return lines.join("\n");
   } finally {
     releaseLock();
@@ -4903,7 +5416,7 @@ async function statusReport(runtime, ctx) {
   const coveredIds = collectCoveredMessageIds(state);
   const sentTokens = estimateTokens(coreMessages, coveredIds) + systemPromptTokens;
   const turn = runtime.core.processTurn({ messages: coreMessages, state, config, tokenCount: sentTokens });
-  const versionStr = "0.2.6" ? `billion-context-omp@${"0.2.6"}` : void 0;
+  const versionStr = "0.2.7" ? `billion-context-omp@${"0.2.7"}` : void 0;
   return buildStatusPanel({
     version: versionStr,
     tokenCount: sessionTokens,
@@ -5033,6 +5546,10 @@ import { readFileSync, writeFileSync } from "fs";
 import { join as join3 } from "path";
 var MARKER_FILE = ".billion-context-omp-instance.json";
 var FRESH_MS = 6e4;
+function normalizeLoadPath(p) {
+  const q = p.indexOf("?");
+  return q === -1 ? p : p.slice(0, q);
+}
 function markerPath() {
   return join3(homeDir(), ".omp", MARKER_FILE);
 }
@@ -5047,7 +5564,7 @@ function readMarker() {
 function detectDualInstance(selfPath, now = Date.now()) {
   const m = readMarker();
   if (!m) return void 0;
-  if (m.path === selfPath) return void 0;
+  if (normalizeLoadPath(m.path) === normalizeLoadPath(selfPath)) return void 0;
   if (now - m.ts > FRESH_MS) return void 0;
   return m;
 }
@@ -5193,7 +5710,7 @@ async function checkForUpdate(autoUpdate, notify) {
     const data = await res.json();
     const latest = data.version;
     if (!latest) return;
-    const current = runtimeVersion ?? "0.2.6";
+    const current = runtimeVersion ?? "0.2.7";
     const hasUpdate = isNewer(latest, current);
     debug.event("update-check", {
       current,
@@ -5450,7 +5967,6 @@ function createAcpExtension(adapter = {}) {
   return (pi) => {
     const runtime = createRuntime(adapter);
     wireSessionLifecycle(pi, runtime);
-    wireSessionLifecycle(pi, runtime);
     wireContextTransform(pi, runtime);
     wireSystemPrompt(pi, runtime);
     wireProviderTransform(pi, runtime);
@@ -5469,9 +5985,9 @@ var index_default = createAcpExtension();
 function wireSessionLifecycle(pi, runtime) {
   pi.on("session_start", async (_event, ctx) => {
     const sid = ctx.sessionManager.getSessionId();
-    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.2.6" : null });
+    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.2.7" : null });
     const selfPath = import.meta.url;
-    const conflict = stampAndDetect(selfPath, true ? "0.2.6" : null);
+    const conflict = stampAndDetect(selfPath, true ? "0.2.7" : null);
     if (conflict) {
       logWarn("instance", { event: "dual-instance", self: selfPath, other: conflict.path, otherPid: conflict.pid, otherVersion: conflict.version });
       try {
@@ -5495,9 +6011,9 @@ function wireSessionLifecycle(pi, runtime) {
       runtime.setPrompts(defaultPrompts);
     }
     runtime.primeFold(ctx);
-    await checkForUpdate(runtime.adapter.autoUpdate ?? true, (msg) => {
+    void checkForUpdate(runtime.adapter.autoUpdate ?? true, (msg) => {
       if (ctx.hasUI) ctx.ui.notify(msg);
-    });
+    }).catch((e) => logThrow("update", e, { sid, phase: "session_start" }));
   });
   pi.on("session_shutdown", (_event, ctx) => {
     try {
@@ -5631,14 +6147,14 @@ ${rendered.text}${example}`);
   } finally {
     release();
   }
-  await checkForUpdate(runtime.adapter.autoUpdate ?? true, (msg) => {
+  void checkForUpdate(runtime.adapter.autoUpdate ?? true, (msg) => {
     if (ctx.hasUI) ctx.ui.notify(msg);
-  });
+  }).catch((e) => logThrow("update", e, { sid, phase: "context" }));
   return result;
 }
 function wireContextTransform(pi, runtime) {
   pi.on("context", async (event, ctx) => {
-    if ((runtime.adapter.transformMode ?? "provider") === "provider") {
+    if (resolveTransformMode(runtime.adapter, ctx.model) === "provider") {
       debug.event("context-observer-skip", { sid: ctx.sessionManager.getSessionId(), msgs: event.messages?.length ?? 0 });
       return void 0;
     }
@@ -5649,34 +6165,151 @@ function wireContextTransform(pi, runtime) {
 }
 function wireProviderTransform(pi, runtime) {
   pi.on("before_provider_request", async (event, ctx) => {
-    if ((runtime.adapter.transformMode ?? "provider") !== "provider") return void 0;
+    if (resolveTransformMode(runtime.adapter, ctx.model) !== "provider") return void 0;
     const payload = event.payload;
     if (payload === null || typeof payload !== "object" || !Array.isArray(payload.messages)) return void 0;
     const sid = ctx.sessionManager?.getSessionId?.() ?? "";
-    const fmt2 = detectWireFormat(payload);
-    if (fmt2 === "unknown") {
+    const fmt2 = detectProviderWireFormat(payload);
+    if (fmt2 === null) {
       debug.event("provider-transform-unknown-format", { sid });
       return void 0;
     }
     try {
-      const synth = synthesizeStream(payload, fmt2);
-      if (synth.stream.length === 0) return void 0;
-      const result = await transformStream(ctx, runtime, synth.stream, "provider");
+      const { msgs, cacheControls } = payloadToCore(payload, fmt2);
+      if (msgs.length === 0) return void 0;
+      const result = await transformStreamCore(ctx, runtime, msgs, fmt2);
       if (!result) return void 0;
-      const wireOut = rebuildWirePayload(result.rebuilt, payload, synth);
-      const outMsgs = wireOut.messages?.length ?? 0;
+      const outMsgs = coreToPayloadMessages(result.coreOut, fmt2, cacheControls).length;
       const inMsgs = payload.messages?.length ?? 0;
-      if (outMsgs !== inMsgs || wireOut !== payload) {
+      if (outMsgs !== inMsgs) {
         logInfo("provider-transform", { sid, fmt: fmt2, inMsgs, outMsgs, nudge: result.nudgeInjected ? "injected" : "idle" });
       }
       debug.event("provider-transform", { sid, fmt: fmt2, inMsgs, outMsgs, nudgeInjected: result.nudgeInjected });
-      return wireOut === payload ? void 0 : wireOut;
+      return { ...payload, messages: coreToPayloadMessages(result.coreOut, fmt2, cacheControls) };
     } catch (e) {
       logThrow("provider-transform", e, { sid, fmt: fmt2 });
       return void 0;
     }
   });
 }
+async function transformStreamCore(ctx, runtime, wireMsgs, fmt2) {
+  const sid = ctx.sessionManager.getSessionId();
+  const release = await runtime.acquireLock(sid);
+  let result;
+  try {
+    if (wireMsgs.length === 0) {
+      debug.event("empty-stream-bypass", { sid, space: "core" });
+      return void 0;
+    }
+    debug.event("context-in-raw", { sid, msgs: wireMsgs.length, mode: "provider" });
+    const { state, coreMessages, streamLen } = runtime.foldStreamCore(ctx, wireMsgs);
+    const preTurnNudgeBaseline = state.nudge.lastPerMessageNudgeTokens;
+    const preTurnNudgeShownTokens = state.nudge.lastNudgeShownTokens;
+    const preTurnNudgeShownByTier = state.nudge.lastShownByTier;
+    const config = runtime.configFor(ctx);
+    const coveredIds = collectCoveredMessageIds(state);
+    const systemPromptTokens = estimateTextTokens2(getSystemPromptText(ctx) ?? "");
+    const sentTokens = estimateTokens(coreMessages, coveredIds) + systemPromptTokens;
+    const sessionTokens = ctx.getContextUsage?.()?.tokens ?? null;
+    const tokenCount = sentTokens;
+    debug.event("context-in", {
+      sid,
+      mode: "provider",
+      fmt: fmt2,
+      streamLen,
+      coreMsgs: coreMessages.length,
+      tokenCount,
+      sessionTokens,
+      limit: config.modelContextLimit,
+      blocksBefore: state.blocks.length,
+      activeBefore: state.blocks.filter((b) => b.active).length
+    });
+    const turn = runtime.core.processTurn({ messages: coreMessages, state, config, tokenCount, renderTags: "text-only" });
+    runtime.commitFoldState(ctx, turn.state);
+    logInfo("turn", {
+      sid,
+      inMsgs: coreMessages.length,
+      outMsgs: turn.messages.length,
+      tokens: tokenCount,
+      sessionTokens,
+      pct: config.modelContextLimit > 0 ? Math.round(tokenCount / config.modelContextLimit * 100) : null,
+      limit: config.modelContextLimit,
+      nudge: turn.nudge?.shouldInject ? turn.nudge.breakdown?.emergencyOverride === 1 ? "emergency" : "active" : "idle",
+      nudgeReason: turn.nudge?.reason ?? null,
+      blocks: turn.state.blocks.length,
+      activeBlocks: turn.state.blocks.filter((b) => b.active).length
+    });
+    debug.event("processTurn", {
+      outMsgs: turn.messages.length,
+      summaryMsgs: turn.messages.filter((m) => m.id.startsWith("acp_summary")).length,
+      prunedMsgs: coreMessages.length - turn.messages.length + turn.messages.filter((m) => m.id.startsWith("acp_summary")).length,
+      nudgeShouldInject: turn.nudge?.shouldInject ?? false,
+      nudgeReason: turn.nudge?.reason ?? null,
+      nudgeVoice: turn.nudge ? renderNudgeText(turn.nudge, runtime.prompts).voice : null,
+      nudgePct: turn.nudge ? Math.round(turn.nudge.contextUsage * 100) : null,
+      nudgeTier: turn.nudge?.tier ?? null,
+      nudgeCompressibleCount: turn.nudge?.compressibleRanges.length ?? 0,
+      nudgeProtectedCount: turn.nudge?.protectedRanges?.length ?? 0,
+      nothingToCompress: turn.nudge?.reason?.includes("nothing to compress") ?? false,
+      blocksAfter: turn.state.blocks.length,
+      activeAfter: turn.state.blocks.filter((b) => b.active).length
+    });
+    const coreOut = applyWireTagContract(
+      turn.messages.filter((m) => !m.id.startsWith("acp_summary_")),
+      turn.state
+    );
+    let nudgeInjected = false;
+    if (turn.nudge?.shouldInject) {
+      const lastUser = [...wireMsgs].reverse().find((m) => m.role === "user");
+      const tailText = lastUser ? lastUser.text ?? "" : "";
+      const isFeedbackView = tailText.includes("efficiency nudge to compress early") || tailText.includes("Context limit reached");
+      if (isFeedbackView) {
+        debug.event("nudge-feedback-skip", { sid, msgs: wireMsgs.length });
+      } else {
+        const emergency = turn.nudge.breakdown?.emergencyOverride === 1;
+        const epochReset = turn.state.nudge.lastPerMessageNudgeTokens !== preTurnNudgeBaseline;
+        const prevShown = epochReset ? 0 : preTurnNudgeShownTokens;
+        const cadenceFloor = turn.nudge.breakdown?.growthFloor ?? 0;
+        const suppressed = !emergency && prevShown > 0 && tokenCount - prevShown < cadenceFloor;
+        if (suppressed) {
+          turn.state.nudge.lastNudgeShownTokens = prevShown;
+          turn.state.nudge.lastShownByTier = preTurnNudgeShownByTier;
+          logInfo("nudge", { sid, event: "cadence-suppressed", growth: tokenCount - prevShown, floor: cadenceFloor, pct: Math.round(turn.nudge.contextUsage * 100), reason: turn.nudge.reason });
+          debug.event("nudge-suppressed", { sid, growth: tokenCount - prevShown, floor: cadenceFloor, pct: Math.round(turn.nudge.contextUsage * 100), reason: turn.nudge.reason });
+        } else {
+          nudgeInjected = true;
+          turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
+          const rendered = renderNudgeText(turn.nudge, runtime.prompts);
+          const top = [...turn.nudge.compressibleRanges].sort((a, b) => b.tokens - a.tokens)[0];
+          const example = top ? `
+
+Example: compress({ content: [{ startId: "${top.startRef}", endId: "${top.endRef}", summary: "..." }] })` : "";
+          if (emergency) {
+            logWarn("nudge", { sid, event: "emergency-inject", pct: Math.round(turn.nudge.contextUsage * 100), voice: rendered.voice, compressible: turn.nudge.compressibleRanges.length });
+          }
+          const debugOn2 = debug.enabled;
+          if (debugOn2 && ctx.hasUI) {
+            ctx.ui.notify(`[ACP nudge \u2192 context]${emergency ? " [EMERGENCY]" : ""}
+${rendered.text}${example}`);
+          }
+          debug.event("nudge-injected", { sid, voice: rendered.voice, channels: ["wire", debugOn2 ? "terminal" : null].filter(Boolean), emergency, text: rendered.text + example });
+          coreOut.push({ id: `acp_nudge_${Date.now()}`, role: "user", contentType: "text", text: nudgeText(turn.nudge, turn.state.blocks.filter((b) => b.active), runtime.prompts, example) });
+        }
+      }
+    }
+    debug.event("core-out", { sid, coreOutMsgs: coreOut.length, space: "core", fmt: fmt2 });
+    result = { coreOut, nudgeInjected };
+  } catch (e) {
+    logThrow("context-core", e, { sid, phase: "transform" });
+    throw e;
+  } finally {
+    release();
+  }
+  void checkForUpdate(runtime.adapter.autoUpdate ?? true, (msg) => {
+    if (ctx.hasUI) ctx.ui.notify(msg);
+  }).catch((e) => logThrow("update", e, { sid, phase: "provider" }));
+  return result;
+}
 function wireSystemPrompt(pi, runtime) {
   pi.on("before_agent_start", (event) => {
     const acp = buildAcpSystemPrompt(runtime.prompts);
@@ -5708,7 +6341,7 @@ function wireProviderDebug(pi) {
     });
   });
 }
-function nudgeMessage(nudge, blocks, prompts, example) {
+function nudgeText(nudge, blocks, prompts, example) {
   const rendered = renderNudgeText(nudge, prompts);
   const lines = [rendered.text];
   if (blocks.length > 0) {
@@ -5727,9 +6360,12 @@ function nudgeMessage(nudge, blocks, prompts, example) {
     lines.push(`Compressed blocks: ${blocks.length} active (${tierStr}) \u2014 ${fmt2(totalSummary)} summary, ${fmt2(totalCompressed)} original compressed. Blocks: ${ids}${extra}.`);
   }
   if (example) lines.push(example);
+  return lines.join("\n");
+}
+function nudgeMessage(nudge, blocks, prompts, example) {
   return {
     role: "user",
-    content: [{ type: "text", text: lines.join("\n") }],
+    content: [{ type: "text", text: nudgeText(nudge, blocks, prompts, example) }],
     timestamp: Date.now()
   };
 }