opencode-context-indicator 1.6.0 → 1.7.1

package/lib/v2.js

@@ -14,9 +14,14 @@ import {
   estimateTokens,
   extractToolTarget,
   fmt,
+  isHookMeasuredEntry,
+  isHookSource,
   isSafeSessionKey,
   oneLine,
+  safeReclaim,
   safeSaneOrNull,
+  safeToolOutByTool,
+  safeTop,
   tokenCountOf,
   TOOL_OUT_MAX_KEYS,
   withTimeout,
@@ -60,6 +65,7 @@ import {
   debugEvent,
   logErr,
   pushFinalSummary,
+  readStateSnapshot,
   writeLog,
   writeStateFile,
 } from "./state.js";
@@ -422,10 +428,6 @@ function onV2Compaction(context) {
       pruneMap(lastKnownProviderCache, MAX_TRACKED_SESSIONS);
     }
 
-    // Arm the fallback guard for the trailing `session.compacted` event.
-    lastCompactionHookAt.set(sid, Date.now());
-    pruneMap(lastCompactionHookAt, MAX_TRACKED_SESSIONS);
-
     const ctxTokens = lastKnownCtx(sid);
     if (ctxTokens > 0) {
       const lines = buildLiveLinesV2(
@@ -436,7 +438,7 @@ function onV2Compaction(context) {
         ctxTokens,
         lastKnownReasoning(sid),
       );
-      writeStateFile(
+      const wrote = writeStateFile(
         sid,
         lastKnownModel(sid),
         lastKnownProvider(sid),
@@ -449,6 +451,16 @@ function onV2Compaction(context) {
           cacheWrite: lastKnownCacheWrite(sid),
         },
       );
+      // Arm the fallback guard for the trailing `session.compacted` event ONLY
+      // when this hook actually PERSISTED the measurement (writeStateFile
+      // returns false on a busy lock / unsafe key / failed rename). A hook that
+      // wrote nothing leaves the entry untouched; arming there would tell the
+      // later event "already handled" and the compaction would leave no trace at
+      // all - no stale mark, no note ("after compaction nothing happens").
+      if (wrote) {
+        lastCompactionHookAt.set(sid, Date.now());
+        pruneMap(lastCompactionHookAt, MAX_TRACKED_SESSIONS);
+      }
       // Claim key derived from the PAYLOAD shape (message count + total
       // estimated chars): identical across plugin instances for the SAME
       // compaction (cross-instance dedup preserved) yet distinct per compaction
@@ -464,7 +476,7 @@ function onV2Compaction(context) {
           (parts.systemChars || 0) +
           (parts.toolSchemasChars || 0));
       pushFinalSummary(`compaction-hook:${sid}:${sig}`, [
-        `[${new Date().toISOString()}] COMPACTION (hook) session=${sid} — pre-compaction snapshot captured`,
+        `[${new Date().toISOString()}] COMPACTION (hook) session=${sid} — pre-compaction snapshot ${wrote ? "captured" : "estimated only (state write refused)"}`,
         ...lines.slice(1),
       ]);
     }
@@ -671,6 +683,40 @@ function aggregateSubagentsV2(sessionID) {
   return result;
 }
 
+// Convert a persisted state.json entry into the in-memory breakdown shape so the
+// diagnostic log can render categories another instance measured with the
+// request hook. Everything here is UNTRUSTED shared-file data: reuse the same
+// sanitisers the writer and the command report use, so a poisoned entry cannot
+// inject unbounded arrays, negative counts or foreign shapes into the log.
+function stateEntryToBreakdown(entry) {
+  const c = entry?.categories || {};
+  const user = safeSaneOrNull(c.user) ?? 0;
+  const assistant = safeSaneOrNull(c.assistant) ?? 0;
+  const reasoning = safeSaneOrNull(c.reasoning) ?? 0;
+  const toolArgs = safeSaneOrNull(c.toolArgs) ?? 0;
+  const toolOut = safeSaneOrNull(c.toolOut) ?? 0;
+  return {
+    userChars: user,
+    assistantChars: assistant,
+    reasoningChars: reasoning,
+    toolArgsChars: toolArgs,
+    toolOutChars: toolOut,
+    toolOutByTool: safeToolOutByTool(entry?.toolOutByTool),
+    systemChars: safeSaneOrNull(c.system),
+    toolSchemasChars: safeSaneOrNull(c.toolSchemas),
+    reclaim: safeReclaim(entry?.reclaim, false),
+    top: safeTop(entry?.top, false),
+    // The entry's residual was computed against the INPUT the hook saw. This
+    // instance may have a different `lastKnownInput` (a mirror that only saw the
+    // trailing event has 0), so the residual must be carried over instead of
+    // recomputed - otherwise the log prints a non-zero breakdown next to
+    // "other 0 (= input - sum of estimates)".
+    otherChars: safeSaneOrNull(c.other),
+    capturedAt: Date.parse(entry?.updatedAt) || 0,
+    source: entry?.source || "snapshot",
+  };
+}
+
 // V2: assemble the live breakdown lines (no client, no fallback fetch —
 // the context hook fills breakdownCache on every request).
 function buildLiveLinesV2(sessionID, modelID, providerID, inputTokens, ctxTokens, reasoningTokens) {
@@ -678,7 +724,74 @@ function buildLiveLinesV2(sessionID, modelID, providerID, inputTokens, ctxTokens
   const ts = new Date().toISOString();
   const limit = getModelLimit(providerID, modelID);
   const usableInfo = getUsableContext(providerID, modelID);
-  const total = typeof ctxTokens === "number" && ctxTokens > 0 ? ctxTokens : inputTokens;
+
+  // A client-context fallback cannot see the system prompt or the tool schemas:
+  // its `other` swallows both and, right after a compaction, it can even read a
+  // nearly empty conversation. The log is shared by every instance, so when
+  // ANOTHER instance has measured this session with the request hook, that
+  // measurement (state.json) is the truthful one to print here - same priority
+  // as writeStateFile / collectSessionReport. `!bd` (this instance has no cache
+  // entry at all, e.g. it only saw the trailing event) takes the same path.
+  // Only the DISPLAY is substituted; the cache itself is left alone.
+  //
+  // The counters come from the same snapshot on purpose: this instance's
+  // input/ctx belong to ITS view (a mirror that only saw the trailing event has
+  // 0), and mixing them with the hook's categories made the header contradict
+  // the "other = input - sum of estimates" line right below it.
+  let bd = breakdownCache.get(sessionID);
+  let snapInputTokens = null;
+  let snapCtxTokens = null;
+  let snapAt = null;
+  let borrowedSnapshot = false;
+  // A hook breakdown whose instance has NO request counters is just as
+  // unprintable as a fallback: the categories are measured, but the total this
+  // instance knows is 0 (it never completed a step - e.g. a mirror that only
+  // saw the compaction hook). Such an entry also takes the state.json path, so
+  // the header and the categories come from ONE measurement instead of a
+  // `ctx=0` header sitting above non-zero categories.
+  const haveLocalCounters =
+    (typeof inputTokens === "number" && inputTokens > 0) ||
+    (typeof ctxTokens === "number" && ctxTokens > 0);
+  if (
+    !bd ||
+    bd.source === "client-context" ||
+    (isHookSource(bd.source) && !haveLocalCounters)
+  ) {
+    const entry = isSafeSessionKey(sessionID)
+      ? readStateSnapshot()[sessionID]
+      : null;
+    if (isHookMeasuredEntry(entry)) {
+      bd = stateEntryToBreakdown(entry);
+      snapInputTokens = safeSaneOrNull(entry.input);
+      snapCtxTokens = safeSaneOrNull(entry.ctx);
+      snapAt = typeof entry.updatedAt === "string" ? entry.updatedAt : null;
+      borrowedSnapshot = true;
+    }
+  }
+  const source = bd?.source || "none";
+  const rt = typeof reasoningTokens === "number" ? reasoningTokens : 0;
+  const effInput = snapInputTokens != null ? snapInputTokens : inputTokens;
+  const effCtx = snapCtxTokens != null ? snapCtxTokens : ctxTokens;
+  // Only a POSITIVE counter is knowledge. A zero is exactly what the broken
+  // case looks like (a state entry written by the trailing-event fallback of a
+  // mirror instance carries `ctx: 0, input: 0`), and treating it as "known"
+  // would reprint the very `ctx=0` this path exists to avoid.
+  const haveSnapCounters =
+    (typeof snapInputTokens === "number" && snapInputTokens > 0) ||
+    (typeof snapCtxTokens === "number" && snapCtxTokens > 0);
+  // Still unknown (no counters here AND no usable hook measurement on disk):
+  // print "?" rather than a fabricated 0 that contradicts the categories below.
+  const countersKnown = haveLocalCounters || haveSnapCounters;
+  // `other = input - sum` needs the input itself; a ctx-only snapshot (the
+  // compaction hook knows ctx but a mirror never saw the request) cannot
+  // produce an honest residual.
+  const inputKnown =
+    countersKnown && typeof effInput === "number" && effInput > 0;
+  const total = !countersKnown
+    ? null
+    : typeof effCtx === "number" && effCtx > 0
+      ? effCtx
+      : effInput;
   const denom =
     usableInfo != null
       ? usableInfo.usable
@@ -686,19 +799,31 @@ function buildLiveLinesV2(sessionID, modelID, providerID, inputTokens, ctxTokens
         ? limit
         : null;
   const pct =
-    denom != null ? ` (${((total / denom) * 100).toFixed(1)}%)` : "";
+    denom != null && total != null
+      ? ` (${((total / denom) * 100).toFixed(1)}%)`
+      : "";
+  // The reader must be able to tell a fresh local measurement from a borrowed
+  // snapshot (and from how old it is). A snapshot without a timestamp still
+  // must not look local.
+  const snapNote = borrowedSnapshot
+    ? ` snapshot=${snapAt || "unknown"}`
+    : "";
 
+  const shownTotal = total != null ? fmt(total) : "?";
   lines.push(
-    `[${ts}] session=${sessionID} model=${modelID} ctx=${fmt(total)}/${denom != null ? fmt(denom) : "?"}${pct} count=${fmt(total)} usable=${usableInfo != null ? fmt(usableInfo.usable) : "?"} limit=${limit != null ? fmt(limit) : "?"} maxOutput=${usableInfo != null ? fmt(usableInfo.maxOutput) : "?"} reserved=${usableInfo != null ? fmt(usableInfo.reserved) : "?"} input=${fmt(inputTokens)}`,
+    `[${ts}] session=${sessionID} model=${modelID} ctx=${shownTotal}/${denom != null ? fmt(denom) : "?"}${pct} count=${shownTotal} usable=${usableInfo != null ? fmt(usableInfo.usable) : "?"} limit=${limit != null ? fmt(limit) : "?"} maxOutput=${usableInfo != null ? fmt(usableInfo.maxOutput) : "?"} reserved=${usableInfo != null ? fmt(usableInfo.reserved) : "?"} input=${inputKnown ? fmt(effInput) : "?"}${snapNote}`,
   );
 
-  const bd = breakdownCache.get(sessionID);
-  const source = bd?.source || "none";
-  const rt = typeof reasoningTokens === "number" ? reasoningTokens : 0;
-
   // 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;
+  // may be absent -> everything 0 and the residual is the whole input). A
+  // breakdown taken from state.json carries the residual the HOOK computed
+  // against the input IT saw; this instance's `inputTokens` can differ (a mirror
+  // that only saw the trailing event has 0), so that value is used instead.
+  const other = inputKnown
+    ? typeof bd?.otherChars === "number"
+      ? bd.otherChars
+      : breakdownCategories(bd, effInput).other
+    : null;
 
   if (bd) {
     lines.push(`  user        ${fmt(bd.userChars || 0)} (est tokens)`);
@@ -728,7 +853,11 @@ function buildLiveLinesV2(sessionID, modelID, providerID, inputTokens, ctxTokens
     lines.push(`  system      n/a (hook did not run)`);
     lines.push(`  tool schemas n/a`);
   }
-  lines.push(`  other       ${fmt(other)} (= input - sum of estimates)`);
+  lines.push(
+    other != null
+      ? `  other       ${fmt(other)} (= input - sum of estimates)`
+      : `  other       n/a (input unknown on this instance)`,
+  );
   lines.push(`  source      ${source}`);
 
   // Provider-reported prompt cache (EXACT, not an estimate; a subset of input —
@@ -877,8 +1006,45 @@ async function handleV2Event(ctx, event) {
           },
         );
       }
+      // Claim key: the event id when the host sends a usable one; otherwise the
+      // event's own timestamp (a per-event revision, when present); otherwise a
+      // per-session minute bucket (same shape as the V1 idle note). A
+      // session-only key would log just the FIRST compaction of a session and
+      // silently drop every later one whenever the host omits the event id.
+      // An empty/zero id is treated as absent: `??` would collapse it to the
+      // same key for every compaction and drop all but the first note.
+      const evId =
+        typeof event.id === "string" && event.id.length > 0 ? event.id : null;
+      let evStamp = null;
+      if (!evId) {
+        for (const v of [
+          event.time,
+          event.timestamp,
+          event.data?.time,
+          event.data?.createdAt,
+          event.data?.timestamp,
+        ]) {
+          if (typeof v === "string" && v.length > 0) {
+            evStamp = v;
+            break;
+          }
+          // `0` is a common "time unknown" sentinel: accepting it would make
+          // the key constant for the whole 24h dedup TTL and re-introduce the
+          // "only the first compaction is logged" bug.
+          if (typeof v === "number" && Number.isFinite(v) && v > 0) {
+            evStamp = String(v);
+            break;
+          }
+        }
+      }
+      // The session id stays in the key even with an event id: some hosts
+      // number ids per session ("1", "2"), and cross-instance dedup only needs
+      // the id to be equal for the SAME event of the SAME session.
+      const claimKey = evId
+        ? `compacted:${sid}:${evId}`
+        : `compacted:${sid}:${evStamp ?? Math.floor(Date.now() / 60000)}`;
       pushFinalSummary(
-        `compacted:${event.id ?? sid}`,
+        claimKey,
         [
           `[${new Date().toISOString()}] COMPACTED session=${sid} (auto — the context may have overflowed)`,
           ...lines.slice(1),
@@ -1071,5 +1237,10 @@ export {
   handleV2Event,
   estimateBreakdownFromContext,
   estimateBreakdownFromClientMessages,
+  // Harness-only (test/prepublish.mjs): the live-log assembly and its
+  // state-entry adapter, so the hook-vs-fallback display rule can be tested
+  // without a real opencode runtime.
+  buildLiveLinesV2,
+  stateEntryToBreakdown,
   V2_FALLBACK_TIMEOUT_MS,
 };

package/package.json

@@ -1,17 +1,20 @@
 {
   "name": "opencode-context-indicator",
-  "version": "1.6.0",
-  "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.",
+  "version": "1.7.1",
+  "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, a TUI sidebar, and an experimental Desktop panel. Dual V1 + V2 plugin entry.",
   "type": "module",
   "license": "MIT",
   "exports": {
     ".": "./index.js",
-    "./tui": "./tui.tsx"
+    "./tui": "./tui.tsx",
+    "./rpc": "./lib/rpc.js",
+    "./gui-experimental": "./dist/gui-experimental.cjs"
   },
   "files": [
     "index.js",
     "lib/",
     "tui.tsx",
+    "dist/",
     "docs/",
     "README.md",
     "CHANGELOG.md",
@@ -31,7 +34,9 @@
     "breakdown",
     "tui",
     "sidebar",
-    "panel"
+    "panel",
+    "desktop",
+    "gui"
   ],
   "publishConfig": {
     "access": "public"
@@ -71,14 +76,18 @@
     "esbuild": "^0.28.2",
     "node-pty": "^1.1.0",
     "solid-js": "^1.9.12",
-    "typescript": "5.9.3"
+    "typescript": "5.9.3",
+    "vite": "^8.3.5",
+    "vite-plugin-solid": "^2.11.14"
   },
   "scripts": {
+    "build:gui": "vite build --config vite.gui.config.mjs",
+    "test:types": "tsc --noEmit && tsc -p tsconfig.gui.json --noEmit",
     "test:prepublish": "node test/prepublish.mjs",
     "test:e2e": "node test/e2e-tui.mjs --full",
     "test:e2e:quick": "node test/e2e-tui.mjs --quick",
     "test:drift": "node test/drift-watch.mjs",
     "test:drift:strict": "node test/drift-watch.mjs --strict"
   },
-  "prepublishOnly": "node test/prepublish.mjs && node test/e2e-tui.mjs --full"
+  "prepublishOnly": "npm run build:gui && node test/prepublish.mjs && node test/e2e-tui.mjs --full"
 }