modelmeter-collect 0.4.0 → 0.6.0

package/README.md

@@ -28,6 +28,22 @@ MODELMETER_DRYRUN=1 npx modelmeter-collect
 `init` writes `~/.modelmeter/config.json` (chmod 600) with your token and the ingest URL.
 Prefer env vars? Set `MODELMETER_TOKEN` and `MODELMETER_INGEST_URL` and skip `init`.
 
+## Check your setup
+
+```bash
+npx modelmeter-collect doctor                  # which logs were found, last activity, config
+npx modelmeter-collect doctor --recommendations # local optimization tips from your logs
+npx modelmeter-collect doctor --payload        # + the exact JSON that would be sent
+```
+
+`doctor` confirms it found your Claude Code and Codex logs and shows precisely what leaves
+your machine: model names, token counts, and tool/MCP names only. Never prompts or keys.
+
+`doctor --recommendations` scores your recent sessions locally (nothing is sent) and prints
+optimization tips: cache reuse, a dominant MCP server, output verbosity, and context bloat
+(a session whose per-turn context kept growing). All computed from token counts, never your
+prompt text.
+
 ## Keep it live (per prompt)
 
 **Claude Code** — add a `Stop` hook (fires after every response). It passes the session
@@ -71,6 +87,7 @@ does the same job.)
 | --- | --- | --- |
 | `MODELMETER_TOKEN` | from config file | Your `mm_live_...` ingest token |
 | `MODELMETER_INGEST_URL` | from config file | The ingest endpoint |
+| `MODELMETER_HOURLY_INGEST_URL` | derived from ingest URL | Detail endpoint for recent hourly/tool rows |
 | `MODELMETER_LOOKBACK_DAYS` | `14` | How many days of logs to scan |
 | `MODELMETER_DRYRUN` | unset | When set, print the payload instead of sending |
 

package/cli.mjs

@@ -6,10 +6,24 @@
 //   npx modelmeter-collect init <mm_live_token>   # one-time: save the token
 //   npx modelmeter-collect                          # scan local logs and report
 //   MODELMETER_DRYRUN=1 npx modelmeter-collect      # preview without sending
-import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from 'node:fs'
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync,
+  chmodSync,
+  readdirSync,
+  statSync,
+} from 'node:fs'
 import { homedir } from 'node:os'
 import { join, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import {
+  formatDoctorReport,
+  claudeSessionSummary,
+  codexSessionSummary,
+  buildLocalRecommendations,
+} from './lib.mjs'
 
 const HOME = homedir()
 const MM_DIR = join(HOME, '.modelmeter')
@@ -47,12 +61,17 @@ function printHelp() {
 
 Usage:
   npx modelmeter-collect init <token> [--url <ingest-url>]
+  npx modelmeter-collect doctor [--payload]
   npx modelmeter-collect                 scan local logs and report
   npx modelmeter-collect --help
 
 Commands:
   init    Save your ingest token to ~/.modelmeter/config.json (chmod 600).
           Pass the token as an argument or via MODELMETER_TOKEN.
+  doctor  Check your setup: which logs were found, last activity, config
+          status, and exactly what would be sent. Add --recommendations for
+          local optimization tips (cache, MCP, output, context bloat), or
+          --payload for the raw JSON (token counts only, never transcript text).
   (none)  Scan Claude Code + Codex logs and report token counts. Deduped,
           so it is safe to run repeatedly. MODELMETER_DRYRUN=1 previews only.
 
@@ -93,5 +112,142 @@ if (cmd === 'init' || cmd === 'setup') {
   process.exit(0)
 }
 
+// Count .jsonl session files (recent + newest mtime) under a logs directory.
+function discoverLogs(dir, cutoffMs) {
+  try {
+    statSync(dir)
+  } catch {
+    return { dir, found: false }
+  }
+  let recentCount = 0
+  let lastWriteMs = 0
+  const stack = [dir]
+  while (stack.length) {
+    const d = stack.pop()
+    let entries = []
+    try {
+      entries = readdirSync(d, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const e of entries) {
+      const p = join(d, e.name)
+      if (e.isDirectory()) stack.push(p)
+      else if (e.isFile() && p.endsWith('.jsonl')) {
+        let m = 0
+        try {
+          m = statSync(p).mtimeMs
+        } catch {
+          continue
+        }
+        if (m > lastWriteMs) lastWriteMs = m
+        if (m >= cutoffMs) recentCount++
+      }
+    }
+  }
+  return { dir, found: true, recentCount, lastWriteMs }
+}
+
+// Recent .jsonl session file paths under a logs directory, newest first, capped.
+function recentSessionFiles(dir, cutoffMs, limit) {
+  try {
+    statSync(dir)
+  } catch {
+    return []
+  }
+  const out = []
+  const stack = [dir]
+  while (stack.length) {
+    const d = stack.pop()
+    let entries = []
+    try {
+      entries = readdirSync(d, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const e of entries) {
+      const p = join(d, e.name)
+      if (e.isDirectory()) stack.push(p)
+      else if (e.isFile() && p.endsWith('.jsonl')) {
+        let m = 0
+        try {
+          m = statSync(p).mtimeMs
+        } catch {
+          continue
+        }
+        if (m >= cutoffMs) out.push({ p, m })
+      }
+    }
+  }
+  return out
+    .sort((a, b) => b.m - a.m)
+    .slice(0, limit)
+    .map((x) => x.p)
+}
+
+function printRecommendations(cutoffMs) {
+  const summaries = []
+  const sources = [
+    [join(HOME, '.claude', 'projects'), claudeSessionSummary],
+    [join(HOME, '.codex', 'sessions'), codexSessionSummary],
+  ]
+  for (const [dir, summarize] of sources) {
+    for (const file of recentSessionFiles(dir, cutoffMs, 200)) {
+      let text = ''
+      try {
+        text = readFileSync(file, 'utf8')
+      } catch {
+        continue
+      }
+      const summary = summarize(text)
+      if (summary) summaries.push(summary)
+    }
+  }
+  console.log('\nLocal recommendations (computed from your logs, nothing sent):')
+  const recs = buildLocalRecommendations(summaries)
+  if (recs.length === 0) {
+    console.log('  Nothing flagged. Your recent usage looks efficient.')
+    return
+  }
+  for (const r of recs) {
+    const mark = r.level === 'warn' ? '!' : r.level === 'ok' ? '+' : '-'
+    console.log(`  ${mark} ${r.text}`)
+  }
+}
+
+if (cmd === 'doctor') {
+  const cfg = readConfig()
+  const lookbackDays = 14
+  const nowMs = Date.now()
+  const cutoffMs = nowMs - lookbackDays * 86_400_000
+  console.log(
+    formatDoctorReport({
+      configPath: CONFIG_PATH,
+      configFound: existsSync(CONFIG_PATH),
+      token: process.env.MODELMETER_TOKEN || cfg.token,
+      ingestUrl: process.env.MODELMETER_INGEST_URL || cfg.ingestUrl,
+      lookbackDays,
+      nowMs,
+      claude: discoverLogs(join(HOME, '.claude', 'projects'), cutoffMs),
+      codex: discoverLogs(join(HOME, '.codex', 'sessions'), cutoffMs),
+    }),
+  )
+  if (args.includes('--recommendations')) {
+    printRecommendations(cutoffMs)
+    process.exit(0)
+  }
+  if (args.includes('--payload')) {
+    console.log('\nNext batch (dry run, nothing is sent):')
+    process.env.MODELMETER_DRYRUN = '1'
+    await runCollector() // prints the exact payload (counts only), then exits
+  } else {
+    console.log(
+      '\nRun `npx modelmeter-collect doctor --recommendations` for local optimization tips, or',
+    )
+    console.log('`doctor --payload` to preview the exact JSON that would be sent.')
+    process.exit(0)
+  }
+}
+
 // Default: scan and report.
 await runCollector()

package/collect.mjs

@@ -9,15 +9,50 @@
 //
 // Config: MODELMETER_TOKEN + MODELMETER_INGEST_URL from env, or ~/.modelmeter/config.json
 //   { "token": "mm_live_...", "ingestUrl": "https://<ref>.supabase.co/functions/v1/ingest" }
-import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync, readdirSync } from 'node:fs'
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync,
+  statSync,
+  readdirSync,
+  chmodSync,
+} from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
+import {
+  findLastTokenCount,
+  codexToolFromEvent,
+  deriveHourlyUrl,
+  claudeEventFromLine,
+  codexDelta,
+  aggregateDaily,
+  aggregateHourly,
+  aggregateTools,
+  pruneClaudeState,
+  mergeDetailBatches,
+} from './lib.mjs'
 
 const HOME = homedir()
 const MM_DIR = join(HOME, '.modelmeter')
 const STATE_PATH = join(MM_DIR, 'collector-state.json')
 const CONFIG_PATH = join(MM_DIR, 'config.json')
-const LOOKBACK_DAYS = Number(process.env.MODELMETER_LOOKBACK_DAYS) || 14
+// Clamp the lookback to a sane range so a bad env var cannot scan nothing
+// (negative) or traverse months of logs (huge).
+const RAW_LOOKBACK = Number(process.env.MODELMETER_LOOKBACK_DAYS)
+const LOOKBACK_DAYS =
+  Number.isFinite(RAW_LOOKBACK) && RAW_LOOKBACK > 0 ? Math.min(RAW_LOOKBACK, 90) : 14
+if (
+  process.env.MODELMETER_LOOKBACK_DAYS !== undefined &&
+  (!Number.isFinite(RAW_LOOKBACK) || RAW_LOOKBACK <= 0 || RAW_LOOKBACK > 90)
+) {
+  console.error(`modelmeter: MODELMETER_LOOKBACK_DAYS out of range, using ${LOOKBACK_DAYS}`)
+}
+
+const FETCH_TIMEOUT_MS = 8000
+// Cap the per-message dedup set so the state file cannot grow without bound. Older
+// entries fall out of the lookback window, so dropping them is safe.
+const CLAUDE_STATE_CAP = 200_000
 
 let cfg = {}
 try {
@@ -29,13 +64,46 @@ const TOKEN = process.env.MODELMETER_TOKEN || cfg.token
 const INGEST_URL = process.env.MODELMETER_INGEST_URL || cfg.ingestUrl
 if (!TOKEN || !INGEST_URL) process.exit(0) // not configured: do nothing, never block
 
-let state = { claude: {}, codex: {} }
+// POST JSON with a hard timeout so a stuck network path can never hang a Stop
+// hook or pile up scheduled collectors. Callers handle the thrown abort/error.
+async function postJson(url, body) {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS)
+  try {
+    return await fetch(url, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    })
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+let state = { claude: {}, codex: {}, pendingDetail: { hours: [], tools: [] } }
 try {
-  state = { claude: {}, codex: {}, ...JSON.parse(readFileSync(STATE_PATH, 'utf8')) }
+  state = {
+    claude: {},
+    codex: {},
+    pendingDetail: { hours: [], tools: [] },
+    ...JSON.parse(readFileSync(STATE_PATH, 'utf8')),
+  }
 } catch {
   // first run
 }
 
+function saveState() {
+  if (!existsSync(MM_DIR)) mkdirSync(MM_DIR, { recursive: true })
+  state.claude = pruneClaudeState(state.claude, CLAUDE_STATE_CAP)
+  writeFileSync(STATE_PATH, JSON.stringify(state))
+  try {
+    chmodSync(STATE_PATH, 0o600) // usage metadata is not secret, but keep it owner-only
+  } catch {
+    // best effort on platforms without POSIX perms
+  }
+}
+
 // --- invocation detection -------------------------------------------------
 let hookInput = null
 if (!process.stdin.isTTY) {
@@ -107,59 +175,15 @@ function scanClaude(files) {
       } catch {
         continue
       }
-      const msg = o.message
-      if (!msg || msg.role !== 'assistant' || !msg.usage) continue
-      const id = o.uuid || `${o.timestamp ?? ''}:${msg.id ?? ''}`
-      if (!id || state.claude[id]) continue
-      state.claude[id] = 1
-      const u = msg.usage
-      const toolNames = Array.isArray(msg.content)
-        ? msg.content.filter((b) => b && b.type === 'tool_use').map((b) => b.name).filter(Boolean)
-        : []
-      events.push({
-        provider: 'anthropic',
-        model: msg.model || 'claude-unknown',
-        occurredOn: (o.timestamp || '').slice(0, 10) || undefined,
-        occurredAt: o.timestamp || undefined,
-        tools: toolNames,
-        uncachedInputTokens: u.input_tokens || 0,
-        cacheReadInputTokens: u.cache_read_input_tokens || 0,
-        cacheCreationInputTokens: u.cache_creation_input_tokens || 0,
-        outputTokens: u.output_tokens || 0,
-        numRequests: 1,
-      })
+      const ev = claudeEventFromLine(o)
+      if (!ev || !ev.id || state.claude[ev.id]) continue
+      state.claude[ev.id] = { ts: ev.occurredAt || ev.occurredOn || '' }
+      events.push(ev)
     }
   }
 }
 
 // --- Codex: cumulative token_count events; report per-session delta.
-function findLastTokenCount(obj) {
-  let last = null
-  const stack = [obj]
-  while (stack.length) {
-    const d = stack.pop()
-    if (Array.isArray(d)) stack.push(...d)
-    else if (d && typeof d === 'object') {
-      if (d.type === 'token_count' && d.info?.total_token_usage) last = d.info.total_token_usage
-      for (const v of Object.values(d)) stack.push(v)
-    }
-  }
-  return last
-}
-// Codex tool names are plain (exec_command, apply_patch, ...); MCP calls carry an
-// invocation with a server name. Returns a group key, or null if not a tool call.
-function codexToolFromEvent(payload, ptype) {
-  if (ptype === 'function_call' || ptype === 'custom_tool_call') {
-    return typeof payload.name === 'string' && payload.name ? payload.name : null
-  }
-  if (ptype === 'mcp_tool_call_end' || ptype === 'mcp_tool_call_begin') {
-    const inv = payload.invocation || {}
-    const server = inv.server || inv.server_name
-    return server ? `mcp:${server}` : 'mcp'
-  }
-  return null
-}
-
 function scanCodex(files) {
   for (const file of files) {
     const m = file.match(/rollout-(\d{4}-\d{2}-\d{2})T[\d-]+-([0-9a-f-]+)\.jsonl$/)
@@ -198,49 +222,14 @@ function scanCodex(files) {
       const g = codexToolFromEvent(p, ptype)
       if (g) toolCalls.push({ ts: ts || totalsTs || '', group: g })
     }
-    if (!totals) continue
-    const stored = state.codex[sessionId]
-    const prevTotal =
-      (stored && stored.total) ||
-      (stored && stored.input_tokens != null ? stored : null) || {
-        input_tokens: 0,
-        cached_input_tokens: 0,
-        output_tokens: 0,
-        reasoning_output_tokens: 0,
-      }
-    const prevLastTs = (stored && stored.lastTs) || ''
-    const dInput = Math.max(0, (totals.input_tokens || 0) - prevTotal.input_tokens)
-    const dCached = Math.max(0, (totals.cached_input_tokens || 0) - prevTotal.cached_input_tokens)
-    const dOut = Math.max(0, (totals.output_tokens || 0) - prevTotal.output_tokens)
-    const dReason = Math.max(0, (totals.reasoning_output_tokens || 0) - prevTotal.reasoning_output_tokens)
-    const newTotalTokens = Math.max(0, dInput - dCached) + dCached + (dOut + dReason)
-    if (dInput + dCached + dOut + dReason > 0) {
-      const occurredOn = (totalsTs || '').slice(0, 10) || m[1]
-      events.push({
-        provider: 'openai',
-        model,
-        occurredOn,
-        occurredAt: totalsTs || undefined, // enables the 5-hour window for Codex
-        uncachedInputTokens: Math.max(0, dInput - dCached),
-        cacheReadInputTokens: dCached,
-        cacheCreationInputTokens: 0,
-        outputTokens: dOut + dReason, // reasoning tokens bill as output
-        numRequests: 1,
-      })
-      // Tool calls new since the last run; even-split this run's new tokens across them.
-      const newCalls = toolCalls.filter((c) => c.ts && c.ts > prevLastTs)
-      if (newCalls.length > 0 && newTotalTokens > 0) {
-        const share = Math.round(newTotalTokens / newCalls.length)
-        for (const c of newCalls) {
-          codexToolDeltas.push({
-            tool: c.group,
-            bucketDate: (c.ts || '').slice(0, 10) || occurredOn,
-            calls: 1,
-            tokens: share,
-          })
-        }
-      }
-      state.codex[sessionId] = { total: totals, lastTs: maxTs }
+    const { event, toolDeltas, state: nextState } = codexDelta(
+      { totals, totalsTs, maxTs, model, fileDate: m[1], toolCalls },
+      state.codex[sessionId],
+    )
+    if (event) {
+      events.push(event)
+      for (const d of toolDeltas) codexToolDeltas.push(d)
+      state.codex[sessionId] = nextState
     }
   }
 }
@@ -255,108 +244,22 @@ if (hookInput?.transcript_path) {
 }
 
 // Collapse to one row per (provider, model, day) so the request stays small.
-const byKey = new Map()
-for (const e of events) {
-  const date = e.occurredOn || new Date().toISOString().slice(0, 10)
-  const key = `${e.provider}|${e.model}|${date}`
-  const cur = byKey.get(key) || {
-    provider: e.provider,
-    model: e.model,
-    occurredOn: date,
-    uncachedInputTokens: 0,
-    cacheReadInputTokens: 0,
-    cacheCreationInputTokens: 0,
-    outputTokens: 0,
-    numRequests: 0,
-  }
-  cur.uncachedInputTokens += e.uncachedInputTokens || 0
-  cur.cacheReadInputTokens += e.cacheReadInputTokens || 0
-  cur.cacheCreationInputTokens += e.cacheCreationInputTokens || 0
-  cur.outputTokens += e.outputTokens || 0
-  cur.numRequests += e.numRequests || 1
-  byKey.set(key, cur)
-}
-const payload = [...byKey.values()]
+const today = new Date().toISOString().slice(0, 10)
+const payload = aggregateDaily(events, today)
 
-// Recent hourly buckets feed the 5-hour rolling window via a separate, additive
-// endpoint. Only events with a real timestamp in the last 8 hours qualify, so a
-// backfill scan never pollutes the recent window. (Codex deltas lack per-event
-// timestamps, so the 5-hour window is Claude Code for now.)
-const HOUR_MS = 3_600_000
-const recentCutoff = Date.now() - 8 * HOUR_MS
-const byHour = new Map()
-for (const e of events) {
-  if (!e.occurredAt) continue
-  const t = new Date(e.occurredAt).getTime()
-  if (Number.isNaN(t) || t < recentCutoff) continue
-  const d = new Date(t)
-  d.setMinutes(0, 0, 0)
-  const hourIso = d.toISOString()
-  const key = `${e.provider}|${e.model}|${hourIso}`
-  const cur = byHour.get(key) || {
-    provider: e.provider,
-    model: e.model,
-    bucketHour: hourIso,
-    uncachedInputTokens: 0,
-    cacheReadInputTokens: 0,
-    cacheCreationInputTokens: 0,
-    outputTokens: 0,
-    numRequests: 0,
-  }
-  cur.uncachedInputTokens += e.uncachedInputTokens || 0
-  cur.cacheReadInputTokens += e.cacheReadInputTokens || 0
-  cur.cacheCreationInputTokens += e.cacheCreationInputTokens || 0
-  cur.outputTokens += e.outputTokens || 0
-  cur.numRequests += e.numRequests || 1
-  byHour.set(key, cur)
-}
-const hourly = [...byHour.values()]
-const HOURLY_URL = INGEST_URL.replace(/\/ingest$/, '/ingest-hourly')
+// Recent hourly buckets (last 8h, timestamped events only) feed the 5-hour rolling
+// window via a separate, additive endpoint, so a backfill cannot pollute it.
+const hourly = aggregateHourly(events, Date.now())
+const HOURLY_URL = deriveHourlyUrl(INGEST_URL, process.env.MODELMETER_HOURLY_INGEST_URL)
 
-// Per-tool / per-MCP attribution. Group MCP tools by server (mcp__server__tool ->
-// mcp:server) and keep built-ins by name. Calls are exact; tokens are an even
-// split of each turn's usage across the distinct tool groups it called.
-function toolGroup(name) {
-  if (typeof name !== 'string' || !name) return 'unknown'
-  if (name.startsWith('mcp__')) {
-    const parts = name.split('__')
-    return parts[1] ? `mcp:${parts[1]}` : 'mcp:unknown'
-  }
-  return name
-}
-const byTool = new Map()
-for (const e of events) {
-  if (!Array.isArray(e.tools) || e.tools.length === 0) continue
-  const date = e.occurredOn || new Date().toISOString().slice(0, 10)
-  const callsByGroup = new Map()
-  for (const name of e.tools) {
-    const g = toolGroup(name)
-    callsByGroup.set(g, (callsByGroup.get(g) || 0) + 1)
-  }
-  const eventTokens =
-    (e.uncachedInputTokens || 0) +
-    (e.cacheReadInputTokens || 0) +
-    (e.cacheCreationInputTokens || 0) +
-    (e.outputTokens || 0)
-  const tokenShare = Math.round(eventTokens / callsByGroup.size)
-  for (const [g, calls] of callsByGroup) {
-    const key = `${g}|${date}`
-    const cur = byTool.get(key) || { tool: g, bucketDate: date, calls: 0, tokens: 0 }
-    cur.calls += calls
-    cur.tokens += tokenShare
-    byTool.set(key, cur)
-  }
-}
-for (const d of codexToolDeltas) {
-  const key = `${d.tool}|${d.bucketDate}`
-  const cur = byTool.get(key) || { tool: d.tool, bucketDate: d.bucketDate, calls: 0, tokens: 0 }
-  cur.calls += d.calls
-  cur.tokens += d.tokens
-  byTool.set(key, cur)
-}
-const toolsPayload = [...byTool.values()]
+// Per-tool / per-MCP attribution. Claude even-splits each turn's tokens across the
+// tools it called; Codex contributes precomputed deltas. Calls are exact.
+const toolsPayload = aggregateTools(events, codexToolDeltas, today)
+const currentDetail = { hours: hourly, tools: toolsPayload }
+const detailBatch = mergeDetailBatches(state.pendingDetail, currentDetail)
+const hasDetail = detailBatch.hours.length > 0 || detailBatch.tools.length > 0
 
-if (payload.length === 0) {
+if (payload.length === 0 && !hasDetail) {
   process.exit(0)
 }
 
@@ -365,41 +268,56 @@ if (process.env.MODELMETER_DRYRUN) {
   for (const e of events) tally[e.provider] = (tally[e.provider] || 0) + 1
   console.log(`DRY RUN: ${events.length} raw events -> ${payload.length} daily rows`, tally)
   console.log(`         + ${hourly.length} recent hourly rows, ${toolsPayload.length} tool rows -> ${HOURLY_URL}`)
+  if (state.pendingDetail?.hours?.length || state.pendingDetail?.tools?.length) {
+    console.log(
+      `         + pending retry rows: ${state.pendingDetail.hours?.length || 0} hourly, ${state.pendingDetail.tools?.length || 0} tool`,
+    )
+  }
   console.log(JSON.stringify(payload, null, 2))
   if (toolsPayload.length) console.log('tools:', JSON.stringify(toolsPayload, null, 2))
   process.exit(0)
 }
 
 let committed = false
-try {
-  const res = await fetch(INGEST_URL, {
-    method: 'POST',
-    headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
-    body: JSON.stringify({ source: 'collector', events: payload }),
-  })
-  if (res.ok) {
-    if (!existsSync(MM_DIR)) mkdirSync(MM_DIR, { recursive: true })
-    writeFileSync(STATE_PATH, JSON.stringify(state))
-    committed = true
-    console.error(`modelmeter: reported ${payload.length} usage rows`)
-  } else {
-    console.error(`modelmeter: ingest returned ${res.status}`)
+if (payload.length > 0) {
+  try {
+    const res = await postJson(INGEST_URL, { source: 'collector', events: payload })
+    if (res.ok) {
+      saveState()
+      committed = true
+      console.error(`modelmeter: reported ${payload.length} usage rows`)
+    } else {
+      console.error(`modelmeter: ingest returned ${res.status}`)
+    }
+  } catch (err) {
+    console.error(`modelmeter: ${err.message}`)
   }
-} catch (err) {
-  console.error(`modelmeter: ${err.message}`)
+} else {
+  committed = true // retrying previously committed detail rows
 }
 
-// Additive + best-effort: only after the daily batch is committed (state written),
-// so a retry cannot double-count into the hourly window.
-if (committed && (hourly.length > 0 || toolsPayload.length > 0)) {
-  try {
-    await fetch(HOURLY_URL, {
-      method: 'POST',
-      headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ source: 'collector', hours: hourly, tools: toolsPayload }),
-    })
-  } catch {
-    // detail (hourly + per-tool) is best-effort; never block the collector on it
+// Additive detail rows are sent only after daily usage is committed. If the detail
+// endpoint fails, keep the merged batch in state and retry on the next run.
+if (committed && hasDetail) {
+  if (!HOURLY_URL) {
+    state.pendingDetail = detailBatch
+    saveState()
+    console.error('modelmeter: detail ingest URL could not be derived; set MODELMETER_HOURLY_INGEST_URL')
+    process.exit(0)
+  }
+  let detailSent = false
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const res = await postJson(HOURLY_URL, { source: 'collector', ...detailBatch })
+      if (res.ok) {
+        detailSent = true
+        break
+      }
+    } catch {
+      // fall through to one retry, then give up
+    }
   }
+  state.pendingDetail = detailSent ? { hours: [], tools: [] } : detailBatch
+  saveState()
 }
 process.exit(0)

package/lib.mjs

@@ -0,0 +1,503 @@
+// Pure, unit-tested core of the collector. All file I/O, networking, and state
+// persistence live in collect.mjs; everything here is deterministic given its
+// inputs, so it can be fixture-tested (see lib.test.mjs).
+
+// Group a Claude tool name: MCP tools (mcp__server__tool) collapse to mcp:server,
+// built-ins keep their name.
+export function toolGroup(name) {
+  if (typeof name !== 'string' || !name) return 'unknown'
+  if (name.startsWith('mcp__')) {
+    const parts = name.split('__')
+    return parts[1] ? `mcp:${parts[1]}` : 'mcp:unknown'
+  }
+  return name
+}
+
+// Group a Codex tool event. Built-in calls carry a plain name; MCP calls carry an
+// invocation with a server. Returns a group key, or null if it is not a tool call.
+export function codexToolFromEvent(payload, ptype) {
+  if (ptype === 'function_call' || ptype === 'custom_tool_call') {
+    return typeof payload.name === 'string' && payload.name ? payload.name : null
+  }
+  if (ptype === 'mcp_tool_call_end' || ptype === 'mcp_tool_call_begin') {
+    const inv = payload.invocation || {}
+    const server = inv.server || inv.server_name
+    return server ? `mcp:${server}` : 'mcp'
+  }
+  return null
+}
+
+// Depth-first find of the last token_count usage block in a Codex line.
+export function findLastTokenCount(obj) {
+  let last = null
+  const stack = [obj]
+  while (stack.length) {
+    const d = stack.pop()
+    if (Array.isArray(d)) stack.push(...d)
+    else if (d && typeof d === 'object') {
+      if (d.type === 'token_count' && d.info?.total_token_usage) last = d.info.total_token_usage
+      for (const v of Object.values(d)) stack.push(v)
+    }
+  }
+  return last
+}
+
+// Detail endpoint from the ingest URL, tolerating a trailing slash, or an override.
+export function deriveHourlyUrl(ingestUrl, override) {
+  if (override) return override
+  try {
+    const u = new URL(ingestUrl)
+    u.pathname = u.pathname.replace(/\/ingest\/?$/, '/ingest-hourly')
+    return u.toString()
+  } catch {
+    return ingestUrl.replace(/\/ingest\/?$/, '/ingest-hourly')
+  }
+}
+
+// Build an event from one parsed Claude transcript line, or null if it is not an
+// assistant message with usage. Carries an `id` for the caller to dedup on.
+export function claudeEventFromLine(o) {
+  const msg = o && o.message
+  if (!msg || msg.role !== 'assistant' || !msg.usage) return null
+  const u = msg.usage
+  const tools = Array.isArray(msg.content)
+    ? msg.content
+        .filter((b) => b && b.type === 'tool_use')
+        .map((b) => b.name)
+        .filter(Boolean)
+    : []
+  return {
+    id: o.uuid || `${o.timestamp ?? ''}:${msg.id ?? ''}`,
+    provider: 'anthropic',
+    model: msg.model || 'claude-unknown',
+    occurredOn: (o.timestamp || '').slice(0, 10) || undefined,
+    occurredAt: o.timestamp || undefined,
+    tools,
+    uncachedInputTokens: u.input_tokens || 0,
+    cacheReadInputTokens: u.cache_read_input_tokens || 0,
+    cacheCreationInputTokens: u.cache_creation_input_tokens || 0,
+    outputTokens: u.output_tokens || 0,
+    numRequests: 1,
+  }
+}
+
+// Codex cumulative-delta + tool attribution. Given what a session walk collected and
+// the previous session state, returns the new event (or null), the tool deltas, and
+// the next state. Tool calls are only attributed up to the token-accounted watermark
+// (totalsTs), so calls after the latest token_count are left for the next run.
+export function codexDelta({ totals, totalsTs, maxTs, model, fileDate, toolCalls }, prev) {
+  if (!totals) return { event: null, toolDeltas: [], state: prev ?? null }
+  const prevTotal =
+    (prev && prev.total) ||
+    (prev && prev.input_tokens != null ? prev : null) || {
+      input_tokens: 0,
+      cached_input_tokens: 0,
+      output_tokens: 0,
+      reasoning_output_tokens: 0,
+    }
+  const prevLastTs = (prev && prev.lastTs) || ''
+  const dInput = Math.max(0, (totals.input_tokens || 0) - prevTotal.input_tokens)
+  const dCached = Math.max(0, (totals.cached_input_tokens || 0) - prevTotal.cached_input_tokens)
+  const dOut = Math.max(0, (totals.output_tokens || 0) - prevTotal.output_tokens)
+  const dReason = Math.max(0, (totals.reasoning_output_tokens || 0) - prevTotal.reasoning_output_tokens)
+  if (dInput + dCached + dOut + dReason <= 0) {
+    return { event: null, toolDeltas: [], state: prev ?? null }
+  }
+  const newTotalTokens = Math.max(0, dInput - dCached) + dCached + (dOut + dReason)
+  const occurredOn = (totalsTs || '').slice(0, 10) || fileDate
+  const event = {
+    provider: 'openai',
+    model: model || 'gpt-5',
+    occurredOn,
+    occurredAt: totalsTs || undefined,
+    uncachedInputTokens: Math.max(0, dInput - dCached),
+    cacheReadInputTokens: dCached,
+    cacheCreationInputTokens: 0,
+    outputTokens: dOut + dReason,
+    numRequests: 1,
+  }
+  // Tool calls are deduped by the maxTs watermark: each is counted exactly once, in
+  // the run where it is first seen, and never recounted. Calls are exact. The
+  // even-split token figure is an estimate; a tail call's tokens can land in a later
+  // run's batch, but no call is ever dropped.
+  const newCalls = (toolCalls || []).filter((c) => c.ts && c.ts > prevLastTs)
+  const toolDeltas = []
+  if (newCalls.length > 0 && newTotalTokens > 0) {
+    const share = Math.round(newTotalTokens / newCalls.length)
+    for (const c of newCalls) {
+      toolDeltas.push({
+        tool: c.group,
+        bucketDate: (c.ts || '').slice(0, 10) || occurredOn,
+        calls: 1,
+        tokens: share,
+      })
+    }
+  }
+  return { event, toolDeltas, state: { total: totals, lastTs: maxTs || totalsTs || '' } }
+}
+
+// Show enough of the token to recognize it, never the secret part.
+export function maskToken(token) {
+  if (!token) return '(not set)'
+  return token.length > 12 ? `${token.slice(0, 12)}...` : token
+}
+
+function relAgo(ms, nowMs) {
+  if (!ms) return 'never'
+  const s = Math.max(0, Math.round((nowMs - ms) / 1000))
+  if (s < 60) return `${s}s ago`
+  if (s < 3600) return `${Math.round(s / 60)}m ago`
+  if (s < 86_400) return `${Math.round(s / 3600)}h ago`
+  return `${Math.round(s / 86_400)}d ago`
+}
+
+// Render the `doctor` report from gathered facts (pure, so it is unit-tested).
+// info: { configPath, configFound, token, ingestUrl, lookbackDays, nowMs,
+//         claude/codex: { dir, found, recentCount, lastWriteMs } }
+export function formatDoctorReport(info) {
+  const lines = ['modelmeter-collect doctor', '']
+  lines.push(`Config  ${info.configPath}`)
+  lines.push(`  status:     ${info.configFound ? 'found' : 'not found'}`)
+  lines.push(`  token:      ${maskToken(info.token)}`)
+  lines.push(`  ingest URL: ${info.ingestUrl || '(not set)'}`)
+  lines.push('')
+  for (const [label, d] of [
+    ['Claude Code', info.claude],
+    ['Codex', info.codex],
+  ]) {
+    lines.push(`${label}  ${d.dir}`)
+    if (!d.found) {
+      lines.push('  logs:       not found')
+    } else {
+      const n = d.recentCount
+      lines.push(`  logs:       found, ${n} session file${n === 1 ? '' : 's'} in the last ${info.lookbackDays} days`)
+      lines.push(`  last write: ${relAgo(d.lastWriteMs, info.nowMs)}`)
+    }
+    lines.push('')
+  }
+  lines.push('Privacy')
+  lines.push('  sent:       model names, token counts, tool and MCP names, dates')
+  lines.push('  never sent: prompts, responses, file contents, API keys')
+  return lines.join('\n')
+}
+
+// Collapse events to one daily row per (provider, model, date).
+export function aggregateDaily(events, today) {
+  const byKey = new Map()
+  for (const e of events) {
+    const date = e.occurredOn || today
+    const key = `${e.provider}|${e.model}|${date}`
+    const cur = byKey.get(key) || {
+      provider: e.provider,
+      model: e.model,
+      occurredOn: date,
+      uncachedInputTokens: 0,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      outputTokens: 0,
+      numRequests: 0,
+    }
+    cur.uncachedInputTokens += e.uncachedInputTokens || 0
+    cur.cacheReadInputTokens += e.cacheReadInputTokens || 0
+    cur.cacheCreationInputTokens += e.cacheCreationInputTokens || 0
+    cur.outputTokens += e.outputTokens || 0
+    cur.numRequests += e.numRequests || 1
+    byKey.set(key, cur)
+  }
+  return [...byKey.values()]
+}
+
+// Recent hourly buckets for the 5-hour window. Only events with a real timestamp in
+// the lookback window qualify, so a backfill cannot pollute the recent window.
+export function aggregateHourly(events, nowMs, lookbackMs = 8 * 3_600_000) {
+  const cutoff = nowMs - lookbackMs
+  const byHour = new Map()
+  for (const e of events) {
+    if (!e.occurredAt) continue
+    const t = new Date(e.occurredAt).getTime()
+    if (Number.isNaN(t) || t < cutoff) continue
+    const d = new Date(t)
+    d.setMinutes(0, 0, 0)
+    const hourIso = d.toISOString()
+    const key = `${e.provider}|${e.model}|${hourIso}`
+    const cur = byHour.get(key) || {
+      provider: e.provider,
+      model: e.model,
+      bucketHour: hourIso,
+      uncachedInputTokens: 0,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      outputTokens: 0,
+      numRequests: 0,
+    }
+    cur.uncachedInputTokens += e.uncachedInputTokens || 0
+    cur.cacheReadInputTokens += e.cacheReadInputTokens || 0
+    cur.cacheCreationInputTokens += e.cacheCreationInputTokens || 0
+    cur.outputTokens += e.outputTokens || 0
+    cur.numRequests += e.numRequests || 1
+    byHour.set(key, cur)
+  }
+  return [...byHour.values()]
+}
+
+// Per-tool / MCP rows. Claude events carry a `tools` array (even-split tokens across
+// the distinct groups a turn called); Codex contributes precomputed tool deltas.
+export function aggregateTools(events, codexToolDeltas = [], today) {
+  const byTool = new Map()
+  const add = (tool, date, calls, tokens) => {
+    const key = `${tool}|${date}`
+    const cur = byTool.get(key) || { tool, bucketDate: date, calls: 0, tokens: 0 }
+    cur.calls += calls
+    cur.tokens += tokens
+    byTool.set(key, cur)
+  }
+  for (const e of events) {
+    if (!Array.isArray(e.tools) || e.tools.length === 0) continue
+    const date = e.occurredOn || today
+    const callsByGroup = new Map()
+    for (const name of e.tools) {
+      const g = toolGroup(name)
+      callsByGroup.set(g, (callsByGroup.get(g) || 0) + 1)
+    }
+    const eventTokens =
+      (e.uncachedInputTokens || 0) +
+      (e.cacheReadInputTokens || 0) +
+      (e.cacheCreationInputTokens || 0) +
+      (e.outputTokens || 0)
+    const tokenShare = Math.round(eventTokens / callsByGroup.size)
+    for (const [g, calls] of callsByGroup) add(g, date, calls, tokenShare)
+  }
+  for (const d of codexToolDeltas) add(d.tool, d.bucketDate, d.calls, d.tokens)
+  return [...byTool.values()]
+}
+
+// --- Local recommendations: session summaries + scoring for `doctor
+// --recommendations`. Computed entirely from local logs, no network. ---
+
+function pct(x) {
+  return `${Math.round(x * 100)}%`
+}
+
+function fmtTok(value) {
+  if (value >= 1_000_000_000) return `${(value / 1_000_000_000).toFixed(1)}B`
+  if (value >= 1_000_000) return `${(value / 1_000_000).toFixed(1)}M`
+  if (value >= 1_000) return `${(value / 1_000).toFixed(1)}K`
+  return String(Math.round(value))
+}
+
+// Summarize one Claude session file into per-session totals, the per-turn context
+// size sequence (for bloat detection), and tool token attribution.
+export function claudeSessionSummary(text) {
+  let model = 'claude-unknown'
+  let uncached = 0
+  let cacheRead = 0
+  let cacheCreate = 0
+  let output = 0
+  let requests = 0
+  const contextSeq = []
+  const tools = {}
+  for (const line of String(text).split('\n')) {
+    if (!line.trim()) continue
+    let o
+    try {
+      o = JSON.parse(line)
+    } catch {
+      continue
+    }
+    const ev = claudeEventFromLine(o)
+    if (!ev) continue
+    model = ev.model || model
+    uncached += ev.uncachedInputTokens
+    cacheRead += ev.cacheReadInputTokens
+    cacheCreate += ev.cacheCreationInputTokens
+    output += ev.outputTokens
+    requests += 1
+    contextSeq.push(ev.uncachedInputTokens + ev.cacheReadInputTokens + ev.cacheCreationInputTokens)
+    const turnTokens =
+      ev.uncachedInputTokens + ev.cacheReadInputTokens + ev.cacheCreationInputTokens + ev.outputTokens
+    const groups = new Map()
+    for (const name of ev.tools) {
+      const g = toolGroup(name)
+      groups.set(g, (groups.get(g) || 0) + 1)
+    }
+    const share = groups.size > 0 ? Math.round(turnTokens / groups.size) : 0
+    for (const [g, calls] of groups) {
+      const cur = tools[g] || { tokens: 0, calls: 0 }
+      cur.tokens += share
+      cur.calls += calls
+      tools[g] = cur
+    }
+  }
+  if (requests === 0) return null
+  return { provider: 'anthropic', model, uncached, cacheRead, cacheCreate, output, requests, contextSeq, tools }
+}
+
+// Summarize one Codex session from its final cumulative token_count. Codex totals are
+// cumulative, so there is no reliable per-turn context sequence (bloat is Claude-only).
+export function codexSessionSummary(text) {
+  let model = 'gpt-5'
+  let totals = null
+  let requests = 0
+  const tools = {}
+  for (const line of String(text).split('\n')) {
+    if (!line.trim()) continue
+    let o
+    try {
+      o = JSON.parse(line)
+    } catch {
+      continue
+    }
+    const p = o.payload || o
+    const ptype = p.type || o.type
+    if (typeof o.model === 'string') model = o.model
+    else if (typeof p.model === 'string') model = p.model
+    const tc = findLastTokenCount(o)
+    if (tc) {
+      totals = tc
+      requests += 1
+    }
+    const g = codexToolFromEvent(p, ptype)
+    if (g) {
+      const cur = tools[g] || { tokens: 0, calls: 0 }
+      cur.calls += 1
+      tools[g] = cur
+    }
+  }
+  if (!totals) return null
+  const cacheRead = totals.cached_input_tokens || 0
+  const uncached = Math.max(0, (totals.input_tokens || 0) - cacheRead)
+  const output = (totals.output_tokens || 0) + (totals.reasoning_output_tokens || 0)
+  return {
+    provider: 'openai',
+    model,
+    uncached,
+    cacheRead,
+    cacheCreate: 0,
+    output,
+    requests: Math.max(1, requests),
+    contextSeq: [],
+    tools,
+  }
+}
+
+// First-5 vs last-5 average turn size + max, for context-bloat detection.
+export function sessionBloat(seq) {
+  if (!Array.isArray(seq) || seq.length < 10) return null
+  const avg = (arr) => Math.round(arr.reduce((a, b) => a + b, 0) / arr.length)
+  return { first5: avg(seq.slice(0, 5)), last5: avg(seq.slice(-5)), max: Math.max(...seq) }
+}
+
+// Turn session summaries into local recommendations. Pure, so the whole engine is
+// fixture-tested. Returns [{ kind, level, text }] in cache -> mcp -> output -> bloat order.
+export function buildLocalRecommendations(summaries) {
+  const recs = []
+  const list = (summaries || []).filter(Boolean)
+  if (list.length === 0) return recs
+
+  let uncached = 0
+  let cacheRead = 0
+  let cacheCreate = 0
+  let output = 0
+  let requests = 0
+  const tools = {}
+  for (const s of list) {
+    uncached += s.uncached
+    cacheRead += s.cacheRead
+    cacheCreate += s.cacheCreate
+    output += s.output
+    requests += s.requests
+    for (const [g, v] of Object.entries(s.tools || {})) {
+      const cur = tools[g] || { tokens: 0, calls: 0 }
+      cur.tokens += v.tokens
+      cur.calls += v.calls
+      tools[g] = cur
+    }
+  }
+  const inputTotal = uncached + cacheRead + cacheCreate
+  const total = inputTotal + output
+
+  // 1. Cache effectiveness.
+  if (inputTotal > 0) {
+    const readRatio = cacheRead / inputTotal
+    const createRatio = cacheCreate / inputTotal
+    const uncachedRatio = uncached / inputTotal
+    if (createRatio > 0.3 && readRatio < createRatio) {
+      recs.push({
+        kind: 'cache',
+        level: 'warn',
+        text: `High cache creation, low reuse: ${pct(createRatio)} of input is cache writes vs ${pct(
+          readRatio,
+        )} reads. Keep your prompt prefix byte-for-byte stable so it gets reused.`,
+      })
+    } else if (uncachedRatio > 0.5) {
+      recs.push({
+        kind: 'cache',
+        level: 'warn',
+        text: `Repeated uncached context: ${pct(
+          uncachedRatio,
+        )} of input pays full price. Move stable content (system prompt, tools, examples) into a cached prefix.`,
+      })
+    } else if (readRatio >= 0.6) {
+      recs.push({
+        kind: 'cache',
+        level: 'ok',
+        text: `Good cache reuse: ${pct(readRatio)} of input is cached reads.`,
+      })
+    }
+  }
+
+  // 2. MCP / tool ranking.
+  const toolArr = Object.entries(tools)
+    .map(([tool, v]) => ({ tool, ...v }))
+    .sort((a, b) => b.tokens - a.tokens)
+  const toolTotal = toolArr.reduce((n, t) => n + t.tokens, 0)
+  const topMcp = toolArr.find((t) => t.tool.startsWith('mcp:'))
+  if (topMcp && toolTotal > 0 && topMcp.tokens / toolTotal >= 0.25) {
+    recs.push({
+      kind: 'mcp',
+      level: 'warn',
+      text: `${topMcp.tool} is ${pct(
+        topMcp.tokens / toolTotal,
+      )} of tool-attributed usage. Disable it when you are not actively using it.`,
+    })
+  }
+
+  // 3. Output verbosity.
+  if (total > 0 && output / total > 0.4) {
+    recs.push({
+      kind: 'output',
+      level: 'warn',
+      text: `Output is ${pct(
+        output / total,
+      )} of usage. Ask for patch-only responses or short summaries; output is the priciest token tier.`,
+    })
+  } else if (requests > 0 && Math.round(output / requests) > 5000) {
+    recs.push({
+      kind: 'output',
+      level: 'info',
+      text: `Responses average ${fmtTok(
+        Math.round(output / requests),
+      )} output tokens. A max_tokens cap or terser prompt trims the priciest tier.`,
+    })
+  }
+
+  // 4. Context bloat (Claude sessions carry a per-turn sequence).
+  let worst = null
+  for (const s of list) {
+    const b = sessionBloat(s.contextSeq)
+    if (b && b.last5 > b.first5 * 2 && b.last5 > 30_000 && (!worst || b.last5 > worst.last5)) {
+      worst = b
+    }
+  }
+  if (worst) {
+    recs.push({
+      kind: 'bloat',
+      level: 'warn',
+      text: `A recent session's context grew from ${fmtTok(worst.first5)} to ${fmtTok(
+        worst.last5,
+      )} tokens per turn. Start a fresh session or ask the model to summarize state.`,
+    })
+  }
+
+  return recs
+}

package/lib.test.mjs

@@ -0,0 +1,173 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  aggregateDaily,
+  aggregateHourly,
+  aggregateTools,
+  claudeEventFromLine,
+  codexDelta,
+  deriveHourlyUrl,
+  findLastTokenCount,
+  formatDoctorReport,
+  mergeDetailBatches,
+  pruneClaudeState,
+} from './lib.mjs'
+
+test('codexDelta leaves post-token-count tool calls for the next batch', () => {
+  const toolCalls = [
+    { ts: '2026-06-18T12:01:00.000Z', group: 'exec_command' },
+    { ts: '2026-06-18T12:03:00.000Z', group: 'apply_patch' },
+  ]
+  const first = codexDelta(
+    {
+      totals: { input_tokens: 100, cached_input_tokens: 0, output_tokens: 0, reasoning_output_tokens: 0 },
+      totalsTs: '2026-06-18T12:02:00.000Z',
+      maxTs: '2026-06-18T12:03:00.000Z',
+      model: 'gpt-5',
+      fileDate: '2026-06-18',
+      toolCalls,
+    },
+    null,
+  )
+  assert.deepEqual(
+    first.toolDeltas.map((d) => d.tool),
+    ['exec_command'],
+  )
+  assert.equal(first.state.lastToolTs, '2026-06-18T12:02:00.000Z')
+
+  const second = codexDelta(
+    {
+      totals: { input_tokens: 200, cached_input_tokens: 0, output_tokens: 0, reasoning_output_tokens: 0 },
+      totalsTs: '2026-06-18T12:04:00.000Z',
+      maxTs: '2026-06-18T12:04:00.000Z',
+      model: 'gpt-5',
+      fileDate: '2026-06-18',
+      toolCalls,
+    },
+    first.state,
+  )
+  assert.deepEqual(
+    second.toolDeltas.map((d) => d.tool),
+    ['apply_patch'],
+  )
+})
+
+test('pruneClaudeState keeps newest timestamped ids and normalizes legacy entries', () => {
+  const pruned = pruneClaudeState(
+    {
+      old: { ts: '2026-06-18T10:00:00.000Z' },
+      legacy: 1,
+      newest: { ts: '2026-06-18T12:00:00.000Z' },
+      middle: { ts: '2026-06-18T11:00:00.000Z' },
+    },
+    2,
+  )
+  assert.deepEqual(Object.keys(pruned), ['middle', 'newest'])
+  assert.deepEqual(pruned.middle, { ts: '2026-06-18T11:00:00.000Z' })
+})
+
+test('deriveHourlyUrl fails closed for nonstandard ingest URLs unless overridden', () => {
+  assert.equal(
+    deriveHourlyUrl('https://x.test/functions/v1/ingest/'),
+    'https://x.test/functions/v1/ingest-hourly',
+  )
+  assert.equal(deriveHourlyUrl('https://x.test/custom'), null)
+  assert.equal(deriveHourlyUrl('https://x.test/custom', 'https://x.test/detail'), 'https://x.test/detail')
+})
+
+test('mergeDetailBatches deduplicates additive rows by bucket', () => {
+  const merged = mergeDetailBatches(
+    {
+      hours: [
+        {
+          provider: 'openai',
+          model: 'gpt-5',
+          bucketHour: '2026-06-18T12:00:00.000Z',
+          uncachedInputTokens: 1,
+          cacheReadInputTokens: 2,
+          cacheCreationInputTokens: 3,
+          outputTokens: 4,
+          numRequests: 1,
+        },
+      ],
+      tools: [{ tool: 'exec_command', bucketDate: '2026-06-18', calls: 1, tokens: 10 }],
+    },
+    {
+      hours: [
+        {
+          provider: 'openai',
+          model: 'gpt-5',
+          bucketHour: '2026-06-18T12:00:00.000Z',
+          uncachedInputTokens: 5,
+          cacheReadInputTokens: 0,
+          cacheCreationInputTokens: 0,
+          outputTokens: 6,
+          numRequests: 1,
+        },
+      ],
+      tools: [{ tool: 'exec_command', bucketDate: '2026-06-18', calls: 2, tokens: 20 }],
+    },
+  )
+  assert.equal(merged.hours.length, 1)
+  assert.equal(merged.hours[0].uncachedInputTokens, 6)
+  assert.equal(merged.hours[0].outputTokens, 10)
+  assert.equal(merged.hours[0].numRequests, 2)
+  assert.deepEqual(merged.tools, [{ tool: 'exec_command', bucketDate: '2026-06-18', calls: 3, tokens: 30 }])
+})
+
+test('claude parsing and aggregations exclude prompt text', () => {
+  const event = claudeEventFromLine({
+    uuid: 'c1',
+    timestamp: '2026-06-18T12:34:56.000Z',
+    message: {
+      role: 'assistant',
+      model: 'claude-sonnet',
+      usage: {
+        input_tokens: 100,
+        cache_read_input_tokens: 20,
+        cache_creation_input_tokens: 5,
+        output_tokens: 30,
+      },
+      content: [
+        { type: 'text', text: 'response text must not be copied' },
+        { type: 'tool_use', name: 'mcp__supabase__query' },
+        { type: 'tool_use', name: 'exec_command' },
+      ],
+    },
+  })
+  assert.equal(event.id, 'c1')
+  assert.equal(event.provider, 'anthropic')
+  assert.deepEqual(event.tools, ['mcp__supabase__query', 'exec_command'])
+  assert.equal(JSON.stringify(event).includes('response text'), false)
+
+  assert.equal(aggregateDaily([event], '2026-06-18')[0].uncachedInputTokens, 100)
+  assert.equal(aggregateHourly([event], new Date('2026-06-18T13:00:00.000Z').getTime()).length, 1)
+  assert.deepEqual(
+    aggregateTools([event], [], '2026-06-18').map((d) => d.tool).sort(),
+    ['exec_command', 'mcp:supabase'],
+  )
+})
+
+test('findLastTokenCount and doctor report cover nested Codex usage and privacy copy', () => {
+  const totals = findLastTokenCount({
+    payload: [
+      { type: 'token_count', info: { total_token_usage: { input_tokens: 1 } } },
+      { nested: { type: 'token_count', info: { total_token_usage: { input_tokens: 2 } } } },
+    ],
+  })
+  assert.deepEqual(totals, { input_tokens: 2 })
+
+  const report = formatDoctorReport({
+    configPath: '/tmp/config.json',
+    configFound: true,
+    token: 'mm_live_abcdefghijklmnop',
+    ingestUrl: 'https://x.test/functions/v1/ingest',
+    lookbackDays: 14,
+    nowMs: 1000,
+    claude: { dir: '/tmp/claude', found: false },
+    codex: { dir: '/tmp/codex', found: true, recentCount: 1, lastWriteMs: 1000 },
+  })
+  assert.match(report, /mm_live_abcd\.\.\./)
+  assert.match(report, /never sent: prompts/)
+})

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "modelmeter-collect",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Report LLM token usage from local Claude Code / Codex logs to ModelMeter. Token counts only, never prompts or keys.",
   "type": "module",
   "bin": {
     "modelmeter-collect": "cli.mjs"
   },
+  "scripts": {
+    "test": "node --test lib.test.mjs"
+  },
   "files": [
     "cli.mjs",
     "collect.mjs",
+    "lib.mjs",
+    "lib.test.mjs",
     "README.md"
   ],
   "engines": {