opencode-acp 1.18.2 → 1.18.3-pr.477.211

package/dist/index.js

@@ -2148,8 +2148,57 @@ Using previous/default values`
 // lib/compress/range.ts
 import { tool as tool2 } from "@opencode-ai/plugin";
 
+// lib/bili-proxy.ts
+var BILI_PROXY_MARKER = "/bili/";
+function extractBaseURL(entry) {
+  if (!entry || typeof entry !== "object") return void 0;
+  const record = entry;
+  const options = record.options;
+  if (options && typeof options === "object") {
+    const optionBaseURL = options.baseURL;
+    if (typeof optionBaseURL === "string" && optionBaseURL.length > 0) {
+      return optionBaseURL;
+    }
+  }
+  const topLevelBaseURL = record.baseURL;
+  if (typeof topLevelBaseURL === "string" && topLevelBaseURL.length > 0) {
+    return topLevelBaseURL;
+  }
+  return void 0;
+}
+function findBiliProxyProviders(provider) {
+  if (!provider || typeof provider !== "object") return [];
+  const matches = [];
+  for (const [name, entry] of Object.entries(provider)) {
+    const baseURL = extractBaseURL(entry);
+    if (baseURL !== void 0 && baseURL.includes(BILI_PROXY_MARKER)) {
+      matches.push({ provider: name, baseURL });
+    }
+  }
+  return matches;
+}
+var BILI_PROXY_ENV_VAR = "BILLION_CONTEXT_PROXY";
+var BILI_NATIVE_ENV_VAR = "BILLION_CONTEXT_NATIVE";
+function detectBiliEnvYield(env = process.env) {
+  if (env[BILI_PROXY_ENV_VAR]) return "launcher";
+  if (env[BILI_NATIVE_ENV_VAR]) return "native";
+  return null;
+}
+function describeBiliEnvYield(source) {
+  return source === "native" ? "BILLION_CONTEXT_NATIVE set (billion-context native mode)" : "BILLION_CONTEXT_PROXY set (billion-context launcher mode)";
+}
+function biliYieldLogMessage(source) {
+  return source === "native" ? "[opencode-acp] disabled: BILLION_CONTEXT_NATIVE detected \u2014 billion-context native mode handles compression" : "[opencode-acp] disabled: BILLION_CONTEXT_PROXY detected \u2014 proxy handles compression";
+}
+
 // lib/compress/types.ts
 function resolveToolContext(factoryCtx, sessionID) {
+  const biliYield = detectBiliEnvYield();
+  if (biliYield !== null) {
+    throw new Error(
+      `ACP is disabled in this process \u2014 ${describeBiliEnvYield(biliYield)}. billion-context owns context compression; do not call ACP tools again.`
+    );
+  }
   const state = factoryCtx.registry.get(sessionID);
   if (!state) {
     throw new Error(
@@ -2859,7 +2908,8 @@ function saveSessionState(sessionState, logger, sessionName) {
     lastCompaction: sessionState.lastCompaction,
     modelContextLimit: sessionState.modelContextLimit,
     modelProviderID: sessionState.modelProviderID,
-    modelID: sessionState.modelID
+    modelID: sessionState.modelID,
+    usageSanity: sessionState.usageSanity
   };
   const key = saveQueueKey(sessionState.sessionId, sessionState.storageDir);
   let queue = saveQueues.get(key);
@@ -3714,18 +3764,32 @@ function adjustBoundariesForToolPairs(context, startIdx, endIdx) {
   return { startIndex: newStartIdx, endIndex: newEndIdx };
 }
 function buildBoundaryRecoveryHint(context, state) {
-  const visibleRefs = [];
+  const visibleIndexes = [];
   for (const [messageRef, messageId] of state.messageIds.byRef) {
-    if (context.rawMessagesById.has(messageId)) {
-      visibleRefs.push(messageRef);
-    }
+    if (!context.rawMessagesById.has(messageId)) continue;
+    const idx = parseMessageRef(messageRef);
+    if (idx !== null) visibleIndexes.push(idx);
   }
+  visibleIndexes.sort((a, b) => a - b);
+  const renderSpan = (start, end) => start === end ? formatMessageRef(start) : `${formatMessageRef(start)}\u2013${formatMessageRef(end)}`;
   const parts = [];
-  if (visibleRefs.length > 0) {
-    visibleRefs.sort();
-    const first = visibleRefs[0];
-    const last = visibleRefs[visibleRefs.length - 1];
-    parts.push(`Current visible: ${first}\u2013${last} (${visibleRefs.length} msgs).`);
+  if (visibleIndexes.length > 0) {
+    const spans = [];
+    let spanStart = visibleIndexes[0];
+    let spanPrev = visibleIndexes[0];
+    for (let i = 1; i < visibleIndexes.length; i++) {
+      const idx = visibleIndexes[i];
+      if (idx !== spanPrev + 1) {
+        spans.push(renderSpan(spanStart, spanPrev));
+        spanStart = idx;
+      }
+      spanPrev = idx;
+    }
+    spans.push(renderSpan(spanStart, spanPrev));
+    const MAX_SPANS = 8;
+    const shown = spans.slice(0, MAX_SPANS);
+    const overflow = spans.length - shown.length;
+    parts.push(`Free ranges: ${shown.join(", ")}${overflow > 0 ? ` (+${overflow} more)` : ""}.`);
   }
   const blockCount = context.summaryByBlockId.size;
   if (blockCount > 0) {
@@ -3734,7 +3798,7 @@ function buildBoundaryRecoveryHint(context, state) {
   if (parts.length === 0) {
     return "";
   }
-  return `${parts.join(" ")} Call acp_status() to see which blocks consumed which IDs, then retry with valid IDs.`;
+  return `${parts.join(" ")} Retry with IDs inside the free ranges.`;
 }
 function clampMessageRef(requested, context, state) {
   if (state.messageIds.byRef.has(requested.ref)) return null;
@@ -5183,6 +5247,14 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
     state.modelProviderID = persisted.modelProviderID;
     state.modelID = persisted.modelID;
   }
+  if (persisted.usageSanity) {
+    const { reported, estimated } = persisted.usageSanity;
+    if (Number.isFinite(reported) && Number.isFinite(estimated) && reported >= 0 && estimated >= 0) {
+      state.usageSanity = { reported, estimated };
+    } else {
+      state.usageSanity = void 0;
+    }
+  }
   const applied = applyPendingCompressionDurations(state);
   if (applied > 0) {
     await saveSessionState(state, logger);
@@ -6384,24 +6456,32 @@ function computeStats(plan) {
   const retentionPct = originalTokens > 0 ? (summaryChars / (originalTokens * 4) * 100).toFixed(2) : "?";
   return { originalTokens, summaryChars, ratio, retentionPct };
 }
-function buildQualityRejectionError(plan, result) {
+function coreReason(reason) {
+  if (!reason) return "unknown";
+  const candidates = [reason.indexOf(":"), reason.indexOf("(")].filter((i) => i >= 0);
+  const cut = Math.min(...candidates);
+  return (cut > 0 ? reason.slice(0, cut) : reason).trim() || "unknown";
+}
+function buildQualityRejectionError(plan, result, logger) {
   const stats = computeStats(plan);
-  const metrics = [
-    `Reason: ${result.reason || "unknown"}`,
-    `Original: ~${stats.originalTokens} tokens`,
-    `Summary: ${stats.summaryChars} chars`,
-    `Ratio: ${stats.ratio}:1`,
-    `Retention: ${stats.retentionPct}%`,
-    `Gate layer: ${result.layer ?? "unknown"}`,
-    `rougeF1: ${formatMetric(result, "rougeF1")}`,
-    `top20Recall: ${formatMetric(result, "top20Recall")}`
-  ];
+  logger?.warn("quality gate rejected compression", {
+    range: `${plan.startId}\u2013${plan.endId}`,
+    reason: result.reason || "unknown",
+    layer: result.layer ?? "unknown",
+    originalTokens: stats.originalTokens,
+    summaryChars: stats.summaryChars,
+    ratio: stats.ratio,
+    retentionPct: stats.retentionPct,
+    rougeF1: formatMetric(result, "rougeF1"),
+    top20Recall: formatMetric(result, "top20Recall")
+  });
   const message = `\u26A0\uFE0F COMPRESSION REJECTED \u2014 QUALITY GATE FAILURE
 
 Range: ${plan.startId}\u2013${plan.endId}
-${metrics.join("\n")}
+Reason: ${coreReason(result.reason)}
+Original: ~${stats.originalTokens} tokens \xB7 Summary: ${stats.summaryChars} chars \xB7 Retention: ${stats.retentionPct}%
 
-Retry: rewrite a more complete summary that preserves critical details (file paths, decisions, exact values, errors) and call compress again on the same range \u2014 the gate re-evaluates automatically. Full compression rules are already in your system prompt. If you are confident the summary is correct despite the metrics, add "acknowledgeRisk": true to bypass the quality gate on your next compress call.`;
+Retry: write a more complete summary preserving critical details (file paths, decisions, exact values, errors), then call compress again on the same range. If you are confident the summary is adequate despite the metrics, pass "acknowledgeRisk": true.`;
   return new Error(message);
 }
 
@@ -6727,6 +6807,49 @@ ${guidance}
 ${afterClose}`;
 }
 
+// lib/usage-sanity.ts
+var RELAY_INFLATION_RATIO = 1.5;
+var PAYLOAD_FLOOR_TOKENS = 5e3;
+function estimatePayloadTokens(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    if (isSyntheticMessage(msg)) continue;
+    if (isIgnoredUserMessage(msg)) continue;
+    total += estimateAllMessageTokensFast(msg);
+  }
+  return total;
+}
+function resolveCurrentUsage(state, messages, logger) {
+  const reported = getCurrentTokenUsage(state, messages);
+  if (reported === 0) {
+    return { tokens: 0, source: "reported", inflationDetected: false };
+  }
+  const estimated = estimatePayloadTokens(messages) + (state.systemPromptTokens ?? 0);
+  const prev = state.usageSanity;
+  let inflationDetected = false;
+  if (prev !== void 0 && prev.reported > 0 && prev.estimated >= PAYLOAD_FLOOR_TOKENS && estimated >= PAYLOAD_FLOOR_TOKENS) {
+    const reportRatio = reported / prev.reported;
+    const payloadRatio = estimated / prev.estimated;
+    if (reportRatio > RELAY_INFLATION_RATIO && payloadRatio <= RELAY_INFLATION_RATIO) {
+      inflationDetected = true;
+    }
+  }
+  state.usageSanity = { reported, estimated };
+  if (inflationDetected) {
+    logger?.warn("Relay usage inflation detected \u2014 re-estimating context size", {
+      session: state.sessionId,
+      reported,
+      previousReported: prev.reported,
+      reportRatio: +(reported / prev.reported).toFixed(3),
+      estimated,
+      previousEstimated: prev.estimated,
+      payloadRatio: +(estimated / prev.estimated).toFixed(3)
+    });
+    return { tokens: estimated, source: "reestimated", inflationDetected: true };
+  }
+  return { tokens: reported, source: "reported", inflationDetected: false };
+}
+
 // lib/messages/utils.ts
 import { createHash as createHash2 } from "crypto";
 var SUMMARY_ID_HASH_LENGTH = 16;
@@ -7077,7 +7200,7 @@ function isContextOverLimits(config, state, providerId, modelId, messages) {
   );
   const maxContextLimit = resolvedMaxContextLimit === void 0 ? void 0 : resolvedMaxContextLimit + summaryTokenExtension;
   const minContextLimit = resolveContextTokenLimit(config, state, providerId, modelId, "min");
-  const currentTokens = getCurrentTokenUsage(state, messages);
+  const currentTokens = resolveCurrentUsage(state, messages).tokens;
   let overMaxLimit = maxContextLimit === void 0 ? false : currentTokens > maxContextLimit;
   const overMinLimit = minContextLimit === void 0 ? false : currentTokens >= minContextLimit;
   if (overMaxLimit) {
@@ -8063,7 +8186,8 @@ function createCompressRangeTool(factoryCtx) {
                 messageIds: plan.selection.messageIds,
                 messageTokenById: plan.selection.messageTokenById
               },
-              result
+              result,
+              ctx.logger
             );
           }
         }
@@ -8381,6 +8505,29 @@ var resolveEffectiveCompressPermission = (basePermission, hostPermissions, agent
 var hasExplicitToolPermission = (permissionConfig, tool6) => {
   return permissionConfig ? Object.prototype.hasOwnProperty.call(permissionConfig, tool6) : false;
 };
+var anyRuleResolves = (permissionConfig, tool6) => {
+  if (hasExplicitToolPermission(permissionConfig, tool6)) {
+    return true;
+  }
+  const match = findLastMatchingRule(
+    getPermissionRules([permissionConfig]),
+    (rule) => wildcardMatch(tool6, rule.permission)
+  );
+  return match !== void 0;
+};
+var applyAcpToolPermissions = (permissionConfig, compressPermission2) => {
+  if (permissionConfig && hasExplicitToolPermission(permissionConfig, "compress")) {
+    return permissionConfig;
+  }
+  const next = {
+    ...permissionConfig ?? {},
+    compress: compressPermission2
+  };
+  if (!anyRuleResolves(permissionConfig, "acp_status")) {
+    next.acp_status = "allow";
+  }
+  return next;
+};
 
 // lib/compress-permission.ts
 var compressPermission = (state, config) => {
@@ -9205,7 +9352,8 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
   const allInProtectedZone = protectedRefs.size > 0 && unprotectedCompressible.length === 0;
   const allBelowMin = contextRanges.compressible.length > 0 && recommendedRanges.length === 0;
   const noExecutableCandidates = candidatesEnabled && nudgeAllowed && candidateMessages !== void 0 && candidatePlan.candidates.length === 0;
-  const nothingToCompress = candidatesEnabled && candidateMessages !== void 0 ? noExecutableCandidates : allProtected || allInProtectedZone || allBelowMin;
+  const noRangesAtAll = contextRanges.compressible.length === 0 && contextRanges.protected.length === 0;
+  const nothingToCompress = (candidatesEnabled && candidateMessages !== void 0 ? noExecutableCandidates : allProtected || allInProtectedZone || allBelowMin) || noRangesAtAll;
   const emergencyNoTargets = emergencyOverride && nothingToCompress;
   const noticeCadenceMet = state.nudges.lastNudgeShownTokens === void 0 || growthSinceBaseline !== void 0 && growthSinceBaseline >= growthFloor;
   let shouldInjectNudge = nudgeAllowed && !nothingToCompress;
@@ -9410,7 +9558,7 @@ ${rules}`;
   } else if (nudgeAllowed && nothingToCompress) {
     logger.info("Nudge suppressed: nothing to compress", {
       session: state.sessionId,
-      reason: allProtected ? "all_protected" : allInProtectedZone ? "in_protected_zone" : allBelowMin ? "below_effective_floor" : "no_executable_candidates",
+      reason: allProtected ? "all_protected" : allInProtectedZone ? "in_protected_zone" : allBelowMin ? "below_effective_floor" : noRangesAtAll ? "no_compressible_ranges" : "no_executable_candidates",
       currentTokens,
       usagePct,
       compressibleRanges: contextRanges.compressible.length
@@ -9823,6 +9971,81 @@ function computeRestoredMessages(messagesState, activeMessagesBefore) {
   }
   return { restoredMessageCount, restoredTokens };
 }
+function collectRequiredDecompressMessageIds(messagesState, targets, options = {}) {
+  const targetBlockIds = /* @__PURE__ */ new Set();
+  for (const target of targets) {
+    for (const block of target.blocks) {
+      targetBlockIds.add(block.blockId);
+    }
+  }
+  if (targetBlockIds.size === 0) {
+    return [];
+  }
+  const consumedClosure = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const target of targets) {
+    for (const block of target.blocks) {
+      for (const id of block.consumedBlockIds ?? []) {
+        if (!consumedClosure.has(id)) {
+          queue.push(id);
+        }
+      }
+    }
+  }
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (consumedClosure.has(id)) continue;
+    consumedClosure.add(id);
+    const consumed = messagesState.blocksById.get(id);
+    if (consumed) {
+      for (const nested of consumed.consumedBlockIds ?? []) {
+        if (!consumedClosure.has(nested)) {
+          queue.push(nested);
+        }
+      }
+    }
+  }
+  let shieldedMessageIds = null;
+  if (!options.full) {
+    shieldedMessageIds = /* @__PURE__ */ new Set();
+    for (const id of consumedClosure) {
+      const block = messagesState.blocksById.get(id);
+      if (!block || block.deactivatedByUser || block.deactivatedByUserDeep) continue;
+      for (const messageId of block.effectiveMessageIds ?? []) {
+        shieldedMessageIds.add(messageId);
+      }
+    }
+  }
+  const required = [];
+  for (const [messageId, entry] of messagesState.byMessageId) {
+    if (entry.activeBlockIds.length === 0) continue;
+    let exclusivelyCoveredByTargets = true;
+    for (const blockId of entry.activeBlockIds) {
+      if (!targetBlockIds.has(blockId)) {
+        exclusivelyCoveredByTargets = false;
+        break;
+      }
+    }
+    if (!exclusivelyCoveredByTargets) continue;
+    if (shieldedMessageIds?.has(messageId)) continue;
+    required.push(messageId);
+  }
+  required.sort();
+  return required;
+}
+function checkDecompressSourceAvailability(messagesState, targets, options, presentInHistory) {
+  const requiredMessageIds = collectRequiredDecompressMessageIds(messagesState, targets, options);
+  const available = [];
+  const missing = [];
+  for (const messageId of requiredMessageIds) {
+    if (presentInHistory.has(messageId)) {
+      available.push(messageId);
+    } else {
+      missing.push(messageId);
+    }
+  }
+  return { requiredMessageIds, availableMessageIds: available, missingMessageIds: missing };
+}
 function computeReactivatedBlockIds(messagesState, activeBlockIdsBefore) {
   return Array.from(messagesState.activeBlockIds).filter((blockId) => !activeBlockIdsBefore.has(blockId)).sort((a, b) => a - b);
 }
@@ -10031,14 +10254,31 @@ function buildSchema2() {
   };
 }
 function extractMessageId(m) {
-  return m.id ?? m.messageId ?? "";
+  return m?.info?.id ?? "";
+}
+function serializeMessagePart(part) {
+  if (!part || typeof part !== "object") return null;
+  if (part.type === "text") {
+    return typeof part.text === "string" && part.text.length > 0 ? part.text : null;
+  }
+  if (part.type === "tool") {
+    const contents = extractToolContent(part);
+    if (contents.length === 0) return null;
+    const toolName = "tool" in part && typeof part.tool === "string" && part.tool.length > 0 ? part.tool : "tool";
+    return `[${toolName}] ${contents.join("\n")}`;
+  }
+  return null;
 }
 function extractMessageText2(m) {
-  const msg = m;
-  const role = msg.role || msg.type || "unknown";
-  const content = typeof msg.content === "string" ? msg.content : typeof msg.text === "string" ? msg.text : JSON.stringify(msg.content || msg.text || "");
+  const role = m?.info?.role ?? "unknown";
+  const parts = Array.isArray(m.parts) ? m.parts : [];
+  const segments = [];
+  for (const part of parts) {
+    const serialized = serializeMessagePart(part);
+    if (serialized !== null) segments.push(serialized);
+  }
   return `[${role}]
-${content}`;
+${segments.join("\n\n")}`;
 }
 function createDecompressTool(factoryCtx) {
   return tool3({
@@ -10090,10 +10330,40 @@ function createDecompressTool(factoryCtx) {
         const blockMessages = rawMessages.filter((m) => msgIdSet.has(extractMessageId(m)));
         const lines2 = blockMessages.map(extractMessageText2);
         const { writeFile: writeFile4 } = await import("fs/promises");
-        const fileContent = lines2.length > 0 ? lines2.join("\n\n---\n\n") : targets[0]?.blocks[0]?.summary ?? "(no content available)";
+        let fileContent;
+        let sourceNote;
+        if (lines2.length > 0) {
+          fileContent = lines2.join("\n\n---\n\n");
+          sourceNote = `${blockMessages.length} original message${blockMessages.length === 1 ? "" : "s"}`;
+        } else {
+          fileContent = targets[0]?.blocks[0]?.summary ?? "(no content available)";
+          sourceNote = `no original messages found; wrote block summary (${targets.length} block${targets.length === 1 ? "" : "s"})`;
+        }
         await writeFile4(targetPath, fileContent, "utf-8");
         const displayIds2 = targets.map((t) => `b${t.displayId}`).join(", ");
-        return `Block(s) ${displayIds2} content (${blockMessages.length} messages, ${fileContent.length} chars) written to ${targetPath}. Block(s) stay compressed \u2014 context unchanged. Use read tool to access specific parts.`;
+        return `Block(s) ${displayIds2} content (${sourceNote}, ${fileContent.length} chars) written to ${targetPath}. Block(s) stay compressed \u2014 context unchanged. Use read tool to access specific parts.`;
+      }
+      const availability = checkDecompressSourceAvailability(
+        messagesState,
+        targets,
+        { full: args.full === true },
+        new Set(rawMessages.map((m) => m.info.id))
+      );
+      if (availability.missingMessageIds.length > 0) {
+        const displayIds2 = targets.map((t) => `b${t.displayId}`).join(", ");
+        const missingRefs = availability.missingMessageIds.map(
+          (id) => ctx.state.messageIds.byRawId.get(id) ?? id
+        );
+        const shownRefs = missingRefs.slice(0, 10).join(", ");
+        const extraCount = missingRefs.length - Math.min(missingRefs.length, 10);
+        ctx.logger.warn("Decompress aborted: source messages missing from host history", {
+          targetDisplayIds: displayIds2,
+          full: args.full === true,
+          requiredCount: availability.requiredMessageIds.length,
+          missingCount: availability.missingMessageIds.length,
+          missingRefs
+        });
+        return `Error: Cannot decompress ${displayIds2}: ${availability.missingMessageIds.length} of ${availability.requiredMessageIds.length} source message(s) are no longer present in session history (removed by native compaction or external deletion). Missing: ${shownRefs}` + (extraCount > 0 ? ` (+${extraCount} more)` : "") + `. Block(s) stay compressed \u2014 the summary remains available and nothing was changed. This is a missing-source condition, not a transient fetch failure.`;
       }
       const activeMessagesBefore = snapshotActiveMessages(messagesState);
       const activeBlockIdsBefore = new Set(messagesState.activeBlockIds);
@@ -10906,7 +11176,7 @@ import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join4 } from "path";
 import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir3 } from "os";
-var LOG_VERSION = true ? "1.18.2" : "dev";
+var LOG_VERSION = true ? "1.18.3-pr.477.211" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -11712,7 +11982,17 @@ var KEEP_PREFIX_CHARS = 2e3;
 var KEEP_SUFFIX_CHARS = 2e3;
 var PROTECT_RECENT_MESSAGES = 3;
 var OUTPUT_RESERVE_TOKENS = 16384;
+var MAX_OVERHEAD_ERROR_SESSIONS = 1024;
 var overheadErrorLogged = /* @__PURE__ */ new Set();
+function recordOverheadError(sessionKey) {
+  if (overheadErrorLogged.has(sessionKey)) return false;
+  if (overheadErrorLogged.size >= MAX_OVERHEAD_ERROR_SESSIONS) {
+    const oldest = overheadErrorLogged.values().next().value;
+    if (oldest !== void 0) overheadErrorLogged.delete(oldest);
+  }
+  overheadErrorLogged.add(sessionKey);
+  return true;
+}
 function parseGcThreshold(threshold, modelContextLimit) {
   if (typeof threshold === "number") return threshold;
   const str = threshold ?? "100%";
@@ -11730,8 +12010,7 @@ function truncateLargeToolOutputs(state, config, logger, messages) {
   const threshold = Math.min(configuredThreshold, effective.limit - overhead);
   if (threshold <= 0) {
     const sessionKey = state.sessionId ?? "unknown";
-    if (!overheadErrorLogged.has(sessionKey)) {
-      overheadErrorLogged.add(sessionKey);
+    if (recordOverheadError(sessionKey)) {
       logger.error("ACP: model context window too small to fit overhead", {
         session: state.sessionId,
         limit: effective.limit,
@@ -13118,7 +13397,7 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
       saveSessionState(state, logger).catch(() => {
       });
     }
-    const prePruneTokens = getCurrentTokenUsage(state, output.messages);
+    const prePruneTokens = resolveCurrentUsage(state, output.messages, logger).tokens;
     const candidateMessages = config.compress.candidates === true ? output.messages.slice() : void 0;
     prune(state, logger, config, output.messages);
     hideConsumedCompressCalls(state, output.messages);
@@ -13167,7 +13446,7 @@ ${text}`);
     if (state.sessionId && smartPlanEnabled === true) {
       recordVisibleMessages(state.sessionId, output.messages);
     }
-    const postTokens = getCurrentTokenUsage(state, output.messages);
+    const postTokens = resolveCurrentUsage(state, output.messages, logger).tokens;
     if (postTokens !== void 0 && effectiveLimit) {
       const budget = effectiveLimit.limit - (state.systemPromptTokens ?? 0) - OUTPUT_RESERVE_TOKENS;
       if (postTokens > budget) {
@@ -13380,36 +13659,6 @@ function configureClientAuth(client) {
   return client;
 }
 
-// lib/bili-proxy.ts
-var BILI_PROXY_MARKER = "/bili/";
-function extractBaseURL(entry) {
-  if (!entry || typeof entry !== "object") return void 0;
-  const record = entry;
-  const options = record.options;
-  if (options && typeof options === "object") {
-    const optionBaseURL = options.baseURL;
-    if (typeof optionBaseURL === "string" && optionBaseURL.length > 0) {
-      return optionBaseURL;
-    }
-  }
-  const topLevelBaseURL = record.baseURL;
-  if (typeof topLevelBaseURL === "string" && topLevelBaseURL.length > 0) {
-    return topLevelBaseURL;
-  }
-  return void 0;
-}
-function findBiliProxyProviders(provider) {
-  if (!provider || typeof provider !== "object") return [];
-  const matches = [];
-  for (const [name, entry] of Object.entries(provider)) {
-    const baseURL = extractBaseURL(entry);
-    if (baseURL !== void 0 && baseURL.includes(BILI_PROXY_MARKER)) {
-      matches.push({ provider: name, baseURL });
-    }
-  }
-  return matches;
-}
-
 // lib/update.ts
 import { readFile as readFile2, rm } from "fs/promises";
 import { basename, dirname as dirname4, join as join7 } from "path";
@@ -13616,15 +13865,14 @@ var server = (async (ctx) => {
   if (!config.enabled) {
     return {};
   }
-  if (process.env.BILLION_CONTEXT_PROXY) {
-    console.log(
-      "[opencode-acp] disabled: BILLION_CONTEXT_PROXY detected \u2014 proxy handles compression"
-    );
+  const setupBiliYield = detectBiliEnvYield();
+  if (setupBiliYield) {
+    console.log(biliYieldLogMessage(setupBiliYield));
     return {};
   }
   const logger = new Logger(config.debug, config.debug ? "debug" : config.logLevel);
   logger.info("ACP plugin initialized", {
-    version: true ? "1.18.2" : "dev",
+    version: true ? "1.18.3-pr.477.211" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,
@@ -13674,7 +13922,21 @@ var server = (async (ctx) => {
     prompts
   };
   let disabledByBiliProxy = false;
-  const guard = (fn) => (...args) => disabledByBiliProxy ? Promise.resolve() : fn(...args);
+  let announcedEnvYieldSource;
+  const noteEnvYield = (source) => {
+    if (source === null || announcedEnvYieldSource === source) return;
+    announcedEnvYieldSource = source;
+    console.log(biliYieldLogMessage(source));
+  };
+  const guard = (fn) => (...args) => {
+    if (disabledByBiliProxy) return Promise.resolve();
+    const envYield = detectBiliEnvYield();
+    if (envYield !== null) {
+      noteEnvYield(envYield);
+      return Promise.resolve();
+    }
+    return fn(...args);
+  };
   return {
     "experimental.chat.system.transform": guard(
       createSystemPromptHandler(registry4, logger, config, prompts)
@@ -13711,14 +13973,9 @@ var server = (async (ctx) => {
       }
     },
     config: async (opencodeConfig) => {
-      const biliMatches = findBiliProxyProviders(opencodeConfig.provider);
-      disabledByBiliProxy = biliMatches.length > 0;
-      if (biliMatches.length > 0) {
-        console.log(
-          "[opencode-acp] disabled: /bili/ proxy detected in provider baseURL (" + biliMatches.map((m) => m.provider).join(", ") + ") \u2014 proxy handles compression"
-        );
-        const permission = opencodeConfig.permission ?? {};
-        opencodeConfig.permission = {
+      const denyAcpTools = (opencodeConfig2) => {
+        const permission = opencodeConfig2.permission ?? {};
+        opencodeConfig2.permission = {
           ...permission,
           compress: "deny",
           decompress: "deny",
@@ -13726,6 +13983,20 @@ var server = (async (ctx) => {
           acp_status: "deny",
           acp_context_recap: "deny"
         };
+      };
+      const biliMatches = findBiliProxyProviders(opencodeConfig.provider);
+      disabledByBiliProxy = biliMatches.length > 0;
+      const envYield = detectBiliEnvYield();
+      if (envYield !== null) {
+        noteEnvYield(envYield);
+        denyAcpTools(opencodeConfig);
+        return;
+      }
+      if (biliMatches.length > 0) {
+        console.log(
+          "[opencode-acp] disabled: /bili/ proxy detected in provider baseURL (" + biliMatches.map((m) => m.provider).join(", ") + ") \u2014 proxy handles compression"
+        );
+        denyAcpTools(opencodeConfig);
         return;
       }
       if (config.compress.permission !== "deny" && compressDisabledByOpencode(opencodeConfig.permission)) {
@@ -13749,14 +14020,10 @@ var server = (async (ctx) => {
           primary_tools: [...existingPrimaryTools, ...toolsToAdd]
         };
       }
-      if (!hasExplicitToolPermission(opencodeConfig.permission, "compress")) {
-        const permission = opencodeConfig.permission ?? {};
-        opencodeConfig.permission = {
-          ...permission,
-          compress: config.compress.permission,
-          acp_status: "allow"
-        };
-      }
+      opencodeConfig.permission = applyAcpToolPermissions(
+        opencodeConfig.permission,
+        config.compress.permission
+      );
       hostPermissions.global = opencodeConfig.permission;
       hostPermissions.agents = Object.fromEntries(
         Object.entries(opencodeConfig.agent ?? {}).map(([name, agent]) => [