@serkanalgur/opencodev2-slim 2.0.11 → 2.0.13

package/README.md

@@ -141,6 +141,20 @@ Note: Compression is performed by the AI assistant using the `compress` tool. Th
 
 ## Changelog
 
+### 2.0.13
+
+- Fix `/panel` in the TUI not reflecting real context usage:
+  - The TUI command now reads live server measurements (`Session.Info.tokens` + `cost` + `model` + context window) via `context.client.session.get()` and prints them (measured tokens, %, cost, model) at the bottom of the panel, matching what the `panel` tool reports.
+  - Resolve the active session from `context.ui.router.current()` instead of a non-existent `context.router`, so the panel targets the focused session rather than always the first one.
+  - Call `context.data.session.message.sync()` before reading the transcript so stats aren't computed from an empty/stale cache.
+
+### 2.0.12
+
+- Bind panel/nudge to real OpenCode context measurements:
+  - Resolve the active model's real context window from `ctx.model.default().data.limit.context` instead of the hard-coded 200k.
+  - `/panel` now reads live server measurements (`Session.Info.tokens` + `cost`) via `ctx.session.get()` and feeds them to `buildPanelData`, so the headline tokens/percent/cost match what OpenCode's UI reports.
+  - The nudge decision prefers the measured token count over the rough 4-char estimation.
+
 ### 2.0.11
 
 - Fix CI publish: add `solid-js`, `@opentui/core`, `@opentui/solid` to `devDependencies`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serkanalgur/opencodev2-slim",
-  "version": "2.0.11",
+  "version": "2.0.13",
   "description": "Smart context management plugin for OpenCode v2 - semantic compression, cost-aware pruning, adaptive thresholds",
   "keywords": [
     "opencode",

package/src/index.ts

@@ -36,20 +36,13 @@ function getConfig(sessionId: string): SlimConfig {
 }
 
 // Resolve the active model's real context limit instead of hard-coding 200k.
+// ctx.model.default() returns { data: ModelInfo | null }, where ModelInfo.limit.context
+// holds the model's context window. Use it directly and only fall back when missing.
 async function resolveModelContextLimit(ctx: any): Promise<number> {
     try {
-        const models: any[] = await ctx.model.list()
-        const selected: { providerID?: string; modelID?: string } | undefined =
+        const selected: { data?: { limit?: { context?: number } } | null } | undefined =
             await ctx.model.default()
-        const match =
-            models.find(
-                (m) =>
-                    (selected?.modelID && m.id === selected.modelID) ||
-                    (selected?.providerID && m.providerID === selected.providerID),
-            ) ||
-            models.find((m) => m.limit?.context) ||
-            undefined
-        const limit = match?.limit?.context
+        const limit = selected?.data?.limit?.context
         return typeof limit === "number" && limit > 0 ? limit : DEFAULT_MODEL_LIMIT
     } catch {
         return DEFAULT_MODEL_LIMIT
@@ -300,6 +293,31 @@ export default Plugin.define({
                     const state = getState(sessionId, config)
 
                     try {
+                        // Pull the real, server-measured context usage for this session.
+                        let measured: import("./lib/tui").MeasuredContext | undefined
+                        try {
+                            const info = await ctx.session.get({ sessionID: sessionId })
+                            const tokens = info.tokens as any
+                            const tokenCount =
+                                (tokens?.input ?? 0) +
+                                (tokens?.output ?? 0) +
+                                (tokens?.reasoning ?? 0) +
+                                (tokens?.cache?.read ?? 0) +
+                                (tokens?.cache?.write ?? 0)
+                            measured = {
+                                tokens: tokenCount,
+                                cost: typeof info.cost === "number" ? info.cost : 0,
+                                contextLimit:
+                                    state.modelContextLimit || (await resolveModelContextLimit(ctx)),
+                                model: (info.model && (info.model as any).id) || "unknown",
+                            }
+                            // Keep state's headline figure aligned with reality.
+                            state.modelContextLimit = measured.contextLimit
+                            state.currentTokenCount = measured.tokens
+                        } catch {
+                            // Fall through to estimation if session.get fails.
+                        }
+
                         const messages = await ctx.session.context({ sessionID: sessionId })
 
                         if (!messages || messages.length === 0) {
@@ -315,9 +333,12 @@ export default Plugin.define({
                             messageWithParts,
                             state,
                             config,
+                            measured?.model,
+                            measured,
                         )
 
                         const panel = renderPanel(panelData)
+                        saveSessionState(state, config.persistence.directory)
                         return { content: panel }
                     } catch (error) {
                         return {
@@ -367,19 +388,24 @@ export default Plugin.define({
                 }
             }
 
-            // Quick token estimate (sync, ~4 chars per token)
-            let totalTokens = 0
+            // Quick token estimate (sync, ~4 chars per token). On the first pass
+            // (before the panel has written real numbers into state) this is a
+            // fallback; afterwards we prefer the server-measured value.
+            let estimatedTokens = 0
             for (const msg of event.messages) {
                 const content = (msg as any).content
                 if (Array.isArray(content)) {
                     for (const part of content) {
                         if (part.type === "text" && part.text) {
-                            totalTokens += Math.ceil(part.text.length / 4)
+                            estimatedTokens += Math.ceil(part.text.length / 4)
                         }
                     }
                 }
             }
 
+            // Prefer the real measured token count when available; else the estimate.
+            const totalTokens =
+                state.currentTokenCount > 0 ? state.currentTokenCount : estimatedTokens
             state.currentTokenCount = totalTokens
 
             const maxTokens = resolveTokenLimit(

package/src/lib/tui.ts

@@ -50,17 +50,30 @@ export interface PanelData {
 
 // ─── Panel Builder ─────────────────────────────────────────────────────────
 
+export interface MeasuredContext {
+    /** Real context input tokens for this session (Session.Info.tokens.input). */
+    tokens: number
+    /** Real total spend for this session (Session.Info.cost). */
+    cost: number
+    /** Real model context window (Model.Info.limit.context). */
+    contextLimit: number
+    /** Real model id. */
+    model: string
+}
+
 export async function buildPanelData(
     sessionId: string,
     messages: MessageWithParts[],
     state: SessionState,
     config: SlimConfig,
     modelId?: string,
+    measured?: MeasuredContext,
 ): Promise<PanelData> {
-    const modelContextLimit = state.modelContextLimit || 200000
+    // Prefer the real model context window from the server; fall back to state/default.
+    const modelContextLimit = measured?.contextLimit || state.modelContextLimit || 200000
     const maxTokens = resolveTokenLimit(config.compress.maxContextLimit, modelContextLimit)
     
-    // Count tokens
+    // Count tokens (estimation for role breakdown; real total used for usage %).
     let currentTokens = 0
     const tokensByRole = { user: 0, assistant: 0, tools: 0, system: 0 }
     let userMessages = 0
@@ -102,8 +115,15 @@ export async function buildPanelData(
     tokensByRole.tools = Math.max(tokensByRole.tools, 0)
     tokensByRole.system = Math.max(0, currentTokens - tokensByRole.user - tokensByRole.assistant - tokensByRole.tools)
     
-    // Calculate status
-    const usagePercent = (currentTokens / maxTokens) * 100
+    // Prefer the server-measured real token count for the headline usage figure.
+    // Role buckets remain our estimate for breakdown detail.
+    const effectiveTokens = measured?.tokens ?? currentTokens
+    
+    // Usage % shown to the user is relative to the real model context window
+    // (e.g. 220k / 1M = 22%), matching what OpenCode's own UI displays. The
+    // configured maxTokens (a percentage of that same window) drives nudge/compress.
+    const usageBase = measured?.contextLimit ? modelContextLimit : modelContextLimit
+    const usagePercent = (effectiveTokens / modelContextLimit) * 100
     let status: "healthy" | "warning" | "critical" = "healthy"
     if (usagePercent > 90) status = "critical"
     else if (usagePercent > 70) status = "warning"
@@ -121,9 +141,9 @@ export async function buildPanelData(
         ? state.compressionHistory[state.compressionHistory.length - 1]
         : null
     
-    // Cost estimate
+    // Cost: prefer the server-measured real spend; else estimate from tokens.
     const profile = COST_PROFILES[modelId || "default"] || COST_PROFILES.default
-    const estimatedCost = (currentTokens / 1000) * profile.inputPricePer1k
+    const estimatedCost = measured?.cost ?? (currentTokens / 1000) * profile.inputPricePer1k
     const costSaved = (totalTokensSaved / 1000) * profile.inputPricePer1k
     
     // Topic distribution
@@ -155,7 +175,7 @@ export async function buildPanelData(
     return {
         sessionId,
         timestamp: Date.now(),
-        currentTokens,
+        currentTokens: effectiveTokens,
         maxTokens,
         usagePercent,
         status,
@@ -171,7 +191,7 @@ export async function buildPanelData(
         lastCompression,
         estimatedCost,
         costSaved,
-        model: modelId || "unknown",
+        model: measured?.model || modelId || "unknown",
         topics,
         recommendations,
     }

package/src/tui.tsx

@@ -94,7 +94,14 @@ export function deriveStats(messages: readonly unknown[]): PanelStats {
 }
 
 // Builds a human-readable panel as plain text (injected into the message stream).
-function renderPanelText(sessionID: string, stats: PanelStats): string {
+function renderPanelText(
+    sessionID: string,
+    stats: PanelStats,
+    real?: MeasuredReal | null,
+): string {
+    const limit = real?.contextLimit ?? 0
+    const pct = real?.usagePercent ?? 0
+    const status = real ? (pct >= 90 ? "critical" : pct >= 70 ? "warning" : "healthy") : "n/a"
     const lines: string[] = []
     lines.push("┌─────────────────────────────────────────────────────────────┐")
     lines.push("│                    SLIM CONTEXT PANEL                       │")
@@ -107,22 +114,67 @@ function renderPanelText(sessionID: string, stats: PanelStats): string {
     lines.push(`│   Tool calls: ${stats.toolCalls}  Compactions: ${stats.compactionCount}`)
     lines.push(`│ Tokens (est): User ${stats.tokensByRole.user} | Assistant ${stats.tokensByRole.assistant} | System ${stats.tokensByRole.system}`)
     lines.push(`│ Total token estimate: ${stats.totalTokens}`)
+    if (real) {
+        lines.push("├─────────────────────────────────────────────────────────────┤")
+        lines.push(`│ Measured tokens: ${real.tokens}  (${pct}% of ${limit})  [${status}]`)
+        if (real.cost > 0) lines.push(`│ Cost: $${real.cost.toFixed(6)}`)
+        lines.push(`│ Model: ${real.model}`)
+    }
     lines.push("└─────────────────────────────────────────────────────────────┘")
     return lines.join("\n")
 }
 
-// Resolves the "current" session: the focused session if any, else the most recent.
+// Resolves the "current" session: the router-focused session if any, else the most recent.
 function resolveCurrentSession(context: any): string | null {
     const sessions = context.data.session.list() || []
     if (sessions.length === 0) return null
-    // Prefer the focused session if exposed; otherwise fall back to the first.
-    const focused = context.router?.current?.()
-    if (focused && typeof focused === "object" && "sessionID" in focused) {
-        return focused.sessionID as string
+    // The TUI host exposes the active route via context.ui.router (not context.router).
+    const route = context.ui?.router?.current?.()
+    if (route && typeof route === "object" && "sessionID" in route) {
+        return route.sessionID as string
     }
     return sessions[0].id
 }
 
+// Server-measured context numbers for a session (Session.Info.tokens + cost + model),
+// mirroring what the `panel` tool in index.ts reads via ctx.session.get().
+interface MeasuredReal {
+    tokens: number
+    cost: number
+    contextLimit: number
+    model: string
+    usagePercent: number
+}
+
+async function measureSession(context: any, sessionID: string): Promise<MeasuredReal | null> {
+    try {
+        const info: any = await context.client.session.get({ sessionID })
+        if (!info) return null
+        const tokens: any = info.tokens ?? {}
+        const tokenCount =
+            (typeof tokens.input === "number" ? tokens.input : 0) +
+            (typeof tokens.output === "number" ? tokens.output : 0) +
+            (typeof tokens.reasoning === "number" ? tokens.reasoning : 0) +
+            (typeof tokens.cache?.read === "number" ? tokens.cache.read : 0) +
+            (typeof tokens.cache?.write === "number" ? tokens.cache.write : 0)
+        const contextLimit: number =
+            typeof info.model?.limit?.context === "number" && info.model.limit.context > 0
+                ? info.model.limit.context
+                : 200000
+        const usagePercent =
+            contextLimit > 0 ? Math.min(100, Math.round((tokenCount / contextLimit) * 100)) : 0
+        return {
+            tokens: tokenCount,
+            cost: typeof info.cost === "number" ? info.cost : 0,
+            contextLimit,
+            model: info.model?.id || "unknown",
+            usagePercent,
+        }
+    } catch {
+        return null
+    }
+}
+
 export default Plugin.define({
     id: "opencodev2-slim.cli",
     setup(context) {
@@ -160,10 +212,14 @@ export default Plugin.define({
                                 }
 
                                 try {
+                                    // Make sure the cached transcript is loaded before reading it.
+                                    await context.data.session.message.sync(sessionID)
                                     const messages =
                                         context.data.session.message.list(sessionID) || []
+                                    // Prefer live server-measured context numbers when available.
+                                    const real = await measureSession(context, sessionID)
                                     const stats = deriveStats(messages)
-                                    const text = renderPanelText(sessionID, stats)
+                                    const text = renderPanelText(sessionID, stats, real)
                                     // Inject the panel as plain text into the session stream,
                                     // so it doesn't take over OpenCode's own panel UI.
                                     await context.client.session.synthetic({