billion-context-omp 0.1.9 → 0.2.1

package/README.md

@@ -145,6 +145,7 @@ Create `~/.omp/acp-omp.json` (global) and/or `<project>/.omp/acp-omp.json` (proj
 | Key | Default | Description |
 |-----|---------|-------------|
 | `debug` | `false` | Enable verbose **debug-level** events in the log. The always-on log (lifecycle events, errors, warnings) is written regardless; `debug` only adds extra diagnostics. Also enabled by env `ACP_DEBUG=1`. |
+| `transformMode` | `"context"` (default) or `"provider"` — where the compression surgery intercepts. `provider` transforms the provider wire payload (no feedback re-entry; experimental). |
 | `autoUpdate` | `true` | On session start (throttled to one check per 3 minutes), check npm for a newer version and auto-install it. Disable to avoid all startup network calls. |
 | `modelContextLimit` | *(auto)* | Override the context limit (in tokens). Defaults to the model's `contextWindow`. |
 | `compressModel` | *(session model)* | `provider:modelId` used for `/compact` model-summarized compaction (e.g. `"zhipuai:glm-5.2"`). Defaults to the current session model when omitted. |

package/dist/config.d.ts

@@ -27,6 +27,13 @@ export interface CompressConfig {
  * (live model context window, protected tools, state persistence).
  */
 export interface AdapterConfig {
+    /** Where the compression surgery intercepts (issue #52). "context" (default)
+     *  rewrites the context event — battle-tested, but omp's recap/subagent
+     *  pipelines can re-feed our output as input (feedback-view loops).
+     *  "provider" leaves the agent array untouched and transforms the WIRE
+     *  payload at before_provider_request — request-local, no re-entry; unknown
+     *  provider formats pass through untransformed (fail-open). */
+    transformMode?: "context" | "provider";
     /** When omitted, the adapter reads `ctx.model.contextWindow` live each turn.
      *  Set explicitly for tests/headless runs. */
     modelContextLimit?: number;

package/dist/index.js

@@ -3166,6 +3166,15 @@ function freshSlot(preserveFrom) {
   }
   return slot;
 }
+function isViewFlip(foldedLen, lcp) {
+  return foldedLen > 0 && lcp >= Math.floor(foldedLen / 2);
+}
+function preserveCompressedSlot(prev) {
+  const slot = freshSlot(prev);
+  slot.state = { ...slot.state, blocks: prev.state.blocks, messageRefs: prev.state.messageRefs, stats: prev.state.stats };
+  slot.appliedCallIds = new Set(prev.appliedCallIds);
+  return slot;
+}
 function stateHasCompressCall(state, callId) {
   return state.blocks.some((b) => b.compressCallId === callId);
 }
@@ -3217,8 +3226,9 @@ function createRuntime(adapter) {
     let lcp = 0;
     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);
+      const flip = isViewFlip(slot.foldedLen, lcp);
+      debug.event("fold-refold", { sid, foldedLen: slot.foldedLen, lcp, streamLen: ids.length, flip });
+      slot = flip ? preserveCompressedSlot(slot) : freshSlot(slot);
       slots.set(sid, slot);
       lcp = 0;
     }
@@ -3244,6 +3254,7 @@ function createRuntime(adapter) {
           debug.event("fold-replay-skipped", { sid, callId: call.id });
           continue;
         }
+        if (slot.appliedCallIds.has(call.id) || stateHasCompressCall(slot.state, call.id)) continue;
         const stale = call.ranges.map((r, ri) => staleRange(r, ri, resultText, coreMessages, i, slot.state.messageRefs.byRef, slot.state.blocks)).find((s) => s !== false);
         if (stale) {
           debug.event("fold-replay-stale", { sid, callId: call.id, reason: stale });
@@ -3425,6 +3436,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);
@@ -4492,7 +4508,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.9" ? `billion-context-omp@${"0.1.9"}` : void 0;
+  const versionStr = "0.2.1" ? `billion-context-omp@${"0.2.1"}` : void 0;
   return buildStatusPanel({
     version: versionStr,
     tokenCount: sessionTokens,
@@ -4504,6 +4520,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";
@@ -4934,7 +5181,7 @@ async function checkForUpdate(autoUpdate, notify) {
     const data = await res.json();
     const latest = data.version;
     if (!latest) return;
-    const current = runtimeVersion ?? "0.1.9";
+    const current = runtimeVersion ?? "0.2.1";
     const hasUpdate = isNewer(latest, current);
     debug.event("update-check", {
       current,
@@ -5149,6 +5396,7 @@ var KNOWN = /* @__PURE__ */ new Set([
   "debug",
   "autoUpdate",
   "modelContextLimit",
+  "transformMode",
   "toolBashDefaultTimeout",
   "toolOutputMaxBytes",
   "delegate",
@@ -5192,6 +5440,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));
@@ -5248,7 +5497,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.9" : null });
+    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.2.1" : null });
     try {
       const user = await loadUserConfig(ctx.cwd);
       runtime.setAdapter(applyUserConfig(runtime.adapter, user));
@@ -5275,130 +5524,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 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,
-        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;
-      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 });
+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;
+        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 {
-          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 ? `
+          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: nudgeInjected,
-        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;
     }
   });
 }