billion-context 0.1.91-pr.615.438 → 0.1.91

package/dist/index.js

@@ -43869,9 +43869,6 @@ function refToIndex(ref) {
 function refForRaw(map, rawId) {
   return map.byRaw[rawId] ?? null;
 }
-function rawForRef(map, ref) {
-  return map.byRef[ref] ?? null;
-}
 function assignRefs(messages, options) {
   const map = {
     byRaw: { ...options.existing.byRaw },
@@ -44825,34 +44822,6 @@ var ACP_MUTATING_TOOLS = /* @__PURE__ */ new Set([
   COMPRESS_TOOL_NAME,
   DECOMPRESS_TOOL_NAME
 ]);
-var ABSORB_TOOL_DESCRIPTION = "Distill a tool result into a compact summary you write. REQUIRED immediately after a tool result ends with an [ACP absorb] instruction: pass its ref and the distilled essentials (outcome, key values, paths:lines, errors, decisions). The original output is then removed from context; your summary is the durable record.";
-var ABSORB_PARAMETERS = {
-  type: "object",
-  properties: {
-    ref: {
-      type: "string",
-      description: "mNNNNN ref of the tool result to absorb (from the [ACP absorb] instruction)"
-    },
-    summary: {
-      type: "string",
-      description: "Distilled essentials of the tool result \u2014 this replaces the original output in context"
-    }
-  },
-  required: ["ref", "summary"]
-};
-var ABSORB_TOOL = {
-  name: ABSORB_TOOL_NAME,
-  description: ABSORB_TOOL_DESCRIPTION,
-  input_schema: ABSORB_PARAMETERS
-};
-var ABSORB_TOOL_OPENAI = {
-  type: "function",
-  function: {
-    name: ABSORB_TOOL_NAME,
-    description: ABSORB_TOOL_DESCRIPTION,
-    parameters: ABSORB_PARAMETERS
-  }
-};
 var ALWAYS_PROTECTED_TOOLS = ["compress"];
 var NEVER_PRESERVE_RECENT_TOOLS = [
   "decompress",
@@ -44921,11 +44890,6 @@ function formatTokenCount(tokens) {
 function buildAbsorbPrompt(ref, tokens, toolName = ABSORB_TOOL_NAME) {
   return `${ABSORB_PROMPT_MARKER} This tool result (~${formatTokenCount(tokens)} tokens) will be REMOVED from context. Your IMMEDIATE next action: call ${toolName}({ ref: "${ref}", summary: "..." }) \u2014 summary = distilled essentials only (outcome, key values, exact paths:lines, error text verbatim, decisions). Afterwards work from your summary; do NOT re-run this tool. If the result contains nothing you need, call ${toolName} with summary "(nothing needed)".`;
 }
-function buildAbsorbSystemPrompt(toolName = ABSORB_TOOL_NAME) {
-  return `INSTANT TOOL-RESULT ABSORPTION (${toolName})
-
-Some tool results end with a ${ABSORB_PROMPT_MARKER} instruction. When you see one, your IMMEDIATE next action must be calling ${toolName}({ ref, summary }) \u2014 distill that tool result's essentials into summary: outcome, key values, exact paths:lines, error text verbatim, decisions. The original output is then removed from context; your ${toolName} summary becomes the only durable record of it, so distill carefully. Never call another tool or answer the user before absorbing a marked result. Do not re-run the original tool afterwards \u2014 work from your summary. ${toolName} calls are ordinary context: the regular compression system may fold them later like any other message.`;
-}
 function isAcpOrConfiguredTool(toolName, cfg) {
   if (!toolName) return false;
   if (toolName === cfg.toolName) return true;
@@ -44980,139 +44944,6 @@ function appendAbsorbPrompts(messages, state, config, tokenCount, countTokens) {
   });
   return { messages: out, promptedCount };
 }
-function parseAbsorbInput(input, callId, onWarn) {
-  let obj = null;
-  if (typeof input === "string") {
-    try {
-      const parsed = JSON.parse(input);
-      if (parsed && typeof parsed === "object") {
-        obj = parsed;
-      }
-    } catch {
-      obj = null;
-    }
-  } else if (input && typeof input === "object") {
-    obj = input;
-  }
-  if (!obj) {
-    onWarn?.(`[acp-absorb-input] rejected: not an object (${typeof input})`);
-    return null;
-  }
-  const ref = pickString(obj, "ref", "messageId", "of");
-  const summary = pickString(obj, "summary", "content");
-  if (typeof ref !== "string" || typeof summary !== "string") {
-    onWarn?.(
-      `[acp-absorb-input] rejected: need ref (string) + summary (string); keys: ${Object.keys(obj).join(",")}`
-    );
-    return null;
-  }
-  return {
-    ref: ref.trim(),
-    summary,
-    ...callId ? { absorbCallId: callId } : {}
-  };
-}
-function pickString(obj, ...keys) {
-  for (const key of keys) {
-    const value = obj[key];
-    if (typeof value === "string") return value;
-  }
-  return void 0;
-}
-function applyAbsorb(input) {
-  const countTokens = input.countTokens ?? ((text) => Math.ceil(text.length / 4));
-  const summary = input.summary?.trim() ?? "";
-  if (!summary) {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: "absorb failed: summary is empty \u2014 provide the distilled key info of the tool result."
-    };
-  }
-  const cfg = resolveAbsorbConfig(input.config);
-  const rawId = rawForRef(input.state.messageRefs, input.ref.trim());
-  if (!rawId) {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: `absorb failed: ref ${input.ref} does not exist in this session (it may be hidden, already compressed, or stale).`
-    };
-  }
-  const existing = (input.state.absorbed ?? []).find(
-    (record2) => record2.resultMessageId === rawId
-  );
-  if (existing) {
-    return {
-      state: input.state,
-      ok: true,
-      resultText: `already absorbed (${input.ref}) \u2014 no change.`
-    };
-  }
-  const target = input.messages.find((m2) => m2.id === rawId);
-  if (!target) {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: `absorb failed: ref ${input.ref} is not visible in this session (hidden or compressed).`
-    };
-  }
-  if (target.contentType !== "tool-result") {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: `absorb failed: ref ${input.ref} is a ${target.contentType}, not a tool result.`
-    };
-  }
-  if (isAcpOrConfiguredTool(target.toolName, cfg)) {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: `absorb failed: ${target.toolName} is an ACP-managed tool result \u2014 it is not absorbable.`
-    };
-  }
-  if (isMessageProtected(target, input.config)) {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: `absorb failed: ${target.toolName} is a protected tool \u2014 its results must stay visible.`
-    };
-  }
-  if (!target.toolCallId) {
-    return {
-      state: input.state,
-      ok: false,
-      resultText: `absorb failed: ref ${input.ref} has no tool-call id \u2014 cannot pair it for hiding.`
-    };
-  }
-  const call = input.messages.find(
-    (m2) => m2.contentType === "tool-call" && m2.toolCallId === target.toolCallId
-  );
-  const tokens = countTokens(target.text ?? "");
-  const summaryTokens = countTokens(summary);
-  const record = {
-    toolCallId: target.toolCallId,
-    callMessageId: call?.id ?? "",
-    resultMessageId: target.id,
-    ...input.absorbCallId ? { absorbCallId: input.absorbCallId } : {},
-    summary,
-    tokensReclaimed: tokens,
-    createdAt: Date.now()
-  };
-  const state = {
-    ...input.state,
-    absorbed: [...input.state.absorbed ?? [], record],
-    stats: {
-      ...input.state.stats,
-      absorbedTokens: (input.state.stats.absorbedTokens ?? 0) + tokens
-    }
-  };
-  const bloat = summaryTokens >= tokens && tokens > 0 ? ` WARNING: your summary (~${formatTokenCount(summaryTokens)} tokens) is not smaller than the original (~${formatTokenCount(tokens)} tokens) \u2014 distill harder next time.` : "";
-  return {
-    state,
-    ok: true,
-    resultText: `absorbed ${input.ref} (~${formatTokenCount(tokens)} tokens \u2192 summary ~${formatTokenCount(summaryTokens)}). The original tool output is now hidden; your summary is the durable record.${bloat}`
-  };
-}
 var registry = /* @__PURE__ */ new Map();
 function listMessageFilters() {
   return [...registry.values()];
@@ -48404,51 +48235,6 @@ function parseCompressSettings(v2) {
     if (typeof obj.acknowledgePromptsRisk !== "boolean") ok = false;
     else out.acknowledgePromptsRisk = obj.acknowledgePromptsRisk;
   }
-  if ("absorb" in obj && obj.absorb !== void 0) {
-    const a = obj.absorb;
-    if (!a || typeof a !== "object" || Array.isArray(a)) {
-      ok = false;
-    } else {
-      const ao2 = a;
-      const cleaned = {};
-      for (const key of ["enabled", "minToolTokens", "contextThresholdPct", "excludeTools", "toolName"]) {
-        if (!(key in ao2)) continue;
-        const v3 = ao2[key];
-        if (key === "enabled") {
-          if (typeof v3 !== "boolean") {
-            ok = false;
-            continue;
-          }
-          cleaned.enabled = v3;
-        } else if (key === "minToolTokens") {
-          if (typeof v3 !== "number" || !Number.isFinite(v3)) {
-            ok = false;
-            continue;
-          }
-          cleaned.minToolTokens = v3;
-        } else if (key === "contextThresholdPct") {
-          if (!numberOrPercent(v3)) {
-            ok = false;
-            continue;
-          }
-          cleaned.contextThresholdPct = typeof v3 === "string" ? v3.trim() : v3;
-        } else if (key === "excludeTools") {
-          if (!Array.isArray(v3) || v3.some((x) => typeof x !== "string")) {
-            ok = false;
-            continue;
-          }
-          cleaned.excludeTools = [...v3];
-        } else {
-          if (typeof v3 !== "string" || v3.trim().length === 0) {
-            ok = false;
-            continue;
-          }
-          cleaned.toolName = v3.trim();
-        }
-      }
-      if (ok) out.absorb = cleaned;
-    }
-  }
   if ("prompts" in obj && obj.prompts !== void 0) {
     const prompts = obj.prompts;
     if (!prompts || typeof prompts !== "object" || Array.isArray(prompts)) {
@@ -48499,7 +48285,6 @@ function mergeCompress(global2, provider, model) {
   const pick = (k2) => model?.[k2] ?? provider?.[k2] ?? global2?.[k2];
   const promptLevels = [global2?.prompts, provider?.prompts, model?.prompts].filter(Boolean);
   const rangeOf = (s3) => s3?.minCompressRangeChars ?? s3?.minCompressRange;
-  const absorbLevels = [global2?.absorb, provider?.absorb, model?.absorb].filter(Boolean);
   return {
     modelContextLimit: pick("modelContextLimit"),
     maxContextLimit: pick("maxContextLimit"),
@@ -48510,8 +48295,7 @@ function mergeCompress(global2, provider, model) {
     minCompressRangeChars: rangeOf(model) ?? rangeOf(provider) ?? rangeOf(global2),
     tiers: pick("tiers"),
     prompts: promptLevels.length > 0 ? Object.assign({}, ...promptLevels) : void 0,
-    acknowledgePromptsRisk: pick("acknowledgePromptsRisk"),
-    absorb: absorbLevels.length > 0 ? Object.assign({}, ...absorbLevels) : void 0
+    acknowledgePromptsRisk: pick("acknowledgePromptsRisk")
   };
 }
 function resolveCompress(routes, upstreamUrl, model, global2) {
@@ -48552,17 +48336,6 @@ function applyCompressSettings(base, limit, s3) {
   }
   const tiers = { ...base.tiers };
   if (s3.tiers !== void 0) tiers.enabled = s3.tiers;
-  let absorb;
-  if (s3.absorb !== void 0) {
-    const d = DEFAULT_ABSORB_CONFIG;
-    absorb = {
-      enabled: s3.absorb.enabled === true,
-      toolName: s3.absorb.toolName ?? d.toolName,
-      minToolTokens: s3.absorb.minToolTokens ?? d.minToolTokens,
-      contextThresholdPct: s3.absorb.contextThresholdPct !== void 0 ? parsePercent(s3.absorb.contextThresholdPct) : d.contextThresholdPct,
-      excludeTools: s3.absorb.excludeTools ?? [...d.excludeTools]
-    };
-  }
   return {
     ...base,
     modelContextLimit: limit,
@@ -48574,8 +48347,7 @@ function applyCompressSettings(base, limit, s3) {
     compress: {
       ...base.compress,
       minCompressRange: s3.minCompressRangeChars ?? s3.minCompressRange ?? base.compress.minCompressRange
-    },
-    ...absorb !== void 0 ? { absorb } : {}
+    }
   };
 }
 function parsePercent(v2) {
@@ -50269,10 +50041,7 @@ function mergeState(parsed) {
     stats: { ...fresh.stats, ...parsed.stats ?? {} },
     nextBlockId: parsed.nextBlockId ?? fresh.nextBlockId,
     nextRunId: parsed.nextRunId ?? fresh.nextRunId,
-    tokenSnapshot: parsed.tokenSnapshot ?? fresh.tokenSnapshot,
-    // Without this, a restart re-exposes absorbed tool outputs: state
-    // resurrects with absorbed=[] and hideAbsorbedMessages has nothing to hide.
-    absorbed: parsed.absorbed ?? fresh.absorbed
+    tokenSnapshot: parsed.tokenSnapshot ?? fresh.tokenSnapshot
   };
 }
 function hostLabel(upstreamOrigin) {
@@ -50875,12 +50644,6 @@ async function flushAllSessions() {
 }
 
 // src/compress-tool.ts
-var ABSORB_TOOL_RESPONSES = {
-  type: "function",
-  name: ABSORB_TOOL_OPENAI.function.name,
-  description: ABSORB_TOOL_OPENAI.function.description,
-  parameters: ABSORB_TOOL_OPENAI.function.parameters
-};
 function parseCompressInput(input, callId) {
   const first = parseCompressArgs(input, { callId });
   if (first.ranges.length === 0 || first.diagnostics.invalidItems > 0) {
@@ -50980,72 +50743,6 @@ function withStagedCompressGuidance(text) {
   return text + STAGED_COMPRESS_GUIDANCE;
 }
 
-// src/absorb.ts
-var EFFECTIVE_ABSORB_KEY = "effectiveAbsorb";
-function absorbEnabled(config) {
-  return config.absorb?.enabled === true;
-}
-function absorbToolName(config) {
-  return config.absorb?.toolName ?? ABSORB_TOOL_NAME;
-}
-function effectiveAbsorbConfig(session, fallback) {
-  const meta = session?.metadata[EFFECTIVE_ABSORB_KEY];
-  if (meta && typeof meta === "object" && typeof meta.enabled === "boolean") {
-    return meta;
-  }
-  return fallback.absorb;
-}
-function storeEffectiveAbsorb(session, config) {
-  session.metadata[EFFECTIVE_ABSORB_KEY] = config.absorb ?? null;
-}
-function isProxyToolFor(name, session, config) {
-  if (ACP_TOOL_NAMES.has(name)) return true;
-  const absorb = effectiveAbsorbConfig(session, config);
-  return absorb?.enabled === true && name === (absorb.toolName ?? ABSORB_TOOL_NAME);
-}
-function applyAbsorbView(messages, state, config, tokenCount) {
-  const hidden = hideAbsorbedMessages(messages, state);
-  const prompted = appendAbsorbPrompts(hidden, state, config, tokenCount, defaultCountTokens);
-  return prompted.messages;
-}
-function executeAbsorb(args, callId, absorb, ctx) {
-  const log2 = ctx.log ?? ((msg) => log("info", msg));
-  const parsed = parseAbsorbInput(args, callId, (w2) => log2(`[acp-absorb] ${w2}`));
-  if (!parsed) {
-    return '[absorb FAILED: invalid input \u2014 expected { ref: "mNNNNN", summary: "..." }]';
-  }
-  const before = ctx.session.state.absorbed?.length ?? 0;
-  let outcome;
-  try {
-    outcome = applyAbsorb({
-      ref: parsed.ref,
-      summary: parsed.summary,
-      absorbCallId: parsed.absorbCallId,
-      messages: ctx.messages,
-      state: ctx.session.state,
-      config: { ...ctx.config, absorb }
-    });
-  } catch (err2) {
-    log2(`[acp-absorb] error: ${String(err2)}`);
-    return `[absorb FAILED: ${String(err2)}]`;
-  }
-  ctx.session.state = outcome.state;
-  if (!outcome.ok) {
-    log2(`[acp-absorb] ${outcome.resultText}`);
-    return `[absorb FAILED: ${outcome.resultText}]`;
-  }
-  const records = outcome.state.absorbed ?? [];
-  const record = records.length > before ? records[records.length - 1] : void 0;
-  if (record) {
-    ctx.session.stats.compressCreditTokens = (ctx.session.stats.compressCreditTokens ?? 0) + record.tokensReclaimed;
-    ctx.session.stats.lastInputTokens = Math.max(0, ctx.session.stats.lastInputTokens - record.tokensReclaimed);
-    log2(`[acp-absorb] ${outcome.resultText} (credit -${record.tokensReclaimed} tok)`);
-  } else {
-    log2(`[acp-absorb] ${outcome.resultText}`);
-  }
-  return outcome.resultText;
-}
-
 // src/acp-status.ts
 function handleAcpStatus(args, ctx) {
   const scope = typeof args.scope === "string" ? args.scope : void 0;
@@ -51413,10 +51110,6 @@ ${lines.join("\n\n")}`;
   if (toolName === "acp_status") {
     return handleAcpStatus(args, ctx);
   }
-  const absorb = effectiveAbsorbConfig(ctx.session, ctx.config);
-  if (absorb?.enabled === true && toolName === (absorb.toolName ?? ABSORB_TOOL_NAME)) {
-    return executeAbsorb(args, void 0, absorb, ctx);
-  }
   return `[Unknown proxy tool: ${toolName}]`;
 }
 function refNum2(ref) {
@@ -51495,7 +51188,7 @@ function rewriteJsonResponse(body, ctx) {
   const newContent = [];
   for (const block of b2.content) {
     const blk = block;
-    if (blk.type === "tool_use" && typeof blk.name === "string" && isProxyToolFor(blk.name, ctx.session, ctx.config)) {
+    if (blk.type === "tool_use" && typeof blk.name === "string" && ACP_TOOL_NAMES.has(blk.name)) {
       converted = true;
       const args = blk.input && typeof blk.input === "object" ? blk.input : {};
       newContent.push({ type: "text", text: executeAnthropicProxyTool(blk.name, args, ctx) });
@@ -51712,7 +51405,6 @@ async function preflightCompress(deps, messages) {
       renderTags: "text-only"
     });
     deps.session.state = turn.state;
-    turn.messages = applyAbsorbView(turn.messages, turn.state, activeConfig, currentTokens);
     currentTokens = Math.max(deps.session.stats.lastInputTokens, estimateCoreMessages(turn.messages) + (deps.imageFloor ?? 0) + (deps.wireOverhead ?? 0));
     if (!baselineKnown) {
       finalUpper = estimateCoreMessagesUpper(turn.messages) + (deps.imageFloor ?? 0) + (deps.wireOverhead ?? 0);
@@ -52564,8 +52256,7 @@ function buildVisibilityMarker(toolName, result) {
     compress: "\u{1F4E6}",
     decompress: "\u{1F4E4}",
     search_context: "\u{1F50D}",
-    acp_status: "\u{1F4CA}",
-    absorb: "\u{1FAE7}"
+    acp_status: "\u{1F4CA}"
   };
   const icon = failed ? "\u274C" : icons[toolName] ?? "\u{1F4E6}";
   if (toolName === "acp_status") {
@@ -52893,10 +52584,6 @@ ${lines.join("\n\n")}`;
   if (toolName === "acp_status") {
     return handleAcpStatus(args, ctx);
   }
-  const absorb = effectiveAbsorbConfig(ctx.session, ctx.config);
-  if (absorb?.enabled === true && toolName === (absorb.toolName ?? ABSORB_TOOL_NAME)) {
-    return executeAbsorb(args, callId, absorb, ctx);
-  }
   return `[Unknown proxy tool: ${toolName}]`;
 }
 function recordUsage(ctx, usage, round) {
@@ -53064,7 +52751,7 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
       const realToolCalls = [];
       const proxyResults = [];
       for (const call of allCalls) {
-        if (isProxyToolFor(call.name, ctx.session, ctx.config)) {
+        if (ACP_TOOL_NAMES.has(call.name)) {
           let parsedArgs;
           try {
             parsedArgs = call.arguments.length > 0 ? JSON.parse(call.arguments) : {};
@@ -53153,11 +52840,7 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
             coreMessages.push(...hidden.messages);
           }
         }
-        const absorbName = (() => {
-          const a = effectiveAbsorbConfig(ctx.session, ctx.config);
-          return a?.enabled === true ? a.toolName ?? ABSORB_TOOL_NAME : void 0;
-        })();
-        if (ctx.refreshFolded && proxyResults.some((pr2) => (pr2.name === "compress" || pr2.name === absorbName) && !pr2.result.includes("FAILED"))) {
+        if (ctx.refreshFolded && proxyResults.some((pr2) => pr2.name === "compress" && !pr2.result.includes("FAILED"))) {
           try {
             const refreshed = ctx.refreshFolded(coreMessages);
             if (refreshed.length > 0) {
@@ -53499,7 +53182,7 @@ data: ${JSON.stringify({ type: "response.completed", response: resp })}
     "utf8"
   );
 }
-function createResponsesAdapter(textProtocol, projection, absorbName) {
+function createResponsesAdapter(textProtocol, projection) {
   const suppressTextLifecycle = !!textProtocol;
   let outputIndex = 0;
   let responseObj = null;
@@ -53585,7 +53268,7 @@ data: ${JSON.stringify({ type: "response.created", response: { id: createdRespId
           const item = obj.item;
           if (item?.type === "function_call") {
             const fcName = typeof item.name === "string" ? item.name : "";
-            if (ACP_TOOL_NAMES.has(fcName) || fcName === absorbName) {
+            if (ACP_TOOL_NAMES.has(fcName)) {
               const itemId = typeof item.id === "string" ? item.id : "";
               pending.set(itemId, {
                 itemId,
@@ -53930,7 +53613,7 @@ function patchUsageChunk(eventStr, parsed, u2, hostCredit) {
   }
   return Buffer.from(eventStr + "\n\n", "utf8");
 }
-function createOpenaiAdapter(requestBody, clientSystem, hostCredit = 0, absorbName) {
+function createOpenaiAdapter(requestBody, clientSystem, hostCredit = 0) {
   const model = requestBody.model ?? "unknown";
   let responseId = `chatcmpl-proxy-${Date.now()}`;
   let toolIndex = 0;
@@ -54032,7 +53715,7 @@ function createOpenaiAdapter(requestBody, clientSystem, hostCredit = 0, absorbNa
       const settleToolCalls = function* () {
         const realIndexes = /* @__PURE__ */ new Set();
         for (const [idx, tc] of pending) {
-          if (tc.name.length > 0 && !PROXY_TOOL_SET.has(tc.name) && tc.name !== absorbName) realIndexes.add(idx);
+          if (tc.name.length > 0 && !PROXY_TOOL_SET.has(tc.name)) realIndexes.add(idx);
         }
         sawRealToolCall = realIndexes.size > 0;
         if (!sawRealToolCall) {
@@ -54624,9 +54307,9 @@ data: ${JSON.stringify({ type: "content_block_stop", index })}
 }
 
 // src/loop/index.ts
-function pickAdapter(protocol, requestBody, textProtocol, responsesProjection, anthropicSystem, openaiSystem, hostCredit = 0, absorbName) {
-  if (protocol === "responses") return createResponsesAdapter(textProtocol, responsesProjection, absorbName);
-  if (protocol === "openai") return createOpenaiAdapter(requestBody, openaiSystem, hostCredit, absorbName);
+function pickAdapter(protocol, requestBody, textProtocol, responsesProjection, anthropicSystem, openaiSystem, hostCredit = 0) {
+  if (protocol === "responses") return createResponsesAdapter(textProtocol, responsesProjection);
+  if (protocol === "openai") return createOpenaiAdapter(requestBody, openaiSystem, hostCredit);
   if (protocol === "anthropic") return createAnthropicAdapter(requestBody, anthropicSystem, hostCredit);
   throw new Error(`[acp-loop] unknown protocol: ${protocol}`);
 }
@@ -55911,16 +55594,11 @@ function handlePluginManifest(res) {
     protocolVersion: PLUGIN_PROTOCOL_VERSION,
     proxy: "billion-context",
     version: VERSION,
-    // Absorb is advertised alongside the four ACP tools. It is host-
-    // registered opt-in (not in the kernel's ACP_TOOL_NAMES), so the
-    // manifest must list it explicitly. Per-session enablement is enforced
-    // at execution (isProxyToolFor / executeProxyTool), not here — the
-    // manifest has no request context to know which route will win.
-    toolNames: [...ACP_TOOL_NAMES, ABSORB_TOOL_NAME],
+    toolNames: [...ACP_TOOL_NAMES],
     tools: {
-      anthropic: [...ACP_TOOLS_ANTHROPIC, ABSORB_TOOL],
-      openai: [...ACP_TOOLS_OPENAI, ABSORB_TOOL_OPENAI],
-      responses: [...ACP_TOOLS_RESPONSES, ABSORB_TOOL_RESPONSES]
+      anthropic: ACP_TOOLS_ANTHROPIC,
+      openai: ACP_TOOLS_OPENAI,
+      responses: ACP_TOOLS_RESPONSES
     },
     headers: { agent: PLUGIN_AGENT_HEADER, conversation: PLUGIN_CONVERSATION_HEADER, contextWindow: PLUGIN_CONTEXT_WINDOW_HEADER },
     toolEndpoint: "/__bili/plugin/tool",
@@ -56017,6 +55695,11 @@ async function handlePluginTool(payload, res, deps) {
     res.end(JSON.stringify({ ok: false, error: `conversationId is required (send the same value as the ${PLUGIN_CONVERSATION_HEADER} header)` }));
     return;
   }
+  if (!ACP_TOOL_NAMES.has(tool)) {
+    res.writeHead(400, { "content-type": "application/json" });
+    res.end(JSON.stringify({ ok: false, error: `unknown tool "${tool}" (expected one of: ${[...ACP_TOOL_NAMES].join(", ")})` }));
+    return;
+  }
   const entry = conversations.get(conversationId2);
   const session = entry ? peekSession(entry.sessionId) : void 0;
   if (!entry || !session) {
@@ -56024,14 +55707,6 @@ async function handlePluginTool(payload, res, deps) {
     res.end(JSON.stringify({ ok: false, error: "unknown plugin conversation (no model request has arrived with this conversation id yet)" }));
     return;
   }
-  if (!isProxyToolFor(tool, session, deps.config)) {
-    const allowed = [...ACP_TOOL_NAMES];
-    const absorb = effectiveAbsorbConfig(session, deps.config);
-    if (absorb?.enabled === true) allowed.push(absorb.toolName ?? ABSORB_TOOL_NAME);
-    res.writeHead(400, { "content-type": "application/json" });
-    res.end(JSON.stringify({ ok: false, error: `unknown tool "${tool}" (expected one of: ${allowed.join(", ")})` }));
-    return;
-  }
   entry.lastSeen = Date.now();
   const args = parsed.args && typeof parsed.args === "object" ? parsed.args : {};
   const callId = `plugin_${Date.now().toString(36)}`;
@@ -59072,13 +58747,9 @@ function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, sessio
     extractSystem(parsed.system);
     const tokenCount = effectiveTokenCount(session, msgs);
     const activeBefore = new Set(session.state.blocks.filter((b2) => b2.active).map((b2) => b2.blockId));
-    const absorbActive = absorbEnabled(config) && opts.compress.injectTool;
-    const loopConfig = absorbActive ? config : { ...config, absorb: void 0 };
-    const turn = core.processTurn({ messages: msgs, state: session.state, config: loopConfig, tokenCount, renderTags: "text-only" });
+    const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: "text-only" });
     session.state = turn.state;
     session.stats.compressCreditTokens = 0;
-    storeEffectiveAbsorb(session, loopConfig);
-    turn.messages = applyAbsorbView(turn.messages, session.state, loopConfig, tokenCount);
     if (turn.nudge) turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
     nudge = turn.nudge;
     session.stats.contextTokens = tokenCount;
@@ -59093,9 +58764,9 @@ function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, sessio
     applyCompactionArchive(session, activeBefore, new Set(msgs.map((m2) => m2.id)), log2);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltMessages = coreToAnthropic(processedMessages, cacheControls);
-    systemOut = injectSystem(parsed, opts, prompts, loopConfig);
+    systemOut = injectSystem(parsed, opts, prompts);
     if (injectTools) {
-      toolsOut = injectTool(parsed.tools, absorbActive ? ABSORB_TOOL : void 0);
+      toolsOut = injectTool(parsed.tools);
     }
     if (willInjectNudge && turn.nudge) {
       try {
@@ -59197,13 +58868,9 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
     originalMessages = msgs;
     const tokenCount = effectiveTokenCount(session, msgs);
     const activeBefore = new Set(session.state.blocks.filter((b2) => b2.active).map((b2) => b2.blockId));
-    const absorbActive = absorbEnabled(config) && shouldInject;
-    const loopConfig = absorbActive ? config : { ...config, absorb: void 0 };
-    const turn = core.processTurn({ messages: msgs, state: session.state, config: loopConfig, tokenCount, renderTags: "text-only" });
+    const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: "text-only" });
     session.state = turn.state;
     session.stats.compressCreditTokens = 0;
-    storeEffectiveAbsorb(session, loopConfig);
-    turn.messages = applyAbsorbView(turn.messages, session.state, loopConfig, tokenCount);
     if (turn.nudge) turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
     nudge = turn.nudge;
     session.stats.contextTokens = tokenCount;
@@ -59221,11 +58888,10 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
     const sysParts = [];
     if (systemText) sysParts.push(systemText);
     if (shouldInject) sysParts.push(buildCompressSystemPrompt(prompts));
-    if (absorbActive) sysParts.push(buildAbsorbSystemPrompt(absorbToolName(config)));
     rebuiltMessages = injectOpenaiSystem(rebuiltMessages, sysParts);
     openaiOutboundSystem = sysParts.join("\n\n");
     if (injectTools) {
-      toolsOut = injectOpenaiTool(parsed.tools, absorbActive ? ABSORB_TOOL_OPENAI : void 0);
+      toolsOut = injectOpenaiTool(parsed.tools);
     }
     if (willInjectNudge && turn.nudge) {
       try {
@@ -59306,13 +58972,9 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
       log2("info", `[${sessionId}] input items: ${Array.isArray(parsed.input) ? parsed.input.map((i) => i.type).join(",") : "(string)"}`);
     }
     const tokenCount = effectiveTokenCount(session, msgs);
-    const absorbActive = absorbEnabled(config) && shouldInject && !isCompactionTrigger && !responsesTextProtocol;
-    const loopConfig = absorbActive ? config : { ...config, absorb: void 0 };
-    const turn = core.processTurn({ messages: msgs, state: session.state, config: loopConfig, tokenCount, renderTags });
+    const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags });
     session.state = turn.state;
     session.stats.compressCreditTokens = 0;
-    storeEffectiveAbsorb(session, loopConfig);
-    turn.messages = applyAbsorbView(turn.messages, session.state, loopConfig, tokenCount);
     if (turn.nudge) turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
     nudge = turn.nudge;
     session.stats.contextTokens = tokenCount;
@@ -59329,13 +58991,11 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
     const forgedSummaries = echoReplaced ? [] : session.metadata.codexForgedSummaries ?? [];
     if (shouldInject && !isCompactionTrigger && !process.env.ACP_NO_COMPRESS_PROMPT) {
       const prompt = responsesTextProtocol ? buildCompressHybridSystemPrompt(prompts) : buildCompressSystemPrompt(prompts);
-      const devParts = [...projection.systemParts, ...forgedSummaries, prompt];
-      if (absorbActive) devParts.push(buildAbsorbSystemPrompt(absorbToolName(config)));
-      const devContent = devParts.join("\n\n---\n\n");
+      const devContent = [...projection.systemParts, ...forgedSummaries, prompt].join("\n\n---\n\n");
       responsesDevContent = devContent;
       rebuiltInput = injectResponsesDeveloperMessage(rebuiltInput, devContent);
       if (!process.env.ACP_NO_INJECT_TOOL && injectTools) {
-        toolsOut = responsesTextProtocol ? injectResponsesTool(parsed.tools, ACP_READONLY_TOOLS_RESPONSES) : injectResponsesTool(parsed.tools, absorbActive ? [...ACP_TOOLS_RESPONSES, ABSORB_TOOL_RESPONSES] : ACP_TOOLS_RESPONSES);
+        toolsOut = responsesTextProtocol ? injectResponsesTool(parsed.tools, ACP_READONLY_TOOLS_RESPONSES) : injectResponsesTool(parsed.tools);
       }
     } else if (projection.systemParts.length > 0 || forgedSummaries.length > 0) {
       const devContent = [...projection.systemParts, ...forgedSummaries].join("\n\n---\n\n");
@@ -59480,16 +59140,14 @@ function prepareResponsesCompact(body, parsed, session, req, core, config, log2)
   let transformOk = false;
   try {
     const projection = responsesToCore(forgeBody);
-    const compactConfig = { ...config, absorb: void 0 };
-    const turn = core.processTurn({ messages: projection.msgs, state: session.state, config: compactConfig, tokenCount: session.stats.lastInputTokens, renderTags: process.env.ACP_RENDER_NONE ? "none" : "text-only" });
+    const turn = core.processTurn({ messages: projection.msgs, state: session.state, config, tokenCount: session.stats.lastInputTokens, renderTags: process.env.ACP_RENDER_NONE ? "none" : "text-only" });
     session.state = turn.state;
     transformOk = true;
     if (!codexCompactGate(session, config.modelContextLimit, transformOk)) {
       session.state = prevState;
       return base;
     }
-    const viewed = applyAbsorbView(turn.messages, turn.state, compactConfig, session.stats.lastInputTokens);
-    const processed = repairResponsesAssistantOrdering(stripKernelSummaries(viewed, turn.state), projection.msgs);
+    const processed = repairResponsesAssistantOrdering(stripKernelSummaries(turn.messages, turn.state), projection.msgs);
     const output = patchResponsesInput(projection, processed);
     if (typeof output === "string") {
       session.state = prevState;
@@ -59525,11 +59183,10 @@ function isAutoModeClassifier(parsed) {
   if (!Array.isArray(stops)) return false;
   return stops.some((s3) => typeof s3 === "string" && AUTO_MODE_CLASSIFIER_STOPS.has(s3));
 }
-function injectSystem(parsed, opts, prompts = defaultPrompts, config) {
+function injectSystem(parsed, opts, prompts = defaultPrompts) {
   const baseText = extractSystem(parsed.system);
   const parts = [];
   if (opts.compress.injectTool) parts.push(buildCompressSystemPrompt(prompts));
-  if (opts.compress.injectTool && absorbEnabled(config)) parts.push(buildAbsorbSystemPrompt(absorbToolName(config)));
   if (parts.length === 0) return parsed.system;
   const full = baseText ? `${baseText}
 
@@ -59538,23 +59195,19 @@ function injectSystem(parsed, opts, prompts = defaultPrompts, config) {
 ${parts.join("\n\n")}` : parts.join("\n\n");
   return buildSystem(full, parsed.system);
 }
-function injectTool(tools, extra) {
-  if (!Array.isArray(tools)) return extra ? [...ACP_TOOLS_ANTHROPIC, extra] : [...ACP_TOOLS_ANTHROPIC];
+function injectTool(tools) {
+  if (!Array.isArray(tools)) return [...ACP_TOOLS_ANTHROPIC];
   const names = new Set(tools.map((t) => t?.name));
   const missing = ACP_TOOLS_ANTHROPIC.filter((t) => !names.has(t.name));
-  const extraMissing = extra && !names.has(extra.name);
-  if (missing.length === 0 && !extraMissing) return tools;
-  return [...tools, ...missing, ...extraMissing ? [extra] : []];
+  return missing.length === 0 ? tools : [...tools, ...missing];
 }
-function injectOpenaiTool(tools, extra) {
-  if (!Array.isArray(tools)) return extra ? [...ACP_TOOLS_OPENAI, extra] : [...ACP_TOOLS_OPENAI];
+function injectOpenaiTool(tools) {
+  if (!Array.isArray(tools)) return [...ACP_TOOLS_OPENAI];
   const present = new Set(
     tools.map((t) => t?.function?.name).filter((n) => typeof n === "string")
   );
   const additions = ACP_TOOLS_OPENAI.filter((t) => !present.has(t.function.name));
-  const out = [...tools, ...additions];
-  if (extra && !out.some((t) => t?.function?.name === extra.function?.name)) out.push(extra);
-  return out;
+  return [...tools, ...additions];
 }
 var FORCE_TEXT_PROTOCOL = process.env.ACP_COMPRESS_PROTOCOL === "text";
 function injectResponsesTool(tools, toolsToAdd = ACP_TOOLS_RESPONSES) {
@@ -60167,27 +59820,19 @@ ${hdrText}
         const parsedReq = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
         const reqHeaders = buildForwardHeaders(headers);
         const textProtocol = prepared.protocol === "responses" && !!prepared.responsesTextProtocol;
-        const absorbActive = absorbEnabled(config) && opts.compress.injectTool && !textProtocol;
-        const loopConfig = absorbActive ? config : { ...config, absorb: void 0 };
-        const absorbSection = absorbActive ? `
-
----
-
-${buildAbsorbSystemPrompt(absorbToolName(loopConfig))}` : "";
-        const systemPrompt = (textProtocol ? buildCompressHybridSystemPrompt(prepared.prompts ?? defaultPrompts) : buildCompressSystemPrompt(prepared.prompts ?? defaultPrompts)) + absorbSection;
-        const adapter = pickAdapter(prepared.protocol, parsedReq, textProtocol, prepared.responsesProjection, prepared.anthropicSystem, prepared.openaiSystemText, prepared.session.hostCreditTokens ?? 0, absorbActive ? absorbToolName(loopConfig) : void 0);
+        const systemPrompt = textProtocol ? buildCompressHybridSystemPrompt(prepared.prompts ?? defaultPrompts) : buildCompressSystemPrompt(prepared.prompts ?? defaultPrompts);
+        const adapter = pickAdapter(prepared.protocol, parsedReq, textProtocol, prepared.responsesProjection, prepared.anthropicSystem, prepared.openaiSystemText, prepared.session.hostCreditTokens ?? 0);
         const refreshFolded = (current) => {
           const turn = core.processTurn({
             messages: prepared.originalMessages,
             state: prepared.session.state,
-            config: loopConfig,
+            config,
             tokenCount: prepared.session.stats.lastInputTokens,
             renderTags: prepared.renderTags ?? "text-only"
           });
           prepared.session.state = turn.state;
-          const viewed = applyAbsorbView(turn.messages, turn.state, loopConfig, prepared.session.stats.lastInputTokens);
           const records = current.filter((m2) => typeof m2.id === "string" && m2.id.startsWith("acp_loop_"));
-          return repairResponsesAssistantOrdering(stripKernelSummaries([...viewed, ...records], turn.state), prepared.originalMessages);
+          return repairResponsesAssistantOrdering(stripKernelSummaries([...turn.messages, ...records], turn.state), prepared.originalMessages);
         };
         const loop = runCompressLoop(
           streamToRead,