opencode-context-indicator 1.5.2 → 1.5.4

package/lib/tui-panel.tsx

@@ -53,6 +53,74 @@ type PanelInput = {
 // (never once per poll) when it is unavailable and hide the whole section.
 let warnedMessagesUnavailable = false
 
+// Cheap change detector for the live message list. The host hands back a fresh
+// array on every poll, so identity cannot be used as a memo key, while walking
+// the whole list (per-character estimates + JSON.stringify of tool args) once
+// per 1000 ms tick is exactly the cost we want to avoid. Length + last message
+// id + created stamp + last message payload size covers appends, streaming and
+// tool completion; an in-place edit of an OLDER message lands one tick later,
+// when the tail changes. Known blind spot by design: the size is a SUM, so a
+// same-length substitution inside the last message is not detected.
+function listSignature(list: unknown[]): string {
+  const n = list.length
+  if (n === 0) return "0"
+  const last: unknown = list[n - 1]
+  if (last == null || typeof last !== "object") return `${n}:?`
+  const rec = last as Record<string, unknown>
+  const id = typeof rec.id === "string" ? rec.id : ""
+  const time = rec.time
+  const created =
+    time != null && typeof time === "object"
+      ? String((time as Record<string, unknown>).created ?? "")
+      : ""
+  let size = typeof rec.text === "string" ? rec.text.length : 0
+  const parts: unknown[] = Array.isArray(rec.content) ? rec.content : []
+  for (const raw of parts) {
+    if (raw == null || typeof raw !== "object") continue
+    const part = raw as Record<string, unknown>
+    if (typeof part.text === "string") {
+      size += part.text.length
+      continue
+    }
+    const state = part.state
+    if (state == null || typeof state !== "object") continue
+    const st = state as Record<string, unknown>
+    if (typeof st.input === "string") size += st.input.length
+    else if (st.input != null) {
+      try {
+        size += JSON.stringify(st.input).length
+      } catch {
+        /* unstringifiable input contributes no size */
+      }
+    }
+    // Tool RESULTS matter as much as args: measureContributors reads
+    // state.content, and a call that finishes between two ticks changes nothing
+    // else on the message. Without this the measured section would freeze for
+    // the whole remainder of the turn.
+    const content = st.content
+    if (typeof content === "string") {
+      size += content.length
+    } else if (Array.isArray(content)) {
+      for (const rawItem of content) {
+        if (rawItem == null || typeof rawItem !== "object") continue
+        const item = rawItem as Record<string, unknown>
+        if (typeof item.text === "string") {
+          size += item.text.length
+        } else {
+          // Non-text parts (e.g. file refs with long/base64 URIs) are not
+          // measured by measureContributors, so their marker is enough: never
+          // JSON.stringify a potentially megabyte-sized reference per tick.
+          size += 1
+        }
+      }
+    }
+    // Status transitions (pending -> completed/error) are cheap and always
+    // accompany a visible change.
+    if (typeof st.status === "string") size += st.status.length
+  }
+  return `${n}:${id}:${created}:${size}`
+}
+
 // Panel column layout (monospace), derived from the host-provided panel width
 // so cells never collide on narrow terminals. Gaps between columns keep a
 // truncated cell visually separated from its neighbour.
@@ -253,14 +321,38 @@ export function BreakdownPanel(props: {
     }
   })
 
+  // Memo for the measured contributors section: the signature/key pair keeps
+  // the expensive walk out of the per-tick path (see listSignature).
+  let contributorKey: string | null = null
+  let contributorValue: Contributor[] = []
+
   const contributors = createMemo<Contributor[]>(() => {
     const m = messages()
-    if (!m.available) return []
+    if (!m.available) {
+      contributorKey = null
+      contributorValue = []
+      return contributorValue
+    }
+    // Re-measure ONLY when the message list actually changed. The host rebuilds
+    // the array (and `props.snapshot()` ticks) every second, so keying on array
+    // identity would re-walk every message — per-character token estimates plus
+    // JSON.stringify of tool args — once per tick on the render thread.
+    let key: string
+    try {
+      key = listSignature(m.list)
+    } catch {
+      key = ""
+    }
+    if (key && key === contributorKey) return contributorValue
     try {
-      return measureContributors(m.list)
+      contributorValue = measureContributors(m.list)
+      contributorKey = key || contributorKey
     } catch {
-      return []
+      // Transient failure: leave the key unset so the next tick retries.
+      contributorValue = []
+      contributorKey = null
     }
+    return contributorValue
   })
 
   // Redacted export (key `e`). No message text, no full session id, no tool

package/lib/v2.js

@@ -24,6 +24,7 @@ import {
 import {
   BREAKDOWN_THROTTLE_MS,
   breakdownCache,
+  clearChildSubagentTracking,
   clearSessionTracking,
   ERROR_TOAST_DEDUP_MS,
   lastBdWrite,
@@ -207,6 +208,35 @@ function addToolOut(map, name, chars) {
   map[safe] = (map[safe] || 0) + chars;
 }
 
+// Bounded candidate list for the "top context consumers" section: the heaviest
+// single units still in the assembled request (one tool output, one message,
+// the system prompt, one tool-call's args). The list is capped: once full, a new
+// item replaces the lightest candidate only when it is heavier, so a runaway
+// session cannot grow the array without bound while the true top-N is kept.
+const MAX_TOP_CANDIDATES = 256;
+const TOP_N = 5;
+
+function pushTopCandidate(list, kind, tokens, name, target) {
+  const t = Math.round(tokens);
+  if (!(t > 0)) return;
+  const item = { kind, tokens: t };
+  if (typeof name === "string" && name.length > 0) item.name = name;
+  if (typeof target === "string" && target.length > 0) item.target = target;
+  if (list.length < MAX_TOP_CANDIDATES) {
+    list.push(item);
+    return;
+  }
+  let min = 0;
+  for (let i = 1; i < list.length; i++) {
+    if (list[i].tokens < list[min].tokens) min = i;
+  }
+  if (t > list[min].tokens) list[min] = item;
+}
+
+function selectTopConsumers(list) {
+  return list.slice().sort((a, b) => b.tokens - a.tokens).slice(0, TOP_N);
+}
+
 function estimateBreakdownFromContext(context, sessionID) {
   let userChars = 0;
   let assistantChars = 0;
@@ -214,6 +244,7 @@ function estimateBreakdownFromContext(context, sessionID) {
   let toolArgsChars = 0;
   let toolOutChars = 0;
   const toolOutByTool = {};
+  const topCandidates = [];
 
   const messages = Array.isArray(context?.messages) ? context.messages : [];
   // Waste detection: correlate tool-call (input -> target) with its tool-result
@@ -231,12 +262,14 @@ function estimateBreakdownFromContext(context, sessionID) {
         const chars = toolResultChars(p);
         toolOutChars += chars;
         addToolOut(toolOutByTool, p?.name, chars);
+        const call = p?.id != null ? callById.get(p.id) : null;
+        const name = p?.name || call?.name || null;
+        const target = extractToolTarget(name, call?.input);
+        pushTopCandidate(topCandidates, "tool", chars, name, target);
         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),
+            target,
             tokens: chars,
             fp: contentFingerprint(toolResultText(p)),
           });
@@ -244,14 +277,30 @@ function estimateBreakdownFromContext(context, sessionID) {
         continue;
       }
       if (msg?.role === "user") {
-        if (p?.type === "text") userChars += estimateTokens(p.text);
+        if (p?.type === "text") {
+          const t = estimateTokens(p.text);
+          userChars += t;
+          pushTopCandidate(topCandidates, "user", t);
+        }
       } else if (msg?.role === "assistant") {
         if (p?.type === "text") {
-          assistantChars += estimateTokens(p.text);
+          const t = estimateTokens(p.text);
+          assistantChars += t;
+          pushTopCandidate(topCandidates, "assistant", t);
         } else if (p?.type === "reasoning") {
-          reasoningChars += estimateTokens(p.text);
+          const t = estimateTokens(p.text);
+          reasoningChars += t;
+          pushTopCandidate(topCandidates, "reasoning", t);
         } else if (p?.type === "tool-call") {
-          toolArgsChars += estJson(p.input);
+          const t = estJson(p.input);
+          toolArgsChars += t;
+          pushTopCandidate(
+            topCandidates,
+            "args",
+            t,
+            p?.name,
+            extractToolTarget(p?.name, 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 });
           }
@@ -265,6 +314,7 @@ function estimateBreakdownFromContext(context, sessionID) {
   let systemChars = 0;
   const system = Array.isArray(context?.system) ? context.system : [];
   for (const s of system) systemChars += estimateTokens(s?.text);
+  pushTopCandidate(topCandidates, "system", systemChars);
 
   let toolSchemasChars = 0;
   const tools = context?.tools;
@@ -302,6 +352,7 @@ function estimateBreakdownFromContext(context, sessionID) {
     systemChars,
     toolSchemasChars,
     reclaim,
+    top: selectTopConsumers(topCandidates),
   };
 }
 
@@ -442,22 +493,39 @@ function estimateBreakdownFromClientMessages(messages) {
   let toolOutChars = 0;
   const toolOutByTool = {};
   const instances = [];
+  const topCandidates = [];
   for (const m of messages || []) {
     if (!m || typeof m !== "object") continue;
     if (m.type === "user") {
-      userChars += estimateTokens(m.text);
+      const t = estimateTokens(m.text);
+      userChars += t;
+      pushTopCandidate(topCandidates, "user", t);
     } else if (m.type === "assistant") {
       const parts = Array.isArray(m.content) ? m.content : [];
       for (const p of parts) {
         if (p?.type === "text") {
-          assistantChars += estimateTokens(p.text);
+          const t = estimateTokens(p.text);
+          assistantChars += t;
+          pushTopCandidate(topCandidates, "assistant", t);
         } else if (p?.type === "reasoning") {
-          reasoningChars += estimateTokens(p.text);
+          const t = estimateTokens(p.text);
+          reasoningChars += t;
+          pushTopCandidate(topCandidates, "reasoning", t);
         } else if (p?.type === "tool") {
           // state.input is a string while streaming; only count the resolved
           // object (running/completed/error) to avoid partial counts.
           const input = p?.state?.input;
-          if (input && typeof input === "object") toolArgsChars += estJson(input);
+          if (input && typeof input === "object") {
+            const t = estJson(input);
+            toolArgsChars += t;
+            pushTopCandidate(
+              topCandidates,
+              "args",
+              t,
+              p?.name,
+              extractToolTarget(p?.name, input),
+            );
+          }
           // Tool results: completed / errored states carry the payload in
           // state.content (ToolContent[]: {type:"text",text}|{type:"file"}) —
           // NOT state.output (that field does not exist on SessionMessageInfo).
@@ -477,10 +545,12 @@ function estimateBreakdownFromClientMessages(messages) {
             // The persisted tool part carries its name on `p.name`
             // (SessionMessageAssistantTool.name) — same field as the hook path.
             addToolOut(toolOutByTool, p?.name, outChars);
+            const target = extractToolTarget(p?.name, input);
+            pushTopCandidate(topCandidates, "tool", outChars, p?.name, target);
             if (outChars > 0 && instances.length < MAX_WASTE_INSTANCES) {
               instances.push({
                 name: p?.name || null,
-                target: extractToolTarget(p?.name, input),
+                target,
                 tokens: outChars,
                 fp: contentFingerprint(text),
               });
@@ -502,6 +572,7 @@ function estimateBreakdownFromClientMessages(messages) {
     systemChars: null,
     toolSchemasChars: null,
     reclaim,
+    top: selectTopConsumers(topCandidates),
   };
 }
 
@@ -763,6 +834,10 @@ async function handleV2Event(ctx, event) {
     // stale entry lingers, via the phantom filter — a deleted session has no
     // step). No dedicated in-memory index to clean up.
     clearSessionTracking(sid);
+    // Whatever this session was, its own descendants must go too: a deleted
+    // parent takes the whole subtree, and a deleted child takes its own
+    // sub-subagents (they would otherwise never be swept).
+    clearChildSubagentTracking(sid);
     return;
   }
 
@@ -852,7 +927,13 @@ async function handleV2Event(ctx, event) {
     } catch (err) {
       logErr("v2 final summary on idle failed", err);
     }
-    clearSessionTracking(sid);
+    // Children keep their parent attribution + totals while the parent runs:
+    // otherwise the very next live line reports "subagents 0" right after a
+    // subagent finishes. A root idle sweeps the whole child set instead.
+    const parentID = sessionParentCache.get(sid);
+    const isSubagent = parentID != null;
+    clearSessionTracking(sid, false, isSubagent);
+    if (!isSubagent) clearChildSubagentTracking(sid);
     return;
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-context-indicator",
-  "version": "1.5.2",
-  "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.",
+  "version": "1.5.4",
+  "description": "Real-time context-window usage for OpenCode: per-category token breakdown, /context-diff, 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",
   "exports": {
@@ -12,6 +12,7 @@
     "index.js",
     "lib/",
     "tui.tsx",
+    "docs/",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
@@ -61,11 +62,11 @@
     }
   },
   "dependencies": {
-    "@opentui/solid": "0.6.6"
+    "@opentui/solid": "0.6.8"
   },
   "devDependencies": {
-    "@opencode/plugin": "2.1.2",
-    "@opentui/core": "0.6.6",
+    "@opencode/plugin": "2.1.4",
+    "@opentui/core": "0.6.8",
     "@types/node": "26.6.3",
     "esbuild": "^0.28.2",
     "node-pty": "^1.1.0",

package/tui.tsx

@@ -38,7 +38,7 @@
  *
  * Runtime requirements: @opentui/core and solid-js are optional peers resolved
  * by OpenCode at runtime. @opentui/solid is a pinned direct dependency (exact
- * 0.6.6): OpenCode's TUI loader does not expose a host instance of it, so for
+ * 0.6.8): OpenCode's TUI loader does not expose a host instance of it, so for
  * npm-installed plugins the JSX pragma would otherwise fail to resolve
  * `@opentui/solid/jsx-runtime` (upstream opencode issue #33884).
  *