@chenlongapps/opencode-token-usage 0.2.3 → 0.2.5

package/README.md

@@ -49,6 +49,7 @@ For remote sessions, add the package name to `plugins` in your local `~/.config/
 | `Cache Rate` | `Cache Read ÷ (Input + Cache Read + Cache Write)` |
 | `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 |
+| `Steps` | Assistant message count across the session tree, including subagents; follows OpenCode's own stats definition, so compaction and user messages are not steps |
 | `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 |
@@ -58,6 +59,7 @@ For remote sessions, add the package name to `plugins` in your local `~/.config/
 - 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.
+- `Steps` counts every assistant message in the tree, whether or not it reported usage, and reuses the fork-copy de-duplication so inherited history is never counted twice.
 - `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.
 

package/README.zh-CN.md

@@ -49,6 +49,7 @@ opencode plugin add @chenlongapps/opencode-token-usage
 | `Cache Rate` | `Cache Read ÷ (Input + Cache Read + Cache Write)` |
 | `Total` | 五类 token 之和 |
 | `Context` | 当前会话最后一次已完成压缩后的最新上下文用量，不随子树累计 |
+| `Steps` | 全树（含子代理）的 assistant 消息数，口径与 OpenCode 自带统计一致，compaction 与用户消息不计为 step |
 | `Cost` | 按当前会话活动模型重新估算的全树费用，不代表提供商账单 |
 | `TPS` | 全树 `Output + Reasoning` 的生成速度；生成中的估算值带 `~` 标记 |
 | `TTFT` | 全树中可测 assistant step 的平均首 token 时间 |
@@ -58,6 +59,7 @@ opencode plugin add @chenlongapps/opencode-token-usage
 - 用量覆盖会话树中服务端上报的 assistant 与 compaction 消息，包括未打开的子代理；不按文本长度估算 token。
 - 分叉会话是独立会话树。继承消息副本只归原始来源，避免重复计费。
 - `Context` 仅搜索最后一次 `status === "completed"` 的 compaction 之后；没有可靠用量或模型上限时隐藏。
+- `Steps` 统计树中全部 assistant 消息，无论是否已上报用量；复用分叉副本去重，继承历史不会重复计数。
 - `Cost` 使用当前查看会话的活动模型重算整棵树；缺失适用价格时按 OpenCode 行为回退为 0。
 - 首次读取失败显示 `Unavailable`；后续失败保留上次完整快照、标注 `Not updated` 并自动重试。
 

package/ROADMAP.md

@@ -54,11 +54,26 @@ TPS  48.7 tok/s
 TTFT  2.7s
 ```
 
+## v0.2.5 — Steps 计数
+
+目标：让整棵树的模型调用次数可见。
+
+* [x] 显示全树（含子代理）的 `Steps` 计数
+* [x] 口径与 OpenCode 官方统计一致：每条 assistant 消息为一个 step，compaction 与用户消息不计
+* [x] 分叉继承副本不重复计数
+* [x] 行位置为 Context 之后、Input 之前；无 Context 时位于面板第一行
+* [x] 实际打包产物在 OpenCode 2.0.11 中验证显示与刷新
+
+```text
+Steps  1,234
+```
+
 ## v0.3.0 — 公开价格目录
 
 目标：提供可查询的价格目录，便于用户了解不同模型的计费档位。
 
 * [ ] 构建公开价格目录，包含模型、价格档位及阈值
+* [ ] 只收录半年内发布的模型
 <!-- 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/dist/usage.d.ts

@@ -77,6 +77,7 @@ export declare function summarize(messages: Iterable<UsageMessage>, prices?: rea
     tokens: Tokens;
     total: number;
     cacheRate: number;
+    steps: number;
     cost: number;
     defaultPrice: boolean;
 };

package/dist/usage.js

@@ -22,8 +22,13 @@ export function estimate(tokens, prices = []) {
 export function summarize(messages, prices = []) {
     const tokens = normalize();
     let cost = 0;
+    let steps = 0;
     let defaultPrice = prices.length === 0;
     for (const message of messages) {
+        // Matches OpenCode SessionStats: every assistant message is one step,
+        // with or without reported usage; compaction and user messages are not.
+        if (message.type === "assistant")
+            steps++;
         if ((message.type !== "assistant" && message.type !== "compaction") || !message.tokens)
             continue;
         const t = normalize(message.tokens);
@@ -36,7 +41,10 @@ export function summarize(messages, prices = []) {
         cost += value.cost;
         defaultPrice ||= value.defaultPrice;
     }
-    return { tokens, total: total(tokens), cacheRate: incoming(tokens) ? tokens.cache.read / incoming(tokens) : 0, cost, defaultPrice };
+    return {
+        tokens, total: total(tokens), cacheRate: incoming(tokens) ? tokens.cache.read / incoming(tokens) : 0,
+        steps, cost, defaultPrice,
+    };
 }
 const usableLimit = (value) => value !== undefined && Number.isFinite(value) && value > 0;
 // Matches the OpenCode 2.0.10 sidebar: the last assistant message with tokens that follows
@@ -73,7 +81,7 @@ export function usageRows(summary, context, performance) {
     const rows = [];
     if (context)
         rows.push(["Context", `${formatTokens(context.used)} / ${formatTokens(context.limit)} (${context.percent.toFixed(1)}%)`]);
-    rows.push(["Input", number(t?.input)], ["Output", number(t?.output)], ["Reasoning", number(t?.reasoning)], ["Cache Read", number(t?.cache.read)]);
+    rows.push(["Steps", number(summary?.steps)], ["Input", number(t?.input)], ["Output", number(t?.output)], ["Reasoning", number(t?.reasoning)], ["Cache Read", number(t?.cache.read)]);
     if (t && t.cache.write > 0)
         rows.push(["Cache Write", number(t.cache.write)]);
     rows.push(["Cache Rate", summary ? `${(summary.cacheRate * 100).toFixed(1)}%` : "—"], ["Total", number(summary?.total)]);

package/docs/verification.md

@@ -2,26 +2,30 @@
 
 ## 未发布（SDK 2.0.11）
 
-验证日期：2026-09-20。环境：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。
+验证日期：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` | 29 项通过 |
+| `npm test` | 32 项通过 |
 | `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 的断言继续通过。
+
+新增 Steps 计数覆盖：`summarize` 对带与不带 `tokens` 的 assistant 消息各计一个 step、compaction 与 user 消息不计、无 summary 时显示 `—`；`uniqueMessages` 链路上分叉继承副本不重复计数（快照 2 个 step、独立分叉树 1 个 step）、compaction 不产生 step、孙会话视图与根视图同为 6 个 step；行序断言锁定 Context → Steps → Input，无 Context 时 Steps 位于面板第一行。基准行数由 6 行调整为 7 行。
+
 ### 真实 OpenCode 集成
 
-隔离 smoke 测试确认打包插件可加载；空会话隐藏无数据行；活动 TPS 估算会收敛为精确值；TTFT、token、上下文与费用正常刷新；真实子代理用量可从父子视图累计且上下文保持会话局部；切换活动模型会同步更新价格选择与上下文上限。测试产物保存在 `/var/folders/rw/bmx6c8hd737brl55m0_ff_b80000gn/T/token-usage-smoke-JXe1KG`。
+隔离 smoke 测试确认打包插件可加载；空会话隐藏无数据行并显示 `Steps 0`；在独立会话已经开始慢速流后，同一 TUI 切换过去会立即显示 `TPS ~…` 与 TTFT，完成后变为无 `~` 的精确 TPS；既有 token、上下文与费用刷新、真实子代理全树累计、会话局部上下文及模型切换验证均继续通过。Steps 在真实集成中断言为：首条 assistant 完成后 `Steps 1` 且行序位于 Context 与 Input 之间；真实子代理场景下根视图与子代理视图均为 `Steps 4`（父 3 条 + 子 1 条），而被查看会话自身仍为 1，确认 Steps 随整棵树累计、上下文保持会话局部。测试产物保存在 `/var/folders/rw/bmx6c8hd737brl55m0_ff_b80000gn/T/token-usage-smoke-423PQP`。
 
 ### 验证边界
 
-当前 SDK 2.0.11 与宿主 2.0.11 的组合已完整验证。2.0.9 和 2.0.10 宿主的历史验证记录保留在下方，但升级 SDK 后未重新执行这两个旧宿主的打包矩阵：本地仅有 2.0.11，官方 GitHub Releases 也没有可获取的对应旧版本资产。后续升级 SDK 或宿主时，仍需重新核对分叉副本、compaction 排序及 step/delta 事件语义。
+当前 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）
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chenlongapps/opencode-token-usage",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Session-tree token usage, live performance, context window and estimated cost for OpenCode 2",
   "keywords": [
     "opencode",