oc-metricboard 0.1.17 → 0.1.19

package/dist/assistant-progress.js

@@ -1,7 +1,7 @@
 import { estimateTokens } from "./metrics";
 import { parseAssistantTextDelta } from "./event-shapes";
 import { currentRequest } from "./request-state";
-import { eventAggregateID, eventID, eventProperties, stringEventProperty } from "./event-bus";
+import { eventAggregateID, eventID, eventPerfTime, eventProperties, stringEventProperty } from "./event-bus";
 import { recordLiveTokens } from "./live-speed";
 import { ensureTurn, recordTurnFirstToken } from "./turn-state";
 function partEstimateKey(sessionID, messageID, partID) {
@@ -51,7 +51,7 @@ export function applyAssistantDelta(ctx, event) {
         sessionAliases.add(aggregateID);
         state.sessionAliases.set(text.sessionID, sessionAliases);
     }
-    const now = performance.now();
+    const now = eventPerfTime(event, performance.now());
     actions.startSessionTiming(text.sessionID, now);
     const key = partEstimateKey(text.sessionID, text.messageID, text.partID);
     const deltaTokens = estimateTokens(text.delta, ctx.config.estimationRatio);

package/dist/collector.js

@@ -1,10 +1,10 @@
-import { getDisplayInputTokens, getDisplayOutputTokens, getTtft } from "./metrics";
+import { credibleTps, getDisplayInputTokens, getDisplayOutputTokens, getTtft, MAX_CREDIBLE_TPS } from "./metrics";
 import { registerEventHandlers } from "./event-handlers";
 import { hydrateSession, isHydrationApi, callWithFallback } from "./session-hydration";
 import { createSessionTree } from "./session-tree";
 import { getScopeElapsedMs, getSessionElapsedMs, startSessionTiming, stopSessionTiming } from "./session-timing";
 import { clearLiveSpeed, getLiveTps } from "./live-speed";
-import { getTurnTtft, liveRequestOutput, turnInputTokens } from "./turn-state";
+import { getTurnTtft, liveRequestOutput, toolOverlapMs, turnInputTokens } from "./turn-state";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -358,8 +358,21 @@ export function createCollector(api, config, log) {
                     : latest.isStreaming || latestLastActivity === null ? now : latestLastActivity;
                 const saneStart = genStart !== null && Number.isFinite(genStart) && genStart >= 0 && genStart <= now;
                 const saneEnd = genEnd !== null && Number.isFinite(genEnd) && genEnd >= 0 && genEnd <= now + 60_000;
+                let primary = null;
                 if (frTokens > 0 && saneStart && saneEnd && genEnd > genStart) {
-                    displayTps = Math.round((frTokens / ((genEnd - genStart) / 1000)) * 10) / 10;
+                    primary = Math.round((frTokens / ((genEnd - genStart) / 1000)) * 10) / 10;
+                }
+                // Same turn-anchored fallback as the main aggregate, using the latest
+                // request's own turn.
+                const latestTurn = state.turns.get(latest.sessionID);
+                if ((primary === null || primary > MAX_CREDIBLE_TPS) && latestTurn && frTokens > 0) {
+                    const turnEnd = completeTime ?? latestLastActivity ?? now;
+                    const turnWindow = turnEnd - latestTurn.turnStartTime
+                        - toolOverlapMs(latestTurn, latestTurn.turnStartTime, turnEnd);
+                    displayTps = credibleTps(frTokens, turnWindow) ?? primary;
+                }
+                else {
+                    displayTps = primary;
                 }
             }
             result.push({
@@ -506,8 +519,22 @@ export function createCollector(api, config, log) {
                     : foregroundActive || foregroundLastActivity === null ? now : foregroundLastActivity;
                 const saneStart = genStart !== null && Number.isFinite(genStart) && genStart >= 0 && genStart <= now;
                 const saneEnd = genEnd !== null && Number.isFinite(genEnd) && genEnd >= 0 && genEnd <= now + 60_000;
+                let primary = null;
                 if (frTokens > 0 && saneStart && saneEnd && genEnd > genStart) {
-                    displayTps = Math.round((frTokens / ((genEnd - genStart) / 1000)) * 10) / 10;
+                    primary = Math.round((frTokens / ((genEnd - genStart) / 1000)) * 10) / 10;
+                }
+                // Fall back to the turn-anchored window when the per-step window
+                // implies a physically incredible rate: per-delta times may be
+                // delivery-stamped (batched flushes), while turn admission, step
+                // boundaries, and tool spans use discrete truthful anchors.
+                if ((primary === null || primary > MAX_CREDIBLE_TPS) && foregroundTurn && frTokens > 0) {
+                    const turnEnd = completeTime ?? foregroundLastActivity ?? now;
+                    const turnWindow = turnEnd - foregroundTurn.turnStartTime
+                        - toolOverlapMs(foregroundTurn, foregroundTurn.turnStartTime, turnEnd);
+                    displayTps = credibleTps(frTokens, turnWindow) ?? primary;
+                }
+                else {
+                    displayTps = primary;
                 }
             }
             // NEW: Build per-model breakdown for tree scope

package/dist/event-bus.js

@@ -51,6 +51,38 @@ export function statusType(event) {
         return "";
     return typeof status.type === "string" ? status.type : "";
 }
+/**
+ * Host-stamped wall-clock time of an event (V2 envelope `created`, epoch ms),
+ * or null when absent/implausible. V1 events carry no timestamp at all.
+ */
+export function eventCreatedWallTime(event) {
+    if (!isRecord(event))
+        return null;
+    const created = event.created;
+    if (typeof created !== "number" || !Number.isFinite(created) || created <= 0)
+        return null;
+    // Guard against a foreign epoch or clock skew: anything more than a day out
+    // is not usable as event time.
+    if (Math.abs(created - Date.now()) > 86_400_000)
+        return null;
+    return created;
+}
+/**
+ * Performance-base timestamp for an event. Prefers the host stamp converted
+ * into this process's performance.now() base; falls back to `now`.
+ *
+ * WHY: the V2 host delivers events in batches — a whole turn's deltas can
+ * arrive in one flush long after generation. Stamping flush time
+ * (performance.now() at handling) collapses the generation window to
+ * milliseconds and inflates frozen TPS absurdly (e.g. 259 tokens / 6ms =
+ * 42627 t/s). V1 events have no `created`, so this is a no-op for V1.
+ */
+export function eventPerfTime(event, now) {
+    const wall = eventCreatedWallTime(event);
+    if (wall === null)
+        return now;
+    return now - Math.max(0, Date.now() - wall);
+}
 export function isMetricsEventApi(value) {
     if (!isRecord(value))
         return false;

package/dist/event-handlers.js

@@ -3,9 +3,9 @@ import { createFreshMetrics, estimateTokens } from "./metrics";
 import { parseAssistantMessage, parseAssistantProgressPart, parseAssistantStepEnded, parseAssistantStepStarted, parseSessionInfo, parseTextPart, parseUserMessage, } from "./event-shapes";
 import { applyAssistantTokens, applySessionModel, hasPositiveAssistantTokens, mergeAssistantModel } from "./request-updates";
 import { completeRequest, currentRequest } from "./request-state";
-import { eventAggregateID, eventID, eventProperties, eventProperty, statusType, stringEventProperty } from "./event-bus";
+import { eventAggregateID, eventID, eventPerfTime, eventProperties, eventProperty, statusType, stringEventProperty } from "./event-bus";
 import { clearLiveSpeed, resetLiveSpeed } from "./live-speed";
-import { ensureTurn, retireRequestIntoTurn, startTurn } from "./turn-state";
+import { ensureTurn, recordToolCalled, recordToolSettled, retireRequestIntoTurn, startTurn } from "./turn-state";
 export function registerEventHandlers(ctx) {
     const { api, config, log, state, actions } = ctx;
     const disposers = [];
@@ -86,7 +86,7 @@ export function registerEventHandlers(ctx) {
         const type = statusType(event);
         log(`session.status: ${sessionID} -> ${type}`);
         if (type === "busy") {
-            const now = performance.now();
+            const now = eventPerfTime(event, performance.now());
             actions.startSessionTiming(sessionID, now);
             actions.clearHoldTimer(sessionID);
             const existingTurn = state.turns.get(sessionID);
@@ -108,7 +108,7 @@ export function registerEventHandlers(ctx) {
             }
         }
         if (type === "idle") {
-            completeRequest({ state, actions, sessionID, now: performance.now(), holdDurationMs: config.holdDurationMs, log });
+            completeRequest({ state, actions, sessionID, now: eventPerfTime(event, performance.now()), holdDurationMs: config.holdDurationMs, log });
         }
     });
     on("session.idle", (event) => {
@@ -116,7 +116,7 @@ export function registerEventHandlers(ctx) {
         if (sessionID.length === 0)
             return;
         recordEventAlias(event, sessionID);
-        completeRequest({ state, actions, sessionID, now: performance.now(), holdDurationMs: config.holdDurationMs, log });
+        completeRequest({ state, actions, sessionID, now: eventPerfTime(event, performance.now()), holdDurationMs: config.holdDurationMs, log });
     });
     // ── message.part.delta ──
     on("message.part.delta", (event) => {
@@ -130,8 +130,8 @@ export function registerEventHandlers(ctx) {
         recordEventAlias(event, sessionID);
         if (field !== "text")
             return;
-        actions.startSessionTiming(sessionID, performance.now());
-        const now = performance.now();
+        actions.startSessionTiming(sessionID, eventPerfTime(event, performance.now()));
+        const now = eventPerfTime(event, performance.now());
         ensureTurn(state.turns, sessionID, now);
         applyAssistantPartDelta(ctx, sessionID, messageID, partID, delta, now);
     });
@@ -140,7 +140,7 @@ export function registerEventHandlers(ctx) {
         if (!step)
             return;
         recordEventAlias(event, step.sessionID);
-        const now = performance.now();
+        const now = eventPerfTime(event, performance.now());
         actions.startSessionTiming(step.sessionID, now);
         const existingTurn = state.turns.get(step.sessionID);
         if (!existingTurn || existingTurn.isComplete)
@@ -157,6 +157,33 @@ export function registerEventHandlers(ctx) {
     });
     on("session.next.text.delta", (event) => applyAssistantDelta(ctx, event));
     on("session.next.reasoning.delta", (event) => applyAssistantDelta(ctx, event));
+    // ── tool execution spans (V2 tool.* events; V1 has none) ──
+    // Feeds per-turn tool intervals so frozen TPS can subtract tool time from
+    // the turn-anchored window. Unknown shapes are ignored defensively.
+    on("session.tool.called", (event) => {
+        const sessionID = stringEventProperty(event, "sessionID");
+        if (sessionID.length === 0)
+            return;
+        recordEventAlias(event, sessionID);
+        recordToolCalled(state.turns, sessionID, stringEventProperty(event, "id"), eventPerfTime(event, performance.now()));
+        actions.notify();
+    });
+    on("session.tool.success", (event) => {
+        const sessionID = stringEventProperty(event, "sessionID");
+        if (sessionID.length === 0)
+            return;
+        recordEventAlias(event, sessionID);
+        recordToolSettled(state.turns, sessionID, stringEventProperty(event, "id"), eventPerfTime(event, performance.now()));
+        actions.notify();
+    });
+    on("session.tool.failed", (event) => {
+        const sessionID = stringEventProperty(event, "sessionID");
+        if (sessionID.length === 0)
+            return;
+        recordEventAlias(event, sessionID);
+        recordToolSettled(state.turns, sessionID, stringEventProperty(event, "id"), eventPerfTime(event, performance.now()));
+        actions.notify();
+    });
     on("session.next.step.ended", (event) => {
         const sessionID = stringEventProperty(event, "sessionID");
         const fallbackMessageID = sessionID ? state.assistantMessageIds.get(sessionID) ?? eventID(event) : eventID(event);
@@ -164,7 +191,7 @@ export function registerEventHandlers(ctx) {
         if (!step)
             return;
         recordEventAlias(event, step.sessionID);
-        const now = performance.now();
+        const now = eventPerfTime(event, performance.now());
         actions.startSessionTiming(step.sessionID, now);
         const turn = ensureTurn(state.turns, step.sessionID, now);
         const existing = state.requests.get(step.sessionID);
@@ -205,7 +232,7 @@ export function registerEventHandlers(ctx) {
         recordEventAlias(event, sessionID);
         const rawPart = eventProperty(event, "part");
         const part = parseTextPart(rawPart);
-        const now = performance.now();
+        const now = eventPerfTime(event, performance.now());
         const msgIds = state.userMessageIds.get(sessionID);
         if (part && msgIds?.has(part.messageID)) {
             const current = state.requests.get(sessionID);
@@ -235,7 +262,7 @@ export function registerEventHandlers(ctx) {
             const nextModel = mergeAssistantModel(state.sessionModels.get(sessionID), assistant);
             if (nextModel)
                 state.sessionModels.set(sessionID, nextModel);
-            const now = performance.now();
+            const now = eventPerfTime(event, performance.now());
             const tokens = assistant.tokens;
             const existing = state.requests.get(sessionID);
             const turn = ensureTurn(state.turns, sessionID, now);
@@ -278,7 +305,7 @@ export function registerEventHandlers(ctx) {
             if (userMsgID && state.userMessageIds.get(sessionID)?.has(userMsgID)) {
                 return;
             }
-            const now = performance.now();
+            const now = eventPerfTime(event, performance.now());
             const previous = state.requests.get(sessionID);
             const previousTurn = state.turns.get(sessionID);
             if (previous && previousTurn)

package/dist/metrics.js

@@ -113,6 +113,22 @@ export function getTtft(m) {
         return null;
     return gateTtft(m.firstTokenTime - m.requestStartTime);
 }
+/**
+ * Upper bound for a believable token rate. Mirrors the live-TPS sanity gate:
+ * per-delta times may be delivery-stamped (batched flushes), collapsing the
+ * generation window to milliseconds and inflating the quotient absurdly
+ * (e.g. 61 tokens / 42ms = 1450 t/s — physically impossible decoding).
+ * Windows implying a faster rate fall back to turn-anchored timing.
+ */
+export const MAX_CREDIBLE_TPS = 300;
+export function credibleTps(tokens, windowMs) {
+    if (!(tokens > 0) || !(windowMs > 0))
+        return null;
+    const tps = Math.round((tokens / (windowMs / 1000)) * 10) / 10;
+    if (!Number.isFinite(tps) || tps < 0 || tps > MAX_CREDIBLE_TPS)
+        return null;
+    return tps;
+}
 /**
  * Calculate average token speed (tokens/second).
  * Based on cumulative streaming time (now - firstTokenTime).

package/dist/tui-v2.js

@@ -64,6 +64,9 @@ const V2_EVENT_MAP = {
     "session.next.reasoning.delta": "session.reasoning.delta",
     "session.next.step.started": "session.step.started",
     "session.next.step.ended": "session.step.ended",
+    "session.tool.called": "session.tool.called",
+    "session.tool.success": "session.tool.success",
+    "session.tool.failed": "session.tool.failed",
 };
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -81,7 +84,14 @@ export function translateExecutionStartedToBusy(event) {
     const sessionID = str(data.sessionID);
     if (!sessionID)
         return null;
-    return { type: "session.status", properties: { sessionID, status: { type: "busy" } } };
+    // Preserve the host stamp so downstream timing uses generation time,
+    // not the (possibly batched) delivery time.
+    const created = typeof event.created === "number" ? event.created : undefined;
+    return {
+        type: "session.status",
+        ...(created !== undefined ? { created } : {}),
+        properties: { sessionID, status: { type: "busy" } },
+    };
 }
 /**
  * Turn-settled execution maps to the V1 `session.idle` shape that drives
@@ -93,7 +103,12 @@ export function translateExecutionSettledToIdle(event) {
     const sessionID = str(data.sessionID);
     if (!sessionID)
         return null;
-    return { type: "session.idle", properties: { sessionID } };
+    const created = typeof event.created === "number" ? event.created : undefined;
+    return {
+        type: "session.idle",
+        ...(created !== undefined ? { created } : {}),
+        properties: { sessionID },
+    };
 }
 function eventSessionID(event) {
     if (!isRecord(event))

package/dist/turn-state.js

@@ -12,6 +12,7 @@ export function createTurnMetrics(sessionID, now) {
         hasStickyContextTokens: false,
         stickyCacheReadTokens: 0,
         hasStickyCacheReadTokens: false,
+        toolIntervals: [],
         isComplete: false,
     };
 }
@@ -78,6 +79,68 @@ export function recordTurnFirstToken(turn, now) {
     if (turn.firstTokenTime === null)
         turn.firstTokenTime = now;
 }
+/**
+ * Record a tool execution span on the session's turn. Tools in one turn may
+ * overlap (parallel calls), so every span is kept and the union is computed
+ * at query time — a plain sum would double-count overlaps.
+ */
+export function recordToolCalled(turns, sessionID, toolID, now) {
+    const turn = ensureTurn(turns, sessionID, now);
+    turn.toolIntervals.push({ id: toolID, start: now, end: null });
+}
+export function recordToolSettled(turns, sessionID, toolID, now) {
+    const turn = turns.get(sessionID);
+    if (!turn)
+        return;
+    if (toolID) {
+        const open = turn.toolIntervals.find((interval) => interval.id === toolID && interval.end === null);
+        if (open) {
+            open.end = Math.max(now, open.start);
+            return;
+        }
+    }
+    // Unknown id (or unsettled shape): close the most recent open span so a
+    // lost settle event cannot leak an infinite interval.
+    for (let i = turn.toolIntervals.length - 1; i >= 0; i--) {
+        if (turn.toolIntervals[i].end === null) {
+            turn.toolIntervals[i].end = Math.max(now, turn.toolIntervals[i].start);
+            return;
+        }
+    }
+}
+/**
+ * Milliseconds of tool execution overlapping [from, to], unioned so parallel
+ * tool calls count once. Open spans are clamped at `to`.
+ */
+export function toolOverlapMs(turn, from, to) {
+    if (!turn || to <= from)
+        return 0;
+    const spans = [];
+    for (const interval of turn.toolIntervals) {
+        const start = Math.max(interval.start, from);
+        const end = Math.min(interval.end ?? to, to);
+        if (end > start)
+            spans.push({ start, end });
+    }
+    spans.sort((a, b) => a.start - b.start);
+    let total = 0;
+    let cursor = null;
+    let cursorEnd = 0;
+    for (const span of spans) {
+        if (cursor === null || span.start > cursorEnd) {
+            if (cursor !== null)
+                total += cursorEnd - cursor;
+            cursor = span.start;
+            cursorEnd = span.end;
+        }
+        else if (span.end > cursorEnd) {
+            cursorEnd = span.end;
+        }
+    }
+    if (cursor !== null)
+        total += cursorEnd - cursor;
+    return total;
+}
 /**
  * Turn-level TTFT (user message → first token), gated. Falls back to the
  * supplied per-request TTFT when the turn has no first-token timing. This is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oc-metricboard",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "OpenCode TUI sidebar plugin showing real-time LLM metrics (TPS, TTFT, tokens) with sub-agent × model breakdown",
   "keywords": [
     "opencode",

package/src/assistant-progress.ts

@@ -1,7 +1,7 @@
 import { estimateTokens } from "./metrics"
 import { parseAssistantTextDelta } from "./event-shapes"
 import { currentRequest } from "./request-state"
-import { eventAggregateID, eventID, eventProperties, stringEventProperty } from "./event-bus"
+import { eventAggregateID, eventID, eventPerfTime, eventProperties, stringEventProperty } from "./event-bus"
 import type { EventHandlerContext } from "./collector-state"
 import { recordLiveTokens } from "./live-speed"
 import { ensureTurn, recordTurnFirstToken } from "./turn-state"
@@ -78,7 +78,7 @@ export function applyAssistantDelta(ctx: EventHandlerContext, event: unknown): v
     sessionAliases.add(aggregateID)
     state.sessionAliases.set(text.sessionID, sessionAliases)
   }
-  const now = performance.now()
+  const now = eventPerfTime(event, performance.now())
   actions.startSessionTiming(text.sessionID, now)
   const key = partEstimateKey(text.sessionID, text.messageID, text.partID)
   const deltaTokens = estimateTokens(text.delta, ctx.config.estimationRatio)

package/src/collector.ts

@@ -1,6 +1,6 @@
 import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
 import type { BarConfig, CacheReadCompleteness, MetricsAggregate, MetricsScope, ModelMetrics, RequestMetrics } from "./types"
-import { getDisplayInputTokens, getDisplayOutputTokens, getTtft } from "./metrics"
+import { credibleTps, getDisplayInputTokens, getDisplayOutputTokens, getTtft, MAX_CREDIBLE_TPS } from "./metrics"
 import { registerEventHandlers } from "./event-handlers"
 import type { CollectorState } from "./collector-state"
 import type { MetricsEventApi } from "./event-bus"
@@ -8,7 +8,7 @@ import { hydrateSession, isHydrationApi, callWithFallback, type HydrationApi } f
 import { createSessionTree } from "./session-tree"
 import { getScopeElapsedMs, getSessionElapsedMs, startSessionTiming, stopSessionTiming } from "./session-timing"
 import { clearLiveSpeed, getLiveTps } from "./live-speed"
-import { getTurnTtft, liveRequestOutput, turnInputTokens } from "./turn-state"
+import { getTurnTtft, liveRequestOutput, toolOverlapMs, turnInputTokens } from "./turn-state"
 
 export type MetricsListener = () => void
 type MetricsHydrationApi = MetricsEventApi & HydrationApi
@@ -426,8 +426,20 @@ export function createCollector(
           : latest.isStreaming || latestLastActivity === null ? now : latestLastActivity
         const saneStart = genStart !== null && Number.isFinite(genStart) && genStart >= 0 && genStart <= now
         const saneEnd = genEnd !== null && Number.isFinite(genEnd) && genEnd >= 0 && genEnd <= now + 60_000
+        let primary: number | null = null
         if (frTokens > 0 && saneStart && saneEnd && genEnd > genStart) {
-          displayTps = Math.round((frTokens / ((genEnd - genStart) / 1000)) * 10) / 10
+          primary = Math.round((frTokens / ((genEnd - genStart) / 1000)) * 10) / 10
+        }
+        // Same turn-anchored fallback as the main aggregate, using the latest
+        // request's own turn.
+        const latestTurn = state.turns.get(latest.sessionID)
+        if ((primary === null || primary > MAX_CREDIBLE_TPS) && latestTurn && frTokens > 0) {
+          const turnEnd = completeTime ?? latestLastActivity ?? now
+          const turnWindow = turnEnd - latestTurn.turnStartTime
+            - toolOverlapMs(latestTurn, latestTurn.turnStartTime, turnEnd)
+          displayTps = credibleTps(frTokens, turnWindow) ?? primary
+        } else {
+          displayTps = primary
         }
       }
 
@@ -580,8 +592,21 @@ export function createCollector(
           : foregroundActive || foregroundLastActivity === null ? now : foregroundLastActivity
         const saneStart = genStart !== null && Number.isFinite(genStart) && genStart >= 0 && genStart <= now
         const saneEnd = genEnd !== null && Number.isFinite(genEnd) && genEnd >= 0 && genEnd <= now + 60_000
+        let primary: number | null = null
         if (frTokens > 0 && saneStart && saneEnd && genEnd > genStart) {
-          displayTps = Math.round((frTokens / ((genEnd - genStart) / 1000)) * 10) / 10
+          primary = Math.round((frTokens / ((genEnd - genStart) / 1000)) * 10) / 10
+        }
+        // Fall back to the turn-anchored window when the per-step window
+        // implies a physically incredible rate: per-delta times may be
+        // delivery-stamped (batched flushes), while turn admission, step
+        // boundaries, and tool spans use discrete truthful anchors.
+        if ((primary === null || primary > MAX_CREDIBLE_TPS) && foregroundTurn && frTokens > 0) {
+          const turnEnd = completeTime ?? foregroundLastActivity ?? now
+          const turnWindow = turnEnd - foregroundTurn.turnStartTime
+            - toolOverlapMs(foregroundTurn, foregroundTurn.turnStartTime, turnEnd)
+          displayTps = credibleTps(frTokens, turnWindow) ?? primary
+        } else {
+          displayTps = primary
         }
       }
 

package/src/event-bus.ts

@@ -54,6 +54,36 @@ export function statusType(event: unknown): string {
   return typeof status.type === "string" ? status.type : ""
 }
 
+/**
+ * Host-stamped wall-clock time of an event (V2 envelope `created`, epoch ms),
+ * or null when absent/implausible. V1 events carry no timestamp at all.
+ */
+export function eventCreatedWallTime(event: unknown): number | null {
+  if (!isRecord(event)) return null
+  const created = event.created
+  if (typeof created !== "number" || !Number.isFinite(created) || created <= 0) return null
+  // Guard against a foreign epoch or clock skew: anything more than a day out
+  // is not usable as event time.
+  if (Math.abs(created - Date.now()) > 86_400_000) return null
+  return created
+}
+
+/**
+ * Performance-base timestamp for an event. Prefers the host stamp converted
+ * into this process's performance.now() base; falls back to `now`.
+ *
+ * WHY: the V2 host delivers events in batches — a whole turn's deltas can
+ * arrive in one flush long after generation. Stamping flush time
+ * (performance.now() at handling) collapses the generation window to
+ * milliseconds and inflates frozen TPS absurdly (e.g. 259 tokens / 6ms =
+ * 42627 t/s). V1 events have no `created`, so this is a no-op for V1.
+ */
+export function eventPerfTime(event: unknown, now: number): number {
+  const wall = eventCreatedWallTime(event)
+  if (wall === null) return now
+  return now - Math.max(0, Date.now() - wall)
+}
+
 export function isMetricsEventApi(value: unknown): value is MetricsEventApi {
   if (!isRecord(value)) return false
   const event = value.event

package/src/event-handlers.ts

@@ -11,10 +11,10 @@ import {
 } from "./event-shapes"
 import { applyAssistantTokens, applySessionModel, hasPositiveAssistantTokens, mergeAssistantModel } from "./request-updates"
 import { completeRequest, currentRequest } from "./request-state"
-import { eventAggregateID, eventID, eventProperties, eventProperty, statusType, stringEventProperty } from "./event-bus"
+import { eventAggregateID, eventID, eventPerfTime, eventProperties, eventProperty, statusType, stringEventProperty } from "./event-bus"
 import type { EventHandlerContext } from "./collector-state"
 import { clearLiveSpeed, resetLiveSpeed } from "./live-speed"
-import { ensureTurn, retireRequestIntoTurn, startTurn } from "./turn-state"
+import { ensureTurn, recordToolCalled, recordToolSettled, retireRequestIntoTurn, startTurn } from "./turn-state"
 
 export function registerEventHandlers(ctx: EventHandlerContext): Array<() => void> {
   const { api, config, log, state, actions } = ctx
@@ -97,7 +97,7 @@ export function registerEventHandlers(ctx: EventHandlerContext): Array<() => voi
     log(`session.status: ${sessionID} -> ${type}`)
 
     if (type === "busy") {
-      const now = performance.now()
+      const now = eventPerfTime(event, performance.now())
       actions.startSessionTiming(sessionID, now)
       actions.clearHoldTimer(sessionID)
       const existingTurn = state.turns.get(sessionID)
@@ -118,7 +118,7 @@ export function registerEventHandlers(ctx: EventHandlerContext): Array<() => voi
     }
 
     if (type === "idle") {
-      completeRequest({ state, actions, sessionID, now: performance.now(), holdDurationMs: config.holdDurationMs, log })
+      completeRequest({ state, actions, sessionID, now: eventPerfTime(event, performance.now()), holdDurationMs: config.holdDurationMs, log })
     }
   })
 
@@ -126,7 +126,7 @@ export function registerEventHandlers(ctx: EventHandlerContext): Array<() => voi
     const sessionID = stringEventProperty(event, "sessionID")
     if (sessionID.length === 0) return
     recordEventAlias(event, sessionID)
-    completeRequest({ state, actions, sessionID, now: performance.now(), holdDurationMs: config.holdDurationMs, log })
+    completeRequest({ state, actions, sessionID, now: eventPerfTime(event, performance.now()), holdDurationMs: config.holdDurationMs, log })
   })
 
   // ── message.part.delta ──
@@ -139,9 +139,9 @@ export function registerEventHandlers(ctx: EventHandlerContext): Array<() => voi
     if (sessionID.length === 0 || messageID.length === 0) return
     recordEventAlias(event, sessionID)
     if (field !== "text") return
-    actions.startSessionTiming(sessionID, performance.now())
+    actions.startSessionTiming(sessionID, eventPerfTime(event, performance.now()))
 
-    const now = performance.now()
+    const now = eventPerfTime(event, performance.now())
     ensureTurn(state.turns, sessionID, now)
     applyAssistantPartDelta(ctx, sessionID, messageID, partID, delta, now)
   })
@@ -150,7 +150,7 @@ export function registerEventHandlers(ctx: EventHandlerContext): Array<() => voi
     const step = parseAssistantStepStarted(eventProperties(event), eventID(event))
     if (!step) return
     recordEventAlias(event, step.sessionID)
-    const now = performance.now()
+    const now = eventPerfTime(event, performance.now())
     actions.startSessionTiming(step.sessionID, now)
     const existingTurn = state.turns.get(step.sessionID)
     if (!existingTurn || existingTurn.isComplete) startTurn(state.turns, step.sessionID, now)
@@ -169,13 +169,40 @@ export function registerEventHandlers(ctx: EventHandlerContext): Array<() => voi
 
   on("session.next.reasoning.delta", (event) => applyAssistantDelta(ctx, event))
 
+  // ── tool execution spans (V2 tool.* events; V1 has none) ──
+  // Feeds per-turn tool intervals so frozen TPS can subtract tool time from
+  // the turn-anchored window. Unknown shapes are ignored defensively.
+  on("session.tool.called", (event) => {
+    const sessionID = stringEventProperty(event, "sessionID")
+    if (sessionID.length === 0) return
+    recordEventAlias(event, sessionID)
+    recordToolCalled(state.turns, sessionID, stringEventProperty(event, "id"), eventPerfTime(event, performance.now()))
+    actions.notify()
+  })
+
+  on("session.tool.success", (event) => {
+    const sessionID = stringEventProperty(event, "sessionID")
+    if (sessionID.length === 0) return
+    recordEventAlias(event, sessionID)
+    recordToolSettled(state.turns, sessionID, stringEventProperty(event, "id"), eventPerfTime(event, performance.now()))
+    actions.notify()
+  })
+
+  on("session.tool.failed", (event) => {
+    const sessionID = stringEventProperty(event, "sessionID")
+    if (sessionID.length === 0) return
+    recordEventAlias(event, sessionID)
+    recordToolSettled(state.turns, sessionID, stringEventProperty(event, "id"), eventPerfTime(event, performance.now()))
+    actions.notify()
+  })
+
   on("session.next.step.ended", (event) => {
     const sessionID = stringEventProperty(event, "sessionID")
     const fallbackMessageID = sessionID ? state.assistantMessageIds.get(sessionID) ?? eventID(event) : eventID(event)
     const step = parseAssistantStepEnded(eventProperties(event), fallbackMessageID)
     if (!step) return
     recordEventAlias(event, step.sessionID)
-    const now = performance.now()
+    const now = eventPerfTime(event, performance.now())
     actions.startSessionTiming(step.sessionID, now)
     const turn = ensureTurn(state.turns, step.sessionID, now)
     const existing = state.requests.get(step.sessionID)
@@ -215,7 +242,7 @@ export function registerEventHandlers(ctx: EventHandlerContext): Array<() => voi
     recordEventAlias(event, sessionID)
     const rawPart = eventProperty(event, "part")
     const part = parseTextPart(rawPart)
-    const now = performance.now()
+    const now = eventPerfTime(event, performance.now())
     const msgIds = state.userMessageIds.get(sessionID)
     if (part && msgIds?.has(part.messageID)) {
       const current = state.requests.get(sessionID)
@@ -246,7 +273,7 @@ export function registerEventHandlers(ctx: EventHandlerContext): Array<() => voi
       const nextModel = mergeAssistantModel(state.sessionModels.get(sessionID), assistant)
       if (nextModel) state.sessionModels.set(sessionID, nextModel)
 
-      const now = performance.now()
+      const now = eventPerfTime(event, performance.now())
       const tokens = assistant.tokens
       const existing = state.requests.get(sessionID)
       const turn = ensureTurn(state.turns, sessionID, now)
@@ -288,7 +315,7 @@ export function registerEventHandlers(ctx: EventHandlerContext): Array<() => voi
       if (userMsgID && state.userMessageIds.get(sessionID)?.has(userMsgID)) {
         return
       }
-      const now = performance.now()
+      const now = eventPerfTime(event, performance.now())
       const previous = state.requests.get(sessionID)
       const previousTurn = state.turns.get(sessionID)
       if (previous && previousTurn) retireRequestIntoTurn(previousTurn, previous)

package/src/metrics.ts

@@ -127,6 +127,22 @@ export function getTtft(m: RequestMetrics): number | null {
   return gateTtft(m.firstTokenTime - m.requestStartTime)
 }
 
+/**
+ * Upper bound for a believable token rate. Mirrors the live-TPS sanity gate:
+ * per-delta times may be delivery-stamped (batched flushes), collapsing the
+ * generation window to milliseconds and inflating the quotient absurdly
+ * (e.g. 61 tokens / 42ms = 1450 t/s — physically impossible decoding).
+ * Windows implying a faster rate fall back to turn-anchored timing.
+ */
+export const MAX_CREDIBLE_TPS = 300
+
+export function credibleTps(tokens: number, windowMs: number): number | null {
+  if (!(tokens > 0) || !(windowMs > 0)) return null
+  const tps = Math.round((tokens / (windowMs / 1000)) * 10) / 10
+  if (!Number.isFinite(tps) || tps < 0 || tps > MAX_CREDIBLE_TPS) return null
+  return tps
+}
+
 /**
  * Calculate average token speed (tokens/second).
  * Based on cumulative streaming time (now - firstTokenTime).

package/src/tui-v2.tsx

@@ -114,6 +114,9 @@ const V2_EVENT_MAP: Readonly<Record<string, string | null>> = {
     "session.next.reasoning.delta": "session.reasoning.delta",
     "session.next.step.started": "session.step.started",
     "session.next.step.ended": "session.step.ended",
+    "session.tool.called": "session.tool.called",
+    "session.tool.success": "session.tool.success",
+    "session.tool.failed": "session.tool.failed",
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -133,7 +136,14 @@ export function translateExecutionStartedToBusy(event: V2EventLike): unknown {
     const data = isRecord(event.data) ? event.data : {}
     const sessionID = str(data.sessionID)
     if (!sessionID) return null
-    return { type: "session.status", properties: { sessionID, status: { type: "busy" } } }
+    // Preserve the host stamp so downstream timing uses generation time,
+    // not the (possibly batched) delivery time.
+    const created = typeof event.created === "number" ? event.created : undefined
+    return {
+        type: "session.status",
+        ...(created !== undefined ? { created } : {}),
+        properties: { sessionID, status: { type: "busy" } },
+    }
 }
 
 /**
@@ -145,7 +155,12 @@ export function translateExecutionSettledToIdle(event: V2EventLike): unknown {
     const data = isRecord(event.data) ? event.data : {}
     const sessionID = str(data.sessionID)
     if (!sessionID) return null
-    return { type: "session.idle", properties: { sessionID } }
+    const created = typeof event.created === "number" ? event.created : undefined
+    return {
+        type: "session.idle",
+        ...(created !== undefined ? { created } : {}),
+        properties: { sessionID },
+    }
 }
 
 function eventSessionID(event: unknown): string {

package/src/turn-state.ts

@@ -14,6 +14,7 @@ export function createTurnMetrics(sessionID: string, now: number): TurnMetrics {
     hasStickyContextTokens: false,
     stickyCacheReadTokens: 0,
     hasStickyCacheReadTokens: false,
+    toolIntervals: [],
     isComplete: false,
   }
 }
@@ -95,6 +96,75 @@ export function recordTurnFirstToken(turn: TurnMetrics, now: number): void {
   if (turn.firstTokenTime === null) turn.firstTokenTime = now
 }
 
+/**
+ * Record a tool execution span on the session's turn. Tools in one turn may
+ * overlap (parallel calls), so every span is kept and the union is computed
+ * at query time — a plain sum would double-count overlaps.
+ */
+export function recordToolCalled(
+  turns: Map<string, TurnMetrics>,
+  sessionID: string,
+  toolID: string,
+  now: number,
+): void {
+  const turn = ensureTurn(turns, sessionID, now)
+  turn.toolIntervals.push({ id: toolID, start: now, end: null })
+}
+
+export function recordToolSettled(
+  turns: Map<string, TurnMetrics>,
+  sessionID: string,
+  toolID: string,
+  now: number,
+): void {
+  const turn = turns.get(sessionID)
+  if (!turn) return
+  if (toolID) {
+    const open = turn.toolIntervals.find((interval) => interval.id === toolID && interval.end === null)
+    if (open) {
+      open.end = Math.max(now, open.start)
+      return
+    }
+  }
+  // Unknown id (or unsettled shape): close the most recent open span so a
+  // lost settle event cannot leak an infinite interval.
+  for (let i = turn.toolIntervals.length - 1; i >= 0; i--) {
+    if (turn.toolIntervals[i]!.end === null) {
+      turn.toolIntervals[i]!.end = Math.max(now, turn.toolIntervals[i]!.start)
+      return
+    }
+  }
+}
+
+/**
+ * Milliseconds of tool execution overlapping [from, to], unioned so parallel
+ * tool calls count once. Open spans are clamped at `to`.
+ */
+export function toolOverlapMs(turn: TurnMetrics | undefined, from: number, to: number): number {
+  if (!turn || to <= from) return 0
+  const spans: Array<{ start: number; end: number }> = []
+  for (const interval of turn.toolIntervals) {
+    const start = Math.max(interval.start, from)
+    const end = Math.min(interval.end ?? to, to)
+    if (end > start) spans.push({ start, end })
+  }
+  spans.sort((a, b) => a.start - b.start)
+  let total = 0
+  let cursor: number | null = null
+  let cursorEnd = 0
+  for (const span of spans) {
+    if (cursor === null || span.start > cursorEnd) {
+      if (cursor !== null) total += cursorEnd - cursor
+      cursor = span.start
+      cursorEnd = span.end
+    } else if (span.end > cursorEnd) {
+      cursorEnd = span.end
+    }
+  }
+  if (cursor !== null) total += cursorEnd - cursor
+  return total
+}
+
 /**
  * Turn-level TTFT (user message → first token), gated. Falls back to the
  * supplied per-request TTFT when the turn has no first-token timing. This is

package/src/types.ts

@@ -34,6 +34,12 @@ export interface FinalizedStepUsage {
   exact: boolean
 }
 
+export interface ToolInterval {
+  readonly id: string
+  readonly start: number
+  end: number | null                   // null = still running
+}
+
 export interface TurnMetrics {
   sessionID: string
   turnStartTime: number
@@ -46,6 +52,7 @@ export interface TurnMetrics {
   hasStickyContextTokens: boolean
   stickyCacheReadTokens: number
   hasStickyCacheReadTokens: boolean
+  toolIntervals: ToolInterval[]         // Tool execution spans (V2 tool.* events; empty on V1)
   isComplete: boolean
 }