opencode-context-indicator 1.8.0 → 1.8.2

package/lib/state.js

@@ -38,7 +38,7 @@ import {
   sumCategories,
 } from "./estimate.js";
 import {
-  breakdownCache,
+  breakdownForModel,
   MAX_TRACKED_SESSIONS,
   sessionAgentCache,
   sessionParentCache,
@@ -424,10 +424,10 @@ function renameWithRetry(from, to, attempts = 3, delayMs = 50) {
 // affect the log / toast / event paths.
 // Tombstone window: state.json entries untouched for longer than this are
 // pruned during the next write (deleted / abandoned sessions used to linger
-// until the LRU cap evicted them). Conservative: consumers are family-scoped,
-// so this is file hygiene, not correctness. Entries with an unparsable
-// updatedAt are kept.
-const PRUNE_AFTER_MS = 30 * 24 * 60 * 60 * 1000;
+// until the LRU cap evicted them). Hygiene, not correctness: consumers are
+// family-scoped, and a resurrected session re-measures on its first request.
+// 7 days: a tombstone only matters while a sibling/parent poll can still see it.
+const PRUNE_AFTER_MS = 7 * 24 * 60 * 60 * 1000;
 
 function writeStateFile(
   sessionID,
@@ -458,8 +458,7 @@ function writeStateFile(
       return false;
     }
     try {
-      const bd = breakdownCache.get(sessionID) || null;
-      const usableInfo = getUsableContext(providerID, modelID);
+      const usableInfo = getUsableContext(providerID, modelID, undefined, opts?.directory);
       // Persist the EFFECTIVE window (min(input, context) when both are known,
       // else input || context: the same window the ceiling was derived from),
       // not the raw context window: on a cold instance
@@ -503,7 +502,7 @@ function writeStateFile(
       }
       // Tombstone prune: entries untouched for PRUNE_AFTER_MS drop out of the
       // shared file (deleted / abandoned sessions used to linger until the LRU
-      // cap). Edge case: resuming a 30+-day-stale session prunes its own old
+      // cap). Edge case: resuming a 7+-day-stale session prunes its own old
       // entry once, losing the inherited usable/agent/parentID for the first
       // write — it self-heals on the next event. Unparsable updatedAt -> keep.
       {
@@ -516,27 +515,6 @@ function writeStateFile(
       const prevEntry = Object.prototype.hasOwnProperty.call(all, sessionID)
         ? all[sessionID]
         : null;
-      const pc = prevEntry?.categories || null;
-
-      // Which breakdown is allowed to OWN the persisted categories?
-      //
-      // This file is shared by every plugin instance, and the instance that
-      // answers the Desktop RPC (the window's) never serves a model request, so
-      // its `breakdownCache` entry is always the client-context fallback rebuilt
-      // from the persisted message list. That fallback cannot see the assembled
-      // system prompt or the tool schemas, folds their whole mass into `other`,
-      // and after a compaction it can even read an empty conversation. Letting
-      // it overwrite the hook's measurement — the two writes landed 11 ms apart
-      // in the field — produced "system 0 / tool schemas 0 / other inflated" and
-      // could blank user/assistant. So: a hook-family source (see
-      // isHookSource) always wins; the fallback only fills an entry that no hook
-      // has ever measured.
-      //
-      // Legacy entries (written before `source` was persisted) carry no tag, but
-      // only a hook can produce a non-null system / tool-schema estimate.
-      const prevHookMeasured = isHookMeasuredEntry(prevEntry);
-      const bdFromHook = bd != null && isHookSource(bd.source);
-      const useBd = bd != null && (bdFromHook || !prevHookMeasured);
 
       // Resolve the model identity for THIS write. An unmeasured write from a
       // mirror/idle instance may not know the model (its caches were cleared);
@@ -554,10 +532,52 @@ function writeStateFile(
       // Same model AND provider? Only then is a previously persisted denominator
       // meaningful — a session that switched model (or provider, even with the
       // same modelID) must not inherit the old window.
+      //
+      // An EMPTY provider on either side is "not known yet", not a change: an
+      // idle/mirror write carries no provider (its caches were cleared), and a
+      // valid split written by another instance under `providerID: ""` must
+      // survive the next write that knows the provider. Treating that as a
+      // switch would zero the categories and drop the denominator.
+      const providerCompatible =
+        prevEntry == null ||
+        !prevEntry.providerID ||
+        !effectiveProvider ||
+        prevEntry.providerID === effectiveProvider;
       const sameModelAsPrev =
         prevEntry != null &&
         prevEntry.model === effectiveModel &&
-        (prevEntry.providerID || "") === effectiveProvider;
+        providerCompatible;
+
+      // A breakdown measured for a DIFFERENT model describes the payload the
+      // previous model received: same tokens, but the window and the tool/system
+      // share move. Persisting it under the new model shows the old split until
+      // the next request re-measures (the reported "categories lag after a model
+      // switch"). breakdownForModel drops exactly that case.
+      const bd = breakdownForModel(sessionID, effectiveModel);
+      // Persisted categories are model-scoped too: after a switch the old split
+      // must not seed the new entry (a hook measurement of the OLD model also
+      // must not block the fallback from filling the new one).
+      const pc = sameModelAsPrev ? prevEntry?.categories || null : null;
+
+      // Which breakdown is allowed to OWN the persisted categories?
+      //
+      // This file is shared by every plugin instance, and the instance that
+      // answers the Desktop RPC (the window's) never serves a model request, so
+      // its `breakdownCache` entry is always the client-context fallback rebuilt
+      // from the persisted message list. That fallback cannot see the assembled
+      // system prompt or the tool schemas, folds their whole mass into `other`,
+      // and after a compaction it can even read an empty conversation. Letting
+      // it overwrite the hook's measurement — the two writes landed 11 ms apart
+      // in the field — produced "system 0 / tool schemas 0 / other inflated" and
+      // could blank user/assistant. So: a hook-family source (see
+      // isHookSource) always wins; the fallback only fills an entry that no hook
+      // has ever measured.
+      //
+      // Legacy entries (written before `source` was persisted) carry no tag, but
+      // only a hook can produce a non-null system / tool-schema estimate.
+      const prevHookMeasured = sameModelAsPrev && isHookMeasuredEntry(prevEntry);
+      const bdFromHook = bd != null && isHookSource(bd.source);
+      const useBd = bd != null && (bdFromHook || !prevHookMeasured);
 
       // A write with no token figure at all is NOT a measurement: it happens on
       // a mirror instance (the hook/step served another instance, so this
@@ -608,25 +628,34 @@ function writeStateFile(
       // 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.
+      // no live breakdown at all AND the model is unchanged (the split describes
+      // the previous model's request payload).
       const toolOutByTool = useBd
         ? safeToolOutByTool(bd.toolOutByTool)
-        : safeToolOutByTool(prevEntry?.toolOutByTool);
+        : sameModelAsPrev
+          ? safeToolOutByTool(prevEntry?.toolOutByTool)
+          : null;
 
       // Redundant tool output (waste detector). Persisted WITHOUT targets
       // (keepTarget=false): state.json is a local temp file, but keeping it
       // path-free matches the redacted-export policy. A present breakdown owns
-      // the value; otherwise inherit the persisted one.
+      // the value; otherwise inherit the persisted one (model-gated, like the
+      // categories it summarises).
       const reclaim = useBd
         ? safeReclaim(bd.reclaim, false)
-        : safeReclaim(prevEntry?.reclaim, false);
+        : sameModelAsPrev
+          ? safeReclaim(prevEntry?.reclaim, false)
+          : null;
 
       // Heaviest single items still in the request (top-N). A present breakdown
-      // OWNS the list; otherwise inherit the persisted one. Persisted WITHOUT
-      // targets (path-free policy, same as reclaim).
+      // OWNS the list; otherwise inherit the persisted one (model-gated: the
+      // system prompt / tool-schema share moves between models). Persisted
+      // WITHOUT targets (path-free policy, same as reclaim).
       const top = useBd
         ? safeTop(bd.top, false)
-        : safeTop(prevEntry?.top, false);
+        : sameModelAsPrev
+          ? safeTop(prevEntry?.top, false)
+          : [];
 
       // Provider-reported prompt cache (EXACT; a subset of input — never added
       // to the category sum). Inherit when this write carries no fresh figure

package/lib/tui-composer.ts

@@ -0,0 +1,70 @@
+// lib/tui-composer.ts - the `prompt.footer.status` slot component.
+//
+// One always-visible usage capsule inside the TUI composer (`38% ctx`), the
+// terminal counterpart of the Desktop composer pill (gui/index.tsx). Without it
+// the percentage only exists inside the sidebar (hidden when collapsed) or the
+// full-screen `/cx` panel.
+//
+// Same rules as every other TUI surface here: NO JSX, no pragma, every dynamic
+// prop a getter (see lib/tui-h.ts). The host ships the slot since opencode 2.2.x
+// (`prompt.footer.status` accepts `{ sessionID, mode, showDetails }`); an older
+// host simply lacks the path and registerSlot() logs once in tui.ts.
+//
+// The component renders nothing on its own when there is no measurement: a
+// missing window must not push an empty box into the composer.
+
+import { usePlugin } from "@opencode/plugin/tui"
+import { Show } from "solid-js"
+import type { StateEntry } from "./tui-data.js"
+import { composerStatus } from "./tui-data.js"
+import { fmt } from "./format.js"
+import { token } from "./tui-theme.js"
+import { c, h } from "./tui-h.ts"
+
+export function ComposerStatus(props: {
+  entry: () => StateEntry | null
+  /** "normal" | "shell"; the host passes this on every render. */
+  mode: () => string
+  /** The host's own compact/detailed toggle (`showDetails`). */
+  showDetails: () => boolean
+}) {
+  const context = usePlugin()
+  const base = () => token(context?.theme?.text?.base, "white")
+  const warn = () => token(context?.theme?.text?.feedback?.warning?.base, "yellow")
+  const danger = () => token(context?.theme?.text?.feedback?.error?.base, "red")
+
+  // A shell prompt is not a model turn: the number would describe the previous
+  // exchange and sit next to a `$` prompt, so it is hidden there.
+  const status = () => (props.mode() === "shell" ? null : composerStatus(props.entry()))
+
+  const fg = () => {
+    const tone = status()?.tone
+    return tone === "danger" ? danger() : tone === "warning" ? warn() : base()
+  }
+
+  const label = () => {
+    const s = status()
+    if (!s) return ""
+    if (!props.showDetails()) return s.label
+    const e = props.entry()
+    const ctx = typeof e?.ctx === "number" ? e.ctx : 0
+    const usable = typeof e?.usable === "number" ? e.usable : 0
+    return `${s.label} ${fmt(ctx)}/${fmt(usable)}`
+  }
+
+  return c(Show, {
+    get when() {
+      return status()
+    },
+    get children() {
+      return h("text", {
+        get fg() {
+          return fg()
+        },
+        get children() {
+          return label()
+        },
+      })
+    },
+  })
+}

package/lib/tui-data.d.ts

@@ -54,6 +54,16 @@ export interface StateEntry {
 
 export declare const STATE_FILE: string
 export declare const POLL_MS: number
+export interface ComposerStatus {
+  percent: number
+  label: string
+  tone?: "warning" | "danger"
+}
+export declare const COMPOSER_WARN_PERCENT: number
+export declare const COMPOSER_DANGER_PERCENT: number
+export declare function composerStatus(
+  entry: StateEntry | null | undefined,
+): ComposerStatus | null
 export declare function readSnapshot(): Record<string, StateEntry>
 export declare function collectFamily(
   snapshot: Record<string, StateEntry>,
@@ -63,6 +73,19 @@ 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 updatedCell(
+  iso: string | undefined,
+  stale: boolean | undefined,
+  width: number,
+): string
+export declare function panelLayout(panelWidth: number | undefined): {
+  roleW: number
+  modelW: number
+  ctxW: number
+  costW: number
+  updW: number
+  gutter: string
+}
 export declare function toolOutEntries(
   map: Record<string, number> | undefined,
   limit?: number,

package/lib/tui-data.js

@@ -122,12 +122,132 @@ export function fit(s, w) {
   return s.padEnd(w)
 }
 
+// Compose the `updated` cell. The stale marker is appended AFTER fitting: fit()
+// cuts the tail and replaces it with "~", so a marker folded into the fitted
+// string would disappear at the first narrow width - while the legend line below
+// the table would still advertise it. The time cell keeps at least 5 columns.
+export function updatedCell(iso, stale, width) {
+  const marker = stale === true ? " *" : ""
+  const timeW = Math.max(5, width - marker.length)
+  return fit(updatedAt(iso), timeW) + marker
+}
+
+// Deterministic clock for the updated column: HH:MM:SS in LOCAL time, built
+// from the Date getters instead of toLocaleTimeString(). toLocaleTimeString()
+// follows the host locale (AM/PM, dots, seconds dropped) and can exceed the
+// column width - the sidebar and the `/cx` row then lose their alignment on
+// non-en-US machines.
 export function updatedAt(iso) {
   if (!iso) return "?"
   try {
     const d = new Date(iso)
-    return Number.isNaN(d.getTime()) ? "?" : d.toLocaleTimeString()
+    if (Number.isNaN(d.getTime())) return "?"
+    const pad = (n) => String(n).padStart(2, "0")
+    return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`
   } catch {
     return "?"
   }
 }
+
+// Panel column layout (monospace), derived from the host-provided panel width so
+// cells never collide on narrow terminals. Pure math (no JSX, no host imports),
+// so the unit harness can assert the row never grows past the panel.
+//
+// Columns: role | model | ctx | cost | updated, four 2-column gutters.
+//
+// Width budget (row = role + model + ctx + cost + updated + 4 gutters):
+//   - the `updated` cell takes 10 columns (HH:MM:SS + " *") only when that
+//     leaves the model cell at its 8-column floor, otherwise 8 (the marker then
+//     elides the seconds) - growing it must never push the row past the panel;
+//   - the model cell absorbs whatever is left above its floor;
+//   - if both floors bind (narrow panels), the ROLE cell gives back the
+//     difference down to its own floor: without that clawback the row landed on
+//     an exact fit at w=60..62, and an exact fit is what clipped the last cell
+//     (the stale marker) in the first place;
+//   - PANEL_SAFE_COLUMNS is therefore preserved for every width >= 57; at 56
+//     the role floor stops the clawback and the row is an exact fit.
+// Below 56 columns the fixed columns (ctx 12 + cost 8 + updated 8 + four
+// gutters) plus the role/model floors no longer fit; the host clips the right
+// edge there.
+const PANEL_GUTTER = 2
+const PANEL_CTX_WIDTH = 12
+const PANEL_COST_WIDTH = 8
+// One spare column: the host adds its own padding/border around a panel and an
+// exact fit let the last cell land on the right edge (clipped on some widths).
+const PANEL_SAFE_COLUMNS = 1
+// Model cell floor: a model name shorter than this is unreadable.
+const PANEL_MIN_MODEL_W = 8
+// Role cell floor: `subagent-12` is the longest role label we print.
+const PANEL_MIN_ROLE_W = 12
+// `HH:MM:SS` is 8 columns; the stale marker needs 2 more.
+const PANEL_TIME_W = 8
+const PANEL_TIME_STALE_W = 10
+
+export function panelLayout(panelWidth) {
+  const w = num(panelWidth) > 0 ? num(panelWidth) : 60
+  const ctxW = PANEL_CTX_WIDTH
+  const costW = PANEL_COST_WIDTH
+  const gutters = 4 * PANEL_GUTTER
+  let roleW = Math.max(PANEL_MIN_ROLE_W, Math.min(20, Math.floor(w * 0.28)))
+  const usable = w - PANEL_SAFE_COLUMNS - roleW - ctxW - costW - gutters
+  // Prefer the full `HH:MM:SS` + " *" cell. When that does not leave the model
+  // cell its floor, fall back to the 8-column time cell: the marker then elides
+  // the SECONDS instead of the row overrunning the panel (which clipped the very
+  // marker the legend explains).
+  const updW =
+    usable - PANEL_TIME_STALE_W >= PANEL_MIN_MODEL_W
+      ? PANEL_TIME_STALE_W
+      : PANEL_TIME_W
+  const modelW = Math.max(PANEL_MIN_MODEL_W, usable - updW)
+  // Both floors binding (narrow panel) made the row an EXACT fit: the model
+  // floor ate PANEL_SAFE_COLUMNS and the last cell again landed on the panel
+  // edge. Take the difference back from the role cell instead - it is prose and
+  // elides gracefully, and the safe column survives.
+  const total = roleW + modelW + ctxW + costW + updW + gutters
+  const over = total - (w - PANEL_SAFE_COLUMNS)
+  if (over > 0) {
+    roleW = Math.max(PANEL_MIN_ROLE_W, roleW - over)
+  }
+  return {
+    roleW,
+    modelW,
+    ctxW,
+    costW,
+    updW,
+    gutter: " ".repeat(PANEL_GUTTER),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Composer pill (`prompt.footer.status` slot).
+// ---------------------------------------------------------------------------
+
+// Same thresholds as the Desktop pill (gui/index.tsx PILL_* constants): amber
+// from 65% of the usable window, red from 85%. Kept in ONE place for the TUI
+// and mirrored there on purpose - the GUI bundle is separate, but a divergence
+// in the two numbers reads as a bug.
+export const COMPOSER_WARN_PERCENT = 65;
+export const COMPOSER_DANGER_PERCENT = 85;
+
+// One-line usage capsule: `{ percent, label, tone }`, or null when the entry
+// has no usable window (no data yet, a fresh session, or a model without a
+// limit). Pure and dependency-free so the unit harness can pin the thresholds.
+export function composerStatus(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  const usable = num(entry.usable);
+  const ctx = num(entry.ctx);
+  if (!(usable > 0) || ctx < 0) return null;
+  const share = (ctx / usable) * 100;
+  if (!Number.isFinite(share)) return null;
+  const percent = Math.round(share);
+  return {
+    percent,
+    label: `${percent}% ctx`,
+    tone:
+      share >= COMPOSER_DANGER_PERCENT
+        ? "danger"
+        : share >= COMPOSER_WARN_PERCENT
+          ? "warning"
+          : undefined,
+  };
+}

package/lib/tui-panel.ts

@@ -10,7 +10,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, toolOutEntries, updatedAt } from "./tui-data.js"
+import { collectFamily, fit, fmt, num, panelLayout, toolOutEntries, updatedCell } from "./tui-data.js"
 import { token } from "./tui-theme.js"
 import { c as comp, h } from "./tui-h.ts"
 import {
@@ -121,29 +121,9 @@ function listSignature(list: unknown[]): string {
   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.
-const GUTTER = 2
-const CTX_WIDTH = 12
-const COST_WIDTH = 8
-
-function panelLayout(panelWidth: number): {
-  roleW: number
-  modelW: number
-  ctxW: number
-  costW: number
-  updW: number
-  gutter: string
-} {
-  const w = num(panelWidth) > 0 ? num(panelWidth) : 60
-  const ctxW = CTX_WIDTH
-  const costW = COST_WIDTH
-  const updW = Math.max(5, Math.min(8, w - ctxW - 4 * GUTTER - 24))
-  const roleW = Math.max(12, Math.min(20, Math.floor(w * 0.28)))
-  const modelW = Math.max(8, w - roleW - ctxW - costW - updW - 4 * GUTTER)
-  return { roleW, modelW, ctxW, costW, updW, gutter: " ".repeat(GUTTER) }
-}
+// Panel column layout lives in lib/tui-data.js (pure math) so the unit harness
+// can regression-test that the row never grows past the panel width (T42 in
+// test/prepublish.mjs).
 
 // Dollar formatting for the cost column: compact, always `$`-prefixed, `-`
 // when the host data layer has no cost for the session.
@@ -617,8 +597,7 @@ export function BreakdownPanel(props: {
       L.gutter +
       fit(money(costOf(e.sessionID)), L.costW) +
       L.gutter +
-      updatedAt(e.updatedAt) +
-      (e.compactStale === true ? " (stale)" : "")
+      updatedCell(e.updatedAt, e.compactStale === true, L.updW)
     )
   }
 
@@ -633,7 +612,7 @@ export function BreakdownPanel(props: {
       all && typeof all === "object"
         ? Object.values(all).filter((v) => num(v) > 0).length
         : 0
-    const parts = entries.map(([name, val]) => `${safeText(name)} ${fmt(val)}`)
+    const parts = entries.map(([name, val]) => `${safeText(name)} ${fmt(val)} tokens`)
     if (total > entries.length) parts.push(`+${total - entries.length} more`)
     return parts.join(" \u00b7 ")
   }
@@ -701,6 +680,14 @@ export function BreakdownPanel(props: {
                 .rows.map((e, i) =>
                   mutedText(() => row(e, i === 0)),
                 ),
+              comp(Show, {
+                get when() {
+                  return data().rows.some((e) => e.compactStale === true)
+                },
+                get children() {
+                  return mutedText(() => " * stale - compacted")
+                },
+              }),
               comp(Show, {
                 get when() {
                   return (data().root?.usable ?? 0) > 0

package/lib/v2.js

@@ -29,6 +29,7 @@ import {
 import {
   BREAKDOWN_THROTTLE_MS,
   breakdownCache,
+  breakdownForModel,
   clearChildSubagentTracking,
   clearSessionTracking,
   ERROR_TOAST_DEDUP_MS,
@@ -61,6 +62,7 @@ import {
   getModelLimit,
   getUsableContext,
 } from "./limits.js";
+import { locationDirectory } from "./config.js";
 import {
   debugEvent,
   logErr,
@@ -364,17 +366,32 @@ function estimateBreakdownFromContext(context, sessionID) {
 
 // V2 context hook handler: capture the final messages / system prompt / tool
 // schemas + the request model. READ-ONLY — the context object is never mutated.
-function onV2Context(context) {
+//
+// `ctx` (the plugin context) is optional and only used to remember which project
+// the hook belongs to: the limits path resolves the user's configured
+// compaction.buffer per directory, and a process can host several instances.
+function onV2Context(context, ctx) {
   try {
     if (!context || typeof context !== "object") return;
     const sid = context.sessionID;
     if (!sid) return;
 
     const parts = estimateBreakdownFromContext(context, sid);
+    // Tag the entry with the model whose payload was measured: a later in-session
+    // model switch must not keep showing this split (see breakdownForModel).
+    const reqModel = context.model;
+    const reqModelID =
+      reqModel &&
+      typeof reqModel === "object" &&
+      typeof reqModel.id === "string" &&
+      reqModel.id
+        ? reqModel.id
+        : "unknown";
     breakdownCache.set(sid, {
       ...parts,
       capturedAt: Date.now(),
       source: "context-hook",
+      model: reqModelID,
     });
     pruneMap(breakdownCache, MAX_TRACKED_SESSIONS);
 
@@ -404,17 +421,28 @@ function onV2Context(context) {
 // compact yet") on a session with no completed request — there is no measured
 // context to mark, so we only cache and skip the state write (no fake stale
 // badge).
-function onV2Compaction(context) {
+function onV2Compaction(context, ctx) {
   try {
     if (!context || typeof context !== "object") return;
     const sid = context.sessionID;
     if (!sid) return;
+    const directory = locationDirectory(ctx);
 
     const parts = estimateBreakdownFromContext(context, sid);
+    // Same model tag as the context hook (see onV2Context / breakdownForModel).
+    const reqModel = context.model;
+    const reqModelID =
+      reqModel &&
+      typeof reqModel === "object" &&
+      typeof reqModel.id === "string" &&
+      reqModel.id
+        ? reqModel.id
+        : "unknown";
     breakdownCache.set(sid, {
       ...parts,
       capturedAt: Date.now(),
       source: "compaction-hook",
+      model: reqModelID,
     });
     pruneMap(breakdownCache, MAX_TRACKED_SESSIONS);
 
@@ -437,6 +465,7 @@ function onV2Compaction(context) {
         lastKnownInput(sid),
         ctxTokens,
         lastKnownReasoning(sid),
+        directory,
       );
       const wrote = writeStateFile(
         sid,
@@ -449,6 +478,7 @@ function onV2Compaction(context) {
           compacted: true,
           cacheRead: lastKnownCacheRead(sid),
           cacheWrite: lastKnownCacheWrite(sid),
+          directory,
         },
       );
       // Arm the fallback guard for the trailing `session.compacted` event ONLY
@@ -620,6 +650,7 @@ async function ensureV2Breakdown(ctx, sessionID) {
           ...estimateBreakdownFromClientMessages(msgs),
           capturedAt: Date.now(),
           source: "client-context",
+          model: lastKnownModel(sessionID),
         });
         pruneMap(breakdownCache, MAX_TRACKED_SESSIONS);
       }
@@ -719,11 +750,11 @@ function stateEntryToBreakdown(entry) {
 
 // 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) {
+function buildLiveLinesV2(sessionID, modelID, providerID, inputTokens, ctxTokens, reasoningTokens, directory) {
   const lines = [];
   const ts = new Date().toISOString();
   const limit = getModelLimit(providerID, modelID);
-  const usableInfo = getUsableContext(providerID, modelID);
+  const usableInfo = getUsableContext(providerID, modelID, undefined, directory);
 
   // 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
@@ -738,7 +769,10 @@ function buildLiveLinesV2(sessionID, modelID, providerID, inputTokens, ctxTokens
   // 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 bd = breakdownForModel(sessionID, modelID);
+  // A breakdown measured for a DIFFERENT model is not this session's split any
+  // more: dropping it falls through to the state.json snapshot path below (which
+  // is model-consistent) or to the header-only path.
   let snapInputTokens = null;
   let snapCtxTokens = null;
   let snapAt = null;
@@ -906,6 +940,9 @@ function buildLiveLinesV2(sessionID, modelID, providerID, inputTokens, ctxTokens
 // V2 event handler. `event` is a V2Event ({ type, data, ... }).
 async function handleV2Event(ctx, event) {
   if (!event || typeof event.type !== "string") return;
+  // The instance's project directory scopes the configured compaction.buffer
+  // lookup (one process can host several plugin instances, one per location).
+  const directory = locationDirectory(ctx);
 
   // DEBUG tap (fault-tolerant, off via flag).
   debugEvent(event);
@@ -981,6 +1018,7 @@ async function handleV2Event(ctx, event) {
         lastKnownInput(sid),
         lastKnownCtx(sid),
         lastKnownReasoning(sid),
+        directory,
       );
       // The `compaction` HOOK already captured + persisted the exact
       // pre-compaction snapshot and marked the entry stale. This event is now a
@@ -1003,6 +1041,7 @@ async function handleV2Event(ctx, event) {
             compacted: true,
             cacheRead: lastKnownCacheRead(sid),
             cacheWrite: lastKnownCacheWrite(sid),
+            directory,
           },
         );
       }
@@ -1073,6 +1112,7 @@ async function handleV2Event(ctx, event) {
         lastKnownInput(sid),
         lastKnownCtx(sid),
         lastKnownReasoning(sid),
+        directory,
       );
       writeStateFile(
         sid,
@@ -1084,6 +1124,7 @@ async function handleV2Event(ctx, event) {
         {
           cacheRead: lastKnownCacheRead(sid),
           cacheWrite: lastKnownCacheWrite(sid),
+          directory,
         },
       );
       pushFinalSummary(`final:${event.id ?? sid}`, [
@@ -1185,6 +1226,7 @@ async function handleV2Event(ctx, event) {
           input,
           contextTokens,
           reasoning,
+          directory,
         );
         writeStateFile(
           sid,
@@ -1196,6 +1238,7 @@ async function handleV2Event(ctx, event) {
           {
             cacheRead: lastKnownCacheRead(sid),
             cacheWrite: lastKnownCacheWrite(sid),
+            directory,
           },
         );
         writeLog(lines);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-context-indicator",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "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",