opencode2-tps 0.2.0-rc.1 → 0.2.1-rc.1

package/README.md

@@ -2,13 +2,9 @@
 
 Live token-throughput indicator for the OpenCode 2 TUI prompt composer.
 
-While a session streams, the top right of the composer shows the estimated tokens and the throughput of the current run:
+While a session streams, the top right of the composer shows estimated observable tokens and throughput: `~1712 tok · ~51.5 t/s`
 
-```text
-1712 tok · 51.5 t/s
-```
-
-When the run ends, the number freezes at the run average and stays there until the next run starts. Nothing is shown on the home screen, or before the first token of a run.
+When OpenCode reports terminal usage, the token count becomes exact while TPS remains approximate, for example `1715 tok · ~51.5 t/s`. The result freezes until the next run starts. Nothing is shown on the home screen, or before the first observable output.
 
 <p align="center">
   <img src="docs/screenshots/opencode2_tps.png" width="750" alt="Composer showing live token-throughput indicator" />
@@ -16,7 +12,7 @@ When the run ends, the number freezes at the run average and stays there until t
 
 ## Install
 
-Built against the OpenCode 2 preview. The earliest known compatible beta is `0.0.0-beta-17595`; the latest tested beta is `0.0.0-beta-17639`. The TUI plugin API is still moving, so a much newer or older build may drop the indicator without an error: a renamed event stops arriving, and an unknown composer slot gets quietly rerouted. If the figure never appears, check your CLI version first.
+Built against the OpenCode 2 preview. The earliest known compatible beta is `0.0.0-beta-17595`; the latest tested beta is `0.0.0-beta-17639`. The TUI plugin API is still moving, so a much newer or older build may drop the indicator without an error. If the figure never appears, check your version first.
 
 Add the package to `~/.config/opencode/cli.json`:
 
@@ -69,9 +65,11 @@ The defaults are usable as they are. For the full option list, the ranges and mo
 
 ## How it works
 
-The plugin counts the output bytes of a run and estimates tokens from the byte total. When the host reports the session's real token counts, the plugin measures its own bytes-per-token ratio for that session and switches to it — until then it assumes 4.75 bytes per token. TPS is the run's estimated tokens divided by active model-generation time: timing starts at each step's first output and continues without pause for provider stalls, while tool-execution intervals and time between model steps are excluded.
+While output streams, the plugin estimates tokens from observable UTF-8 bytes at a default of 4.75 bytes per token and calculates a bounded rolling delivery rate. Complete text, reasoning, and tool-input events reconcile buffered or missed deltas without creating artificial live-rate spikes.
+
+At the end of each model step, OpenCode's reported output and reasoning usage replaces the byte estimate. Settled TPS divides those exact tokens by observed step spans ending at the final model-content boundary, which excludes later local tool execution and time between model calls.
 
-The measured ratio depends on the model and is calibrated once per session. Changing models mid-session can therefore make the token and t/s estimates inaccurate; start a new session after switching models for a fresh calibration. This also avoids the prompt-cache disruption associated with changing models in existing sessions.
+TPS is always approximate (`~`) because OpenCode does not expose token-level timestamps. Proprietary reasoning may be encrypted or represented only by a short summary, and some providers buffer tool arguments until completion. During those opaque intervals the live rate holds or becomes unavailable instead of continuously falling. Opaque provider state is never counted by byte length.
 
 For more detail, see [Architecture](docs/development.md#architecture).
 

package/dist/tui.js

@@ -78,7 +78,8 @@ export function isEnvEnabled(value) {
 function mark(line) {
   if (!debugState.enabled) return;
   try {
-    appendFileSync(debugState.file, `${new Date().toISOString()} ${line}\n`);
+    const safeLine = line.replace(/\p{Cc}/gu, character => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`);
+    appendFileSync(debugState.file, `${new Date().toISOString()} ${safeLine}\n`);
   } catch {
     // debug only; never break the host
   }
@@ -92,15 +93,11 @@ export const DEFAULT_CONFIG = {
 };
 // The frozen final average stays visible until the next prompt starts a new run.
 
-// Step completion events carry the generated-token count for that model call.
-// Pairing it with deltas from the same assistant message avoids contamination
-// from concurrent title generation and other session-level usage updates.
-export const CALIBRATION_MIN_BYTES = 2_048;
-export const CALIBRATION_MIN_TOKENS = 50;
-// Bounds shared by the option clamp and the calibration sanity check: a ratio
-// outside them means the report does not describe the bytes the plugin watched.
 const BYTES_PER_TOKEN_MIN = 1;
 const BYTES_PER_TOKEN_MAX = 16;
+const LIVE_WINDOW_MS = 5_000;
+const LIVE_STALE_MS = 1_500;
+const LIVE_MIN_DURATION_MS = 250;
 function estimateTokens(bytes, bytesPerToken) {
   return Math.ceil(bytes / bytesPerToken);
 }
@@ -123,10 +120,6 @@ export class TpsTracker {
   // Insertion order is kept equal to run-start recency (see beginRun), which is
   // what makes eviction from the front drop the stalest session.
   runs = new Map();
-  // Calibrated bytes/token and the currently observed model step. Both share
-  // the bounded lifecycle of `runs`.
-  ratios = new Map();
-  calibrationSteps = new Map();
   constructor(config = DEFAULT_CONFIG) {
     this.config = config;
   }
@@ -135,13 +128,12 @@ export class TpsTracker {
     if (!st) {
       st = {
         phase: "ended",
-        bytes: 0,
-        activeMs: 0,
-        activeAssistantMessageID: null,
-        lastSampleAt: null,
-        activeTools: new Set(),
-        toolPauseStartedAt: null,
-        toolPausedMs: 0,
+        settledTokens: 0,
+        settledDurationMs: 0,
+        tokensEstimated: false,
+        partial: false,
+        activeStep: null,
+        settledSteps: new Set(),
         frozen: null
       };
       this.runs.set(sessionID, st);
@@ -150,15 +142,13 @@ export class TpsTracker {
   }
   beginRun(sessionID) {
     const st = this.state(sessionID);
-    this.calibrationSteps.delete(sessionID);
     st.phase = "running";
-    st.bytes = 0;
-    st.activeMs = 0;
-    st.activeAssistantMessageID = null;
-    st.lastSampleAt = null;
-    st.activeTools.clear();
-    st.toolPauseStartedAt = null;
-    st.toolPausedMs = 0;
+    st.settledTokens = 0;
+    st.settledDurationMs = 0;
+    st.tokensEstimated = false;
+    st.partial = false;
+    st.activeStep = null;
+    st.settledSteps.clear();
     st.frozen = null;
     // Re-insert so this session becomes the newest in iteration order. Every
     // entry is created through here, so the cap is checked on the one path that
@@ -175,159 +165,167 @@ export class TpsTracker {
       this.dropSession(sessionID);
     }
   }
-  advanceTiming(st, now) {
-    if (st.lastSampleAt === null) return;
-    const currentPause = st.toolPauseStartedAt === null ? 0 : Math.max(0, now - st.toolPauseStartedAt);
-    st.activeMs += Math.max(0, now - st.lastSampleAt - st.toolPausedMs - currentPause);
-    st.lastSampleAt = now;
-    st.toolPausedMs = 0;
-    if (st.toolPauseStartedAt !== null) st.toolPauseStartedAt = now;
+  ensureStep(sessionID, assistantMessageID, now, replace = false) {
+    const st = this.state(sessionID);
+    if (st.settledSteps.has(assistantMessageID) || st.phase === "ended" && st.frozen !== null) return null;
+    if (st.phase !== "running") this.beginRun(sessionID);
+    const running = this.state(sessionID);
+    if (running.activeStep?.assistantMessageID === assistantMessageID) return running.activeStep;
+    if (running.activeStep && !replace) return null;
+    if (running.activeStep) this.settleActiveStep(running, undefined);
+    const step = {
+      assistantMessageID,
+      startedAt: now,
+      lastBoundaryAt: null,
+      observableBytes: 0,
+      blocks: new Map(),
+      samples: []
+    };
+    running.activeStep = step;
+    running.frozen = null;
+    return step;
   }
-  push(sessionID, delta, now, assistantMessageID) {
-    if (!delta) return;
+  beginStep(sessionID, assistantMessageID, now = Date.now()) {
     const st = this.state(sessionID);
-    if (st.phase !== "running") this.beginRun(sessionID); // execution.started missed
-    st.frozen = null;
-    // Bytes accumulate; tokens are derived from the run total, so providers
-    // that emit 1-3 byte deltas are not rounded up on every single one.
-    const bytes = Buffer.byteLength(delta, "utf8");
-    st.bytes += bytes;
-    const calibration = this.calibrationSteps.get(sessionID);
-    if (calibration && calibration.assistantMessageID === assistantMessageID) calibration.bytes += bytes;
-    const stepID = assistantMessageID ?? "";
-    if (st.activeAssistantMessageID !== stepID) {
-      st.activeAssistantMessageID = stepID;
-      st.lastSampleAt = null;
-      st.activeTools.clear();
-      st.toolPauseStartedAt = null;
-      st.toolPausedMs = 0;
-    }
-    if (st.lastSampleAt === null) {
-      st.lastSampleAt = now;
-      if (st.activeTools.size > 0) st.toolPauseStartedAt = now;
-    } else {
-      this.advanceTiming(st, now);
+    if (st.phase !== "running") {
+      if (st.settledSteps.has(assistantMessageID)) return;
+      this.beginRun(sessionID);
     }
+    if (st.activeStep?.assistantMessageID === assistantMessageID) return;
+    this.ensureStep(sessionID, assistantMessageID, now, true);
   }
-
-  /** Start observing one model step for a possible one-shot calibration. */
-  beginStep(sessionID, assistantMessageID) {
-    const st = this.runs.get(sessionID);
-    if (!st || st.phase !== "running") this.beginRun(sessionID);
-    const running = this.runs.get(sessionID);
-    if (running) {
-      running.activeAssistantMessageID = assistantMessageID;
-      running.lastSampleAt = null;
-      running.activeTools.clear();
-      running.toolPauseStartedAt = null;
-      running.toolPausedMs = 0;
+  beginBlock(sessionID, assistantMessageID, blockID, now) {
+    const step = this.ensureStep(sessionID, assistantMessageID, now);
+    if (!step) return;
+    if (!step.blocks.has(blockID)) step.blocks.set(blockID, {
+      streamedBytes: 0,
+      finalBytes: null
+    });
+  }
+  push(sessionID, delta, now, assistantMessageID = "implicit", blockID = "implicit") {
+    if (!delta) return;
+    const step = this.ensureStep(sessionID, assistantMessageID, now);
+    if (!step) return;
+    let block = step.blocks.get(blockID);
+    if (!block) {
+      block = {
+        streamedBytes: 0,
+        finalBytes: null
+      };
+      step.blocks.set(blockID, block);
     }
-    if (this.ratios.has(sessionID)) return;
-    this.calibrationSteps.set(sessionID, {
-      assistantMessageID,
-      bytes: 0
+    if (block.finalBytes !== null) return;
+    const bytes = Buffer.byteLength(delta, "utf8");
+    block.streamedBytes += bytes;
+    step.observableBytes += bytes;
+    step.samples.push({
+      bytes,
+      timestamp: now
     });
+    const oldest = now - LIVE_WINDOW_MS;
+    while (step.samples[0] && step.samples[0].timestamp < oldest) step.samples.shift();
   }
-
-  /** Pair a completed step's usage with deltas from that assistant message. */
-  finishStep(sessionID, assistantMessageID, generatedTokens, now) {
+  finishBlock(sessionID, assistantMessageID, blockID, text, now) {
     const st = this.runs.get(sessionID);
-    if (st?.activeAssistantMessageID === assistantMessageID) {
-      this.advanceTiming(st, now);
-      st.activeAssistantMessageID = null;
-      st.lastSampleAt = null;
-      st.activeTools.clear();
-      st.toolPauseStartedAt = null;
-      st.toolPausedMs = 0;
-    }
-    const calibration = this.calibrationSteps.get(sessionID);
-    if (!calibration || calibration.assistantMessageID !== assistantMessageID) return;
-    this.calibrationSteps.delete(sessionID);
-    if (this.ratios.has(sessionID)) return;
-    if (generatedTokens === undefined || !Number.isFinite(generatedTokens) || generatedTokens < CALIBRATION_MIN_TOKENS) return;
-    const bytes = calibration.bytes;
-    if (bytes < CALIBRATION_MIN_BYTES) return;
-    const ratio = bytes / generatedTokens;
-    if (ratio < BYTES_PER_TOKEN_MIN || ratio > BYTES_PER_TOKEN_MAX) {
-      mark(`calibration rejected sid=${sessionID} bytes=${bytes} tokens=${generatedTokens} ratio=${ratio.toFixed(2)}`);
-      return;
+    const step = st?.activeStep;
+    if (!step || step.assistantMessageID !== assistantMessageID) return;
+    let block = step.blocks.get(blockID);
+    if (!block) {
+      block = {
+        streamedBytes: 0,
+        finalBytes: null
+      };
+      step.blocks.set(blockID, block);
     }
-    this.ratios.set(sessionID, ratio);
-    mark(`calibrated sid=${sessionID} bytes=${bytes} tokens=${generatedTokens} ratio=${ratio.toFixed(2)}`);
+    if (block.finalBytes !== null) return;
+    block.finalBytes = Buffer.byteLength(text, "utf8");
+    step.observableBytes += block.finalBytes - block.streamedBytes;
+    step.lastBoundaryAt = Math.max(step.lastBoundaryAt ?? now, now);
   }
-  beginTool(sessionID, assistantMessageID, toolID, now) {
-    const st = this.runs.get(sessionID);
-    if (!st || st.activeAssistantMessageID !== assistantMessageID || st.activeTools.has(toolID)) return;
-    if (st.activeTools.size === 0 && st.lastSampleAt !== null) st.toolPauseStartedAt = now;
-    st.activeTools.add(toolID);
+  settleActiveStep(st, generatedTokens) {
+    const step = st.activeStep;
+    if (!step) return;
+    const exact = generatedTokens !== undefined && Number.isFinite(generatedTokens) && generatedTokens >= 0;
+    st.settledTokens += exact ? generatedTokens : estimateTokens(step.observableBytes, this.config.bytesPerToken);
+    if (!exact) {
+      st.tokensEstimated = true;
+      st.partial = true;
+    }
+    if (step.lastBoundaryAt !== null) st.settledDurationMs += Math.max(0, step.lastBoundaryAt - step.startedAt);
+    st.settledSteps.add(step.assistantMessageID);
+    st.activeStep = null;
   }
-  finishTool(sessionID, assistantMessageID, toolID, now) {
+  finishStep(sessionID, assistantMessageID, generatedTokens, _now) {
     const st = this.runs.get(sessionID);
-    if (st?.activeAssistantMessageID !== assistantMessageID || !st.activeTools.delete(toolID) || st.activeTools.size > 0) return;
-    if (st.toolPauseStartedAt !== null) st.toolPausedMs += Math.max(0, now - st.toolPauseStartedAt);
-    st.toolPauseStartedAt = null;
+    if (st?.activeStep?.assistantMessageID !== assistantMessageID) return;
+    this.settleActiveStep(st, generatedTokens);
   }
-
-  /** The session's calibrated ratio, or the configured fallback. */
-  ratioFor(sessionID) {
-    return this.ratios.get(sessionID) ?? this.config.bytesPerToken;
-  }
-  finish(sessionID, now) {
+  finish(sessionID, _now) {
     const st = this.runs.get(sessionID);
     if (!st || st.phase === "ended") return;
-    this.calibrationSteps.delete(sessionID);
+    if (st.activeStep) this.settleActiveStep(st, undefined);
     st.phase = "ended";
-    this.advanceTiming(st, now);
-    st.lastSampleAt = null;
-    st.activeAssistantMessageID = null;
-    st.activeTools.clear();
-    st.toolPauseStartedAt = null;
-    st.toolPausedMs = 0;
-    const tokens = estimateTokens(st.bytes, this.ratioFor(sessionID));
+    const tokens = st.settledTokens;
     if (tokens <= 0) {
       this.evictStale();
       return;
     }
-    const seconds = Math.max(st.activeMs, 1) / 1000;
+    const tps = st.settledDurationMs > 0 ? tokens / (st.settledDurationMs / 1000) : null;
     st.frozen = {
-      tps: tokens / seconds,
-      tokens
+      tps,
+      tokens,
+      tokensEstimated: st.tokensEstimated,
+      partial: st.partial
     };
-    mark(`finish sid=${sessionID} tokens=${tokens} activeMs=${st.activeMs} tps=${st.frozen.tps.toFixed(1)}`);
+    mark(`finish sid=${sessionID} tokens=${tokens} observedMs=${st.settledDurationMs} tps=${tps?.toFixed(1) ?? "n/a"}`);
     this.evictStale();
   }
   dropSession(sessionID) {
     this.runs.delete(sessionID);
-    this.ratios.delete(sessionID);
-    this.calibrationSteps.delete(sessionID);
   }
   evict(sessionID) {
     this.dropSession(sessionID);
   }
-  hasRunning() {
+  hasRunning(now = Date.now()) {
     for (const st of this.runs.values()) {
-      if (st.phase === "running" && st.activeAssistantMessageID !== null && st.lastSampleAt !== null) return true;
+      const last = st.activeStep?.samples.at(-1);
+      if (st.phase === "running" && last && now < last.timestamp + LIVE_STALE_MS) return true;
     }
     return false;
   }
+  liveTps(step, now) {
+    const last = step.samples.at(-1);
+    if (!last) return null;
+    const effectiveNow = Math.min(now, last.timestamp + LIVE_STALE_MS);
+    const oldest = effectiveNow - LIVE_WINDOW_MS;
+    const samples = step.samples.filter(sample => sample.timestamp >= oldest);
+    const first = samples[0];
+    if (!first) return null;
+    const bytes = samples.reduce((total, sample) => total + sample.bytes, 0);
+    const durationMs = Math.max(effectiveNow - first.timestamp, LIVE_MIN_DURATION_MS);
+    return estimateTokens(bytes, this.config.bytesPerToken) / (durationMs / 1000);
+  }
   value(sessionID, now) {
     const st = this.runs.get(sessionID);
     if (!st) return null;
     if (st.frozen) return {
-      tps: st.frozen.tps,
-      tokens: st.frozen.tokens,
-      frozen: true
+      ...st.frozen,
+      frozen: true,
+      tpsEstimated: true
     };
     if (st.phase !== "running") return null;
-    const tokens = estimateTokens(st.bytes, this.ratioFor(sessionID));
+    const active = st.activeStep;
+    const activeTokens = active ? estimateTokens(active.observableBytes, this.config.bytesPerToken) : 0;
+    const tokens = st.settledTokens + activeTokens;
     if (tokens <= 0) return null;
-    const currentPause = st.toolPauseStartedAt === null ? 0 : Math.max(0, now - st.toolPauseStartedAt);
-    const activeTail = st.lastSampleAt === null ? 0 : Math.max(0, now - st.lastSampleAt - st.toolPausedMs - currentPause);
-    const seconds = Math.max(st.activeMs + activeTail, 1) / 1000;
+    const settledTps = st.settledDurationMs > 0 ? st.settledTokens / (st.settledDurationMs / 1000) : null;
     return {
-      tps: tokens / seconds,
+      tps: active ? this.liveTps(active, now) ?? settledTps : settledTps,
       tokens,
-      frozen: false
+      frozen: false,
+      tokensEstimated: st.tokensEstimated || active !== null,
+      tpsEstimated: true,
+      partial: st.partial
     };
   }
 }
@@ -373,9 +371,11 @@ export function resolveOptions(raw) {
   };
 }
 export function formatLabel(value, display) {
-  if (display === "tokens") return `${value.tokens} tok`;
-  if (display === "tps") return `${formatTps(value.tps)} t/s`;
-  return `${value.tokens} tok · ${formatTps(value.tps)} t/s`;
+  const tokens = `${value.tokensEstimated ? "~" : ""}${value.tokens} tok`;
+  const tps = value.tps === null ? null : `~${formatTps(value.tps)} t/s`;
+  if (display === "tokens") return tokens;
+  if (display === "tps") return tps ?? "— t/s";
+  return tps === null ? tokens : `${tokens} · ${tps}`;
 }
 
 // ---------------------------------------------------------------------------
@@ -385,6 +385,10 @@ export function formatLabel(value, display) {
 // `data.listen` signature) rather than restated structurally: handlers are
 // contravariant, so hand-written shapes keep typechecking after a field rename.
 
+function blockID(e) {
+  if (e.type === "session.tool.input.delta" || e.type === "session.tool.input.started" || e.type === "session.tool.input.ended") return `tool:${e.data.id}`;
+  return `${e.type.startsWith("session.text.") ? "text" : "reasoning"}:${e.data.ordinal}`;
+}
 const definition = {
   id: "opencode2.tps",
   setup(ctx) {
@@ -406,6 +410,16 @@ const definition = {
     configureDebug(options.debug || isEnvEnabled(process.env["TPS_DEBUG"]));
     const tracker = new TpsTracker(options);
     const [version, setVersion] = createSignal(0);
+    const seenEventIDs = new Set();
+    const isNewEvent = e => {
+      if (seenEventIDs.has(e.id)) return false;
+      seenEventIDs.add(e.id);
+      if (seenEventIDs.size > 4_096) {
+        const oldest = seenEventIDs.values().next().value;
+        if (oldest !== undefined) seenEventIDs.delete(oldest);
+      }
+      return true;
+    };
     mark(`setup ok app=${ctx.app.version} gen=${mine} display=${options.display} refreshHz=${options.refreshHz}`);
 
     // Rendering is throttled: deltas arrive at 100-200/s, and every bump costs
@@ -420,9 +434,9 @@ const definition = {
         stopTimer();
         return;
       }
-      const running = tracker.hasRunning();
-      // While a model step is running, elapsed generation time changes even
-      // without new deltas, so republish every tick to expose provider stalls.
+      const running = tracker.hasRunning(Date.now());
+      // The observable live rate decays only through a short stale tail. Opaque
+      // provider work after that is not charged to a numerator we cannot see.
       if (dirty || running) {
         dirty = false;
         setVersion(v => v + 1);
@@ -441,42 +455,42 @@ const definition = {
       timer.unref?.();
     };
     const onDelta = e => {
-      if (!isActive()) return;
-      tracker.push(e.data.sessionID, e.data.delta, Date.now(), e.data.assistantMessageID);
+      if (!isActive() || !isNewEvent(e)) return;
+      tracker.push(e.data.sessionID, e.data.delta, e.created, e.data.assistantMessageID, blockID(e));
+      touch();
+    };
+    const onBlockStarted = e => {
+      if (!isActive() || !isNewEvent(e)) return;
+      tracker.beginBlock(e.data.sessionID, e.data.assistantMessageID, blockID(e), e.created);
+    };
+    const onBlockEnded = e => {
+      if (!isActive() || !isNewEvent(e)) return;
+      tracker.finishBlock(e.data.sessionID, e.data.assistantMessageID, blockID(e), e.data.text, e.created);
       touch();
     };
     const onFinish = e => {
-      if (!isActive()) return;
-      tracker.finish(e.data.sessionID, Date.now());
+      if (!isActive() || !isNewEvent(e)) return;
+      tracker.finish(e.data.sessionID, e.created);
       touch();
     };
     const onStepStarted = e => {
-      if (!isActive()) return;
-      tracker.beginStep(e.data.sessionID, e.data.assistantMessageID);
+      if (!isActive() || !isNewEvent(e)) return;
+      tracker.beginStep(e.data.sessionID, e.data.assistantMessageID, e.created);
+      touch();
     };
     const onStepFinished = e => {
-      if (!isActive()) return;
+      if (!isActive() || !isNewEvent(e)) return;
       const tokens = e.data.tokens;
-      tracker.finishStep(e.data.sessionID, e.data.assistantMessageID, tokens === undefined ? undefined : tokens.output + tokens.reasoning, Date.now());
+      const generatedTokens = tokens !== undefined && Number.isFinite(tokens.output) && tokens.output >= 0 && Number.isFinite(tokens.reasoning) && tokens.reasoning >= 0 ? tokens.output + tokens.reasoning : undefined;
+      tracker.finishStep(e.data.sessionID, e.data.assistantMessageID, generatedTokens, e.created);
       touch();
     };
-    const onToolStarted = e => {
-      if (!isActive()) return;
-      tracker.beginTool(e.data.sessionID, e.data.assistantMessageID, e.data.id, Date.now());
-    };
-    const onToolFinished = e => {
-      if (!isActive()) return;
-      tracker.finishTool(e.data.sessionID, e.data.assistantMessageID, e.data.id, Date.now());
-    };
     const unsubs = [ctx.data.on("session.execution.started", e => {
-      if (!isActive()) return;
+      if (!isActive() || !isNewEvent(e)) return;
       tracker.beginRun(e.data.sessionID);
       touch();
-    }), ctx.data.on("session.text.delta", onDelta), ctx.data.on("session.reasoning.delta", onDelta),
-    // Tool arguments are model output too: without this the indicator blanks
-    // partway through every large write/edit while generation is at full rate.
-    ctx.data.on("session.tool.input.delta", onDelta), ctx.data.on("session.step.started", onStepStarted), ctx.data.on("session.step.ended", onStepFinished), ctx.data.on("session.step.failed", onStepFinished), ctx.data.on("session.tool.called", onToolStarted), ctx.data.on("session.tool.success", onToolFinished), ctx.data.on("session.tool.failed", onToolFinished), ctx.data.on("session.execution.succeeded", onFinish), ctx.data.on("session.execution.failed", onFinish), ctx.data.on("session.execution.interrupted", onFinish), ctx.data.on("session.idle", onFinish), ctx.data.on("session.deleted", e => {
-      if (!isActive()) return;
+    }), ctx.data.on("session.text.delta", onDelta), ctx.data.on("session.reasoning.delta", onDelta), ctx.data.on("session.tool.input.delta", onDelta), ctx.data.on("session.text.started", onBlockStarted), ctx.data.on("session.reasoning.started", onBlockStarted), ctx.data.on("session.tool.input.started", onBlockStarted), ctx.data.on("session.text.ended", onBlockEnded), ctx.data.on("session.reasoning.ended", onBlockEnded), ctx.data.on("session.tool.input.ended", onBlockEnded), ctx.data.on("session.step.started", onStepStarted), ctx.data.on("session.step.ended", onStepFinished), ctx.data.on("session.step.failed", onStepFinished), ctx.data.on("session.execution.succeeded", onFinish), ctx.data.on("session.execution.failed", onFinish), ctx.data.on("session.execution.interrupted", onFinish), ctx.data.on("session.idle", onFinish), ctx.data.on("session.deleted", e => {
+      if (!isActive() || !isNewEvent(e)) return;
       tracker.evict(e.data.sessionID);
       touch();
     })];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode2-tps",
-  "version": "0.2.0-rc.1",
+  "version": "0.2.1-rc.1",
   "description": "Live token-throughput indicator for the OpenCode 2 TUI prompt composer",
   "license": "MIT",
   "author": "P-Theo",