opencode-context-indicator 1.2.1 → 1.3.0

package/CHANGELOG.md

@@ -0,0 +1,101 @@
+# Changelog
+
+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.3.0 — unreleased
+
+Highlights: per-session cost in `/cx` (family-aggregated for the main session),
+a searchable family-session picker, and `/cx` reachable from subagent session
+views.
+
+- `/cx` panel: new **cost** column (upstream #45417). The main session shows
+  the family-aggregated spend, each subagent its own; `-` when the host has no
+  cost for a session.
+- New panel key `s` — a searchable picker over all family sessions
+  (title / model / cost / running marker). `Enter` navigates: root sessions
+  focus their tab, subagent sessions switch the route.
+- `/cx` now works from **subagent session views**: those views have no prompt
+  input, so the command is also in the command palette and bound to
+  `<leader>c` (ctrl+x, then c) and `f4`. The panel family is rooted at the
+  topmost ancestor, so the whole family is shown, not just the child subtree.
+- OpenTUI pinned `0.5.17`; `@opencode/plugin` types devDep pinned `2.0.26`
+  (drift-watch now tracks both). Tested against opencode **2.0.26**.
+
+## 1.2.2 — 2026-10-08
+
+- TUI entry split for maintainability: `tui.tsx` down to ~195 lines; the
+  components and the data layer moved to `lib/` (`tui-sidebar.tsx`,
+  `tui-panel.tsx`, `tui-data.js` + `.d.ts`, `tui-theme.js`). No behavior
+  change. The pragma regression gate now covers every `lib/*.tsx`.
+- E2E hardened: deterministic fail-closed plugin-load check (isolated global
+  config via `OPENCODE_CONFIG_DIR` + the isolated instance's own log file +
+  a live-surface stamp), cleanup of spawned CLI instances, WMI probe timeouts.
+
+## 1.2.1 — 2026-10-08
+
+- The panel / percentage denominator now equals **opencode's compaction
+  ceiling** (v2.0.23+ `calculateCeiling`: window = `limit.input ||
+  limit.context`; reserve = max(10% of the window, 16k when the window is at
+  least 32k)) — percentages read as "% to compaction", not "% of the raw
+  window" (upstream #51271).
+- `state.json`: new `reserve` field; the panel and `/context` show
+  `compact at X (N reserve)`.
+- Unit harness extended to 34 checks (measured contributors, redacted-export
+  invariants, ceiling formula, hydrate seeding).
+- OpenTUI pinned `0.5.16`.
+
+## 1.2.0 — 2026-10-04
+
+- New: **zero-LLM `/cx` session panel** — a family table (role / model /
+  ctx% / updated) for the current session and all subagent descendants, plus a
+  `largest contributors (measured)` section computed from the in-process
+  message list (per tool call, with message clock times and bounded previews).
+- Redacted export (`e`): no message text, no full session ids, no tool output
+  content — written under `%TEMP%/opencode-context-indicator/exports/`.
+- Keys: `esc` closes, `r` refreshes, `e` exports.
+
+## 1.1.6 — 2026-10-04
+
+- OpenTUI pinned `0.5.14` (opencode 2.0.21+), optional-peer floor aligned.
+- `index.js` split into `lib/` modules (no behavior change).
+
+## 1.1.5 — 2026-10-02
+
+- Security hardening: sanitized table metadata, validated `state.json`
+  (prototype-poisoning keys dropped), ownership-safe state lock, tmp hygiene.
+
+## 1.1.4 — 2026-10-02
+
+- Removed a stray `opencode/process` import from the TUI entry; the prepublish
+  gate now rejects bare `opencode/*` specifiers (not bridged at runtime).
+
+## 1.1.3 — 2026-10-01
+
+- Stable context denominator across plugin instances: a transient
+  `ctx.model.list()` miss falls back to the shared snapshot instead of
+  clobbering persisted windows.
+
+## 1.1.2 — 2026-10-01
+
+- Graceful sidebar/panel disable on npm installs (upstream #33884: `node_modules`
+  plugins skip the host Solid transform, so slots would freeze) — a single hint
+  is logged instead; `@opentui/solid` is shipped pinned; `file://` install docs.
+
+## 1.1.1 — 2026-10-01
+
+- Fixed `Cannot find package 'react'` when loaded from the npm cache: the
+  `@jsxImportSource @opentui/solid` pragma must be the file's first line.
+
+## 1.1.0 — 2026-10-01
+
+- New: `/context` (compact summary) and `/context-breakdown` (full table, main
+  + all subagent sessions) slash commands.
+- Stable per-model window limits; strict subagent discovery.
+
+## 1.0.0 — 2026-09-30
+
+- Initial release: dual V1/V2 plugin, real-time context indicator, per-category
+  token breakdown (system / tool schemas / user / assistant / reasoning / tool
+  args / residual), TUI sidebar.

package/README.md

@@ -3,6 +3,8 @@
 Real-time **context-window usage** indicator for [OpenCode](https://opencode.ai),
 with a **per-category token breakdown** and an optional **terminal-UI sidebar**.
 
+User-facing changes per release: [CHANGELOG.md](./CHANGELOG.md).
+
 It tells you how full the current model's context window is, and *what* is
 filling it: system prompt, tool schemas, user/assistant text, reasoning, tool
 arguments and the residual "other" bucket.
@@ -10,7 +12,7 @@ arguments and the residual "other" bucket.
 The package ships a **dual V1 + V2 plugin** (one entry works in both OpenCode
 generations) plus an optional TUI module (`./tui` entry) that renders a **live
 sidebar** and a **zero-LLM `/cx` breakdown panel** with measured contributors
-and a redacted export. The V2 path is **tested against opencode v2.0.25**; the
+and a redacted export. The V2 path is **tested against opencode v2.0.26**; the
 V1 path against 1.18.29+.
 
 > **V1 is feature-frozen.** It is kept working for compatibility (bug fixes
@@ -56,7 +58,7 @@ For every served request the plugin estimates how the context window is split:
   carries a `compaction.buffer` configured in its own settings, the plugin
   cannot read that value (it is not exposed to plugins), so the default
   reserve formula is used — set `OPENCODE_CONTEXT_INDICATOR_COMPACT_BUFFER`
-  to override the reserve for testing or custom setups (positive integer <=
+  to override the reserve for testing or custom setups (non-negative integer <=
   1e9; invalid values are silently ignored).
 
 ### Toast (V1 only)
@@ -240,7 +242,20 @@ back to a plain notice if needed.
 `/cx` opens a full `session.panel` showing the breakdown for the current session
 **and its subagent descendants**, read from the same `state.json` bridge as the
 sidebar. Keys: `/cx` opens, `esc` closes, `r` refreshes (re-read the bridge),
-`e` exports a redacted snapshot.
+`e` exports a redacted snapshot, `s` picks a family session.
+
+Every row carries a **cost** column read from the host data layer: a main
+session shows the **family-aggregated** spend, each subagent its own — no more
+invisible subagent spend (upstream #45417). `s` opens a searchable picker over
+all family sessions (title / model / cost / running marker); `Enter` navigates
+there — root sessions focus their tab, subagent sessions switch the route.
+
+Works from **subagent session views too**: those views have no prompt input
+(the composer switches to its subagents tab), so `/cx` is also registered in
+the command palette and bound to `<leader>c` / `f4` — both fire from any
+session view (the palette itself is only reachable outside the composer).
+Opened from a subagent view, the family is rooted at the topmost ancestor, so
+the whole family is shown, not just the child subtree.
 
 **Zero LLM calls.** Unlike `/context` and `/context-breakdown` (which run a real
 agent turn so the model renders the table), the panel only reads local TUI data
@@ -437,13 +452,13 @@ the sidebar instead.
   gracefully (the breakdown falls back to throttled `session.messages` fetches
   and toasts keep working).
 * **OpenCode ≥ 2.0.16** for the V2 path (built and verified against
-  **2.0.25**).
+  **2.0.26**).
 * **TUI sidebar**: terminal TUI only, requires the OpenTUI rendering stack that
   ships with OpenCode. `@opentui/core` and `solid-js` are **optional** peer
   dependencies resolved by OpenCode at runtime; the main plugin installs and runs
   fine without them (the sidebar simply is not available). `@opentui/solid` is
-  instead shipped as a **pinned direct dependency** (exact `0.5.16`, matching
-  the OpenTUI stack OpenCode 2.0.25 ships): OpenCode's
+  instead shipped as a **pinned direct dependency** (exact `0.5.17`, matching
+  the OpenTUI stack OpenCode 2.0.26 ships): 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 — `node_modules` plugins are excluded from the
@@ -505,9 +520,10 @@ caller.
 ### Running tests
 
 ```bash
-npm run test:prepublish       # fast gate: tarball + tui.tsx + resolve + T1–T12 unit
+npm run test:prepublish       # fast gate: tarball + tui.tsx + resolve + T1–T16i 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)
 ```
 
 `prepublishOnly` runs **both** gates automatically on `npm publish`
@@ -524,8 +540,8 @@ 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 → `import.meta.resolve` for all tui.tsx imports | broken peer/optional dep silently breaks the sidebar |
-| (d) unit harness T1–T12 | all limit/agent/state fix assertions | regressions in modelLimits, writeStateFile, hydrate |
+| (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 |
 | (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 |
 
@@ -533,7 +549,7 @@ STEP 80 s, ~3 min total.
 
 | Check | What | Why |
 |---|---|---|
-| A — plugin load | spins a private `opencode --standalone` PTY, asserts `msg="loading plugin" → opencode-context-indicator` and that the `file:///` entrypoint is **this checkout** | catches a plugin that no longer imports cleanly, or a config pointing at the published npm copy |
+| A — plugin load | spins a private `opencode --standalone` PTY against an **isolated global config** (`OPENCODE_CONFIG_DIR` → `%TEMP%/oci-e2e-config`, sole plugin entry = this checkout's `file://` URL), then asserts **from the host opencode log** (atomic lines, immune to PTY interleaving) that the plugin loaded and its `entrypoint` is **this checkout's `index.js`** — both fail-closed | catches a plugin that no longer imports cleanly, or an isolated config the host did not honor |
 | B — live update | one `opencode run "Say OK" --standalone` round-trip; asserts the LLM answered **and** the isolated `state.json` gained a session with `ctx > 0` | catches a regression in the `session.idle` → `writeStateFile` path |
 
 The E2E is fully **non-invasive** to your running OpenCode Desktop:
@@ -542,7 +558,14 @@ The E2E is fully **non-invasive** to your running OpenCode Desktop:
 - `OPENCODE_DB` points at a throwaway DB in `%TEMP%` (your sessions are untouched);
 - `OPENCODE_CONTEXT_INDICATOR_STATE_FILE` points at a throwaway state file in `%TEMP%`
   — the live `opencode-context-indicator-state.json` is never read or written;
+- `OPENCODE_CONFIG_DIR` points at a throwaway global config written by the script
+  (plugins: this checkout; `update: "disable"`) **for Check A only** — the load
+  source is deterministic and fail-closed instead of following your live config;
+  Check B uses your real global config read-only (the round-trip needs the
+  provider/model defined there). Your real config is never modified;
 - `OPENCODE_DISABLE_PROJECT_CONFIG=1` avoids project-level config;
+- any `opencode-cli` instance the test itself spawned is force-killed after each
+  check (`serve --service` — your Desktop background service — is never touched);
 - exactly **one** minimal LLM call (`Say OK`) is made, in the isolated session.
 
 The script prints `[e2e] running against ISOLATED opencode instance — your running
@@ -555,10 +578,20 @@ model.
 
 ### CI
 
-`.github/workflows/ci.yml` runs `test/prepublish.mjs` on every push/PR and additionally
-does a standalone esbuild transpile check (pragmas, no React). The Node-pty E2E is not
-run in CI (requires the OpenCode Desktop binary) and is skipped gracefully when the CLI
-is absent (`[SKIP] opencode CLI not found`).
+`.github/workflows/ci.yml` runs on every push/PR to `main`, on `workflow_dispatch`,
+and on a daily schedule (GitHub auto-parks scheduled workflows after 60 days of
+repo inactivity — a push or manual run re-enables them):
+
+1. `npx --no-install tsc --noEmit` — typecheck of the TUI entry (`tui.tsx` + its
+   `lib/*` imports);
+2. `test/prepublish.mjs` — the full fast gate (a)–(f), including the standalone
+   esbuild transpile check (pragmas, no React);
+3. `test/drift-watch.mjs` — the OpenTUI pin must match the OpenTUI catalog of the
+   **latest released** opencode; red CI means "bump the pin before the next
+   release".
+
+The Node-pty E2E is not run in CI (requires the OpenCode binary) and is skipped
+gracefully when the CLI is absent (`[SKIP] opencode CLI not found`).
 
 ---
 

package/lib/tui-data.d.ts

@@ -0,0 +1,45 @@
+// lib/tui-data.d.ts
+//
+// Types for lib/tui-data.js (the TUI data layer). state.json is written by
+// writeStateFile() in index.js and is untrusted input — every consumer treats
+// the fields as optional.
+
+export interface Categories {
+  user?: number
+  assistant?: number
+  reasoning?: number
+  toolArgs?: number
+  system?: number | null
+  toolSchemas?: number | null
+  other?: number
+}
+
+export interface StateEntry {
+  sessionID?: string
+  parentID?: string | null
+  role?: string
+  agent?: string | null
+  model?: string
+  providerID?: string
+  ctx?: number
+  input?: number
+  usable?: number | null
+  reserve?: number | null
+  limit?: number | null
+  reasoning?: number
+  categories?: Categories
+  updatedAt?: string
+}
+
+export declare const STATE_FILE: string
+export declare const POLL_MS: number
+export declare function isNodeModulesInstall(): boolean
+export declare function readSnapshot(): Record<string, StateEntry>
+export declare function collectFamily(
+  snapshot: Record<string, StateEntry>,
+  rootID: string,
+): StateEntry[]
+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

package/lib/tui-data.js

@@ -0,0 +1,165 @@
+// lib/tui-data.js
+//
+// Data layer for the TUI entry (tui.tsx): the state.json bridge (readSnapshot /
+// isEmptyEntry / collectFamily), the shared formatting helpers (fmt / num / fit
+// / updatedAt) and the npm-install detection. Plain JS with JSDoc — same shape
+// as lib/contributors.js — so tui.tsx stays a thin JSX/setup shell and the node
+// tooling (resolve gate, future unit tests) can import it without a transform.
+//
+// These helpers must stay free of solid-js / @opentui imports: the TUI host
+// bridges those modules only for the JSX entry, and keeping this file pure
+// means it also loads anywhere node does.
+//
+// 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 } }
+// The authoritative TS mirror of the entry shape is the `StateEntry` interface
+// in lib/tui-data.d.ts — keep the two structurally compatible.
+
+import { readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const STATE_FILE =
+  process.env.OPENCODE_CONTEXT_INDICATOR_STATE_FILE ||
+  join(tmpdir(), "opencode-context-indicator-state.json");
+
+export const POLL_MS = 1000;
+
+// True when this package was loaded from an npm install, i.e. its own file
+// path contains a `node_modules` segment (OpenCode's TUI loader skips the host
+// Solid transform for such paths → slots mount once but never live-update; see
+// the Graceful mode note in tui.tsx). Normalised to forward slashes for
+// Windows paths. ANY file of the package yields the same answer, so checking
+// from lib/ is equivalent to checking from the tui.tsx entry.
+export function isNodeModulesInstall() {
+  try {
+    const selfPath = fileURLToPath(import.meta.url).replace(/\\/g, "/").toLowerCase()
+    return selfPath.includes("/node_modules/")
+  } catch {
+    return false
+  }
+}
+
+// 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
+// file simply yields {}.
+export function readSnapshot() {
+  try {
+    const raw = readFileSync(STATE_FILE, "utf8")
+    const all = JSON.parse(raw)
+    if (!all || typeof all !== "object" || Array.isArray(all)) return {}
+    // Rebuild into a fresh plain object: drops prototype-poisoning keys
+    // (__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
+    }
+    return clean
+  } catch {
+    return {}
+  }
+}
+
+// True when an entry carries no measured tokens at all (a registered session
+// that never served a step). Mirrors isEmptyStateEntry() in lib/commands.js:
+// `categories` is always persisted, so the emptiness test SUMS its fields —
+// 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
+}
+
+// The panel row set: the root entry (panel.sessionID) plus every entry whose
+// parentID chain reaches it, breadth-first. A small local walk over the snapshot
+// — the server's collectDescendantSessionIDs lives in lib/commands.js and is NOT
+// imported here (the TUI entry stays independent of the server code by design). A
+// phantom node (no tokens, see isEmptyEntry) is not emitted, but traversal still
+// descends through it so real grandchildren behind it are found. `seen` guards
+// against cycles (parentID loops) and double-listing.
+export function collectFamily(snapshot, rootID) {
+  const out = []
+  // hasOwnProperty guard: a host-supplied rootID of "__proto__"/"constructor"
+  // must never resolve through the prototype chain into a phantom row.
+  const root = Object.prototype.hasOwnProperty.call(snapshot, rootID)
+    ? snapshot[rootID]
+    : undefined
+  if (root && typeof root === "object") out.push(root)
+  const seen = new Set([rootID])
+  const queue = [rootID]
+  // Index the snapshot by parentID once (O(n)) instead of an O(n) scan per node.
+  const byParent = new Map()
+  for (const [id, e] of Object.entries(snapshot)) {
+    const pid = e?.parentID
+    if (!pid || typeof pid !== "string") continue
+    const kids = byParent.get(pid)
+    if (kids) kids.push(id)
+    else byParent.set(pid, [id])
+  }
+  while (queue.length > 0) {
+    const cur = queue.shift()
+    const kids = byParent.get(cur)
+    if (!kids) continue
+    for (const id of kids) {
+      if (!id || seen.has(id)) continue
+      seen.add(id)
+      const e = snapshot[id]
+      if (e && !isEmptyEntry(e)) out.push(e)
+      queue.push(id) // descend through phantom parents too
+    }
+  }
+  return out
+}
+
+export function fmt(n) {
+  if (!Number.isFinite(n)) return "0"
+  return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(Math.round(n))
+}
+
+export function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0
+}
+
+// Code-point-safe column fit: truncate on code points (never splitting a
+// surrogate pair at a column boundary), mark a truncated cell with a trailing
+// "~" so clipping is VISIBLE (a silently clipped cell reads as two columns
+// colliding), then pad to the column width.
+export function fit(s, w) {
+  const cps = Array.from(s)
+  if (cps.length > w) return `${cps.slice(0, Math.max(0, w - 1)).join("")}~`
+  return s.padEnd(w)
+}
+
+export function updatedAt(iso) {
+  if (!iso) return "?"
+  try {
+    const d = new Date(iso)
+    return Number.isNaN(d.getTime()) ? "?" : d.toLocaleTimeString()
+  } catch {
+    return "?"
+  }
+}