opencode-context-indicator 1.7.1 → 1.8.1

package/lib/config.js

@@ -0,0 +1,228 @@
+// lib/config.js
+//
+// Reads the ONE opencode setting the plugin cannot obtain through the plugin
+// API: `compaction.buffer` (opencode 2.2.5+, a token count or a percentage such
+// as "20%"). Core applies it in calculateCeiling(); a plugin only sees the
+// resulting model limits, so the reserve has to be mirrored from the user's own
+// config file.
+//
+// The plugin has NO runtime dependencies (see README "Live sidebar"), so the
+// JSONC reader is a small in-file scanner instead of a parser package:
+//   - strips // line and /* block */ comments OUTSIDE strings,
+//   - drops a trailing comma before } or ] OUTSIDE strings,
+//   - understands strings with escapes so "a//b" and "/*" survive.
+// That covers the shapes opencode itself accepts (opencode.jsonc is JSONC).
+//
+// Precedence mirrors opencode: the project config wins over the global one; the
+// env var OPENCODE_CONTEXT_INDICATOR_COMPACT_BUFFER still wins over both (it is
+// a testing/power-user override, resolved in lib/limits.js). A buffer that is
+// not smaller than the window is ignored by the caller, exactly like core.
+//
+// The directory is an ARGUMENT, never module state: one server process can host
+// several plugin instances (one per location), so a single "current project"
+// variable would leak project A's buffer into project B's measurement. Callers
+// pass `ctx.location.directory` (see locationDirectory) or nothing for the
+// global-only lookup.
+//
+// The file is read on demand and re-parsed only when its mtime/size changes, so
+// the 1 s tick never turns this into a hot loop.
+
+import { readFileSync, statSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+// path -> { mtimeMs, size, entry }; entry = { ok: true, value } | { ok: false }
+const fileCache = new Map()
+
+// The project directory a V2 plugin context belongs to, or "" when the host did
+// not give one. Accepts any object with a `location.directory` string.
+export function locationDirectory(ctx) {
+  try {
+    const dir = ctx?.location?.directory
+    return typeof dir === "string" && dir.length > 0 ? dir : ""
+  } catch {
+    return ""
+  }
+}
+
+// Global config directory, same resolution opencode uses on every platform.
+function globalConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME
+  const base = typeof xdg === "string" && xdg.length > 0 ? xdg : join(homedir(), ".config")
+  return join(base, "opencode")
+}
+
+// Drop a trailing comma (one followed only by whitespace and } or ]). This is a
+// second string-aware pass: a plain regex would also rewrite `"a,}"` INSIDE a
+// string value, silently changing it.
+function dropTrailingCommas(text) {
+  let out = ""
+  let inString = false
+  let escaped = false
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]
+    if (inString) {
+      out += ch
+      if (escaped) escaped = false
+      else if (ch === "\\") escaped = true
+      else if (ch === '"') inString = false
+      continue
+    }
+    if (ch === '"') {
+      inString = true
+      out += ch
+      continue
+    }
+    if (ch === ",") {
+      let j = i + 1
+      while (j < text.length && /\s/.test(text[j])) j++
+      if (text[j] === "}" || text[j] === "]") continue // drop the comma only
+    }
+    out += ch
+  }
+  return out
+}
+
+// Strip comments and trailing commas from a JSONC document. The scanner is
+// string-aware: `//` or `/*` inside a string value is left untouched.
+export function stripJsonc(text) {
+  if (typeof text !== "string") return ""
+  let out = ""
+  let inString = false
+  let escaped = false
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]
+    if (inString) {
+      out += ch
+      if (escaped) {
+        escaped = false
+      } else if (ch === "\\") {
+        escaped = true
+      } else if (ch === '"') {
+        inString = false
+      }
+      continue
+    }
+    if (ch === '"') {
+      inString = true
+      out += ch
+      continue
+    }
+    if (ch === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++
+      out += "\n"
+      continue
+    }
+    if (ch === "/" && text[i + 1] === "*") {
+      i += 2
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++
+      i++ // skip the closing "/"
+      continue
+    }
+    out += ch
+  }
+  return dropTrailingCommas(out)
+}
+
+// Parse a JSONC file with caching. Returns { ok, value } (never throws).
+function readJsoncFile(path) {
+  let stat
+  try {
+    stat = statSync(path)
+  } catch {
+    return { ok: false }
+  }
+  const cached = fileCache.get(path)
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+    return cached.entry
+  }
+  let entry
+  try {
+    const parsed = JSON.parse(stripJsonc(readFileSync(path, "utf8")))
+    entry = { ok: true, value: parsed }
+  } catch {
+    // A malformed config is the host's problem to report; the plugin simply
+    // falls back to the default reserve rather than guessing.
+    entry = { ok: false }
+  }
+  fileCache.set(path, { mtimeMs: stat.mtimeMs, size: stat.size, entry })
+  return entry
+}
+
+// Candidate files for one config directory, in opencode's own precedence.
+function configFiles(dir) {
+  return [
+    join(dir, "opencode.jsonc"),
+    join(dir, "opencode.json"),
+    join(dir, ".opencode", "opencode.jsonc"),
+    join(dir, ".opencode", "opencode.json"),
+  ]
+}
+
+function bufferFromFile(path) {
+  const read = readJsoncFile(path)
+  if (!read.ok) return { found: false }
+  const root = read.value && typeof read.value === "object" ? read.value : null
+  const compaction = root && typeof root.compaction === "object" && root.compaction ? root.compaction : null
+  if (!compaction || !Object.prototype.hasOwnProperty.call(compaction, "buffer")) {
+    return { found: false }
+  }
+  return { found: true, value: compaction.buffer, source: path }
+}
+
+// Resolve the effective `compaction.buffer`. Project beats global; inside one
+// directory the first existing file wins (that is how opencode picks a file).
+// Returns { value, source } where value may be undefined when nobody set it.
+export function resolveCompactionBuffer(directory) {
+  const globalDir = globalConfigDir()
+  const dirs = [globalDir]
+  if (typeof directory === "string" && directory.length > 0 && directory !== globalDir) {
+    dirs.push(directory)
+  }
+
+  let result = { value: undefined, source: undefined }
+  for (const configDir of dirs) {
+    for (const path of configFiles(configDir)) {
+      const hit = bufferFromFile(path)
+      if (hit.found) {
+        result = { value: hit.value, source: hit.source }
+        break
+      }
+      // A file that exists but has no buffer still ends the search in this
+      // directory only if it exists; otherwise keep looking at the next name.
+      let exists = true
+      try {
+        statSync(path)
+      } catch {
+        exists = false
+      }
+      if (exists) break
+    }
+  }
+  return result
+}
+
+// Convert a configured buffer to tokens for a given window. Accepts the two
+// shapes opencode 2.2.5 accepts (`NonNegativeInt` and a 1%-99% string) and
+// returns undefined for anything else - the caller then keeps the default 15%
+// formula, exactly like core ignoring an unusable buffer. The integer/1e9
+// bounds match the env override in lib/limits.js so both paths reject the same
+// shapes.
+export function bufferTokens(window, raw) {
+  if (typeof raw === "number") {
+    return Number.isInteger(raw) && raw >= 0 && raw <= 1e9 ? raw : undefined
+  }
+  if (typeof raw !== "string") return undefined
+  const match = /^([1-9]\d?(?:\.\d+)?)%$/.exec(raw)
+  if (!match) return undefined
+  const percent = Number.parseFloat(match[1])
+  if (!Number.isFinite(percent) || percent <= 0 || percent >= 100) return undefined
+  if (typeof window !== "number" || !Number.isFinite(window) || window <= 0) return undefined
+  return Math.round((window * percent) / 100)
+}
+
+// Test-only: drop the parse cache so a rewritten fixture is re-read on the same
+// mtime granularity (Windows FAT timestamps are coarse).
+export function resetConfigCache() {
+  fileCache.clear()
+}

package/lib/contributors.js

@@ -1,6 +1,7 @@
 // lib/contributors.js
 //
-// Pure contributor-measurement helpers extracted from tui.tsx for unit testing.
+// Pure contributor-measurement helpers extracted from the TUI panel (lib/tui-panel.ts)
+// for unit testing.
 // All functions are stateless transforms of their arguments.
 //
 // Functions: asRecord, safeText, measureContributors, contributorLine,
@@ -185,7 +186,7 @@ function exportFileName(sessionID, now) {
 }
 
 // Build the redacted export payload. All IO (mkdirSync/writeFileSync) and
-// toasts stay in tui.tsx as the thin exportRedacted() wrapper.
+// toasts stay in lib/tui-panel.ts as the thin exportRedacted() wrapper.
 //
 // Fields: generatedAt, session{id8-prefixed id, model, providerID},
 // family[role/model/ctx/usable/limit/pct/updated], contributors[kind/tool/ref/
@@ -193,7 +194,7 @@ function exportFileName(sessionID, now) {
 // content, NO contributor preview text.
 //
 // panelDenom / panelRole are passed as parameters so this file stays pure and
-// tui.tsx controls their source.
+// lib/tui-panel.ts controls their source.
 function buildRedactedPayload({ sessionID, root, rows, contributors, now, panelDenom, panelRole, num }) {
   const id8 = String(sessionID).slice(0, 8);
   return {
@@ -227,7 +228,7 @@ function buildRedactedPayload({ sessionID, root, rows, contributors, now, panelD
 }
 
 // ---------------------------------------------------------------------------
-// Panel helpers (pure, shared with tui.tsx)
+// Panel helpers (pure, shared with lib/tui-panel.ts)
 // ---------------------------------------------------------------------------
 
 // Per-row denominator with the same fallback cascade as the server table:

package/lib/limits.js

@@ -10,21 +10,27 @@
 // Compaction ceiling (opencode calculateCeiling): opencode's core
 // calculateCeiling() in packages/core/src/session/compaction.ts derives the
 // auto-compaction trigger ceiling as window - reserve, where
-// window = limit.input || limit.context (null/zero falls through to the context
-// window) and
+//   window = input && context ? min(input, context) : input || context
+// (null/zero falls through; since opencode 2.2.5 (#60660) an input limit ABOVE
+// the context window is capped at the context window, because the context also
+// holds the reply) and
 //   reserve = max(floor(window * 0.15), window >= 2 * 16_000 ? 16_000 : 0)
-// `RESERVE_SHARE = 0.15` in every RELEASED host from 2.1.4 through 2.2.2
+// `RESERVE_SHARE = 0.15` in every RELEASED host from 2.1.4 through 2.2.5
 // (verified tag by tag; the `2 * RESERVE_MIN` gate is older and unchanged). The
 // unreleased `v2` branch HEAD has an inline `0.1` instead - do NOT mirror a
 // branch head: a wrong reserve makes every displayed percentage wrong.
-// A compaction.buffer configured in opencode itself is NOT visible to the
-// plugin (the plugin cannot read opencode's internal compaction config); the
-// env var OPENCODE_CONTEXT_INDICATOR_COMPACT_BUFFER overrides the reserve for
-// testing and power users only (non-negative finite integer <= 1e9, ignore invalid).
-// Like core, a buffer that is NOT smaller than the window is ignored: a buffer
-// set for a larger model must never leave zero room.
+// A compaction.buffer configured in opencode itself is NOT exposed through the
+// plugin API, so lib/config.js reads the user's own config file and this module
+// applies it as the reserve. Precedence: the env var
+// OPENCODE_CONTEXT_INDICATOR_COMPACT_BUFFER (testing / power users) wins, then
+// the configured buffer, then the 15% default.
+// opencode 2.2.5 accepts a token count or a percentage ("buffer": "20%"); both
+// are converted with Math.round(window * pct / 100), matching core. Like core, a
+// buffer that is NOT smaller than the window is ignored: a buffer set for a
+// larger model must never leave zero room.
 
 import { finitePos, withTimeout } from "./estimate.js";
+import { bufferTokens, resolveCompactionBuffer } from "./config.js";
 import { logErr, readStateSnapshot } from "./state.js";
 
 const PROVIDERS_TTL_MS = 5 * 60 * 1000; // providers()/model.list() cache TTL after SUCCESS
@@ -86,7 +92,7 @@ function getModelLimit(providerID, modelID) {
 
 // Compute the reserve for a given window, matching opencode's
 // packages/core/src/session/compaction.ts calculateCeiling() as RELEASED
-// (RESERVE_SHARE = 0.15 in 2.1.4 .. 2.2.2; the branch head is not a release).
+// (RESERVE_SHARE = 0.15 in 2.1.4 .. 2.2.5; the branch head is not a release).
 // Returns null when
 // window is not a finite positive number.
 const RESERVE_SHARE = 0.15; // core: RESERVE_SHARE in every released 2.x
@@ -117,17 +123,60 @@ function reserveFor(window, bufferOverride) {
   );
 }
 
+// ---------------------------------------------------------------------------
+// Configured compaction.buffer (opencode 2.2.5+), cached per project directory.
+// ---------------------------------------------------------------------------
+
+// getUsableContext runs on every measured request and on every command/panel
+// build, so the config file must not be stat()ed four times per call. One
+// second is far below a human edit cycle and keeps a config change visible
+// almost immediately. The cache is keyed by the caller's project directory: one
+// server process can host several plugin instances (one per location) and the
+// shared module must not apply project A's buffer to project B.
+const CONFIGURED_BUFFER_TTL_MS = 1000;
+const configuredBufferCache = new Map(); // dirKey -> { at, value }
+
+function configuredCompactionBuffer(directory) {
+  const key = typeof directory === "string" ? directory : "";
+  const now = Date.now();
+  const cached = configuredBufferCache.get(key);
+  if (cached && now - cached.at < CONFIGURED_BUFFER_TTL_MS) return cached.value;
+  let value;
+  try {
+    value = resolveCompactionBuffer(key).value;
+  } catch {
+    value = undefined;
+  }
+  configuredBufferCache.set(key, { at: now, value });
+  return value;
+}
+
+// Test-only: forget the TTL cache so a rewritten fixture is picked up by the
+// next call.
+function resetConfiguredBufferCache() {
+  configuredBufferCache.clear();
+}
+
 // Native opencode compaction ceiling (calculateCeiling, released 2.x):
-//   window = limit.input || limit.context  (zero/null falls through to context)
+//   window = input && context ? min(input, context) : input || context
 //   reserve = reserveFor(window)  [or bufferOverride when provided]
 //   usable  = window - reserve
 // Returns { usable, limit: window, maxOutput, reserved } or null when not
 // derivable (callers then degrade to count / limit.context, or no percentage).
 // The per-model compaction.reserved and the old min(20000, maxOutput) no longer
-// participate in this calculation; opencode's internal buffer is not visible.
-// The buffer override (env or argument) replaces the whole reserve only while
-// it is smaller than the window — a buffer >= window falls back to the share.
-function getUsableContext(providerID, modelID, bufferOverride) {
+// participate in this calculation. The reserve comes from (in order) the
+// argument, the env override, the user's configured compaction.buffer (see
+// lib/config.js) or the 15% share, and replaces the whole reserve only while it
+// is smaller than the window - a buffer >= window falls back to the share.
+//
+// The min() is opencode 2.2.5 (#60660): a provider that reports an input limit
+// ABOVE the context window cannot use it in full, because the context also holds
+// the reply. Using input alone would overstate the denominator (and show a
+// compact-at point the host never reaches).
+//
+// `directory` is the calling instance's project directory (ctx.location); it
+// scopes the configured-buffer lookup. Omitted means global config only.
+function getUsableContext(providerID, modelID, bufferOverride, directory) {
   const rec = getModelLimitRecord(providerID, modelID);
   if (!rec) return null;
   const context =
@@ -135,13 +184,18 @@ function getUsableContext(providerID, modelID, bufferOverride) {
   const input =
     typeof rec.input === "number" && rec.input > 0 ? rec.input : null;
   if (input == null && context == null) return null;
-  // Mirror core's limit.input || limit.context (zero/null falls through to context).
-  const window = input != null && input > 0 ? input : context;
+  // Mirror core's inputWindow(): min(input, context) when both are known.
+  // The `??` is core's `||` here: a non-positive input was normalized to null
+  // above, so there is no 0 to fall through.
+  const window =
+    input != null && context != null ? Math.min(input, context) : input ?? context;
   if (window == null || !(window > 0)) return null;
 
   // When bufferOverride is omitted, read it from the env var once per call.
   let resolvedBuffer = bufferOverride;
-  if (resolvedBuffer === undefined) {
+  if (resolvedBuffer !== undefined) {
+    // explicit argument wins over everything
+  } else {
     const raw = process.env.OPENCODE_CONTEXT_INDICATOR_COMPACT_BUFFER;
     // Strict digits-only: reject "5000abc", "5e3", " 5000", "", "-1" and other
     // partial parses (parseInt/parseFloat stop at the first non-digit).
@@ -152,6 +206,13 @@ function getUsableContext(providerID, modelID, bufferOverride) {
       }
     }
   }
+  // No env override: use opencode's own compaction.buffer when the user set one.
+  if (resolvedBuffer === undefined) {
+    const configured = configuredCompactionBuffer(directory);
+    if (configured !== undefined) {
+      resolvedBuffer = bufferTokens(window, configured);
+    }
+  }
 
   const reserve = reserveFor(window, resolvedBuffer);
   if (reserve == null) return null;
@@ -469,6 +530,7 @@ export {
   getModelLimit,
   getUsableContext,
   reserveFor,
+  resetConfiguredBufferCache,
   ensureProviderLimits,
   ensureModelLimits,
   hydrateModelLimitsFromState,

package/lib/state.js

@@ -60,7 +60,7 @@ const LOG_FILE =
   process.env.OPENCODE_CONTEXT_INDICATOR_LOG_FILE ||
   join(tmpdir(), "context-breakdown.log");
 
-// Machine-readable snapshot consumed by the optional TUI sidebar (./tui.tsx,
+// Machine-readable snapshot consumed by the optional TUI sidebar (./tui.ts,
 // package entry "./tui"). Written next to each log update — same moment, same
 // data. See writeStateFile() below.
 // State file path — overridable via env for test isolation.
@@ -417,7 +417,7 @@ function renameWithRetry(from, to, attempts = 3, delayMs = 50) {
 // TUI state bridge (opencode-context-indicator)
 // ---------------------------------------------------------------------------
 // Persist a tiny machine-readable snapshot of the CURRENT breakdown for one
-// session so the optional TUI sidebar (./tui.tsx, package entry "./tui") can
+// session so the optional TUI sidebar (./tui.ts, package entry "./tui") can
 // render it without talking to the server. The file is one JSON object keyed by
 // sessionID, rewritten atomically (temp + rename) at every log write — same
 // moment, same data. Strictly additive: any failure is swallowed and must never
@@ -459,10 +459,11 @@ function writeStateFile(
     }
     try {
       const bd = breakdownCache.get(sessionID) || null;
-      const usableInfo = getUsableContext(providerID, modelID);
-      // Persist the EFFECTIVE window (limit.input || limit.context — the same
-      // window the ceiling was derived from), not the raw context window: on a
-      // cold instance hydrateModelLimitsFromState seeds context = limit, so a
+      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
+      // hydrateModelLimitsFromState seeds context = limit, so a
       // mismatched limit would re-derive a WRONG (too large) ceiling for models
       // where limit.input < limit.context.
       const limit =

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,7 +54,16 @@ export interface StateEntry {
 
 export declare const STATE_FILE: string
 export declare const POLL_MS: number
-export declare function isNodeModulesInstall(): boolean
+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>,

package/lib/tui-data.js

@@ -1,13 +1,13 @@
 // lib/tui-data.js
 //
-// Data layer for the TUI entry (tui.tsx): the state.json bridge (readSnapshot /
+// Data layer for the TUI entry (tui.ts): 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.
+// / updatedAt) and the family walk. Plain JS with JSDoc — same shape as
+// lib/contributors.js — so tui.ts stays a thin setup shell and the node tooling
+// (resolve gate, 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
+// bridges those modules only for the plugin bundle, and keeping this file pure
 // means it also loads anywhere node does.
 //
 // state.json shape (written by writeStateFile() in index.js, untrusted input):
@@ -20,7 +20,6 @@
 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";
 import { fmt, num } from "./format.js";
 
@@ -38,21 +37,6 @@ export const STATE_FILE =
 
 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
-  }
-}
-
 // 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
@@ -147,3 +131,37 @@ export function updatedAt(iso) {
     return "?"
   }
 }
+
+// ---------------------------------------------------------------------------
+// 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,
+  };
+}