oc-metricboard 0.1.16 → 0.1.18

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

@@ -350,7 +350,12 @@ export function createCollector(api, config, log) {
                 const latest = metrics.reduce((a, b) => (b.requestStartTime >= a.requestStartTime ? b : a));
                 const frTokens = getDisplayOutputTokens(latest);
                 const genStart = latest.firstTokenTime ?? latest.requestStartTime;
-                const genEnd = isComplete && completeTime !== null ? completeTime : now;
+                // Same freeze rule as the main aggregate: an open-but-silent group
+                // ends its window at the latest request's last activity, not `now`.
+                const latestLastActivity = latest.lastDeltaTime ?? null;
+                const genEnd = isComplete && completeTime !== null
+                    ? completeTime
+                    : 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;
                 if (frTokens > 0 && saneStart && saneEnd && genEnd > genStart) {
@@ -490,7 +495,15 @@ export function createCollector(api, config, log) {
                 // the foreground window would inflate TPS absurdly (1800+ t/s).
                 const frTokens = getDisplayOutputTokens(foregroundRequest);
                 const genStart = firstTokenTime ?? requestStartTime;
-                const genEnd = isComplete ? completeTime : now;
+                // Window end: complete → frozen completeTime; streaming → now;
+                // open but silent (e.g. a lost completion event) → last observed
+                // activity, so the reading freezes instead of decaying in real time
+                // while idle.
+                const foregroundActive = foregroundRequest?.isStreaming ?? false;
+                const foregroundLastActivity = foregroundRequest?.lastDeltaTime ?? null;
+                const genEnd = isComplete
+                    ? completeTime
+                    : 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;
                 if (frTokens > 0 && saneStart && saneEnd && genEnd > genStart) {

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,7 +3,7 @@ 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";
 export function registerEventHandlers(ctx) {
@@ -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)
@@ -164,7 +164,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 +205,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 +235,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 +278,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/tui-v2.js

@@ -74,14 +74,38 @@ function str(value) {
 /**
  * `session.execution.started` = "the user's prompt was admitted and work
  * started" — the V2 equivalent of V1's `session.status -> busy`, which drives
- * turn start and session timing.
+ * turn start and session timing. Exported for tests.
  */
-function translateExecutionStarted(event) {
+export function translateExecutionStartedToBusy(event) {
     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" } },
+    };
+}
+/**
+ * Turn-settled execution maps to the V1 `session.idle` shape that drives
+ * request completion. Used as a fallback next to the native V2
+ * `session.idle`, which some flows never emit. Exported for tests.
+ */
+export function translateExecutionSettledToIdle(event) {
+    const data = isRecord(event.data) ? event.data : {};
+    const sessionID = str(data.sessionID);
+    if (!sessionID)
+        return null;
+    const created = typeof event.created === "number" ? event.created : undefined;
+    return {
+        type: "session.idle",
+        ...(created !== undefined ? { created } : {}),
+        properties: { sessionID },
+    };
 }
 function eventSessionID(event) {
     if (!isRecord(event))
@@ -110,39 +134,76 @@ function createV1EventShim(ctx, holder) {
             // Family attribution is best-effort; the root session works without it.
         }
     };
+    const subscribeV2 = (v2Type, subscribee) => {
+        try {
+            const unsub = ctx.data.on(v2Type, (event) => {
+                try {
+                    subscribee(event);
+                }
+                catch (error) {
+                    // One malformed event must never tear down the handler chain.
+                    log(`v2 event dispatch failed: ${String(error)}`);
+                }
+            });
+            return typeof unsub === "function" ? unsub : () => { };
+        }
+        catch (error) {
+            log(`v2 event subscribe failed (${v2Type}): ${String(error)}`);
+            return () => { };
+        }
+    };
     return {
         event: {
             on(type, handler) {
                 // V1 hosts subscribe `.1`/`.2` delivery variants; V2 has none.
                 if (/\.1$|\.2$/.test(type))
                     return () => { };
-                const v2Type = V2_EVENT_MAP[type];
-                if (!v2Type)
-                    return () => { };
-                let unsub;
-                try {
-                    unsub = ctx.data.on(v2Type, (event) => {
-                        try {
-                            if (v2Type === "session.execution.started") {
-                                const translated = translateExecutionStarted(event);
-                                if (translated !== null)
-                                    handler(translated);
-                                return;
+                // V1 session lifecycle has no same-name V2 event: synthesize
+                // busy from execution.started. (Without this, turns, session
+                // timing, and completion never start on V2.)
+                if (type === "session.status") {
+                    return subscribeV2("session.execution.started", (event) => {
+                        const translated = translateExecutionStartedToBusy(event);
+                        if (translated !== null)
+                            handler(translated);
+                    });
+                }
+                // Completion: native V2 session.idle where emitted, plus the
+                // execution-settled events as fallback — some flows never emit
+                // session.idle, which used to leave the turn/request/timing
+                // open forever (TPS decaying in real time while idle).
+                // completeRequest is idempotent, so a doubled signal is safe.
+                if (type === "session.idle") {
+                    const unsubs = [
+                        subscribeV2("session.idle", handler),
+                    ];
+                    for (const settled of [
+                        "session.execution.succeeded",
+                        "session.execution.failed",
+                        "session.execution.interrupted",
+                    ]) {
+                        unsubs.push(subscribeV2(settled, (event) => {
+                            const translated = translateExecutionSettledToIdle(event);
+                            if (translated !== null)
+                                handler(translated);
+                        }));
+                    }
+                    return () => {
+                        for (const unsub of unsubs) {
+                            try {
+                                unsub();
                             }
-                            syncFamily(eventSessionID(event));
-                            handler(event);
-                        }
-                        catch (error) {
-                            // One malformed event must never tear down the handler chain.
-                            log(`v2 event dispatch failed: ${String(error)}`);
+                            catch { /* ignore */ }
                         }
-                    });
+                    };
                 }
-                catch (error) {
-                    log(`v2 event subscribe failed (${type}): ${String(error)}`);
+                const v2Type = V2_EVENT_MAP[type];
+                if (!v2Type)
                     return () => { };
-                }
-                return typeof unsub === "function" ? unsub : () => { };
+                return subscribeV2(v2Type, (event) => {
+                    syncFamily(eventSessionID(event));
+                    handler(event);
+                });
             },
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oc-metricboard",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "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

@@ -418,7 +418,12 @@ export function createCollector(
         const latest = metrics.reduce((a, b) => (b.requestStartTime >= a.requestStartTime ? b : a))
         const frTokens = getDisplayOutputTokens(latest)
         const genStart = latest.firstTokenTime ?? latest.requestStartTime
-        const genEnd = isComplete && completeTime !== null ? completeTime : now
+        // Same freeze rule as the main aggregate: an open-but-silent group
+        // ends its window at the latest request's last activity, not `now`.
+        const latestLastActivity = latest.lastDeltaTime ?? null
+        const genEnd = isComplete && completeTime !== null
+          ? completeTime
+          : 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
         if (frTokens > 0 && saneStart && saneEnd && genEnd > genStart) {
@@ -564,7 +569,15 @@ export function createCollector(
         // the foreground window would inflate TPS absurdly (1800+ t/s).
         const frTokens = getDisplayOutputTokens(foregroundRequest)
         const genStart = firstTokenTime ?? requestStartTime
-        const genEnd = isComplete ? completeTime : now
+        // Window end: complete → frozen completeTime; streaming → now;
+        // open but silent (e.g. a lost completion event) → last observed
+        // activity, so the reading freezes instead of decaying in real time
+        // while idle.
+        const foregroundActive = foregroundRequest?.isStreaming ?? false
+        const foregroundLastActivity = foregroundRequest?.lastDeltaTime ?? null
+        const genEnd = isComplete
+          ? completeTime
+          : 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
         if (frTokens > 0 && saneStart && saneEnd && genEnd > genStart) {

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,7 +11,7 @@ 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"
@@ -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)
@@ -175,7 +175,7 @@ export function registerEventHandlers(ctx: EventHandlerContext): Array<() => voi
     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 +215,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 +246,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 +288,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/tui-v2.tsx

@@ -127,13 +127,37 @@ function str(value: unknown): string {
 /**
  * `session.execution.started` = "the user's prompt was admitted and work
  * started" — the V2 equivalent of V1's `session.status -> busy`, which drives
- * turn start and session timing.
+ * turn start and session timing. Exported for tests.
  */
-function translateExecutionStarted(event: V2EventLike): unknown {
+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" } },
+    }
+}
+
+/**
+ * Turn-settled execution maps to the V1 `session.idle` shape that drives
+ * request completion. Used as a fallback next to the native V2
+ * `session.idle`, which some flows never emit. Exported for tests.
+ */
+export function translateExecutionSettledToIdle(event: V2EventLike): unknown {
+    const data = isRecord(event.data) ? event.data : {}
+    const sessionID = str(data.sessionID)
+    if (!sessionID) return null
+    const created = typeof event.created === "number" ? event.created : undefined
+    return {
+        type: "session.idle",
+        ...(created !== undefined ? { created } : {}),
+        properties: { sessionID },
+    }
 }
 
 function eventSessionID(event: unknown): string {
@@ -164,34 +188,73 @@ function createV1EventShim(ctx: V2Context, holder: CollectorHolder): MetricsEven
         }
     }
 
+    const subscribeV2 = (
+        v2Type: string,
+        subscribee: (event: unknown) => void,
+    ): (() => void) => {
+        try {
+            const unsub = ctx.data.on(v2Type, (event: unknown) => {
+                try {
+                    subscribee(event)
+                } catch (error) {
+                    // One malformed event must never tear down the handler chain.
+                    log(`v2 event dispatch failed: ${String(error)}`)
+                }
+            })
+            return typeof unsub === "function" ? unsub : () => {}
+        } catch (error) {
+            log(`v2 event subscribe failed (${v2Type}): ${String(error)}`)
+            return () => {}
+        }
+    }
+
     return {
         event: {
             on(type: string, handler: (event: unknown) => void): () => void {
                 // V1 hosts subscribe `.1`/`.2` delivery variants; V2 has none.
                 if (/\.1$|\.2$/.test(type)) return () => {}
-                const v2Type = V2_EVENT_MAP[type]
-                if (!v2Type) return () => {}
-                let unsub: (() => void) | undefined
-                try {
-                    unsub = ctx.data.on(v2Type, (event: unknown) => {
-                        try {
-                            if (v2Type === "session.execution.started") {
-                                const translated = translateExecutionStarted(event as V2EventLike)
-                                if (translated !== null) handler(translated)
-                                return
-                            }
-                            syncFamily(eventSessionID(event))
-                            handler(event)
-                        } catch (error) {
-                            // One malformed event must never tear down the handler chain.
-                            log(`v2 event dispatch failed: ${String(error)}`)
-                        }
+                // V1 session lifecycle has no same-name V2 event: synthesize
+                // busy from execution.started. (Without this, turns, session
+                // timing, and completion never start on V2.)
+                if (type === "session.status") {
+                    return subscribeV2("session.execution.started", (event) => {
+                        const translated = translateExecutionStartedToBusy(event as V2EventLike)
+                        if (translated !== null) handler(translated)
                     })
-                } catch (error) {
-                    log(`v2 event subscribe failed (${type}): ${String(error)}`)
-                    return () => {}
                 }
-                return typeof unsub === "function" ? unsub : () => {}
+                // Completion: native V2 session.idle where emitted, plus the
+                // execution-settled events as fallback — some flows never emit
+                // session.idle, which used to leave the turn/request/timing
+                // open forever (TPS decaying in real time while idle).
+                // completeRequest is idempotent, so a doubled signal is safe.
+                if (type === "session.idle") {
+                    const unsubs: Array<() => void> = [
+                        subscribeV2("session.idle", handler),
+                    ]
+                    for (const settled of [
+                        "session.execution.succeeded",
+                        "session.execution.failed",
+                        "session.execution.interrupted",
+                    ] as const) {
+                        unsubs.push(subscribeV2(settled, (event) => {
+                            const translated = translateExecutionSettledToIdle(event as V2EventLike)
+                            if (translated !== null) handler(translated)
+                        }))
+                    }
+                    return () => {
+                        for (const unsub of unsubs) {
+                            try {
+                                unsub()
+                            } catch { /* ignore */ }
+                        }
+                    }
+                }
+                const v2Type = V2_EVENT_MAP[type]
+                if (!v2Type) return () => {}
+                return subscribeV2(v2Type, (event) => {
+                    syncFamily(eventSessionID(event))
+                    handler(event)
+                })
             },
         },
     }