opencode-context-indicator 1.4.0 → 1.4.1

package/CHANGELOG.md

@@ -4,6 +4,33 @@ Notable user-facing changes per release. Dates are commit days (UTC).
 The package also ships a dual V1/V2 plugin — see the README for the surface
 matrix; everything below concerns the V2 path unless stated otherwise.
 
+## 1.4.1 — 2026-10-14
+
+Highlights: the `toolOut` category is now split **by tool name**, and a
+`(stale — compacted)` marker tells you when the numbers predate a compaction.
+
+- **Tool results by tool**: `/context-breakdown` (a `### Tool results by tool
+  (main)` section) and the `./cx` panel (`tool results by tool` line) split the
+  `toolOut` column by tool name (`webfetch`, `read`, `bash`, …) — top-N with a
+  `+N more` tail. Aggregated on both the hook and the fallback path from each
+  tool part's `name`; names are sanitised and the map is bounded (overflow folds
+  into `other tools`). Persisted as `toolOutByTool` in `state.json`.
+- **Compaction staleness marker**: opencode's compaction fires no `context`
+  hook, so `/context` right after `/compact` used to show stale pre-compaction
+  numbers with no hint. Such an entry is now flagged (`compactStale`) and every
+  surface (sidebar, panel, `/context`, `/context-breakdown`) shows
+  `(stale — compacted)` until the next model request refreshes the breakdown.
+- Legacy `state.json` entries (no new fields) behave exactly as before.
+- Tests: T19/T19a (staleness mark lifecycle + surfaces), T20–T20c (per-tool
+  split on both paths, sanitisation/bounding, persistence + rendering).
+- **Refactor (behaviour-preserving)**: extracted the shared category helpers
+  (`sumCategories` / `breakdownCategories`) into `lib/estimate.js`, removing
+  four hand-rolled copies of the residual-`other` computation (V2 live log,
+  state writer, command report, TUI panel); the TUI now imports the ONE token
+  estimator and per-tool split from `lib/estimate.js` instead of keeping byte
+  copies; dropped unused module exports; unified the per-tool map cap. New
+  guard test T21.
+
 ## 1.4.0 — 2026-10-13
 
 Highlights: a new **toolOut** category names what used to drown in `other` —

package/README.md

@@ -49,9 +49,10 @@ For every served request the plugin estimates how the context window is split:
 * `other` is the residual (`input − sum of estimates`): what no category
   explains — images/media, unknown part types.
 * `toolOut` names the former blind spot: **tool results** fed back into the
-  context (webfetch pages, file reads, subagent reports). The TUI panel's
-  *largest contributors* section attributes them **per tool call**; the
-  category only totals them.
+  context (webfetch pages, file reads, subagent reports). `/context-breakdown`
+  and the TUI panel split it **by tool name** (`webfetch`, `read`, `bash`, …);
+  the TUI panel's *largest contributors* section attributes them **per tool
+  call**; the category only totals them.
 * `ctx` is OpenCode's native overflow count: `tokens.total` when present, else
   `input + output + cache.read + cache.write`. Percentages are **not clamped**
   at 100% — exceeding the window stays visible.
@@ -160,6 +161,9 @@ reads, subagent reports fed back into context), sys=system prompt, schm=tool
 schemas, oth=residual input. src: live=context hook, snap=state.json,
 fallback=session.context (no system/schemas → n/a), no-data=categories
 unavailable._
+
+### Tool results by tool (main)
+webfetch 242.1k · read 18.4k · bash 4.9k · +3 more
 ```
 
 It is delivered with `resume:true` **and** a verbatim instruction prefix, so the
@@ -524,6 +528,13 @@ duplicate final summaries are suppressed with an atomic claim marker
 (`lib/dedup.js`). Every file / estimate / subagent path is fault-tolerant: a
 failure is logged and never breaks the main event or toast path.
 
+**Compaction staleness.** OpenCode's compaction runs a separate flow that fires
+no `context` hook, so the numbers a `session.compacted` write re-persists are
+the *pre-compaction* ones. The plugin flags such an entry
+(`compactStale` in `state.json`) and every surface shows `(stale — compacted)`
+until the next model request refreshes the breakdown — i.e. the data is exactly
+as fresh as the last model request in the session.
+
 This plugin does not touch `opencode-token-monitor`
 (`token_stats` / `token_history` / `token_export` keep working unchanged).
 
@@ -542,7 +553,7 @@ caller.
 ### Running tests
 
 ```bash
-npm run test:prepublish       # fast gate: tarball + tui.tsx + resolve + T1–T16i unit checks
+npm run test:prepublish       # fast gate: tarball + tui.tsx + resolve + T1–T22 unit checks
 npm run test:e2e              # full E2E: isolated plugin load + one "Say OK" round-trip
 npm run test:e2e:quick        # E2E load-only, no LLM call
 npm run test:drift            # OpenTUI pin vs the latest RELEASED opencode (also in CI)
@@ -563,7 +574,7 @@ STEP 80 s, ~3 min total.
 | (a) tarball composition | `package.json` `files[]` expands to the base files plus every `lib/*` module (count asserted dynamically) | no test/node_modules/tsconfig in the tarball |
 | (b) pragma regression | esbuild `--jsx=automatic` → `@opentui/solid/jsx-runtime` present, `react/jsx-runtime` absent | a removed/broken pragma kills the sidebar on npm install |
 | (c) resolve chain | replica install: host-bridged + peer packages resolve; local tui.tsx relative imports resolve via node from the entry (resolve-bridge.cjs) | broken peer/optional dep or a bad local import silently breaks the sidebar |
-| (d) unit harness T1–T16i | limit/agent/state fix assertions plus measureContributors and redacted-export checks (34 total) | regressions in modelLimits, writeStateFile, hydrate, contributors, export |
+| (d) unit harness T1–T22 | limit/agent/state fix assertions plus measureContributors, redacted-export, shared category-helper and sanitizer/unicode checks (51 total) | regressions in modelLimits, writeStateFile, hydrate, contributors, export |
 | (e) corporate-identifier scan | no forbidden identifiers in the published surface + test tree | compliance |
 | (f) non-English scan | no non-ASCII letters (`\p{L}` above U+007F) in any repo file | English-only source rule |
 

package/index.js

@@ -151,12 +151,14 @@
 
 import { makeV1 } from "./lib/v1.js";
 import { handleV2Event, onV2Context, estimateBreakdownFromContext, estimateBreakdownFromClientMessages } from "./lib/v2.js";
+import { breakdownCategories, estimateTokens, isSafeSessionKey, safeCell, safeToolOutByTool, sumCategories, toolOutEntries } from "./lib/estimate.js";
 import {
   commandContextBreakdown,
   commandContextSummary,
   CONTEXT_BREAKDOWN_RESUME,
   collectSessionReport,
   renderSessionRow,
+  renderBreakdownTable,
   shortSummaryText,
   shortSummaryDescription,
 } from "./lib/commands.js";
@@ -194,6 +196,7 @@ export {
   reserveFor,
   collectSessionReport,
   renderSessionRow,
+  renderBreakdownTable,
   shortSummaryText,
   shortSummaryDescription,
   ensureModelLimits,
@@ -201,6 +204,13 @@ export {
   estimateBreakdownFromContext,
   estimateBreakdownFromClientMessages,
   onV2Context,
+  safeToolOutByTool,
+  toolOutEntries,
+  sumCategories,
+  breakdownCategories,
+  safeCell,
+  isSafeSessionKey,
+  estimateTokens,
 };
 
 // ---------------------------------------------------------------------------

package/lib/commands.js

@@ -6,12 +6,17 @@
 // from index.js.
 
 import {
+  breakdownCategories,
   fmt,
   fmtCell,
   isSafeSessionKey,
   oneLine,
   safeCategories,
   safeCell,
+  safeCount,
+  safeToolOutByTool,
+  sumCategories,
+  toolOutEntries,
   withTimeout,
 } from "./estimate.js";
 import {
@@ -73,16 +78,7 @@ const CONTEXT_BREAKDOWN_RESUME = true;
 // Note: `system` / `toolSchemas` may legitimately be null (hook-only), so they
 // are coerced with `|| 0`.
 function isEmptyStateEntry(entry) {
-  const c = entry?.categories || {};
-  const sum =
-    (c.user || 0) +
-    (c.assistant || 0) +
-    (c.reasoning || 0) +
-    (c.toolArgs || 0) +
-    (c.toolOut || 0) +
-    (c.system || 0) +
-    (c.toolSchemas || 0) +
-    (c.other || 0);
+  const sum = sumCategories(entry?.categories);
   return (
     sum === 0 &&
     (!entry?.ctx || entry.ctx === 0) &&
@@ -135,21 +131,8 @@ function collectDescendantSessionIDs(rootID, state) {
 }
 
 // Normalise a breakdown record (cache or state entry) into the 8 categories.
-// `inputTokens` is used only for the residual "other".
-function breakdownCategories(rec, inputTokens) {
-  const user = rec?.userChars ?? rec?.user ?? 0;
-  const assistant = rec?.assistantChars ?? rec?.assistant ?? 0;
-  const reasoning = rec?.reasoningChars ?? rec?.reasoning ?? 0;
-  const toolArgs = rec?.toolArgsChars ?? rec?.toolArgs ?? 0;
-  const toolOut = rec?.toolOutChars ?? rec?.toolOut ?? 0;
-  const system = rec?.systemChars !== undefined ? rec.systemChars : rec?.system ?? null;
-  const toolSchemas =
-    rec?.toolSchemasChars !== undefined ? rec.toolSchemasChars : rec?.toolSchemas ?? null;
-  const sum =
-    user + assistant + reasoning + toolArgs + toolOut + (system || 0) + (toolSchemas || 0);
-  const other = Math.max(0, (inputTokens || 0) - sum);
-  return { user, assistant, reasoning, toolArgs, toolOut, system, toolSchemas, other };
-}
+// Moved to lib/estimate.js (shared with the V2 live log); re-used here so the
+// residual computation has exactly one implementation.
 
 // Short source tag for the table (kept tiny on purpose).
 function sourceTag(source) {
@@ -238,6 +221,7 @@ async function collectSessionReport(ctx, sessionID, state, deadline) {
 
   let categories = null;
   let source = "none";
+  let fallbackParts = null;
   if (bd) {
     // Sanitise: every value reaches a markdown/log sink and must be a number.
     categories = safeCategories(
@@ -249,9 +233,8 @@ async function collectSessionReport(ctx, sessionID, state, deadline) {
     categories = safeCategories(entry.categories);
     source = "snapshot";
   } else if (Array.isArray(contextMsgs)) {
-    categories = safeCategories(
-      breakdownCategories(estimateBreakdownFromClientMessages(contextMsgs), 0),
-    );
+    fallbackParts = estimateBreakdownFromClientMessages(contextMsgs);
+    categories = safeCategories(breakdownCategories(fallbackParts, 0));
     source = "client-context";
   } else if (needFallback) {
     // No live cache, no state.json categories, and the bounded session.context
@@ -284,6 +267,11 @@ async function collectSessionReport(ctx, sessionID, state, deadline) {
   const updatedAt =
     entry?.updatedAt ||
     (bd?.capturedAt ? new Date(bd.capturedAt).toISOString() : null);
+  const toolOutByTool = bd
+    ? safeToolOutByTool(bd.toolOutByTool)
+    : safeToolOutByTool(entry?.toolOutByTool) ||
+      safeToolOutByTool(fallbackParts?.toolOutByTool);
+  const compactStale = entry?.compactStale === true;
   return {
     sessionID,
     parentID,
@@ -294,6 +282,8 @@ async function collectSessionReport(ctx, sessionID, state, deadline) {
     usable,
     reserve,
     categories,
+    toolOutByTool,
+    compactStale,
     source,
     updatedAt,
   };
@@ -311,11 +301,27 @@ function renderSessionRow(r, isMain) {
       ? ` (${((r.ctxTokens / r.usable) * 100).toFixed(0)}%)`
       : "";
   const ctx = `${fmt(r.ctxTokens)}${pct}`;
-  const upd = `${timeOnly(r.updatedAt)} ${sourceTag(r.source)}`;
+  const upd = `${timeOnly(r.updatedAt)} ${sourceTag(r.source)}${r.compactStale ? " (stale)" : ""}`;
   return `| ${role} | ${safeCell(r.modelID)} | ${ctx} | ${fmtCell(c.user)} | ${fmtCell(c.assistant)} | ${fmtCell(c.reasoning)} | ${fmtCell(c.toolArgs)} | ${fmtCell(c.toolOut)} | ${fmtCell(c.system)} | ${fmtCell(c.toolSchemas)} | ${fmtCell(c.other)} | ${upd} |`;
 }
 
-function renderBreakdownTable(rows, childCount) {
+// A compact one-line "tool results by tool" split for the main session, built
+// from the server-side aggregate (sanitised names, top-N). Empty when the map
+// carries nothing.
+function renderToolOutLine(toolOutByTool, limit) {
+  const entries = toolOutEntries(toolOutByTool, limit || 8);
+  if (entries.length === 0) return "";
+  const parts = entries.map(
+    ([name, val]) => `${safeCell(name)} ${fmt(val)}`,
+  );
+  const total = Object.values(toolOutByTool || {}).filter(
+    (v) => safeCount(v) > 0,
+  ).length;
+  if (total > entries.length) parts.push(`+${total - entries.length} more`);
+  return parts.join(" · ");
+}
+
+function renderBreakdownTable(rows, childCount, mainReport) {
   const lines = [];
   lines.push("### Context breakdown");
   lines.push("");
@@ -332,6 +338,14 @@ function renderBreakdownTable(rows, childCount) {
       `schm=tool schemas, oth=residual input. src: live=context hook, snap=state.json, ` +
       `fallback=session.context (no system/schemas → n/a), no-data=categories unavailable._`,
   );
+  // Per-tool split of the main session's tool results (which tool ate the
+  // "out" column). Server-side aggregate; names sanitised, top-N only.
+  const byTool = renderToolOutLine(mainReport?.toolOutByTool, 8);
+  if (byTool) {
+    lines.push("");
+    lines.push("### Tool results by tool (main)");
+    lines.push(byTool);
+  }
   return lines.join("\n");
 }
 
@@ -403,6 +417,11 @@ function shortSummaryText(r) {
     lines.push(compact);
   }
   lines.push(`updated ${timeOnly(r.updatedAt)} (${sourceTag(r.source)})`);
+  if (r.compactStale) {
+    lines.push(
+      "stale — compacted: these are pre-compaction numbers; they refresh after the next message",
+    );
+  }
   return lines.join("\n");
 }
 
@@ -484,7 +503,7 @@ async function commandContextBreakdown(ctx, invocation, opts) {
     ]);
     const rows = [renderSessionRow(root, true)];
     for (const rep of children) rows.push(renderSessionRow(rep, false));
-    const table = renderBreakdownTable(rows, childIDs.length);
+    const table = renderBreakdownTable(rows, childIDs.length, root);
     const payload = resume
       ? `${BREAKDOWN_MODEL_INSTRUCTION}\n\n<context-breakdown>\n${table}\n</context-breakdown>`
       : table;
@@ -510,6 +529,7 @@ export {
   CONTEXT_BREAKDOWN_RESUME,
   collectSessionReport,
   renderSessionRow,
+  renderBreakdownTable,
   shortSummaryText,
   shortSummaryDescription,
 };

package/lib/contributors.js

@@ -3,48 +3,19 @@
 // Pure contributor-measurement helpers extracted from tui.tsx for unit testing.
 // All functions are stateless transforms of their arguments.
 //
-// Extracted 1:1 (behaviour + WHY comments, stripped of TS syntax):
-//   estimateTokensLocal, asRecord, safeText, measureContributors,
-//   contributorLine, exportFileName, buildRedactedPayload, panelDenom, panelRole.
+// Functions: asRecord, safeText, measureContributors, contributorLine,
+// exportFileName, buildRedactedPayload, panelDenom, panelRole. Token estimation
+// is imported from lib/estimate.js (single source of truth).
+
+import { estimateTokens } from "./estimate.js";
 
 // ---------------------------------------------------------------------------
-// Token estimation (mirrors lib/estimate.js but self-contained — tui.tsx
-// loads standalone and must NOT import lib/*).
+// Token estimation — the SHARED lib/estimate.js heuristic (the TUI panel and
+// the server must price the same text identically; the earlier self-contained
+// copy had drifted risk). estimate.js is pure and dependency-free, so it loads
+// in the TUI host exactly like the rest of lib/.
 // ---------------------------------------------------------------------------
 
-// Unicode heuristic — estimate, not a tokenizer. Cyrillic ~2.5, CJK ~1.5,
-// latin/ASCII ~4 chars/token.
-function estimateTokensLocal(s) {
-  let other = 0;
-  let cyr = 0;
-  let cjk = 0;
-  for (let i = 0; i < s.length; i++) {
-    const cp = s.codePointAt(i);
-    if (cp > 0xffff) i++; // astral pair — consume the low surrogate
-    if (cp < 0x80) other++;
-    else if (
-      (cp >= 0x0400 && cp <= 0x04ff) || // Cyrillic
-      (cp >= 0x0500 && cp <= 0x052f) || // Cyrillic Supplement
-      (cp >= 0x2de0 && cp <= 0x2dff) || // Cyrillic Extended-A
-      (cp >= 0xa640 && cp <= 0xa69f) || // Cyrillic Extended-B
-      (cp >= 0x1c80 && cp <= 0x1c8f) // Cyrillic Extended-C
-    )
-      cyr++;
-    else if (
-      (cp >= 0x4e00 && cp <= 0x9fff) || // CJK Unified Ideographs
-      (cp >= 0x3400 && cp <= 0x4dbf) || // CJK Extension A
-      (cp >= 0xf900 && cp <= 0xfaff) || // CJK Compatibility Ideographs
-      (cp >= 0x3040 && cp <= 0x30ff) || // Hiragana + Katakana
-      (cp >= 0xac00 && cp <= 0xd7af) || // Hangul Syllables
-      (cp >= 0x3000 && cp <= 0x303f) || // CJK Symbols and Punctuation
-      (cp >= 0xff00 && cp <= 0xffef) // Halfwidth/Fullwidth Forms
-    )
-      cjk++;
-    else other++;
-  }
-  return Math.round(other / 4 + cyr / 2.5 + cjk / 1.5);
-}
-
 // Live message data is untrusted: coerce every field defensively, never throw.
 function asRecord(v) {
   return v && typeof v === "object" ? v : null;
@@ -96,7 +67,7 @@ function measureContributors(messages) {
       kind,
       ref,
       chars: sample.length,
-      tokensEstimate: estimateTokensLocal(sample),
+      tokensEstimate: estimateTokens(sample),
       tool: tool || "",
       preview: previewOverride !== undefined ? previewOverride : previewOf(sample),
     });
@@ -276,8 +247,6 @@ function panelRole(e, isMain) {
 }
 
 export {
-  estimateTokensLocal,
-  asRecord,
   safeText,
   measureContributors,
   contributorLine,

package/lib/dedup.js

@@ -17,9 +17,9 @@
 //
 // EXPORTS
 //   claimOnce(key, dedupDir)  atomic cross-instance / cross-process claim
-//   pruneDedup(dedupDir)      delete claim markers older than DEDUP_TTL_MS
 //   pruneMap(map, maxSize)    FIFO-trim an in-process Map (insertion order)
-//   DEDUP_TTL_MS              marker lifetime (24h)
+//   (pruneDedup / DEDUP_TTL_MS are module-internal: pruning is driven from
+//    claimOnce, never from outside this file)
 //
 // The claim mechanism is the exact one proven in token-usage-logger.js:
 // OpenCode loads one plugin instance per loaded location and mirrors the public
@@ -40,7 +40,7 @@ import {
 import { createHash } from "node:crypto";
 import { join } from "node:path";
 
-export const DEDUP_TTL_MS = 24 * 60 * 60 * 1000; // prune claim markers after a day
+const DEDUP_TTL_MS = 24 * 60 * 60 * 1000; // prune claim markers after a day
 // Time-throttled pruning. A claim directory can hold tens of thousands of
 // markers (mostly legacy per-delta markers), and pruneDedup() does a
 // synchronous readdirSync+statSync over the whole directory — running that in
@@ -103,7 +103,7 @@ export function claimOnce(key, dedupDir) {
 }
 
 // Delete claim markers older than DEDUP_TTL_MS. Never throws.
-export function pruneDedup(dedupDir) {
+function pruneDedup(dedupDir) {
   try {
     const now = Date.now();
     for (const f of readdirSync(dedupDir)) {

package/lib/estimate.js

@@ -99,6 +99,53 @@ function safeCategories(raw) {
   };
 }
 
+// A session key safe to use as an object property / map key. Rejects the
+// prototype-pollution vectors ("__proto__", "constructor", "prototype").
+// Sum of the 8 canonical category fields (null `system`/`toolSchemas` count as
+// 0). The single place the "total measured tokens" is derived — shared by the
+// residual-`other` computation, the continuity test and the log/summary writers.
+function sumCategories(c) {
+  if (!c || typeof c !== "object") return 0;
+  return (
+    safeCount(c.user) +
+    safeCount(c.assistant) +
+    safeCount(c.reasoning) +
+    safeCount(c.toolArgs) +
+    safeCount(c.toolOut) +
+    safeCount(c.system) +
+    safeCount(c.toolSchemas) +
+    safeCount(c.other)
+  );
+}
+
+// Normalise a breakdown record (cache record with *Chars keys, or a persisted
+// state entry with canonical keys) into the 8 categories, deriving the residual
+// `other` from `inputTokens`. Pure; the one converter shared by the V2 live log
+// (lib/v2.js) and the slash-command report (lib/commands.js).
+function breakdownCategories(rec, inputTokens) {
+  const user = rec?.userChars ?? rec?.user ?? 0;
+  const assistant = rec?.assistantChars ?? rec?.assistant ?? 0;
+  const reasoning = rec?.reasoningChars ?? rec?.reasoning ?? 0;
+  const toolArgs = rec?.toolArgsChars ?? rec?.toolArgs ?? 0;
+  const toolOut = rec?.toolOutChars ?? rec?.toolOut ?? 0;
+  const system =
+    rec?.systemChars !== undefined ? rec.systemChars : (rec?.system ?? null);
+  const toolSchemas =
+    rec?.toolSchemasChars !== undefined
+      ? rec.toolSchemasChars
+      : (rec?.toolSchemas ?? null);
+  const sum =
+    user +
+    assistant +
+    reasoning +
+    toolArgs +
+    toolOut +
+    (system || 0) +
+    (toolSchemas || 0);
+  const other = Math.max(0, (inputTokens || 0) - sum);
+  return { user, assistant, reasoning, toolArgs, toolOut, system, toolSchemas, other };
+}
+
 // A session key safe to use as an object property / map key. Rejects the
 // prototype-pollution vectors ("__proto__", "constructor", "prototype").
 function isSafeSessionKey(k) {
@@ -111,6 +158,46 @@ function isSafeSessionKey(k) {
   );
 }
 
+// Bound on the number of distinct tool names kept in a per-tool tool-result
+// map (state.json / context payload are untrusted and a plugin could define an
+// unbounded tool set). Everything past the cap — plus any unsafe name — is
+// folded into a single "other tools" bucket so the total still reconciles with
+// the toolOut category.
+const TOOL_OUT_MAX_KEYS = 24;
+// Normalise a per-tool tool-result map (tool name -> estimated tokens) from
+// untrusted input. Names become object keys AND display cells, so prototype
+// vectors are dropped and the map is bounded (see TOOL_OUT_MAX_KEYS). The
+// overflow bucket is named "other tools" — a real tool with that exact name
+// would merge into it (accepted: it is a display-only label).
+function safeToolOutByTool(raw, maxKeys = TOOL_OUT_MAX_KEYS) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const out = {};
+  let rest = 0;
+  let used = 0;
+  for (const [k, v] of Object.entries(raw)) {
+    const val = safeCount(v);
+    if (!isSafeSessionKey(k) || used >= maxKeys) {
+      rest += val;
+      continue;
+    }
+    out[k] = (out[k] || 0) + val;
+    used++;
+  }
+  if (rest > 0) out["other tools"] = (out["other tools"] || 0) + rest;
+  return Object.keys(out).length > 0 ? out : null;
+}
+
+// Descending [name, tokens] pairs for display, capped at `limit`; empty when
+// the map carries no positive rows.
+function toolOutEntries(map, limit = 8) {
+  if (!map || typeof map !== "object" || Array.isArray(map)) return [];
+  return Object.entries(map)
+    .map(([k, v]) => [k, safeCount(v)])
+    .filter(([, v]) => v > 0)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, Math.max(0, limit));
+}
+
 function fmt(n) {
   return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
 }
@@ -215,17 +302,18 @@ function fmtCell(n) {
 }
 
 export {
-  CHARS_PER_TOKEN_OTHER,
-  CHARS_PER_TOKEN_CYRILLIC,
-  CHARS_PER_TOKEN_CJK,
-  MAX_SANE_LIMIT,
   oneLine,
   safeCell,
   finitePos,
   safeCount,
   safeCountOrNull,
   safeCategories,
+  sumCategories,
+  breakdownCategories,
   isSafeSessionKey,
+  safeToolOutByTool,
+  toolOutEntries,
+  TOOL_OUT_MAX_KEYS,
   fmt,
   estimateTokens,
   estJson,

package/lib/limits.js

@@ -453,7 +453,6 @@ export {
   getModelLimit,
   getUsableContext,
   reserveFor,
-  setModelLimit,
   ensureProviderLimits,
   ensureModelLimits,
   hydrateModelLimitsFromState,

package/lib/state.js

@@ -27,6 +27,8 @@ import {
   oneLine,
   safeCount,
   safeCountOrNull,
+  safeToolOutByTool,
+  sumCategories,
 } from "./estimate.js";
 import {
   breakdownCache,
@@ -168,16 +170,6 @@ function writeLog(liveLines) {
   }
 }
 
-// Append a single line to the file (used for final summaries / notes).
-function appendLogLine(line) {
-  try {
-    ensureRegularFile(LOG_FILE); // refuse to follow a symlink planted at the path
-    appendFileSync(LOG_FILE, line + "\n", "utf8");
-  } catch (err) {
-    logErr("appendLogLine failed", err);
-  }
-}
-
 // Synchronous sleep for the lock retry loop. Atomics.wait is the documented
 // non-busy way to block this thread; fall back to a bounded spin if unavailable.
 function sleepSync(ms) {
@@ -316,6 +308,7 @@ function writeStateFile(
   inputTokens,
   ctxTokens,
   reasoningTokens,
+  opts,
 ) {
   try {
     if (!sessionID) return;
@@ -432,15 +425,57 @@ function writeStateFile(
         ? safeCount(bd.toolOutChars)
         : safeCount(pc?.toolOut);
 
-      const sumEstimates =
-        catUser +
-        catAssistant +
-        catReasoning +
-        catToolArgs +
-        catToolOut +
-        (catSystem || 0) +
-        (catToolSchemas || 0);
-      const other = Math.max(0, (inputTokens || 0) - sumEstimates);
+      // Per-tool split of the toolOut category (webfetch / read / bash / …).
+      // Untrusted names -> sanitised + bounded. A present breakdown OWNS the
+      // split (an empty one means "no tool results now" — do NOT revive a stale
+      // peer value); only fall back to the persisted map when this instance has
+      // no live breakdown at all.
+      const toolOutByTool = bd
+        ? safeToolOutByTool(bd.toolOutByTool)
+        : safeToolOutByTool(prevEntry?.toolOutByTool);
+
+      // Compaction staleness: a `session.compacted` write re-persists the
+      // pre-compaction numbers (the compaction flow fires no context hook), so
+      // the entry is stale BY CONSTRUCTION — even when this instance has no live
+      // breakdown to compare against (a mirror instance must not drop the
+      // signal). Later writes inherit `compactedAt` and clear the mark only once
+      // a FRESH breakdown (bd.capturedAt newer than the compaction) lands.
+      const compactedAt = opts?.compacted
+        ? new Date().toISOString()
+        : typeof prevEntry?.compactedAt === "string"
+          ? prevEntry.compactedAt
+          : null;
+      let compactStale = false;
+      if (opts?.compacted === true) {
+        compactStale = true;
+      } else if (compactedAt) {
+        const cMs = Date.parse(compactedAt);
+        const measuredMs =
+          bd && typeof bd.capturedAt === "number" ? bd.capturedAt : NaN;
+        if (Number.isFinite(cMs) && Number.isFinite(measuredMs)) {
+          compactStale = measuredMs <= cMs;
+        } else {
+          // No live breakdown here: keep the previous verdict (a peer instance
+          // may have measured it).
+          compactStale = prevEntry?.compactStale === true;
+        }
+      }
+
+      // Residual = input minus every measured category (shared sum; null
+      // system/toolSchemas count as 0).
+      const other = Math.max(
+        0,
+        safeCount(inputTokens) -
+          sumCategories({
+            user: catUser,
+            assistant: catAssistant,
+            reasoning: catReasoning,
+            toolArgs: catToolArgs,
+            toolOut: catToolOut,
+            system: catSystem,
+            toolSchemas: catToolSchemas,
+          }),
+      );
       // Parent link for the /context-breakdown command. Prefer the live cache;
       // fall back to the previously persisted value (backward compatible with
       // snapshots written before parentID existed -> null). role mirrors it.
@@ -490,6 +525,9 @@ function writeStateFile(
           toolSchemas: catToolSchemas,
           other,
         },
+        toolOutByTool,
+        compactedAt,
+        compactStale,
         updatedAt: new Date().toISOString(),
       };
       all[sessionID] = entry;
@@ -618,19 +656,9 @@ function pushFinalSummary(claimKey, summaryLines) {
 
 export {
   logErr,
-  renderFile,
   writeLog,
-  appendLogLine,
-  sleepSync,
-  ensureRegularFile,
-  isStaleLock,
-  acquireStateLock,
-  releaseStateLock,
-  renameWithRetry,
   writeStateFile,
-  appendEventLog,
   debugEvent,
   readStateSnapshot,
-  finalSummaries,
   pushFinalSummary,
 };

package/lib/tui-data.d.ts

@@ -29,6 +29,12 @@ export interface StateEntry {
   limit?: number | null
   reasoning?: number
   categories?: Categories
+  /** Per-tool tool-result split: tool name -> estimated tokens. */
+  toolOutByTool?: Record<string, number>
+  /** ISO time of the last session.compacted (marker only). */
+  compactedAt?: string | null
+  /** True while the entry still shows pre-compaction numbers. */
+  compactStale?: boolean
   updatedAt?: string
 }
 
@@ -44,3 +50,7 @@ export declare function fmt(n: number): string
 export declare function num(v: unknown): number
 export declare function fit(s: string, w: number): string
 export declare function updatedAt(iso: string | undefined): string
+export declare function toolOutEntries(
+  map: Record<string, number> | undefined,
+  limit?: number,
+): Array<[string, number]>

package/lib/tui-data.js

@@ -12,7 +12,8 @@
 //
 // state.json shape (written by writeStateFile() in index.js, untrusted input):
 //   { [sessionID]: { sessionID, parentID, role, agent, model, providerID,
-//     ctx, input, usable, reserve, limit, reasoning, categories{...}, updatedAt } }
+//     ctx, input, usable, reserve, limit, reasoning, categories{...},
+//     toolOutByTool{name->tokens}, compactedAt, compactStale, updatedAt } }
 // The authoritative TS mirror of the entry shape is the `StateEntry` interface
 // in lib/tui-data.d.ts — keep the two structurally compatible.
 
@@ -20,6 +21,11 @@ import { readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isSafeSessionKey, sumCategories } from "./estimate.js";
+
+// Re-exported so the panel keeps importing it from this module; the
+// implementation is the shared one (lib/estimate.js) — no second copy to drift.
+export { toolOutEntries } from "./estimate.js";
 
 export const STATE_FILE =
   process.env.OPENCODE_CONTEXT_INDICATOR_STATE_FILE ||
@@ -42,19 +48,6 @@ export function isNodeModulesInstall() {
   }
 }
 
-// Reserved object keys must never be treated as session ids: state.json is
-// untrusted input (structural mirror of isSafeSessionKey() in lib/estimate.js,
-// including the string/length requirement).
-function isSafeKey(k) {
-  return (
-    typeof k === "string" &&
-    k.length > 0 &&
-    k !== "__proto__" &&
-    k !== "constructor" &&
-    k !== "prototype"
-  )
-}
-
 // Whole state.json snapshot ({ sessionID: entry }) or {} on any error. The
 // sidebar resolves one entry from it and the breakdown panel walks the
 // parentID family over it. Never throws — a missing / empty / corrupt
@@ -68,7 +61,7 @@ export function readSnapshot() {
     // (__proto__ / constructor / prototype) and non-object entries in one pass.
     const clean = {}
     for (const [k, v] of Object.entries(all)) {
-      if (isSafeKey(k) && v && typeof v === "object") clean[k] = v
+      if (isSafeSessionKey(k) && v && typeof v === "object") clean[k] = v
     }
     return clean
   } catch {
@@ -82,17 +75,11 @@ export function readSnapshot() {
 // a missing categories object is not the only trigger. `system` / `toolSchemas`
 // may legitimately be null, hence the num() coercion.
 function isEmptyEntry(e) {
-  const c = e?.categories
-  const sum =
-    num(c?.user) +
-    num(c?.assistant) +
-    num(c?.reasoning) +
-    num(c?.toolArgs) +
-    num(c?.toolOut) +
-    num(c?.system) +
-    num(c?.toolSchemas) +
-    num(c?.other)
-  return sum === 0 && num(e?.ctx) === 0 && num(e?.input) === 0
+  return (
+    sumCategories(e?.categories) === 0 &&
+    num(e?.ctx) === 0 &&
+    num(e?.input) === 0
+  )
 }
 
 // The panel row set: the root entry (panel.sessionID) plus every entry whose

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>
@@ -569,6 +588,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,14 @@
 // from index.js.
 
 import {
+  breakdownCategories,
   estJson,
   estimateTokens,
   fmt,
+  isSafeSessionKey,
   oneLine,
   tokenCountOf,
+  TOOL_OUT_MAX_KEYS,
   withTimeout,
 } from "./estimate.js";
 import {
@@ -75,10 +78,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 +102,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,12 +144,34 @@ function toolResultChars(p) {
   return estJson(r.value); // json | error | unexpected shapes
 }
 
+// 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 : [];
   for (const msg of messages) {
@@ -153,7 +181,9 @@ 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);
         continue;
       }
       if (msg?.role === "user") {
@@ -206,6 +236,7 @@ function estimateBreakdownFromContext(context, sessionID) {
     reasoningChars,
     toolArgsChars,
     toolOutChars,
+    toolOutByTool,
     systemChars,
     toolSchemasChars,
   };
@@ -259,6 +290,7 @@ function estimateBreakdownFromClientMessages(messages) {
   let reasoningChars = 0;
   let toolArgsChars = 0;
   let toolOutChars = 0;
+  const toolOutByTool = {};
   for (const m of messages || []) {
     if (!m || typeof m !== "object") continue;
     if (m.type === "user") {
@@ -282,11 +314,16 @@ function estimateBreakdownFromClientMessages(messages) {
           // policy as the hook path).
           const content = p?.state?.content;
           if (Array.isArray(content)) {
+            let outChars = 0;
             for (const item of content) {
               if (item?.type === "text" && typeof item.text === "string") {
-                toolOutChars += estimateTokens(item.text);
+                outChars += estimateTokens(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);
           }
         }
       }
@@ -298,6 +335,7 @@ function estimateBreakdownFromClientMessages(messages) {
     reasoningChars,
     toolArgsChars,
     toolOutChars,
+    toolOutByTool,
     systemChars: null,
     toolSchemasChars: null,
   };
@@ -423,14 +461,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)`);
@@ -569,6 +602,11 @@ 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 },
       );
       pushFinalSummary(
         `compacted:${event.id ?? sid}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-context-indicator",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "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",