opencode-context-indicator 1.3.1 → 1.4.1

package/lib/estimate.js

@@ -81,8 +81,10 @@ function safeCountOrNull(v) {
   return typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : null;
 }
 
-// Normalise a categories object from untrusted input (state.json) into the 7
-// known numeric fields — never trust its shape.
+// Normalise a categories object from untrusted input (state.json) into the 8
+// known numeric fields — never trust its shape. `toolOut` is 0 for legacy
+// entries written before the category existed (their tool results stay folded
+// into `other`, matching how they were measured).
 function safeCategories(raw) {
   if (!raw || typeof raw !== "object") return null;
   return {
@@ -90,12 +92,60 @@ function safeCategories(raw) {
     assistant: safeCount(raw.assistant),
     reasoning: safeCount(raw.reasoning),
     toolArgs: safeCount(raw.toolArgs),
+    toolOut: safeCount(raw.toolOut),
     system: safeCountOrNull(raw.system),
     toolSchemas: safeCountOrNull(raw.toolSchemas),
     other: safeCount(raw.other),
   };
 }
 
+// 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) {
@@ -108,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);
 }
@@ -212,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;
@@ -426,15 +419,63 @@ function writeStateFile(
         bd && bd.toolSchemasChars != null
           ? safeCount(bd.toolSchemasChars)
           : safeCountOrNull(pc?.toolSchemas);
+      // Tool results are counted by both the hook and the fallback path, so
+      // this is a plain counted category (never null): a missing value is 0.
+      const catToolOut = bd
+        ? safeCount(bd.toolOutChars)
+        : safeCount(pc?.toolOut);
+
+      // 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;
+        }
+      }
 
-      const sumEstimates =
-        catUser +
-        catAssistant +
-        catReasoning +
-        catToolArgs +
-        (catSystem || 0) +
-        (catToolSchemas || 0);
-      const other = Math.max(0, (inputTokens || 0) - sumEstimates);
+      // 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.
@@ -479,10 +520,14 @@ function writeStateFile(
           assistant: catAssistant,
           reasoning: catReasoning,
           toolArgs: catToolArgs,
+          toolOut: catToolOut,
           system: catSystem,
           toolSchemas: catToolSchemas,
           other,
         },
+        toolOutByTool,
+        compactedAt,
+        compactStale,
         updatedAt: new Date().toISOString(),
       };
       all[sessionID] = entry;
@@ -611,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

@@ -9,6 +9,7 @@ export interface Categories {
   assistant?: number
   reasoning?: number
   toolArgs?: number
+  toolOut?: number
   system?: number | null
   toolSchemas?: number | null
   other?: number
@@ -28,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
 }
 
@@ -43,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,16 +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?.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>
@@ -565,10 +584,14 @@ export function BreakdownPanel(props: {
           </Show>
           <text fg={muted()}>
             {
-              "measured != server categories (tool outputs counted here; server categories exclude them)"
+              "measured != server categories: contributors attribute outputs per tool call; the server's toolOut category only totals them"
             }
           </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

@@ -54,6 +54,7 @@ export function Sidebar(props: { entry: () => StateEntry | null }) {
         <text fg={muted()}>{line("assistant", e()?.categories?.assistant)}</text>
         <text fg={muted()}>{line("reasoning", e()?.categories?.reasoning)}</text>
         <text fg={muted()}>{line("tool args", e()?.categories?.toolArgs)}</text>
+        <text fg={muted()}>{line("tool out", e()?.categories?.toolOut)}</text>
         <text fg={muted()}>
           {e()?.categories?.system == null
             ? `${"system".padEnd(LABEL_WIDTH)}     n/a`
@@ -65,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>