dsh-token-total 1.1.2 → 1.1.3

package/README.md

@@ -43,7 +43,7 @@ DSH（DeepSeek Harness）Web 插件：**Token 用量统计看板** + **单会话
 - **Token 胶囊**显示的是**整棵会话树**（主智能体 + 全部子智能体）的合计，点开弹窗分为「主智能体 / 子智能体 / 会话合计」三行，并给出子智能体会话数。
 - 子智能体是独立持久化的会话，通过日志头的 `parentSession` 串成树；插件按需重放这些日志汇总（同一套 `(turn, step)` 去重规则，且跳过 fork 继承来的事件前缀，避免与父会话重复计数）。
 - **会话 Token 明细始终开启**：未命中缓存、缓存读 / 写、输出分别列出；底部胶囊的缓存命中率始终显示两位小数。
-- **流式吞吐速度始终开启**：始终显示当前的实时解码速度——输出过程中按已到达的流式增量实测（每步开始约 0.2 秒内出首个读数）；一步结算后保持该步最后的实测值，工具执行、步间空档也不回落到会话均值，只有从未产生过输出的会话才显示会话累计的精确值。
+- **流式吞吐速度始终开启**：输出过程中显示当前这一步的实时解码速度——按已到达的流式增量实测（每步开始约 0.2 秒内出首个读数）；一旦没有步骤在流（一步刚结算、工具执行中、步间空档），就交回本轮会话的加权平均解码速度（Σ 输出 token ÷ Σ 解码耗时，与会话「用量」页里的平均速率同口径），而不是停在最后那次短窗口读数上——那正是底部 57 tok/s 与请求记录 156 token/秒看起来互相矛盾的原因。
 - 不再提供底部增强功能的开关；旧版本保存的关闭设置不再影响显示。
 
 ### 会话「用量」页

package/lib/client.js

@@ -31661,14 +31661,14 @@ window.__ModuleLoader__.load({
 		* cannot see.
 		*
 		* Streaming throughput replaces the gauge pill's speed
-		* figure with a live estimate of what is happening now. The figure is the
-		* streaming step's measured rate while one streams and the LAST measured rate
-		* once it settles — a session average describes the whole session's past, and
-		* it cannot match the pace of the answer on screen, which is what users read
-		* as the pill disagreeing with the stream in front of them. The official
-		* session figure only shows on a session that has never streamed. That
-		* subscription lives in
-		* its own child component so stream deltas never re-render the pills. The live
+		* figure with a live estimate of what is happening now, and hands the slot back
+		* to the session's decode average when nothing is streaming. While a step
+		* streams the live rate is the only reading that can match the pace of the
+		* answer on screen; once the step settles it becomes a figure from a window
+		* nobody is watching any more, so the pill returns to the same quotient the
+		* usage view quotes (ΣoutputTokens / ΣdecodeMs) instead of freezing on the last
+		* measurement. That subscription lives in its own child component, so stream
+		* deltas never re-render the pills. The live
 		* figure itself is measured by a bounded sliding window over observed token
 		* growth (stats-line-core's StreamingRateSampler): the earlier cumulative
 		* quotient charged a whole step's text to a window that had just opened, so a
@@ -31754,14 +31754,23 @@ window.__ModuleLoader__.load({
 		* The gauge pill's always-on streaming speed slot.
 		*
 		* It subscribes to `legacy.partial` itself so per-frame deltas re-render only
-		* this child, not the surrounding pills. The figure it carries is the CURRENT
-		* stream's measured rate, and it stays that rate once the step settles:
-		* tool execution and the gap between steps happen inside the same answer, and
-		* the session average this slot used to fall back to there is a figure from
-		* the whole session's past — a number that cannot match the pace of the answer
-		* on screen, which is what reads as "not the real-time speed". The official
-		* session figure is only a session's opening state, shown until the first
-		* window measures anything.
+		* this child, not the surrounding pills. Two figures share the slot, chosen by
+		* whether a step is streaming right now:
+		*
+		* - while one is (`partial != null`), the measured rate of THAT stream — a
+		*   bounded sliding window over observed token growth (stats-line-core's
+		*   StreamingRateSampler), the only reading that can track the pace of the
+		*   answer currently on screen;
+		* - otherwise the session's own decode average, ΣoutputTokens / ΣdecodeMs —
+		*   the same quotient `decodeRateOf` quotes in the usage view. An idle composer
+		*   must not freeze on whatever the last window happened to measure: a settled
+		*   thirty-step turn kept showing its final second-long reading (57 tok/s)
+		*   beside the usage view's 156 tok/s for the same work, and the two read as a
+		*   contradiction rather than as two scopes of one number.
+		*
+		* The measured reading carries the step it was taken in, so a new step cannot
+		* inherit the previous one's figure before its own window publishes; nothing is
+		* held across the gap — the gap is exactly when the average applies.
 		*
 		* One window covers a whole step, across every output kind the accumulator
 		* carries — reasoning, answer text, and Tool-call arguments — because the
@@ -31772,7 +31781,8 @@ window.__ModuleLoader__.load({
 		* state, so no render reads a clock or mutates the window: a render React starts
 		* and then discards must not decide what the next committed one displays. The
 		* rate itself comes from stats-line-core's StreamingRateSampler — a bounded
-		* window over observed token growth, smoothed, and held while nothing arrives.
+		* window over observed token growth, smoothed, and held while nothing arrives
+		* inside the step it belongs to.
 		*/
 		function LiveSpeed({ useChat, scale, fallback, t }) {
 			const partial = useChat((s) => s.legacy.partial);
@@ -31788,13 +31798,17 @@ window.__ModuleLoader__.load({
 			const scaleRef = (0, react.useRef)(scale);
 			const [beat, setBeat] = (0, react.useState)(0);
 			(0, react.useLayoutEffect)(() => {
+				if (key === null) return;
 				if (scaleRef.current !== scale) {
 					scaleRef.current = scale;
 					rate.reset();
 				}
 				rate.observe(tokens, Date.now());
 				const next = rate.ratePerSecond();
-				if (next !== null) setReading((previous) => previous === next ? previous : next);
+				if (next !== null) setReading((previous) => previous !== null && previous.key === key && previous.value === next ? previous : {
+					key,
+					value: next
+				});
 			}, [
 				tokens,
 				key,
@@ -31812,7 +31826,8 @@ window.__ModuleLoader__.load({
 					clearInterval(handle);
 				};
 			}, [streaming]);
-			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SpeedFigure, { text: reading === null ? fallback : t("stats.tokensPerSecond", { throughput: formatTokensPerSecond(reading) }) });
+			const measured = reading !== null && reading.key === key ? reading.value : null;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SpeedFigure, { text: measured === null ? fallback : t("stats.tokensPerSecond", { throughput: formatTokensPerSecond(measured) }) });
 		}
 		function TimePill({ stats, t, dialog, useChat, scale, dock }) {
 			const { open, setOpen, rootRef, panelRef, pos } = useStatDialog(dialog);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-token-total",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "DSH web plugin: token 用量统计看板 + 单会话（主智能体 + 子智能体）用量统计。提供今日/近3天/近7天/近1月/近3月/自定义筛选、六个汇总卡片、活跃热力图、缓存命中率折线与分模型柱状图、按模型/按供应商 Top5 列表。",
   "icon": "./icon.svg",
   "type": "module",

package/src/client/StatsLineEnhanced.tsx

@@ -31,14 +31,14 @@
  * cannot see.
  *
  * Streaming throughput replaces the gauge pill's speed
- * figure with a live estimate of what is happening now. The figure is the
- * streaming step's measured rate while one streams and the LAST measured rate
- * once it settles — a session average describes the whole session's past, and
- * it cannot match the pace of the answer on screen, which is what users read
- * as the pill disagreeing with the stream in front of them. The official
- * session figure only shows on a session that has never streamed. That
- * subscription lives in
- * its own child component so stream deltas never re-render the pills. The live
+ * figure with a live estimate of what is happening now, and hands the slot back
+ * to the session's decode average when nothing is streaming. While a step
+ * streams the live rate is the only reading that can match the pace of the
+ * answer on screen; once the step settles it becomes a figure from a window
+ * nobody is watching any more, so the pill returns to the same quotient the
+ * usage view quotes (ΣoutputTokens / ΣdecodeMs) instead of freezing on the last
+ * measurement. That subscription lives in its own child component, so stream
+ * deltas never re-render the pills. The live
  * figure itself is measured by a bounded sliding window over observed token
  * growth (stats-line-core's StreamingRateSampler): the earlier cumulative
  * quotient charged a whole step's text to a window that had just opened, so a
@@ -181,14 +181,23 @@ const LIVE_SPEED_REFRESH_MS = 1_000
  * The gauge pill's always-on streaming speed slot.
  *
  * It subscribes to `legacy.partial` itself so per-frame deltas re-render only
- * this child, not the surrounding pills. The figure it carries is the CURRENT
- * stream's measured rate, and it stays that rate once the step settles:
- * tool execution and the gap between steps happen inside the same answer, and
- * the session average this slot used to fall back to there is a figure from
- * the whole session's past — a number that cannot match the pace of the answer
- * on screen, which is what reads as "not the real-time speed". The official
- * session figure is only a session's opening state, shown until the first
- * window measures anything.
+ * this child, not the surrounding pills. Two figures share the slot, chosen by
+ * whether a step is streaming right now:
+ *
+ * - while one is (`partial != null`), the measured rate of THAT stream — a
+ *   bounded sliding window over observed token growth (stats-line-core's
+ *   StreamingRateSampler), the only reading that can track the pace of the
+ *   answer currently on screen;
+ * - otherwise the session's own decode average, ΣoutputTokens / ΣdecodeMs —
+ *   the same quotient `decodeRateOf` quotes in the usage view. An idle composer
+ *   must not freeze on whatever the last window happened to measure: a settled
+ *   thirty-step turn kept showing its final second-long reading (57 tok/s)
+ *   beside the usage view's 156 tok/s for the same work, and the two read as a
+ *   contradiction rather than as two scopes of one number.
+ *
+ * The measured reading carries the step it was taken in, so a new step cannot
+ * inherit the previous one's figure before its own window publishes; nothing is
+ * held across the gap — the gap is exactly when the average applies.
  *
  * One window covers a whole step, across every output kind the accumulator
  * carries — reasoning, answer text, and Tool-call arguments — because the
@@ -199,13 +208,16 @@ const LIVE_SPEED_REFRESH_MS = 1_000
  * state, so no render reads a clock or mutates the window: a render React starts
  * and then discards must not decide what the next committed one displays. The
  * rate itself comes from stats-line-core's StreamingRateSampler — a bounded
- * window over observed token growth, smoothed, and held while nothing arrives.
+ * window over observed token growth, smoothed, and held while nothing arrives
+ * inside the step it belongs to.
  */
 function LiveSpeed({ useChat, scale, fallback, t }: {
   useChat: ChatSnapshotSelectorHook
   /** Correction measured from this session's settled steps (1 = raw prior). */
   scale: number
-  /** The official session figure, shown until the slot has measured its own. */
+  /** The session's own decode average (ΣoutputTokens / ΣdecodeMs): what the
+   *  slot shows whenever no step is streaming, and before the streaming step's
+   *  window has published its first reading. */
   fallback: string | null
   t: T
 }) {
@@ -223,18 +235,22 @@ function LiveSpeed({ useChat, scale, fallback, t }: {
     sampler.current = { key, rate: new StreamingRateSampler() }
   }
   const rate = sampler.current.rate
-  // The latest figure this slot has measured, held across step boundaries. A
-  // settled step's rate is still the conversation's current speed until the
-  // next step measures its own, so the display keeps it instead of switching to
-  // a session average the moment the stream goes quiet — holding it is the
-  // point, not a stale value to guard against, which is why no step tag rides
-  // along any more.
-  const [reading, setReading] = useState<number | null>(null)
+  // The figure last measured, tagged with the step it came from. The tag is
+  // what retires it: a reading taken in 3:4 never shows during 3:5, and with
+  // no step streaming (`key === null`) no tag can match at all, so the slot
+  // falls through to the session average on its own — no timer, no clearing
+  // effect, and no stale figure left standing after a turn settles.
+  const [reading, setReading] = useState<{ key: string; value: number } | null>(null)
   const scaleRef = useRef(scale)
   // Every delta re-runs this (its dependencies move), and the beat re-runs it once
   // a second so a step that has gone quiet still advances its window.
   const [beat, setBeat] = useState(0)
   useLayoutEffect(() => {
+    // Nothing is streaming: the slot shows the session average, and there is no
+    // window to advance. Skipping the observation also keeps a settled step's
+    // sampler from being fed a zero estimate, which would re-anchor it against
+    // text that is already counted.
+    if (key === null) return
     // A correction that moved re-prices the whole estimate, so growth already
     // counted under the old one must not be measured against the new one: that
     // would read as a burst the stream never produced.
@@ -244,11 +260,13 @@ function LiveSpeed({ useChat, scale, fallback, t }: {
     }
     rate.observe(tokens, Date.now())
     // A null here means the fresh window has not measured anything yet (a step
-    // that just opened, or one that re-anchored); the figure already on screen
-    // is still the best current reading, so it is left alone.
+    // that just opened, or one that re-anchored); the average stays up until
+    // this step's own window publishes something.
     const next = rate.ratePerSecond()
     if (next !== null) {
-      setReading(previous => (previous === next ? previous : next))
+      setReading(previous => (previous !== null && previous.key === key && previous.value === next
+        ? previous
+        : { key, value: next }))
     }
   }, [tokens, key, beat, rate, scale])
   // Keyed on "a step is streaming", not on the step identity: switching steps
@@ -259,9 +277,12 @@ function LiveSpeed({ useChat, scale, fallback, t }: {
     const handle = setInterval(() => { setBeat(Date.now()) }, LIVE_SPEED_REFRESH_MS)
     return () => { clearInterval(handle) }
   }, [streaming])
-  return <SpeedFigure text={reading === null
+  // The tag test is the whole selection rule: a reading only shows while the
+  // step that produced it is the step streaming now.
+  const measured = reading !== null && reading.key === key ? reading.value : null
+  return <SpeedFigure text={measured === null
     ? fallback
-    : t('stats.tokensPerSecond', { throughput: formatTokensPerSecond(reading) })} />
+    : t('stats.tokensPerSecond', { throughput: formatTokensPerSecond(measured) })} />
 }
 
 function TimePill({ stats, t, dialog, useChat, scale, dock }: {
@@ -278,9 +299,10 @@ function TimePill({ stats, t, dialog, useChat, scale, dock }: {
 }) {
   const { open, setOpen, rootRef, panelRef, pos } = useStatDialog(dialog)
   const counts = t('stats.counts', { turns: stats.turns, steps: stats.steps })
-  // The pill's accessible name stays on the official figure: a screen reader
-  // gets the durable session reading rather than a value that changes every
-  // second while a step streams.
+  // The session figure now serves both jobs: the pill's accessible name (a
+  // screen reader gets the durable session reading rather than a value that
+  // changes every second while a step streams) and the visible figure whenever
+  // no step is streaming.
   const officialTps = stats.decodeMs > 0
     ? t('stats.tokensPerSecond', {
       throughput: formatTokensPerSecond(stats.decodeTokens / (stats.decodeMs / 1_000)),