billion-context-omp 0.1.8 → 0.2.0

package/dist/index.js

@@ -3158,8 +3158,13 @@ function rangeFingerprints(ranges, coreMessages, byRef, blocks) {
 }
 
 // src/runtime.ts
-function freshSlot() {
-  return { identities: [], foldedLen: 0, preview: false, state: createInitialState(), coreMessages: [], appliedCallIds: /* @__PURE__ */ new Set() };
+function freshSlot(preserveFrom) {
+  const slot = { identities: [], foldedLen: 0, preview: false, state: createInitialState(), coreMessages: [], appliedCallIds: /* @__PURE__ */ new Set(), rejectStreak: 0 };
+  if (preserveFrom) {
+    slot.state = { ...slot.state, nudge: preserveFrom.state.nudge };
+    slot.rejectStreak = preserveFrom.rejectStreak;
+  }
+  return slot;
 }
 function stateHasCompressCall(state, callId) {
   return state.blocks.some((b) => b.compressCallId === callId);
@@ -3205,7 +3210,7 @@ function createRuntime(adapter) {
     let slot = slotFor(sid);
     if (slot.preview) {
       debug.event("fold-refold", { sid, foldedLen: slot.foldedLen, lcp: 0, streamLen: stream.length, reason: "preview" });
-      slot = freshSlot();
+      slot = freshSlot(slot);
       slots.set(sid, slot);
     }
     const ids = stream.map(messageIdentity);
@@ -3213,7 +3218,7 @@ function createRuntime(adapter) {
     while (lcp < Math.min(ids.length, slot.identities.length) && ids[lcp] === slot.identities[lcp]) lcp++;
     if (lcp < slot.foldedLen) {
       debug.event("fold-refold", { sid, foldedLen: slot.foldedLen, lcp, streamLen: ids.length });
-      slot = freshSlot();
+      slot = freshSlot(slot);
       slots.set(sid, slot);
       lcp = 0;
     }
@@ -3295,6 +3300,11 @@ function createRuntime(adapter) {
     slot.state = state;
     if (toolCallId) slot.appliedCallIds.add(toolCallId);
   }
+  function noteCompressOutcome(ctx, ok) {
+    const slot = slotFor(sidOf(ctx));
+    slot.rejectStreak = ok ? 0 : slot.rejectStreak + 1;
+    return slot.rejectStreak;
+  }
   return {
     core,
     get adapter() {
@@ -3314,6 +3324,7 @@ function createRuntime(adapter) {
     foldStream,
     stateFor,
     commitFoldState,
+    noteCompressOutcome,
     forgetSession,
     primeFold,
     acquireLock
@@ -3414,6 +3425,11 @@ function makeCompressTool(runtime) {
 async function handleCompress(args, runtime, ctx, toolCallId) {
   const ranges = args.content ?? [];
   if (ranges.length === 0) return "No ranges provided.";
+  const invalid = ranges.filter((r) => !r || typeof r.summary !== "string" || !r.summary.trim() || !r.startId || !r.endId);
+  if (invalid.length > 0) {
+    logWarn("compress", { sid: ctx.sessionManager.getSessionId(), event: "invalid-ranges", count: invalid.length });
+    return `Every range needs startId, endId and a summary (min 50 chars) \u2014 got ${invalid.length} range(s) missing fields. Re-send the FULL ranges array with summaries included.`;
+  }
   const releaseLock = await runtime.acquireLock(ctx.sessionManager.getSessionId());
   try {
     const { state: initialState, coreMessages } = await runtime.stateFor(ctx);
@@ -3444,7 +3460,7 @@ async function handleCompress(args, runtime, ctx, toolCallId) {
     const invalidRanges = rangeSpecs.filter((r) => !r.startRef || !r.endRef || typeof r.startRef !== "string" || typeof r.endRef !== "string");
     if (invalidRanges.length > 0) {
       logError("compress", { sid: ctx.sessionManager.getSessionId(), event: "invalid-ranges", count: invalidRanges.length, ranges: invalidRanges.map((r) => `${r.startRef}..${r.endRef}`) });
-      return `Rejected: ${invalidRanges.length} range(s) have invalid startId or endId (missing or non-string). All ranges must have valid message refs (e.g. "m00005") or block IDs (e.g. "b3"). No changes applied \u2014 run acp_status for current refs.`;
+      return rejectionMessage(ctx, runtime, `Rejected: ${invalidRanges.length} range(s) have invalid startId or endId (missing or non-string). All ranges must have valid message refs (e.g. "m00005") or block IDs (e.g. "b3"). No changes applied \u2014 run acp_status for current refs.`);
     }
     let applied;
     try {
@@ -3456,12 +3472,13 @@ async function handleCompress(args, runtime, ctx, toolCallId) {
       });
     } catch (e) {
       logThrow("compress", e, { sid: ctx.sessionManager.getSessionId(), phase: "applyCompression", ranges: rangeSpecs.length });
-      return `Compression failed: ${e instanceof Error ? e.message : String(e)}. No changes applied \u2014 state is unchanged.`;
+      return rejectionMessage(ctx, runtime, `Compression failed: ${e instanceof Error ? e.message : String(e)}. No changes applied \u2014 state is unchanged.`);
     }
     if (applied.result.errors.length > 0) {
       logError("compress", { sid: ctx.sessionManager.getSessionId(), event: "apply-errors", count: applied.result.errors.length, errors: applied.result.errors.slice(0, 5) });
-      return `Compression rejected: ${applied.result.errors.join("; ")}. No changes applied \u2014 run acp_status to verify current state.`;
+      return rejectionMessage(ctx, runtime, `Compression rejected: ${applied.result.errors.join("; ")}. No changes applied \u2014 run acp_status to verify current state.`);
     }
+    runtime.noteCompressOutcome(ctx, true);
     await runtime.commitFoldState(ctx, applied.state, toolCallId);
     const { blocksCreated, tokensCompressed, warnings } = applied.result;
     const afterTokens = Math.max(0, beforeTokens - tokensCompressed);
@@ -3502,6 +3519,22 @@ async function handleCompress(args, runtime, ctx, toolCallId) {
     releaseLock();
   }
 }
+var LOOP_GUARD_STOP = 3;
+var LOOP_GUARD_SUPPRESS = 4;
+function rejectionMessage(ctx, runtime, base) {
+  const streak = runtime.noteCompressOutcome(ctx, false);
+  if (streak >= LOOP_GUARD_SUPPRESS) {
+    logWarn("compress", { sid: ctx.sessionManager.getSessionId(), event: "loop-guard", streak, mode: "suppressed" });
+    return `Compression rejected (again \u2014 ${streak} consecutive rejections). No changes applied. STOP calling compress; it is not converging. Continue the task. Compress stays available: a fresh attempt works when acp_status shows a range that can meet the minimum size.`;
+  }
+  if (streak >= LOOP_GUARD_STOP) {
+    logWarn("compress", { sid: ctx.sessionManager.getSessionId(), event: "loop-guard", streak, mode: "stop-directive" });
+    return `${base}
+
+STOP: ${streak} compress calls rejected in a row. Do NOT retry the same range. Run acp_status to see what is actually compressible now; if no range can meet the minimum size, nothing is left to compress \u2014 stop and continue the actual task.`;
+  }
+  return base;
+}
 
 // src/decompress-tool.ts
 import { type as type2 } from "@oh-my-pi/omptype";
@@ -4464,7 +4497,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.1.8" ? `billion-context-omp@${"0.1.8"}` : void 0;
+  const versionStr = "0.2.0" ? `billion-context-omp@${"0.2.0"}` : void 0;
   return buildStatusPanel({
     version: versionStr,
     tokenCount: sessionTokens,
@@ -4476,6 +4509,237 @@ async function statusReport(runtime, ctx) {
   });
 }
 
+// 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";
+  }
+  return "openai";
+}
+function anthropicBlocks(m) {
+  return typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content ?? [];
+}
+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");
+    });
+    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 };
+}
+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);
+      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);
+        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);
+        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);
+      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);
+    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;
+    }
+    out.push({ role: srcMsg.role === "assistant" ? "assistant" : srcMsg.role, content: text });
+  }
+  return { ...payload, messages: out };
+}
+
 // src/auto-compress.ts
 import { readFileSync } from "fs";
 import { join as join3 } from "path";
@@ -4570,7 +4834,7 @@ async function summarizeMessages(ctx, messages, prompts, configuredModel, opts)
 User instructions for this compaction: ${custom}`;
     const userText = `ENTIRE conversation to compress (${slice.length} messages, ~${tokens} tokens). Compress it:
 
-` + formatSlice(slice, createInitialState());
+` + formatSlice(slice, opts?.messageRefs ? { ...createInitialState(), messageRefs: opts.messageRefs } : createInitialState());
     const response = await run(
       model,
       { systemPrompt: [instructions], messages: [{ role: "user", content: [{ type: "text", text: userText }], timestamp: Date.now() }] },
@@ -4638,6 +4902,8 @@ WHEN NOT TO COMPRESS
 - Content the current task step is actively reading or reasoning about.
 - Important user messages \u2014 preserve their exact intent, constraints, and acceptance criteria. If a message in the range must stay verbatim, exclude it from the compress range instead of compressing it.
 - Protected tool outputs \u2014 hard-excluded from compression ranges, survive intact in visible context.
+- Nothing left worth compressing \u2014 if no compressible range can meet the minimum size, do NOT call compress at all. Compression is maintenance, never the task goal; when there is nothing to compress, do the task.
+- A rejected compress call \u2014 never retry a rejected range unchanged. Re-check acp_status first; after 3 rejections, stop compressing and continue the task.
 
 ${prompts.howToCompressRules}
 
@@ -4784,7 +5050,7 @@ var PACKAGE_NAME = "billion-context-omp";
 var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 var SEMVER_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z-.]+)?$/;
 var CHECK_INTERVAL_MS = 3 * 60 * 1e3;
-var THROTTLE_FILE = join4(homeDir(), CONFIG_DIR_NAME3, ".billion-context-omp-update-check");
+var throttleFile = () => join4(homeDir(), CONFIG_DIR_NAME3, ".billion-context-omp-update-check");
 var updateInFlight = false;
 function parseVersion(v) {
   return v.replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
@@ -4800,7 +5066,7 @@ function isNewer(latest, current) {
 }
 async function readLastCheck() {
   try {
-    const data = await readFile(THROTTLE_FILE, "utf-8");
+    const data = await readFile(throttleFile(), "utf-8");
     return parseInt(data.trim(), 10) || 0;
   } catch {
     return 0;
@@ -4808,8 +5074,8 @@ async function readLastCheck() {
 }
 async function writeLastCheck(timestamp) {
   try {
-    await mkdir2(dirname3(THROTTLE_FILE), { recursive: true });
-    await writeFile2(THROTTLE_FILE, String(timestamp), "utf-8");
+    await mkdir2(dirname3(throttleFile()), { recursive: true });
+    await writeFile2(throttleFile(), String(timestamp), "utf-8");
   } catch {
   }
 }
@@ -4891,12 +5157,12 @@ async function checkForUpdate(autoUpdate, notify) {
     const now = Date.now();
     const lastCheck = await readLastCheck();
     if (now - lastCheck < CHECK_INTERVAL_MS) return;
-    await writeLastCheck(now);
     const runtimeVersion = await getRuntimeVersion();
     const res = await fetch(REGISTRY_URL, {
       signal: AbortSignal.timeout(5e3),
       headers: { Accept: "application/json" }
     });
+    await writeLastCheck(now);
     if (!res.ok) {
       logWarn("update", { event: "check-http", status: res.status });
       return;
@@ -4904,7 +5170,7 @@ async function checkForUpdate(autoUpdate, notify) {
     const data = await res.json();
     const latest = data.version;
     if (!latest) return;
-    const current = runtimeVersion ?? "0.1.8";
+    const current = runtimeVersion ?? "0.2.0";
     const hasUpdate = isNewer(latest, current);
     debug.event("update-check", {
       current,
@@ -5119,6 +5385,7 @@ var KNOWN = /* @__PURE__ */ new Set([
   "debug",
   "autoUpdate",
   "modelContextLimit",
+  "transformMode",
   "toolBashDefaultTimeout",
   "toolOutputMaxBytes",
   "delegate",
@@ -5162,6 +5429,7 @@ function createAcpExtension(adapter = {}) {
     wireSessionLifecycle(pi, runtime);
     wireContextTransform(pi, runtime);
     wireSystemPrompt(pi, runtime);
+    wireProviderTransform(pi, runtime);
     wireProviderDebug(pi);
     wireToolGuardrails(pi, runtime);
     pi.registerTool(makeCompressTool(runtime));
@@ -5181,11 +5449,13 @@ function wireCompactionDisable(pi, runtime) {
       const prep = event.preparation;
       const toSummarize = [...prep.messagesToSummarize ?? [], ...prep.turnPrefixMessages ?? []];
       if (toSummarize.length === 0) return void 0;
+      const slot = await runtime.stateFor(ctx);
       ctx.ui?.notify?.(`ACP: compacting ${toSummarize.length} messages\u2026`, "info");
       const result = await summarizeMessages(ctx, toSummarize, runtime.prompts, runtime.adapter.compress?.compressModel, {
         previousSummary: prep.previousSummary,
         customInstructions: event.customInstructions,
-        signal: event.signal
+        signal: event.signal,
+        messageRefs: slot.state.messageRefs
       });
       if (!result) {
         ctx.ui?.notify?.("ACP: compression fell back to Pi native compaction", "warning");
@@ -5216,7 +5486,7 @@ function wireCompactionDisable(pi, runtime) {
 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.1.8" : null });
+    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.2.0" : null });
     try {
       const user = await loadUserConfig(ctx.cwd);
       runtime.setAdapter(applyUserConfig(runtime.adapter, user));
@@ -5243,107 +5513,168 @@ function wireSessionLifecycle(pi, runtime) {
     closeLogStream();
   });
 }
-function wireContextTransform(pi, runtime) {
-  pi.on("context", async (event, ctx) => {
-    const sid = ctx.sessionManager.getSessionId();
-    const release = await runtime.acquireLock(sid);
-    try {
-      const input = event.messages ?? [];
-      if (input.length === 0) {
-        debug.event("empty-stream-bypass", { sid });
-        return void 0;
-      }
-      debug.event("context-in-raw", { sid, msgs: input.length });
-      const { state, coreMessages, originalById, streamLen } = runtime.foldStream(ctx, input);
-      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,
-        eventMsgs: event.messages?.length ?? 0,
-        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 });
-      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 rebuilt = coreOutToAgentMessages(turn.messages, originalById);
-      debug.event("core-out", {
-        sid,
-        coreOutMsgs: turn.messages.length,
-        originalByIdSize: originalById.size,
-        rebuiltMsgs: rebuilt.length
-      });
-      const debugOn2 = debug.enabled;
-      if (turn.nudge?.shouldInject) {
+async function transformStream(ctx, runtime, input, mode) {
+  const sid = ctx.sessionManager.getSessionId();
+  const release = await runtime.acquireLock(sid);
+  try {
+    if (input.length === 0) {
+      debug.event("empty-stream-bypass", { sid });
+      return void 0;
+    }
+    debug.event("context-in-raw", { sid, msgs: input.length, mode });
+    const { state, coreMessages, originalById, streamLen } = runtime.foldStream(ctx, input);
+    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,
+      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 });
+    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 rebuilt = coreOutToAgentMessages(turn.messages, originalById);
+    debug.event("core-out", {
+      sid,
+      coreOutMsgs: turn.messages.length,
+      originalByIdSize: originalById.size,
+      rebuiltMsgs: rebuilt.length
+    });
+    const debugOn2 = debug.enabled;
+    let nudgeInjected = false;
+    if (turn.nudge?.shouldInject) {
+      const lastUser = [...input].reverse().find((m) => m.role === "user");
+      const tailText = lastUser ? JSON.stringify(lastUser.content ?? "") : "";
+      const isFeedbackView = tailText.includes("efficiency nudge to compress early") || tailText.includes("Context limit reached");
+      if (isFeedbackView) {
+        debug.event("nudge-feedback-skip", { sid: ctx.sessionManager.getSessionId(), msgs: input.length });
+      } else {
         const emergency = turn.nudge.breakdown?.emergencyOverride === 1;
-        {
-          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 ? `
+        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: "..." }] })` : "";
-          rebuilt.push(nudgeMessage(turn.nudge, turn.state.blocks.filter((b) => b.active), runtime.prompts, example));
-          if (emergency) {
-            logWarn("nudge", { sid: ctx.sessionManager.getSessionId(), event: "emergency-inject", pct: Math.round(turn.nudge.contextUsage * 100), voice: rendered.voice, compressible: turn.nudge.compressibleRanges.length });
-          }
-          if (debugOn2 && ctx.hasUI) {
-            ctx.ui.notify(`[ACP nudge \u2192 context]${emergency ? " [EMERGENCY]" : ""}
+            rebuilt.push(nudgeMessage(turn.nudge, turn.state.blocks.filter((b) => b.active), runtime.prompts, example));
+            if (emergency) {
+              logWarn("nudge", { sid: ctx.sessionManager.getSessionId(), event: "emergency-inject", pct: Math.round(turn.nudge.contextUsage * 100), voice: rendered.voice, compressible: turn.nudge.compressibleRanges.length });
+            }
+            if (debugOn2 && ctx.hasUI) {
+              ctx.ui.notify(`[ACP nudge \u2192 context]${emergency ? " [EMERGENCY]" : ""}
 ${rendered.text}${example}`);
+            }
+            debug.event("nudge-injected", { sid: ctx.sessionManager.getSessionId(), voice: rendered.voice, channels: ["context", debugOn2 ? "terminal" : null].filter(Boolean), emergency, text: rendered.text + example });
           }
-          debug.event("nudge-injected", { sid: ctx.sessionManager.getSessionId(), voice: rendered.voice, channels: ["context", debugOn2 ? "terminal" : null].filter(Boolean), emergency, text: rendered.text + example });
         }
       }
-      dumpContextMessages(rebuilt, {
-        sid,
-        injected: turn.nudge?.shouldInject ?? false,
-        emergency: turn.nudge?.breakdown?.emergencyOverride === 1
-      });
-      await checkForUpdate(runtime.adapter.autoUpdate ?? true, (msg) => {
-        if (ctx.hasUI) ctx.ui.notify(msg);
-      });
-      return { messages: rebuilt };
+    }
+    dumpContextMessages(rebuilt, {
+      sid,
+      injected: nudgeInjected,
+      emergency: turn.nudge?.breakdown?.emergencyOverride === 1
+    });
+    await checkForUpdate(runtime.adapter.autoUpdate ?? true, (msg) => {
+      if (ctx.hasUI) ctx.ui.notify(msg);
+    });
+    return { rebuilt, nudgeInjected };
+  } catch (e) {
+    logThrow("context", e, { sid, phase: "transform", mode });
+    throw e;
+  } finally {
+    release();
+  }
+}
+function wireContextTransform(pi, runtime) {
+  pi.on("context", async (event, ctx) => {
+    if ((runtime.adapter.transformMode ?? "context") === "provider") {
+      debug.event("context-observer-skip", { sid: ctx.sessionManager.getSessionId(), msgs: event.messages?.length ?? 0 });
+      return void 0;
+    }
+    const result = await transformStream(ctx, runtime, event.messages ?? [], "context");
+    if (!result) return void 0;
+    return { messages: result.rebuilt };
+  });
+}
+function wireProviderTransform(pi, runtime) {
+  pi.on("before_provider_request", async (event, ctx) => {
+    if ((runtime.adapter.transformMode ?? "context") !== "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") {
+      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");
+      if (!result) return void 0;
+      const wireOut = rebuildWirePayload(result.rebuilt, payload, synth);
+      const outMsgs = wireOut.messages?.length ?? 0;
+      const inMsgs = payload.messages?.length ?? 0;
+      if (outMsgs !== inMsgs || wireOut !== payload) {
+        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;
     } catch (e) {
-      logThrow("context", e, { sid, phase: "transform" });
-      throw e;
-    } finally {
-      release();
+      logThrow("provider-transform", e, { sid, fmt: fmt2 });
+      return void 0;
     }
   });
 }