@chenlongapps/opencode-token-usage 0.2.2 → 0.2.4

package/README.md

@@ -1,40 +1,30 @@
-# opencode-token-usage
-
-[![npm version](https://img.shields.io/npm/v/%40chenlongapps%2Fopencode-token-usage?logo=npm)](https://www.npmjs.com/package/@chenlongapps/opencode-token-usage)
-[![OpenCode 2](https://img.shields.io/badge/OpenCode-2-5A67D8)](https://opencode.ai/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-
-面向 **OpenCode 2** 的 token 用量插件。在原生 TUI 中显示整棵会话树（含子代理）的 token、估算费用与性能指标，以及当前会话的上下文占用。
-
-## 预览
-
-```text
-Token Usage
-Context        9,810 / 128,000 (7.7%)
-Input                          54,200
-Output                          6,800
-Reasoning                       4,100
-Cache Read                     31,700
-Cache Write                     1,300
-Cache Rate                      36.4%
-Total                          98,100
-Cost                            $0.21
-
-TPS                         48.7 tok/s
-TTFT                              2.7s
-```
+<h1 align="center">opencode-token-usage</h1>
+
+<p align="center">A session-tree token usage monitor for OpenCode 2.</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@chenlongapps/opencode-token-usage"><img alt="npm" src="https://img.shields.io/npm/v/%40chenlongapps%2Fopencode-token-usage?style=flat-square&logo=npm" /></a>
+  <a href="https://opencode.ai/"><img alt="OpenCode 2" src="https://img.shields.io/badge/OpenCode-2-5A67D8?style=flat-square" /></a>
+  <a href="https://github.com/chenlongapps/opencode-token-usage/actions/workflows/ci.yml"><img alt="CI" src="https://img.shields.io/github/actions/workflow/status/chenlongapps/opencode-token-usage/ci.yml?style=flat-square&branch=main&label=ci" /></a>
+  <a href="LICENSE"><img alt="MIT License" src="https://img.shields.io/badge/license-MIT-yellow?style=flat-square" /></a>
+</p>
+
+<p align="center">
+  <strong>English</strong> |
+  <a href="https://github.com/chenlongapps/opencode-token-usage/blob/main/README.zh-CN.md">简体中文</a>
+</p>
 
-实际价格与上下文上限取自当前会话的活动模型。
+[![OpenCode Token Usage plugin preview](https://raw.githubusercontent.com/chenlongapps/opencode-token-usage/main/docs/assets/opencode-token-usage-preview.webp)](https://www.npmjs.com/package/@chenlongapps/opencode-token-usage)
 
-## 安装
+---
 
-推荐使用 OpenCode 安装：
+### Installation
 
 ```bash
 opencode plugin add @chenlongapps/opencode-token-usage
 ```
 
-也可以在项目的 `opencode.json` 或 `opencode.jsonc` 中配置：
+Alternatively, add the package to your project's `opencode.json` or `opencode.jsonc`:
 
 ```json
 {
@@ -42,33 +32,36 @@ opencode plugin add @chenlongapps/opencode-token-usage
 }
 ```
 
-安装后重启 OpenCode。主会话中的面板位于原生侧边栏；终端需要足够宽，且 `session.sidebar` 应设为 `auto`。宿主在子代理视图中隐藏侧边栏，因此插件会在输入区上方显示同一面板。
+> [!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.
 
-连接远程服务器时，可将包名加入本机 `~/.config/opencode/cli.json` 的 `plugins`，仅加载终端入口；配置路径遵循 `XDG_CONFIG_HOME`。
+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 renders the same panel above the composer instead.
 
-## 指标口径
+For remote sessions, add the package name to `plugins` in your local `~/.config/opencode/cli.json` to load only the terminal entry point. The configuration path follows `XDG_CONFIG_HOME`.
 
-| 指标 | 定义 |
+### Metrics
+
+| Metric | Definition |
 | --- | --- |
-| `Input` | 输入 token，不含缓存读取和写入 |
-| `Output` | 输出 token，不含推理 token |
-| `Reasoning` | 推理 token |
+| `Input` | Input tokens, excluding cache reads and writes |
+| `Output` | Output tokens, excluding reasoning tokens |
+| `Reasoning` | Reasoning tokens |
 | `Cache Rate` | `Cache Read ÷ (Input + Cache Read + Cache Write)` |
-| `Total` | 五类 token 之和 |
-| `Context` | 当前会话最后一次已完成压缩后的最新上下文用量，不随子树累计 |
-| `Cost` | 按当前会话活动模型重新估算的全树费用，不代表提供商账单 |
-| `TPS` | 全树 `Output + Reasoning` 的生成速度；生成中显示 `~` 估算值，完成后显示精确值 |
-| `TTFT` | 全树中可测 assistant step 的平均首 token 时间 |
+| `Total` | Sum of all five token categories |
+| `Context` | Latest context usage after the most recent completed compaction in the viewed session; not aggregated across the subtree |
+| `Cost` | Estimated cost for the entire tree, recalculated using the viewed session's active model; not a provider bill |
+| `TPS` | Generation throughput for `Output + Reasoning` across the tree; live estimates are marked with `~` |
+| `TTFT` | Average time to first token across measurable assistant steps in the tree |
 
-补充说明：
+#### Behavior
 
-- 用量覆盖当前会话树中的 assistant 与 compaction 消息，包括未打开的子代理；只使用服务端上报值，不按文本长度估算。
-- 分叉会话是独立会话树。继承消息副本只归原始来源，避免重复计费。
-- `Context` 仅搜索最后一次 `status === "completed"` 的 compaction 之后；没有可靠用量或模型上限时隐藏。
-- `Cost` 使用每条消息的传入 token 选择价格档位，`Output` 与 `Reasoning` 使用输出价格。缺失适用价格时按 OpenCode 官方行为回退为 0。
-- 首次读取失败显示 `Unavailable`；后续刷新失败保留上次完整快照、标注 `Not updated` 并自动重试。
+- Usage includes server-reported assistant and compaction messages throughout the session tree, including unopened subagents. Token counts are never inferred from text length.
+- A fork is a separate session tree. Inherited message copies are attributed only to their original source to prevent double counting.
+- `Context` only searches messages after the most recent compaction with `status === "completed"` and is hidden when reliable usage or a model context limit is unavailable.
+- `Cost` applies the viewed session's active model to the whole tree. Missing applicable prices fall back to 0, matching OpenCode's behavior.
+- Initial read failures display `Unavailable`. Later failures retain the last complete snapshot, display `Not updated`, and retry automatically.
 
-## 开发
+### Development
 
 ```bash
 npm ci
@@ -78,23 +71,24 @@ npm run build
 npm run test:smoke
 ```
 
-`test:smoke` 会打包真实产物，并在隔离的 OpenCode 与本地模拟提供商中验证加载、刷新、子代理累计、模型切换、TPS 和 TTFT。它需要 Python 3、可用的本地端口和 npm 网络访问，不会修改现有 OpenCode 配置或调用付费模型。
+`test:smoke` packages the real artifact and validates loading, refreshes, subagent aggregation, 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.
+
+To load the plugin from source, build the project and add the repository's absolute path to `plugins` in the target project.
+
+### Documentation
 
-从源码加载时，先构建项目，再将仓库绝对路径加入目标项目的 `plugins`。根目录入口会转发到已编译的 ESM 产物。
+- [Roadmap](ROADMAP.md)
+- [Verification record](docs/verification.md)
+- [Release guide](docs/releasing.md)
+- [OpenCode 2 plugin documentation](https://opencode.ai/v2/docs/build/plugins/)
+- [OpenCode 2 CLI plugin API](https://opencode.ai/v2/docs/build/plugins/cli/)
 
-- [路线图](ROADMAP.md)
-- [验证记录](docs/verification.md)
-- [发布说明](docs/releasing.md)
+The implementation follows OpenCode's [TokenUsage schema](https://github.com/anomalyco/opencode/blob/v2/packages/schema/src/token-usage.ts), [cost calculation](https://github.com/anomalyco/opencode/blob/v2/packages/core/src/session/usage.ts), and [fork history projection](https://github.com/anomalyco/opencode/blob/v2/packages/core/src/session/projector.ts).
 
-## 接口依据
+### Disclaimer
 
-- [OpenCode 2 插件开发](https://opencode.ai/v2/docs/build/plugins/)
-- [OpenCode 2 CLI 插件接口](https://opencode.ai/v2/docs/build/plugins/cli/)
-- [CLI 设置](https://opencode.ai/v2/docs/cli/config/)
-- [TokenUsage 定义](https://github.com/anomalyco/opencode/blob/v2/packages/schema/src/token-usage.ts)
-- [官方计费实现](https://github.com/anomalyco/opencode/blob/v2/packages/core/src/session/usage.ts)
-- [分叉历史投影](https://github.com/anomalyco/opencode/blob/v2/packages/core/src/session/projector.ts)
+This is an independent community plugin. It is not built, maintained, or endorsed by the OpenCode team.
 
-## 许可证
+### License
 
 [MIT](LICENSE)

package/README.zh-CN.md

@@ -0,0 +1,94 @@
+<h1 align="center">opencode-token-usage</h1>
+
+<p align="center">面向 OpenCode 2 的会话树 token 用量监视器。</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@chenlongapps/opencode-token-usage"><img alt="npm" src="https://img.shields.io/npm/v/%40chenlongapps%2Fopencode-token-usage?style=flat-square&logo=npm" /></a>
+  <a href="https://opencode.ai/"><img alt="OpenCode 2" src="https://img.shields.io/badge/OpenCode-2-5A67D8?style=flat-square" /></a>
+  <a href="https://github.com/chenlongapps/opencode-token-usage/actions/workflows/ci.yml"><img alt="CI" src="https://img.shields.io/github/actions/workflow/status/chenlongapps/opencode-token-usage/ci.yml?style=flat-square&branch=main&label=ci" /></a>
+  <a href="LICENSE"><img alt="MIT License" src="https://img.shields.io/badge/license-MIT-yellow?style=flat-square" /></a>
+</p>
+
+<p align="center">
+  <a href="README.md">English</a> |
+  <strong>简体中文</strong>
+</p>
+
+[![OpenCode Token Usage 插件预览](https://raw.githubusercontent.com/chenlongapps/opencode-token-usage/main/docs/assets/opencode-token-usage-preview.webp)](https://www.npmjs.com/package/@chenlongapps/opencode-token-usage)
+
+---
+
+### 安装
+
+```bash
+opencode plugin add @chenlongapps/opencode-token-usage
+```
+
+也可以在项目的 `opencode.json` 或 `opencode.jsonc` 中配置：
+
+```json
+{
+  "plugins": ["@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 上重新验证。
+
+安装后重启 OpenCode。终端足够宽且 `session.sidebar` 设为 `auto` 时，面板会显示在原生侧边栏中。OpenCode 在子代理视图中隐藏侧边栏，因此插件会在输入区上方显示同一面板。
+
+连接远程服务器时，可将包名加入本机 `~/.config/opencode/cli.json` 的 `plugins`，仅加载终端入口；配置路径遵循 `XDG_CONFIG_HOME`。
+
+### 指标
+
+| 指标 | 定义 |
+| --- | --- |
+| `Input` | 输入 token，不含缓存读取和写入 |
+| `Output` | 输出 token，不含推理 token |
+| `Reasoning` | 推理 token |
+| `Cache Rate` | `Cache Read ÷ (Input + Cache Read + Cache Write)` |
+| `Total` | 五类 token 之和 |
+| `Context` | 当前会话最后一次已完成压缩后的最新上下文用量，不随子树累计 |
+| `Cost` | 按当前会话活动模型重新估算的全树费用，不代表提供商账单 |
+| `TPS` | 全树 `Output + Reasoning` 的生成速度；生成中的估算值带 `~` 标记 |
+| `TTFT` | 全树中可测 assistant step 的平均首 token 时间 |
+
+#### 行为
+
+- 用量覆盖会话树中服务端上报的 assistant 与 compaction 消息，包括未打开的子代理；不按文本长度估算 token。
+- 分叉会话是独立会话树。继承消息副本只归原始来源，避免重复计费。
+- `Context` 仅搜索最后一次 `status === "completed"` 的 compaction 之后；没有可靠用量或模型上限时隐藏。
+- `Cost` 使用当前查看会话的活动模型重算整棵树；缺失适用价格时按 OpenCode 行为回退为 0。
+- 首次读取失败显示 `Unavailable`；后续失败保留上次完整快照、标注 `Not updated` 并自动重试。
+
+### 开发
+
+```bash
+npm ci
+npm run typecheck
+npm test
+npm run build
+npm run test:smoke
+```
+
+`test:smoke` 会打包真实产物，并在隔离的 OpenCode 与本地模拟提供商中验证加载、刷新、子代理累计、模型切换、TPS 和 TTFT。它需要 Python 3、可用的本地端口和 npm 网络访问，不会修改现有 OpenCode 配置或调用付费模型。
+
+从源码加载时，先构建项目，再将仓库绝对路径加入目标项目的 `plugins`。
+
+### 文档
+
+- [路线图](ROADMAP.md)
+- [验证记录](docs/verification.md)
+- [发布说明](docs/releasing.md)
+- [OpenCode 2 插件开发文档](https://opencode.ai/v2/docs/build/plugins/)
+- [OpenCode 2 CLI 插件接口](https://opencode.ai/v2/docs/build/plugins/cli/)
+
+实现遵循 OpenCode 的 [TokenUsage 定义](https://github.com/anomalyco/opencode/blob/v2/packages/schema/src/token-usage.ts)、[官方计费实现](https://github.com/anomalyco/opencode/blob/v2/packages/core/src/session/usage.ts)和[分叉历史投影](https://github.com/anomalyco/opencode/blob/v2/packages/core/src/session/projector.ts)。
+
+### 声明
+
+这是一个独立的社区插件，并非由 OpenCode 团队构建、维护或认可。
+
+### 许可证
+
+[MIT](LICENSE)

package/ROADMAP.md

@@ -59,6 +59,7 @@ TTFT  2.7s
 目标：提供可查询的价格目录，便于用户了解不同模型的计费档位。
 
 * [ ] 构建公开价格目录，包含模型、价格档位及阈值
+* [ ] 只收录半年内发布的模型
 <!-- TODO -->
 
 ## v0.4.0 — 用量命令

package/dist/controller.d.ts

@@ -1,4 +1,5 @@
 import type { UsageSource } from "./source.js";
+import { PerformanceMonitor } from "./performance.js";
 import type { PerformanceSummary } from "./performance.js";
 import type { ContextUsage, Summary } from "./usage.js";
 export interface UsageState {
@@ -30,11 +31,14 @@ export declare class UsageController {
     private timer;
     private retry;
     private performanceTimer;
+    private sessions;
     private pending;
     private disposed;
     private unsubscribe;
+    private readonly unsubscribePerformance;
     private readonly performance;
-    constructor(source: UsageSource, subscribe: Subscribe, publish: (state: UsageState) => void, delay?: number, retryDelay?: number, performanceDelay?: number);
+    private readonly ownsPerformance;
+    constructor(source: UsageSource, subscribe: Subscribe, publish: (state: UsageState) => void, delay?: number, retryDelay?: number, performanceDelay?: number, performance?: PerformanceMonitor);
     select(sessionID: string): void;
     refresh(): void;
     dispose(): void;

package/dist/controller.js

@@ -1,10 +1,6 @@
 import { loadSnapshot, uniqueMessages, viewedMessages } from "./source.js";
-import { PerformanceTracker } from "./performance.js";
+import { PerformanceMonitor } from "./performance.js";
 import { contextUsage, summarize } from "./usage.js";
-const performanceEvents = new Set([
-    "session.step.started", "session.step.streamed", "session.step.ended", "session.step.failed",
-    "session.text.delta", "session.reasoning.delta", "session.tool.input.delta",
-]);
 const sessionEvents = new Set([
     "session.created", "session.deleted", "session.forked", "session.moved",
     "session.model.selected", "session.agent.selected", "session.step.ended", "session.step.failed",
@@ -31,22 +27,32 @@ export class UsageController {
     timer;
     retry;
     performanceTimer;
+    sessions = new Set();
     pending = false;
     disposed = false;
     unsubscribe;
-    performance = new PerformanceTracker();
-    constructor(source, subscribe, publish, delay = 80, retryDelay = 3_000, performanceDelay = 100) {
+    unsubscribePerformance;
+    performance;
+    ownsPerformance;
+    constructor(source, subscribe, publish, delay = 80, retryDelay = 3_000, performanceDelay = 100, performance) {
         this.source = source;
         this.publish = publish;
         this.delay = delay;
         this.retryDelay = retryDelay;
         this.performanceDelay = performanceDelay;
+        this.ownsPerformance = performance === undefined;
+        this.performance = performance ?? new PerformanceMonitor(subscribe);
+        this.unsubscribePerformance = this.performance.listen(sessionID => {
+            if (this.sessions.has(sessionID))
+                this.refreshPerformance();
+        });
         this.unsubscribe = subscribe(event => {
             const data = (event.data && typeof event.data === "object" ? event.data : {});
-            if (event.type === "session.created")
-                this.performance.addSession(data.sessionID, data.parentID);
-            if (performanceEvents.has(event.type) && this.performance.handle(event))
-                this.refreshPerformance();
+            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))
@@ -69,6 +75,7 @@ export class UsageController {
         this.performanceTimer = undefined;
         this.pending = false;
         this.snapshot = undefined;
+        this.sessions.clear();
         this.sessionID = sessionID;
         this.update({ status: "loading" });
         void this.run();
@@ -95,7 +102,10 @@ export class UsageController {
         clearTimeout(this.timer);
         clearTimeout(this.retry);
         clearTimeout(this.performanceTimer);
+        this.unsubscribePerformance();
         this.unsubscribe();
+        if (this.ownsPerformance)
+            this.performance.dispose();
     }
     update(state) { this.state = state; this.publish(state); }
     refreshPerformance() {
@@ -105,7 +115,7 @@ 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.update({ ...this.state, performance: this.performance.summary(uniqueMessages(this.snapshot), this.sessions) });
         }, this.performanceDelay);
     }
     async run() {
@@ -121,15 +131,15 @@ export class UsageController {
                 return;
             this.snapshot = snapshot;
             const messages = [...uniqueMessages(snapshot)];
-            this.performance.setTree(snapshot.rootID, snapshot.sessions.keys());
-            this.performance.reconcile(messages);
+            this.sessions = new Set(snapshot.sessions.keys());
+            this.performance.reconcile(messages, this.sessions);
             clearTimeout(this.performanceTimer);
             this.performanceTimer = undefined;
             this.update({
                 status: "ready",
                 summary: summarize(messages, snapshot.model.prices),
                 context: contextUsage(viewedMessages(snapshot), snapshot.model.context),
-                performance: this.performance.summary(messages),
+                performance: this.performance.summary(messages, this.sessions),
                 model: snapshot.model.label,
             });
         }

package/dist/performance.d.ts

@@ -17,17 +17,29 @@ export interface PerformanceEvent {
     id?: string;
     created?: 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;
-/** Tracks ephemeral streaming events without fetching the full session tree. */
-export declare class PerformanceTracker {
-    private rootID;
-    private sessions;
+/** Captures streaming performance for every session for one plugin lifetime. */
+export declare class PerformanceMonitor {
+    private readonly retention;
+    private readonly now;
     private active;
     private observed;
-    setTree(rootID: string, sessionIDs: Iterable<string>): void;
-    addSession(sessionID: string | undefined, parentID: string | undefined): void;
+    private listeners;
+    private cleanupTimer;
+    private disposed;
+    private readonly unsubscribe;
+    constructor(subscribe?: PerformanceSubscribe, retention?: number, now?: () => number);
+    listen(listener: PerformanceListener): () => void;
+    dispose(): void;
+    private key;
+    private publish;
+    private deleteSession;
+    private prune;
+    private scheduleCleanup;
     handle(event: PerformanceEvent): boolean;
-    reconcile(messages: Iterable<UsageMessage>): void;
-    summary(messages: Iterable<UsageMessage>): PerformanceSummary;
+    reconcile(messages: Iterable<UsageMessage>, sessionIDs: Iterable<string>): void;
+    summary(messages: Iterable<UsageMessage>, sessionIDs: Iterable<string>): PerformanceSummary;
 }

package/dist/performance.js

@@ -68,56 +68,134 @@ export function historicalPerformance(messages, observations = []) {
         result.ttft = ttft / ttftSamples;
     return result;
 }
-/** Tracks ephemeral streaming events without fetching the full session tree. */
-export class PerformanceTracker {
-    rootID;
-    sessions = new Set();
+/** Captures streaming performance for every session for one plugin lifetime. */
+export class PerformanceMonitor {
+    retention;
+    now;
     active = new Map();
     observed = new Map();
-    setTree(rootID, sessionIDs) {
-        if (this.rootID !== rootID) {
-            this.active.clear();
-            this.observed.clear();
-            this.rootID = rootID;
-        }
-        this.sessions = new Set(sessionIDs);
-        for (const [id, step] of this.active)
-            if (!this.sessions.has(step.sessionID))
-                this.active.delete(id);
-        for (const [id, sample] of this.observed)
-            if (!this.sessions.has(sample.sessionID))
-                this.observed.delete(id);
+    listeners = new Set();
+    cleanupTimer;
+    disposed = false;
+    unsubscribe;
+    constructor(subscribe, retention = 60_000, now = Date.now) {
+        this.retention = retention;
+        this.now = now;
+        this.unsubscribe = subscribe?.(event => this.handle(event));
     }
-    addSession(sessionID, parentID) {
-        if (sessionID && parentID && this.sessions.has(parentID))
-            this.sessions.add(sessionID);
+    listen(listener) {
+        if (this.disposed)
+            return () => { };
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.unsubscribe?.();
+        clearTimeout(this.cleanupTimer);
+        this.cleanupTimer = undefined;
+        this.listeners.clear();
+        this.active.clear();
+        this.observed.clear();
+    }
+    key(sessionID, messageID) { return `${sessionID}\0${messageID}`; }
+    publish(sessionID) {
+        for (const listener of this.listeners)
+            listener(sessionID);
+    }
+    deleteSession(sessionID) {
+        for (const [key, step] of this.active)
+            if (step.sessionID === sessionID)
+                this.active.delete(key);
+        for (const [key, sample] of this.observed)
+            if (sample.sessionID === sessionID)
+                this.observed.delete(key);
+    }
+    prune() {
+        const now = this.now();
+        const changed = new Set();
+        for (const [key, step] of this.active) {
+            if (step.finishedAt !== undefined && step.finishedAt + this.retention <= now) {
+                this.active.delete(key);
+                changed.add(step.sessionID);
+            }
+        }
+        for (const [key, sample] of this.observed) {
+            if (sample.expiresAt !== undefined && sample.expiresAt <= now) {
+                this.observed.delete(key);
+                changed.add(sample.sessionID);
+            }
+        }
+        return changed;
+    }
+    scheduleCleanup() {
+        clearTimeout(this.cleanupTimer);
+        if (this.disposed || !Number.isFinite(this.retention) || this.retention < 0)
+            return;
+        let next = Infinity;
+        for (const step of this.active.values()) {
+            if (step.finishedAt !== undefined)
+                next = Math.min(next, step.finishedAt + this.retention);
+        }
+        for (const sample of this.observed.values()) {
+            if (sample.expiresAt !== undefined)
+                next = Math.min(next, sample.expiresAt);
+        }
+        if (!Number.isFinite(next))
+            return;
+        this.cleanupTimer = setTimeout(() => {
+            this.cleanupTimer = undefined;
+            for (const sessionID of this.prune())
+                this.publish(sessionID);
+            this.scheduleCleanup();
+        }, Math.max(0, next - this.now()));
+        this.cleanupTimer.unref?.();
     }
     handle(event) {
+        if (this.disposed)
+            return false;
+        for (const sessionID of this.prune())
+            this.publish(sessionID);
         const data = (event.data && typeof event.data === "object" ? event.data : {});
         const sessionID = typeof data.sessionID === "string" ? data.sessionID : undefined;
+        if (event.type === "session.deleted") {
+            if (sessionID)
+                this.deleteSession(sessionID);
+            return false;
+        }
         const messageID = typeof data.assistantMessageID === "string" ? data.assistantMessageID : undefined;
-        if (!sessionID || !messageID || !this.sessions.has(sessionID))
+        if (!sessionID || !messageID)
             return false;
+        const key = this.key(sessionID, messageID);
         if (event.type === "session.step.started") {
             if (!finite(data.started))
                 return false;
-            if (this.active.has(messageID))
+            if (this.active.has(key))
                 return false;
-            this.active.set(messageID, {
+            this.active.set(key, {
                 messageID, sessionID, started: data.started, bytes: 0, events: new Set(),
             });
             return false;
         }
-        const step = this.active.get(messageID);
+        const step = this.active.get(key);
         if (!step)
             return false;
         if (event.type === "session.step.streamed") {
             if (!finite(event.created) || event.created < step.started)
                 return false;
             step.streamed = event.created;
+            if (step.bytes > 0)
+                this.publish(sessionID);
             return step.bytes > 0;
         }
         if (event.type === "session.step.ended" || event.type === "session.step.failed") {
+            step.finishedAt = this.now();
+            const sample = this.observed.get(key);
+            if (sample)
+                sample.expiresAt = step.finishedAt + this.retention;
+            this.scheduleCleanup();
             return false;
         }
         if (event.type !== "session.text.delta" && event.type !== "session.reasoning.delta"
@@ -133,29 +211,33 @@ export class PerformanceTracker {
         step.last = Math.max(step.last ?? event.created, event.created);
         if (step.first === undefined) {
             step.first = event.created;
-            this.observed.set(messageID, { messageID, sessionID, started: step.started, first: event.created });
+            this.observed.set(key, { messageID, sessionID, started: step.started, first: event.created });
         }
+        this.publish(sessionID);
         return true;
     }
-    reconcile(messages) {
+    reconcile(messages, sessionIDs) {
+        const sessions = new Set(sessionIDs);
         const represented = new Set();
         for (const message of messages) {
             if (message.type === "assistant" && (message.tokens || message.time?.streamed !== undefined
                 || message.time?.completed !== undefined))
                 represented.add(message.id);
         }
-        for (const [id, step] of this.active) {
-            if (represented.has(id))
-                this.active.delete(id);
+        for (const [key, step] of this.active) {
+            if (sessions.has(step.sessionID) && represented.has(step.messageID)
+                && (step.finishedAt !== undefined || step.streamed !== undefined))
+                this.active.delete(key);
         }
     }
-    summary(messages) {
-        const samples = [...this.observed.values()].filter(sample => this.sessions.has(sample.sessionID));
+    summary(messages, sessionIDs) {
+        const sessions = new Set(sessionIDs);
+        const samples = [...this.observed.values()].filter(sample => sessions.has(sample.sessionID));
         const result = historicalPerformance(messages, samples);
         let bytes = 0;
         let duration = 0;
         for (const step of this.active.values()) {
-            if (!this.sessions.has(step.sessionID) || step.bytes <= 0)
+            if (!sessions.has(step.sessionID) || step.bytes <= 0)
                 continue;
             const last = step.streamed ?? step.last;
             if (!finite(last) || last <= step.started)

package/dist/tui.js

@@ -8,6 +8,7 @@ import { createElement as _$createElement } from "@opentui/solid";
 import { Plugin } from "@opencode/plugin/tui";
 import { createEffect, createMemo, createSignal, For, onCleanup, Show } from "solid-js";
 import { UsageController } from "./controller.js";
+import { PerformanceMonitor } from "./performance.js";
 import { createSource } from "./source.js";
 import { usageRows } from "./usage.js";
 function UsagePanel(props) {
@@ -16,7 +17,7 @@ function UsagePanel(props) {
   });
   const controller = new UsageController(createSource(props.context.client), listener => props.context.data.listen(({
     details
-  }) => listener(details)), setState);
+  }) => listener(details)), setState, 80, 3_000, 100, props.performance);
   const unregister = props.register(controller);
   createEffect(() => controller.select(props.sessionID));
   onCleanup(() => {
@@ -89,6 +90,9 @@ function UsagePanel(props) {
 export default Plugin.define({
   id: "opencode-token-usage.tui",
   setup(context) {
+    const performance = new PerformanceMonitor(listener => context.data.listen(({
+      details
+    }) => listener(details)));
     const controllers = new Set();
     const register = controller => {
       controllers.add(controller);
@@ -103,6 +107,7 @@ export default Plugin.define({
         get sessionID() {
           return props.sessionID;
         },
+        performance: performance,
         register: register
       })
     });
@@ -130,6 +135,7 @@ export default Plugin.define({
             get sessionID() {
               return props.sessionID;
             },
+            performance: performance,
             register: register
           }));
           return _el$9;
@@ -141,6 +147,7 @@ export default Plugin.define({
       controllers.clear();
       remove();
       removeChild();
+      performance.dispose();
     };
   }
 });

package/docs/verification.md

@@ -1,5 +1,30 @@
 # 验证记录
 
+## 未发布（SDK 2.0.11）
+
+验证日期：2026-09-22。环境：macOS、Node.js v22.23.2、npm 10.9.8、OpenCode v2.0.11；`@opencode/plugin`、`@opencode/client`、`@opencode/schema` 和 `@opencode/theme` 均精确锁定为 2.0.11。
+
+### 自动化检查
+
+| 检查 | 结果 |
+| --- | --- |
+| `npm run typecheck` | 通过 |
+| `npm test` | 31 项通过 |
+| `npm run build` | 通过，输出 ESM 与类型声明 |
+| `npm run test:smoke` | 通过，使用实际 `.tgz` 安装产物和真实 OpenCode 2.0.11 |
+
+SDK 从 2.0.9 升级到 2.0.11 后，四个顶层 OpenCode 包及锁文件中的传递依赖均已统一到 2.0.11。`@opencode/plugin` 两版的导出结构一致；包内容差异除依赖版本外，仅为 `ToastOptions` 新增可选的 `sessionID` 类型字段。
+
+新增共享性能监视器测试覆盖：查看会话 A 时捕获独立会话 B 的流，切换到 B 后立即恢复实时 TPS/TTFT；生成中切走、继续接收 delta 再切回；控制器销毁重建后恢复共享流；不同会话树隔离、新子代理即时纳入，以及删除会话清理运行期状态。既有重复事件去重与完成后收敛为精确 TPS 的断言继续通过。
+
+### 真实 OpenCode 集成
+
+隔离 smoke 测试确认打包插件可加载；空会话隐藏无数据行；在独立会话已经开始慢速流后，同一 TUI 切换过去会立即显示 `TPS ~…` 与 TTFT，完成后变为无 `~` 的精确 TPS；既有 token、上下文与费用刷新、真实子代理全树累计、会话局部上下文及模型切换验证均继续通过。测试产物保存在 `/var/folders/rw/bmx6c8hd737brl55m0_ff_b80000gn/T/token-usage-smoke-cgsCK2`。
+
+### 验证边界
+
+当前 SDK 2.0.11 与宿主 2.0.11 的组合已完整验证。验证时机器默认宿主已是 2.0.12，因此 smoke 使用校验完整性的官方 `@opencode/cli-darwin-arm64@2.0.11` 隔离二进制，没有放宽宿主版本断言。2.0.9 和 2.0.10 宿主的历史验证记录保留在下方，但升级 SDK 后未重新执行这两个旧宿主的打包矩阵。后续升级 SDK 或宿主时，仍需重新核对分叉副本、compaction 排序及 step/delta 事件语义。
+
 ## v0.2.1（TPS 与 TTFT）
 
 验证日期：2026-09-20。环境：macOS、Node.js v22.23.2、npm 10.9.8、OpenCode v2.0.11；插件 SDK 依赖为 2.0.9。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chenlongapps/opencode-token-usage",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Session-tree token usage, live performance, context window and estimated cost for OpenCode 2",
   "keywords": [
     "opencode",
@@ -57,7 +57,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@opencode/plugin": "2.0.9"
+    "@opencode/plugin": "2.0.11"
   },
   "peerDependencies": {
     "@opentui/core": "0.5.10",
@@ -66,9 +66,9 @@
   },
   "devDependencies": {
     "@babel/core": "^7.28.0",
-    "@opencode/client": "2.0.9",
-    "@opencode/schema": "2.0.9",
-    "@opencode/theme": "2.0.9",
+    "@opencode/client": "2.0.11",
+    "@opencode/schema": "2.0.11",
+    "@opencode/theme": "2.0.11",
     "@opentui/core": "0.5.10",
     "@opentui/solid": "0.5.10",
     "@types/node": "^22.0.0",