opencode-context-indicator 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -4,6 +4,61 @@ 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.5.0 — 2026-10-16
+
+Highlights: two new context-health signals — the **provider-reported prompt
+cache** (exact) and a **waste detector** for redundant tool output already in
+the context.
+
+- **Prompt cache (provider-reported)**: `session.step.ended` carries
+  `tokens.cache.{read,write}` — the provider's EXACT prompt-cache figures. Shown
+  as `prompt cache read=X (Y% of input) · write=Z` in `/context-breakdown`
+  (a `### Prompt cache` section), `/context`, the `./cx` panel and the live log.
+  It is a **subset of `input`**, so it is deliberately **not** added to the
+  category sum (no double-count). `n/a` when the provider reports nothing;
+  persisted as `cacheRead`/`cacheWrite` and inherited by mirror writes (a
+  non-measuring write cannot drop them).
+- **Waste detector**: finds tool output already in the context that is redundant
+  — the **same target** invoked repeatedly (the same file read twice, the same
+  URL fetched again) or **byte-identical output**. Reported as a `### Potential
+  reclaim (redundant tool output)` section in `/context-breakdown` (top findings
+  with tool + target) plus a `reclaim ~X redundant tool output (N dup)` panel/log
+  line. The number is the non-largest member of each duplicate group — an honest
+  *"N copies are in context; trimming/compaction could reclaim ~X"*, never "the
+  model wasted effort". Findings are **path-free** in the persisted/exported
+  form; the estimate is computed on both the hook and the fallback path.
+- Tests: T23/T23a/T23b (cache persistence, surfaces, sanitisation), T24–T24c
+  (reclaim algorithm, target extraction, hook capture via call-id correlation,
+  path-free persistence + rendering).
+- Legacy `state.json` entries (without the new fields) behave exactly as before.
+
+## 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

@@ -40,6 +40,8 @@ For every served request the plugin estimates how the context window is split:
   tool schemas 1.4k (est tokens)
   other       5.6k (= input - sum of estimates)
   source      context-hook
+  prompt cache read=12.0k (27% of input) write=1.1k (provider-reported)
+  reclaim     ~9.8k redundant tool output (3 duplicate(s) — estimate)
   subagents   2 session(s): in=8.1k out=2.3k r=1.0k worst=12%
 ```
 
@@ -49,12 +51,25 @@ 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.
+* `prompt cache` is **provider-reported and exact** (`tokens.cache.read` /
+  `tokens.cache.write`), shown as a share of `input`. It is a *subset* of input,
+  so it is deliberately **not** added to the category sum: a cache read means the
+  provider served those prompt tokens from its prompt cache, not that they are
+  absent from the window. `n/a` when the provider reports nothing.
+* `reclaim` is the **waste detector**: tool output already in the context that is
+  redundant — the **same target** invoked repeatedly (the same file read twice,
+  the same URL fetched again) or **byte-identical output**. It is an estimate of
+  what trimming/compaction could reclaim (the non-largest member of each
+  duplicate group), reported honestly as *"N redundant tool outputs ≈ X tokens"*
+  — never as "the model wasted effort". Findings are per-session and **path-free
+  in the persisted/exported form**.
 * The denominator is the **opencode v2.0.23 compaction ceiling**: `window =
   limit.input || limit.context`; `reserve = max(floor(window * 0.1), window >=
   32_000 ? 16_000 : 0)`; the ceiling is `window - reserve`. When opencode
@@ -160,6 +175,16 @@ 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
+
+### Prompt cache (main, provider-reported)
+read 12.0k (27% of input) · write 1.1k
+
+### Potential reclaim (redundant tool output)
+- read src/a.ts x2 — ~9.8k reclaimable
+_~9.8k across 3 redundant tool output(s) — estimate of what trimming/compaction could reclaim._
 ```
 
 It is delivered with `resume:true` **and** a verbatim instruction prefix, so the
@@ -524,6 +549,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 +574,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–T24 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 +595,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–T24 | limit/agent/state fix assertions plus measureContributors, redacted-export, shared category-helper, sanitizer/unicode, prompt-cache and waste-detector checks (58 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, computeReclaim, contentFingerprint, estimateTokens, extractToolTarget, isSafeSessionKey, safeCell, safeReclaim, safeSaneOrNull, safeToolOutByTool, sumCategories, toolOutEntries } from "./lib/estimate.js";
 import {
   commandContextBreakdown,
   commandContextSummary,
   CONTEXT_BREAKDOWN_RESUME,
   collectSessionReport,
   renderSessionRow,
+  renderBreakdownTable,
   shortSummaryText,
   shortSummaryDescription,
 } from "./lib/commands.js";
@@ -168,7 +170,7 @@ import {
   modelLimits,
   reserveFor,
 } from "./lib/limits.js";
-import { sessionAgentCache, sessionParentCache } from "./lib/cache.js";
+import { lastKnownCacheRead, lastKnownCacheWrite, sessionAgentCache, sessionParentCache } from "./lib/cache.js";
 import {
   logErr,
   readStateSnapshot,
@@ -194,6 +196,7 @@ export {
   reserveFor,
   collectSessionReport,
   renderSessionRow,
+  renderBreakdownTable,
   shortSummaryText,
   shortSummaryDescription,
   ensureModelLimits,
@@ -201,6 +204,20 @@ export {
   estimateBreakdownFromContext,
   estimateBreakdownFromClientMessages,
   onV2Context,
+  safeToolOutByTool,
+  toolOutEntries,
+  sumCategories,
+  breakdownCategories,
+  safeCell,
+  isSafeSessionKey,
+  estimateTokens,
+  extractToolTarget,
+  contentFingerprint,
+  computeReclaim,
+  safeReclaim,
+  safeSaneOrNull,
+  lastKnownCacheRead,
+  lastKnownCacheWrite,
 };
 
 // ---------------------------------------------------------------------------

package/lib/cache.js

@@ -53,6 +53,12 @@ const lastKnownReasoningCache = new Map();
 // sessionID -> last native opencode overflow count (tokens.total, else
 // input + output + cache.read + cache.write)
 const lastKnownCtxCache = new Map();
+// sessionID -> last provider-reported prompt-cache figures from
+// session.step.ended (`tokens.cache.read` / `tokens.cache.write`). These are
+// EXACT provider numbers (not estimates) and are a subset of `input`, so they
+// are shown as a separate metric and never folded into the category sum.
+const lastKnownCacheReadCache = new Map();
+const lastKnownCacheWriteCache = new Map();
 
 // sessionID -> last time we wrote a live breakdown snapshot
 const lastBdWrite = new Map();
@@ -92,6 +98,16 @@ function lastKnownReasoning(sessionID) {
 function lastKnownCtx(sessionID) {
   return lastKnownCtxCache.get(sessionID) || 0;
 }
+// Provider-reported prompt-cache figures; null when the provider never reported
+// them (a plain "n/a" rather than a misleading 0).
+function lastKnownCacheRead(sessionID) {
+  const v = lastKnownCacheReadCache.get(sessionID);
+  return typeof v === "number" ? v : null;
+}
+function lastKnownCacheWrite(sessionID) {
+  const v = lastKnownCacheWriteCache.get(sessionID);
+  return typeof v === "number" ? v : null;
+}
 
 // ---------------------------------------------------------------------------
 // Clear per-session tracking. Full wipe on session.idle / session.deleted;
@@ -118,6 +134,8 @@ function clearSessionTracking(sessionID, keepToastDedup = false) {
   lastKnownInputCache.delete(sessionID);
   lastKnownReasoningCache.delete(sessionID);
   lastKnownCtxCache.delete(sessionID);
+  lastKnownCacheReadCache.delete(sessionID);
+  lastKnownCacheWriteCache.delete(sessionID);
   lastBdWrite.delete(sessionID);
   // V2 subagent accumulation for this session.
   sessionTotals.delete(sessionID);
@@ -145,6 +163,8 @@ export {
   lastKnownInputCache,
   lastKnownReasoningCache,
   lastKnownCtxCache,
+  lastKnownCacheReadCache,
+  lastKnownCacheWriteCache,
   lastBdWrite,
   lastErrorToast,
   lastCompactedToast,
@@ -157,5 +177,7 @@ export {
   lastKnownInput,
   lastKnownReasoning,
   lastKnownCtx,
+  lastKnownCacheRead,
+  lastKnownCacheWrite,
   clearSessionTracking,
 };

package/lib/commands.js

@@ -6,16 +6,25 @@
 // from index.js.
 
 import {
+  breakdownCategories,
   fmt,
   fmtCell,
   isSafeSessionKey,
   oneLine,
   safeCategories,
   safeCell,
+  safeCount,
+  safeReclaim,
+  safeSaneOrNull,
+  safeToolOutByTool,
+  sumCategories,
+  toolOutEntries,
   withTimeout,
 } from "./estimate.js";
 import {
   breakdownCache,
+  lastKnownCacheRead,
+  lastKnownCacheWrite,
   lastKnownCtx,
   lastKnownInput,
   lastKnownModel,
@@ -73,16 +82,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 +135,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 +225,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 +237,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 +271,24 @@ 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;
+  // Provider-reported prompt cache (exact; subset of input). Live cache first,
+  // then the persisted snapshot.
+  const cacheRead =
+    safeSaneOrNull(lastKnownCacheRead(sessionID)) ??
+    safeSaneOrNull(entry?.cacheRead);
+  const cacheWrite =
+    safeSaneOrNull(lastKnownCacheWrite(sessionID)) ??
+    safeSaneOrNull(entry?.cacheWrite);
+  // Redundant tool output. The live breakdown owns targets; the persisted entry
+  // has them stripped (path-free) — sanitise both.
+  const reclaim = bd
+    ? safeReclaim(bd.reclaim, true)
+    : safeReclaim(entry?.reclaim, false);
   return {
     sessionID,
     parentID,
@@ -291,9 +296,15 @@ async function collectSessionReport(ctx, sessionID, state, deadline) {
     modelID,
     providerID,
     ctxTokens,
+    inputTokens: lastKnownInput(sessionID) || entry?.input || 0,
     usable,
     reserve,
     categories,
+    toolOutByTool,
+    reclaim,
+    cacheRead,
+    cacheWrite,
+    compactStale,
     source,
     updatedAt,
   };
@@ -311,11 +322,62 @@ 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(" · ");
+}
+
+// Provider-reported prompt cache for the main session — EXACT numbers, a
+// SUBSET of input (so the percentage is "of input", never a category). Empty
+// when the provider never reported cache tokens.
+function renderCacheLine(r) {
+  if (!r || (r.cacheRead == null && r.cacheWrite == null)) return "";
+  const read = r.cacheRead != null ? fmt(r.cacheRead) : "0";
+  const write = r.cacheWrite != null ? fmt(r.cacheWrite) : "0";
+  const pct =
+    r.cacheRead != null && r.inputTokens > 0
+      ? ` (${((r.cacheRead / r.inputTokens) * 100).toFixed(0)}% of input)`
+      : "";
+  return `read ${read}${pct} · write ${write}`;
+}
+
+// Redundant tool output already in context (repeated target / identical output).
+// Targets are shown only when present (the live breakdown has them; the
+// persisted/redacted path strips them).
+function renderReclaimSection(r) {
+  const rc = r?.reclaim;
+  if (!rc || rc.tokens <= 0) return "";
+  const lines = ["", "### Potential reclaim (redundant tool output)"];
+  for (const f of rc.findings || []) {
+    const label = f.target
+      ? `${safeCell(f.name)} ${safeCell(f.target)}`
+      : f.kind === "content"
+        ? `${safeCell(f.name)} (identical output)`
+        : safeCell(f.name);
+    lines.push(`- ${label} x${f.n} — ~${fmt(f.tokens)} reclaimable`);
+  }
+  lines.push(
+    `_~${fmt(rc.tokens)} across ${rc.count} redundant tool output(s) — estimate of what trimming/compaction could reclaim._`,
+  );
+  return lines.join("\n");
+}
+
+function renderBreakdownTable(rows, childCount, mainReport) {
   const lines = [];
   lines.push("### Context breakdown");
   lines.push("");
@@ -332,6 +394,24 @@ 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);
+  }
+  // Provider-reported prompt cache (exact; a subset of input).
+  const cache = renderCacheLine(mainReport);
+  if (cache) {
+    lines.push("");
+    lines.push("### Prompt cache (main, provider-reported)");
+    lines.push(cache);
+  }
+  // Redundant tool output (waste detector).
+  const reclaim = renderReclaimSection(mainReport);
+  if (reclaim) lines.push(reclaim);
   return lines.join("\n");
 }
 
@@ -402,7 +482,16 @@ function shortSummaryText(r) {
     }
     lines.push(compact);
   }
+  // Provider-reported prompt cache (exact; subset of input) — shown when the
+  // provider reported it.
+  const cache = renderCacheLine(r);
+  if (cache) lines.push(`prompt cache ${cache}`);
   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 +573,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 +599,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)) {