opencode-context-indicator 1.4.0 → 1.5.0

package/lib/tui-panel.tsx

@@ -11,7 +11,7 @@ import { mkdirSync, writeFileSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { basename, join } from "node:path"
 import type { StateEntry } from "./tui-data.js"
-import { collectFamily, fit, fmt, num, updatedAt } from "./tui-data.js"
+import { collectFamily, fit, fmt, num, toolOutEntries, updatedAt } from "./tui-data.js"
 import { token } from "./tui-theme.js"
 import {
   buildRedactedPayload,
@@ -475,11 +475,13 @@ export function BreakdownPanel(props: {
     const model = safeText(r.model && r.model !== "unknown" ? r.model : "model?")
     const ctx = fmt(num(r.ctx))
     const d = panelDenom(r)
-    return d > 0
-      ? `Context breakdown \u2014 ${model} ${ctx}/${fmt(d)} (${Math.round(
-          (num(r.ctx) / d) * 100,
-        )}%)`
-      : `Context breakdown \u2014 ${model} ${ctx}`
+    const base =
+      d > 0
+        ? `Context breakdown \u2014 ${model} ${ctx}/${fmt(d)} (${Math.round(
+            (num(r.ctx) / d) * 100,
+          )}%)`
+        : `Context breakdown \u2014 ${model} ${ctx}`
+    return r.compactStale === true ? `${base} (stale — compacted)` : base
   }
 
   const layout = (): {
@@ -523,10 +525,27 @@ export function BreakdownPanel(props: {
       L.gutter +
       fit(money(costOf(e.sessionID)), L.costW) +
       L.gutter +
-      updatedAt(e.updatedAt)
+      updatedAt(e.updatedAt) +
+      (e.compactStale === true ? " (stale)" : "")
     )
   }
 
+  // One compact line: the main session's tool results split by tool name
+  // (server-side aggregate; the per-call "largest contributors" block above is
+  // the measured, client-side view).
+  const byToolLine = (): string => {
+    const all = data().root?.toolOutByTool
+    const entries = toolOutEntries(all, 5)
+    if (entries.length === 0) return ""
+    const total =
+      all && typeof all === "object"
+        ? Object.values(all).filter((v) => num(v) > 0).length
+        : 0
+    const parts = entries.map(([name, val]) => `${safeText(name)} ${fmt(val)}`)
+    if (total > entries.length) parts.push(`+${total - entries.length} more`)
+    return parts.join(" \u00b7 ")
+  }
+
   return (
     <box flexDirection="column">
       <text fg={base()}>{header()}</text>
@@ -551,6 +570,29 @@ export function BreakdownPanel(props: {
                 : "")}
           </text>
         </Show>
+        <Show
+          when={
+            num(data().root?.cacheRead) > 0 ||
+            num(data().root?.cacheWrite) > 0
+          }
+        >
+          <text fg={muted()}>
+            {"  prompt cache r " +
+              fmt(num(data().root?.cacheRead)) +
+              " / w " +
+              fmt(num(data().root?.cacheWrite)) +
+              " (provider-reported)"}
+          </text>
+        </Show>
+        <Show when={num(data().root?.reclaim?.tokens) > 0}>
+          <text fg={muted()}>
+            {"  reclaim ~" +
+              fmt(num(data().root?.reclaim?.tokens)) +
+              " redundant tool output (" +
+              num(data().root?.reclaim?.count) +
+              " dup)"}
+          </text>
+        </Show>
         <Show when={messages().available}>
           <text fg={base()}>{"largest contributors (measured)"}</text>
           <Show
@@ -569,6 +611,10 @@ export function BreakdownPanel(props: {
             }
           </text>
         </Show>
+        <Show when={byToolLine().length > 0}>
+          <text fg={base()}>{"tool results by tool"}</text>
+          <text fg={muted()}>{byToolLine()}</text>
+        </Show>
       </Show>
     </box>
   )

package/lib/tui-sidebar.tsx

@@ -66,6 +66,9 @@ export function Sidebar(props: { entry: () => StateEntry | null }) {
             : line("tool schemas", e()?.categories?.toolSchemas)}
         </text>
         <text fg={muted()}>{line("other", e()?.categories?.other)}</text>
+        <Show when={e()?.compactStale === true}>
+          <text fg={muted()}>{"  stale — compacted"}</text>
+        </Show>
         <text fg={muted()}>{`updated ${updatedAt(e()?.updatedAt)}`}</text>
       </Show>
     </box>

package/lib/v2.js

@@ -7,11 +7,18 @@
 // from index.js.
 
 import {
+  breakdownCategories,
+  computeReclaim,
+  contentFingerprint,
   estJson,
   estimateTokens,
+  extractToolTarget,
   fmt,
+  isSafeSessionKey,
   oneLine,
+  safeSaneOrNull,
   tokenCountOf,
+  TOOL_OUT_MAX_KEYS,
   withTimeout,
 } from "./estimate.js";
 import {
@@ -22,6 +29,10 @@ import {
   lastBdWrite,
   lastKnownCtx,
   lastKnownCtxCache,
+  lastKnownCacheRead,
+  lastKnownCacheReadCache,
+  lastKnownCacheWrite,
+  lastKnownCacheWriteCache,
   lastKnownInput,
   lastKnownInputCache,
   lastKnownModel,
@@ -75,10 +86,11 @@ const V2_FALLBACK_TIMEOUT_MS = 3000;
 // every schema does not run on every single model request.
 // Cheap structural fingerprint of the tool schema map: count + total description
 // length + number of schema property keys + two O(n) charCode checksums (mod
-// 0xFFFFFF) over every description and over the top-level input keys. The
-// checksums widen the fingerprint so two different schemas that happen to share
-// the same length/key counts do not collide into a wrong cache hit — without
-// paying for full JSON.stringify (the whole point of the cache).
+// 0xFFFFFF) over every description and over the PARAMETER names
+// (input.properties keys). The checksums widen the fingerprint so two different
+// schemas that happen to share the same length/key counts do not collide into a
+// wrong cache hit — without paying for full JSON.stringify (the whole point of
+// the cache).
 function toolsFingerprint(tools) {
   if (!tools || typeof tools !== "object") return "none";
   let n = 0;
@@ -98,14 +110,16 @@ function toolsFingerprint(tools) {
     const input = t?.input;
     if (input && typeof input === "object") {
       const props = input.properties;
-      propKeys +=
+      // Hash the PARAMETER names (input.properties keys) when present — a
+      // property rename that keeps the same count/description must change the
+      // fingerprint, or the TTL cache would serve a stale schema estimate.
+      // Fall back to the top-level schema keys for schemas without `properties`.
+      const nameSource =
         props && typeof props === "object"
-          ? Object.keys(props).length
-          : Object.keys(input).length;
-      // Sum the top-level key names so property RENAMES that keep the same count
-      // still change the fingerprint.
-      const topKeys = Object.keys(input);
-      for (const k of topKeys) {
+          ? Object.keys(props)
+          : Object.keys(input);
+      propKeys += nameSource.length;
+      for (const k of nameSource) {
         for (let i = 0; i < k.length; i++) {
           keyHash = (keyHash + k.charCodeAt(i)) & 0xffffff;
         }
@@ -138,14 +152,69 @@ function toolResultChars(p) {
   return estJson(r.value); // json | error | unexpected shapes
 }
 
+// Concatenated text of a ToolResultPart payload, for content FINGERPRINTING
+// (bounded — the first ~4KB is enough to spot byte-identical outputs). Mirrors
+// the shapes handled by toolResultChars; file items are URI references, skipped.
+function toolResultText(p) {
+  const r = p?.result;
+  if (!r || typeof r !== "object") return "";
+  if (r.type === "content" && Array.isArray(r.value)) {
+    let out = "";
+    for (const item of r.value) {
+      if (item?.type === "text" && typeof item.text === "string") {
+        out += item.text;
+        if (out.length > 4096) break;
+      }
+    }
+    return out;
+  }
+  if (r.type === "text" && typeof r.value === "string") return r.value;
+  try {
+    return JSON.stringify(r.value);
+  } catch {
+    return "";
+  }
+}
+
+// Bound on tool-call instances tracked per request for waste detection (the
+// message history is untrusted and a runaway session could be huge).
+const MAX_WASTE_INSTANCES = 256;
+
+// Accumulate the per-tool tool-result estimate. Tool names are untrusted
+// (host tool ids, plugin-defined tools): unsafe names and any name beyond the
+// cap fold into "other tools" so the bucket never becomes a prototype vector
+// and the map stays bounded. The sum of the map mirrors the toolOut category.
+// The cap is the SHARED TOOL_OUT_MAX_KEYS (lib/estimate.js) so the accumulation
+// bound and the persisted/displayed bound can never drift apart.
+function addToolOut(map, name, chars) {
+  if (!(chars > 0)) return;
+  const safe =
+    isSafeSessionKey(name) && name.length <= 64 ? name : "other tools";
+  if (
+    safe !== "other tools" &&
+    !Object.prototype.hasOwnProperty.call(map, safe) &&
+    Object.keys(map).length >= TOOL_OUT_MAX_KEYS
+  ) {
+    map["other tools"] = (map["other tools"] || 0) + chars;
+    return;
+  }
+  map[safe] = (map[safe] || 0) + chars;
+}
+
 function estimateBreakdownFromContext(context, sessionID) {
   let userChars = 0;
   let assistantChars = 0;
   let reasoningChars = 0;
   let toolArgsChars = 0;
   let toolOutChars = 0;
+  const toolOutByTool = {};
 
   const messages = Array.isArray(context?.messages) ? context.messages : [];
+  // Waste detection: correlate tool-call (input -> target) with its tool-result
+  // (-> tokens + content fingerprint) by call id, over the calls still present
+  // in the assembled context.
+  const callById = new Map();
+  const instances = [];
   for (const msg of messages) {
     const parts = Array.isArray(msg?.content) ? msg.content : [];
     for (const p of parts) {
@@ -153,7 +222,19 @@ function estimateBreakdownFromContext(context, sessionID) {
       // carrying them varies by host version (user, assistant, or the dedicated
       // "tool" role) — count them role-independently.
       if (p?.type === "tool-result") {
-        toolOutChars += toolResultChars(p);
+        const chars = toolResultChars(p);
+        toolOutChars += chars;
+        addToolOut(toolOutByTool, p?.name, chars);
+        if (chars > 0 && instances.length < MAX_WASTE_INSTANCES) {
+          const call = p?.id != null ? callById.get(p.id) : null;
+          const name = p?.name || call?.name || null;
+          instances.push({
+            name,
+            target: extractToolTarget(name, call?.input),
+            tokens: chars,
+            fp: contentFingerprint(toolResultText(p)),
+          });
+        }
         continue;
       }
       if (msg?.role === "user") {
@@ -165,10 +246,15 @@ function estimateBreakdownFromContext(context, sessionID) {
           reasoningChars += estimateTokens(p.text);
         } else if (p?.type === "tool-call") {
           toolArgsChars += estJson(p.input);
+          if (p?.id != null && callById.size < MAX_WASTE_INSTANCES && !callById.has(p.id)) {
+            callById.set(p.id, { name: p.name, input: p.input });
+          }
         }
       }
     }
   }
+  const reclaimRaw = instances.length > 0 ? computeReclaim(instances) : null;
+  const reclaim = reclaimRaw && reclaimRaw.tokens > 0 ? reclaimRaw : null;
 
   let systemChars = 0;
   const system = Array.isArray(context?.system) ? context.system : [];
@@ -206,8 +292,10 @@ function estimateBreakdownFromContext(context, sessionID) {
     reasoningChars,
     toolArgsChars,
     toolOutChars,
+    toolOutByTool,
     systemChars,
     toolSchemasChars,
+    reclaim,
   };
 }
 
@@ -259,6 +347,8 @@ function estimateBreakdownFromClientMessages(messages) {
   let reasoningChars = 0;
   let toolArgsChars = 0;
   let toolOutChars = 0;
+  const toolOutByTool = {};
+  const instances = [];
   for (const m of messages || []) {
     if (!m || typeof m !== "object") continue;
     if (m.type === "user") {
@@ -282,24 +372,43 @@ function estimateBreakdownFromClientMessages(messages) {
           // policy as the hook path).
           const content = p?.state?.content;
           if (Array.isArray(content)) {
+            let outChars = 0;
+            let text = "";
             for (const item of content) {
               if (item?.type === "text" && typeof item.text === "string") {
-                toolOutChars += estimateTokens(item.text);
+                outChars += estimateTokens(item.text);
+                if (text.length <= 4096) text += item.text;
               }
             }
+            toolOutChars += outChars;
+            // The persisted tool part carries its name on `p.name`
+            // (SessionMessageAssistantTool.name) — same field as the hook path.
+            addToolOut(toolOutByTool, p?.name, outChars);
+            if (outChars > 0 && instances.length < MAX_WASTE_INSTANCES) {
+              instances.push({
+                name: p?.name || null,
+                target: extractToolTarget(p?.name, input),
+                tokens: outChars,
+                fp: contentFingerprint(text),
+              });
+            }
           }
         }
       }
     }
   }
+  const reclaimRaw = instances.length > 0 ? computeReclaim(instances) : null;
+  const reclaim = reclaimRaw && reclaimRaw.tokens > 0 ? reclaimRaw : null;
   return {
     userChars,
     assistantChars,
     reasoningChars,
     toolArgsChars,
     toolOutChars,
+    toolOutByTool,
     systemChars: null,
     toolSchemasChars: null,
+    reclaim,
   };
 }
 
@@ -423,14 +532,9 @@ function buildLiveLinesV2(sessionID, modelID, providerID, inputTokens, ctxTokens
   const source = bd?.source || "none";
   const rt = typeof reasoningTokens === "number" ? reasoningTokens : 0;
 
-  const sumEstimates = (bd?.userChars || 0) +
-    (bd?.assistantChars || 0) +
-    (bd?.reasoningChars || 0) +
-    (bd?.toolArgsChars || 0) +
-    (bd?.toolOutChars || 0) +
-    (bd?.systemChars || 0) +
-    (bd?.toolSchemasChars || 0);
-  const other = Math.max(0, inputTokens - sumEstimates);
+  // Residual = input minus every measured category (shared normaliser; `bd`
+  // may be absent -> everything 0 and the residual is the whole input).
+  const other = breakdownCategories(bd, inputTokens).other;
 
   if (bd) {
     lines.push(`  user        ${fmt(bd.userChars || 0)} (est tokens)`);
@@ -463,6 +567,25 @@ function buildLiveLinesV2(sessionID, modelID, providerID, inputTokens, ctxTokens
   lines.push(`  other       ${fmt(other)} (= input - sum of estimates)`);
   lines.push(`  source      ${source}`);
 
+  // Provider-reported prompt cache (EXACT, not an estimate; a subset of input —
+  // never folded into the category sum). Absent when the provider stays silent.
+  const cr = lastKnownCacheRead(sessionID);
+  const cw = lastKnownCacheWrite(sessionID);
+  lines.push(
+    cr == null && cw == null
+      ? `  prompt cache n/a (provider reported no cache tokens)`
+      : `  prompt cache read=${fmt(cr || 0)} write=${fmt(cw || 0)} (provider-reported; subset of input)`,
+  );
+
+  // Redundant tool output already in context (repeated target / identical
+  // output). An estimate of what trimming/compaction could reclaim.
+  const rcl = bd?.reclaim || null;
+  if (rcl && rcl.tokens > 0) {
+    lines.push(
+      `  reclaim     ~${fmt(rcl.tokens)} redundant tool output (${rcl.count} duplicate(s) — estimate)`,
+    );
+  }
+
   try {
     const sub = aggregateSubagentsV2(sessionID);
     if (sub.count > 0) {
@@ -569,6 +692,15 @@ async function handleV2Event(ctx, event) {
         lastKnownInput(sid),
         lastKnownCtx(sid),
         lastKnownReasoning(sid),
+        // This write re-persists the PRE-compaction snapshot (the compaction
+        // flow fires no context hook — see README): mark the entry stale so the
+        // UI shows the numbers as pre-compaction until the next model request
+        // refreshes them.
+        {
+          compacted: true,
+          cacheRead: lastKnownCacheRead(sid),
+          cacheWrite: lastKnownCacheWrite(sid),
+        },
       );
       pushFinalSummary(
         `compacted:${event.id ?? sid}`,
@@ -608,6 +740,10 @@ async function handleV2Event(ctx, event) {
         lastKnownInput(sid),
         lastKnownCtx(sid),
         lastKnownReasoning(sid),
+        {
+          cacheRead: lastKnownCacheRead(sid),
+          cacheWrite: lastKnownCacheWrite(sid),
+        },
       );
       pushFinalSummary(`final:${event.id ?? sid}`, [
         `[${new Date().toISOString()}] FINAL session=${sid}`,
@@ -630,10 +766,16 @@ async function handleV2Event(ctx, event) {
     const output = typeof t.output === "number" ? t.output : 0;
     const reasoning = typeof t.reasoning === "number" ? t.reasoning : 0;
     const contextTokens = tokenCountOf(t);
+    // Provider-reported prompt-cache figures (exact): a subset of `input`.
+    // Sanitised — a NaN/negative/absurd provider value must never be persisted.
+    const cacheRead = safeSaneOrNull(t.cache?.read ?? t.cacheRead);
+    const cacheWrite = safeSaneOrNull(t.cache?.write ?? t.cacheWrite);
 
     lastKnownInputCache.set(sid, input);
     lastKnownCtxCache.set(sid, contextTokens);
     lastKnownReasoningCache.set(sid, reasoning);
+    if (cacheRead != null) lastKnownCacheReadCache.set(sid, cacheRead);
+    if (cacheWrite != null) lastKnownCacheWriteCache.set(sid, cacheWrite);
     if (!lastKnownModelCache.has(sid) && data.model) {
       // Some builds put the model on the step payload; harmless when absent.
       if (typeof data.model.id === "string") lastKnownModelCache.set(sid, data.model.id);
@@ -644,6 +786,8 @@ async function handleV2Event(ctx, event) {
     pruneMap(lastKnownInputCache, MAX_TRACKED_SESSIONS);
     pruneMap(lastKnownCtxCache, MAX_TRACKED_SESSIONS);
     pruneMap(lastKnownReasoningCache, MAX_TRACKED_SESSIONS);
+    pruneMap(lastKnownCacheReadCache, MAX_TRACKED_SESSIONS);
+    pruneMap(lastKnownCacheWriteCache, MAX_TRACKED_SESSIONS);
     pruneMap(lastKnownModelCache, MAX_TRACKED_SESSIONS);
     pruneMap(lastKnownProviderCache, MAX_TRACKED_SESSIONS);
 
@@ -702,6 +846,10 @@ async function handleV2Event(ctx, event) {
           input,
           contextTokens,
           reasoning,
+          {
+            cacheRead: lastKnownCacheRead(sid),
+            cacheWrite: lastKnownCacheWrite(sid),
+          },
         );
         writeLog(lines);
       } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-context-indicator",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Real-time context-window usage for OpenCode: per-category token breakdown, a zero-LLM /cx panel with per-session cost and a searchable family-session picker, and a TUI sidebar. Dual V1 + V2 plugin entry.",
   "type": "module",
   "license": "MIT",
@@ -64,7 +64,7 @@
     "@opentui/solid": "0.5.17"
   },
   "devDependencies": {
-    "@opencode/plugin": "2.0.28",
+    "@opencode/plugin": "2.0.30",
     "@opentui/core": "0.5.17",
     "@types/node": "26.6.3",
     "esbuild": "^0.28.2",