oc-metricboard 0.1.16 → 0.1.17

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/tui-v2.js

@@ -74,15 +74,27 @@ 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" } } };
 }
+/**
+ * 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;
+    return { type: "session.idle", properties: { sessionID } };
+}
 function eventSessionID(event) {
     if (!isRecord(event))
         return "";
@@ -110,39 +122,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 { /* ignore */ }
                         }
-                        catch (error) {
-                            // One malformed event must never tear down the handler chain.
-                            log(`v2 event dispatch failed: ${String(error)}`);
-                        }
-                    });
+                    };
                 }
-                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.17",
   "description": "OpenCode TUI sidebar plugin showing real-time LLM metrics (TPS, TTFT, tokens) with sub-agent × model breakdown",
   "keywords": [
     "opencode",

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/tui-v2.tsx

@@ -127,15 +127,27 @@ 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" } } }
 }
 
+/**
+ * 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
+    return { type: "session.idle", properties: { sessionID } }
+}
+
 function eventSessionID(event: unknown): string {
     if (!isRecord(event)) return ""
     return str(isRecord(event.data) ? event.data.sessionID : undefined)
@@ -164,34 +176,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)
+                })
             },
         },
     }