@chenlongapps/opencode-token-usage 0.4.9 → 0.4.10

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+ (see the OpenTUI engine note under [Development](#development)). OpenCode 2.0.9 and 2.0.10 have been verified in earlier releases. SDK 2.0.24 integration checks have passed on OpenCode 2.0.11, 2.0.22, 2.0.24, and 2.0.26. Native turn durations and sidebar title clicks were integration-tested on 2.0.26; the other listed host checks predate these additions.
+> Requires Node.js 22+ (see the OpenTUI engine note under [Development](#development)). OpenCode 2.0.9 and 2.0.10 have been verified in earlier releases. SDK 2.0.24 integration checks have passed on OpenCode 2.0.11, 2.0.22, 2.0.24, 2.0.26, and 2.0.28. Native turn durations and sidebar title clicks were integration-tested on 2.0.26 and 2.0.28; the other listed host checks predate these additions.
 
 Restart OpenCode after installation. The panel appears in the native sidebar when `session.sidebar` is set to `auto` and the terminal is wide enough. Click its **Token Usage** title to open the detailed usage dialog. OpenCode hides the sidebar in subagent views, so the plugin keeps one live summary line above the composer with Context, Total, Cost, Time, 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.
 
@@ -86,8 +86,8 @@ Costs follow the sidebar's pricing and `partial`/unavailable/free conventions. I
 - 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.
-- `Run Time` follows OpenCode 2.0.26's native response footer: assistant completion time minus the first user/synthetic input's creation time after the previous idle marker. Older histories without idle markers use the nearest input; without any input, it uses the assistant's creation time. Each turn contributes only its final completed response duration, not the overlapping duration of every assistant step. Model calls, tools, retries and foreground waits within that span are included; idle time between turns is not. Waiting for a subagent is already part of the parent's span and is never added separately.
-- While the viewed session is running, `Run Time` estimates **elapsed time so far**, not final or remaining time, and prefixes the cumulative display with `~` (for example, `~42.5s`). A shared 500 ms clock replaces the current turn's already-counted duration rather than adding an overlapping steer/retry duration. Clock ticks only update memory: history reads remain event-driven. One optional read-only server-plugin clock RPC at startup/reconnection supplies a server-time anchor, with timestamped live events as a fallback; local monotonic time advances it without assuming that a remote server shares the client's clock. Opening an already-running session restores the turn's start from history. Without a trusted anchor or valid timing, native totals remain unchanged.
+- `Run Time` follows OpenCode 2.0.26's native response footer: assistant completion time minus the first user/synthetic input's creation time after the previous idle marker. A new session whose native time metadata records no previous idle uses the first input even before its first idle marker: synthetic deliveries and steers do not reset that turn. Older histories without idle markers use the nearest input; missing session metadata preserves this legacy fallback. Without any input, it uses the assistant's creation time. Each turn contributes only its final completed response duration, not the overlapping duration of every assistant step. Model calls, tools, retries and foreground waits within that span are included; idle time between turns is not. Waiting for a subagent is already part of the parent's span and is never added separately.
+- While the viewed session is running, `Run Time` estimates **elapsed time so far**, not final or remaining time, and prefixes the cumulative display with `~` (for example, `~42.5s`). A shared 500 ms clock replaces the current turn's already-counted duration rather than adding an overlapping steer/retry duration. Clock ticks only update memory: history reads remain event-driven. One optional read-only server-plugin clock RPC at startup/reconnection supplies a server-time anchor, with timestamped live events as a fallback; local monotonic time advances it without assuming that a remote server shares the client's clock. Opening an already-running session restores the turn's start from history. A reconnect history refresh arriving before clock resynchronization keeps the last trusted display for the same retained open turn and unchanged historical subtotal, rather than dropping it to zero. Without a trusted anchor or valid timing, native totals remain unchanged.
 - Completion, failure or interruption stops projection; reported native completion timing replaces the estimate and removes `~`, so a small downward correction is possible. Only native completed durations enter the historical subtotal. Totals use unrounded milliseconds before formatting (milliseconds below one second, one decimal below one minute, then minutes/hours), so they need not equal the sum of rounded footer labels. The existing message-history read restores totals after restarts, including sessions predating installation; no experimental execution-log API or server plugin is required. Missing historical timing data displays `—`, not zero. Read failures freeze the last displayed value and mark it `Not updated` (`stale` in the short summary).
 - `Run Time` / `Time` shows the duration and its estimate/freshness markers, without running-status text or animation. An idle parent's time never advances just because a child is active. Closing or switching views cleans up their estimates, and the shared elapsed-time ticker stops when no view needs it. Unavailable/stale timing keeps its own marker.
 - A confirmed zero `Run Time` / `Time` is hidden in the sidebar, subagent summary/dialog and both `/usage` modes, without leaving an empty row or field. A nonzero live estimate makes the first turn visible even before any response has completed. Nonzero millisecond durations, unavailable values and stale timing remain visible.
@@ -96,6 +96,7 @@ Costs follow the sidebar's pricing and `partial`/unavailable/free conventions. I
 - 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`; positive estimates below `$0.001` display `<$0.001`, estimates through and including `$0.01` use three decimal places, and larger estimates use two. 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` uses a ~2s sliding window, batches deliveries within 100 ms and requires a span of at least 500 ms. The first batch is only a baseline: its bytes are not counted as output generated after its timestamp. Smoothing follows elapsed time rather than delta count. After 2s without a new delta, a shared in-memory timeout expires the estimate without reading history; historical TPS takes over, or the row is hidden if unavailable. Resuming output after expiry starts a fresh baseline and smoothing state.
+- Reconnection resets live TPS windows and reconciles all tracked sessions, including offscreen sessions, with the server's active-session set. Quiet unfinished streams get a shared activity check after 60s, without reading message history. Confirmed inactive streams and their TTFT observations expire after a further 60s. Running tools, retries and pre-first-token waits have no hard lifetime; failed activity reads retain state and retry. Provider `streamed` metadata alone never means that tools have finished. Checks stop when no unfinished streams remain.
 - Live TPS measures observable delivery, not the model's internal token-generation clock. Responses summary bursts, done-only content and transport buffering can still affect estimates; complete hidden reasoning cannot be reconstructed. Without `~`, TPS is `Σ(Output + Reasoning) ÷ Σ(time.streamed − time.created)` in seconds across valid assistant samples in the tree, not just the last request. This historical denominator includes pre-first-token waiting, so it is not the same metric as the recent live estimate. No model-specific multipliers, hard TPS caps or hidden-reasoning guesses are applied.
 - Initial read failures display `Unavailable`. Later failures retain the last complete snapshot, display `Not updated`, and retry automatically.
 
@@ -117,7 +118,9 @@ Failed validation never bumps the version. An unfinished tagged price release is
 
 For a manual refresh, run `npm run prices:update` in a networked environment, review the generated diff and exceptions, then run the checks above. Builds and plugin refreshes do not contact models.dev.
 
-`test:smoke` packages the real artifact and validates loading, refreshes, `/usage`, sidebar title clicks, subagent aggregation, per-message pricing, first-party price fallback, model switching, TPS, TTFT, Responses summary bursts/done-only summaries/quiet expiry, and session-local native turn durations (unfinished responses, idle gaps, interruption, message-history restoration, forks and narrow child views) against an isolated OpenCode instance and local mock providers. It requires Python 3, an available local port, and npm network access. It never modifies your existing OpenCode configuration or calls paid models.
+`test:smoke` packages the real artifact and validates loading, refreshes, `/usage`, sidebar title clicks, subagent aggregation, per-message pricing, first-party price fallback, model switching, TPS, TTFT, Responses summary bursts/done-only summaries/quiet expiry, and session-local native turn durations (unfinished responses, first-turn synthetic continuations, reopening a running TUI, terminal focus events, idle gaps, interruption, message-history restoration, forks and narrow child views) against an isolated OpenCode instance and local mock providers. It requires Python 3, an available local port, and npm network access. It never modifies your existing OpenCode configuration or calls paid models. Terminal focus checks do not establish physical macOS multi-display, App Nap or sleep/wake behavior.
+
+Performance lifecycle checks also use the real host's active-session API, with ending events withheld from an offscreen monitor, injected reconnect handshakes and an accelerated 25-hour tool/child wait. They verify preservation while running and reclamation after completion without history reads.
 
 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.
 

package/README.zh-CN.md

@@ -34,7 +34,7 @@ opencode plugin add @chenlongapps/opencode-token-usage
 ```
 
 > [!NOTE]
-> 需要 Node.js 22+（见[开发](#开发)中的 OpenTUI 引擎说明）。此前发布已验证 OpenCode 2.0.9 和 2.0.10；SDK 2.0.24 集成检查已在 OpenCode 2.0.11、2.0.22、2.0.24 和 2.0.26 上通过。原生对话耗时与侧边栏标题点击的集成验证使用 2.0.26，其余列出的宿主检查早于这些功能加入。
+> 需要 Node.js 22+（见[开发](#开发)中的 OpenTUI 引擎说明）。此前发布已验证 OpenCode 2.0.9 和 2.0.10；SDK 2.0.24 集成检查已在 OpenCode 2.0.11、2.0.22、2.0.24、2.0.26 和 2.0.28 上通过。原生对话耗时与侧边栏标题点击的集成验证使用 2.0.26 和 2.0.28，其余列出的宿主检查早于这些功能加入。
 
 安装后重启 OpenCode。终端足够宽且 `session.sidebar` 设为 `auto` 时，面板会显示在原生侧边栏中。点击面板的 **Token Usage** 标题可打开用量详情弹窗。OpenCode 在子代理视图中隐藏侧边栏，因此插件会在输入区上方保留一行实时摘要，显示 Context、Total、Cost、Time 和 TPS。点击摘要可在居中弹窗中查看完整统计；按 Escape 或点击 **esc** 即可关闭，关闭弹窗不会中断子代理。
 
@@ -86,8 +86,8 @@ opencode plugin add @chenlongapps/opencode-token-usage
 - 分叉会话是独立会话树。继承消息副本只归原始来源，避免重复计费。
 - `Context` 仅搜索最后一次 `status === "completed"` 的 compaction 之后；没有可靠用量或模型上限时隐藏。
 - `Steps` 统计树中全部 assistant 消息，无论是否已上报用量；复用分叉副本去重，继承历史不会重复计数。
-- `Run Time` 沿用 OpenCode 2.0.26 的原生回答页脚口径：assistant 完成时间减去上一条 idle 标记之后首个 user／synthetic 输入的创建时间。没有 idle 标记的旧历史使用最近一条输入；没有输入则回退到 assistant 自身的创建时间。每轮只计最终已完成回答的耗时，不把各条 assistant step 的重叠时长重复相加。包含跨度内的模型调用、工具、重试和前台等待，不含轮次之间的空闲；父会话等待子代理的时间已在父会话跨度内，不再额外叠加子代理耗时。
-- 被查看会话运行中时，`Run Time` 估算的是**截至当前已经过去的时间**，不是最终耗时或剩余时间，累计显示值带 `~`（例如 `~42.5s`）。共享的 500ms 时钟替换当前轮已经计入的时长，不额外叠加重叠的 steer／retry 耗时。时钟 tick 只更新内存，历史读取仍由事件触发。启动／重连时通过一次可选的服务端插件只读时间 RPC 取得服务端锚点，带时间戳的实时事件可作为回退；用本地单调时钟推进，不假定远程服务端与客户端时钟一致。中途打开正在运行的会话时，从历史恢复当前轮起点。没有可信锚点或有效时间时，保留原生累计值。
+- `Run Time` 沿用 OpenCode 2.0.26 的原生回答页脚口径：assistant 完成时间减去上一条 idle 标记之后首个 user／synthetic 输入的创建时间。新会话的原生时间元数据尚未记录 idle 时，即使第一条 idle 消息尚未出现，也使用首条输入，同轮 synthetic 投递与 steer 不重置起点。没有 idle 标记的旧历史使用最近一条输入；会话时间元数据缺失时保留这项旧历史回退。没有输入则回退到 assistant 自身的创建时间。每轮只计最终已完成回答的耗时，不把各条 assistant step 的重叠时长重复相加。包含跨度内的模型调用、工具、重试和前台等待，不含轮次之间的空闲；父会话等待子代理的时间已在父会话跨度内，不再额外叠加子代理耗时。
+- 被查看会话运行中时，`Run Time` 估算的是**截至当前已经过去的时间**，不是最终耗时或剩余时间，累计显示值带 `~`（例如 `~42.5s`）。共享的 500ms 时钟替换当前轮已经计入的时长，不额外叠加重叠的 steer／retry 耗时。时钟 tick 只更新内存，历史读取仍由事件触发。启动／重连时通过一次可选的服务端插件只读时间 RPC 取得服务端锚点，带时间戳的实时事件可作为回退；用本地单调时钟推进，不假定远程服务端与客户端时钟一致。中途打开正在运行的会话时，从历史恢复当前轮起点。重连时若历史刷新早于校时完成，仅在同一开放轮次仍保留且历史小计未变时冻结上次可信显示，避免回落到零。没有可信锚点或有效时间时，保留原生累计值。
 - 完成、失败或中断时停止估算；上报的原生完成耗时替换估算值并移除 `~`，因此允许小幅向下校正。历史累计只包含原生已完成耗时。先累加未取整的毫秒值，再格式化（不足一秒显示毫秒，不足一分钟的秒值保留一位小数，其后显示分／小时），因此不一定等于相加各轮已取整的页脚标签。复用现有消息历史读取，重启后可恢复，也适用于安装之前的会话；不依赖实验性执行日志 API 或服务端插件。历史计时数据缺失时显示 `—`，不会显示伪零。读取失败冻结上次显示值并标注 `Not updated`（短摘要中为 `stale`）。
 - `Run Time`／`Time` 仅显示耗时及估算／未更新标记，不附加运行状态文本或动画。已空闲父会话的耗时不会因子代理活跃而增长。关闭视图或切换会话时清理相应估算，无视图需要估算时停止共享耗时 ticker。不可用／未更新的耗时仍保留各自标记。
 - 正常状态下确认累计值为零时，侧边栏、子代理摘要／浮窗及 `/usage` 紧凑／详细模式均隐藏整个 `Run Time`／`Time` 项，不留空行或空字段。当前轮实时估算非零时，首轮回答尚未完成也会显示时间。非零毫秒耗时、不可用值和未更新的耗时仍保留显示。
@@ -96,6 +96,7 @@ opencode plugin add @chenlongapps/opencode-token-usage
 - 内置回退快照从 [models.dev](https://models.dev/api.json) 生成，只采用审核过的原厂 Provider 与自家模型系列；少量经原厂核实的例外单独维护。快照覆盖有价格的文本模型，插件运行时不下载价格。网关模型通过精确原厂 ID、明确别名和已知包装格式匹配；只有终尾 `-free` 或 `:free` 会在再次精确查找前移除。
 - 确认免费时显示 `$0.00`；正费用低于 `$0.001` 时显示 `<$0.001`，不超过 `$0.01` 的费用保留三位小数，更高费用保留两位。价格不可用时显示 `—`；只有部分消息可计算时在已知小计后标注 `partial`。快照不含网关加价、区域溢价、未列明的折扣、非文本计费、工具费和税费；Est. Cost 是估算而非账单。覆盖范围、来源和限制见[价格来源与限制](docs/pricing.md)。
 - 实时 `TPS` 使用约 2 秒滑动窗口，合并 100ms 内的增量，要求至少 500ms 的有效跨度。首批增量仅作基线，其字节不计为该时间戳之后生成的输出；平滑按经过时间而非 delta 条数推进。2 秒没有新增量时，共享的内存超时任务使估算过期，不读取历史；回退到历史 TPS，没有可用历史值则隐藏该行。过期后恢复输出时，重新建立基线与平滑状态。
+- 重连时重置实时 TPS 窗口，并通过服务端活动会话列表对账全部已跟踪会话，包括离屏会话。未结束的流静默 60 秒后进行共享活动检查，不读取消息历史；确认会话已停止后，再保留 60 秒并回收流及其 TTFT 观察。仍在运行的工具、重试及首 token 前等待没有硬性寿命上限；活动查询失败时保留状态并重试。仅有提供商的 `streamed` 元数据不代表工具已结束。没有未结束流时停止检查。
 - 实时 TPS 测量可观察的内容交付，而非模型内部生成 token 的时钟。Responses 摘要突发、仅在 done 中返回的内容和传输缓冲仍可能影响估算，不能还原完整隐藏推理。不带 `~` 时，TPS 为全树有效 assistant 样本的 `Σ(Output + Reasoning) ÷ Σ(time.streamed − time.created)`（换算为秒），不是仅取最近请求；该历史分母包含首 token 前等待，与近期实时估算口径不同。不做模型专属倍率、TPS 硬上限或隐藏 reasoning token 猜测。
 - 首次读取失败显示 `Unavailable`；后续失败保留上次完整快照、标注 `Not updated` 并自动重试。
 
@@ -117,7 +118,9 @@ OpenCode SDK 包精确锁定为 `2.0.24`，OpenTUI 为 `0.5.14`。Node.js 22 下
 
 手动更新时，在联网的维护环境运行 `npm run prices:update`，审阅生成文件及例外差异，再执行上述检查。构建和插件刷新不会请求 models.dev。
 
-`test:smoke` 会打包真实产物，并在隔离的 OpenCode 与本地模拟提供商中验证加载、刷新、`/usage`、侧边栏标题点击、子代理累计、逐消息计价、原厂价格补全、模型切换、TPS、TTFT、Responses 摘要突发／done-only 摘要／静默过期，以及会话自身的原生对话耗时（未完成回答、空闲、中断、消息历史恢复、分叉和窄终端子代理视图）。它需要 Python 3、可用的本地端口和 npm 网络访问，不会修改现有 OpenCode 配置或调用付费模型。
+`test:smoke` 会打包真实产物，并在隔离的 OpenCode 与本地模拟提供商中验证加载、刷新、`/usage`、侧边栏标题点击、子代理累计、逐消息计价、原厂价格补全、模型切换、TPS、TTFT、Responses 摘要突发／done-only 摘要／静默过期，以及会话自身的原生对话耗时（未完成回答、首轮 synthetic 延续、重开运行中 TUI、终端焦点事件、空闲、中断、消息历史恢复、分叉和窄终端子代理视图）。它需要 Python 3、可用的本地端口和 npm 网络访问，不会修改现有 OpenCode 配置或调用付费模型。终端焦点检查不代表已验证物理 macOS 多屏切换、App Nap 或睡眠／唤醒行为。
+
+性能生命周期检查还会使用真实宿主的活动会话 API，对离屏监视器过滤结束事件、注入重连握手，并加速模拟 25 小时的工具／子代理等待，确认运行时保留状态、结束后无需读取历史即可回收。
 
 默认使用 `PATH` 中的 `opencode`。OpenCode 2.0.9 及之后的稳定版 2.x 可以运行；尚未与当前 SDK 验证的宿主会输出警告，然后继续实际兼容性检查。仅通过版本检查不代表兼容性已验证。SDK 依赖仍独立锁定，不随本机 CLI 更新而自动升级。
 

package/ROADMAP.md

@@ -115,6 +115,8 @@ Steps  1,234
 * [x] 运行中以 `~` 显示当前轮已耗时估算，首轮非零估算可见；共享 500ms 单调时钟，不定时读取 API，结束后校正为原生值
 * [x] 时间缺失显示不可用，读取失败保留旧值并标注未更新；分叉副本不继承耗时，已提交回退随删除历史扣除
 * [x] 移除动画后通过类型检查、205 项测试、构建及真实 OpenCode 2.0.26 完整打包集成复验
+* [x] 首轮尚无 idle 消息时依据原生会话时间保持起点，synthetic／steer 不误重置；重连校时期间保留同一开放轮次的可信显示，247 项测试及真实 OpenCode 2.0.28 完整打包验证通过
+* [ ] macOS 物理多屏切换导致耗时倒退的实机复验（终端焦点事件、视图重建与模拟重连已覆盖，不代表已验证物理切屏、App Nap 或睡眠／唤醒）
 
 ## 后续评估
 
@@ -123,3 +125,4 @@ Steps  1,234
 ## 待解决问题
 
 - [x] TPS 显示机制修改：100ms 突发合并、首批基线、500ms 最小跨度、时间加权平滑与静默过期；209 项测试及真实 OpenCode 2.0.26 本地 Responses SSE 打包集成验证通过
+- [x] 异常流与 TTFT 回收：离屏会话的共享活动检查、重连对账、丢失结束事件回收及异步竞态保护；长工具／重试等待不按静默时长误清理，234 项测试及真实 OpenCode 2.0.26 打包集成验证通过（长等待采用加速时钟）

package/dist/controller.js

@@ -57,7 +57,7 @@ export class UsageController {
         this.performanceDelay = performanceDelay;
         this.detailed = detailed;
         this.ownsPerformance = performance === undefined;
-        this.performance = performance ?? new PerformanceMonitor(subscribe);
+        this.performance = performance ?? new PerformanceMonitor(subscribe, { active: source.active });
         this.unsubscribePerformance = this.performance.listen(sessionID => {
             if (this.sessions.has(sessionID))
                 this.refreshPerformance();
@@ -231,15 +231,30 @@ export class UsageController {
             const history = viewedMessages(snapshot);
             const session = snapshot.sessions.get(snapshot.viewedID);
             const revertMessageID = session.revert?.messageID;
-            this.preparedRuntime = prepareRuntime(history, !!session.fork);
+            const previousRuntime = this.preparedRuntime;
+            this.preparedRuntime = prepareRuntime(history, !!session.fork, session.time);
             this.runtimeFresh = true;
+            let runtime = this.runtimeSummary();
+            const estimated = this.state.runtime?.estimatedMilliseconds;
+            const turn = this.preparedRuntime.turn, previousTurn = previousRuntime?.turn;
+            // A reconnect can finish reading history before its optional clock RPC.
+            // Keep the last trusted projection only for the same retained open turn
+            // and unchanged historical subtotal. This is not a maximum-value latch:
+            // native completion, reverts and replacement histories remain authoritative.
+            if (runtime.status === "ready" && runtime.estimatedMilliseconds === undefined && estimated !== undefined
+                && turn && previousTurn && turn.started === previousTurn.started
+                && runtime.milliseconds !== undefined && previousRuntime?.summary.milliseconds !== undefined
+                && runtime.milliseconds - turn.milliseconds === previousRuntime.summary.milliseconds - previousTurn.milliseconds
+                && runtime.milliseconds <= estimated && snapshot.messages.get(snapshot.viewedID)?.has(previousTurn.messageID)) {
+                runtime = { ...runtime, estimatedMilliseconds: estimated };
+            }
             this.update({
                 status: "ready",
                 summary: summarize(messages, snapshot.model.catalog),
                 context: contextUsage(history, snapshot.model.context, revertMessageID),
                 ...(this.detailed ? { details: { request: requestDetails(history, revertMessageID), models: summarizeModels(messages, snapshot.model.catalog), sessionTitle: session.title } } : {}),
                 performance: this.performance.summaryPrepared(this.prepared, this.sessions),
-                runtime: this.runtimeSummary(),
+                runtime,
                 model: snapshot.model.label,
             });
             this.refreshRuntime();

package/dist/performance.d.ts

@@ -26,6 +26,14 @@ export declare const LIVE_MIN_SPAN_MS = 500;
 export declare const LIVE_SAMPLE_MS = 100;
 export declare const LIVE_EWMA_ALPHA = 0.35;
 export declare const LIVE_BYTES_PER_TOKEN = 4;
+/** Quiet streams need a server liveness check, not a maximum tool-wait duration. */
+export declare const ACTIVITY_CHECK_MS = 60000;
+export type ReadActiveSessions = (signal: AbortSignal) => Promise<ReadonlySet<string>>;
+export interface PerformanceOptions {
+    retention?: number;
+    monotonic?: () => number;
+    active?: ReadActiveSessions | undefined;
+}
 /** The first batch is a counter baseline, not bytes generated after its timestamp. */
 export declare function estimatedLiveTps(samples: readonly StreamSample[]): number | undefined;
 /** Time-based EWMA: elapsed time determines the weight, never delta count. */
@@ -44,22 +52,27 @@ export declare function historicalPerformance(messages: Iterable<UsageMessage>,
 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;
-    private readonly now;
-    private readonly monotonic;
     private active;
     private observed;
     private listeners;
     private cleanupTimer;
+    private synchronization;
     private disposed;
     private readonly unsubscribe;
-    constructor(subscribe?: PerformanceSubscribe, retention?: number, now?: () => number, monotonic?: () => number);
+    private readonly retention;
+    private readonly monotonic;
+    private readonly readActive;
+    constructor(subscribe?: PerformanceSubscribe, options?: PerformanceOptions);
     listen(listener: PerformanceListener): () => void;
     dispose(): void;
     private key;
     private publish;
     private deleteSession;
     private resetLive;
+    private touch;
+    private finish;
+    /** One shared, history-free read covers offscreen sessions too. Failures are not idle. */
+    private checkActivity;
     private prune;
     private scheduleCleanup;
     handle(event: PerformanceEvent): boolean;

package/dist/performance.js

@@ -4,6 +4,8 @@ export const LIVE_MIN_SPAN_MS = 500;
 export const LIVE_SAMPLE_MS = 100;
 export const LIVE_EWMA_ALPHA = 0.35;
 export const LIVE_BYTES_PER_TOKEN = 4;
+/** Quiet streams need a server liveness check, not a maximum tool-wait duration. */
+export const ACTIVITY_CHECK_MS = 60_000;
 /** The first batch is a counter baseline, not bytes generated after its timestamp. */
 export function estimatedLiveTps(samples) {
     if (samples.length < 2)
@@ -116,19 +118,20 @@ function performanceWithObservations(prepared, observations) {
 }
 /** Captures streaming performance for every session for one plugin lifetime. */
 export class PerformanceMonitor {
-    retention;
-    now;
-    monotonic;
     active = new Map();
     observed = new Map();
     listeners = new Set();
     cleanupTimer;
+    synchronization;
     disposed = false;
     unsubscribe;
-    constructor(subscribe, retention = 60_000, now = Date.now, monotonic = () => performance.now()) {
-        this.retention = retention;
-        this.now = now;
-        this.monotonic = monotonic;
+    retention;
+    monotonic;
+    readActive;
+    constructor(subscribe, options = {}) {
+        this.retention = options.retention ?? 60_000;
+        this.monotonic = options.monotonic ?? (() => performance.now());
+        this.readActive = options.active;
         this.unsubscribe = subscribe?.(event => this.handle(event));
     }
     listen(listener) {
@@ -142,6 +145,7 @@ export class PerformanceMonitor {
             return;
         this.disposed = true;
         this.unsubscribe?.();
+        this.synchronization?.abort();
         clearTimeout(this.cleanupTimer);
         this.cleanupTimer = undefined;
         this.listeners.clear();
@@ -170,13 +174,93 @@ export class PerformanceMonitor {
         delete step.liveDuration;
         delete step.smoothedAt;
     }
+    touch(step, created) {
+        step.revision++;
+        step.checkedAt = this.monotonic();
+        if (finite(created))
+            step.latest = Math.max(step.latest, created);
+        // A live event wins over an inactive snapshot taken just before it arrived.
+        if (step.inactive) {
+            delete step.finishedAt;
+            delete step.inactive;
+            const sample = this.observed.get(this.key(step.sessionID, step.messageID));
+            if (sample)
+                delete sample.expiresAt;
+        }
+    }
+    finish(step, inactive = false) {
+        if (step.finishedAt !== undefined && (inactive || !step.inactive))
+            return;
+        step.finishedAt ??= this.monotonic();
+        step.inactive = inactive;
+        step.revision++;
+        const key = this.key(step.sessionID, step.messageID);
+        const sample = this.observed.get(key);
+        if (sample)
+            sample.expiresAt = step.finishedAt + this.retention;
+        this.resetLive(step);
+        this.publish(step.sessionID);
+    }
+    /** One shared, history-free read covers offscreen sessions too. Failures are not idle. */
+    async checkActivity(force = false) {
+        if (this.disposed || !this.readActive)
+            return;
+        if (this.synchronization) {
+            if (!force)
+                return;
+            this.synchronization.abort();
+            this.synchronization = undefined;
+        }
+        const now = this.monotonic();
+        const unfinished = [...this.active.values()].filter(step => step.finishedAt === undefined);
+        if (!unfinished.length || (!force && !unfinished.some(step => now - step.checkedAt >= ACTIVITY_CHECK_MS)))
+            return;
+        // The endpoint is process-wide: use each read for every tracked unfinished step,
+        // rather than issuing one request per staggered session deadline.
+        const candidates = new Map(unfinished.map(step => [step, step.revision]));
+        const request = new AbortController();
+        this.synchronization = request;
+        const signal = AbortSignal.any([request.signal, AbortSignal.timeout(5_000)]);
+        let onAbort = () => { };
+        try {
+            // Also bound readers that fail to cooperate with cancellation.
+            const active = await Promise.race([
+                this.readActive(signal),
+                new Promise((_, reject) => {
+                    onAbort = () => reject(signal.reason);
+                    signal.addEventListener("abort", onAbort, { once: true });
+                    if (signal.aborted)
+                        onAbort();
+                }),
+            ]);
+            if (this.disposed || signal.aborted || this.synchronization !== request)
+                return;
+            for (const [step, revision] of candidates) {
+                if (this.active.get(this.key(step.sessionID, step.messageID)) !== step || step.revision !== revision)
+                    continue;
+                if (!active.has(step.sessionID))
+                    this.finish(step, true);
+            }
+        }
+        catch { /* Preserve quiet tools/retries when server activity is unknown. */ }
+        finally {
+            signal.removeEventListener("abort", onAbort);
+            request.abort();
+            if (this.synchronization === request) {
+                this.synchronization = undefined;
+                for (const [step, revision] of candidates) {
+                    if (step.revision === revision)
+                        step.checkedAt = this.monotonic();
+                }
+                this.scheduleCleanup();
+            }
+        }
+    }
     prune() {
-        const now = this.now();
         const monotonic = this.monotonic();
         const changed = new Set();
         for (const [key, step] of this.active) {
-            if ((step.finishedAt ?? step.reconciledAt) !== undefined
-                && (step.finishedAt ?? step.reconciledAt) + this.retention <= now) {
+            if (step.finishedAt !== undefined && step.finishedAt + this.retention <= monotonic) {
                 this.active.delete(key);
                 changed.add(step.sessionID);
             }
@@ -186,7 +270,7 @@ export class PerformanceMonitor {
             }
         }
         for (const [key, sample] of this.observed) {
-            if (sample.expiresAt !== undefined && sample.expiresAt <= now) {
+            if (sample.expiresAt !== undefined && sample.expiresAt <= monotonic) {
                 this.observed.delete(key);
                 changed.add(sample.sessionID);
             }
@@ -199,20 +283,21 @@ export class PerformanceMonitor {
         if (this.disposed)
             return;
         let next = Infinity;
-        const now = this.now();
         const monotonic = this.monotonic();
         const retain = Number.isFinite(this.retention) && this.retention >= 0;
         for (const step of this.active.values()) {
-            const settled = step.finishedAt ?? step.reconciledAt;
-            if (retain && settled !== undefined)
-                next = Math.min(next, settled + this.retention - now);
+            if (retain && step.finishedAt !== undefined)
+                next = Math.min(next, step.finishedAt + this.retention - monotonic);
+            if (step.finishedAt === undefined && this.readActive && !this.synchronization) {
+                next = Math.min(next, step.checkedAt + ACTIVITY_CHECK_MS - monotonic);
+            }
             // Local monotonic age, never client epoch minus a remote event timestamp.
             if (step.observedAt !== undefined)
                 next = Math.min(next, step.observedAt + LIVE_WINDOW_MS - monotonic);
         }
         for (const sample of this.observed.values()) {
             if (retain && sample.expiresAt !== undefined)
-                next = Math.min(next, sample.expiresAt - now);
+                next = Math.min(next, sample.expiresAt - monotonic);
         }
         if (!Number.isFinite(next))
             return;
@@ -220,6 +305,7 @@ export class PerformanceMonitor {
             this.cleanupTimer = undefined;
             for (const sessionID of this.prune())
                 this.publish(sessionID);
+            void this.checkActivity();
             this.scheduleCleanup();
         }, Math.max(0, Math.ceil(next)));
         this.cleanupTimer.unref?.();
@@ -229,6 +315,16 @@ export class PerformanceMonitor {
             return false;
         for (const sessionID of this.prune())
             this.publish(sessionID);
+        if (event.type === "server.connected") {
+            // Delivery across a connection gap cannot share a throughput window.
+            for (const step of this.active.values()) {
+                this.resetLive(step);
+                this.publish(step.sessionID);
+            }
+            void this.checkActivity(true);
+            this.scheduleCleanup();
+            return false;
+        }
         const data = (event.data && typeof event.data === "object" ? event.data : {});
         const sessionID = typeof data.sessionID === "string" ? data.sessionID : undefined;
         if (event.type === "session.deleted") {
@@ -236,8 +332,30 @@ export class PerformanceMonitor {
                 this.deleteSession(sessionID);
             return false;
         }
+        if (!sessionID)
+            return false;
+        if (["session.execution.succeeded", "session.execution.failed", "session.execution.interrupted", "session.idle"].includes(event.type)
+            || (event.type === "session.status" && data.status?.type === "idle")) {
+            for (const step of this.active.values()) {
+                if (step.sessionID !== sessionID || !finite(event.created) || event.created < step.latest)
+                    continue;
+                step.latest = event.created;
+                this.finish(step);
+            }
+            this.scheduleCleanup();
+            return false;
+        }
+        if (event.type === "session.execution.started"
+            || (event.type === "session.status" && ["busy", "retry"].includes(String(data.status?.type)))) {
+            for (const step of this.active.values()) {
+                if (step.sessionID === sessionID && finite(event.created) && event.created >= step.latest)
+                    this.touch(step, event.created);
+            }
+            this.scheduleCleanup();
+            return false;
+        }
         const messageID = typeof data.assistantMessageID === "string" ? data.assistantMessageID : undefined;
-        if (!sessionID || !messageID)
+        if (!messageID)
             return false;
         const key = this.key(sessionID, messageID);
         if (event.type === "session.step.started") {
@@ -245,29 +363,65 @@ export class PerformanceMonitor {
                 return false;
             if (this.active.has(key))
                 return false;
+            // A session's foreground steps are serial; missing endings must not accumulate
+            // forever just because the same session continues to run later steps.
+            for (const step of this.active.values()) {
+                if (step.sessionID !== sessionID)
+                    continue;
+                if (step.started > data.started)
+                    return false;
+            }
+            for (const step of this.active.values()) {
+                if (step.sessionID !== sessionID)
+                    continue;
+                step.latest = Math.max(step.latest, data.started);
+                this.finish(step);
+            }
             this.active.set(key, {
                 messageID, sessionID, started: data.started, bytes: 0, samples: [], events: new Set(),
+                checkedAt: this.monotonic(), revision: 0, latest: Math.max(data.started, finite(event.created) ? event.created : data.started),
             });
+            this.scheduleCleanup();
             return false;
         }
         const step = this.active.get(key);
         if (!step)
             return false;
+        if (event.type === "session.retry.scheduled" || (event.type.startsWith("session.tool.") && event.type !== "session.tool.input.delta")) {
+            if (!finite(event.created) || event.created < step.latest)
+                return false;
+            if (event.type === "session.retry.scheduled") {
+                delete step.finishedAt;
+                delete step.inactive;
+                delete step.reconciledAt;
+                delete step.streamed;
+                this.resetLive(step);
+                const sample = this.observed.get(key);
+                if (sample)
+                    delete sample.expiresAt;
+            }
+            this.touch(step, event.created);
+            this.scheduleCleanup();
+            return false;
+        }
         if (event.type === "session.step.streamed") {
             if (!finite(event.created) || event.created < step.started)
                 return false;
+            if (step.streamed !== undefined && event.created <= step.streamed)
+                return false;
             step.streamed = event.created;
+            this.touch(step, event.created);
+            this.scheduleCleanup();
             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;
-            if (step.reconciledAt !== undefined)
-                this.active.delete(key);
+            if (finite(event.created) && event.created < step.latest)
+                return false;
+            if (finite(event.created))
+                step.latest = event.created;
+            this.finish(step);
             this.scheduleCleanup();
             return false;
         }
@@ -280,8 +434,11 @@ export class PerformanceMonitor {
             return false;
         if (event.id && step.events.has(event.id))
             return false;
+        if (step.finishedAt !== undefined && !step.inactive)
+            return false;
         if (event.id)
             step.events.add(event.id);
+        this.touch(step, event.created);
         if (step.reconciledAt !== undefined) {
             // A later delta means the snapshot did not represent the final stream.
             delete step.reconciledAt;
@@ -330,23 +487,24 @@ export class PerformanceMonitor {
     }
     reconcile(messages, sessionIDs) {
         const sessions = new Set(sessionIDs);
-        const represented = new Set();
+        if (this.disposed)
+            return;
+        const represented = new Map();
         for (const message of messages) {
             if (message.type === "assistant" && (message.tokens || message.time?.streamed !== undefined
                 || message.time?.completed !== undefined))
-                represented.add(message.id);
+                represented.set(message.id, message);
         }
-        for (const [key, step] of this.active) {
+        for (const step of this.active.values()) {
             if (sessions.has(step.sessionID) && represented.has(step.messageID)) {
-                if (step.finishedAt !== undefined)
-                    this.active.delete(key);
-                else {
-                    // A snapshot can arrive before step.ended. Retain the step to attach
-                    // the real expiry later, and set a fallback if that event is lost.
-                    step.reconciledAt ??= this.now();
-                    const sample = this.observed.get(key);
-                    if (sample)
-                        sample.expiresAt ??= step.reconciledAt + this.retention;
+                // streamed/tokens describe the provider boundary, not tool settlement.
+                // Only completion or an authoritative inactive session permits expiry;
+                // a stale pre-retry completion cannot settle newer activity.
+                step.reconciledAt ??= this.monotonic();
+                const completed = represented.get(step.messageID)?.time?.completed;
+                if (finite(completed) && completed >= step.latest) {
+                    step.latest = completed;
+                    this.finish(step);
                 }
             }
         }

package/dist/prices.generated.d.ts

@@ -1,5 +1,5 @@
 export declare const GENERATED_PRICE_SNAPSHOT: {
-    readonly verified: "2026-10-08";
+    readonly verified: "2026-10-14";
     readonly source: "https://models.dev/api.json";
     readonly entries: readonly [{
         readonly providerID: "ai21";
@@ -1129,6 +1129,17 @@ export declare const GENERATED_PRICE_SNAPSHOT: {
             };
         }];
         readonly released: "2026-09-02";
+    }, {
+        readonly providerID: "google";
+        readonly id: "gemini-4-argon";
+        readonly prices: readonly [{
+            readonly input: 2;
+            readonly output: 10;
+            readonly cache: {
+                readonly read: 0.1;
+            };
+        }];
+        readonly released: "2026-10-13";
     }, {
         readonly providerID: "google";
         readonly id: "gemini-flash-latest";
@@ -1250,6 +1261,17 @@ export declare const GENERATED_PRICE_SNAPSHOT: {
             };
         }];
         readonly released: "2026-09-02";
+    }, {
+        readonly providerID: "meta";
+        readonly id: "muse-wonder-1.0";
+        readonly prices: readonly [{
+            readonly input: 4;
+            readonly output: 20;
+            readonly cache: {
+                readonly read: 0.2;
+            };
+        }];
+        readonly released: "2026-10-12";
     }, {
         readonly providerID: "minimax";
         readonly id: "minimax-m2";

package/dist/prices.generated.js

@@ -1,5 +1,5 @@
 export const GENERATED_PRICE_SNAPSHOT = {
-    verified: "2026-10-08",
+    verified: "2026-10-14",
     source: "https://models.dev/api.json",
     entries: [
         { "providerID": "ai21", "id": "jamba-large", "prices": [{ "input": 2, "output": 8 }], "released": "2025-07-01" },
@@ -106,6 +106,7 @@ export const GENERATED_PRICE_SNAPSHOT = {
         { "providerID": "google", "id": "gemini-3.6-flash", "prices": [{ "input": 0.75, "output": 3.75, "cache": { "read": 0.075 } }], "released": "2026-07-21" },
         { "providerID": "google", "id": "gemini-3.7-flash", "prices": [{ "input": 0.75, "output": 3.75, "cache": { "read": 0.075 } }], "released": "2026-08-13" },
         { "providerID": "google", "id": "gemini-3.8-flash", "prices": [{ "input": 0.75, "output": 3.75, "cache": { "read": 0.075 } }], "released": "2026-09-02" },
+        { "providerID": "google", "id": "gemini-4-argon", "prices": [{ "input": 2, "output": 10, "cache": { "read": 0.1 } }], "released": "2026-10-13" },
         { "providerID": "google", "id": "gemini-flash-latest", "prices": [{ "input": 0.75, "output": 3.75, "cache": { "read": 0.075 } }], "released": "2026-08-13" },
         { "providerID": "google", "id": "gemini-flash-lite-latest", "prices": [{ "input": 0.3, "output": 2.5, "cache": { "read": 0.03 } }], "released": "2026-07-21" },
         { "providerID": "inception", "id": "mercury-2", "prices": [{ "input": 0.25, "output": 0.75, "cache": { "read": 0.025 } }], "released": "2026-02-24" },
@@ -117,6 +118,7 @@ export const GENERATED_PRICE_SNAPSHOT = {
         { "providerID": "meta", "id": "muse-spark-1.2-contributor", "prices": [{ "input": 0.1, "output": 0.2, "cache": { "read": 0.002 } }], "released": "2026-08-05" },
         { "providerID": "meta", "id": "muse-spark-1.3", "prices": [{ "input": 1.25, "output": 4.25, "cache": { "read": 0.15 } }], "released": "2026-09-02" },
         { "providerID": "meta", "id": "muse-spark-1.3-contributor", "prices": [{ "input": 0.1, "output": 0.2, "cache": { "read": 0.002 } }], "released": "2026-09-02" },
+        { "providerID": "meta", "id": "muse-wonder-1.0", "prices": [{ "input": 4, "output": 20, "cache": { "read": 0.2 } }], "released": "2026-10-12" },
         { "providerID": "minimax", "id": "minimax-m2", "prices": [{ "input": 0.3, "output": 1.2 }], "released": "2025-10-27" },
         { "providerID": "minimax", "id": "minimax-m2.1", "prices": [{ "input": 0.3, "output": 1.2, "cache": { "read": 0.03, "write": 0.375 } }], "released": "2025-12-23" },
         { "providerID": "minimax", "id": "minimax-m2.5", "prices": [{ "input": 0.3, "output": 1.2, "cache": { "read": 0.03, "write": 0.375 } }], "released": "2026-02-12" },

package/dist/pricing.d.ts

@@ -14,7 +14,7 @@ export interface OfficialPriceEntry {
 /** Checked-in data: updating prices is explicit, not a network request at
  * startup, during a refresh, or during an npm build. */
 export declare const OFFICIAL_PRICE_SNAPSHOT: {
-    verified: "2026-10-08";
+    verified: "2026-10-14";
     source: "https://models.dev/api.json";
     entries: OfficialPriceEntry[];
 };

package/dist/runtime.d.ts

@@ -15,16 +15,23 @@ export interface PreparedRuntime {
         milliseconds: number;
     };
 }
+/** Native session metadata from the existing session read; omitted metadata is unknown. */
+export interface RuntimeTime {
+    created: number;
+    idle?: number;
+}
 /**
  * OpenCode 2.0.26's TUI turnDuration/inputIndex: completed assistant time minus
  * the first user/synthetic input after the previous idle marker, or the nearest
- * input in legacy histories with no idle markers. With no input it falls back
- * to the assistant's creation time. Take only the final response in each turn:
+ * input in legacy histories with no idle markers. Native session metadata with
+ * no previous idle identifies the first turn, even before its first marker.
+ * With no input it falls back to the assistant's creation time.
+ * Take only the final response in each turn:
  * intermediate footer durations overlap and must never be added separately.
  * No execution-log API, client clock, child history, or additional reads.
  */
-export declare function summarizeRuntime(messages: readonly UsageMessage[], fork?: boolean): RuntimeSummary;
+export declare function summarizeRuntime(messages: readonly UsageMessage[], fork?: boolean, time?: RuntimeTime): RuntimeSummary;
 /** Scan history once per snapshot, keeping the current turn's overlapping subtotal separate. */
-export declare function prepareRuntime(messages: readonly UsageMessage[], fork?: boolean): PreparedRuntime;
+export declare function prepareRuntime(messages: readonly UsageMessage[], fork?: boolean, time?: RuntimeTime): PreparedRuntime;
 /** Replace, rather than add to, an already-counted footer in the same steered turn. */
 export declare function projectRuntime(prepared: PreparedRuntime, now: number | undefined): RuntimeSummary;

package/dist/runtime.js

@@ -3,18 +3,24 @@ const timestamp = (value) => typeof value === "number" && value >= 0
 /**
  * OpenCode 2.0.26's TUI turnDuration/inputIndex: completed assistant time minus
  * the first user/synthetic input after the previous idle marker, or the nearest
- * input in legacy histories with no idle markers. With no input it falls back
- * to the assistant's creation time. Take only the final response in each turn:
+ * input in legacy histories with no idle markers. Native session metadata with
+ * no previous idle identifies the first turn, even before its first marker.
+ * With no input it falls back to the assistant's creation time.
+ * Take only the final response in each turn:
  * intermediate footer durations overlap and must never be added separately.
  * No execution-log API, client clock, child history, or additional reads.
  */
-export function summarizeRuntime(messages, fork = false) {
-    return prepareRuntime(messages, fork).summary;
+export function summarizeRuntime(messages, fork = false, time) {
+    return prepareRuntime(messages, fork, time).summary;
 }
 /** Scan history once per snapshot, keeping the current turn's overlapping subtotal separate. */
-export function prepareRuntime(messages, fork = false) {
+export function prepareRuntime(messages, fork = false, time) {
+    // A new session has not recorded an idle yet. Merely missing a message marker
+    // must not turn synthetic deliveries/steers into new turns during that run.
+    // Unknown metadata retains the native legacy fallback, as does a past idle.
+    const firstTurn = timestamp(time?.created) && time?.idle === undefined;
     // Even a copied marker identifies the host's turn semantics for an open fork.
-    const legacy = !messages.some(message => message.type === "idle");
+    const legacy = !firstTurn && !messages.some(message => message.type === "idle");
     // Fork copies belong to the original session, including copied turn boundaries.
     const history = fork ? messages.filter(message => !/_\d+$/.test(message.id)) : messages;
     let milliseconds = 0, unavailable = false;

package/dist/source.d.ts

@@ -1,7 +1,8 @@
 import type { OpenCodeClient, SessionInfo } from "@opencode/client";
 import type { ContextSources } from "./context-sources.js";
+import type { ReadActiveSessions } from "./performance.js";
 import type { PriceCatalog, UsageMessage } from "./usage.js";
-export type Session = Pick<SessionInfo, "id" | "parentID" | "fork" | "model" | "location" | "title" | "revert">;
+export type Session = Pick<SessionInfo, "id" | "parentID" | "fork" | "model" | "location" | "title" | "revert"> & Partial<Pick<SessionInfo, "time">>;
 export interface Page<T> {
     data: T[];
     cursor: {
@@ -21,6 +22,7 @@ export interface UsageSource {
     messages(id: string, cursor: string | undefined, signal: AbortSignal): Promise<Page<UsageMessage>>;
     model(session: Session, signal: AbortSignal): Promise<ActiveModel>;
     composition?(session: Session, signal: AbortSignal): Promise<ContextSources | undefined>;
+    active?: ReadActiveSessions;
 }
 export declare function createSource(client: OpenCodeClient): UsageSource;
 export declare function pages<T>(read: (cursor?: string) => Promise<Page<T>>, signal: AbortSignal): Promise<T[]>;

package/dist/source.js

@@ -3,6 +3,16 @@ import { parseContextSources } from "./context-sources.js";
 import { modelKey } from "./usage.js";
 export function createSource(client) {
     return {
+        async active(signal) {
+            // V2 returns the complete process-wide foreground-drain set, already unwrapped
+            // by the Promise client. Cached TUI status can still be stale after reconnect.
+            const active = await client.session.active({ signal });
+            if (!active || typeof active !== "object" || Array.isArray(active)
+                || Object.values(active).some(value => !value || value.type !== "running")) {
+                throw new Error("Invalid active session snapshot");
+            }
+            return new Set(Object.keys(active));
+        },
         session: (sessionID, signal) => client.session.get({ sessionID }, { signal }),
         children: (parentID, cursor, signal) => client.session.list(cursor ? { cursor } : { parentID, order: "asc", limit: 100 }, { signal }),
         // Unlike session.context(), message.list() includes pre-compaction history.

package/dist/tui.js

@@ -960,7 +960,9 @@ export default Plugin.define({
   setup(context) {
     const performance = new PerformanceMonitor(listener => context.data.listen(({
       details
-    }) => listener(details)));
+    }) => listener(details)), {
+      active: createSource(context.client).active
+    });
     const runtime = new RuntimeMonitor(listener => context.data.listen(({
       details
     }) => listener(details)));

package/docs/verification.md

@@ -1,5 +1,73 @@
 # 验证记录
 
+## 2026-10-14 · 首轮 Run Time 起点重置与重连归零（未发布）
+
+无 idle 消息并不一定是旧历史：新会话的第一轮在执行结束前也没有该标记。此前每次 synthetic／steer 输入都被当成 legacy 轮次边界，工具延续时丢失首轮之前已经过去的时间；重新读取历史或重建视图可以重新暴露该少算。匿名固定夹具复现原先 `~1m 56s` 与正确 `~18m 57s` 的差异，不依赖屏幕操作。
+
+`src/runtime.ts` 接收既有会话读取的原生时间元数据：有效 `time.created` 且尚未设置 `time.idle` 时，首轮使用首个 user／synthetic 输入，即使尚未产生第一条 idle 消息。工具、retry 与 steer 保持同轮，完成页脚替换重叠时长；首次 idle 前后的 native 小计一致。已有原生 idle 时间（包括零）或元数据未知的无标记旧历史仍使用最近输入。会话创建时间只用于区分边界语义，不代替缺失的输入时间、不会按会话年龄计时。`src/source.ts` 保留原有 `session.get()` 返回的时间字段，控制器复用它，没有新增请求、周期读取或持久化。
+
+另修复 `src/controller.ts` 的重连窗口：历史读取可以早于可选 clock RPC 返回，不能把同一仍保留的开放轮次的可信 `~` 值替换成原生零小计。只有起点一致、此前 assistant 仍在历史中且不含当前轮的历史小计未变时保留冻结显示；等待可信锚点期间停止 ticker。完成／中断、回退删除及替换历史仍使用新历史的权威数值，允许合法向下校正，不使用最大值锁掩盖差异。
+
+已核对 V2 插件／CLI／Client／API 文档、SDK 2.0.24 的 `SessionInfo.time`，以及版本固定的宿主 [`2.0.9 projector`](https://github.com/anomalyco/opencode/blob/v2.0.9/packages/core/src/session/projector.ts)、[`2.0.28 projector`](https://github.com/anomalyco/opencode/blob/v2.0.28/packages/core/src/session/projector.ts) 与 [`2.0.28 info`](https://github.com/anomalyco/opencode/blob/v2.0.28/packages/core/src/session/info.ts)：新建／分叉不继承 `time_idle`，原生执行结束记录它；未设置时 API 不输出 `time.idle`。2.0.28 的 `turnDuration`／`inputIndex`、分叉副本 ID、完成 compaction 与升序历史语义已复核；首轮的元数据修正避免其首次 idle 前临时误用 legacy 回退。
+
+环境：macOS、Node.js v22.23.2、npm 10.9.8，插件包 0.4.9、SDK 2.0.24、OpenTUI 0.5.14、真实 OpenCode 2.0.28。此前 2.0.11／2.0.22／2.0.24／2.0.26 的验证记录保留，不宣称这些宿主本次全部重跑。
+
+| 检查 | 结果 |
+| --- | --- |
+| `npm run typecheck` | 通过 |
+| `npm test` | 247 项通过，新增 13 项首轮、恢复及适配器回归测试 |
+| `npm run build` | 通过 |
+| `node --check scripts/smoke.mjs`、`git diff --check` | 通过 |
+| `npm run test:smoke` | 真实 OpenCode 2.0.28 打包／隔离安装的完整检查通过，含首轮延续场景 |
+
+自动化测试覆盖多次 synthetic 投递造成的约 17 分钟少算、首次 idle 前后完成结算、首轮 steer／retry 页脚替换、无 marker 的分叉、旧历史最近输入、缺失／无效消息时间、同一视图刷新、sidebar／详情同时重建、暂停回调后一次补齐两分钟、慢校时期间冻结及恢复、新监视器的一次 clock 读取，以及历史替换／小计变化不能继承旧冻结值。暂停、重连和慢 RPC 由注入的事件、单调时钟与可控 Promise 验证，不是实际断网或操作系统暂停。
+
+新增真实宿主首轮场景：本地模拟提供商先返回 subagent 工具调用，两个原生 synthetic inbox 项在同一轮投递，继续输出保持门控等待。确认消息中没有 idle、原生 `time.idle` 也未设置；打包算法与侧边栏均从最初输入计时，完成之前 native 小计保持零。可见耗时为投递前 `~4.4s`、投递后 `~7.2s`、新 TUI 恢复 `~8.7s`、终端失焦／恢复 `~9.2s`、紧凑／详细 `/usage` `~9.4s`，各实时值与服务端 clock 减原始输入相符。结束后两个 TUI 均恢复原生 9,564ms；原有上下文、定价、TPS／TTFT、Responses、子代理、分叉及 compaction 的完整检查也通过。模拟提供商只在本地，不调用付费模型、不修改现有 OpenCode 配置。
+
+验证产物：`/private/var/folders/rw/bmx6c8hd737brl55m0_ff_b80000gn/T/opencode/token-usage-smoke-DIvmzk`。`13-first-turn-*.txt`／`.ansi` 保存首轮各入口，`result.json` 的 `firstTurnRuntime` 保存最初输入、投递项、实测参考与显示值及最终 native 时长。2.0.28 已加入实际验证宿主记录；Node 22 的既有 OpenTUI 引擎警告与 MockTimers 实验警告保留。
+
+用户报告的 **macOS 物理多屏切换** 尚未实机复验：上述终端焦点事件、新 TUI 恢复和模拟重连不代表已确认物理切屏是原因，也不代表已验证 App Nap 或睡眠／唤醒。中英文 README、产品约定与路线图已同步；版本、SDK 与价格快照未变，未升级版本、提交、推送或发布。
+
+## 2026-10-11 · 性能监视器异常流回收（未发布）
+
+`PerformanceMonitor` 在 `server.connected` 后重置近期 TPS 窗口，并通过 V2 `session.active()` 对账全部已跟踪的未结束流，包括离屏会话。未结束流静默 60 秒后进行共享活动检查，每次请求覆盖全部未结束流；确认 inactive 后保留 60 秒，再释放流、去重事件集合和 TTFT 观察。没有未结束流时停止活动查询，增量及 2 秒 TPS 窗口过期仍使用内存，不读取历史。状态请求有 5 秒超时；失败保留并重试，请求身份及逐流 revision 防止迟到响应覆盖新活动、重连及销毁。
+
+历史 tokens／`time.streamed` 只表示提供商已交付，不能证明工具已完成，不再单独触发 TTFT／流状态回收。有效历史 `time.completed`、step／execution 结束或后继 step 可以结算，重复结束不延长保留期；旧结束／重试不能影响新 step，重试可撤销此前失败的回收。回收与静默检查都用本地单调时钟。服务端仍 running 的长工具等待、首 token 前等待和重试没有硬性寿命上限。
+
+环境：macOS、Node.js v22.23.2、npm 10.9.8，插件包 0.4.9、SDK 2.0.24、OpenTUI 0.5.14。已复核 V2 插件、CLI 插件与官方 OpenAPI 文档，以及已安装 SDK 的 `session.active()` Promise 解包形状、execution／step／retry／tool 事件；活动集合覆盖本进程的前台执行，缺席才表示 inactive，读取异常不能代替空集合。
+
+| 检查 | 结果 |
+| --- | --- |
+| `npm run typecheck` | 通过 |
+| `npm test` | 234 项通过，新增 29 项生命周期、控制器及适配器回归测试 |
+| `npm run build` | 通过 |
+| `node --check scripts/smoke.mjs`、`git diff --check` | 通过 |
+| `npm run test:smoke` | 真实 OpenCode 2.0.26 打包／隔离安装的完整复验通过，包含新增异常流场景 |
+
+自动化测试覆盖无视图／无结束事件／无后续历史的自主回收、首 token 缺失、session 结束兜底、连续 step 替代、长工具等待及 streamed-only 历史、长重试、跨树重连、交错会话的共享查询、失败／超时重试、新 delta／工具进度／retry／execution 活动与慢查询竞态、重复重连及取消失效、旧状态响应、重复结束不续期、单调时钟、删除／销毁与空监视器停止查询。关闭全部控制器后回收离屏流，再打开对应会话不会恢复过期 TTFT。
+
+首轮真实 OpenCode 2.0.26 的原有整套检查通过，新增场景因测试要求父会话必须有实时 TTFT 而超时。事件记录确认宿主可以直接交付完整工具参数、没有 `session.tool.input.delta`，父会话因此没有可测实时 TTFT；其流状态仍应保留。测试已改为同时确认父／子流存在，并保留实际可测的子会话 TTFT，不伪造父会话样本。首轮记录：`/private/var/folders/rw/bmx6c8hd737brl55m0_ff_b80000gn/T/opencode/token-usage-smoke-nvGQ95`。
+
+完整复验使用真实宿主执行 subagent 工具、由本地模拟提供商暂缓子会话输出；独立的打包监视器没有挂载视图，也没有接收历史对账。测试过滤其 step／execution 结束事件，注入与宿主相同的无 `created` 重连握手，并将该监视器的单调时钟加速至 1 小时、累计 25 小时。两次真实活动查询都包含父／子会话，两条流一直保留，子会话 TTFT 始终为 418ms；结束后第三次活动集合为空，监视器回收全部流与观察并停止定时任务。此处验证的是加速年龄及注入的事件丢失／重连路径，不是实际等待 25 小时或切断真实网络连接。
+
+通过记录：`/private/var/folders/rw/bmx6c8hd737brl55m0_ff_b80000gn/T/opencode/token-usage-smoke-WOFN5d`。`result.json` 的 `performanceLifecycle` 保存会话、90,000,000ms 加速年龄、可测 TTFT 与三次真实活动集合；`stream-events.json` 保存包括被过滤结束事件在内的宿主事件。原有侧边栏、详情、子代理、耗时、TPS 突发／过期、分叉和压缩检查全部通过。中英文 README、产品约定及路线图已同步；插件版本仍为 0.4.9，未升级版本、提交、推送或发布。
+
+## 2026-10-11 · 构建清理与打包文件一致性
+
+`scripts/build.mjs` 在 TypeScript 编译前递归清理 `dist`，目录不存在时也可构建；`npm pack` 的既有 `prepack` 钩子复用该流程。`scripts/smoke.mjs` 的打包断言改为从当前 `src` 推导完整 `.js`／`.d.ts` 清单，精确比对包内 `dist` 文件，统一检测残留、缺失以及未清理的 JSX 中间产物。
+
+环境：macOS、Node.js v22.23.2、npm 10.9.8，插件包 0.4.9。本次执行本地构建与打包专项校验。
+
+| 检查 | 结果 |
+| --- | --- |
+| `npm run typecheck`、`npm test` | 通过，205 项测试全部通过 |
+| `npm run build` | 通过，原有孤儿 `dist/popover.js`／`dist/popover.d.ts` 已清理 |
+| 实际 `npm pack --json` | 预置孤儿 JS、声明及嵌套残留后，`prepack` 全部清理；16 个源码模块对应 32 个 `dist` 文件，tarball 共 41 个文件，归档实际清单与 npm 清单一致 |
+| 重复打包 | 连续两次完整 `prepack`／打包的 SHA-512 integrity 一致 |
+| `node --check scripts/smoke.mjs` | 通过 |
+
+打包验证产物：`/private/var/folders/rw/bmx6c8hd737brl55m0_ff_b80000gn/T/opencode/token-usage-pack-EJkcwj/chenlongapps-opencode-token-usage-0.4.9.tgz`。
+
 ## 2026-10-10 · 移除 Run Time 运行状态动画（未发布）
 
 侧边栏、子代理摘要／完整浮窗以及 `/usage` 紧凑／详细模式直接显示耗时，不再附加 `Running.`／`Running..`／`Running...`。移除 `src/running.ts`、动画专用计时器及其 5 项测试，清理仅供动画使用的会话 ID 传递；各入口的原生状态仍用于控制 `~` 实时估算，共享 500ms 耗时 ticker 与原生累计算法未改动。零值隐藏、不可用／未更新标记及面板末行顺序保持不变。

package/package.json

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