opencode-context-indicator 1.1.6 → 1.2.1

package/lib/limits.js

@@ -6,6 +6,16 @@
 // client.config.providers(), ensureModelLimits for V2 via ctx.model.list()).
 // hydrateModelLimitsFromState() seeds the maps from the shared state.json
 // snapshot via ./state.js. Extracted 1:1 (code + WHY comments) from index.js.
+//
+// Compaction ceiling (v2.0.23): opencode's core calculateCeiling() in
+// packages/core/src/session/compaction.ts derives the auto-compaction trigger
+// ceiling as window - reserve, where window = limit.input || limit.context
+// (null/zero falls through to the context window) and
+//   reserve = max(floor(window * 0.1), window >= 32_000 ? 16_000 : 0)
+// A compaction.buffer configured in opencode itself is NOT visible to the
+// plugin (the plugin cannot read opencode's internal compaction config); the
+// env var OPENCODE_CONTEXT_INDICATOR_COMPACT_BUFFER overrides the reserve for
+// testing and power users only (positive finite integer <= 1e9, ignore invalid).
 
 import { finitePos, withTimeout } from "./estimate.js";
 import { logErr, readStateSnapshot } from "./state.js";
@@ -67,32 +77,73 @@ function getModelLimit(providerID, modelID) {
   return typeof rec.context === "number" && rec.context > 0 ? rec.context : null;
 }
 
-// Native opencode usable window (see packages/opencode/src/session/overflow.ts):
-//   usable = limit.input ? limit.input − reserved : limit.context − maxOutput
-//   reserved = compaction.reserved ?? min(20_000, maxOutput)
-//   maxOutput = model.limit.output
-// Returns { usable, limit, maxOutput, reserved } or null when not derivable
-// (callers then degrade to count / limit.context, or to no percentage at all).
-function getUsableContext(providerID, modelID) {
+// Compute the reserve for a given window, matching opencode v2.0.23
+// packages/core/src/session/compaction.ts calculateCeiling().  Returns null when
+// window is not a finite positive number.
+function reserveFor(window, bufferOverride) {
+  if (
+    typeof window !== "number" ||
+    !Number.isFinite(window) ||
+    window <= 0
+  ) return null;
+  // bufferOverride: accept only finite, non-negative integers <= 1e9.
+  if (
+    typeof bufferOverride === "number" &&
+    Number.isFinite(bufferOverride) &&
+    bufferOverride >= 0 &&
+    bufferOverride <= 1e9
+  ) {
+    return bufferOverride;
+  }
+  // Default reserve formula (mirror of opencode core):
+  //   max(floor(window * 0.1), window >= 32_000 ? 16_000 : 0)
+  return Math.max(
+    Math.floor(window * 0.1),
+    window >= 32_000 ? 16_000 : 0,
+  );
+}
+
+// Native opencode compaction ceiling (v2.0.23 calculateCeiling):
+//   window = limit.input || limit.context  (zero/null falls through to context)
+//   reserve = reserveFor(window)  [or bufferOverride when provided]
+//   usable  = window - reserve
+// Returns { usable, limit: window, maxOutput, reserved } or null when not
+// derivable (callers then degrade to count / limit.context, or no percentage).
+// The per-model compaction.reserved and the old min(20000, maxOutput) no longer
+// participate in this calculation; opencode's internal buffer is not visible.
+function getUsableContext(providerID, modelID, bufferOverride) {
   const rec = getModelLimitRecord(providerID, modelID);
   if (!rec) return null;
   const context =
     typeof rec.context === "number" && rec.context > 0 ? rec.context : null;
   const input =
     typeof rec.input === "number" && rec.input > 0 ? rec.input : null;
+  if (input == null && context == null) return null;
+  // Mirror core's limit.input || limit.context (zero/null falls through to context).
+  const window = input != null && input > 0 ? input : context;
+  if (window == null || !(window > 0)) return null;
+
+  // When bufferOverride is omitted, read it from the env var once per call.
+  let resolvedBuffer = bufferOverride;
+  if (resolvedBuffer === undefined) {
+    const raw = process.env.OPENCODE_CONTEXT_INDICATOR_COMPACT_BUFFER;
+    // Strict digits-only: reject "5000abc", "5e3", " 5000", "", "-1" and other
+    // partial parses (parseInt/parseFloat stop at the first non-digit).
+    if (typeof raw === "string" && /^\d+$/.test(raw)) {
+      const parsed = parseInt(raw, 10);
+      if (Number.isFinite(parsed) && parsed >= 0 && parsed <= 1e9) {
+        resolvedBuffer = parsed;
+      }
+    }
+  }
+
+  const reserve = reserveFor(window, resolvedBuffer);
+  if (reserve == null) return null;
+  const usable = window - reserve;
+  if (usable <= 0) return null;
   const maxOutput =
     typeof rec.output === "number" && rec.output > 0 ? rec.output : 0;
-  if (input == null && context == null) return null;
-  // Mirrors opencode overflow.ts: reserved = min(20000, maxOutput), i.e. 0 when
-  // the model declares no output limit (NOT a 20000 default — that would
-  // understate the usable window).
-  const reserved =
-    typeof rec.reserved === "number" && rec.reserved >= 0
-      ? rec.reserved
-      : Math.min(20000, maxOutput);
-  const usable = input != null ? input - reserved : context - maxOutput;
-  if (!(usable > 0)) return null;
-  return { usable, limit: context, maxOutput, reserved };
+  return { usable, limit: window, maxOutput, reserved: reserve };
 }
 
 // Store a model limit record under `<providerID>:<modelID>`. Written by
@@ -366,13 +417,18 @@ function hydrateModelLimitsFromState() {
         }
       }
 
-      // Build the record: precise usable-as-input when known (so getUsableContext
-      // re-derives EXACTLY the persisted window), else the raw context window.
+      // Build the record: seed the raw window (context, preferring limit when
+      // present) so the NEW formula derives the ceiling fresh on every call.
+      // The old precise-usable-as-input seeding (which caused double-reserve
+      // under the new formula) is retired: getUsableContext is now a pure
+      // function of the window and needs no pre-derived state.
       let rec = null;
-      if (best.usable != null) {
-        rec = { context: best.limit, input: best.usable, output: null, reserved: 0 };
-      } else if (best.limit != null) {
+      if (best.limit != null) {
         rec = { context: best.limit, input: null, output: null, reserved: null };
+      } else if (best.usable != null) {
+        // No limit in snapshot: fall back to persisted usable as a best-effort
+        // window (it was the ceiling before the formula change, close enough).
+        rec = { context: best.usable, input: null, output: null, reserved: null };
       }
       if (rec == null) continue;
       modelLimits.set(key, rec);
@@ -396,6 +452,7 @@ export {
   modelKey,
   getModelLimit,
   getUsableContext,
+  reserveFor,
   setModelLimit,
   ensureProviderLimits,
   ensureModelLimits,

package/lib/state.js

@@ -331,14 +331,23 @@ function writeStateFile(
     }
     try {
       const bd = breakdownCache.get(sessionID) || null;
-      const limit = getModelLimit(providerID, modelID);
       const usableInfo = getUsableContext(providerID, modelID);
+      // Persist the EFFECTIVE window (limit.input || limit.context — the same
+      // window the ceiling was derived from), not the raw context window: on a
+      // cold instance hydrateModelLimitsFromState seeds context = limit, so a
+      // mismatched limit would re-derive a WRONG (too large) ceiling for models
+      // where limit.input < limit.context.
+      const limit =
+        usableInfo != null && usableInfo.limit != null
+          ? usableInfo.limit
+          : getModelLimit(providerID, modelID);
       const denom =
         usableInfo != null
           ? usableInfo.usable
           : limit != null && limit > 0
             ? limit
             : null;
+      const reserve = usableInfo != null ? usableInfo.reserved : null;
       const total =
         typeof ctxTokens === "number" && ctxTokens > 0
           ? ctxTokens
@@ -433,6 +442,12 @@ function writeStateFile(
             : sameModelAsPrev && finitePos(prevEntry.usable)
               ? prevEntry.usable
               : null,
+        reserve:
+          reserve != null
+            ? reserve
+            : sameModelAsPrev && finitePos(prevEntry.reserve)
+              ? prevEntry.reserve
+              : null,
         limit:
           limit != null
             ? limit

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-context-indicator",
-  "version": "1.1.6",
+  "version": "1.2.1",
   "description": "Real-time OpenCode context-window usage indicator: per-category token breakdown written to a log file, plus an optional TUI sidebar. Dual V1 + V2 plugin entry.",
   "type": "module",
   "license": "MIT",
@@ -56,11 +56,11 @@
     }
   },
   "dependencies": {
-    "@opentui/solid": "0.5.14"
+    "@opentui/solid": "0.5.16"
   },
   "devDependencies": {
     "@opencode/plugin": "^2.0.19",
-    "@opentui/core": "0.5.14",
+    "@opentui/core": "0.5.16",
     "esbuild": "^0.28.2",
     "node-pty": "^1.1.0",
     "solid-js": "^1.9.12"