@chroxify/eunoe 1.1.0 → 1.2.1

package/README.md

@@ -336,6 +336,7 @@ eunoe settings               # pick a setting and change it
 eunoe settings list          # show them all
 eunoe settings set keep 5    # change one directly
 eunoe status                 # what's running, every session, context and tokens saved
+eunoe stats                  # tokens and API cost by day (--days 14, --weekly), and what eunoe saved
 eunoe replay                 # replay your whole Claude Code history through eunoe, offline, and see what it saves
 eunoe uninstall              # stop and remove the background proxy
 ```
@@ -416,6 +417,18 @@ Every request is written to `~/.eunoe/requests.jsonl` with what eunoe did
 to it and how much of it the API served from cache, which is also where
 `eunoe status` gets its numbers.
 
+`eunoe stats` reads the usage the API returned, from Claude Code's own session
+files, subagents included, so it covers every session, routed through eunoe or
+not. Claude Code writes one response as several lines, so each response is
+counted once, with its final output count. Cost is at API list prices.
+Its eunoe columns are only what eunoe actually did, from its request log: the
+input tokens it kept out, and what that saved. Those tokens are mostly history
+plain Claude Code would have read from cache, so they are priced as cache
+reads, and every token a fold rewrote is charged back at the cache-write price.
+`eunoe replay` and `eunoe stats` can only see what is still on disk: Claude Code
+deletes sessions that have been idle for 30 days unless `cleanupPeriodDays` in
+its `settings.json` says otherwise.
+
 ## What it doesn't do
 
 - **It is a proxy, which makes it a single point of failure.** If it isn't

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chroxify/eunoe",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Context management for Claude Code that never forgets what matters.",
   "license": "MIT",
   "repository": {

package/src/cli/commands/index.ts

@@ -7,6 +7,7 @@ import { serve } from "./serve"
 import { sessions } from "./sessions"
 import { settings } from "./settings"
 import { start } from "./start"
+import { stats } from "./stats"
 import { status } from "./status"
 import { stop } from "./stop"
 import { uninstall } from "./uninstall"
@@ -20,6 +21,7 @@ export const commands: Record<string, Command> = {
   mode,
   settings,
   status,
+  stats,
   replay,
   sessions,
   peek,

package/src/cli/commands/replay.ts

@@ -1,20 +1,23 @@
-import { statSync } from "node:fs"
+import { closeSync, openSync, readSync, statSync } from "node:fs"
 import { cpus } from "node:os"
 import path from "node:path"
 import { claudeConfigDirs, DEFAULTS, parseTunable, readConfig } from "../../config"
 import { listEntries, projectFolderName, projectFolders } from "../../transcript/locate"
 import type { Command } from "../command"
+import { cleanupDays } from "../proxy/claude-settings"
 import { recentRequests } from "../proxy/inspect"
-import type { ReplayedSession, ReplayOptions } from "../replay"
+import type { ReplayedSession, ReplayFailure, ReplayOptions } from "../replay"
 import { shortId } from "../sessions"
-import { c, fail, line, percent, plural, rows, table, tilde, tokens, useColor } from "../terminal/ui"
+import { c, fail, line, percent, plural, rows, table, tilde, tokens, useColor, warn } from "../terminal/ui"
 
 interface Target {
   file: string
   bytes: number
+  lastActive: number
 }
 
 const WINDOW = 1_000_000
+const HEAD_BYTES = 64 * 1024
 const TOP_SESSIONS = 10
 
 function targets(configDirs: string[], ids: string[], here: string | null): Target[] {
@@ -28,7 +31,8 @@ function targets(configDirs: string[], ids: string[], here: string | null): Targ
       const id = name.slice(0, -".jsonl".length)
       if (!wanted(id) || seen.has(id)) continue
       const file = path.join(folder, name)
-      seen.set(id, { file, bytes: statSync(file).size })
+      const stat = statSync(file)
+      seen.set(id, { file, bytes: stat.size, lastActive: stat.mtimeMs })
     }
   }
   return [...seen.values()].sort((a, b) => b.bytes - a.bytes)
@@ -42,12 +46,35 @@ function fixedTokens(): { value: number; measured: boolean } {
   return { value: sizes[Math.floor(sizes.length / 2)], measured: true }
 }
 
+const day = (ms: number) => new Date(ms).toLocaleDateString(undefined, { month: "short", day: "numeric", year: "numeric" })
+
 const duration = (ms: number) => (ms < 60_000 ? `${Math.max(1, Math.round(ms / 1000))}s` : `${Math.floor(ms / 60_000)}m ${Math.round((ms % 60_000) / 1000)}s`)
 const size = (bytes: number) => (bytes >= 1e9 ? `${(bytes / 1e9).toFixed(1)} GB` : `${Math.round(bytes / 1e6)} MB`)
 const fewer = (plain: number, eunoe: number) => (plain > 0 ? percent(1 - eunoe / plain) : "–")
 
-async function replayAll(list: Target[], options: ReplayOptions, onDone: (done: number, bytes: number) => void): Promise<ReplayedSession[]> {
+function startedAt(target: Target): number {
+  const buffer = Buffer.alloc(HEAD_BYTES)
+  let read = 0
+  try {
+    const fd = openSync(target.file, "r")
+    read = readSync(fd, buffer, 0, HEAD_BYTES, 0)
+    closeSync(fd)
+  } catch {
+    return target.lastActive
+  }
+  const found = /"timestamp":"([^"]+)"/.exec(buffer.toString("utf8", 0, read))
+  const at = found ? Date.parse(found[1]) : Number.NaN
+  return Number.isNaN(at) ? target.lastActive : Math.min(at, target.lastActive)
+}
+
+function historyLine(list: Target[], keepDays: number): string {
+  const span = `${day(Math.min(...list.map(startedAt)))} – ${day(Math.max(...list.map((t) => t.lastActive)))}`
+  return `${span}  ${c.dim(`· the sessions still on disk; Claude Code deletes sessions idle for ${keepDays} days (cleanupPeriodDays), so totals cover a moving window`)}`
+}
+
+async function replayAll(list: Target[], options: ReplayOptions, onDone: (done: number, bytes: number) => void): Promise<{ results: ReplayedSession[]; failures: ReplayFailure[] }> {
   const results: ReplayedSession[] = []
+  const failures: ReplayFailure[] = []
   const queue = [...list]
   let bytesDone = 0
   const workers = Math.max(1, Math.min(8, cpus().length - 1, list.length))
@@ -56,28 +83,46 @@ async function replayAll(list: Target[], options: ReplayOptions, onDone: (done:
       { length: workers },
       () =>
         new Promise<void>((resolve) => {
-          const worker = new Worker(new URL("../replay/worker.ts", import.meta.url).href)
+          let worker = new Worker(new URL("../replay/worker.ts", import.meta.url).href)
+          let current: Target | undefined
+          const finish = (target: Target) => {
+            bytesDone += target.bytes
+            onDone(results.length + failures.length, bytesDone)
+          }
           const next = () => {
-            const target = queue.shift()
-            if (!target) {
+            current = queue.shift()
+            if (!current) {
               worker.terminate()
               resolve()
               return
             }
-            worker.postMessage({ file: target.file, options })
+            worker.postMessage({ file: current.file, options })
           }
-          worker.onmessage = (event: MessageEvent<ReplayedSession>) => {
-            results.push(event.data)
-            bytesDone += event.data.bytes
-            onDone(results.length, bytesDone)
-            next()
+          const listen = () => {
+            worker.onmessage = (event: MessageEvent<ReplayedSession | ReplayFailure>) => {
+              if ("error" in event.data) failures.push(event.data)
+              else results.push(event.data)
+              if (current) finish(current)
+              next()
+            }
+            worker.onerror = (event) => {
+              event.preventDefault()
+              if (current) {
+                failures.push({ file: current.file, error: event.message || "worker crashed" })
+                finish(current)
+              }
+              worker.terminate()
+              worker = new Worker(new URL("../replay/worker.ts", import.meta.url).href)
+              listen()
+              next()
+            }
           }
-          worker.onerror = () => next()
+          listen()
           next()
         }),
     ),
   )
-  return results
+  return { results, failures }
 }
 
 export const replay: Command = {
@@ -105,7 +150,8 @@ export const replay: Command = {
     const config = readConfig()
     const turnCap = capAt === -1 ? config.turnCap : parseTunable("turnCap", args[capAt + 1] ?? "")
     if (turnCap === null) fail("--turn-cap needs a token count or off", "eunoe replay --turn-cap off")
-    const list = targets(claudeConfigDirs(config), ids, args.includes("--here") ? process.cwd() : null)
+    const configDirs = claudeConfigDirs(config)
+    const list = targets(configDirs, ids, args.includes("--here") ? process.cwd() : null)
     if (list.length === 0) fail("No Claude Code sessions found.")
     const totalBytes = list.reduce((total, entry) => total + entry.bytes, 0)
     const fixed = fixedTokens()
@@ -113,7 +159,7 @@ export const replay: Command = {
     const options: ReplayOptions = { config: { ...config, turnCap, mode: config.mode === "off" ? DEFAULTS.mode : config.mode }, window, fixedTokens: fixed.value }
     const started = Date.now()
     const progress = useColor && process.stdout.isTTY
-    const results = await replayAll(list, options, (done, doneBytes) => {
+    const { results, failures } = await replayAll(list, options, (done, doneBytes) => {
       if (!progress) return
       const left = doneBytes > 0 ? ` · ~${duration(((Date.now() - started) / doneBytes) * (totalBytes - doneBytes))} left` : ""
       process.stdout.write(`\r\x1b[K  ${c.dim(`Replaying ${done} / ${list.length} sessions · ${size(doneBytes)} of ${size(totalBytes)}${left}`)}`)
@@ -133,7 +179,8 @@ export const replay: Command = {
     line()
     rows(
       [
-        ["Sessions", `${c.bold(String(compared.length))} replayed  ${c.dim("·")}  ${size(totalBytes)}  ${c.dim("·")}  ${duration(Date.now() - started)}`],
+        ["Sessions", `${c.bold(compared.length.toLocaleString())} replayed  ${c.dim("·")}  ${size(totalBytes)}  ${c.dim("·")}  ${duration(Date.now() - started)}`],
+        ["History", historyLine(list, cleanupDays(configDirs))],
         ["Requests", c.bold(sum.requests.toLocaleString())],
         ["Window", `${tokens(window)}  ${c.dim(`· ${tokens(fixed.value)} of it system prompt and tools, ${fixed.measured ? "from your logged requests" : "assumed"}`)}`],
       ],
@@ -144,33 +191,33 @@ export const replay: Command = {
       [
         [
           "History kept",
-          `eunoe ${c.bold(c.green("every turn"))}, folded or whole  ${c.dim("·")}  Claude Code compacted ${c.bold(String(sum.nativeCompactions))} time${sum.nativeCompactions === 1 ? "" : "s"}, ${c.bold(tokens(sum.discarded))} tokens of conversation replaced by summaries`,
+          `eunoe ${c.bold(c.green("every turn"))}, folded or whole  ${c.dim("·")}  Claude Code compacted ${c.bold(sum.nativeCompactions.toLocaleString())} time${sum.nativeCompactions === 1 ? "" : "s"}, ${c.bold(tokens(sum.discarded))} tokens of conversation replaced by summaries`,
         ],
         [
           "Input tokens",
           `plain ${tokens(sum.plainTokens)}  ${c.dim("→")}  eunoe ${c.bold(tokens(sum.eunoeTokens))} tokens   ${c.green(c.bold(`${fewer(sum.plainTokens, sum.eunoeTokens)} fewer`))}  ${c.dim("the conversation; system prompt and tools are the same on both sides")}`,
         ],
         ["Cost", `${c.green(c.bold(`${fewer(sum.plainCost, sum.eunoeCost)} cheaper`))}  ${c.dim("cache reads at 0.1×, writes at 1.25×")}`],
-        ["Folds", c.bold(String(sum.folds))],
-        ["Folds dropped", `${c.bold(String(sum.dropped))} ${c.dim("folded turns removed entirely to fit the window")}`],
-        ["Peak context", `plain ${tokens(sum.peakPlain)}  ${c.dim("→")}  eunoe ${c.bold(tokens(sum.peakEunoe))}`],
+        ["Folds", c.bold(sum.folds.toLocaleString())],
+        ["Folds dropped", `${c.bold(sum.dropped.toLocaleString())} ${c.dim("folded turns removed entirely to fit the window")}`],
+        ["Peak context", `plain ${c.green(c.bold(tokens(sum.peakPlain)))}  ${c.dim("→")}  eunoe ${c.bold(tokens(sum.peakEunoe))}  ${c.dim("· the longest conversation whole, every compaction undone, against the most eunoe sent")}`],
       ],
       4,
     )
     const saved = [...compared]
       .filter((r) => r.nativeCompactions > 0)
-      .sort((a, b) => b.discarded - a.discarded)
+      .sort((a, b) => b.peakPlain - a.peakPlain)
       .slice(0, TOP_SESSIONS)
     if (saved.length > 0) {
       line()
-      line(`  ${c.dim("Sessions Claude Code would have compacted, by history it would have lost")}`)
+      line(`  ${c.dim("Longest sessions Claude Code would have compacted, by their whole history")}`)
       table(
         saved.map((r) => [
           c.cyan(shortId(r.id)),
           (r.title ?? (r.cwd ? tilde(r.cwd) : "")).slice(0, 40),
-          c.bold(c.green(`${plural(r.nativeCompactions, "compaction")} avoided`)),
-          `${tokens(r.discarded)} tokens kept`,
-          c.dim(`${plural(r.folds, "fold")} · ${tokens(r.plainTokens)} → ${tokens(r.eunoeTokens)} tokens`),
+          `${c.green(c.bold(tokens(r.peakPlain)))} ${c.dim("of history")}`,
+          c.bold(`${plural(r.nativeCompactions, "compaction")} avoided`),
+          c.dim(`eunoe peak ${tokens(r.peakEunoe)} · ${plural(r.folds, "fold")}`),
         ]),
       )
     }
@@ -189,6 +236,10 @@ export const replay: Command = {
         ]),
       )
     }
+    if (failures.length > 0) {
+      line()
+      warn(`${plural(failures.length, "session")} couldn't be replayed and ${failures.length === 1 ? "is" : "are"} not counted: ${failures.map((f) => `${shortId(path.basename(f.file, ".jsonl"))} (${f.error})`).join(", ")}`)
+    }
     line()
   },
 }

package/src/cli/commands/start.ts

@@ -1,14 +1,16 @@
 import { existsSync } from "node:fs"
 import path from "node:path"
-import { type Config, claudeConfigDirs, compactionOwner, readConfig, saveConfig } from "../../config"
+import { type Config, claudeConfigDirs, compactionOwner, modeFor, readConfig, saveConfig } from "../../config"
+import { seenSessions } from "../../proxy/sessions"
 import type { Command } from "../command"
 import { editSettings, withEunoe } from "../proxy/claude-settings"
 import { routedDirs } from "../proxy/inspect"
+import { isIdle, isTerminal, type LiveSession, listLiveSessions, restartSessions, unroutedSessions } from "../proxy/live"
 import { startService } from "../proxy/service"
 import { clearWatch } from "../proxy/watch"
 import { isKnown, sessionArgs, shortId } from "../sessions"
 import { flagValues } from "../terminal/args"
-import { c, fail, line, listFiles, note, ok, rows, tilde } from "../terminal/ui"
+import { c, fail, line, listFiles, note, ok, plural, rows, tilde } from "../terminal/ui"
 import { MODE_DESCRIPTIONS } from "./mode"
 
 function scoped(config: Config, ids: string[]): Partial<Config> {
@@ -30,13 +32,34 @@ function managedSessions(config: Config): string {
   return `only ${ids.join(", ")}`
 }
 
+function restartUnrouted(config: Config, skip: boolean): { restarted: LiveSession[]; busy: LiveSession[] } {
+  const lastSeen = new Map(seenSessions().map(([id, seen]) => [id, seen.lastSeen]))
+  const managed = (id: string) => modeFor(config, id) !== "off"
+  const unrouted = unroutedSessions(listLiveSessions(claudeConfigDirs(config)), lastSeen, managed, process.env.CLAUDE_CODE_SESSION_ID)
+  if (skip) return { restarted: [], busy: unrouted }
+  return { restarted: restartSessions(unrouted.filter(isIdle)), busy: unrouted.filter((session) => !isIdle(session)) }
+}
+
+function reportRestarts({ restarted, busy }: { restarted: LiveSession[]; busy: LiveSession[] }) {
+  if (restarted.length > 0) {
+    ok(`Restarted ${plural(restarted.length, "idle session")} so they go through eunoe`)
+    if (restarted.some((session) => !isTerminal(session))) note("App sessions come back on their next message.")
+    if (restarted.some(isTerminal)) note("Resume the terminal ones with:")
+    for (const session of restarted.filter(isTerminal)) line(`    ${c.dim(`cd ${tilde(session.cwd)} && claude --resume ${session.sessionId}`)}`)
+    line()
+  }
+  if (busy.length > 0) note(`Still on the direct route until restarted: ${busy.map((session) => shortId(session.sessionId)).join(", ")}.`)
+}
+
 export const start: Command = {
   summary: "Route Claude Code through eunoe",
-  usage: "eunoe start [--session <id>] [--config-dir <dir>]",
+  usage: "eunoe start [--session <id>] [--config-dir <dir>] [--no-restart]",
   details: [
     "Starts the background proxy if it isn't running (setting it up the first time)",
     "and points Claude Code at it through ANTHROPIC_BASE_URL in settings.json.",
-    "New sessions pick it up; restart the ones already running.",
+    "New sessions pick it up. Idle sessions already running are restarted so they",
+    "pick it up too: app-hosted ones resume on their next message, terminal ones",
+    "print the command that resumes them. Busy sessions are left alone.",
     "",
     "With --session, eunoe manages only the sessions you name and passes the rest",
     "through untouched. Session ids are in Claude Code's /status, or `eunoe status`.",
@@ -44,6 +67,7 @@ export const start: Command = {
   options: [
     ["--session <id>", "Only manage this session (repeatable; a unique prefix is enough)"],
     ["--config-dir <dir>", "Also manage this Claude config directory (repeatable, remembered)"],
+    ["--no-restart", "Leave running sessions alone"],
   ],
   async run(args) {
     const added = flagValues(args, "--config-dir").map((dir) => path.resolve(dir))
@@ -65,9 +89,11 @@ export const start: Command = {
       ["Sessions", managedSessions(config)],
     ])
     line()
-    const unseen = ids.filter((id) => !isKnown(id))
+    const restarts = restartUnrouted(config, args.includes("--no-restart"))
+    reportRestarts(restarts)
+    const unseen = ids.filter((id) => !isKnown(id) && !restarts.restarted.some((session) => session.sessionId === id))
     if (unseen.length > 0) note(`Not seen through eunoe yet: ${unseen.map(shortId).join(", ")}. It applies once that session's requests come through; one started before routing needs a restart.`)
-    else note(ids.length > 0 ? "Takes effect on the session's next request." : "New sessions go through eunoe. Restart any that are already running.")
+    else note(ids.length > 0 ? "Takes effect on the session's next request." : "New sessions go through eunoe.")
     line()
   },
 }

package/src/cli/commands/stats.ts

@@ -0,0 +1,264 @@
+import { claudeConfigDirs, readConfig } from "../../config"
+import type { Command } from "../command"
+import { cleanupDays } from "../proxy/claude-settings"
+import { type RequestRecord, recentRequests } from "../proxy/inspect"
+import { nativeCompactions, savedTokens, type ThreadPeak, threadPeaks, totals } from "../proxy/stats"
+import { REPLAY_NATIVE_COMPACT_AT } from "../replay"
+import { shortId } from "../sessions"
+import { c, fail, line, percent, plural, table, tokens, wrap } from "../terminal/ui"
+import { costOf, ratesOf, readUsage, type UsageEntry, usageFiles } from "../usage"
+
+interface Bucket {
+  start: number
+  label: string
+  usage: UsageEntry[]
+  logged: RequestRecord[]
+}
+
+type Matched = Map<RequestRecord, UsageEntry>
+
+const DAY = 86_400_000
+const MATCH_WITHIN = 10 * 60_000
+const NOTE_WIDTH = 110
+const DEFAULT_DAYS = 7
+const DEFAULT_WEEKS = 8
+const LONGEST = 5
+
+const midnight = (ms: number) => new Date(new Date(ms).toDateString()).getTime()
+const addDays = (ms: number, days: number) => {
+  const date = new Date(ms)
+  date.setDate(date.getDate() + days)
+  return date.getTime()
+}
+const monday = (ms: number) => addDays(midnight(ms), -((new Date(ms).getDay() + 6) % 7))
+const short = (ms: number) => new Date(ms).toLocaleDateString(undefined, { month: "short", day: "numeric" })
+const dayLabel = (ms: number) => new Date(ms).toLocaleDateString(undefined, { weekday: "short", month: "short", day: "numeric" })
+const dollars = (amount: number) => `$${amount >= 100 ? Math.round(amount).toLocaleString() : amount.toFixed(2)}`
+
+export function buckets(now: number, weekly: boolean, count: number): Bucket[] {
+  const step = weekly ? 7 : 1
+  const last = weekly ? monday(now) : midnight(now)
+  return Array.from({ length: count }, (_, i) => {
+    const start = addDays(last, -step * (count - 1 - i))
+    const label = weekly ? `${short(start)} – ${short(addDays(start, 6))}` : dayLabel(start)
+    return { start, label, usage: [], logged: [] }
+  })
+}
+
+function place(list: Bucket[], at: number, add: (bucket: Bucket) => void) {
+  for (let i = list.length - 1; i >= 0; i -= 1) {
+    if (at < list[i].start) continue
+    add(list[i])
+    return
+  }
+}
+
+export function summarize(usage: UsageEntry[]) {
+  const sum = { requests: usage.length, input: 0, output: 0, cacheWrite: 0, cacheRead: 0, cost: 0, unpriced: 0 }
+  for (const entry of usage) {
+    sum.input += entry.input
+    sum.output += entry.output
+    sum.cacheWrite += entry.cacheWrite5m + entry.cacheWrite1h
+    sum.cacheRead += entry.cacheRead
+    const cost = costOf(entry)
+    if (cost === null) sum.unpriced += 1
+    else sum.cost += cost
+  }
+  return sum
+}
+
+const usageKey = (cacheRead: number, cacheWrite: number, uncached: number) => `${cacheRead}:${cacheWrite}:${uncached}`
+
+export function matchLogged(usage: UsageEntry[], logged: RequestRecord[]): Matched {
+  const index = new Map<string, UsageEntry[]>()
+  for (const entry of usage) {
+    const key = usageKey(entry.cacheRead, entry.cacheWrite5m + entry.cacheWrite1h, entry.input)
+    index.set(key, [...(index.get(key) ?? []), entry])
+  }
+  const matched: Matched = new Map()
+  for (const record of logged) {
+    if (!record.input) continue
+    const at = Date.parse(record.ts)
+    const distance = (entry: UsageEntry) => Math.abs(entry.at - at)
+    const nearest = (index.get(usageKey(record.cacheRead ?? 0, record.cacheWrite ?? 0, record.uncached ?? 0)) ?? []).reduce<UsageEntry | null>((best, entry) => (!best || distance(entry) < distance(best) ? entry : best), null)
+    if (nearest && distance(nearest) <= MATCH_WITHIN) matched.set(record, nearest)
+  }
+  return matched
+}
+
+export function costSaved(record: RequestRecord, entry: UsageEntry): number | null {
+  const saved = savedTokens(record)
+  const rates = ratesOf(entry)
+  if (saved === null || !rates) return null
+  const foldRewrite = record.compacted ? (record.cacheWrite ?? 0) * (rates.write - rates.read) : 0
+  return saved * rates.read - foldRewrite
+}
+
+export function savings(logged: RequestRecord[], matched: Matched) {
+  const sum = { handled: 0, priced: 0, unsized: 0, unmatched: 0, actual: 0, saved: 0 }
+  for (const record of logged) {
+    if (!record.input) continue
+    sum.handled += 1
+    const entry = matched.get(record)
+    if (savedTokens(record) === null) sum.unsized += 1
+    else if (!entry) sum.unmatched += 1
+    const saved = entry ? costSaved(record, entry) : null
+    const actual = entry ? costOf(entry) : null
+    if (saved === null || actual === null) continue
+    sum.priced += 1
+    sum.actual += actual
+    sum.saved += saved
+  }
+  return sum
+}
+
+function leftOut(sum: ReturnType<typeof savings>) {
+  const reasons = [
+    sum.unsized ? `${sum.unsized.toLocaleString()} predate size logging` : "",
+    sum.unmatched ? `${sum.unmatched.toLocaleString()} aren't in session files` : "",
+    sum.handled - sum.priced - sum.unsized - sum.unmatched > 0 ? `${sum.handled - sum.priced - sum.unsized - sum.unmatched} to models without a price` : "",
+  ]
+  const listed = reasons.filter(Boolean)
+  return listed.length > 1 ? `${listed.slice(0, -1).join(", ")} and ${listed.at(-1)}` : listed.join("")
+}
+
+function notSentCell(logged: RequestRecord[]) {
+  const sum = totals(logged)
+  if (sum.requests === 0) return c.dim("–")
+  if (sum.saved <= 0) return c.dim("±0")
+  return `${c.green(c.bold(tokens(sum.saved)))} ${c.dim(plural(sum.folds, "fold"))}`
+}
+
+function avoidedCell(logged: RequestRecord[], avoided: Set<RequestRecord>) {
+  if (!logged.some((record) => record.input)) return c.dim("–")
+  const count = logged.filter((record) => avoided.has(record)).length
+  return count > 0 ? c.green(c.bold(count.toLocaleString())) : c.dim("0")
+}
+
+function costSavedCell(logged: RequestRecord[], matched: Matched) {
+  const sum = savings(logged, matched)
+  if (sum.priced === 0) return c.dim("–")
+  if (Math.abs(sum.saved) < 0.005) return c.dim("±0")
+  const share = c.dim(percent(sum.saved / (sum.actual + sum.saved)))
+  return sum.saved > 0 ? `${dollars(sum.saved)} ${share}` : `${c.yellow(`−${dollars(-sum.saved)}`)} ${share}`
+}
+
+function row(label: string, usage: UsageEntry[], logged: RequestRecord[], matched: Matched, avoided: Set<RequestRecord>, bold = false) {
+  const sum = summarize(usage)
+  const strong = (text: string) => (bold ? c.bold(text) : text)
+  const eunoe = [avoidedCell(logged, avoided), notSentCell(logged), costSavedCell(logged, matched)]
+  if (sum.requests === 0) return [strong(label), c.dim("–"), "", "", "", "", "", ...eunoe]
+  return [strong(label), strong(sum.requests.toLocaleString()), tokens(sum.input), tokens(sum.output), tokens(sum.cacheWrite), tokens(sum.cacheRead), strong(`${dollars(sum.cost)}${sum.unpriced ? c.dim("*") : ""}`), ...eunoe]
+}
+
+function byModel(usage: UsageEntry[]) {
+  const models = new Map<string, UsageEntry[]>()
+  for (const entry of usage) models.set(entry.model, [...(models.get(entry.model) ?? []), entry])
+  const total = summarize(usage).cost
+  return [...models]
+    .map(([model, entries]) => ({ model, sum: summarize(entries) }))
+    .sort((a, b) => b.sum.cost - a.sum.cost || b.sum.requests - a.sum.requests)
+    .map(({ model, sum }) => [
+      model,
+      sum.requests.toLocaleString(),
+      tokens(sum.input),
+      tokens(sum.output),
+      tokens(sum.cacheWrite),
+      tokens(sum.cacheRead),
+      sum.unpriced ? c.dim("no price") : c.bold(dollars(sum.cost)),
+      c.dim(total > 0 && !sum.unpriced ? percent(sum.cost / total) : ""),
+    ])
+}
+
+function longestRow(peak: ThreadPeak) {
+  return [
+    c.cyan(shortId(peak.session)),
+    `${c.green(c.bold(tokens(peak.plain)))} ${c.dim("of history")}`,
+    peak.compactions > 0 ? `${c.bold(plural(peak.compactions, "compaction"))} avoided` : c.dim("no compaction needed"),
+    c.dim(`eunoe sent ${tokens(peak.sent)}${peak.turns ? ` · ${plural(peak.turns, "turn")}` : ""} · ${dayLabel(Date.parse(peak.lastSeen))}`),
+  ]
+}
+
+const countArg = (args: string[], flag: string, fallback: number) => {
+  const at = args.indexOf(flag)
+  if (at === -1) return fallback
+  const value = Number(args[at + 1])
+  if (!Number.isInteger(value) || value < 1) fail(`${flag} needs a whole number`, `eunoe stats ${flag} 14`)
+  return value
+}
+
+export const stats: Command = {
+  summary: "Token usage and cost by day or week, and what eunoe saved",
+  usage: "eunoe stats [--days <n>] [--weekly] [--weeks <n>]",
+  details: [
+    "Reads the usage the API returned for every request in your Claude Code",
+    "sessions, subagents included, counting each response once. Cost is at",
+    "API list prices. The eunoe columns come from its request log: the",
+    "compactions Claude Code would have run on the conversations it handled,",
+    "the input tokens it kept out, and what that saved at cache-read prices",
+    "once the cache writes its folds caused are paid for.",
+  ],
+  options: [
+    ["--days <n>", `Days to show (default ${DEFAULT_DAYS})`],
+    ["--weekly", `Group by week, Monday first (default ${DEFAULT_WEEKS} weeks)`],
+    ["--weeks <n>", "Weeks to show; implies --weekly"],
+  ],
+  run(args) {
+    const weekly = args.includes("--weekly") || args.includes("--weeks")
+    const count = weekly ? countArg(args, "--weeks", DEFAULT_WEEKS) : countArg(args, "--days", DEFAULT_DAYS)
+    const now = Date.now()
+    const list = buckets(now, weekly, count)
+    const since = list[0].start
+    const configDirs = claudeConfigDirs(readConfig())
+    const usage = readUsage(usageFiles(configDirs, since), since)
+    const all = recentRequests(Number.POSITIVE_INFINITY)
+    const avoided = nativeCompactions(all)
+    const logged = all.filter((record) => Date.parse(record.ts) >= since)
+    for (const entry of usage) place(list, entry.at, (bucket) => bucket.usage.push(entry))
+    const matched = matchLogged(usage, logged)
+    for (const record of logged) place(list, Date.parse(record.ts), (bucket) => bucket.logged.push(record))
+
+    line()
+    line(`  ${c.bold("eunoe stats")}  ${c.dim(`the last ${count} ${weekly ? "weeks" : "days"} of Claude Code, from your session files`)}`)
+    line()
+    table([
+      [weekly ? "Week" : "Day", "Requests", "Input", "Output", "Cache write", "Cache read", "API cost", "Compactions avoided", "Tokens saved", "Cost saved"].map((title) => c.dim(title)),
+      ...list.map((bucket) => row(bucket.label, bucket.usage, bucket.logged, matched, avoided)),
+      row("Total", usage, logged, matched, avoided, true),
+    ])
+
+    const longest = threadPeaks(all, avoided)
+      .filter((peak) => Date.parse(peak.lastSeen) >= since)
+      .slice(0, LONGEST)
+    if (longest.length > 0) {
+      line()
+      line(`  ${c.dim("Longest conversations, by the history Claude Code would have had to carry")}`)
+      table(longest.map(longestRow))
+    }
+
+    const models = byModel(usage)
+    if (models.length > 0) {
+      line()
+      table([["Model", "Requests", "Input", "Output", "Cache write", "Cache read", "API cost", "Share"].map((title) => c.dim(title)), ...models])
+    }
+
+    const keepDays = cleanupDays(configDirs)
+    const handled = savings(logged, matched)
+    const notes: Array<[label: string, text: string]> = [
+      ["API cost", "At list prices, including cache writes and fast mode."],
+      ["Compactions", `Times Claude Code would have compacted a conversation eunoe handled, at ${Math.round(REPLAY_NATIVE_COMPACT_AT * 100)}% of its window. eunoe kept every turn instead.`],
+      ["Tokens saved", "Input eunoe kept out, mostly history Claude Code would have read from cache."],
+      ["Cost saved", "Those tokens at cache-read prices, minus what each fold cost to rewrite."],
+      ...(handled.priced < handled.handled ? [["Not priced", `${(handled.handled - handled.priced).toLocaleString()} of ${handled.handled.toLocaleString()} eunoe requests: ${leftOut(handled)}.`] as [string, string]] : []),
+      ...(summarize(usage).unpriced ? [["* No price", "Some models have no known price, so their tokens count but their cost doesn't."] as [string, string]] : []),
+      ...(since < now - keepDays * DAY ? [["History", `Claude Code deletes sessions after ${keepDays} idle days, so older rows may be incomplete.`] as [string, string]] : []),
+    ]
+    const labelWidth = Math.max(...notes.map(([label]) => label.length)) + 3
+    const width = Math.min(process.stdout.columns || NOTE_WIDTH, NOTE_WIDTH) - 2 - labelWidth
+    for (const [label, text] of notes) {
+      line()
+      for (const [index, part] of wrap(text, width).entries()) line(`  ${c.dim((index === 0 ? label : "").padEnd(labelWidth))}${part}`)
+    }
+    line()
+  },
+}

package/src/cli/commands/status.ts

@@ -29,7 +29,7 @@ function summary(title: string, sum: Totals) {
   line(`  ${title}`)
   rows(
     [
-      ["Requests", `${c.bold(String(sum.requests))}${folds}`],
+      ["Requests", `${c.bold(sum.requests.toLocaleString())}${folds}`],
       ["Cache", `${c.bold(tokens(sum.cacheRead))} read  ${c.dim("·")}  ${tokens(sum.cacheWrite)} written  ${c.dim("·")}  ${tokens(sum.uncached)} uncached${hitRate}`],
       ["Saved", saved],
     ],
@@ -100,7 +100,7 @@ export const status: Command = {
     const routed = routedDirs(config)
     const all = recentRequests(Number.POSITIVE_INFINITY)
     const recent = all.slice(-RECENT_REQUESTS)
-    const sum = totals(withinWindow(recent))
+    const sum = totals(withinWindow(all))
     const allTime = totals(all)
 
     line()
@@ -114,7 +114,7 @@ export const status: Command = {
       ["Recall", recallLine(config, recent)],
     ])
 
-    sessionsTable(config, perSession(recent))
+    sessionsTable(config, perSession(all))
 
     if (sum.requests) summary(c.dim("Last 24h"), sum)
     if (allTime.requests > sum.requests) summary(`${c.dim("All time")}  ${c.dim(`since ${new Date(all[0].ts).toLocaleDateString()}`)}`, allTime)

package/src/cli/proxy/claude-settings.ts

@@ -7,6 +7,8 @@ export interface Settings {
   [key: string]: unknown
 }
 
+const CLAUDE_CLEANUP_DAYS = 30
+
 export const BLOCKING_LIMIT_ENV = "CLAUDE_CODE_BLOCKING_LIMIT_OVERRIDE"
 export const BLOCKING_LIMIT_OFF = "1000000000"
 
@@ -44,6 +46,14 @@ export function readSettings(dir: string): Settings {
   }
 }
 
+export function cleanupDays(configDirs: string[]): number {
+  for (const dir of configDirs) {
+    const days = readSettings(dir).cleanupPeriodDays
+    if (typeof days === "number") return days
+  }
+  return CLAUDE_CLEANUP_DAYS
+}
+
 export function editSettings(dirs: string[], edit: (settings: Settings) => Settings): string[] {
   const touched: string[] = []
   for (const dir of dirs) {

package/src/cli/proxy/live.ts

@@ -0,0 +1,57 @@
+import { spawnSync } from "node:child_process"
+import { existsSync, readdirSync, readFileSync } from "node:fs"
+import path from "node:path"
+
+export interface LiveSession {
+  pid: number
+  sessionId: string
+  cwd: string
+  startedAt: number
+  status: string
+  entrypoint: string
+}
+
+const isLiveSession = (value: Partial<LiveSession>): value is LiveSession => typeof value.pid === "number" && typeof value.sessionId === "string" && typeof value.startedAt === "number" && typeof value.status === "string"
+
+function runsClaude(pid: number) {
+  const result = spawnSync("ps", ["-o", "command=", "-p", String(pid)], { encoding: "utf8" })
+  return result.status === 0 && /claude/i.test(result.stdout)
+}
+
+export function listLiveSessions(configDirs: string[]): LiveSession[] {
+  const live: LiveSession[] = []
+  for (const dir of configDirs) {
+    const sessionsDir = path.join(dir, "sessions")
+    if (!existsSync(sessionsDir)) continue
+    for (const file of readdirSync(sessionsDir).filter((name) => /^\d+\.json$/.test(name))) {
+      try {
+        const session = JSON.parse(readFileSync(path.join(sessionsDir, file), "utf8"))
+        if (isLiveSession(session) && runsClaude(session.pid)) live.push(session)
+      } catch {}
+    }
+  }
+  return live
+}
+
+export function unroutedSessions(live: LiveSession[], lastSeen: Map<string, string>, managed: (sessionId: string) => boolean, self: string | undefined): LiveSession[] {
+  return live.filter((session) => {
+    if (session.sessionId === self || !managed(session.sessionId)) return false
+    const seen = lastSeen.get(session.sessionId)
+    return !seen || Date.parse(seen) < session.startedAt
+  })
+}
+
+export const isIdle = (session: LiveSession) => session.status === "idle"
+
+export const isTerminal = (session: LiveSession) => session.entrypoint === "cli"
+
+export function restartSessions(sessions: LiveSession[]): LiveSession[] {
+  return sessions.filter((session) => {
+    try {
+      process.kill(session.pid, "SIGTERM")
+      return true
+    } catch {
+      return false
+    }
+  })
+}

package/src/cli/proxy/stats.ts

@@ -1,3 +1,5 @@
+import { DEFAULT_RATIO } from "../../proxy/estimate"
+import { NATIVE_SUMMARY_CHARS, REPLAY_NATIVE_COMPACT_AT } from "../replay"
 import type { RequestRecord } from "./inspect"
 
 export interface SessionStats {
@@ -31,6 +33,11 @@ function scaled(record: RequestRecord, chars: number | undefined): number | null
   return input > 0 && charsOut > 0 && chars && chars > 0 ? Math.round((input * chars) / charsOut) : null
 }
 
+export function savedTokens(record: RequestRecord): number | null {
+  const plain = scaled(record, record.charsIn)
+  return plain === null ? null : plain - inputOf(record)
+}
+
 export function withinWindow(records: RequestRecord[], now = Date.now(), window = 24 * 3_600_000): RequestRecord[] {
   return records.filter((record) => now - Date.parse(record.ts) <= window)
 }
@@ -66,10 +73,10 @@ export function totals(records: RequestRecord[]): Totals {
       out.folds += 1
       out.lastFold = record.ts
     }
-    const plain = scaled(record, record.charsIn)
-    if (plain !== null) {
+    const saved = savedTokens(record)
+    if (saved !== null) {
       out.sent += inputOf(record)
-      out.saved += plain - inputOf(record)
+      out.saved += saved
     }
   }
   return out
@@ -79,3 +86,49 @@ export function savedShare(context: number, plain: number | null): number | null
   if (!plain) return null
   return plain > context ? 1 - context / plain : 0
 }
+
+export function nativeCompactions(records: RequestRecord[]): Set<RequestRecord> {
+  const summary = Math.round(NATIVE_SUMMARY_CHARS * DEFAULT_RATIO)
+  const offsets = new Map<string, number>()
+  const compacted = new Set<RequestRecord>()
+  for (const record of records) {
+    const plain = scaled(record, record.charsIn)
+    const window = typeof record.window === "number" ? record.window : 0
+    if (typeof record.thread !== "string" || plain === null || window <= 0) continue
+    if (plain - (offsets.get(record.thread) ?? 0) <= REPLAY_NATIVE_COMPACT_AT * window) continue
+    compacted.add(record)
+    offsets.set(record.thread, plain - (scaled(record, record.charsFixed) ?? 0) - summary)
+  }
+  return compacted
+}
+
+export interface ThreadPeak {
+  thread: string
+  session: string
+  plain: number
+  sent: number
+  turns: number | null
+  compactions: number
+  lastSeen: string
+}
+
+export function threadPeaks(records: RequestRecord[], compacted: Set<RequestRecord>): ThreadPeak[] {
+  const peaks = new Map<string, ThreadPeak>()
+  for (const record of records) {
+    const plain = scaled(record, record.charsIn)
+    const session = sessionOf(record)
+    if (typeof record.thread !== "string" || !session || plain === null) continue
+    const previous = peaks.get(record.thread)
+    const higher = !previous || plain >= previous.plain
+    peaks.set(record.thread, {
+      thread: record.thread,
+      session,
+      plain: higher ? plain : previous.plain,
+      sent: higher ? inputOf(record) : previous.sent,
+      turns: record.turns ?? previous?.turns ?? null,
+      compactions: (previous?.compactions ?? 0) + (compacted.has(record) ? 1 : 0),
+      lastSeen: record.ts,
+    })
+  }
+  return [...peaks.values()].sort((a, b) => b.plain - a.plain)
+}

package/src/cli/replay/index.ts

@@ -36,9 +36,14 @@ export interface ReplayedSession extends Replay {
   ms: number
 }
 
+export interface ReplayFailure {
+  file: string
+  error: string
+}
+
 export const REPLAY_NATIVE_COMPACT_AT = 0.92
 
-const NATIVE_SUMMARY_CHARS = 30_000
+export const NATIVE_SUMMARY_CHARS = 30_000
 const CACHE_READ_WEIGHT = 0.1
 const CACHE_WRITE_WEIGHT = 1.25
 
@@ -80,7 +85,7 @@ export function replaySession(messages: Message[], { config, window, fixedTokens
 
   const state: ThreadState = {}
   const eunoe = { sent: [] as Message[], sum: 0, count: 0, upTo: 0, recall: 0, compactedTurn: -2, previous: 0 }
-  const plain = { sum: 0, count: 0, since: 0, previous: 0 }
+  const plain = { sum: 0, count: 0, since: 0, previous: 0, whole: 0, wholeCount: 0 }
 
   const sendEunoe = (i: number) => {
     const turn = turnAt[i - 1]
@@ -114,10 +119,12 @@ export function replaySession(messages: Message[], { config, window, fixedTokens
     for (; plain.since < i; plain.since += 1) {
       plain.sum += sizes[plain.since]
       plain.count += 1
+      plain.whole += sizes[plain.since]
+      plain.wholeCount += 1
     }
+    out.peakPlain = Math.max(out.peakPlain, tokens(fixedChars + listChars(plain.whole, plain.wholeCount)))
     let chars = fixedChars + listChars(plain.sum, plain.count)
     let cacheable = plain.previous
-    out.peakPlain = Math.max(out.peakPlain, tokens(chars))
     if (tokens(chars) > REPLAY_NATIVE_COMPACT_AT * window) {
       out.nativeCompactions += 1
       out.discarded += tokens(chars - fixedChars)

package/src/cli/replay/worker.ts

@@ -2,14 +2,19 @@ import { statSync } from "node:fs"
 import { basename } from "node:path"
 import { cwdOf, titleOf } from "../../proxy/sessions"
 import { sessionMessages } from "../../transcript/messages"
-import { type ReplayedSession, type ReplayOptions, replaySession } from "."
+import { type ReplayedSession, type ReplayFailure, type ReplayOptions, replaySession } from "."
 
 declare var self: Worker
 
 self.onmessage = (event: MessageEvent<{ file: string; options: ReplayOptions }>) => {
   const { file, options } = event.data
   const started = performance.now()
-  const replay = replaySession(sessionMessages(file), options)
-  const done: ReplayedSession = { ...replay, id: basename(file, ".jsonl"), file, bytes: statSync(file).size, cwd: cwdOf(file) ?? null, title: titleOf(file) ?? null, ms: Math.round(performance.now() - started) }
-  postMessage(done)
+  try {
+    const replay = replaySession(sessionMessages(file), options)
+    const done: ReplayedSession = { ...replay, id: basename(file, ".jsonl"), file, bytes: statSync(file).size, cwd: cwdOf(file) ?? null, title: titleOf(file) ?? null, ms: Math.round(performance.now() - started) }
+    postMessage(done)
+  } catch (error) {
+    const failed: ReplayFailure = { file, error: String(error) }
+    postMessage(failed)
+  }
 }

package/src/cli/usage/index.ts

@@ -0,0 +1,151 @@
+import { readFileSync, statSync } from "node:fs"
+import path from "node:path"
+import { listEntries, projectFolders } from "../../transcript/locate"
+import { subagentsDir } from "../../transcript/subagents"
+
+export interface UsageEntry {
+  at: number
+  model: string
+  input: number
+  output: number
+  cacheWrite5m: number
+  cacheWrite1h: number
+  cacheRead: number
+  fast: boolean
+}
+
+interface Price {
+  input: number
+  output: number
+  cacheRead: number
+}
+
+interface RawUsage {
+  input_tokens?: number
+  output_tokens?: number
+  cache_creation_input_tokens?: number
+  cache_read_input_tokens?: number
+  cache_creation?: { ephemeral_5m_input_tokens?: number; ephemeral_1h_input_tokens?: number }
+  service_tier?: string
+  speed?: string
+}
+
+interface RawLine {
+  timestamp?: string
+  requestId?: string
+  message?: { id?: string; model?: string; usage?: RawUsage }
+}
+
+const PRICES: Array<[prefix: string, price: Price]> = [
+  ["claude-fable-5-1", { input: 10, output: 50, cacheRead: 0.25 }],
+  ["claude-mythos-5-1", { input: 10, output: 50, cacheRead: 0.25 }],
+  ["claude-fable-5", { input: 10, output: 50, cacheRead: 1 }],
+  ["claude-mythos-5", { input: 10, output: 50, cacheRead: 1 }],
+  ["claude-opus-5-5", { input: 4, output: 20, cacheRead: 0.2 }],
+  ["claude-opus-5", { input: 5, output: 25, cacheRead: 0.5 }],
+  ["claude-opus-4-8", { input: 5, output: 25, cacheRead: 0.5 }],
+  ["claude-opus-4-7", { input: 5, output: 25, cacheRead: 0.5 }],
+  ["claude-opus-4-6", { input: 5, output: 25, cacheRead: 0.5 }],
+  ["claude-opus-4-5", { input: 5, output: 25, cacheRead: 0.5 }],
+  ["claude-sonnet-5-5", { input: 2, output: 10, cacheRead: 0.2 }],
+  ["claude-sonnet-5", { input: 2, output: 10, cacheRead: 0.2 }],
+  ["claude-sonnet-4", { input: 3, output: 15, cacheRead: 0.3 }],
+  ["claude-haiku-4-5", { input: 1, output: 5, cacheRead: 0.1 }],
+]
+
+const CACHE_WRITE_5M = 1.25
+const CACHE_WRITE_1H = 2
+const FAST_MULTIPLIER = 2
+const PLACEHOLDER_INPUT = 1000
+
+const priceFor = (model: string) => PRICES.find(([prefix]) => model === prefix || model.startsWith(`${prefix}-`))?.[1] ?? null
+
+export function ratesOf(entry: UsageEntry): { read: number; write: number } | null {
+  const price = priceFor(entry.model)
+  if (!price) return null
+  const writes = entry.cacheWrite5m + entry.cacheWrite1h
+  const writeShare = writes > 0 ? (entry.cacheWrite5m * CACHE_WRITE_5M + entry.cacheWrite1h * CACHE_WRITE_1H) / writes : CACHE_WRITE_1H
+  const scale = (entry.fast ? FAST_MULTIPLIER : 1) / 1e6
+  return { read: price.cacheRead * scale, write: price.input * writeShare * scale }
+}
+
+export function costOf(entry: UsageEntry): number | null {
+  const price = priceFor(entry.model)
+  if (!price) return null
+  const dollars = entry.input * price.input + entry.output * price.output + entry.cacheRead * price.cacheRead + entry.cacheWrite5m * price.input * CACHE_WRITE_5M + entry.cacheWrite1h * price.input * CACHE_WRITE_1H
+  return (dollars / 1e6) * (entry.fast ? FAST_MULTIPLIER : 1)
+}
+
+const fromApi = (usage: RawUsage) => usage.service_tier !== undefined
+
+const isPlaceholder = (usage: RawUsage) => !fromApi(usage) && usage.input_tokens === PLACEHOLDER_INPUT && !usage.cache_read_input_tokens && !usage.cache_creation_input_tokens
+
+const supersedes = (next: RawUsage, known: RawUsage) =>
+  fromApi(next) !== fromApi(known)
+    ? fromApi(next)
+    : (next.output_tokens ?? 0) > (known.output_tokens ?? 0) || ((next.output_tokens ?? 0) === (known.output_tokens ?? 0) && (next.cache_creation_input_tokens ?? 0) > (known.cache_creation_input_tokens ?? 0))
+
+function entryOf(line: RawLine, usage: RawUsage, at: number): UsageEntry {
+  const written = usage.cache_creation_input_tokens ?? 0
+  const hour = Math.min(written, usage.cache_creation?.ephemeral_1h_input_tokens ?? 0)
+  return {
+    at,
+    model: line.message?.model ?? "unknown",
+    input: usage.input_tokens ?? 0,
+    output: usage.output_tokens ?? 0,
+    cacheWrite5m: written - hour,
+    cacheWrite1h: hour,
+    cacheRead: usage.cache_read_input_tokens ?? 0,
+    fast: usage.speed === "fast",
+  }
+}
+
+export function usageFiles(configDirs: string[], since: number): string[] {
+  const files: string[] = []
+  const recent = (file: string) => {
+    try {
+      return statSync(file).mtimeMs >= since
+    } catch {
+      return false
+    }
+  }
+  for (const folder of projectFolders(configDirs)) {
+    for (const name of listEntries(folder)) {
+      if (!name.endsWith(".jsonl")) continue
+      const file = path.join(folder, name)
+      if (recent(file)) files.push(file)
+      const subagents = subagentsDir(file)
+      for (const agent of listEntries(subagents)) if (agent.endsWith(".jsonl") && recent(path.join(subagents, agent))) files.push(path.join(subagents, agent))
+    }
+  }
+  return files.sort()
+}
+
+export function readUsage(files: string[], since: number): UsageEntry[] {
+  const seen = new Map<string, { usage: RawUsage; entry: UsageEntry }>()
+  for (const file of files) {
+    let text: string
+    try {
+      text = readFileSync(file, "utf8")
+    } catch {
+      continue
+    }
+    for (const [index, raw] of text.split("\n").entries()) {
+      if (!raw.includes('"usage"')) continue
+      let line: RawLine
+      try {
+        line = JSON.parse(raw)
+      } catch {
+        continue
+      }
+      const usage = line.message?.usage
+      const at = Date.parse(line.timestamp ?? "")
+      if (!usage || !(at >= since) || line.message?.model === "<synthetic>") continue
+      const key = line.message?.id ? `${line.message.id}:${line.requestId ?? ""}` : `${file}:${index}`
+      const known = seen.get(key)
+      if (known && !supersedes(usage, known.usage)) continue
+      seen.set(key, { usage, entry: entryOf(line, usage, at) })
+    }
+  }
+  return [...seen.values()].filter(({ usage }) => !isPlaceholder(usage)).map(({ entry }) => entry)
+}