@chenlongapps/opencode-token-usage 0.4.2 → 0.4.4

package/README.md

@@ -34,7 +34,7 @@ Alternatively, add the package to your project's `opencode.json` or `opencode.js
 ```
 
 > [!NOTE]
-> Requires Node.js 22+. OpenCode 2.0.9, 2.0.10, and 2.0.11 have been verified across project releases. The current SDK 2.0.11 build has been reverified on OpenCode 2.0.11.
+> Requires Node.js 22+. OpenCode 2.0.9, 2.0.10, and 2.0.11 have been verified across project releases. The current SDK 2.0.11 build has been reverified on OpenCode 2.0.11 and 2.0.22.
 
 Restart OpenCode after installation. The panel appears in the native sidebar when `session.sidebar` is set to `auto` and the terminal is wide enough. OpenCode hides the sidebar in subagent views, so the plugin keeps one live summary line above the composer with Context, Total, Cost, and TPS. Click the line to open the full statistics in a centered dialog. Press Escape or click **esc** to close it; closing the dialog does not interrupt the subagent.
 
@@ -42,7 +42,7 @@ For remote sessions, add the package name to `plugins` in your local `~/.config/
 
 ### Detailed usage
 
-Enter `/usage` in a session to open a native dialog with the session tree's token totals and estimated cost by recorded model. Scroll with ↑/↓, Page Up/Down, Home/End, press `d` to switch between compact and detailed numbers, and close with Escape. The command does not send a prompt to the model.
+Enter `/usage` in a session to open a native dialog with the session tree's token totals and estimated cost by recorded model. Scroll with ↑/↓, Page Up/Down, Home/End, press `d` to switch between compact and detailed numbers and reveal model rates, and close with Escape. The command does not send a prompt to the model.
 
 The subagent picker keeps the summary in the form `Token Usage · Context … · Total … · Cost … · TPS …`. Missing values remain unavailable rather than becoming zero, and the line does not advertise a keyboard shortcut. Clicking it opens a smaller dialog with the sidebar's exact rows (including Steps, TPS and TTFT) without reserving space for the full panel while closed.
 
@@ -54,11 +54,11 @@ The dialog is split into five sections with separate statistics:
 | Last Request | The five token categories and cache rate of the viewed session's most recent reported call |
 | Context Breakdown | Estimated prompt composition, largest first, with bars |
 | Session | Tree totals: steps, calls, tokens, cache rate, cost (single line, or per-category rows in detailed mode) |
-| By Model | Tokens, calls and cost per recorded model, highest cost first |
+| By Model | Tokens, calls and cost per recorded model, highest cost first; detailed mode shows the rates used for each model's cost estimate |
 
 One line under the title names the session and its active model, and the body never repeats the model name. Compact mode uses `K`/`M` abbreviations (`812`, `139.4K`, `3.70M`), hides empty rows and merges the two tool families in Context Breakdown into a single `Tools` row. Detailed mode shows exact numbers, empty rows, and the `System Tools` / `MCP Tools` split. The sidebar keeps exact numbers and its own layout.
 
-Costs follow the sidebar's pricing and `partial`/unavailable/free conventions. Context sections are unavailable until the viewed session has reported usage and a known context limit.
+Costs follow the sidebar's pricing and `partial`/unavailable/free conventions. In detailed mode, By Model shows the applied Input, Output, Reasoning, Cache Read and Cache Write rates in USD per million text tokens. Each rate group names its source (OpenCode or the built-in snapshot), incoming-token tier and call count; a model can have multiple groups. `Incoming` means Input + Cache Read + Cache Write. Missing rates show `—`, confirmed free rates show `$0.00`, and unpriced calls are counted separately. These are the current rates used to estimate recorded calls, not historical provider bills. Context sections are unavailable until the viewed session has reported usage and a known context limit.
 
 **Context Breakdown** separates Messages, System Tools, System Prompt, Skills, MCP Tools, and Other. It estimates the text and tool definitions in the viewed session's **latest assembled model request**; its percentages use the sum of those estimates. These are not provider-reported token counts and do not add up to the measured context window, which also includes output and reasoning. Media and provider-specific framing cannot be measured from the request. A server plugin records only aggregate estimates (not prompt text); sessions without a captured request or an available server RPC show “Source estimates unavailable”.
 
@@ -74,7 +74,7 @@ Costs follow the sidebar's pricing and `partial`/unavailable/free conventions. C
 | `Context` | Latest context usage after the most recent completed compaction in the viewed session; not aggregated across the subtree |
 | `Steps` | Assistant message count across the session tree, including subagents; follows OpenCode's own stats definition, so compaction and user messages are not steps |
 | `Est. Cost` | Estimated cost across the tree, pricing each assistant and compaction call with its actual model |
-| `TPS` | Generation throughput for `Output + Reasoning` across the tree; live estimates are marked with `~` |
+| `TPS` | Generation throughput for `Output + Reasoning` across the tree. While streaming, it estimates recent observable text, reasoning-summary and tool-input deltas (UTF-8 bytes / 4) over a short sliding window after the first delta, excluding pre-first-token waiting, and marks the value with `~`. APIs such as OpenAI Responses do not expose complete hidden reasoning tokens in real time, so live values cannot represent hidden reasoning throughput. After completion it uses provider-reported Output and Reasoning tokens and removes `~` |
 | `TTFT` | Average time to first token across measurable assistant steps in the tree |
 
 #### Behavior
@@ -86,6 +86,7 @@ Costs follow the sidebar's pricing and `partial`/unavailable/free conventions. C
 - `Est. Cost` prices every message with its recorded model. A complete non-zero price resolved by OpenCode takes precedence. If OpenCode reports a complete zero price, a complete first-party snapshot price overrides it; incomplete prices fall back for the whole message without mixing rates.
 - The checked-in fallback snapshot is generated from [models.dev](https://models.dev/api.json) using only reviewed first-party provider/model families; a small set of manufacturer-verified exceptions is kept separately. It covers priced text models, without downloading prices while the plugin runs. Gateway models match exact manufacturer IDs, documented aliases, and known wrappers; only a terminal `-free` or `:free` can be removed for a second exact lookup.
 - Confirmed free usage displays `$0.00`; unavailable prices display `—`; known subtotals with unpriced messages are marked `partial`. The snapshot excludes gateway markups, regional premiums, unlisted discounts, non-text billing, tool fees, and taxes, so Est. Cost is not a provider bill. See [price sources and limitations](docs/pricing.md).
+- Live `TPS` with `~` is an estimate from recent observable deltas after the first delta over a ~2s sliding window with light smoothing; it excludes TTFT and hidden-reasoning waits. Without `~` it is exact provider-reported `Output + Reasoning` throughput. No model-specific multipliers or hidden-reasoning guesses are applied.
 - Initial read failures display `Unavailable`. Later failures retain the last complete snapshot, display `Not updated`, and retry automatically.
 
 ### Development
@@ -104,6 +105,16 @@ For a manual refresh, run `npm run prices:update` in a networked environment, re
 
 `test:smoke` packages the real artifact and validates loading, refreshes, `/usage`, subagent aggregation, per-message pricing, first-party price fallback, model switching, TPS, and TTFT against an isolated OpenCode instance and a local mock provider. It requires Python 3, an available local port, and npm network access. It never modifies your existing OpenCode configuration or calls paid models.
 
+By default, smoke uses `opencode` from `PATH`. Stable OpenCode 2 versions from 2.0.9 onward can run; a host not yet verified with the current SDK prints a warning and continues through the actual compatibility checks. Passing the version check alone does not establish compatibility. The SDK dependencies remain pinned independently of your local CLI updates.
+
+To reproduce a baseline with a separately installed binary, without downgrading your normal installation:
+
+```bash
+OPENCODE_BIN=/absolute/path/to/opencode-2.0.11 npm run test:smoke
+```
+
+`OPENCODE_BIN` selects the same executable for the version check, isolated server, and TUI. Relative paths resolve from the directory where you run the command. The host version and selected binary are recorded in the smoke output and `result.json`; see the [verification record](docs/verification.md) for tested combinations.
+
 To load the plugin from source, build the project and add the repository's absolute path to `plugins` in the target project.
 
 ### Documentation

package/README.zh-CN.md

@@ -34,7 +34,7 @@ opencode plugin add @chenlongapps/opencode-token-usage
 ```
 
 > [!NOTE]
-> 需要 Node.js 22+。项目历次发布已验证 OpenCode 2.0.9、2.0.10 和 2.0.11；当前 SDK 2.0.11 构建已在 OpenCode 2.0.11 上重新验证。
+> 需要 Node.js 22+。项目历次发布已验证 OpenCode 2.0.9、2.0.10 和 2.0.11；当前 SDK 2.0.11 构建已在 OpenCode 2.0.11 和 2.0.22 上重新验证。
 
 安装后重启 OpenCode。终端足够宽且 `session.sidebar` 设为 `auto` 时，面板会显示在原生侧边栏中。OpenCode 在子代理视图中隐藏侧边栏，因此插件会在输入区上方保留一行实时摘要，显示 Context、Total、Cost 和 TPS。点击摘要可在居中弹窗中查看完整统计；按 Escape 或点击 **esc** 即可关闭，关闭弹窗不会中断子代理。
 
@@ -42,7 +42,7 @@ opencode plugin add @chenlongapps/opencode-token-usage
 
 ### 详细用量
 
-在会话中输入 `/usage`，可打开原生弹窗查看当前会话树的 token 总量，以及按消息实际模型汇总的估算费用。使用 ↑/↓、Page Up/Down、Home/End 滚动，按 `d` 切换紧凑／详细数字，Escape 关闭。该命令不会向模型发送消息。
+在会话中输入 `/usage`，可打开原生弹窗查看当前会话树的 token 总量，以及按消息实际模型汇总的估算费用。使用 ↑/↓、Page Up/Down、Home/End 滚动，按 `d` 切换紧凑／详细数字并查看模型费率，Escape 关闭。该命令不会向模型发送消息。
 
 子代理视图中的摘要格式为 `Token Usage · Context … · Total … · Cost … · TPS …`。缺失数据仍显示不可用，不会被当作零，摘要也不提示快捷键。点击后打开较小的弹窗，按侧边栏原有行序展示精确数值（包括 Steps、TPS 和 TTFT）；关闭时不会为完整面板预留高度。
 
@@ -54,11 +54,11 @@ opencode plugin add @chenlongapps/opencode-token-usage
 | Last Request | 被查看会话最近一次已上报调用的五类 token 与缓存命中率 |
 | Context Breakdown | 提示词构成估算，按占比降序排列并带条形图 |
 | Session | 全树汇总：steps、calls、tokens、缓存率与费用（紧凑模式为单行，详细模式逐类展开） |
-| By Model | 各模型的 tokens、calls 与费用，按费用降序 |
+| By Model | 各模型的 tokens、calls 与费用，按费用降序；详细模式显示用于估算各模型费用的费率 |
 
 标题下方一行注明会话与当前活动模型，正文不再重复模型名。紧凑模式使用 `K`/`M` 缩写（`812`、`139.4K`、`3.70M`），隐藏零值行，并把 Context Breakdown 中的两类工具合并为一行 `Tools`；详细模式显示精确数字、零值行及 `System Tools` / `MCP Tools` 拆分。侧边栏仍使用精确数字和原有布局。
 
-费用沿用侧边栏的价格及 `partial`、不可定价、免费口径。当前会话尚未上报用量或上下文上限未知时，上下文相关区域显示不可用。
+费用沿用侧边栏的价格及 `partial`、不可定价、免费口径。详细模式下，By Model 显示 Input、Output、Reasoning、Cache Read、Cache Write 的美元／百万文本 token 费率。每组费率注明来源（OpenCode 或内置快照）、传入 token 档位和调用数；同一模型可能有多组。传入 token 为 Input + Cache Read + Cache Write。缺失费率显示 `—`，确认免费显示 `$0.00`，无法定价的调用单独计数。这些是当前用于估算已记录调用的费率，不是历史提供商账单。当前会话尚未上报用量或上下文上限未知时，上下文相关区域显示不可用。
 
 弹窗中的 **Context Breakdown** 将消息、系统工具、系统提示词、技能、MCP 工具及其他分开展示。它根据被查看会话**最近一次已组装的模型请求**中的文本和工具定义估算，占比的分母是六项估算值之和；这些不是提供商上报的精确 token，也不会与上方含输出、推理的实测上下文窗口相加一致。媒体内容与提供商额外包装无法准确计量。服务端插件仅保存分类数值，不保存提示词正文；未捕获到请求或服务端 RPC 不可用时显示“来源估算不可用”。
 
@@ -74,7 +74,7 @@ opencode plugin add @chenlongapps/opencode-token-usage
 | `Context` | 当前会话最后一次已完成压缩后的最新上下文用量，不随子树累计 |
 | `Steps` | 全树（含子代理）的 assistant 消息数，口径与 OpenCode 自带统计一致，compaction 与用户消息不计为 step |
 | `Est. Cost` | 按每条 assistant 与 compaction 消息实际模型估算的全树费用 |
-| `TPS` | 全树 `Output + Reasoning` 的生成速度；生成中的估算值带 `~` 标记 |
+| `TPS` | 全树 `Output + Reasoning` 的生成吞吐。请求进行中时，插件根据首个流式增量之后最近的可观察文本、reasoning summary 和工具输入流（UTF-8 字节数 / 4）按短时间滑动窗口估算输出速度，不包含首 token 前等待时间，并以 `~` 标记。OpenAI Responses 等 API 不会实时暴露完整的隐藏 reasoning token，因此实时值不能表示隐藏推理吞吐。请求完成后，插件使用服务端上报的 Output 与 Reasoning token 及时间信息计算精确 TPS，并移除 `~` 标记 |
 | `TTFT` | 全树中可测 assistant step 的平均首 token 时间 |
 
 #### 行为
@@ -86,6 +86,7 @@ opencode plugin add @chenlongapps/opencode-token-usage
 - `Est. Cost` 按每条消息记录的实际模型分别计算。OpenCode 当前解析出的完整非零价格优先；若 OpenCode 给出完整零价，且内置价格快照可以完整计价，则采用快照价格。价格不完整时整条消息回退，不混用两套费率。
 - 内置回退快照从 [models.dev](https://models.dev/api.json) 生成，只采用审核过的原厂 Provider 与自家模型系列；少量经原厂核实的例外单独维护。快照覆盖有价格的文本模型，插件运行时不下载价格。网关模型通过精确原厂 ID、明确别名和已知包装格式匹配；只有终尾 `-free` 或 `:free` 会在再次精确查找前移除。
 - 确认免费时显示 `$0.00`；价格不可用时显示 `—`；只有部分消息可计算时在已知小计后标注 `partial`。快照不含网关加价、区域溢价、未列明的折扣、非文本计费、工具费和税费；Est. Cost 是估算而非账单。覆盖范围、来源和限制见[价格来源与限制](docs/pricing.md)。
+- 带 `~` 的实时 `TPS` 是首个流式增量之后约 2 秒滑动窗口内可观察增量的估算值（带轻度平滑），不包含 TTFT 与隐藏推理等待；不带 `~` 时为服务端上报的 `Output + Reasoning` 精确吞吐。不做模型专属倍率，也不猜测隐藏 reasoning token。
 - 首次读取失败显示 `Unavailable`；后续失败保留上次完整快照、标注 `Not updated` 并自动重试。
 
 ### 开发
@@ -104,6 +105,16 @@ npm run test:smoke
 
 `test:smoke` 会打包真实产物，并在隔离的 OpenCode 与本地模拟提供商中验证加载、刷新、`/usage`、子代理累计、逐消息计价、原厂价格补全、模型切换、TPS 和 TTFT。它需要 Python 3、可用的本地端口和 npm 网络访问，不会修改现有 OpenCode 配置或调用付费模型。
 
+默认使用 `PATH` 中的 `opencode`。OpenCode 2.0.9 及之后的稳定版 2.x 可以运行；尚未与当前 SDK 验证的宿主会输出警告，然后继续实际兼容性检查。仅通过版本检查不代表兼容性已验证。SDK 依赖仍独立锁定，不随本机 CLI 更新而自动升级。
+
+如需用独立安装的二进制复现基准，而不降级日常使用的安装：
+
+```bash
+OPENCODE_BIN=/absolute/path/to/opencode-2.0.11 npm run test:smoke
+```
+
+`OPENCODE_BIN` 为版本检查、隔离服务端和 TUI 统一选择同一个可执行文件。相对路径以执行命令时的目录为基准解析。smoke 输出和 `result.json` 会记录宿主版本与所选二进制；已测试组合见[验证记录](docs/verification.md)。
+
 从源码加载时，先构建项目，再将仓库绝对路径加入目标项目的 `plugins`。
 
 ### 文档

package/ROADMAP.md

@@ -101,10 +101,13 @@ Steps  1,234
 * [x] 紧凑数字（K/M）、来源条形图、Session 单行汇总、`d` 详细模式切换
 * [x] 子代理视图保留 Context、Total、Cost、TPS 单行摘要，点击打开可关闭的原生居中统计弹窗
 
+## v0.4.3 
+
+* [x] 在 `/usage` 中显示模型的定价信息。
+
 ## 后续评估
 
 * [x] 首次 npm 发布：`@chenlongapps/opencode-token-usage@0.2.1`
 
 ## 待解决问题
 
-* [ ] TPS 的实时计算：当前为近似值，后续考虑通过更精确的算法计算

package/dist/context-capture.d.ts

@@ -0,0 +1,43 @@
+import type { SessionContext } from "@opencode/plugin/promise/session";
+import type { Plugin } from "@opencode/plugin";
+import type { ContextSources } from "./context-sources.js";
+type Request = Pick<SessionContext, "sessionID" | "model" | "system" | "messages" | "tools">;
+type Mcp = {
+    list(): Promise<{
+        data: readonly {
+            name: string;
+        }[];
+    }>;
+};
+type Storage = Pick<Plugin.Context["storage"], "get" | "set" | "remove">;
+/** The hook awaits MCP metadata only on a cache miss; persistence follows the request. */
+export declare class ContextCapture {
+    private readonly mcp;
+    private readonly storage;
+    private readonly ttl;
+    private readonly now;
+    private readonly elapsed;
+    private names;
+    private expiresAt;
+    private listing;
+    private writes;
+    private inflight;
+    private latestEstimate;
+    private deleted;
+    readonly timings: {
+        requests: number;
+        mcpReads: number;
+        mcpWaitMs: number;
+        storageWrites: number;
+        storageWriteMs: number;
+    };
+    constructor(mcp: Mcp, storage: Storage, ttl?: number, now?: () => number, elapsed?: () => number);
+    private servers;
+    invalidateMcp(): void;
+    capture(request: Request): Promise<void>;
+    private record;
+    latest(sessionID: string): Promise<ContextSources | undefined>;
+    remove(sessionID: string): Promise<void>;
+    flush(): Promise<void>;
+}
+export {};

package/dist/context-capture.js

@@ -0,0 +1,111 @@
+import { estimateContextSources, parseContextSources } from "./context-sources.js";
+/** The hook awaits MCP metadata only on a cache miss; persistence follows the request. */
+export class ContextCapture {
+    mcp;
+    storage;
+    ttl;
+    now;
+    elapsed;
+    names;
+    expiresAt = 0;
+    listing;
+    writes = new Map();
+    inflight = new Map();
+    latestEstimate = new Map();
+    deleted = new Set();
+    timings = { requests: 0, mcpReads: 0, mcpWaitMs: 0, storageWrites: 0, storageWriteMs: 0 };
+    constructor(mcp, storage, ttl = 30_000, now = Date.now, elapsed = () => performance.now()) {
+        this.mcp = mcp;
+        this.storage = storage;
+        this.ttl = ttl;
+        this.now = now;
+        this.elapsed = elapsed;
+    }
+    async servers() {
+        if (this.names && this.now() < this.expiresAt)
+            return this.names;
+        if (!this.listing) {
+            this.timings.mcpReads++;
+            this.listing = this.mcp.list().then(result => {
+                this.names = result.data.map(server => server.name);
+                this.expiresAt = this.now() + this.ttl;
+                return this.names;
+            }).catch(error => {
+                if (this.names) {
+                    this.expiresAt = this.now() + this.ttl;
+                    return this.names;
+                }
+                throw error;
+            }).finally(() => { this.listing = undefined; });
+        }
+        return this.listing;
+    }
+    invalidateMcp() { this.expiresAt = 0; }
+    capture(request) {
+        const tasks = this.inflight.get(request.sessionID) ?? new Set();
+        this.inflight.set(request.sessionID, tasks);
+        const task = this.record(request);
+        tasks.add(task);
+        return task.finally(() => {
+            tasks.delete(task);
+            if (tasks.size === 0)
+                this.inflight.delete(request.sessionID);
+        });
+    }
+    async record(request) {
+        if (this.deleted.has(request.sessionID))
+            return;
+        const start = this.elapsed();
+        let names;
+        try {
+            names = await this.servers();
+        }
+        finally {
+            this.timings.requests++;
+            this.timings.mcpWaitMs += this.elapsed() - start;
+        }
+        if (this.deleted.has(request.sessionID))
+            return;
+        const value = estimateContextSources(request, names);
+        this.latestEstimate.set(request.sessionID, value);
+        const previous = this.writes.get(request.sessionID) ?? Promise.resolve();
+        const write = previous.catch(() => { }).then(async () => {
+            if (this.deleted.has(request.sessionID))
+                return;
+            const started = this.elapsed();
+            this.timings.storageWrites++;
+            try {
+                await this.storage.set(`context/${request.sessionID}`, {
+                    capturedAt: value.capturedAt, model: value.model, tokens: { ...value.tokens },
+                });
+            }
+            finally {
+                this.timings.storageWriteMs += this.elapsed() - started;
+            }
+        });
+        this.writes.set(request.sessionID, write);
+        void write.catch(() => { }).finally(() => {
+            if (this.writes.get(request.sessionID) === write)
+                this.writes.delete(request.sessionID);
+        });
+    }
+    async latest(sessionID) {
+        if (this.deleted.has(sessionID))
+            return undefined;
+        return this.latestEstimate.get(sessionID)
+            ?? parseContextSources(await this.storage.get(`context/${sessionID}`));
+    }
+    async remove(sessionID) {
+        this.deleted.add(sessionID);
+        if (this.deleted.size > 256)
+            this.deleted.delete(this.deleted.values().next().value);
+        this.latestEstimate.delete(sessionID);
+        await Promise.allSettled(this.inflight.get(sessionID) ?? []);
+        await this.writes.get(sessionID)?.catch(() => { });
+        await this.storage.remove(`context/${sessionID}`);
+    }
+    async flush() {
+        await Promise.allSettled([...this.inflight.values()].flatMap(tasks => [...tasks]));
+        await Promise.allSettled(this.writes.values());
+    }
+}

package/dist/controller.d.ts

@@ -40,6 +40,9 @@ export declare class UsageController {
     private retry;
     private performanceTimer;
     private sessions;
+    private changed;
+    private fullScan;
+    private prepared;
     private pending;
     private disposed;
     private unsubscribe;
@@ -49,6 +52,7 @@ export declare class UsageController {
     constructor(source: UsageSource, subscribe: Subscribe, publish: (state: UsageState) => void, delay?: number, retryDelay?: number, performanceDelay?: number, performance?: PerformanceMonitor, detailed?: boolean);
     select(sessionID: string): void;
     refresh(): void;
+    private schedule;
     dispose(): void;
     private update;
     private refreshPerformance;

package/dist/controller.js

@@ -1,11 +1,12 @@
 import { loadSnapshot, uniqueMessages, viewedMessages } from "./source.js";
-import { PerformanceMonitor } from "./performance.js";
+import { PerformanceMonitor, preparePerformance } from "./performance.js";
 import { contextDetails, summarize, summarizeModels } from "./usage.js";
 const sessionEvents = new Set([
     "session.created", "session.deleted", "session.forked", "session.moved",
     "session.model.selected", "session.agent.selected", "session.step.ended", "session.step.failed",
     "session.compaction.ended", "session.compaction.failed", "session.message.content.updated",
     "session.usage.recorded", "session.usage.updated", "session.revert.committed",
+    "session.revert.staged", "session.revert.cleared",
     "session.execution.succeeded", "session.execution.failed", "session.execution.interrupted",
 ]);
 const globalEvents = new Set([
@@ -29,6 +30,9 @@ export class UsageController {
     retry;
     performanceTimer;
     sessions = new Set();
+    changed = new Set();
+    fullScan = true;
+    prepared;
     pending = false;
     disposed = false;
     unsubscribe;
@@ -50,18 +54,27 @@ export class UsageController {
         });
         this.unsubscribe = subscribe(event => {
             const data = (event.data && typeof event.data === "object" ? event.data : {});
-            if (event.type === "session.created" && data.sessionID && data.parentID && this.sessions.has(data.parentID)) {
-                this.sessions.add(data.sessionID);
-            }
-            if (event.type === "session.deleted" && data.sessionID)
-                this.sessions.delete(data.sessionID);
             if (globalEvents.has(event.type))
                 return this.refresh();
             if (!sessionEvents.has(event.type))
                 return;
-            if (!this.snapshot || event.type === "session.created" || event.type === "session.forked"
-                || data.sessionID === this.sessionID || (data.sessionID && this.snapshot.sessions.has(data.sessionID)))
-                this.refresh();
+            if (event.type === "session.created") {
+                if (data.sessionID && data.parentID && (this.sessions.has(data.parentID) || data.parentID === this.sessionID)) {
+                    this.sessions.add(data.sessionID); // Stream updates can precede discovery.
+                    this.schedule(false);
+                }
+                else if (data.sessionID === this.sessionID)
+                    this.schedule(false);
+                return;
+            }
+            const related = data.sessionID === this.sessionID || !!(data.sessionID && this.sessions.has(data.sessionID));
+            if (!related)
+                return;
+            if (event.type === "session.deleted" && data.sessionID)
+                this.sessions.delete(data.sessionID);
+            if (data.sessionID)
+                this.changed.add(data.sessionID);
+            this.schedule(event.type === "session.moved");
         });
     }
     select(sessionID) {
@@ -77,14 +90,22 @@ export class UsageController {
         this.performanceTimer = undefined;
         this.pending = false;
         this.snapshot = undefined;
+        this.prepared = undefined;
         this.sessions.clear();
+        this.changed.clear();
+        this.fullScan = true;
         this.sessionID = sessionID;
         this.update({ status: "loading" });
         void this.run();
     }
     refresh() {
+        this.schedule(true);
+    }
+    schedule(full) {
         if (this.disposed || !this.sessionID)
             return;
+        if (full)
+            this.fullScan = true;
         clearTimeout(this.retry);
         if (this.request) {
             this.pending = true;
@@ -117,7 +138,8 @@ export class UsageController {
             this.performanceTimer = undefined;
             if (this.disposed || !this.snapshot || !this.state.summary)
                 return;
-            this.update({ ...this.state, performance: this.performance.summary(uniqueMessages(this.snapshot), this.sessions) });
+            if (this.prepared)
+                this.update({ ...this.state, performance: this.performance.summaryPrepared(this.prepared, this.sessions) });
         }, this.performanceDelay);
     }
     async run() {
@@ -126,24 +148,29 @@ export class UsageController {
         const generation = this.generation;
         const request = new AbortController();
         this.request = request;
+        const full = this.fullScan;
+        const changed = new Set(this.changed);
+        this.fullScan = false;
+        this.changed.clear();
         try {
             const signal = AbortSignal.any([request.signal, AbortSignal.timeout(30_000)]);
-            const snapshot = await loadSnapshot(this.source, this.sessionID, signal);
+            const snapshot = await loadSnapshot(this.source, this.sessionID, signal, full ? undefined : this.snapshot, full ? undefined : changed);
             if (this.disposed || generation !== this.generation)
                 return;
             this.snapshot = snapshot;
             const messages = [...uniqueMessages(snapshot)];
             this.sessions = new Set(snapshot.sessions.keys());
             this.performance.reconcile(messages, this.sessions);
+            this.prepared = preparePerformance(messages);
             clearTimeout(this.performanceTimer);
             this.performanceTimer = undefined;
-            const context = contextDetails(viewedMessages(snapshot), snapshot.model.context);
+            const context = contextDetails(viewedMessages(snapshot), snapshot.model.context, snapshot.sessions.get(snapshot.viewedID)?.revert?.messageID);
             this.update({
                 status: "ready",
                 summary: summarize(messages, snapshot.model.catalog),
                 context: context?.usage,
                 ...(this.detailed ? { details: { context, models: summarizeModels(messages, snapshot.model.catalog), sessionTitle: snapshot.sessions.get(snapshot.viewedID)?.title } } : {}),
-                performance: this.performance.summary(messages, this.sessions),
+                performance: this.performance.summaryPrepared(this.prepared, this.sessions),
                 model: snapshot.model.label,
             });
             // The server plugin may be absent. An optional RPC must not delay measured usage.
@@ -160,15 +187,16 @@ export class UsageController {
         catch {
             if (this.disposed || generation !== this.generation)
                 return;
+            this.fullScan = true;
             this.update({ ...this.state, status: this.state.summary ? "stale" : "unavailable" });
-            this.retry = setTimeout(() => this.refresh(), this.retryDelay);
+            this.retry = setTimeout(() => this.schedule(false), this.retryDelay);
         }
         finally {
             if (generation === this.generation && !this.disposed) {
                 this.request = undefined;
                 if (this.pending) {
                     this.pending = false;
-                    this.refresh();
+                    this.schedule(false);
                 }
             }
         }

package/dist/index.js

@@ -1,27 +1,48 @@
 import { Plugin } from "@opencode/plugin";
-import { estimateContextSources, parseContextSources } from "./context-sources.js";
+import { ContextCapture } from "./context-capture.js";
 import { ContextSourceRpc } from "./context-rpc.js";
 export default Plugin.define({
     id: "opencode-token-usage",
     async setup(context) {
+        const capture = new ContextCapture(context.mcp, context.storage);
         const rpc = await context.rpc.register(ContextSourceRpc, {
             latest: async (input) => {
                 const sessionID = input.sessionID;
-                return { estimate: parseContextSources(await context.storage.get(`context/${sessionID}`)) ?? null };
+                return { estimate: await capture.latest(sessionID) ?? null };
             },
         });
         const hook = await context.session.hook("context", async (request) => {
             try {
-                const servers = (await context.mcp.list()).data.map(server => server.name);
-                const estimate = estimateContextSources(request, servers);
-                await context.storage.set(`context/${request.sessionID}`, {
-                    capturedAt: estimate.capturedAt, model: estimate.model, tokens: { ...estimate.tokens },
-                });
+                await capture.capture(request);
             }
             catch {
                 // Instrumentation must not interrupt the model call.
             }
         });
-        return async () => { await hook.dispose(); await rpc.dispose(); };
+        const stop = new AbortController();
+        const events = (async () => {
+            try {
+                for await (const event of context.event.subscribe({ signal: stop.signal })) {
+                    if (event.type === "session.deleted") {
+                        try {
+                            await capture.remove(event.data.sessionID);
+                        }
+                        catch { /* Keep processing later events. */ }
+                    }
+                    if (event.type === "mcp.status.changed" || event.type === "mcp.resources.changed")
+                        capture.invalidateMcp();
+                }
+            }
+            catch {
+                // A disconnect or shutdown must not affect model requests.
+            }
+        })();
+        return async () => {
+            stop.abort();
+            await hook.dispose();
+            await capture.flush();
+            await rpc.dispose();
+            void events;
+        };
     },
 });

package/dist/performance.d.ts

@@ -17,10 +17,28 @@ export interface PerformanceEvent {
     id?: string;
     created?: number;
 }
+export interface StreamSample {
+    time: number;
+    bytes: number;
+}
+export declare const LIVE_WINDOW_MS = 2000;
+export declare const LIVE_EWMA_ALPHA = 0.35;
+export declare const LIVE_BYTES_PER_TOKEN = 4;
+/** Raw live throughput from one step's recent observable deltas. */
+export declare function estimatedLiveTps(samples: readonly StreamSample[]): number | undefined;
+export declare function smoothLiveTps(previous: number | undefined, raw: number): number;
+export interface PreparedPerformance {
+    tps?: number;
+    ttftSum: number;
+    ttftCount: number;
+    historical: ReadonlyMap<string, number>;
+}
 export type PerformanceSubscribe = (listener: (event: PerformanceEvent) => void) => () => void;
 export type PerformanceListener = (sessionID: string) => void;
 /** Exact completed-run TPS and the average of only measurable TTFT samples. */
 export declare function historicalPerformance(messages: Iterable<UsageMessage>, observations?: Iterable<FirstTokenObservation>): PerformanceSummary;
+/** The immutable part of a snapshot is scanned once, then reused for stream updates. */
+export declare function preparePerformance(messages: Iterable<UsageMessage>): PreparedPerformance;
 /** Captures streaming performance for every session for one plugin lifetime. */
 export declare class PerformanceMonitor {
     private readonly retention;
@@ -42,4 +60,5 @@ export declare class PerformanceMonitor {
     handle(event: PerformanceEvent): boolean;
     reconcile(messages: Iterable<UsageMessage>, sessionIDs: Iterable<string>): void;
     summary(messages: Iterable<UsageMessage>, sessionIDs: Iterable<string>): PerformanceSummary;
+    summaryPrepared(prepared: PreparedPerformance, sessionIDs: Iterable<string>): PerformanceSummary;
 }