@dropalltables/yacu 0.1.0

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@dropalltables/yacu",
+  "version": "0.1.0",
+  "description": "Local coding-agent usage dashboard for the terminal",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dropalltables/yacu.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dropalltables/yacu/issues"
+  },
+  "homepage": "https://github.com/dropalltables/yacu#readme",
+  "type": "module",
+  "bin": {
+    "yacu": "dist/yacu.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "tsconfig.json",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "bun src/index.tsx",
+    "build": "bun build src/index.tsx --target=bun --packages=external --outfile=dist/yacu.js",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "check": "bun test && tsc --noEmit",
+    "prepack": "bun run check && bun run build"
+  },
+  "engines": {
+    "bun": ">=1.4.0"
+  },
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "opentui",
+    "terminal",
+    "tokens",
+    "tui",
+    "usage"
+  ],
+  "license": "MIT",
+  "author": "Natey Hecht",
+  "packageManager": "bun@1.4.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opentui/core": "^0.5.9",
+    "@opentui/react": "^0.5.9",
+    "gpt-tokenizer": "4.0.0",
+    "react": "^19.2.8",
+    "tokentally": "^0.1.4"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.4.0",
+    "@types/react": "^19.2.18",
+    "typescript": "^7.0.2"
+  }
+}

package/src/data/jsonl.ts

@@ -0,0 +1,81 @@
+export async function forEachJsonLine(
+  path: string,
+  callback: (value: unknown) => void | Promise<void>,
+): Promise<void> {
+  const reader = Bun.file(path).stream().getReader()
+  const decoder = new TextDecoder()
+  let pending = ""
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    pending += decoder.decode(value, { stream: true })
+    const lines = pending.split("\n")
+    pending = lines.pop() ?? ""
+    for (const line of lines) await parseLine(line, callback)
+  }
+
+  pending += decoder.decode()
+  await parseLine(pending, callback)
+}
+
+async function parseLine(
+  line: string,
+  callback: (value: unknown) => void | Promise<void>,
+): Promise<void> {
+  if (line.trim() === "") return
+  try {
+    await callback(JSON.parse(line))
+  } catch {
+    return
+  }
+}
+
+export async function globFiles(
+  root: string,
+  pattern: string,
+  options: { includeSymlinks?: boolean } = {},
+): Promise<string[]> {
+  if (!(await Bun.file(root).exists()) && !(await isDirectory(root))) return []
+  const files: string[] = []
+  const glob = new Bun.Glob(pattern)
+  for await (const file of glob.scan({
+    cwd: root,
+    absolute: true,
+    onlyFiles: options.includeSymlinks !== true,
+  })) files.push(file)
+  if (options.includeSymlinks === true) {
+    const existingFiles = await Promise.all(files.map(async (file) => {
+      try {
+        return (await stat(file)).isFile() ? file : null
+      } catch {
+        return null
+      }
+    }))
+    return existingFiles.filter((file): file is string => file != null).sort()
+  }
+  return files.sort()
+}
+
+async function isDirectory(path: string): Promise<boolean> {
+  try {
+    return (await stat(path)).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+export function asObject(value: unknown): Record<string, unknown> | null {
+  return typeof value === "object" && value != null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null
+}
+
+export function numberValue(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0
+}
+
+export function stringValue(value: unknown): string | null {
+  return typeof value === "string" && value !== "" ? value : null
+}
+import { stat } from "node:fs/promises"

package/src/data/load.ts

@@ -0,0 +1,52 @@
+import { SOURCE_META, type SourceId, type UsageDataset } from "../domain/types"
+import { loadClaudeUsage } from "./sources/claude"
+import { loadCodexUsage } from "./sources/codex"
+import { loadCursorUsage } from "./sources/cursor"
+import { loadGeminiUsage } from "./sources/gemini"
+import { loadGrokUsage } from "./sources/grok"
+import { loadOpenCodeUsage } from "./sources/opencode"
+import type { ScanProgressHandler, SourceLoadResult } from "./types"
+
+type SourceLoader = {
+  id: SourceId
+  load: () => Promise<SourceLoadResult>
+}
+
+const SOURCES: SourceLoader[] = [
+  { id: "claude", load: loadClaudeUsage },
+  { id: "codex", load: loadCodexUsage },
+  { id: "cursor", load: loadCursorUsage },
+  { id: "gemini", load: loadGeminiUsage },
+  { id: "opencode", load: loadOpenCodeUsage },
+  { id: "grok", load: loadGrokUsage },
+]
+
+export async function loadUsageDataset(onProgress?: ScanProgressHandler): Promise<UsageDataset> {
+  let completed = 0
+  const results = await Promise.all(SOURCES.map(async (source) => {
+    const common = { source: source.id, label: SOURCE_META[source.id].label, total: SOURCES.length }
+    onProgress?.({ ...common, status: "scanning", completed })
+    try {
+      const value = await source.load()
+      completed += 1
+      onProgress?.({
+        ...common,
+        status: "done",
+        completed,
+        files: value.files,
+        records: value.records.length,
+        sessions: value.sessions.length,
+      })
+      return { value, error: null }
+    } catch (cause) {
+      completed += 1
+      const error = cause instanceof Error ? cause.message : String(cause)
+      onProgress?.({ ...common, status: "error", completed, error })
+      return { value: null, error }
+    }
+  }))
+  const records = results.flatMap((result) => result.value?.records ?? [])
+  const sessions = results.flatMap((result) => result.value?.sessions ?? [])
+  const errors = results.flatMap((result) => result.error == null ? [] : [result.error])
+  return { records, sessions, errors, scannedAt: new Date() }
+}

package/src/data/pricing.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test"
+import { estimateCacheSavings, estimateCost, resolvePricing } from "./pricing"
+
+describe("pricing", () => {
+  test("matches supported model families", () => {
+    expect(resolvePricing("claude-opus-4-1")).not.toBeNull()
+    expect(resolvePricing("gpt-5-codex")).not.toBeNull()
+    expect(resolvePricing("unknown-local-model")).toBeNull()
+  })
+
+  test("estimates cost and cache savings", () => {
+    const cost = estimateCost("gpt-5-codex", {
+      inputTokens: 1_000_000,
+      outputTokens: 0,
+      cacheCreationTokens: 0,
+      cacheReadTokens: 0,
+    })
+
+    expect(cost).toBeCloseTo(1.75)
+    expect(estimateCacheSavings("gpt-5-codex", 1_000_000)).toBeCloseTo(1.575)
+  })
+})

package/src/data/pricing.ts

@@ -0,0 +1,49 @@
+import {
+  estimateUsdCost,
+  normalizeTokenUsage,
+  pricingFromUsdPerMillion,
+  type Pricing,
+} from "tokentally"
+
+export type TokenParts = {
+  inputTokens: number
+  outputTokens: number
+  cacheCreationTokens: number
+  cacheReadTokens: number
+}
+
+const PRICING: Array<[RegExp, Pricing]> = [
+  [/claude.*opus/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 5, outputUsdPerMillion: 25, cachedInputUsdPerMillion: 0.5, cacheCreationInputUsdPerMillion: 6.25 })],
+  [/claude.*sonnet/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 3, outputUsdPerMillion: 15, cachedInputUsdPerMillion: 0.3, cacheCreationInputUsdPerMillion: 3.75 })],
+  [/claude.*haiku/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 1, outputUsdPerMillion: 5, cachedInputUsdPerMillion: 0.1, cacheCreationInputUsdPerMillion: 1.25 })],
+  [/(^|\/)gpt-5|codex/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 1.75, outputUsdPerMillion: 14, cachedInputUsdPerMillion: 0.175 })],
+  [/grok|composer/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 2, outputUsdPerMillion: 10, cachedInputUsdPerMillion: 0.2 })],
+  [/deepseek/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 0.27, outputUsdPerMillion: 1.1, cachedInputUsdPerMillion: 0.07 })],
+  [/gemini-3\.1-pro/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 2, outputUsdPerMillion: 12, cachedInputUsdPerMillion: 0.2 })],
+  [/gemini-2\.5-pro/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 1.25, outputUsdPerMillion: 10, cachedInputUsdPerMillion: 0.125 })],
+  [/gemini-3\.[67]-flash/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 0.75, outputUsdPerMillion: 3.75, cachedInputUsdPerMillion: 0.075 })],
+  [/gemini-3\.5-flash/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 1.5, outputUsdPerMillion: 9, cachedInputUsdPerMillion: 0.15 })],
+  [/gemini-3\.1-flash-lite/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 0.25, outputUsdPerMillion: 1.5, cachedInputUsdPerMillion: 0.025 })],
+  [/gemini.*flash/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 0.3, outputUsdPerMillion: 2.5, cachedInputUsdPerMillion: 0.03 })],
+]
+
+export function resolvePricing(model: string): Pricing | null {
+  return PRICING.find(([pattern]) => pattern.test(model))?.[1] ?? null
+}
+
+export function estimateCost(model: string, tokens: TokenParts): number {
+  const usage = normalizeTokenUsage({
+    inputTokens: tokens.inputTokens,
+    outputTokens: tokens.outputTokens,
+    cachedInputTokens: tokens.cacheReadTokens,
+    cacheCreationInputTokens: tokens.cacheCreationTokens,
+  })
+  return estimateUsdCost({ usage, pricing: resolvePricing(model) })?.totalUsd ?? 0
+}
+
+export function estimateCacheSavings(model: string, cachedReadTokens: number): number {
+  const pricing = resolvePricing(model)
+  if (pricing == null) return 0
+  const cachedRate = pricing.cachedInputUsdPerToken ?? pricing.inputUsdPerToken
+  return Math.max(0, cachedReadTokens * (pricing.inputUsdPerToken - cachedRate))
+}

package/src/data/sources/claude.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from "bun:test"
+import { parseClaudeUsageEntry } from "./claude"
+
+describe("parseClaudeUsageEntry", () => {
+  test("reads Claude token usage without transcript content", () => {
+    expect(parseClaudeUsageEntry({
+      timestamp: "2026-08-29T12:00:00.000Z",
+      sessionId: "session-1",
+      requestId: "request-1",
+      message: {
+        id: "message-1",
+        model: "claude-opus-5",
+        usage: {
+          input_tokens: 10,
+          output_tokens: 20,
+          cache_creation_input_tokens: 30,
+          cache_read_input_tokens: 40,
+        },
+      },
+    })).toEqual({
+      timestamp: "2026-08-29T12:00:00.000Z",
+      sessionId: "session-1",
+      requestId: "request-1",
+      messageId: "message-1",
+      model: "claude-opus-5",
+      inputTokens: 10,
+      outputTokens: 20,
+      cacheCreationTokens: 30,
+      cacheReadTokens: 40,
+    })
+  })
+
+  test("rejects rows without required counters or a valid timestamp", () => {
+    expect(parseClaudeUsageEntry({ timestamp: "invalid", message: { usage: {} } })).toBeNull()
+    expect(parseClaudeUsageEntry({
+      timestamp: "2026-08-29T12:00:00.000Z",
+      message: { usage: { input_tokens: 1 } },
+    })).toBeNull()
+  })
+})

package/src/data/sources/claude.ts

@@ -0,0 +1,118 @@
+import { homedir } from "node:os"
+import { join, resolve } from "node:path"
+import { localDate } from "../../domain/dates"
+import type { UsageRecord, UsageSession } from "../../domain/types"
+import { estimateCacheSavings, estimateCost } from "../pricing"
+import { asObject, forEachJsonLine, globFiles, numberValue, stringValue } from "../jsonl"
+import type { SourceLoadResult } from "../types"
+
+type ClaudeEntry = {
+  timestamp: string
+  sessionId: string | null
+  model: string
+  messageId: string | null
+  requestId: string | null
+  inputTokens: number
+  outputTokens: number
+  cacheCreationTokens: number
+  cacheReadTokens: number
+}
+
+export async function loadClaudeUsage(): Promise<SourceLoadResult> {
+  const files = [...new Set((await Promise.all(
+    claudeRoots().map((root) => globFiles(
+      join(root, "projects"),
+      "**/*.jsonl",
+      { includeSymlinks: true },
+    )),
+  )).flat())]
+  const records: UsageRecord[] = []
+  const sessions = new Map<string, UsageSession>()
+  const processed = new Set<string>()
+
+  for (const path of files) {
+    await forEachJsonLine(path, (value) => {
+      const entry = parseClaudeUsageEntry(value)
+      if (entry == null) return
+
+      const uniqueId = entry.messageId != null && entry.requestId != null
+        ? `${entry.messageId}:${entry.requestId}`
+        : null
+      if (uniqueId != null && processed.has(uniqueId)) return
+      if (uniqueId != null) processed.add(uniqueId)
+
+      const date = localDate(entry.timestamp)
+      const sessionId = entry.sessionId == null ? undefined : `claude:${entry.sessionId}`
+      const tokens = {
+        inputTokens: entry.inputTokens,
+        outputTokens: entry.outputTokens,
+        cacheCreationTokens: entry.cacheCreationTokens,
+        cacheReadTokens: entry.cacheReadTokens,
+      }
+      if (sumTokens(tokens) === 0 || entry.model === "<synthetic>") return
+
+      records.push({
+        date,
+        source: "claude",
+        model: entry.model,
+        sessionId,
+        ...tokens,
+        costUsd: estimateCost(entry.model, tokens),
+        cacheSavingsUsd: estimateCacheSavings(entry.model, entry.cacheReadTokens),
+      })
+
+      if (sessionId != null) {
+        const existing = sessions.get(sessionId)
+        if (existing == null || existing.date < date) {
+          sessions.set(sessionId, { id: sessionId, source: "claude", date })
+        }
+      }
+    })
+  }
+
+  return { records, sessions: [...sessions.values()], files: files.length }
+}
+
+export function parseClaudeUsageEntry(value: unknown): ClaudeEntry | null {
+  const row = asObject(value)
+  const message = asObject(row?.message)
+  const usage = asObject(message?.usage)
+  const timestamp = stringValue(row?.timestamp)
+  const inputTokens = finiteNumber(usage?.input_tokens)
+  const outputTokens = finiteNumber(usage?.output_tokens)
+
+  if (
+    timestamp == null
+    || Number.isNaN(new Date(timestamp).getTime())
+    || inputTokens == null
+    || outputTokens == null
+  ) return null
+
+  return {
+    timestamp,
+    sessionId: stringValue(row?.sessionId),
+    model: stringValue(message?.model) ?? "unknown",
+    messageId: stringValue(message?.id),
+    requestId: stringValue(row?.requestId),
+    inputTokens,
+    outputTokens,
+    cacheCreationTokens: numberValue(usage?.cache_creation_input_tokens),
+    cacheReadTokens: numberValue(usage?.cache_read_input_tokens),
+  }
+}
+
+function claudeRoots(): string[] {
+  const configured = process.env.CLAUDE_CONFIG_DIR?.trim()
+  if (configured != null && configured !== "") {
+    return [...new Set(configured.split(",").map((path) => resolve(path.trim())).filter(Boolean))]
+  }
+  return [join(homedir(), ".config", "claude"), join(homedir(), ".claude")]
+}
+
+function finiteNumber(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null
+}
+
+function sumTokens(tokens: Pick<UsageRecord, "inputTokens" | "outputTokens" | "cacheCreationTokens" | "cacheReadTokens">): number {
+  return tokens.inputTokens + tokens.outputTokens + tokens.cacheCreationTokens + tokens.cacheReadTokens
+}

package/src/data/sources/codex.ts

@@ -0,0 +1,73 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { localDate } from "../../domain/dates"
+import type { UsageRecord, UsageSession } from "../../domain/types"
+import { estimateCacheSavings, estimateCost } from "../pricing"
+import { asObject, forEachJsonLine, globFiles, numberValue, stringValue } from "../jsonl"
+import type { SourceLoadResult } from "../types"
+
+export async function loadCodexUsage(): Promise<SourceLoadResult> {
+  const root = join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "sessions")
+  const files = await globFiles(root, "**/*.jsonl")
+  const records: UsageRecord[] = []
+  const sessions = new Map<string, UsageSession>()
+
+  for (const path of files) {
+    let sessionId = path
+    let model = "codex"
+    let skipSession = false
+    let previousTotal = ""
+
+    await forEachJsonLine(path, (unknownValue) => {
+      const value = asObject(unknownValue)
+      const payload = asObject(value?.payload)
+      const type = stringValue(value?.type)
+
+      if (type === "session_meta") {
+        sessionId = stringValue(payload?.id) ?? sessionId
+        const timestamp = stringValue(payload?.timestamp) ?? stringValue(value?.timestamp)
+        const threadSource = payload?.thread_source
+        skipSession = typeof threadSource !== "string" && JSON.stringify(threadSource).toLowerCase().includes("sub")
+        previousTotal = ""
+        if (timestamp != null && !skipSession) {
+          sessions.set(sessionId, { id: `codex:${sessionId}`, source: "codex", date: localDate(timestamp) })
+        }
+        return
+      }
+
+      if (type === "turn_context") {
+        model = stringValue(payload?.model) ?? model
+        return
+      }
+
+      if (skipSession || type !== "event_msg" || payload?.type !== "token_count") return
+      const info = asObject(payload.info)
+      const last = asObject(info?.last_token_usage)
+      const total = asObject(info?.total_token_usage)
+      if (last == null) return
+
+      const signature = JSON.stringify(total)
+      if (signature === previousTotal) return
+      previousTotal = signature
+
+      const cached = numberValue(last.cached_input_tokens)
+      const rawInput = numberValue(last.input_tokens)
+      const input = Math.max(0, rawInput - cached)
+      const output = numberValue(last.output_tokens)
+      if (input + cached + output === 0) return
+      const timestamp = stringValue(value?.timestamp) ?? new Date().toISOString()
+      const tokens = { inputTokens: input, outputTokens: output, cacheCreationTokens: 0, cacheReadTokens: cached }
+      records.push({
+        date: localDate(timestamp),
+        source: "codex",
+        model,
+        sessionId: `codex:${sessionId}`,
+        ...tokens,
+        costUsd: estimateCost(model, tokens),
+        cacheSavingsUsd: estimateCacheSavings(model, cached),
+      })
+    })
+  }
+
+  return { records, sessions: [...sessions.values()], files: files.length }
+}

package/src/data/sources/cursor.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test"
+import { countContent } from "./cursor"
+
+describe("countContent", () => {
+  test("counts text and tool calls from Cursor transcript parts", () => {
+    const text = countContent([{ type: "text", text: "hello world" }])
+    const tool = countContent([{ type: "tool_use", name: "Read", input: { path: "a.ts" } }])
+
+    expect(text).toBeGreaterThan(0)
+    expect(tool).toBeGreaterThan(0)
+  })
+
+  test("ignores unknown transcript parts", () => {
+    expect(countContent([{ type: "image", data: "ignored" }])).toBe(0)
+  })
+})

package/src/data/sources/cursor.ts

@@ -0,0 +1,83 @@
+import { stat } from "node:fs/promises"
+import { homedir } from "node:os"
+import { basename, dirname, join } from "node:path"
+import { countTokens } from "gpt-tokenizer/encoding/o200k_base"
+import { localDate } from "../../domain/dates"
+import type { UsageRecord, UsageSession } from "../../domain/types"
+import { estimateCost } from "../pricing"
+import { asObject, forEachJsonLine, globFiles, stringValue } from "../jsonl"
+import type { SourceLoadResult } from "../types"
+
+type TranscriptCount = {
+  inputTokens: number
+  outputTokens: number
+}
+
+export async function loadCursorUsage(): Promise<SourceLoadResult> {
+  const root = process.env.CURSOR_CONFIG_DIR ?? join(homedir(), ".cursor")
+  const files = await globFiles(join(root, "projects"), "**/agent-transcripts/**/*.jsonl")
+  const fallbackModel = await readConfiguredModel(join(root, "cli-config.json"))
+  const records: UsageRecord[] = []
+  const sessions: UsageSession[] = []
+
+  for (const path of files) {
+    const counts: TranscriptCount = { inputTokens: 0, outputTokens: 0 }
+    let model = fallbackModel
+    await forEachJsonLine(path, (unknownValue) => {
+      const value = asObject(unknownValue)
+      const message = asObject(value?.message) ?? value
+      const role = stringValue(value?.role) ?? stringValue(message?.role)
+      model = stringValue(value?.model) ?? stringValue(message?.model) ?? model
+      const tokens = countContent(message?.content)
+      if (role === "user") counts.inputTokens += tokens
+      if (role === "assistant") counts.outputTokens += tokens
+    })
+
+    if (counts.inputTokens + counts.outputTokens === 0) continue
+    const timestamp = (await stat(path)).mtime
+    const date = localDate(timestamp)
+    const rawSessionId = basename(dirname(path))
+    const sessionId = `cursor:${rawSessionId}`
+    const tokens = { ...counts, cacheCreationTokens: 0, cacheReadTokens: 0 }
+    records.push({
+      date,
+      source: "cursor",
+      model,
+      sessionId,
+      ...tokens,
+      costUsd: estimateCost(model, tokens),
+      cacheSavingsUsd: 0,
+    })
+    sessions.push({ id: sessionId, source: "cursor", date })
+  }
+
+  return { records, sessions, files: files.length }
+}
+
+export function countContent(value: unknown): number {
+  if (typeof value === "string") return countTokens(value)
+  if (!Array.isArray(value)) return 0
+  return value.reduce((total, item) => {
+    const part = asObject(item)
+    if (part == null) return total
+    const text = stringValue(part.text)
+    if (text != null) return total + countTokens(text)
+    if (part.type === "tool_use") return total + countTokens(JSON.stringify({ name: part.name, input: part.input }))
+    return total
+  }, 0)
+}
+
+async function readConfiguredModel(path: string): Promise<string> {
+  try {
+    const config = asObject(await Bun.file(path).json())
+    const model = asObject(config?.model)
+    const selected = asObject(config?.selectedModel)
+    return stringValue(model?.modelId)
+      ?? stringValue(model?.id)
+      ?? stringValue(selected?.modelId)
+      ?? stringValue(selected?.id)
+      ?? "cursor-agent"
+  } catch {
+    return "cursor-agent"
+  }
+}

package/src/data/sources/gemini.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test"
+import { parseGeminiConversation } from "./gemini"
+
+describe("parseGeminiConversation", () => {
+  test("parses complete JSON session files", () => {
+    const parsed = parseGeminiConversation(JSON.stringify({
+      sessionId: "one",
+      startTime: "2026-08-28T10:00:00Z",
+      messages: [{ id: "m1", type: "gemini", tokens: { input: 10, output: 2, cached: 3, total: 12 } }],
+    }))
+
+    expect(parsed?.sessionId).toBe("one")
+    expect(parsed?.messages).toHaveLength(1)
+  })
+
+  test("applies JSONL rewinds", () => {
+    const parsed = parseGeminiConversation([
+      JSON.stringify({ sessionId: "two", startTime: "2026-08-28T10:00:00Z" }),
+      JSON.stringify({ id: "m1", type: "gemini", tokens: { input: 10 } }),
+      JSON.stringify({ id: "m2", type: "gemini", tokens: { input: 20 } }),
+      JSON.stringify({ $rewindTo: "m1" }),
+      JSON.stringify({ id: "m3", type: "gemini", tokens: { input: 30 } }),
+    ].join("\n"))
+
+    expect(parsed?.messages.map((message) => message.id)).toEqual(["m1", "m3"])
+  })
+})