oc-metricboard 0.1.22 → 0.1.24

package/dist/tui.js

@@ -1,61 +1,2700 @@
-import { createCollector } from "./collector";
-import { getConfig } from "./config";
-import { log } from "./logger";
-import { SidebarMetrics } from "./components/SidebarMetrics";
-import { computeEffectiveOrder, createMetricsSidebarController, DEFAULT_SLOT_ORDER, PLUGIN_KEY, resolveMetricsPrefs, } from "./tui-preferences";
-import { readTuiPreferencesFileSync } from "./tui-prefs-io";
-import { setupTuiV2 } from "./tui-v2";
-const plugin = async (api, _options, _meta) => {
-    const config = getConfig();
-    const collector = createCollector(api, config, log);
-    // Sync-read preferences at slot mount so the sidebar renders at its final
-    // order and collapse state on the first paint (no async flicker).
-    const seedRoot = readTuiPreferencesFileSync();
-    const effectiveOrder = computeEffectiveOrder(seedRoot, PLUGIN_KEY, DEFAULT_SLOT_ORDER);
-    const prefs = resolveMetricsPrefs(seedRoot);
-    const controller = createMetricsSidebarController(prefs, () => api.renderer.requestRender());
-    // Explicit teardown for component-owned timers/subscriptions (replaces
-    // the components' old onCleanup, which is not reliable on the V2 Node
-    // loader path). Drained from the plugin dispose hook below.
-    const sidebarDisposers = [];
-    api.slots.register({
-        order: effectiveOrder,
-        slots: {
-            sidebar_content(ctx, props) {
-                const sidebar = SidebarMetrics({
-                    sessionID: props.session_id,
-                    collector,
-                    refreshIntervalMs: config.refreshIntervalMs,
-                    barConfig: config,
-                    theme: ctx.theme.current,
-                    controller: controller,
-                    requestRender: () => api.renderer.requestRender(),
-                });
-                sidebarDisposers.push(sidebar.dispose);
-                return sidebar.node;
-            },
-        },
+// src/metrics.ts
+function estimateTokens(text, ratio) {
+  if (!text) return 0;
+  const safeRatio = Number.isFinite(ratio) && ratio > 0 ? ratio : 4;
+  let tokens = 0;
+  for (const char of text) {
+    const isCjk = /\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}|\p{Script=Hangul}/u.test(char);
+    tokens += isCjk ? 0.6 : 1 / safeRatio;
+  }
+  return Math.max(0, tokens);
+}
+function getDisplayOutputTokens(m) {
+  if (m.hasExactTokens) {
+    return Math.max(0, m.exactOutputTokens + m.exactReasoningTokens);
+  }
+  return Math.max(0, m.estimatedOutputTokens);
+}
+function getDisplayInputTokens(m) {
+  if (m.hasExactTokens) {
+    return Math.max(0, m.exactInputTokens + m.exactCacheReadTokens + m.exactCacheWriteTokens);
+  }
+  return Math.max(0, m.estimatedInputTokens);
+}
+function formatCacheRead(n, completeness) {
+  if (completeness === "unknown") return "\u2014";
+  return `${formatTokens(n)}${completeness === "partial" ? "+" : ""}`;
+}
+var MAX_TTFT_MS = 10 * 60 * 1e3;
+function gateTtft(rawMs) {
+  if (!Number.isFinite(rawMs) || rawMs < 0 || rawMs > MAX_TTFT_MS) return null;
+  return Math.round(rawMs);
+}
+function getTtft(m) {
+  if (m.firstTokenTime === null) return null;
+  return gateTtft(m.firstTokenTime - m.requestStartTime);
+}
+var MAX_CREDIBLE_TPS = 300;
+function credibleTps(tokens, windowMs) {
+  if (!(tokens > 0) || !(windowMs > 0)) return null;
+  const tps = Math.round(tokens / (windowMs / 1e3) * 10) / 10;
+  if (!Number.isFinite(tps) || tps < 0 || tps > MAX_CREDIBLE_TPS) return null;
+  return tps;
+}
+function formatTokens(n) {
+  if (n < 1e3) return String(Math.round(n));
+  return (n / 1e3).toFixed(1) + "K";
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.round(ms % 6e4 / 1e3);
+  return `${minutes}m${seconds}s`;
+}
+function formatElapsed(ms) {
+  ms = Math.max(0, ms);
+  if (ms < 6e4) return `${Math.floor(ms / 1e3)}s`;
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.floor(ms % 6e4 / 1e3);
+  return `${minutes}m${seconds}s`;
+}
+function createFreshMetrics(sessionID, messageID, modelID, providerID, now) {
+  return {
+    sessionID,
+    messageID,
+    modelID,
+    providerID,
+    requestStartTime: now,
+    firstTokenTime: null,
+    lastDeltaTime: null,
+    completeTime: null,
+    estimatedInputTokens: 0,
+    estimatedOutputTokens: 0,
+    exactInputTokens: 0,
+    exactOutputTokens: 0,
+    exactCacheReadTokens: 0,
+    exactCacheWriteTokens: 0,
+    exactReasoningTokens: 0,
+    hasExactTokens: false,
+    hasExactCacheReadTokens: false,
+    hasExactCacheWriteTokens: false,
+    isStreaming: false,
+    isComplete: false
+  };
+}
+
+// src/event-shapes.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function stringOrEmpty(value) {
+  return typeof value === "string" ? value : "";
+}
+function nonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function timestampOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function parseSessionInfo(value) {
+  if (!isRecord(value)) return null;
+  const id = stringOrEmpty(value.id);
+  if (id.length === 0) return null;
+  const hasParentID = hasOwn(value, "parentID");
+  return {
+    id,
+    parentID: typeof value.parentID === "string" ? value.parentID : null,
+    hasParentID
+  };
+}
+function parseTextPart(value) {
+  if (!isRecord(value)) return null;
+  if (value.type !== "text") return null;
+  const partID = stringOrEmpty(value.id);
+  const messageID = stringOrEmpty(value.messageID);
+  const text = stringOrEmpty(value.text);
+  if (partID.length === 0 || messageID.length === 0 || text.length === 0) return null;
+  return { partID, messageID, text };
+}
+function parseAssistantProgressPart(value) {
+  if (!isRecord(value)) return null;
+  if (value.type !== "text" && value.type !== "reasoning") return null;
+  const partID = stringOrEmpty(value.id);
+  const messageID = stringOrEmpty(value.messageID);
+  const text = stringOrEmpty(value.text);
+  if (partID.length === 0 || messageID.length === 0 || text.length === 0) return null;
+  return { partID, messageID, text };
+}
+function parseAssistantTokens(value) {
+  if (!isRecord(value)) return null;
+  const cache = isRecord(value.cache) ? value.cache : null;
+  const hasInput = hasOwn(value, "input");
+  const hasOutput = hasOwn(value, "output");
+  const hasReasoning = hasOwn(value, "reasoning");
+  const hasCacheRead = cache !== null && hasOwn(cache, "read");
+  const hasCacheWrite = cache !== null && hasOwn(cache, "write");
+  return {
+    hasAny: hasInput || hasOutput || hasReasoning || hasCacheRead || hasCacheWrite,
+    hasCacheRead,
+    hasCacheWrite,
+    input: nonNegativeNumber(value.input),
+    output: nonNegativeNumber(value.output),
+    reasoning: nonNegativeNumber(value.reasoning),
+    cacheRead: nonNegativeNumber(cache?.read),
+    cacheWrite: nonNegativeNumber(cache?.write)
+  };
+}
+function parseAssistantMessage(value) {
+  if (!isRecord(value)) return null;
+  const time = isRecord(value.time) ? value.time : null;
+  const createdTime = timestampOrNull(time?.created);
+  const completedTime = timestampOrNull(time?.completed);
+  if (value.role === "assistant") {
+    return {
+      messageID: stringOrEmpty(value.id),
+      modelID: stringOrEmpty(value.modelID),
+      providerID: stringOrEmpty(value.providerID),
+      tokens: parseAssistantTokens(value.tokens),
+      completed: completedTime !== null,
+      createdTime,
+      completedTime
+    };
+  }
+  if (value.type !== "assistant") return null;
+  const model = isRecord(value.model) ? value.model : null;
+  return {
+    messageID: stringOrEmpty(value.id),
+    modelID: stringOrEmpty(model?.id),
+    providerID: stringOrEmpty(model?.providerID),
+    tokens: parseAssistantTokens(value.tokens),
+    completed: completedTime !== null,
+    createdTime,
+    completedTime
+  };
+}
+function parseUserMessage(value) {
+  if (!isRecord(value) || value.role !== "user") return null;
+  const time = isRecord(value.time) ? value.time : null;
+  return { messageID: stringOrEmpty(value.id), createdTime: timestampOrNull(time?.created) };
+}
+function parseAssistantStepStarted(value, fallbackMessageID = "") {
+  if (!isRecord(value)) return null;
+  const sessionID = stringOrEmpty(value.sessionID);
+  const messageID = stringOrEmpty(value.assistantMessageID) || fallbackMessageID;
+  const model = isRecord(value.model) ? value.model : null;
+  if (sessionID.length === 0 || messageID.length === 0) return null;
+  return {
+    sessionID,
+    messageID,
+    modelID: stringOrEmpty(model?.id),
+    providerID: stringOrEmpty(model?.providerID)
+  };
+}
+function parseAssistantTextDelta(value, fallbackMessageID = "") {
+  if (!isRecord(value)) return null;
+  const sessionID = stringOrEmpty(value.sessionID);
+  const messageID = stringOrEmpty(value.assistantMessageID) || fallbackMessageID;
+  const partID = stringOrEmpty(value.textID) || stringOrEmpty(value.reasoningID) || `${messageID}:stream`;
+  const delta = stringOrEmpty(value.delta);
+  if (sessionID.length === 0 || messageID.length === 0 || partID.length === 0 || delta.length === 0) return null;
+  return { sessionID, messageID, partID, delta };
+}
+function parseAssistantStepEnded(value, fallbackMessageID = "") {
+  if (!isRecord(value)) return null;
+  const sessionID = stringOrEmpty(value.sessionID);
+  const messageID = stringOrEmpty(value.assistantMessageID) || fallbackMessageID;
+  const tokens = parseAssistantTokens(value.tokens);
+  if (sessionID.length === 0 || messageID.length === 0 || tokens === null) return null;
+  return { sessionID, messageID, tokens };
+}
+
+// src/request-updates.ts
+function mergeAssistantModel(existing, message) {
+  const modelID = message.modelID || existing?.modelID || "";
+  const providerID = message.providerID || existing?.providerID || "";
+  return modelID || providerID ? { modelID, providerID } : null;
+}
+function applySessionModel(metrics, model) {
+  if (!model) return;
+  metrics.modelID = model.modelID;
+  metrics.providerID = model.providerID;
+}
+function hasPositiveAssistantTokens(tokens) {
+  if (!tokens?.hasAny) return false;
+  return tokens.input + tokens.output + tokens.reasoning + tokens.cacheRead + tokens.cacheWrite > 0;
+}
+function applyAssistantTokens(metrics, tokens) {
+  if (!hasPositiveAssistantTokens(tokens)) return false;
+  metrics.exactInputTokens = tokens.input;
+  metrics.exactOutputTokens = tokens.output;
+  metrics.exactReasoningTokens = tokens.reasoning;
+  metrics.exactCacheReadTokens = tokens.cacheRead;
+  metrics.exactCacheWriteTokens = tokens.cacheWrite;
+  metrics.hasExactTokens = true;
+  metrics.hasExactCacheReadTokens = tokens.hasCacheRead;
+  metrics.hasExactCacheWriteTokens = tokens.hasCacheWrite;
+  return true;
+}
+
+// src/live-speed.ts
+var LIVE_SPEED_WINDOW_MS = 3e3;
+var LIVE_SPEED_STALE_MS = 2e3;
+var LIVE_SPEED_MAX_SAMPLES = 256;
+var LIVE_SPEED_MIN_SAMPLE_INTERVAL_MS = 20;
+function resetLiveSpeed(states, sessionID, messageID) {
+  states.set(sessionID, {
+    messageID,
+    cumulativeTokens: 0,
+    samples: []
+  });
+}
+function clearLiveSpeed(states, sessionID) {
+  states.delete(sessionID);
+}
+function recordLiveTokens(states, sessionID, messageID, deltaTokens, now) {
+  if (!Number.isFinite(deltaTokens) || deltaTokens <= 0) return;
+  let state = states.get(sessionID);
+  if (!state || state.messageID !== messageID) {
+    state = { messageID, cumulativeTokens: 0, samples: [] };
+    states.set(sessionID, state);
+  }
+  state.cumulativeTokens += deltaTokens;
+  const latest = state.samples.at(-1);
+  if (latest !== void 0 && now - latest.at < LIVE_SPEED_MIN_SAMPLE_INTERVAL_MS) {
+    latest.cumulativeTokens = state.cumulativeTokens;
+  } else {
+    state.samples.push({ at: now, cumulativeTokens: state.cumulativeTokens });
+  }
+  const cutoff = now - LIVE_SPEED_WINDOW_MS;
+  while (state.samples.length > 2 && state.samples[1].at < cutoff) {
+    state.samples.shift();
+  }
+  while (state.samples.length > LIVE_SPEED_MAX_SAMPLES) state.samples.shift();
+}
+function getLiveTps(state, now) {
+  if (!state || state.samples.length < 2) return null;
+  const latest = state.samples.at(-1);
+  if (now - latest.at >= LIVE_SPEED_STALE_MS) return null;
+  const cutoff = latest.at - LIVE_SPEED_WINDOW_MS;
+  let baseline = state.samples[0];
+  for (const sample of state.samples) {
+    if (sample.at >= cutoff) {
+      baseline = sample;
+      break;
+    }
+  }
+  const elapsedMs = latest.at - baseline.at;
+  const tokens = latest.cumulativeTokens - baseline.cumulativeTokens;
+  if (elapsedMs <= 0 || tokens <= 0) return null;
+  return Math.round(tokens / (elapsedMs / 1e3) * 10) / 10;
+}
+
+// src/turn-state.ts
+function createTurnMetrics(sessionID, now) {
+  return {
+    sessionID,
+    turnStartTime: now,
+    firstTokenTime: null,
+    completeTime: null,
+    finalizedOutputTokens: 0,
+    finalizedSteps: /* @__PURE__ */ new Map(),
+    stickyContextTokens: 0,
+    stickyContextUpdatedAt: Number.NEGATIVE_INFINITY,
+    hasStickyContextTokens: false,
+    stickyCacheReadTokens: 0,
+    hasStickyCacheReadTokens: false,
+    toolIntervals: [],
+    isComplete: false
+  };
+}
+function ensureTurn(turns, sessionID, now) {
+  const existing = turns.get(sessionID);
+  if (existing) return existing;
+  const turn = createTurnMetrics(sessionID, now);
+  turns.set(sessionID, turn);
+  return turn;
+}
+function startTurn(turns, sessionID, now) {
+  const turn = createTurnMetrics(sessionID, now);
+  turns.set(sessionID, turn);
+  return turn;
+}
+function retireRequestIntoTurn(turn, request, updateSticky = true) {
+  if (!request.messageID) return false;
+  const outputTokens = getDisplayOutputTokens(request);
+  const exact = request.hasExactTokens;
+  const previous = turn.finalizedSteps.get(request.messageID);
+  if (!previous) {
+    turn.finalizedSteps.set(request.messageID, { outputTokens, exact });
+    turn.finalizedOutputTokens += outputTokens;
+  } else if (!previous.exact && exact) {
+    turn.finalizedOutputTokens += outputTokens - previous.outputTokens;
+    turn.finalizedSteps.set(request.messageID, { outputTokens, exact: true });
+  } else {
+    return false;
+  }
+  if (updateSticky && exact && request.requestStartTime >= turn.stickyContextUpdatedAt) {
+    turn.stickyContextTokens = getDisplayInputTokens(request);
+    turn.stickyContextUpdatedAt = request.requestStartTime;
+    turn.hasStickyContextTokens = true;
+    turn.stickyCacheReadTokens = Math.max(0, request.exactCacheReadTokens);
+    turn.hasStickyCacheReadTokens = request.hasExactCacheReadTokens;
+  }
+  return true;
+}
+function liveRequestOutput(turn, request) {
+  if (!request?.messageID || turn.finalizedSteps.has(request.messageID)) return 0;
+  return getDisplayOutputTokens(request);
+}
+function turnInputTokens(turn, request) {
+  if (turn.hasStickyContextTokens) return turn.stickyContextTokens;
+  return request ? getDisplayInputTokens(request) : 0;
+}
+function completeTurn(turn, now) {
+  turn.isComplete = true;
+  turn.completeTime = now;
+}
+function recordTurnFirstToken(turn, now) {
+  if (turn.firstTokenTime === null) turn.firstTokenTime = now;
+}
+function recordToolCalled(turns, sessionID, toolID, now) {
+  const turn = ensureTurn(turns, sessionID, now);
+  turn.toolIntervals.push({ id: toolID, start: now, end: null });
+}
+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;
+    }
+  }
+  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;
+    }
+  }
+}
+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;
+}
+function getTurnTtft(turn, fallback = null) {
+  if (turn?.firstTokenTime != null) {
+    const gated = gateTtft(turn.firstTokenTime - turn.turnStartTime);
+    if (gated !== null) return gated;
+  }
+  return fallback;
+}
+
+// src/request-state.ts
+function currentRequest(input) {
+  const existing = input.state.requests.get(input.sessionID);
+  const isDifferentMessage = existing?.messageID.length ? existing.messageID !== input.messageID : false;
+  if (!existing || isDifferentMessage) {
+    const priorTurn = input.state.turns.get(input.sessionID);
+    const startsAfterCompletedTurn = Boolean(priorTurn?.isComplete && isDifferentMessage);
+    const turn = startsAfterCompletedTurn ? startTurn(input.state.turns, input.sessionID, input.now) : ensureTurn(input.state.turns, input.sessionID, existing?.requestStartTime ?? input.now);
+    if (existing && isDifferentMessage && !startsAfterCompletedTurn) retireRequestIntoTurn(turn, existing);
+    const inheritAnchor = !startsAfterCompletedTurn && (existing?.firstTokenTime ?? null) === null;
+    const requestStartTime = inheritAnchor ? existing?.requestStartTime ?? input.now : input.now;
+    const current = createFreshMetrics(
+      input.sessionID,
+      input.messageID,
+      existing?.modelID ?? "",
+      existing?.providerID ?? "",
+      requestStartTime
+    );
+    applySessionModel(current, input.state.sessionModels.get(input.sessionID));
+    input.state.requests.set(input.sessionID, current);
+    resetLiveSpeed(input.state.liveSpeeds, input.sessionID, input.messageID);
+    input.state.lastRequestSessionID = input.sessionID;
+    input.actions.clearHoldTimer(input.sessionID);
+    return current;
+  }
+  if (existing.messageID.length === 0) {
+    existing.messageID = input.messageID;
+  }
+  input.state.lastRequestSessionID = input.sessionID;
+  return existing;
+}
+function completeRequest(input) {
+  const current = input.state.requests.get(input.sessionID);
+  input.actions.stopSessionTiming(input.sessionID, input.now);
+  const turn = input.state.turns.get(input.sessionID);
+  if (current && turn) retireRequestIntoTurn(turn, current);
+  if (turn) completeTurn(turn, input.now);
+  clearLiveSpeed(input.state.liveSpeeds, input.sessionID);
+  if (!current) return;
+  current.isStreaming = false;
+  current.isComplete = true;
+  current.completeTime = input.now;
+  input.log(`request complete: session=${input.sessionID}`);
+  input.actions.notify();
+  if (input.holdDurationMs <= 0) return;
+  input.actions.clearHoldTimer(input.sessionID);
+  input.state.holdTimers.set(input.sessionID, setTimeout(() => {
+    input.state.holdTimers.delete(input.sessionID);
+    if (input.state.requests.get(input.sessionID)?.sessionID === input.sessionID) {
+      input.state.requests.delete(input.sessionID);
+      input.actions.notify();
+    }
+  }, input.holdDurationMs));
+}
+
+// src/event-bus.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function syncEvent(event) {
+  if (!isRecord2(event)) return null;
+  const sync = event.syncEvent;
+  return isRecord2(sync) ? sync : null;
+}
+function eventProperties(event) {
+  if (!isRecord2(event)) return null;
+  if (Object.prototype.hasOwnProperty.call(event, "properties")) return event.properties;
+  if (Object.prototype.hasOwnProperty.call(event, "data")) return event.data;
+  const sync = syncEvent(event);
+  if (sync && Object.prototype.hasOwnProperty.call(sync, "data")) return sync.data;
+  return null;
+}
+function eventID(event) {
+  if (!isRecord2(event)) return "";
+  const sync = syncEvent(event);
+  if (sync && typeof sync.id === "string") return sync.id;
+  return typeof event.id === "string" ? event.id : "";
+}
+function eventAggregateID(event) {
+  const sync = syncEvent(event);
+  if (sync && typeof sync.aggregateID === "string") return sync.aggregateID;
+  if (!isRecord2(event) || !isRecord2(event.durable)) return "";
+  return typeof event.durable.aggregateID === "string" ? event.durable.aggregateID : "";
+}
+function eventProperty(event, key) {
+  const properties = eventProperties(event);
+  if (!isRecord2(properties) || !Object.prototype.hasOwnProperty.call(properties, key)) return null;
+  return properties[key];
+}
+function stringEventProperty(event, key) {
+  const value = eventProperty(event, key);
+  return typeof value === "string" ? value : "";
+}
+function statusType(event) {
+  const status = eventProperty(event, "status");
+  if (!isRecord2(status)) return "";
+  return typeof status.type === "string" ? status.type : "";
+}
+function eventCreatedWallTime(event) {
+  if (!isRecord2(event)) return null;
+  const created = event.created;
+  if (typeof created !== "number" || !Number.isFinite(created) || created <= 0) return null;
+  if (Math.abs(created - Date.now()) > 864e5) return null;
+  return created;
+}
+function eventPerfTime(event, now) {
+  const wall = eventCreatedWallTime(event);
+  if (wall === null) return now;
+  return now - Math.max(0, Date.now() - wall);
+}
+
+// src/assistant-progress.ts
+function partEstimateKey(sessionID, messageID, partID) {
+  return `${sessionID}:${messageID}:${partID}`;
+}
+function applyTokenDelta(ctx, sessionID, messageID, deltaTokens, now) {
+  const { actions, state } = ctx;
+  if (state.turns.get(sessionID)?.finalizedSteps.has(messageID)) return;
+  const current = currentRequest({ state, actions, sessionID, messageID, now });
+  if (current.firstTokenTime === null) current.firstTokenTime = now;
+  recordTurnFirstToken(ensureTurn(state.turns, sessionID, now), now);
+  if (deltaTokens > 0) {
+    current.estimatedOutputTokens += deltaTokens;
+    current.lastDeltaTime = now;
+    recordLiveTokens(state.liveSpeeds, sessionID, messageID, deltaTokens, now);
+  }
+  current.isStreaming = true;
+  actions.notify();
+}
+function applyAssistantText(ctx, sessionID, messageID, partID, text, now) {
+  const { actions, config, state } = ctx;
+  const key = partEstimateKey(sessionID, messageID, partID);
+  const nextTokens = estimateTokens(text, config.estimationRatio);
+  const previousTokens = state.partTokenEstimates.get(key) ?? 0;
+  const deltaTokens = Math.max(0, nextTokens - previousTokens);
+  state.partTokenEstimates.set(key, Math.max(previousTokens, nextTokens));
+  applyTokenDelta(ctx, sessionID, messageID, deltaTokens, now);
+}
+function applyAssistantProgress(ctx, sessionID, part, now) {
+  applyAssistantText(ctx, sessionID, part.messageID, part.partID, part.text, now);
+}
+function applyAssistantDelta(ctx, event) {
+  const { actions, state } = ctx;
+  const sessionID = stringEventProperty(event, "sessionID");
+  const fallbackMessageID = sessionID.length > 0 ? state.assistantMessageIds.get(sessionID) ?? eventID(event) : eventID(event);
+  const text = parseAssistantTextDelta(eventProperties(event), fallbackMessageID);
+  if (!text) return;
+  const aggregateID = eventAggregateID(event);
+  if (aggregateID.length > 0 && aggregateID !== text.sessionID) {
+    const aggregateAliases = state.sessionAliases.get(aggregateID) ?? /* @__PURE__ */ new Set();
+    aggregateAliases.add(text.sessionID);
+    state.sessionAliases.set(aggregateID, aggregateAliases);
+    const sessionAliases = state.sessionAliases.get(text.sessionID) ?? /* @__PURE__ */ new Set();
+    sessionAliases.add(aggregateID);
+    state.sessionAliases.set(text.sessionID, sessionAliases);
+  }
+  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);
+  state.partTokenEstimates.set(key, (state.partTokenEstimates.get(key) ?? 0) + deltaTokens);
+  applyTokenDelta(ctx, text.sessionID, text.messageID, deltaTokens, now);
+}
+function applyAssistantPartDelta(ctx, sessionID, messageID, partID, delta, now) {
+  const key = partEstimateKey(sessionID, messageID, partID);
+  const deltaTokens = estimateTokens(delta, ctx.config.estimationRatio);
+  ctx.state.partTokenEstimates.set(key, (ctx.state.partTokenEstimates.get(key) ?? 0) + deltaTokens);
+  applyTokenDelta(ctx, sessionID, messageID, deltaTokens, now);
+}
+
+// src/event-handlers.ts
+function registerEventHandlers(ctx) {
+  const { api, config, log: log2, state, actions } = ctx;
+  const disposers = [];
+  function recordSession(value, defaultParentWhenMissing) {
+    const info = parseSessionInfo(value);
+    if (!info) return;
+    if (info.hasParentID) {
+      state.sessionTree.setParent(info.id, info.parentID);
+    } else if (defaultParentWhenMissing) {
+      state.sessionTree.setParent(info.id, null);
+    }
+  }
+  function on(type, handler) {
+    for (const eventType of [type, `${type}.1`, `${type}.2`]) {
+      disposers.push(api.event.on(eventType, (event) => {
+        const id = eventID(event);
+        const properties = eventProperties(event);
+        let serialized = "";
+        try {
+          serialized = JSON.stringify(properties);
+        } catch {
+          serialized = "";
+        }
+        const key = id && eventAggregateID(event) ? `${type}:${id}:${serialized}` : "";
+        if (key && state.seenEventKeys.has(key)) return;
+        if (key) {
+          state.seenEventKeys.add(key);
+          state.seenEventOrder.push(key);
+          if (state.seenEventOrder.length > 4096) {
+            const oldest = state.seenEventOrder.shift();
+            if (oldest) state.seenEventKeys.delete(oldest);
+          }
+        }
+        handler(event);
+      }));
+    }
+  }
+  function addAlias(left, right) {
+    if (left.length === 0 || right.length === 0 || left === right) return;
+    const leftAliases = state.sessionAliases.get(left) ?? /* @__PURE__ */ new Set();
+    leftAliases.add(right);
+    state.sessionAliases.set(left, leftAliases);
+    const rightAliases = state.sessionAliases.get(right) ?? /* @__PURE__ */ new Set();
+    rightAliases.add(left);
+    state.sessionAliases.set(right, rightAliases);
+  }
+  function recordEventAlias(event, sessionID) {
+    addAlias(eventAggregateID(event), sessionID);
+  }
+  function clearPartEstimates(sessionID) {
+    for (const key of state.partTokenEstimates.keys()) {
+      if (key.startsWith(`${sessionID}:`)) state.partTokenEstimates.delete(key);
+    }
+  }
+  on("session.created", (event) => {
+    recordSession(eventProperty(event, "info"), true);
+    actions.notify();
+  });
+  on("session.updated", (event) => {
+    recordSession(eventProperty(event, "info"), false);
+    actions.notify();
+  });
+  on("session.status", (event) => {
+    const sessionID = stringEventProperty(event, "sessionID");
+    if (sessionID.length === 0) return;
+    recordEventAlias(event, sessionID);
+    const type = statusType(event);
+    log2(`session.status: ${sessionID} -> ${type}`);
+    if (type === "busy") {
+      const now = eventPerfTime(event, performance.now());
+      actions.startSessionTiming(sessionID, now);
+      actions.clearHoldTimer(sessionID);
+      const existingTurn = state.turns.get(sessionID);
+      if (!existingTurn || existingTurn.isComplete) startTurn(state.turns, sessionID, now);
+      const existing = state.requests.get(sessionID);
+      if (existing && existing.isComplete) {
+        const prev = existing;
+        state.requests.set(sessionID, createFreshMetrics(sessionID, "", prev.modelID, prev.providerID, now));
+        clearLiveSpeed(state.liveSpeeds, sessionID);
+        state.lastRequestSessionID = sessionID;
+        log2(`new turn after idle: session=${sessionID}`);
+        actions.notify();
+      } else if (!existing) {
+        state.requests.set(sessionID, createFreshMetrics(sessionID, "", "", "", now));
+        state.lastRequestSessionID = sessionID;
+        actions.notify();
+      }
+    }
+    if (type === "idle") {
+      completeRequest({ state, actions, sessionID, now: eventPerfTime(event, performance.now()), holdDurationMs: config.holdDurationMs, log: log2 });
+    }
+  });
+  on("session.idle", (event) => {
+    const sessionID = stringEventProperty(event, "sessionID");
+    if (sessionID.length === 0) return;
+    recordEventAlias(event, sessionID);
+    completeRequest({ state, actions, sessionID, now: eventPerfTime(event, performance.now()), holdDurationMs: config.holdDurationMs, log: log2 });
+  });
+  on("message.part.delta", (event) => {
+    const sessionID = stringEventProperty(event, "sessionID");
+    const messageID = stringEventProperty(event, "messageID");
+    const delta = stringEventProperty(event, "delta");
+    const field = stringEventProperty(event, "field");
+    const partID = stringEventProperty(event, "partID") || `${messageID}:stream`;
+    if (sessionID.length === 0 || messageID.length === 0) return;
+    recordEventAlias(event, sessionID);
+    if (field !== "text") return;
+    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);
+  });
+  on("session.next.step.started", (event) => {
+    const step = parseAssistantStepStarted(eventProperties(event), eventID(event));
+    if (!step) return;
+    recordEventAlias(event, step.sessionID);
+    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);
+    state.assistantMessageIds.set(step.sessionID, step.messageID);
+    clearPartEstimates(step.sessionID);
+    if (step.modelID || step.providerID) {
+      state.sessionModels.set(step.sessionID, { modelID: step.modelID, providerID: step.providerID });
+    }
+    const current = currentRequest({ state, actions, sessionID: step.sessionID, messageID: step.messageID, now });
+    resetLiveSpeed(state.liveSpeeds, step.sessionID, step.messageID);
+    applySessionModel(current, state.sessionModels.get(step.sessionID));
+    actions.notify();
+  });
+  on("session.next.text.delta", (event) => applyAssistantDelta(ctx, event));
+  on("session.next.reasoning.delta", (event) => applyAssistantDelta(ctx, event));
+  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 = eventPerfTime(event, performance.now());
+    actions.startSessionTiming(step.sessionID, now);
+    const turn = ensureTurn(state.turns, step.sessionID, now);
+    const existing = state.requests.get(step.sessionID);
+    const isCurrent = existing?.messageID === step.messageID;
+    if (turn.finalizedSteps.get(step.messageID)?.exact) {
+      log2(`duplicate finalized step ignored: session=${step.sessionID} message=${step.messageID}`);
+      return;
+    }
+    const shouldStore = !existing || existing.messageID.length === 0 || Boolean(state.userMessageIds.get(step.sessionID)?.has(existing.messageID));
+    const current = isCurrent ? existing : createFreshMetrics(step.sessionID, step.messageID, existing?.modelID ?? "", existing?.providerID ?? "", now);
+    if (shouldStore) {
+      state.requests.set(step.sessionID, current);
+      state.lastRequestSessionID = step.sessionID;
+    }
+    if (applyAssistantTokens(current, step.tokens)) {
+      log2(`exact: in=${step.tokens.input} out=${step.tokens.output} cr=${step.tokens.cacheRead} cw=${step.tokens.cacheWrite}`);
+    } else {
+      log2("assistant tokens all zero, skipping overwrite");
+    }
+    current.lastDeltaTime = now;
+    current.isStreaming = false;
+    retireRequestIntoTurn(turn, current, isCurrent || shouldStore);
+    if (state.liveSpeeds.get(step.sessionID)?.messageID === step.messageID) {
+      clearLiveSpeed(state.liveSpeeds, step.sessionID);
+    }
+    actions.notify();
+  });
+  on("message.part.updated", (event) => {
+    const sessionID = stringEventProperty(event, "sessionID");
+    if (sessionID.length === 0) return;
+    recordEventAlias(event, sessionID);
+    const rawPart = eventProperty(event, "part");
+    const part = parseTextPart(rawPart);
+    const now = eventPerfTime(event, performance.now());
+    const msgIds = state.userMessageIds.get(sessionID);
+    if (part && msgIds?.has(part.messageID)) {
+      const current = state.requests.get(sessionID);
+      if (current) {
+        if (!current.isComplete) actions.startSessionTiming(sessionID, now);
+        current.estimatedInputTokens = estimateTokens(part.text, config.estimationRatio);
+        log2(`estimated input tokens: ${current.estimatedInputTokens} (textLen=${part.text.length})`);
+        actions.notify();
+      }
+      return;
+    }
+    const assistantPart = parseAssistantProgressPart(rawPart);
+    if (assistantPart) {
+      applyAssistantProgress(ctx, sessionID, assistantPart, now);
+    }
+  });
+  on("message.updated", (event) => {
+    const sessionID = stringEventProperty(event, "sessionID");
+    if (sessionID.length === 0) return;
+    recordEventAlias(event, sessionID);
+    const info = eventProperty(event, "info");
+    const assistant = parseAssistantMessage(info);
+    if (assistant) {
+      const nextModel = mergeAssistantModel(state.sessionModels.get(sessionID), assistant);
+      if (nextModel) state.sessionModels.set(sessionID, nextModel);
+      const now = eventPerfTime(event, performance.now());
+      const tokens = assistant.tokens;
+      const existing = state.requests.get(sessionID);
+      const turn = ensureTurn(state.turns, sessionID, now);
+      const hasPositive = hasPositiveAssistantTokens(tokens);
+      const isCurrent = existing?.messageID === assistant.messageID;
+      const shouldUseAssistantMessage = assistant.messageID.length > 0 && (hasPositive || isCurrent);
+      const current = shouldUseAssistantMessage ? isCurrent ? existing : turn.finalizedSteps.has(assistant.messageID) ? createFreshMetrics(sessionID, assistant.messageID, assistant.modelID, assistant.providerID, now) : currentRequest({ state, actions, sessionID, messageID: assistant.messageID, now }) : existing;
+      if (current) {
+        if (!current.isComplete) actions.startSessionTiming(sessionID, now);
+        if (tokens) {
+          if (applyAssistantTokens(current, tokens)) {
+            log2(`exact: in=${tokens.input} out=${tokens.output} cr=${tokens.cacheRead} cw=${tokens.cacheWrite}`);
+            retireRequestIntoTurn(turn, current, isCurrent || state.requests.get(sessionID) === current);
+          } else {
+            log2(`assistant tokens all zero, skipping overwrite`);
+          }
+        }
+        applySessionModel(current, state.sessionModels.get(sessionID));
+        if (assistant.completed && state.liveSpeeds.get(sessionID)?.messageID === assistant.messageID) {
+          clearLiveSpeed(state.liveSpeeds, sessionID);
+        }
+        actions.notify();
+      }
+    }
+    const user = parseUserMessage(info);
+    if (user) {
+      const userMsgID = user.messageID;
+      const current = state.requests.get(sessionID);
+      if (current && current.messageID === userMsgID) {
+        return;
+      }
+      if (userMsgID && state.userMessageIds.get(sessionID)?.has(userMsgID)) {
+        return;
+      }
+      const now = eventPerfTime(event, performance.now());
+      const previous = state.requests.get(sessionID);
+      const previousTurn = state.turns.get(sessionID);
+      if (previous && previousTurn) retireRequestIntoTurn(previousTurn, previous);
+      startTurn(state.turns, sessionID, now);
+      clearLiveSpeed(state.liveSpeeds, sessionID);
+      clearPartEstimates(sessionID);
+      const fresh = createFreshMetrics(sessionID, userMsgID, "", "", now);
+      actions.startSessionTiming(sessionID, fresh.requestStartTime);
+      if (userMsgID) {
+        let msgIds = state.userMessageIds.get(sessionID);
+        if (!msgIds) {
+          msgIds = /* @__PURE__ */ new Set();
+          state.userMessageIds.set(sessionID, msgIds);
+        }
+        msgIds.add(userMsgID);
+      }
+      log2(`user msg: id=${userMsgID}`);
+      applySessionModel(fresh, state.sessionModels.get(sessionID));
+      state.requests.set(sessionID, fresh);
+      state.lastRequestSessionID = sessionID;
+      actions.notify();
+    }
+  });
+  on("session.deleted", (event) => {
+    const sessionID = stringEventProperty(event, "sessionID");
+    if (sessionID.length === 0) return;
+    state.sessionTree.deleteSession(sessionID);
+    state.sessionModels.delete(sessionID);
+    state.sessionTimings.delete(sessionID);
+    state.turns.delete(sessionID);
+    state.liveSpeeds.delete(sessionID);
+    state.userMessageIds.delete(sessionID);
+    state.assistantMessageIds.delete(sessionID);
+    state.sessionAliases.delete(sessionID);
+    for (const aliases of state.sessionAliases.values()) {
+      aliases.delete(sessionID);
+    }
+    for (const key of state.partTokenEstimates.keys()) {
+      if (key.startsWith(`${sessionID}:`)) state.partTokenEstimates.delete(key);
+    }
+    actions.clearHoldTimer(sessionID);
+    if (state.requests.has(sessionID)) {
+      state.requests.delete(sessionID);
+      if (state.lastRequestSessionID === sessionID) {
+        state.lastRequestSessionID = [...state.requests.keys()].at(-1) ?? null;
+      }
+      actions.notify();
+    }
+  });
+  return disposers;
+}
+
+// src/logger.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+
+// src/config.ts
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+// src/types.ts
+var DEFAULT_CONFIG = {
+  refreshIntervalMs: 200,
+  holdDurationMs: 0,
+  estimationRatio: 4,
+  enableLogging: false,
+  visible: {
+    speed: true,
+    ttft: true,
+    input: true,
+    output: true,
+    cache: false,
+    elapsed: true,
+    session: true,
+    model: true,
+    modelBreakdown: true
+  }
+};
+
+// src/config.ts
+function getConfigPaths() {
+  return [
+    join(homedir(), ".config", "opencode", "opencode-metrics.json"),
+    join(homedir(), ".config", "opencode", "opencode-bar.json"),
+    join(process.cwd(), ".opencode", "opencode-metrics.json"),
+    join(process.cwd(), ".opencode", "opencode-bar.json")
+  ];
+}
+var cachedConfig = null;
+function getConfig() {
+  if (cachedConfig) return cachedConfig;
+  const merged = { ...DEFAULT_CONFIG };
+  for (const path of getConfigPaths()) {
+    if (!existsSync(path)) continue;
+    try {
+      const raw = readFileSync(path, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.refreshIntervalMs === "number" && parsed.refreshIntervalMs >= 100) {
+        merged.refreshIntervalMs = parsed.refreshIntervalMs;
+      }
+      if (typeof parsed.holdDurationMs === "number" && (parsed.holdDurationMs === 0 || parsed.holdDurationMs >= 1e3)) {
+        merged.holdDurationMs = parsed.holdDurationMs;
+      }
+      if (typeof parsed.estimationRatio === "number" && parsed.estimationRatio > 0) {
+        merged.estimationRatio = parsed.estimationRatio;
+      }
+      if (typeof parsed.enableLogging === "boolean") {
+        merged.enableLogging = parsed.enableLogging;
+      }
+      if (parsed.visible && typeof parsed.visible === "object") {
+        for (const key of Object.keys(merged.visible)) {
+          if (typeof parsed.visible[key] === "boolean") {
+            merged.visible[key] = parsed.visible[key];
+          }
+        }
+      }
+    } catch (error) {
+      if (process.env.OPENCODE_METRICS_DEBUG === "1") {
+        console.warn(`opencode-metrics: failed to read config ${path}`, error);
+      }
+    }
+  }
+  cachedConfig = merged;
+  return merged;
+}
+
+// src/logger.ts
+var logFile = null;
+function getLogDir() {
+  if (process.platform === "win32") {
+    return join2(process.env.LOCALAPPDATA || join2(homedir2(), "AppData", "Local"), "opentui", "opencode-metrics", "logs");
+  }
+  const dataHome = process.env.XDG_DATA_HOME || join2(homedir2(), ".local", "share");
+  return join2(dataHome, "opentui", "opencode-metrics", "logs");
+}
+function getLogFile() {
+  if (logFile) return logFile;
+  const dir = getLogDir();
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+  logFile = join2(dir, "opencode-metrics.log");
+  return logFile;
+}
+function log(msg) {
+  const config = getConfig();
+  if (!config.enableLogging) return;
+  try {
+    appendFileSync(getLogFile(), `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`);
+  } catch (error) {
+    if (process.env.OPENCODE_METRICS_DEBUG === "1") {
+      console.warn("opencode-metrics: failed to write log", error);
+    }
+  }
+}
+
+// src/session-hydration.ts
+async function callWithFallback(attempts) {
+  let lastResponse = null;
+  for (let i = 0; i < attempts.length; i++) {
+    const response = await attempts[i]();
+    if (!isRecord3(response) || response.error == null) {
+      if (i > 0) log(`sdk arg shapes: attempt ${i + 1}/${attempts.length} succeeded`);
+      return response;
+    }
+    lastResponse = response;
+  }
+  log(`sdk arg shapes: all ${attempts.length} failed (response.error)`);
+  return lastResponse;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function timestampOrNull2(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function isHydrationApi(value) {
+  if (!isRecord3(value)) return false;
+  const client = value.client;
+  if (!isRecord3(client)) return false;
+  const session = client.session;
+  return isRecord3(session) && typeof session.messages === "function" && typeof session.status === "function";
+}
+function unwrapData(value) {
+  if (isRecord3(value) && "data" in value) return value.data;
+  return value;
+}
+function unwrapMessageList(response) {
+  const value = unwrapData(response);
+  return Array.isArray(value) ? value : [];
+}
+function unwrapSessionStatus(response, sessionID) {
+  const value = unwrapData(response);
+  if (isRecord3(value)) {
+    const bySessionID = value[sessionID];
+    if (typeof bySessionID === "string" || isRecord3(bySessionID)) return bySessionID;
+  }
+  return value;
+}
+function statusKind(value) {
+  if (typeof value === "string") return value;
+  if (!isRecord3(value)) return "";
+  return typeof value.type === "string" ? value.type : "";
+}
+function messageInfo(value) {
+  if (!isRecord3(value)) return value;
+  return isRecord3(value.info) ? value.info : value;
+}
+function toPerformanceTime(wallTime, now) {
+  if (wallTime === null) return null;
+  return now - Math.max(0, Date.now() - wallTime);
+}
+async function observablePartTimes(api, messageID, now) {
+  const parts = api.client.message?.parts;
+  if (typeof parts !== "function") return { first: null, last: null };
+  let values;
+  try {
+    values = unwrapMessageList(await callWithFallback([
+      () => parts({ id: messageID }),
+      () => parts({ path: { messageID } }),
+      () => parts({ path: { id: messageID } })
+    ]));
+  } catch {
+    return { first: null, last: null };
+  }
+  let firstWall = null;
+  let lastWall = null;
+  for (const value of values) {
+    if (!isRecord3(value) || value.type !== "text" && value.type !== "reasoning") continue;
+    const time = isRecord3(value.time) ? value.time : null;
+    const start = timestampOrNull2(time?.start);
+    const end = timestampOrNull2(time?.end);
+    if (start !== null) firstWall = firstWall === null ? start : Math.min(firstWall, start);
+    if (end !== null) lastWall = lastWall === null ? end : Math.max(lastWall, end);
+  }
+  return { first: toPerformanceTime(firstWall, now), last: toPerformanceTime(lastWall, now) };
+}
+function hydrateSessionTiming(rawMessages, now) {
+  const intervals = [];
+  const hasUserBoundary = rawMessages.some((raw) => parseUserMessage(messageInfo(raw)) !== null);
+  if (!hasUserBoundary) {
+    for (const raw of rawMessages) {
+      const assistant = parseAssistantMessage(messageInfo(raw));
+      const start = toPerformanceTime(assistant?.createdTime ?? null, now);
+      const end = toPerformanceTime(assistant?.completedTime ?? null, now);
+      if (start !== null && end !== null && end >= start) intervals.push({ start, end });
+    }
+    const elapsedMs2 = Math.round(intervals.reduce((total, interval) => total + Math.max(0, interval.end - interval.start), 0));
+    return { elapsedMs: elapsedMs2, activeSince: null, intervals };
+  }
+  let groupStartWall = null;
+  let groupEndWall = null;
+  function closeGroup() {
+    const start = toPerformanceTime(groupStartWall, now);
+    const end = toPerformanceTime(groupEndWall, now);
+    if (start !== null && end !== null && end >= start) intervals.push({ start, end });
+  }
+  for (const raw of rawMessages) {
+    const info = messageInfo(raw);
+    const user = parseUserMessage(info);
+    if (user) {
+      if (groupStartWall !== null) closeGroup();
+      groupStartWall = user.createdTime;
+      groupEndWall = null;
+      continue;
+    }
+    const assistant = parseAssistantMessage(info);
+    if (!assistant) continue;
+    groupStartWall ??= assistant.createdTime;
+    if (assistant.completedTime !== null) {
+      groupEndWall = groupEndWall === null ? assistant.completedTime : Math.max(groupEndWall, assistant.completedTime);
+    }
+  }
+  if (groupStartWall !== null) closeGroup();
+  const elapsedMs = Math.round(intervals.reduce((total, interval) => total + Math.max(0, interval.end - interval.start), 0));
+  return { elapsedMs, activeSince: null, intervals };
+}
+async function hydrateSession(input) {
+  const rawMessages = unwrapMessageList(await callWithFallback([
+    () => input.api.client.session.messages({ sessionID: input.sessionID }),
+    () => input.api.client.session.messages({ id: input.sessionID }),
+    () => input.api.client.session.messages({ path: { sessionID: input.sessionID } }),
+    () => input.api.client.session.messages({ path: { id: input.sessionID } })
+  ]));
+  const infos = rawMessages.map(messageInfo);
+  const assistants = infos.map(parseAssistantMessage).filter((message) => message !== null && hasPositiveAssistantTokens(message.tokens));
+  const assistant = assistants.at(-1);
+  if (!assistant || !hasPositiveAssistantTokens(assistant.tokens)) return false;
+  let lastUserIndex = -1;
+  for (let index = infos.length - 1; index >= 0; index -= 1) {
+    if (parseUserMessage(infos[index])) {
+      lastUserIndex = index;
+      break;
+    }
+  }
+  const trailingAssistants = infos.slice(lastUserIndex + 1).map(parseAssistantMessage).filter((message) => message !== null && hasPositiveAssistantTokens(message.tokens));
+  const lastUser = lastUserIndex >= 0 ? parseUserMessage(infos[lastUserIndex]) : null;
+  const existing = input.state.requests.get(input.sessionID);
+  if (existing && !existing.isComplete && existing.messageID !== assistant.messageID) return false;
+  const requestStartTime = toPerformanceTime(lastUser?.createdTime ?? assistant.createdTime, input.now) ?? input.now;
+  const completedTime = toPerformanceTime(assistant.completedTime, input.now);
+  const sessionStatus = statusKind(unwrapSessionStatus(
+    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(
+    input.sessionID,
+    assistant.messageID,
+    assistant.modelID,
+    assistant.providerID,
+    requestStartTime
+  );
+  if (!shouldReuseExisting || !current.isComplete) {
+    current.requestStartTime = requestStartTime;
+  }
+  current.messageID = assistant.messageID;
+  current.modelID = assistant.modelID;
+  current.providerID = assistant.providerID;
+  const partTimes = await observablePartTimes(input.api, assistant.messageID, input.now);
+  current.firstTokenTime = current.firstTokenTime ?? partTimes.first;
+  current.lastDeltaTime = current.lastDeltaTime ?? partTimes.last ?? completedTime ?? input.now;
+  current.isStreaming = !assistant.completed && sessionStatus !== "idle";
+  current.isComplete = assistant.completed || !current.isStreaming;
+  if (current.isComplete && current.completeTime === null) {
+    current.completeTime = completedTime ?? input.now;
+  }
+  if (!current.isComplete) {
+    current.completeTime = null;
+    current.lastDeltaTime = input.now;
+  }
+  applyAssistantTokens(current, assistant.tokens);
+  const turnStartTime = toPerformanceTime(
+    lastUser?.createdTime ?? trailingAssistants[0]?.createdTime ?? assistant.createdTime,
+    input.now
+  ) ?? requestStartTime;
+  const turn = createTurnMetrics(input.sessionID, turnStartTime);
+  turn.firstTokenTime = toPerformanceTime(trailingAssistants[0]?.createdTime, input.now) ?? current.firstTokenTime;
+  for (const step of trailingAssistants) {
+    if (!step.tokens || !hasPositiveAssistantTokens(step.tokens)) continue;
+    const stepStart = toPerformanceTime(step.createdTime, input.now) ?? turnStartTime;
+    const stepMetrics = createFreshMetrics(
+      input.sessionID,
+      step.messageID,
+      step.modelID,
+      step.providerID,
+      stepStart
+    );
+    applyAssistantTokens(stepMetrics, step.tokens);
+    retireRequestIntoTurn(turn, stepMetrics);
+  }
+  if (sessionStatus === "idle" || current.isComplete) completeTurn(turn, completedTime ?? input.now);
+  input.state.turns.set(input.sessionID, turn);
+  const liveEntry = input.state.requests.get(input.sessionID);
+  if (liveEntry !== void 0 && liveEntry !== current && !liveEntry.isComplete && liveEntry.messageID !== current.messageID) {
+    return false;
+  }
+  input.state.requests.set(input.sessionID, current);
+  input.state.lastRequestSessionID = input.sessionID;
+  if (assistant.modelID || assistant.providerID) {
+    input.state.sessionModels.set(input.sessionID, { modelID: assistant.modelID, providerID: assistant.providerID });
+  }
+  if (!input.state.sessionTimings.has(input.sessionID)) {
+    const timing = hydrateSessionTiming(rawMessages, input.now);
+    input.state.sessionTimings.set(input.sessionID, timing);
+    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;
+}
+
+// src/session-tree.ts
+function createSessionTree() {
+  const parentBySession = /* @__PURE__ */ new Map();
+  function collectDescendants(sessionID, seen) {
+    const descendants = [];
+    for (const [candidateID, parentID] of parentBySession) {
+      if (parentID !== sessionID || seen.has(candidateID)) continue;
+      seen.add(candidateID);
+      descendants.push(candidateID, ...collectDescendants(candidateID, seen));
+    }
+    return descendants;
+  }
+  return {
+    setParent(sessionID, parentID) {
+      parentBySession.set(sessionID, parentID);
+    },
+    deleteSession(sessionID) {
+      parentBySession.delete(sessionID);
+    },
+    clear() {
+      parentBySession.clear();
+    },
+    getScopeSessionIDs(sessionID, scope) {
+      if (scope === "current") return [sessionID];
+      const seen = /* @__PURE__ */ new Set([sessionID]);
+      return [sessionID, ...collectDescendants(sessionID, seen)];
+    },
+    getChildSessionCount(sessionID) {
+      return collectDescendants(sessionID, /* @__PURE__ */ new Set([sessionID])).length;
+    }
+  };
+}
+
+// src/session-timing.ts
+function startSessionTiming(timings, sessionID, now) {
+  const timing = timings.get(sessionID);
+  if (!timing) {
+    timings.set(sessionID, { elapsedMs: 0, activeSince: now, intervals: [] });
+    return;
+  }
+  if (timing.activeSince === null) timing.activeSince = now;
+}
+function stopSessionTiming(timings, sessionID, now) {
+  const timing = timings.get(sessionID);
+  if (!timing || timing.activeSince === null) return;
+  timing.elapsedMs += Math.max(0, now - timing.activeSince);
+  timing.intervals ??= [];
+  timing.intervals.push({ start: timing.activeSince, end: now });
+  timing.activeSince = null;
+}
+function getScopeElapsedMs(timings, sessionIDs, now) {
+  const intervals = [];
+  let unpositionedElapsedMs = 0;
+  for (const sessionID of sessionIDs) {
+    const timing = timings.get(sessionID);
+    if (!timing) continue;
+    const positionedMs = (timing.intervals ?? []).reduce(
+      (total, interval) => total + Math.max(0, interval.end - interval.start),
+      0
+    );
+    for (const interval of timing.intervals ?? []) intervals.push(interval);
+    if (timing.activeSince !== null) intervals.push({ start: timing.activeSince, end: now });
+    unpositionedElapsedMs += Math.max(0, timing.elapsedMs - positionedMs);
+  }
+  intervals.sort((left, right) => left.start - right.start || left.end - right.end);
+  let unionMs = 0;
+  let start = null;
+  let end = null;
+  for (const interval of intervals) {
+    if (start === null || end === null) {
+      start = interval.start;
+      end = interval.end;
+      continue;
+    }
+    if (interval.start <= end) {
+      end = Math.max(end, interval.end);
+      continue;
+    }
+    unionMs += Math.max(0, end - start);
+    start = interval.start;
+    end = interval.end;
+  }
+  if (start !== null && end !== null) unionMs += Math.max(0, end - start);
+  return unionMs + unpositionedElapsedMs;
+}
+function getSessionElapsedMs(timing, now) {
+  if (!timing) return 0;
+  return timing.elapsedMs + (timing.activeSince === null ? 0 : Math.max(0, now - timing.activeSince));
+}
+
+// src/collector.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTreeHydrationApi(value) {
+  if (!isRecord4(value) || !isRecord4(value.client)) return false;
+  const session = isRecord4(value.client.session) ? value.client.session : null;
+  return session !== null && typeof session.children === "function";
+}
+function childSessions(value) {
+  if (isRecord4(value) && value.error !== void 0 && value.error !== null) {
+    throw new Error(`session.children returned an error: ${String(value.error)}`);
+  }
+  const data = Array.isArray(value) ? value : isRecord4(value) && Array.isArray(value.data) ? value.data : [];
+  return data.flatMap((item) => {
+    if (!isRecord4(item) || typeof item.id !== "string" || item.id.length === 0) return [];
+    return [{ id: item.id, parentID: typeof item.parentID === "string" ? item.parentID : null }];
+  });
+}
+function createCollector(api, config, log2) {
+  const state = {
+    requests: /* @__PURE__ */ new Map(),
+    turns: /* @__PURE__ */ new Map(),
+    liveSpeeds: /* @__PURE__ */ new Map(),
+    holdTimers: /* @__PURE__ */ new Map(),
+    sessionTree: createSessionTree(),
+    sessionModels: /* @__PURE__ */ new Map(),
+    sessionTimings: /* @__PURE__ */ new Map(),
+    userMessageIds: /* @__PURE__ */ new Map(),
+    assistantMessageIds: /* @__PURE__ */ new Map(),
+    partTokenEstimates: /* @__PURE__ */ new Map(),
+    sessionAliases: /* @__PURE__ */ new Map(),
+    seenEventKeys: /* @__PURE__ */ new Set(),
+    seenEventOrder: [],
+    lastRequestSessionID: null
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  const hydrationApi = isHydrationApi(api) ? api : null;
+  const treeHydrationApi = isTreeHydrationApi(api) ? api : null;
+  const hydratedSessions = /* @__PURE__ */ new Set();
+  const hydratingSessions = /* @__PURE__ */ new Set();
+  const hydrationRetryAfter = /* @__PURE__ */ new Map();
+  const hydrationRetries = /* @__PURE__ */ new Map();
+  const MAX_HYDRATION_RETRIES = 5;
+  const loggedFallbacks = /* @__PURE__ */ new Set();
+  const hydratedTreeRoots = /* @__PURE__ */ new Set();
+  const hydratingTreeRoots = /* @__PURE__ */ new Set();
+  const treeRetryAfter = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const AGGREGATE_CACHE_TTL_MS = 150;
+  let aggregateCacheKey = "";
+  let aggregateCacheAt = 0;
+  let aggregateCacheValue = null;
+  function notify() {
+    if (disposed) return;
+    aggregateCacheKey = "";
+    aggregateCacheAt = 0;
+    aggregateCacheValue = null;
+    for (const listener of listeners) listener();
+  }
+  function clearHoldTimer(sessionID) {
+    const timer = state.holdTimers.get(sessionID);
+    if (timer) {
+      clearTimeout(timer);
+      state.holdTimers.delete(sessionID);
+    }
+  }
+  const disposers = registerEventHandlers({
+    api,
+    config,
+    log: log2,
+    state,
+    actions: {
+      notify,
+      startSessionTiming: (sessionID, now) => startSessionTiming(state.sessionTimings, sessionID, now),
+      stopSessionTiming: (sessionID, now) => stopSessionTiming(state.sessionTimings, sessionID, now),
+      clearHoldTimer
+    }
+  });
+  function hydrate(sessionID) {
+    if (!hydrationApi || hydratedSessions.has(sessionID) || hydratingSessions.has(sessionID)) return;
+    const now = performance.now();
+    if ((hydrationRetryAfter.get(sessionID) ?? 0) > now) return;
+    if ((hydrationRetries.get(sessionID) ?? 0) >= MAX_HYDRATION_RETRIES) return;
+    hydratingSessions.add(sessionID);
+    void (async () => {
+      let hydrated = false;
+      try {
+        hydrated = await hydrateSession({ api: hydrationApi, state, sessionID, now });
+      } catch (error) {
+        log2(`session hydration failed: session=${sessionID} error=${String(error)}`);
+      } finally {
+        hydratingSessions.delete(sessionID);
+      }
+      if (disposed) return;
+      const current = state.requests.get(sessionID);
+      if (hydrated && current) {
+        hydratedSessions.add(sessionID);
+        hydrationRetryAfter.delete(sessionID);
+        hydrationRetries.delete(sessionID);
+        clearLiveSpeed(state.liveSpeeds, sessionID);
+        log2(`hydrated session state: session=${sessionID} message=${current.messageID} in=${current.exactInputTokens} out=${current.exactOutputTokens}`);
+        notify();
+      } else {
+        hydrationRetryAfter.set(sessionID, now + 2e3);
+        hydrationRetries.set(sessionID, (hydrationRetries.get(sessionID) ?? 0) + 1);
+      }
+    })();
+  }
+  function hydrateTree(rootSessionID) {
+    if (!treeHydrationApi || hydratedTreeRoots.has(rootSessionID) || hydratingTreeRoots.has(rootSessionID)) return;
+    const now = performance.now();
+    if ((treeRetryAfter.get(rootSessionID) ?? 0) > now) return;
+    hydratingTreeRoots.add(rootSessionID);
+    void (async () => {
+      try {
+        let parents = [rootSessionID];
+        const visited = new Set(parents);
+        while (parents.length > 0) {
+          const responses = await Promise.all(parents.map(async (parentID) => ({
+            parentID,
+            response: await callWithFallback([
+              () => treeHydrationApi.client.session.children({ sessionID: parentID }),
+              () => treeHydrationApi.client.session.children({ path: { sessionID: parentID } }),
+              () => treeHydrationApi.client.session.children({ path: { id: parentID } })
+            ])
+          })));
+          if (disposed) return;
+          const next = [];
+          for (const { parentID, response } of responses) {
+            for (const child of childSessions(response)) {
+              const childID = child.id;
+              state.sessionTree.setParent(childID, child.parentID ?? parentID);
+              hydrate(childID);
+              if (!visited.has(childID)) {
+                visited.add(childID);
+                next.push(childID);
+              }
+            }
+          }
+          parents = next;
+        }
+        hydratedTreeRoots.add(rootSessionID);
+        treeRetryAfter.delete(rootSessionID);
+        notify();
+      } catch (error) {
+        if (!disposed) {
+          treeRetryAfter.set(rootSessionID, performance.now() + 2e3);
+          log2(`tree hydration failed: session=${rootSessionID} error=${String(error)}`);
+        }
+      } finally {
+        hydratingTreeRoots.delete(rootSessionID);
+      }
+    })();
+  }
+  function normalizeSessionID(sessionID) {
+    return typeof sessionID === "string" ? sessionID : "";
+  }
+  function hasUsefulMetrics(metrics) {
+    return metrics.some((item) => getDisplayInputTokens(item) > 0 || getDisplayOutputTokens(item) > 0 || item.exactCacheReadTokens > 0 || item.exactCacheWriteTokens > 0 || item.firstTokenTime !== null || item.lastDeltaTime !== null);
+  }
+  function hasUsefulSession(sessionID) {
+    const request = state.requests.get(sessionID);
+    const turn = state.turns.get(sessionID);
+    return Boolean(
+      request && hasUsefulMetrics([request]) || turn && (turn.finalizedOutputTokens > 0 || turn.hasStickyContextTokens)
+    );
+  }
+  function usefulMetricsFor(ids) {
+    const metrics = ids.map((id) => state.requests.get(id)).filter((item) => item !== void 0);
+    return metrics.length > 0 && ids.some(hasUsefulSession) ? metrics : [];
+  }
+  function aliasScopeSessionIDs(sessionID, scope) {
+    for (const aliasID of state.sessionAliases.get(sessionID) ?? []) {
+      const aliasIDs = state.sessionTree.getScopeSessionIDs(aliasID, scope);
+      if (usefulMetricsFor(aliasIDs).length > 0) {
+        return { rootID: aliasID, ids: aliasIDs };
+      }
+    }
+    return null;
+  }
+  function resolveMetricsSessionID(sessionID) {
+    const requestedSessionID = normalizeSessionID(sessionID);
+    const requested = state.requests.get(requestedSessionID);
+    if (requested && hasUsefulMetrics([requested]) || hasUsefulSession(requestedSessionID)) return requestedSessionID;
+    const alias = aliasScopeSessionIDs(requestedSessionID, "current");
+    if (alias) return alias.rootID;
+    return requestedSessionID;
+  }
+  function scopeSessionIDs(sessionID, scope) {
+    const requestedSessionID = normalizeSessionID(sessionID);
+    const requestedIDs = state.sessionTree.getScopeSessionIDs(requestedSessionID, scope);
+    if (usefulMetricsFor(requestedIDs).length > 0) {
+      return { rootID: requestedSessionID, ids: requestedIDs };
+    }
+    const alias = aliasScopeSessionIDs(requestedSessionID, scope);
+    if (alias) {
+      const fallbackKey = `${requestedSessionID}->${alias.rootID}`;
+      if (!loggedFallbacks.has(fallbackKey)) {
+        loggedFallbacks.add(fallbackKey);
+        log2(`sidebar session alias: requested=${requestedSessionID || "(empty)"} metrics=${alias.rootID}`);
+      }
+      return alias;
+    }
+    return { rootID: requestedSessionID, ids: requestedIDs };
+  }
+  function aggregateByModel(ids, now, scope, rootID, foregroundTurnStart) {
+    const modelGroups = /* @__PURE__ */ new Map();
+    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;
+      const key = `${request.modelID}|${request.providerID}`;
+      const group = modelGroups.get(key) ?? [];
+      group.push(request);
+      modelGroups.set(key, group);
+    }
+    const result = [];
+    for (const [key, metrics] of modelGroups) {
+      const [modelID, providerID] = key.split("|");
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let cacheReadTokens = 0;
+      let exactCacheCount = 0;
+      let requestStartTime = Number.POSITIVE_INFINITY;
+      let firstTokenTime = null;
+      let completeTime = null;
+      let isStreaming = false;
+      let isComplete = true;
+      const sessionCount = new Set(metrics.map((m) => m.sessionID)).size;
+      for (const m of metrics) {
+        inputTokens += getDisplayInputTokens(m);
+        outputTokens += getDisplayOutputTokens(m);
+        if (m.hasExactCacheReadTokens) {
+          cacheReadTokens += Math.max(0, m.exactCacheReadTokens);
+          exactCacheCount += 1;
+        }
+        requestStartTime = Math.min(requestStartTime, m.requestStartTime);
+        if (m.firstTokenTime !== null) {
+          firstTokenTime = firstTokenTime === null ? m.firstTokenTime : Math.min(firstTokenTime, m.firstTokenTime);
+        }
+        if (m.completeTime !== null) {
+          completeTime = completeTime === null ? m.completeTime : Math.max(completeTime, m.completeTime);
+        }
+        isStreaming = isStreaming || m.isStreaming;
+        isComplete = isComplete && m.isComplete;
+      }
+      const cacheReadCompleteness = exactCacheCount === 0 ? "unknown" : exactCacheCount === metrics.length ? "exact" : "partial";
+      let ttft = null;
+      for (const m of metrics) {
+        const candidate = getTurnTtft(state.turns.get(m.sessionID), getTtft(m));
+        if (candidate !== null && (ttft === null || candidate < ttft)) ttft = candidate;
+      }
+      let liveTps = 0;
+      let liveRateCount = 0;
+      for (const m of metrics) {
+        const rate = getLiveTps(state.liveSpeeds.get(m.sessionID), now);
+        if (rate !== null) {
+          liveTps += rate;
+          liveRateCount += 1;
+        }
+      }
+      let displayTps = null;
+      if (liveRateCount > 0 && !isComplete) {
+        const saneLive = Number.isFinite(liveTps) && liveTps >= 0 && liveTps <= 300;
+        if (saneLive) {
+          displayTps = Math.round(liveTps * 10) / 10;
+        }
+      }
+      if (displayTps === null && metrics.length > 0) {
+        const latest = metrics.reduce((a, b) => b.requestStartTime >= a.requestStartTime ? b : a);
+        const frTokens = getDisplayOutputTokens(latest);
+        const genStart = latest.firstTokenTime ?? latest.requestStartTime;
+        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 + 6e4;
+        let primary = null;
+        if (frTokens > 0 && saneStart && saneEnd && genEnd > genStart) {
+          primary = Math.round(frTokens / ((genEnd - genStart) / 1e3) * 10) / 10;
+        }
+        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({
+        modelID,
+        providerID,
+        sessionID: providerID,
+        sessionCount,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheReadCompleteness,
+        requestStartTime: requestStartTime === Number.POSITIVE_INFINITY ? now : requestStartTime,
+        firstTokenTime,
+        completeTime: isComplete ? completeTime ?? now : null,
+        ttft,
+        liveTps: displayTps,
+        isStreaming,
+        isComplete
+      });
+    }
+    return result.sort((a, b) => {
+      const providerCompare = a.providerID.localeCompare(b.providerID);
+      if (providerCompare !== 0) return providerCompare;
+      return a.modelID.localeCompare(b.modelID);
     });
-    api.lifecycle.onDispose(() => {
-        for (const dispose of sidebarDisposers.splice(0)) {
-            try {
-                dispose();
+  }
+  return {
+    getCurrent(sessionID) {
+      const requestedSessionID = normalizeSessionID(sessionID);
+      hydrate(requestedSessionID);
+      return state.requests.get(resolveMetricsSessionID(requestedSessionID)) ?? null;
+    },
+    getAggregate(sessionID, scope, now = performance.now()) {
+      const requestedSessionID = normalizeSessionID(sessionID);
+      hydrate(requestedSessionID);
+      if (scope === "tree") hydrateTree(requestedSessionID);
+      const cacheKey = `${requestedSessionID}:${scope}`;
+      if (cacheKey === aggregateCacheKey && now - aggregateCacheAt < AGGREGATE_CACHE_TTL_MS) {
+        return aggregateCacheValue;
+      }
+      const { rootID, ids } = scopeSessionIDs(requestedSessionID, scope);
+      const foregroundTurn = state.turns.get(rootID);
+      const foregroundRequest = state.requests.get(rootID);
+      if (!foregroundTurn && !foregroundRequest) return null;
+      const foregroundTurnStart = foregroundTurn?.turnStartTime ?? foregroundRequest.requestStartTime;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let cacheReadTokens = 0;
+      let cacheExactCount = 0;
+      let contributingCount = 0;
+      let liveTps = 0;
+      let liveRateCount = 0;
+      let isStreaming = false;
+      const contributingSessionIDs = [];
+      for (const id of ids) {
+        const turn = state.turns.get(id);
+        const request = state.requests.get(id);
+        if (!turn && !request) continue;
+        const belongsToForegroundTurn = id === rootID || Boolean(turn && (turn.turnStartTime >= foregroundTurnStart || !turn.isComplete));
+        if (belongsToForegroundTurn) {
+          const sessionInput = turn ? turnInputTokens(turn, request) : request ? getDisplayInputTokens(request) : 0;
+          const sessionOutput = turn ? turn.finalizedOutputTokens + liveRequestOutput(turn, request) : request ? getDisplayOutputTokens(request) : 0;
+          const hasContribution = sessionInput > 0 || sessionOutput > 0 || Boolean(request?.isStreaming);
+          if (hasContribution) {
+            inputTokens += sessionInput;
+            outputTokens += sessionOutput;
+            contributingCount += 1;
+            contributingSessionIDs.push(id);
+            if (turn?.hasStickyCacheReadTokens) {
+              cacheReadTokens += turn.stickyCacheReadTokens;
+              cacheExactCount += 1;
+            } else if (!turn && request?.hasExactCacheReadTokens) {
+              cacheReadTokens += Math.max(0, request.exactCacheReadTokens);
+              cacheExactCount += 1;
             }
-            catch { /* ignore */ }
+          }
+        }
+        const rate = getLiveTps(state.liveSpeeds.get(id), now);
+        if (rate !== null) {
+          liveTps += rate;
+          liveRateCount += 1;
+        }
+        isStreaming = isStreaming || Boolean(request?.isStreaming);
+      }
+      const cacheReadCompleteness = cacheExactCount === 0 ? "unknown" : cacheExactCount === contributingCount ? "exact" : "partial";
+      const requestStartTime = foregroundTurn?.turnStartTime ?? foregroundRequest.requestStartTime;
+      const firstTokenTime = foregroundRequest?.firstTokenTime ?? null;
+      const foregroundComplete = foregroundTurn?.isComplete ?? foregroundRequest?.isComplete ?? false;
+      const isComplete = isStreaming ? false : foregroundComplete;
+      const completeTime = foregroundTurn?.completeTime ?? foregroundRequest?.completeTime ?? null;
+      let displayTps = null;
+      if (liveRateCount > 0 && !isComplete) {
+        const saneLive = Number.isFinite(liveTps) && liveTps >= 0 && liveTps <= 300;
+        if (saneLive) {
+          displayTps = Math.round(liveTps * 10) / 10;
+        }
+      }
+      if (displayTps === null && foregroundRequest) {
+        const frTokens = getDisplayOutputTokens(foregroundRequest);
+        const genStart = firstTokenTime ?? requestStartTime;
+        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 + 6e4;
+        let primary = null;
+        if (frTokens > 0 && saneStart && saneEnd && genEnd > genStart) {
+          primary = Math.round(frTokens / ((genEnd - genStart) / 1e3) * 10) / 10;
+        }
+        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;
+        }
+      }
+      const modelBreakdown = scope === "tree" ? aggregateByModel(ids, now, scope, rootID, foregroundTurnStart) : [];
+      const ttft = getTurnTtft(foregroundTurn, foregroundRequest ? getTtft(foregroundRequest) : null);
+      const result = {
+        sessionIDs: contributingSessionIDs.length > 0 ? contributingSessionIDs : [rootID],
+        childSessionCount: scope === "tree" ? state.sessionTree.getChildSessionCount(rootID) : 0,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheReadCompleteness,
+        requestStartTime,
+        firstTokenTime,
+        completeTime: isComplete ? completeTime ?? now : null,
+        ttft,
+        liveTps: displayTps,
+        isStreaming,
+        isComplete,
+        modelBreakdown
+      };
+      aggregateCacheKey = cacheKey;
+      aggregateCacheAt = now;
+      aggregateCacheValue = result;
+      return result;
+    },
+    getSessionElapsedMs(sessionID, scope = "current", now = performance.now()) {
+      const requestedSessionID = normalizeSessionID(sessionID);
+      hydrate(requestedSessionID);
+      if (scope === "tree") hydrateTree(requestedSessionID);
+      const { rootID, ids } = scopeSessionIDs(requestedSessionID, scope);
+      if (scope === "current") return getSessionElapsedMs(state.sessionTimings.get(rootID), now);
+      return getScopeElapsedMs(state.sessionTimings, ids, now);
+    },
+    getChildSessionCount(sessionID) {
+      return state.sessionTree.getChildSessionCount(sessionID);
+    },
+    setSessionParent(childID, parentID) {
+      if (!childID) return;
+      state.sessionTree.setParent(childID, parentID);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    dispose() {
+      disposed = true;
+      for (const dispose of disposers.splice(0)) dispose();
+      for (const timer of state.holdTimers.values()) clearTimeout(timer);
+      state.holdTimers.clear();
+      state.requests.clear();
+      state.turns.clear();
+      state.liveSpeeds.clear();
+      state.sessionTree.clear();
+      state.sessionModels.clear();
+      state.sessionTimings.clear();
+      state.userMessageIds.clear();
+      state.assistantMessageIds.clear();
+      state.partTokenEstimates.clear();
+      state.sessionAliases.clear();
+      state.seenEventKeys.clear();
+      state.seenEventOrder.length = 0;
+      state.lastRequestSessionID = null;
+      loggedFallbacks.clear();
+      hydratedSessions.clear();
+      hydratingSessions.clear();
+      hydrationRetryAfter.clear();
+      hydratedTreeRoots.clear();
+      hydratingTreeRoots.clear();
+      treeRetryAfter.clear();
+      listeners.clear();
+    }
+  };
+}
+
+// src/components/SidebarMetrics.tsx
+import { createMemo, createSignal } from "solid-js";
+
+// src/components/ui-element.ts
+import { createElement, insert, setProp } from "@opentui/solid";
+function element(tag, props = {}, children = []) {
+  const node = createElement(tag);
+  let ref;
+  for (const [key, value] of Object.entries(props)) {
+    if (value === void 0) continue;
+    if (key === "ref") {
+      ref = value;
+      continue;
+    }
+    setProp(node, key, value);
+  }
+  if (children.length > 0) insert(node, children);
+  ref?.(node);
+  return node;
+}
+
+// src/components/StatRow.tsx
+function StatRow(props) {
+  let rowNode;
+  let labelNode;
+  let valueNode;
+  const fg = () => {
+    if (props.warning) return props.theme.warning;
+    if (props.success) return props.theme.success ?? props.theme.accent;
+    if (props.accent) return props.theme.accent;
+    if (props.dim) return props.theme.textMuted;
+    return props.theme.text;
+  };
+  const label2 = () => typeof props.label === "function" ? props.label() : props.label;
+  const value = () => typeof props.value === "function" ? props.value() : props.value;
+  const visible = () => typeof props.visible === "function" ? props.visible() : props.visible !== false;
+  const content = () => `${props.icon ? `${props.icon}  ` : ""}${value()}`;
+  const syncContent = () => {
+    const isVisible = visible();
+    if (rowNode && !rowNode.isDestroyed) {
+      rowNode.visible = isVisible;
+      try {
+        rowNode.height = isVisible ? "auto" : 0;
+      } catch {
+      }
+    }
+    if (labelNode && !labelNode.isDestroyed) labelNode.content = isVisible ? label2() : "";
+    if (!valueNode || valueNode.isDestroyed) return;
+    valueNode.content = isVisible ? content() : "";
+    valueNode.requestRender();
+  };
+  props.registerSync?.(syncContent);
+  const attachRowNode = (node) => {
+    rowNode = node;
+    syncContent();
+  };
+  const attachLabelNode = (node) => {
+    labelNode = node;
+    syncContent();
+  };
+  const attachValueNode = (node) => {
+    valueNode = node;
+    syncContent();
+  };
+  return element("box", {
+    ref: attachRowNode,
+    width: "100%",
+    flexDirection: "row",
+    justifyContent: "space-between",
+    visible: visible()
+  }, [
+    element("text", {
+      ref: attachLabelNode,
+      fg: props.theme.textMuted,
+      content: visible() ? label2() : ""
+    }),
+    element("text", {
+      ref: attachValueNode,
+      fg: fg(),
+      content: content()
+    })
+  ]);
+}
+
+// src/components/SidebarMetrics.tsx
+var MAX_MODEL_ROWS = 8;
+function SidebarMetrics(props) {
+  let disposed = false;
+  let refreshQueued = false;
+  let interval;
+  let unsub = () => {
+  };
+  let unsubController = () => {
+  };
+  const rowSyncs = /* @__PURE__ */ new Set();
+  const registerRowSync = (sync) => {
+    if (disposed) return () => {
+    };
+    rowSyncs.add(sync);
+    return () => rowSyncs.delete(sync);
+  };
+  const syncRows = () => {
+    if (disposed) return;
+    for (const sync of rowSyncs) sync();
+  };
+  const [tick, setTick] = createSignal(0);
+  const bump = () => {
+    if (disposed) return;
+    setTick((t) => t + 1);
+    syncRows();
+    if (refreshQueued) return;
+    refreshQueued = true;
+    queueMicrotask(() => {
+      refreshQueued = false;
+      if (disposed) return;
+      syncRows();
+      props.requestRender?.();
+    });
+  };
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    refreshQueued = false;
+    rowSyncs.clear();
+    if (interval !== void 0) clearInterval(interval);
+    unsub();
+    unsubController();
+  };
+  interval = setInterval(bump, props.refreshIntervalMs);
+  unsub = props.collector.subscribe(bump);
+  unsubController = props.controller.subscribe(bump);
+  const sectionEnabled = createMemo(() => {
+    tick();
+    return props.controller.prefs().section.enabled;
+  });
+  const requestNow = (m) => {
+    const live = performance.now();
+    return m.isComplete && m.completeTime !== null ? m.completeTime : live;
+  };
+  const rowVisible = (key) => {
+    const barVis = props.barConfig.visible;
+    const rowPrefs = props.controller.prefs().rows;
+    return barVis[key] !== false && rowPrefs[key] !== false;
+  };
+  const collapsed = createMemo(() => {
+    tick();
+    return props.controller.collapsed();
+  });
+  const headerLabel = () => props.controller.prefs().section.label;
+  let collapsedHeaderNode;
+  let expandedHeaderNode;
+  const syncHeader = () => {
+    if (disposed) return;
+    const isCollapsed = collapsed();
+    for (const [node, visible] of [
+      [collapsedHeaderNode, isCollapsed],
+      [expandedHeaderNode, !isCollapsed]
+    ]) {
+      if (!node || node.isDestroyed) continue;
+      try {
+        node.visible = visible;
+        if (visible) {
+          node.width = "auto";
+          node.height = "auto";
+        } else {
+          node.width = 0;
+          node.height = 0;
+        }
+      } catch {
+      }
+    }
+  };
+  registerRowSync(syncHeader);
+  const attachCollapsedHeaderNode = (node) => {
+    collapsedHeaderNode = node;
+    syncHeader();
+  };
+  const attachExpandedHeaderNode = (node) => {
+    expandedHeaderNode = node;
+    syncHeader();
+  };
+  const toggleCollapsed = () => props.controller.toggleCollapsed();
+  const attachBoxToggle = (node) => {
+    node.onMouseDown = toggleCollapsed;
+  };
+  const currentScope = () => props.controller.prefs().scope;
+  const currentAggregate = () => props.collector.getAggregate(props.sessionID, currentScope());
+  const hasAggregate = () => currentAggregate() !== null;
+  const expandedActive = () => !collapsed() && hasAggregate();
+  const expandedIdle = () => !collapsed() && !hasAggregate();
+  const collapsedActive = () => collapsed() && hasAggregate();
+  const frozenNow = () => {
+    const m = currentAggregate();
+    if (!m) return performance.now();
+    return requestNow(m);
+  };
+  const speedValue = () => {
+    const m = currentAggregate();
+    return m?.liveTps === null || m?.liveTps === void 0 ? "\u2014" : `${m.liveTps.toFixed(1)} t/s`;
+  };
+  const elapsedValue = () => {
+    const m = currentAggregate();
+    return formatElapsed(m ? frozenNow() - m.requestStartTime : 0);
+  };
+  const ttftValue = () => {
+    const ttft = currentAggregate()?.ttft ?? null;
+    return ttft !== null ? formatDuration(ttft) : "--";
+  };
+  const tokenValue = () => {
+    const m = currentAggregate();
+    const inputTokens = m?.inputTokens ?? 0;
+    const outputTokens = m?.outputTokens ?? 0;
+    return `${rowVisible("input") ? `\u2193 ${formatTokens(inputTokens)} in` : ""}${rowVisible("input") && rowVisible("output") ? "  " : ""}${rowVisible("output") ? `\u2191 ${formatTokens(outputTokens)} out` : ""}`;
+  };
+  const cacheValue = () => {
+    const m = currentAggregate();
+    return formatCacheRead(m?.cacheReadTokens ?? 0, m?.cacheReadCompleteness ?? "unknown");
+  };
+  const sessionValue = () => {
+    return formatElapsed(props.collector.getSessionElapsedMs(props.sessionID, currentScope(), performance.now()));
+  };
+  const headerBox = element("box", {
+    width: "100%",
+    flexDirection: "row",
+    alignItems: "center",
+    ref: attachBoxToggle
+  }, [
+    element("text", {
+      ref: attachCollapsedHeaderNode,
+      fg: props.theme.text,
+      visible: false
+    }, [
+      element("b", {}, ["\u25B6 ", headerLabel()])
+    ]),
+    element("text", {
+      ref: attachExpandedHeaderNode,
+      fg: props.theme.text
+    }, [
+      element("b", {}, ["\u25BC ", headerLabel()])
+    ])
+  ]);
+  const rows = [];
+  rows.push(StatRow({
+    theme: props.theme,
+    label: "Status",
+    value: "No active request",
+    dim: true,
+    icon: "\u25CB",
+    visible: expandedIdle,
+    registerSync: registerRowSync
+  }));
+  if (rowVisible("speed")) {
+    rows.push(StatRow({
+      theme: props.theme,
+      label: "TPS",
+      value: speedValue,
+      accent: true,
+      icon: "\u26A1",
+      registerSync: registerRowSync,
+      visible: expandedActive
+    }));
+  }
+  if (rowVisible("elapsed")) {
+    rows.push(StatRow({
+      theme: props.theme,
+      label: "Elapsed",
+      value: elapsedValue,
+      icon: "\u25B9",
+      registerSync: registerRowSync,
+      visible: expandedActive
+    }));
+  }
+  if (rowVisible("ttft")) {
+    rows.push(StatRow({
+      theme: props.theme,
+      label: "TTFT",
+      value: ttftValue,
+      icon: "\u23F1",
+      registerSync: registerRowSync,
+      visible: expandedActive
+    }));
+  }
+  if (rowVisible("input") || rowVisible("output")) {
+    rows.push(StatRow({
+      theme: props.theme,
+      label: "Tokens",
+      value: tokenValue,
+      registerSync: registerRowSync,
+      visible: expandedActive
+    }));
+  }
+  if (rowVisible("cache")) {
+    rows.push(StatRow({
+      theme: props.theme,
+      label: "Cache",
+      value: cacheValue,
+      dim: true,
+      icon: "\u25CB",
+      registerSync: registerRowSync,
+      visible: expandedActive
+    }));
+  }
+  if (rowVisible("session")) {
+    rows.push(StatRow({
+      theme: props.theme,
+      label: "Session",
+      value: sessionValue,
+      icon: "\u25F7",
+      registerSync: registerRowSync,
+      visible: expandedActive
+    }));
+  }
+  if (rowVisible("modelBreakdown")) {
+    for (let i = 0; i < MAX_MODEL_ROWS; i++) {
+      const modelLabel = () => {
+        const m = currentAggregate()?.modelBreakdown[i];
+        if (!m) return "";
+        const count = m.sessionCount > 1 ? ` \xD7${m.sessionCount}` : "";
+        return `${m.modelID}${count}`;
+      };
+      const modelValue = () => {
+        const m = currentAggregate()?.modelBreakdown[i];
+        if (!m) return "";
+        const parts = [];
+        if (rowVisible("speed")) parts.push(`\u26A1${m.liveTps !== null ? m.liveTps.toFixed(1) : "\u2014"}`);
+        if (rowVisible("ttft")) parts.push(`\u23F1${m.ttft !== null ? " " + formatDuration(m.ttft) : " --"}`);
+        if (rowVisible("input")) parts.push(`\u2193${formatTokens(m.inputTokens)}`);
+        if (rowVisible("output")) parts.push(`\u2191${formatTokens(m.outputTokens)}`);
+        return parts.join(" ");
+      };
+      const visible = () => expandedActive() && (currentAggregate()?.modelBreakdown.length ?? 0) > i;
+      let wrapperNode;
+      const syncWrapper = () => {
+        if (disposed) return;
+        if (!wrapperNode || wrapperNode.isDestroyed) return;
+        const v = visible();
+        try {
+          wrapperNode.height = v ? "auto" : 0;
+          wrapperNode.marginTop = v ? 1 : 0;
+          wrapperNode.marginLeft = v ? 1 : 0;
+        } catch {
         }
-        collector.dispose();
+      };
+      const attachWrapper = (node) => {
+        wrapperNode = node;
+        syncWrapper();
+      };
+      registerRowSync(syncWrapper);
+      rows.push(element("box", {
+        ref: attachWrapper,
+        width: "100%",
+        flexDirection: "column",
+        marginLeft: 1,
+        marginTop: 1
+      }, [
+        StatRow({
+          theme: props.theme,
+          label: modelLabel,
+          value: () => "",
+          dim: true,
+          registerSync: registerRowSync,
+          visible
+        }),
+        StatRow({
+          theme: props.theme,
+          label: () => "",
+          value: modelValue,
+          dim: true,
+          registerSync: registerRowSync,
+          visible
+        })
+      ]));
+    }
+  }
+  if (rowVisible("speed")) {
+    rows.push(StatRow({
+      theme: props.theme,
+      label: "TPS",
+      value: speedValue,
+      accent: true,
+      icon: "\u26A1",
+      registerSync: registerRowSync,
+      visible: collapsedActive
+    }));
+  }
+  if (rowVisible("session")) {
+    rows.push(StatRow({
+      theme: props.theme,
+      label: "Session",
+      value: sessionValue,
+      icon: "\u25F7",
+      registerSync: registerRowSync,
+      visible: collapsedActive
+    }));
+  }
+  const contentBox = element("box", {
+    width: "100%",
+    flexDirection: "column"
+  }, rows);
+  const root = element("box", {
+    width: "100%",
+    flexDirection: "column",
+    height: sectionEnabled() ? "auto" : 0
+  }, [headerBox, contentBox]);
+  return { node: root, dispose };
+}
+
+// src/tui-preferences.ts
+import { createSignal as createSignal2 } from "solid-js";
+
+// src/tui-prefs-io.ts
+import { readFileSync as readFileSync2, watch } from "node:fs";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { basename, dirname, join as join3 } from "node:path";
+import { parse, stringify } from "comment-json";
+var TUI_PREFS_FILE_ENV = "OPENCODE_TUI_PREFERENCES_FILE";
+var FILE_NAME = "tui-preferences.jsonc";
+function getTuiPreferencesFile() {
+  const override = process.env[TUI_PREFS_FILE_ENV];
+  if (override) return override;
+  const configDir = process.env.OPENCODE_CONFIG_DIR || join3(process.env.XDG_CONFIG_HOME || join3(homedir3(), ".config"), "opencode");
+  return join3(configDir, FILE_NAME);
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readTuiPreferencesFile() {
+  try {
+    const raw = await readFile(getTuiPreferencesFile(), "utf8");
+    if (raw.trim() === "") return {};
+    const root = parse(raw);
+    return isRecord5(root) ? root : {};
+  } catch {
+    return {};
+  }
+}
+function readTuiPreferencesFileSync() {
+  try {
+    const raw = readFileSync2(getTuiPreferencesFile(), "utf8");
+    if (raw.trim() === "") return {};
+    const root = parse(raw);
+    return isRecord5(root) ? root : {};
+  } catch {
+    return {};
+  }
+}
+var TEMPLATE = `// Shared preferences for OpenCode TUI plugins.
+// One top-level key per plugin (short name). See each plugin's README for its
+// supported settings. This file is safe to hand-edit; plugins update individual
+// keys and preserve the rest (values and comments).
+{}
+`;
+function setDeep(root, path, value) {
+  let node = root;
+  for (let i = 0; i < path.length - 1; i += 1) {
+    const key = path[i];
+    const child = node[key];
+    if (child === void 0 || child === null) {
+      node[key] = {};
+    } else if (!isRecord5(child)) {
+      return false;
+    }
+    node = node[key];
+  }
+  node[path[path.length - 1]] = value;
+  return true;
+}
+async function writePreference(pluginKey, path, value) {
+  const file = getTuiPreferencesFile();
+  await mkdir(dirname(file), { recursive: true });
+  let text;
+  try {
+    text = await readFile(file, "utf8");
+  } catch {
+    text = "";
+  }
+  if (text.trim() === "") text = TEMPLATE;
+  let root;
+  try {
+    root = parse(text);
+  } catch {
+    return;
+  }
+  if (!isRecord5(root)) root = {};
+  if (!setDeep(root, [pluginKey, ...path], value)) {
+    return;
+  }
+  const next = `${stringify(root, null, 2)}
+`;
+  const tmp = `${file}.${process.pid}.tmp`;
+  await writeFile(tmp, next, "utf8");
+  await rename(tmp, file);
+}
+var writeChain = Promise.resolve();
+function queueTuiPreferenceUpdate(pluginKey, path, value) {
+  writeChain = writeChain.then(() => writePreference(pluginKey, path, value)).catch(() => {
+  });
+  return writeChain;
+}
+var WATCH_DEBOUNCE_MS = 150;
+function watchTuiPreferences(onChange) {
+  const file = getTuiPreferencesFile();
+  const name = basename(file);
+  let timer = null;
+  let lastSeen = null;
+  void readFile(file, "utf8").then((text) => {
+    if (lastSeen === null) lastSeen = text;
+  }).catch(() => {
+  });
+  try {
+    const watcher = watch(dirname(file), (_event, filename) => {
+      const isOurs = filename === name || filename?.startsWith(`${name}.`) && filename.endsWith(".tmp");
+      if (filename != null && !isOurs) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        timer = null;
+        void readFile(file, "utf8").catch(() => null).then((text) => {
+          if (text === null) return;
+          if (text === lastSeen) return;
+          lastSeen = text;
+          onChange();
+        });
+      }, WATCH_DEBOUNCE_MS);
     });
-    log("opencode-metrics sidebar initialized");
+    return () => {
+      if (timer) clearTimeout(timer);
+      watcher.close();
+    };
+  } catch {
+    return () => {
+    };
+  }
+}
+
+// src/tui-preferences.ts
+var PLUGIN_KEY = "oc-metricboard";
+var DEFAULT_SLOT_ORDER = 160;
+var DEFAULT_PREFS = {
+  forceToTop: false,
+  order: DEFAULT_SLOT_ORDER,
+  scope: "current",
+  section: {
+    enabled: true,
+    collapsed: null,
+    rememberCollapsed: true,
+    label: "MetricBoard"
+  },
+  rows: {
+    speed: true,
+    ttft: true,
+    input: true,
+    output: true,
+    cache: true,
+    elapsed: true,
+    session: true,
+    model: true,
+    modelBreakdown: true
+  }
+};
+function bool(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function int(value, fallback, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.min(Math.max(Math.round(value), min), max);
+}
+function label(value, fallback, maxLength) {
+  if (typeof value !== "string" || value.length === 0) return fallback;
+  return value.slice(0, maxLength);
+}
+function metricsScope(value, fallback) {
+  return value === "current" || value === "tree" ? value : fallback;
+}
+function resolveMetricsPrefs(root) {
+  const entry = root[PLUGIN_KEY];
+  if (!isRecord5(entry)) return structuredClone(DEFAULT_PREFS);
+  const d = DEFAULT_PREFS;
+  const section = isRecord5(entry.section) ? entry.section : {};
+  const rows = isRecord5(entry.rows) ? entry.rows : {};
+  return {
+    forceToTop: bool(entry.forceToTop, d.forceToTop),
+    order: int(entry.order, d.order, -1e4, 1e4),
+    scope: metricsScope(entry.scope, d.scope),
+    section: {
+      enabled: bool(section.enabled, d.section.enabled),
+      collapsed: typeof section.collapsed === "boolean" ? section.collapsed : null,
+      rememberCollapsed: bool(section.rememberCollapsed, d.section.rememberCollapsed),
+      label: label(section.label, d.section.label, 24)
+    },
+    rows: {
+      speed: bool(rows.speed, d.rows.speed),
+      ttft: bool(rows.ttft, d.rows.ttft),
+      input: bool(rows.input, d.rows.input),
+      output: bool(rows.output, d.rows.output),
+      cache: bool(rows.cache, d.rows.cache),
+      elapsed: bool(rows.elapsed, d.rows.elapsed),
+      session: bool(rows.session, d.rows.session),
+      model: bool(rows.model, d.rows.model),
+      modelBreakdown: bool(rows.modelBreakdown, d.rows.modelBreakdown)
+    }
+  };
+}
+var FORCE_TOP_BASE = -1e5;
+function computeEffectiveOrder(root, pluginKey, defaultOrder) {
+  const entry = root[pluginKey];
+  if (!isRecord5(entry)) return defaultOrder;
+  if (entry.forceToTop === true) {
+    return FORCE_TOP_BASE + Object.keys(root).indexOf(pluginKey);
+  }
+  return int(entry.order, defaultOrder, -1e4, 1e4);
+}
+function createMetricsSidebarController(initialPrefs, requestRender) {
+  const [prefs, setPrefs] = createSignal2(initialPrefs);
+  const seedCollapsed = initialPrefs.section.rememberCollapsed && initialPrefs.section.collapsed != null ? initialPrefs.section.collapsed : false;
+  const [collapsed, setCollapsed] = createSignal2(seedCollapsed);
+  let lastPersistedCollapsed = initialPrefs.section.collapsed;
+  let lastApplied = JSON.stringify(initialPrefs);
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    requestRender?.();
+    for (const cb of listeners) cb();
+  };
+  const disposeWatcher = watchTuiPreferences(() => {
+    void (async () => {
+      const next = resolveMetricsPrefs(await readTuiPreferencesFile());
+      const serialized = JSON.stringify(next);
+      if (serialized === lastApplied) return;
+      lastApplied = serialized;
+      setPrefs(next);
+      if (next.section.rememberCollapsed && next.section.collapsed != null && next.section.collapsed !== lastPersistedCollapsed) {
+        lastPersistedCollapsed = next.section.collapsed;
+        setCollapsed(next.section.collapsed);
+      }
+      notify();
+    })();
+  });
+  void disposeWatcher;
+  function toggleCollapsed() {
+    const next = !collapsed();
+    setCollapsed(next);
+    notify();
+    if (prefs().section.rememberCollapsed) {
+      void queueTuiPreferenceUpdate(PLUGIN_KEY, ["section", "collapsed"], next).then(() => {
+        lastPersistedCollapsed = next;
+      });
+    }
+  }
+  function subscribe(cb) {
+    listeners.add(cb);
+    return () => listeners.delete(cb);
+  }
+  return { prefs, collapsed, toggleCollapsed, subscribe };
+}
+
+// src/tui-v2.tsx
+import { createElement as createElement2 } from "@opentui/solid";
+var V2_EVENT_MAP = {
+  "message.part.delta": null,
+  "message.part.updated": null,
+  "message.updated": null,
+  "session.created": "session.created",
+  "session.updated": "session.updated",
+  "session.deleted": "session.deleted",
+  "session.status": null,
+  "session.idle": "session.idle",
+  "session.next.text.delta": "session.text.delta",
+  "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 isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+function translateExecutionStartedToBusy(event) {
+  const data = isRecord6(event.data) ? event.data : {};
+  const sessionID = str(data.sessionID);
+  if (!sessionID) return null;
+  const created = typeof event.created === "number" ? event.created : void 0;
+  return {
+    type: "session.status",
+    ...created !== void 0 ? { created } : {},
+    properties: { sessionID, status: { type: "busy" } }
+  };
+}
+function translateExecutionSettledToIdle(event) {
+  const data = isRecord6(event.data) ? event.data : {};
+  const sessionID = str(data.sessionID);
+  if (!sessionID) return null;
+  const created = typeof event.created === "number" ? event.created : void 0;
+  return {
+    type: "session.idle",
+    ...created !== void 0 ? { created } : {},
+    properties: { sessionID }
+  };
+}
+function eventSessionID(event) {
+  if (!isRecord6(event)) return "";
+  return str(isRecord6(event.data) ? event.data.sessionID : void 0);
+}
+function createV1EventShim(ctx, holder) {
+  let lastFamilySyncAt = -Infinity;
+  const syncFamily = (sessionID) => {
+    const data = ctx.data;
+    try {
+      if (!holder.collector || !data?.session || !sessionID) return;
+      const now = Date.now();
+      if (now - lastFamilySyncAt < 2e3) return;
+      lastFamilySyncAt = now;
+      const rootID = data.session.root(sessionID);
+      const ids = data.session.family(rootID) ?? [];
+      for (const id of ids) {
+        if (id !== rootID) holder.collector.setSessionParent(id, rootID);
+      }
+    } catch {
+    }
+  };
+  const subscribeV2 = (v2Type, subscribee) => {
+    try {
+      const unsub = ctx.data.on(v2Type, (event) => {
+        try {
+          subscribee(event);
+        } catch (error) {
+          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) {
+        if (/\.1$|\.2$/.test(type)) return () => {
+        };
+        if (type === "session.status") {
+          return subscribeV2("session.execution.started", (event) => {
+            const translated = translateExecutionStartedToBusy(event);
+            if (translated !== null) handler(translated);
+          });
+        }
+        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();
+              } catch {
+              }
+            }
+          };
+        }
+        const v2Type = V2_EVENT_MAP[type];
+        if (!v2Type) return () => {
+        };
+        return subscribeV2(v2Type, (event) => {
+          syncFamily(eventSessionID(event));
+          handler(event);
+        });
+      }
+    }
+  };
+}
+function pickThemeToken(theme, paths) {
+  for (const path of paths) {
+    let value = theme;
+    for (const key of path) {
+      if (!isRecord6(value)) {
+        value = void 0;
+        break;
+      }
+      value = value[key];
+    }
+    if (value !== void 0 && value !== null) return value;
+  }
+  return void 0;
+}
+function v1ThemeFromV2(theme) {
+  return {
+    text: pickThemeToken(theme, [["text", "default"]]),
+    textMuted: pickThemeToken(theme, [["text", "subdued"]]),
+    accent: pickThemeToken(theme, [["text", "feedback", "info", "default"], ["text", "default"]]),
+    warning: pickThemeToken(theme, [["text", "feedback", "warning", "default"]]),
+    success: pickThemeToken(theme, [["text", "feedback", "success", "default"]])
+  };
+}
+function setupTuiV2(ctx) {
+  if (!ctx || !ctx.ui || typeof ctx.ui.slot !== "function") {
+    log("opencode-metrics v2 entry: no ui.slot in this context, skipping");
+    return () => {
+    };
+  }
+  const config = getConfig();
+  log("opencode-metrics v2 entry initialized");
+  const seedRoot = readTuiPreferencesFileSync();
+  const effectiveOrder = computeEffectiveOrder(seedRoot, PLUGIN_KEY, DEFAULT_SLOT_ORDER);
+  const prefs = resolveMetricsPrefs(seedRoot);
+  const requestRender = () => {
+    try {
+      ctx.renderer?.requestRender?.();
+    } catch {
+    }
+  };
+  const controller = createMetricsSidebarController(prefs, requestRender);
+  const holder = { collector: null };
+  const collector = createCollector(createV1EventShim(ctx, holder), config, log);
+  holder.collector = collector;
+  const theme = v1ThemeFromV2(ctx.theme);
+  const disposers = [];
+  disposers.push(
+    ctx.ui.slot({
+      append: "sidebar.content",
+      render: (input) => {
+        const sessionID = input?.sessionID ?? "";
+        if (!sessionID) return createElement2("box");
+        const sidebar = SidebarMetrics({
+          sessionID,
+          collector,
+          refreshIntervalMs: config.refreshIntervalMs,
+          barConfig: config,
+          theme,
+          controller,
+          requestRender
+        });
+        disposers.push(sidebar.dispose);
+        return sidebar.node;
+      }
+    })
+  );
+  return () => {
+    for (const dispose of disposers) {
+      try {
+        dispose();
+      } catch {
+      }
+    }
+    disposers.length = 0;
+    collector.dispose();
+  };
+}
+
+// src/tui.tsx
+var plugin = async (api, _options, _meta) => {
+  const config = getConfig();
+  const collector = createCollector(api, config, log);
+  const seedRoot = readTuiPreferencesFileSync();
+  const effectiveOrder = computeEffectiveOrder(seedRoot, PLUGIN_KEY, DEFAULT_SLOT_ORDER);
+  const prefs = resolveMetricsPrefs(seedRoot);
+  const controller = createMetricsSidebarController(prefs, () => api.renderer.requestRender());
+  const sidebarDisposers = [];
+  api.slots.register({
+    order: effectiveOrder,
+    slots: {
+      sidebar_content(ctx, props) {
+        const sidebar = SidebarMetrics({
+          sessionID: props.session_id,
+          collector,
+          refreshIntervalMs: config.refreshIntervalMs,
+          barConfig: config,
+          theme: ctx.theme.current,
+          controller,
+          requestRender: () => api.renderer.requestRender()
+        });
+        sidebarDisposers.push(sidebar.dispose);
+        return sidebar.node;
+      }
+    }
+  });
+  api.lifecycle.onDispose(() => {
+    for (const dispose of sidebarDisposers.splice(0)) {
+      try {
+        dispose();
+      } catch {
+      }
+    }
+    collector.dispose();
+  });
+  log("opencode-metrics sidebar initialized");
+};
+var pluginModule = {
+  id: "oc-metricboard",
+  tui: plugin,
+  setup: setupTuiV2
 };
-/**
- * Dual-host TUI module:
- * - OpenCode V1 (1.18.x) validates `{ id, tui }` and ignores extra keys.
- * - OpenCode V2 (2.0.x) validates `{ id, setup }` and rejects V1-only modules.
- * Exporting both keys from one `./tui` module satisfies both hosts.
- */
-const pluginModule = {
-    id: "oc-metricboard",
-    tui: plugin,
-    setup: setupTuiV2,
+var tui_default = pluginModule;
+export {
+  tui_default as default
 };
-export default pluginModule;