opencode-cache-hit 0.1.0 → 0.2.1

package/src/main-session-view.tsx

@@ -1,7 +1,10 @@
 /** @jsxImportSource @opentui/solid */
 import { Show } from "solid-js"
 import { TokenDetailRows } from "./cache-hit-rows.tsx"
+import { CacheTTLView } from "./cache-ttl-view.tsx"
 import type { CacheHitMetrics } from "./use-cache-hit-metrics.ts"
+import type { CacheTTLConfig } from "./plugin-config.ts"
+import type { AssistantMessage } from "./types.ts"
 import {
   TuiHitRow,
   TuiMetricRow,
@@ -9,6 +12,7 @@ import {
   type PanelLayout,
   type SectionFold,
 } from "./tui-panel/index.ts"
+import type { Accessor } from "solid-js"
 
 export function MainSessionView(props: {
   m: CacheHitMetrics
@@ -16,6 +20,9 @@ export function MainSessionView(props: {
   detail: SectionFold
   model: SectionFold
   formatCost: (n: number) => string
+  formatRate: (perMillion: number) => string
+  cacheTTL?: CacheTTLConfig
+  messages?: Accessor<AssistantMessage[]>
 }) {
   const { m, layout } = props
   return (
@@ -31,6 +38,15 @@ export function MainSessionView(props: {
         }
       />
       <TuiMetricRow pal={m.pal()} layout={layout} label={m.t().totalHit} value={m.sessionPct()} />
+      <Show when={props.cacheTTL?.enabled && props.messages}>
+        <CacheTTLView
+          messages={props.messages!}
+          config={props.cacheTTL!}
+          pal={m.pal()}
+          layout={layout}
+          label={m.t().secTTL}
+        />
+      </Show>
 
       <TuiSection
         pal={m.pal()}
@@ -40,12 +56,13 @@ export function MainSessionView(props: {
         onToggle={props.detail.toggle}
       >
         <TokenDetailRows pal={m.pal()} layout={layout} t={m.t()} snap={m.main()}>
-          <Show when={m.showCombinedHit()}>
+          <Show when={m.pricing().saved > 0}>
             <TuiMetricRow
               pal={m.pal()}
               layout={layout}
-              label={m.t().withAgents}
-              value={m.combinedPct()}
+              label={m.t().saved}
+              value={props.formatCost(m.pricing().saved)}
+              fg={m.pal().success}
             />
           </Show>
         </TokenDetailRows>
@@ -70,6 +87,29 @@ export function MainSessionView(props: {
         <Show when={m.modelShort()}>
           <TuiMetricRow pal={m.pal()} layout={layout} label={m.t().model} value={m.modelShort()} />
         </Show>
+        <Show when={m.pricing().inputRate > 0}>
+          <TuiMetricRow
+            pal={m.pal()}
+            layout={layout}
+            label={m.t().rate}
+            value={`${props.formatRate(m.pricing().inputRate)}${m.t().rateIn}`}
+            fg={m.pal().muted}
+          />
+          <TuiMetricRow
+            pal={m.pal()}
+            layout={layout}
+            label=""
+            value={`${props.formatRate(m.pricing().cacheReadRate)}${m.t().rateCache}`}
+            fg={m.pal().muted}
+          />
+          <TuiMetricRow
+            pal={m.pal()}
+            layout={layout}
+            label=""
+            value={`${props.formatRate(m.pricing().outputRate)}${m.t().rateOut}`}
+            fg={m.pal().muted}
+          />
+        </Show>
       </TuiSection>
     </>
   )

package/src/plugin-config.ts

@@ -19,7 +19,7 @@ export const DEFAULT_DISPLAY: DisplayConfig = {
 
 export type TimelineConfig = {
   enabled: boolean
-  /** Empty → plugin `logs/` directory */
+  /** Empty → `~/.local/share/opencode/logs/cache-hit`. Supports `~/…` expansion. */
   dir: string
   flushIncomplete: boolean
   logSummaryMessages: boolean
@@ -49,16 +49,29 @@ export const DEFAULT_TIMELINE: TimelineConfig = {
   maxLogFiles: 0,
 }
 
+export type CacheTTLConfig = {
+  enabled: boolean
+  /** TTL per provider (or provider:model). Values like "5m", "1h", "30s". Falls back to built-in defaults. */
+  providers: Record<string, string>
+}
+
+export const DEFAULT_CACHE_TTL: CacheTTLConfig = {
+  enabled: true,
+  providers: {},
+}
+
 export type PluginConfig = {
   cost: CostDisplayConfig
   display: DisplayConfig
   timeline: TimelineConfig
+  cacheTTL: CacheTTLConfig
 }
 
 export const DEFAULT_PLUGIN_CONFIG: PluginConfig = {
   cost: { ...DEFAULT_COST_DISPLAY },
   display: { ...DEFAULT_DISPLAY },
   timeline: { ...DEFAULT_TIMELINE },
+  cacheTTL: { ...DEFAULT_CACHE_TTL },
 }
 
 export function normalizeTimelineConfig(raw: unknown): TimelineConfig {
@@ -103,6 +116,50 @@ export function normalizeDisplayConfig(raw: unknown): DisplayConfig {
   return d
 }
 
+export function normalizeCacheTTLConfig(raw: unknown): CacheTTLConfig {
+  const t: CacheTTLConfig = { enabled: DEFAULT_CACHE_TTL.enabled, providers: {} }
+  if (!raw || typeof raw !== "object") return t
+  const o = raw as Record<string, unknown>
+  if (typeof o.enabled === "boolean") t.enabled = o.enabled
+  if (o.providers && typeof o.providers === "object") {
+    const providers = o.providers as Record<string, unknown>
+    for (const [key, value] of Object.entries(providers)) {
+      if (typeof value === "string") {
+        t.providers[key] = value
+      }
+    }
+  }
+  return t
+}
+
+const TIME_UNITS: Record<string, number> = {
+  s: 1000,
+  sec: 1000,
+  second: 1000,
+  seconds: 1000,
+  m: 60_000,
+  min: 60_000,
+  minute: 60_000,
+  minutes: 60_000,
+  h: 3_600_000,
+  hr: 3_600_000,
+  hour: 3_600_000,
+  hours: 3_600_000,
+}
+
+export function parseDuration(raw: string): number | null {
+  const match = raw.trim().match(/^(\d+(?:\.\d+)?)\s*([a-z]+)$/i)
+  if (!match) {
+    const num = Number(raw)
+    return Number.isFinite(num) && num > 0 ? Math.floor(num) : null
+  }
+  const value = Number(match[1])
+  const unit = match[2].toLowerCase()
+  const multiplier = TIME_UNITS[unit]
+  if (!multiplier || !Number.isFinite(value) || value <= 0) return null
+  return Math.floor(value * multiplier)
+}
+
 export function normalizePluginConfig(raw: unknown): PluginConfig {
   if (!raw || typeof raw !== "object") return { ...DEFAULT_PLUGIN_CONFIG }
   const o = raw as Record<string, unknown>
@@ -112,5 +169,6 @@ export function normalizePluginConfig(raw: unknown): PluginConfig {
     cost,
     display: normalizeDisplayConfig(displayRaw),
     timeline: normalizeTimelineConfig(o.timeline),
+    cacheTTL: normalizeCacheTTLConfig(o.cacheTTL),
   }
 }

package/src/plugin.tsx

@@ -1,7 +1,7 @@
 /** @jsxImportSource @opentui/solid */
 import { CacheHitSidebarHost } from "./sidebar-host.tsx"
 import { loadPluginConfig } from "./load-config.ts"
-import { createCostFormatter } from "./format-cost.ts"
+import { createCostFormatter, createRateFormatter } from "./format-cost.ts"
 import type { OpenCodeTuiApi } from "./types.ts"
 
 export const PLUGIN_ID = "opencode-cache-hit"
@@ -9,6 +9,7 @@ export const PLUGIN_ID = "opencode-cache-hit"
 export const tui = async (api: OpenCodeTuiApi) => {
   const pluginConfig = loadPluginConfig()
   const formatCost = createCostFormatter(pluginConfig.cost)
+  const formatRate = createRateFormatter(pluginConfig.cost)
 
   api.slots.register({
     order: 56,
@@ -20,7 +21,9 @@ export const tui = async (api: OpenCodeTuiApi) => {
             theme={ctx.theme.current}
             display={pluginConfig.display}
             timeline={pluginConfig.timeline}
+            cacheTTL={pluginConfig.cacheTTL}
             formatCost={formatCost}
+            formatRate={formatRate}
             api={api}
           />
         )

package/src/pricing.ts

@@ -0,0 +1,57 @@
+import type { ModelCost, ProviderInfo, SubAgentSummary } from "./types.ts"
+
+export type PricingInfo = {
+  inputRate: number
+  outputRate: number
+  cacheReadRate: number
+  cacheWriteRate: number
+  saved: number
+}
+
+export const EMPTY_PRICING: PricingInfo = {
+  inputRate: 0,
+  outputRate: 0,
+  cacheReadRate: 0,
+  cacheWriteRate: 0,
+  saved: 0,
+}
+
+export function lookupModelCost(
+  providers: ReadonlyArray<ProviderInfo>,
+  providerID: string | undefined,
+  modelID: string | undefined,
+): ModelCost | null {
+  if (!providerID || !modelID) return null
+  for (const p of providers) {
+    if (p.id !== providerID) continue
+    const model = p.models[modelID]
+    return model?.cost ?? null
+  }
+  return null
+}
+
+export function computePricing(
+  providers: ReadonlyArray<ProviderInfo>,
+  providerID: string | undefined,
+  modelID: string | undefined,
+  cacheRead: number,
+): PricingInfo {
+  const cost = lookupModelCost(providers, providerID, modelID)
+  if (!cost) return EMPTY_PRICING
+  const inputRate = cost.input
+  const outputRate = cost.output
+  const cacheReadRate = cost.cache.read
+  const cacheWriteRate = cost.cache.write
+  const saved =
+    inputRate > cacheReadRate ? (cacheRead * (inputRate - cacheReadRate)) / 1_000_000 : 0
+  return { inputRate, outputRate, cacheReadRate, cacheWriteRate, saved }
+}
+
+export function computeSubsSaved(subs: readonly SubAgentSummary[], providers: ReadonlyArray<ProviderInfo>): number {
+  let total = 0
+  for (const sub of subs) {
+    const p = computePricing(providers, sub.providerID, sub.model, sub.cacheRead)
+    total += p.saved
+  }
+  return total
+}

package/src/sidebar-host.tsx

@@ -1,7 +1,7 @@
 /** @jsxImportSource @opentui/solid */
 import { createSignal, createMemo, createEffect, onCleanup } from "solid-js"
 import { CacheHitSidebar } from "./widget.tsx"
-import type { DisplayConfig, TimelineConfig } from "./plugin-config.ts"
+import type { DisplayConfig, TimelineConfig, CacheTTLConfig } from "./plugin-config.ts"
 import { createTimelineCollector } from "./timeline/collector.ts"
 import type { AssistantMessage, OpenCodeTuiApi, SubAgentSummary } from "./types.ts"
 import {
@@ -16,13 +16,16 @@ import { loadPluginConfig } from "./load-config.ts"
 /**
  * Session-scoped sidebar host. Bumps `refreshTick` on message.updated (same as visual-cache)
  * so memos re-read api.state.session.messages.
+ * Timeline writes are event-driven: message.updated → handleMessage → appendFile.
  */
 export function CacheHitSidebarHost(props: {
   sessionId: string
   theme: Record<string, unknown>
   display: DisplayConfig
   timeline: TimelineConfig
+  cacheTTL: CacheTTLConfig
   formatCost: (amount: number) => string
+  formatRate: (perMillion: number) => string
   api: OpenCodeTuiApi
 }) {
   const [refreshTick, setRefreshTick] = createSignal(0)
@@ -34,6 +37,7 @@ export function CacheHitSidebarHost(props: {
     return loadPluginConfig()
   })
   const display = createMemo(() => runtimeConfig().display)
+  const cacheTTL = createMemo(() => runtimeConfig().cacheTTL)
 
   const bumpRefresh = () => setRefreshTick((v) => v + 1)
 
@@ -41,8 +45,6 @@ export function CacheHitSidebarHost(props: {
     config: props.timeline,
     getRootSessionId: () => props.sessionId,
     getChildIds: childIds,
-    getMessages: (id) =>
-      (props.api.state.session.messages(id) ?? []) as AssistantMessage[],
   })
   onCleanup(() => timeline.dispose())
 
@@ -53,7 +55,6 @@ export function CacheHitSidebarHost(props: {
     setChildIds,
     onSynced: () => {
       bumpRefresh()
-      timeline.schedule()
     },
   })
   onCleanup(() => childSync.dispose())
@@ -94,15 +95,17 @@ export function CacheHitSidebarHost(props: {
     timeline.resetForRootChange()
     if (sid) {
       childSync.loadChildren()
-      timeline.schedule()
     }
   })
 
   createEffect(() => {
     const unsub = props.api.event.on("message.updated", (event) => {
       bumpRefresh()
-      childSync.onForeignSessionActivity(event.properties?.info?.sessionID)
-      timeline.schedule()
+      const sid = event.properties?.info?.sessionID
+      childSync.onForeignSessionActivity(sid)
+      if (sid && event.properties?.info) {
+        timeline.handleMessage(sid, event.properties.info as AssistantMessage)
+      }
     })
     onCleanup(() => unsub?.())
   })
@@ -112,10 +115,13 @@ export function CacheHitSidebarHost(props: {
       sessionId={() => props.sessionId}
       theme={props.theme}
       display={display()}
+      cacheTTL={cacheTTL()}
       messages={mainMessages}
       main={mainSnap}
       subAgents={subAgentList}
+      providers={() => props.api.state.provider ?? []}
       formatCost={props.formatCost}
+      formatRate={props.formatRate}
     />
   )
 }

package/src/stats.ts

@@ -11,11 +11,12 @@ export function mainSessionHasStats(main: SessionSnapshot): boolean {
 }
 
 export function emptySessionSnapshot(): SessionSnapshot {
-  return { model: "", input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0, cost: 0 }
+  return { model: "", providerID: "", input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0, cost: 0 }
 }
 
 export function aggregateSessionFromMessages(messages: readonly AssistantMessage[]): SessionSnapshot {
   let model = "",
+    providerID = "",
     input = 0,
     output = 0,
     reasoning = 0,
@@ -32,13 +33,16 @@ export function aggregateSessionFromMessages(messages: readonly AssistantMessage
     cacheWrite += t.cache?.write ?? 0
     cost += msg.cost ?? 0
     if (msg.modelID) model = msg.modelID
+    if (msg.providerID) providerID = msg.providerID
   }
-  return { model, input, output, reasoning, cacheRead, cacheWrite, cost }
+  return { model, providerID, input, output, reasoning, cacheRead, cacheWrite, cost }
 }
 
 export function toSubAgentSummary(id: string, snap: SessionSnapshot): SubAgentSummary {
   return {
     id,
+    model: snap.model,
+    providerID: snap.providerID,
     cost: snap.cost,
     input: snap.input,
     output: snap.output,
@@ -66,19 +70,6 @@ export function cacheHitRatio(cacheRead: number, input: number): number {
   return denom > 0 ? cacheRead / denom : 0
 }
 
-export function combinedCacheHitRatio(
-  main: SessionSnapshot,
-  subs: readonly Pick<SubAgentSummary, "cacheRead" | "input">[],
-): number {
-  let cacheRead = main.cacheRead
-  let input = main.input
-  for (const s of subs) {
-    cacheRead += s.cacheRead
-    input += s.input
-  }
-  return cacheHitRatio(cacheRead, input)
-}
-
 export function subAgentHasStats(snap: SessionSnapshot): boolean {
   return (
     snap.cost > 0 ||

package/src/timeline/collector.ts

@@ -1,6 +1,6 @@
 import type { TimelineConfig } from "../plugin-config.ts"
 import type { AssistantMessage } from "../types.ts"
-import { buildCallRecords, mergeAndSortRecords } from "./records.ts"
+import { assistantMessageToRecord } from "./records.ts"
 import {
   appendTimelineRecord,
   localDateKey,
@@ -10,10 +10,9 @@ import {
 } from "./writer.ts"
 import type { LlmCallRecord } from "./types.ts"
 
-export const TIMELINE_DEBOUNCE_MS = 500
-
 export type TimelineCollector = {
-  schedule: () => void
+  /** Process a single message from a message.updated event. */
+  handleMessage: (sessionID: string, msg: AssistantMessage) => void
   resetForRootChange: () => void
   dispose: () => void
   memoryRecords: () => readonly LlmCallRecord[]
@@ -23,13 +22,12 @@ export function createTimelineCollector(opts: {
   config: TimelineConfig
   getRootSessionId: () => string
   getChildIds: () => readonly string[]
-  getMessages: (sessionId: string) => readonly AssistantMessage[]
   /** Test hook: replace disk append */
   append?: (logPath: string, record: LlmCallRecord) => Promise<void>
 }): TimelineCollector {
   if (!opts.config.enabled) {
     return {
-      schedule: () => {},
+      handleMessage: () => {},
       resetForRootChange: () => {},
       dispose: () => {},
       memoryRecords: () => [],
@@ -51,106 +49,61 @@ export function createTimelineCollector(opts: {
       maxLogFiles: opts.config.maxLogFiles,
     })
   }
-  const flushedKeys = new Set<string>()
+
   let activeDateKey = localDateKey()
-  let debounceTimer: ReturnType<typeof setTimeout> | undefined
   let memory: LlmCallRecord[] = []
-  let collectGen = 0
+  let disposed = false
 
   const ensureDateKey = () => {
     const today = localDateKey()
     if (today !== activeDateKey) {
-      flushedKeys.clear()
       activeDateKey = today
     }
     return today
   }
 
-  const clearDebounce = () => {
-    if (debounceTimer !== undefined) clearTimeout(debounceTimer)
-    debounceTimer = undefined
-  }
-
-  const shouldFlushToDisk = (rec: LlmCallRecord): boolean => {
-    if (flushedKeys.has(rec.messageKey)) return false
-    if (rec.isComplete) return true
-    return opts.config.flushIncomplete
-  }
-
-  const flushRecords = async (records: LlmCallRecord[], rootId: string, gen: number) => {
-    const logPath = timelineDailyLogPath(logsDir, ensureDateKey())
-    for (const rec of records) {
-      if (gen !== collectGen || opts.getRootSessionId() !== rootId) return
-      if (!shouldFlushToDisk(rec)) continue
-      flushedKeys.add(rec.messageKey)
-      try {
-        await append(logPath, rec)
-      } catch {
-        flushedKeys.delete(rec.messageKey)
-      }
-    }
-  }
-
-  const collectNow = () => {
-    clearDebounce()
+  const handleMessage = (sessionID: string, msg: AssistantMessage) => {
+    if (disposed) return
     const rootId = opts.getRootSessionId()
-    if (!rootId) {
-      memory = []
+    if (!rootId) return
+
+    let scope: "main" | "child"
+    if (sessionID === rootId) {
+      scope = "main"
+    } else if (opts.getChildIds().includes(sessionID)) {
+      scope = "child"
+    } else {
       return
     }
-    const gen = collectGen
-    const chunks: LlmCallRecord[][] = []
-    const mainMsgs = opts.getMessages(rootId)
-    if (mainMsgs.length) {
-      chunks.push(
-        buildCallRecords(rootId, rootId, "main", mainMsgs, {
-          logSummaryMessages: opts.config.logSummaryMessages,
-        }),
-      )
-    }
-    for (const cid of opts.getChildIds()) {
-      const msgs = opts.getMessages(cid)
-      if (msgs.length) {
-        chunks.push(
-          buildCallRecords(cid, rootId, "child", msgs, {
-            logSummaryMessages: opts.config.logSummaryMessages,
-          }),
-        )
-      }
-    }
-    if (gen !== collectGen || opts.getRootSessionId() !== rootId) return
-    memory = mergeAndSortRecords(chunks)
-    const toFlush = memory.filter(shouldFlushToDisk)
-    if (toFlush.length > 0) {
-      queueMicrotask(() => flushRecords(toFlush, rootId, gen))
-    }
-  }
 
-  const schedule = () => {
-    clearDebounce()
-    if (!opts.getRootSessionId()) return
-    debounceTimer = setTimeout(() => {
-      debounceTimer = undefined
-      collectNow()
-    }, TIMELINE_DEBOUNCE_MS)
-  }
+    if (msg.role !== "assistant") return
+    if (!opts.config.logSummaryMessages && msg.summary === true) return
 
-  const resetForRootChange = () => {
-    collectGen++
-    clearDebounce()
-    memory = []
-  }
+    const rec = assistantMessageToRecord(msg, sessionID, rootId, scope, Date.now())
+    if (!rec) return
+    if (!opts.config.flushIncomplete && !rec.isComplete) return
 
-  const dispose = () => {
-    collectGen++
-    clearDebounce()
-  }
+    const logPath = timelineDailyLogPath(logsDir, ensureDateKey())
+    void append(logPath, rec).catch(() => {})
 
-  const memoryRecords = () => {
+    memory.push(rec)
     const max = opts.config.maxMemoryRows
-    if (memory.length <= max) return memory
-    return memory.slice(-max)
+    while (memory.length > max) memory.shift()
   }
 
-  return { schedule, resetForRootChange, dispose, memoryRecords }
+  return {
+    handleMessage,
+    resetForRootChange: () => {
+      memory = []
+    },
+    dispose: () => {
+      disposed = true
+      memory = []
+    },
+    memoryRecords: () => {
+      const max = opts.config.maxMemoryRows
+      if (memory.length <= max) return memory
+      return memory.slice(-max)
+    },
+  }
 }

package/src/timeline/records.ts

@@ -3,6 +3,21 @@ import { perMessageHitPercent } from "../stats.ts"
 import type { AssistantMessage } from "../types.ts"
 import type { LlmCallRecord } from "./types.ts"
 
+/** Convert milliseconds timestamp to ISO 8601 with local timezone offset. */
+export function msToISOString(ms: number): string {
+  const d = new Date(ms)
+  const off = -d.getTimezoneOffset()
+  const sign = off >= 0 ? "+" : "-"
+  const hh = String(Math.floor(Math.abs(off) / 60)).padStart(2, "0")
+  const mm = String(Math.abs(off) % 60).padStart(2, "0")
+  const pad = (n: number, len = 2) => String(n).padStart(len, "0")
+  return (
+    `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` +
+    `T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}` +
+    `.${pad(d.getMilliseconds(), 3)}${sign}${hh}:${mm}`
+  )
+}
+
 export function messageKeyFor(msg: AssistantMessage, sessionId: string): string {
   const id = msg.id ?? msg.messageID
   if (typeof id === "string" && id.length > 0) return `${sessionId}:${id}`
@@ -10,10 +25,6 @@ export function messageKeyFor(msg: AssistantMessage, sessionId: string): string
   return `${sessionId}:${created}:${msg.modelID ?? ""}`
 }
 
-export function sortKeyForRecord(r: LlmCallRecord): number {
-  return r.completedAt ?? r.created
-}
-
 export function assistantMessageToRecord(
   msg: AssistantMessage,
   sessionId: string,
@@ -28,14 +39,14 @@ export function assistantMessageToRecord(
   const skippedForHit = msg.summary === true
   return {
     schema: 1,
-    recordedAt,
+    recordedAt: msToISOString(recordedAt),
     sessionId,
     rootSessionId,
     scope,
     messageKey: messageKeyFor(msg, sessionId),
     modelId: msg.modelID ?? "",
-    created: timing.created,
-    completedAt: timing.completedAt,
+    created: msToISOString(timing.created),
+    completedAt: timing.completedAt !== undefined ? msToISOString(timing.completedAt) : undefined,
     durationMs: timing.durationMs,
     isComplete: timing.isComplete,
     input: t.input ?? 0,
@@ -49,25 +60,3 @@ export function assistantMessageToRecord(
   }
 }
 
-export function buildCallRecords(
-  sessionId: string,
-  rootSessionId: string,
-  scope: "main" | "child",
-  messages: readonly AssistantMessage[],
-  opts?: { logSummaryMessages?: boolean; recordedAt?: number },
-): LlmCallRecord[] {
-  const now = opts?.recordedAt ?? Date.now()
-  const logSummary = opts?.logSummaryMessages !== false
-  const out: LlmCallRecord[] = []
-  for (const msg of messages) {
-    if (!logSummary && msg.summary === true) continue
-    const rec = assistantMessageToRecord(msg, sessionId, rootSessionId, scope, now)
-    if (rec) out.push(rec)
-  }
-  return out
-}
-
-export function mergeAndSortRecords(chunks: readonly LlmCallRecord[][]): LlmCallRecord[] {
-  const all = chunks.flat()
-  return all.sort((a, b) => sortKeyForRecord(a) - sortKeyForRecord(b))
-}

package/src/timeline/types.ts

@@ -1,14 +1,14 @@
 /** Single LLM call row (one JSONL line). */
 export type LlmCallRecord = {
   schema: 1
-  recordedAt: number
+  recordedAt: string
   sessionId: string
   rootSessionId: string
   scope: "main" | "child"
   messageKey: string
   modelId: string
-  created: number
-  completedAt?: number
+  created: string
+  completedAt?: string
   durationMs?: number
   isComplete: boolean
   input: number