oc-metricboard 0.1.9 → 0.1.11

package/package.json

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

package/src/collector.ts

@@ -303,14 +303,28 @@ export function createCollector(
     return { rootID: requestedSessionID, ids: requestedIDs }
   }
 
-  function aggregateByModel(ids: readonly string[], now: number, scope: MetricsScope): ModelMetrics[] {
+  function aggregateByModel(
+    ids: readonly string[],
+    now: number,
+    scope: MetricsScope,
+    rootID: string,
+    foregroundTurnStart: number,
+  ): ModelMetrics[] {
     // Group requests by (modelID, providerID) — one row per distinct model
-    // across all sub-agent sessions, with a ×N session count.
+    // across all sub-agent sessions, with a ×N session count. Apply the same
+    // foreground-turn membership filter as the token totals: a session whose
+    // last turn predates the foreground turn (e.g. a model the user switched
+    // away from hours ago) would otherwise linger as a stale zombie row that
+    // is absent from the aggregate totals.
     const modelGroups = new Map<string, RequestMetrics[]>()
 
     for (const id of ids) {
       const request = state.requests.get(id)
       if (!request) continue
+      const turn = state.turns.get(id)
+      const belongsToForegroundTurn = id === rootID
+        || Boolean(turn && (turn.turnStartTime >= foregroundTurnStart || !turn.isComplete))
+      if (!belongsToForegroundTurn) continue
 
       // Key: modelID|providerID (model-grouped, not per-session)
       const key = `${request.modelID}|${request.providerID}`
@@ -557,7 +571,7 @@ export function createCollector(
       }
 
       // NEW: Build per-model breakdown for tree scope
-      const modelBreakdown = scope === "tree" ? aggregateByModel(ids, now, scope) : []
+      const modelBreakdown = scope === "tree" ? aggregateByModel(ids, now, scope, rootID, foregroundTurnStart) : []
       // Turn-level TTFT: opencode stamps step.started at the first token, so
       // intra-turn steps cannot measure their own request start (they would
       // collapse to ~0). Anchor TTFT to the turn's user message instead —

package/src/session-hydration.ts

@@ -138,9 +138,8 @@ async function observablePartTimes(api: HydrationApi, messageID: string, now: nu
   return { first: toPerformanceTime(firstWall, now), last: toPerformanceTime(lastWall, now) }
 }
 
-function hydrateSessionTiming(
+export function hydrateSessionTiming(
   rawMessages: readonly unknown[],
-  status: string,
   now: number,
 ): SessionTiming {
   const intervals: Array<{ start: number; end: number }> = []
@@ -183,10 +182,16 @@ function hydrateSessionTiming(
     }
   }
 
-  const activeSince = status === "idle" ? null : toPerformanceTime(groupStartWall, now)
-  if (activeSince === null && groupStartWall !== null) closeGroup()
+  // Hydration NEVER leaves an open active interval. The session-status lookup
+  // is unreliable across host SDK dialects (may resolve to '' — see the turn
+  // completion fix), and an open interval anchored to a pre-process wall time
+  // becomes {start: negative, end: now} in performance-time: its span then
+  // includes the entire era before this TUI process existed, inflating the
+  // Session readout by the session's full age and growing in real time while
+  // idle. Activity accounting resumes exclusively via live busy/idle events.
+  if (groupStartWall !== null) closeGroup()
   const elapsedMs = Math.round(intervals.reduce((total, interval) => total + Math.max(0, interval.end - interval.start), 0))
-  return { elapsedMs, activeSince, intervals }
+  return { elapsedMs, activeSince: null, intervals }
 }
 
 export interface HydrateSessionInput {
@@ -235,6 +240,7 @@ export async function hydrateSession(input: HydrateSessionInput): Promise<boolea
     await input.api.client.session.status({ id: input.sessionID }),
     input.sessionID,
   ))
+  log(`hydrate session=${input.sessionID.slice(0, 8)} status='${sessionStatus}'`)
   const shouldReuseExisting = existing?.messageID === assistant.messageID
 
   const current = shouldReuseExisting ? existing : createFreshMetrics(
@@ -287,7 +293,12 @@ export async function hydrateSession(input: HydrateSessionInput): Promise<boolea
     applyAssistantTokens(stepMetrics, step.tokens)
     retireRequestIntoTurn(turn, stepMetrics)
   }
-  if (sessionStatus === "idle") completeTurn(turn, completedTime ?? input.now)
+  // Turn completion: the session-status lookup is unreliable across host SDK
+  // dialects (may resolve to an unrecognizable shape → status ''). The last
+  // assistant message's own completed flag is authoritative: if it finished,
+  // its turn is over. An in-flight resumed message (completed=false) keeps
+  // the turn open.
+  if (sessionStatus === "idle" || current.isComplete) completeTurn(turn, completedTime ?? input.now)
   input.state.turns.set(input.sessionID, turn)
 
   // Write-point race guard: the checks above ran before several awaits. By
@@ -310,9 +321,18 @@ export async function hydrateSession(input: HydrateSessionInput): Promise<boolea
     input.state.sessionModels.set(input.sessionID, { modelID: assistant.modelID, providerID: assistant.providerID })
   }
   if (!input.state.sessionTimings.has(input.sessionID)) {
-    input.state.sessionTimings.set(
-      input.sessionID,
-      hydrateSessionTiming(rawMessages, sessionStatus, input.now),
+    const timing = hydrateSessionTiming(rawMessages, input.now)
+    input.state.sessionTimings.set(input.sessionID, timing)
+    // Debug: timing hydration summary — pinpoints where inflated Session
+    // elapsed values come from (initial value vs runtime accumulation).
+    const intervals = timing.intervals ?? []
+    const maxSpan = intervals.reduce((m, iv) => Math.max(m, iv.end - iv.start), 0)
+    const oldestStart = intervals.reduce((m, iv) => Math.min(m, iv.start), Number.POSITIVE_INFINITY)
+    log(
+      `timing hydrate session=${input.sessionID.slice(0, 8)} elapsed=${Math.round(timing.elapsedMs)}ms`
+      + ` activeSinceAge=${timing.activeSince === null ? "null" : `${Math.round(input.now - timing.activeSince)}ms`}`
+      + ` intervals=${intervals.length} maxSpan=${Math.round(maxSpan)}ms`
+      + ` oldestStartAge=${Number.isFinite(oldestStart) ? `${Math.round(input.now - oldestStart)}ms` : "n/a"}`,
     )
   }
   return true