reread-cli 0.2.1 → 0.3.0

package/README.md

@@ -21,13 +21,14 @@ Code, Codex and Antigravity already keep. Nothing is uploaded, and it has no dep
   Reading history from the cache      33.6%  95.2% of all tokens read
   Writing history again               18.7%  after the cache was lost
   Everything else                     47.7%  new input, first cache writes, output
+  Of which thinking                    5.9%  27% of output tokens
 ```
 
 Every reply in a session sends the whole conversation to the model again. Prompt caching makes those re-reads
 cheaper, but in a long session they still add up, and when the cache is lost the whole history is written again at
 full price. ReRead shows you the split, when and why the cache was lost, and which sessions cost the most.
 
-Every tool with sessions on your machine is read; `--tool claude`, `--tool codex` or `--tool antigravity` picks one. Needs Node.js 20 or newer (22.15 or newer also reads Codex's archived sessions).
+Every tool with sessions on your machine is read; `--tool claude`, `--tool codex` or `--tool antigravity` picks one. Needs Node.js 20 or newer (22.15 or newer also reads Codex's compressed sessions; on an older Node.js, ReRead says how many it had to skip).
 
 ## The report
 
@@ -35,13 +36,14 @@ Every tool with sessions on your machine is read; `--tool claude`, `--tool codex
 
 - **Key findings** first: a few cards, the costliest first, each with one number, what it means and what to do
   (how much of your usage came from long contexts, how concentrated it is in a few sessions, what losing the cache
-  cost and why, how large your context grew before each compaction).
+  cost and why, how large your context grew before each compaction, how much of your usage was thinking).
 - **The split**: re-reading from the cache, history written again, and everything else.
 - **By day**: what each day cost and how much of it was re-reading.
 - **By context size**: how much of your usage came from replies with a large context (over 150k is where it adds up).
 - **Why the cache was lost**: a break longer than its life (5 minutes or 1 hour), a model switch mid-session, or a
   change near the start of the context (tools, MCP servers, settings).
 - **By project and by model**, and by tool when you use more than one.
+- **By effort level**: the cost of each tool's effort levels, and how much of their output was thinking.
 - **Sessions**: the 10 costliest, sortable and searchable across all of them, with their git branch. Open one to see
   its context grow reply by reply, with each rebuild and compaction marked.
 - **Share**: copy a line of text, or save an image card with no project names on it. Hide names in the whole report
@@ -103,7 +105,7 @@ Output
   --json             all the numbers as JSON
   --csv              every session as CSV
   --md               a Markdown summary, to paste into an issue or a pull request
-  --by <what>        add a breakdown to the summary: project, model, tool or day
+  --by <what>        add a breakdown to the summary: project, model, tool, effort or day
   --top <n>          sessions in the summary (default 10)
   --anon             replace project names with "project 1", "project 2", ... and leave branches out
 ```
@@ -112,6 +114,7 @@ Examples:
 
 ```
 npx reread-cli --days 7 --by model          # this week, by model
+npx reread-cli --by effort                  # cost and thinking share by effort level
 npx reread-cli --tool codex                 # Codex sessions only
 npx reread-cli --project api --text         # one project, terminal only
 npx reread-cli --json | jq .summary         # the numbers, for your own scripts
@@ -140,6 +143,11 @@ A reply counts once, in the session that made it, even when a resumed session co
 toward the session that started it. "Writing history again" is estimated from token counts: a reply whose cache read
 fell below half of the previous reply's context while the context did not shrink.
 
+Thinking is the part of the output the model spent reasoning, billed as output: Claude Code records it as
+`thinking_tokens` and Codex as `reasoning_output_tokens`, next to the effort level each reply ran at. ReRead shows its
+share of output and of usage, and `--by effort` breaks the cost down by tool and effort level. Antigravity's
+transcripts record neither, so its replies count no thinking.
+
 The details, with every rule and threshold: [docs/how-it-counts.md](docs/how-it-counts.md). None of the tools documents
 its session format, and any may change it; if ReRead reads yours wrong, please
 [open an issue](https://github.com/tecyfyai/reread/issues).
@@ -181,6 +189,20 @@ it, so ReRead prices its replies at the model in Antigravity's settings (Gemini
 stay right whatever the model. Gemini CLI was retired for individual users in June 2026 in favour of Antigravity CLI,
 so ReRead does not read it.
 
+### How much of my Claude Code usage is thinking?
+
+ReRead shows it directly. Claude Code records the thinking tokens of each reply and the effort level it ran at, and
+Codex records its reasoning tokens the same way. ReRead adds them up as a share of your output and of your usage, and
+`--by effort` shows the cost and thinking share of each effort level. Thinking is billed as output, so on a high
+effort level it can be a large part of each reply's price; a lower level (`claude --effort low`, or
+`model_reasoning_effort` in Codex's `config.toml`) suits routine tasks.
+
+### What about DeepSeek, Qwen or other models?
+
+When a coding agent ReRead reads runs a model it has no price for, such as a DeepSeek or Qwen model run through Claude
+Code, ReRead counts those replies and their tokens, leaves them out of every cost and share rather than guess a price,
+and names the models in the summary and the report.
+
 ### How is ReRead different from ccusage?
 
 [ccusage](https://github.com/ccusage/ccusage) reports how many tokens you used and what they cost, by day, month or
@@ -197,6 +219,13 @@ their own way, so the dollar figures are what the same tokens would cost on the
 No. It reads only token counts from local files, makes no network requests and has no dependencies. See
 [Private by design](#private-by-design).
 
+## Related
+
+[Agent Chime](https://marketplace.visualstudio.com/items?itemName=hamperpick.agent-chime) (also on
+[Open VSX](https://open-vsx.org/extension/hamperpick/agent-chime)) plays a sound in VS Code or Cursor when Claude Code,
+Codex, Cursor's agent or Antigravity CLI finishes or needs your approval, so you can return before the prompt cache goes
+cold.
+
 ## Contributing
 
 Bug reports, ideas and pull requests are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reread-cli",
-  "version": "0.2.1",
-  "description": "Token usage and prompt cache analyzer for Claude Code, Codex and Antigravity: how much of your coding agent's usage was re-reading context, and why. Visual report and a cache-countdown status line. Local only; uploads nothing.",
+  "version": "0.3.0",
+  "description": "Token usage and prompt cache analyzer for Claude Code, Codex and Antigravity: how much of your coding agent's usage was re-reading context or thinking, and why. Visual report, cost by effort level and a cache-countdown status line. Local only; uploads nothing.",
   "type": "module",
   "bin": {
     "reread": "bin/reread.js"
@@ -40,6 +40,8 @@
     "token-cost",
     "prompt-caching",
     "prompt-cache",
+    "thinking-tokens",
+    "reasoning-effort",
     "context-window",
     "llm",
     "llm-cost",

package/src/analyze.js

@@ -5,7 +5,7 @@ import path from 'node:path'
 import { isInside } from './files.js'
 import { findingsOf } from './findings.js'
 import { dayOf, pct, round1, round2 } from './format.js'
-import { contextOf, costOf, priceOf } from './prices.js'
+import { contextOf, costOf, hasPrice, priceOf } from './prices.js'
 import { DISPLAY_ORDER, toolOf, TOOLS } from './tools.js'
 
 /** @typedef {import('./prices.js').Call} Call */
@@ -56,6 +56,11 @@ export const BUCKETS = /** @type {const} */ ([
  * @property {number} tokensRead
  * @property {number} peak         largest context
  * @property {number} longCost     cost of replies with a context over LONG_CONTEXT
+ * @property {number} out          output tokens
+ * @property {number} think        of which thinking (reasoning) tokens, where the tool records them
+ * @property {number} thinkCost    what the thinking tokens cost
+ * @property {number} unpricedCalls   replies from models with no known price, left out of every cost
+ * @property {number} unpricedTokens  their tokens, sent and output
  * @property {Record<Reason, { n: number, cost: number }>} rebuilds
  * @property {{ n: number, ctx: number }} compact  compactions, and the sum of the contexts they replaced
  * @property {number} [first]
@@ -72,6 +77,11 @@ export const emptyTotals = () => ({
   tokensRead: 0,
   peak: 0,
   longCost: 0,
+  out: 0,
+  think: 0,
+  thinkCost: 0,
+  unpricedCalls: 0,
+  unpricedTokens: 0,
   rebuilds: { cold: { n: 0, cost: 0 }, model: { n: 0, cost: 0 }, prefix: { n: 0, cost: 0 } },
   compact: { n: 0, ctx: 0 },
 })
@@ -91,6 +101,11 @@ export function addTotals(a, b) {
   a.tokensIn += b.tokensIn
   a.tokensRead += b.tokensRead
   a.longCost += b.longCost
+  a.out += b.out
+  a.think += b.think
+  a.thinkCost += b.thinkCost
+  a.unpricedCalls += b.unpricedCalls
+  a.unpricedTokens += b.unpricedTokens
   a.peak = Math.max(a.peak, b.peak)
   for (const w of REASONS) {
     a.rebuilds[w].n += b.rebuilds[w].n
@@ -109,6 +124,7 @@ export function addTotals(a, b) {
  * @property {number} cost
  * @property {number} readCost
  * @property {number} rebuildCost
+ * @property {number} thinkCost
  * @property {Reason | null} why  set when the whole history was written again
  * @property {number} flag        FLAG value for the report
  */
@@ -138,9 +154,17 @@ export function walk(calls, onCall = () => {}) {
       continue
     }
     const ctx = contextOf(c)
-    const p = priceOf(c.model, ctx)
-    const cost = costOf(c)
+    // A model with no known price costs nothing here, rather than a guessed price.
+    const priced = hasPrice(c.model)
+    const p = priced ? priceOf(c.model, ctx) : { input: 0, write5m: 0, write1h: 0, read: 0, output: 0 }
+    const cost = priced ? costOf(c) : 0
     const readCost = (c.read * p.read) / 1e6
+    const think = c.think ?? 0
+    const thinkCost = (think * p.output) / 1e6
+    if (!priced) {
+      s.unpricedCalls++
+      s.unpricedTokens += ctx + c.out
+    }
     /** @type {Reason | null} */
     let why = null
     let rebuildCost = 0
@@ -167,11 +191,22 @@ export function walk(calls, onCall = () => {}) {
     s.rebuildCost += rebuildCost
     s.tokensIn += ctx
     s.tokensRead += c.read
+    s.out += c.out
+    s.think += think
+    s.thinkCost += thinkCost
     s.peak = Math.max(s.peak, ctx)
     if (ctx > LONG_CONTEXT) s.longCost += cost
     s.first ??= c.ts
     s.last = c.ts
-    onCall(c, { ctx, cost, readCost, rebuildCost, why, flag: why ? FLAG[why] : shrank ? FLAG.shrink : FLAG.none })
+    onCall(c, {
+      ctx,
+      cost,
+      readCost,
+      rebuildCost,
+      thinkCost,
+      why,
+      flag: why ? FLAG[why] : shrank ? FLAG.shrink : FLAG.none,
+    })
     if (c.cw1 > 0) ttl = 3600e3
     else if (c.cw5 > 0) ttl = 300e3
     prev = c
@@ -183,6 +218,7 @@ export function walk(calls, onCall = () => {}) {
  * @typedef {Totals & { id: string, tool: Tool, project: string, branch: string, points: [number, number, number, number][] }} Session
  *   points: [time, context, cache read, FLAG] for each reply, for the report's chart
  * @typedef {{ calls: number, usd: number, readUsd: number, rebuildUsd: number }} Money
+ * @typedef {{ tool: Tool, effort: string, calls: number, usd: number, out: number, think: number, thinkUsd: number }} EffortRow
  */
 
 /**
@@ -205,6 +241,8 @@ export function analyze(files, { since, project = '', folders = [], onProgress }
   const models = new Map()
   /** @type {Map<string, Money>} */
   const buckets = new Map()
+  /** @type {Map<string, EffortRow>} */
+  const efforts = new Map()
   const zero = () => ({ calls: 0, usd: 0, readUsd: 0, rebuildUsd: 0 })
   /**
    * @param {Map<string, Money>} map
@@ -222,6 +260,8 @@ export function analyze(files, { since, project = '', folders = [], onProgress }
 
   /** @type {{ file: string, error: string }[]} */
   const skipped = []
+  /** Compressed files this Node.js cannot read. */
+  const unread = /** @type {string[]} */ ([])
 
   files.forEach((file, i) => {
     onProgress?.(i + 1, files.length)
@@ -236,6 +276,7 @@ export function analyze(files, { since, project = '', folders = [], onProgress }
       return
     }
     const { id, sub, cwd, branch, calls } = read
+    if (read.unread) unread.push(file)
     if (!calls.some((c) => !c.seen)) return
     const info = /** @type {import('./tools.js').ToolInfo} */ (TOOLS[tool])
     if (!info.projectInPath && needle) {
@@ -249,6 +290,16 @@ export function analyze(files, { since, project = '', folders = [], onProgress }
       tally(models, c.model, x)
       const label = /** @type {(typeof BUCKETS)[number]} */ (BUCKETS.find(([top]) => x.ctx < top))[1]
       tally(buckets, label, x)
+      if (c.effort) {
+        const ek = `${tool}|${c.effort}`
+        const e = efforts.get(ek) ?? { tool, effort: c.effort, calls: 0, usd: 0, out: 0, think: 0, thinkUsd: 0 }
+        e.calls++
+        e.usd += x.cost
+        e.out += c.out
+        e.think += c.think ?? 0
+        e.thinkUsd += x.thinkCost
+        efforts.set(ek, e)
+      }
       if (!sub) cur.points.push([c.ts, x.ctx, c.read, x.flag])
     })
     if (cwd && !cur.project) cur.project = path.basename(cwd)
@@ -257,7 +308,16 @@ export function analyze(files, { since, project = '', folders = [], onProgress }
     addTotals(total, s)
   })
 
-  return { total, sessions: [...sessions.values()].sort((a, b) => b.cost - a.cost), daily, models, buckets, skipped }
+  return {
+    total,
+    sessions: [...sessions.values()].sort((a, b) => b.cost - a.cost),
+    daily,
+    models,
+    buckets,
+    efforts,
+    skipped,
+    unread,
+  }
 }
 
 /**
@@ -357,6 +417,18 @@ export function summarize(a, { span, anon, version, now = new Date() }) {
       otherShare: round1(100 - share),
       tokensReadFromCache: round1(pct(total.tokensRead, total.tokensIn)),
       longContextShare: round1(pct(total.longCost, total.cost)),
+      unpriced: {
+        calls: total.unpricedCalls,
+        tokens: total.unpricedTokens,
+        models: [...a.models.keys()].filter((m) => !hasPrice(m)).map((m) => m || '(no model named)'),
+      },
+      thinking: {
+        tokens: total.think,
+        outputTokens: total.out,
+        shareOfOutput: round1(pct(total.think, total.out)),
+        usd: round2(total.thinkCost),
+        share: round1(pct(total.thinkCost, total.cost)),
+      },
       apiEquivalentUSD: round2(total.cost),
       rebuilds: /** @type {Record<Reason, { count: number, usd: number, share: number }>} */ (
         Object.fromEntries(
@@ -384,11 +456,23 @@ export function summarize(a, { span, anon, version, now = new Date() }) {
       .sort((x, y) => y[1].usd - x[1].usd)
       .map(([model, v]) => ({
         model,
+        priced: hasPrice(model),
         calls: v.calls,
         usd: round2(v.usd),
         readUsd: round2(v.readUsd),
         rebuildUsd: round2(v.rebuildUsd),
       })),
+    efforts: [...a.efforts.values()]
+      .sort((x, y) => y.usd - x.usd)
+      .map((e) => ({
+        tool: e.tool,
+        name: TOOLS[e.tool].name,
+        effort: e.effort,
+        calls: e.calls,
+        usd: round2(e.usd),
+        thinkingShareOfOutput: round1(pct(e.think, e.out)),
+        thinkingUsd: round2(e.thinkUsd),
+      })),
     projects: projects.map((p) => ({
       project: nameOf(p.project),
       sessions: p.sessions,

package/src/args.js

@@ -15,7 +15,7 @@ export class UsageError extends Error {}
  * @property {string} dir        the sessions folder given with --dir, or ''
  * @property {'all' | import('./tools.js').Tool} tool  whose sessions to read
  * @property {'text' | 'json' | 'csv' | 'md'} format
- * @property {'' | 'project' | 'model' | 'day' | 'tool'} by
+ * @property {'' | 'project' | 'model' | 'day' | 'tool' | 'effort'} by
  * @property {number} top        sessions in the summary
  * @property {string | null} html  null: decide by the terminal; '': a file in a private temp folder; else this path
  * @property {boolean} text      --text: the summary only
@@ -109,8 +109,8 @@ export function parseArgs(argv, now = Date.now()) {
   if (!Number.isInteger(top) || top < 0) throw new UsageError('--top takes a whole number, such as --top 20')
 
   const by = values.get('--by') ?? ''
-  if (by !== '' && by !== 'project' && by !== 'model' && by !== 'day' && by !== 'tool') {
-    throw new UsageError('--by takes project, model, tool or day')
+  if (by !== '' && by !== 'project' && by !== 'model' && by !== 'day' && by !== 'tool' && by !== 'effort') {
+    throw new UsageError('--by takes project, model, tool, effort or day')
   }
 
   const tool = /** @type {Options['tool']} */ (values.get('--tool') ?? 'all')

package/src/claude.js

@@ -113,8 +113,8 @@ export function latestClaudeSession(folders, { dirs = claudeDirs(), cwdCache = n
 }
 
 /**
- * One line of a session file as a reply, or null when it is not one. Only token counts, the model, the time and
- * the ids are kept.
+ * One line of a session file as a reply, or null when it is not one. Only token counts, the model, the effort
+ * level, the time and the ids are kept.
  * @param {string} line
  * @param {number} since  replies before this time are left out
  * @returns {Call | null}
@@ -136,6 +136,7 @@ export function callOf(line, since) {
   // Some replies list 1-hour writes in the breakdown while the total says 0; the breakdown is kept.
   const cw = n(u.cache_creation_input_tokens)
   const cw1 = n(u.cache_creation?.ephemeral_1h_input_tokens)
+  const out = n(u.output_tokens)
   return {
     key: `${m.id}|${j.requestId ?? ''}`,
     ts,
@@ -144,7 +145,9 @@ export function callOf(line, since) {
     cw5: Math.max(0, cw - cw1),
     cw1,
     read: n(u.cache_read_input_tokens),
-    out: n(u.output_tokens),
+    out,
+    think: n(u.output_tokens_details?.thinking_tokens),
+    effort: typeof j.effort === 'string' ? j.effort : '',
   }
 }
 
@@ -156,8 +159,10 @@ export function callOf(line, since) {
  */
 export function collect(calls, call) {
   const old = calls.get(call.key)
-  if (old) old.out = Math.max(old.out, call.out)
-  else calls.set(call.key, call)
+  if (old) {
+    old.out = Math.max(old.out, call.out)
+    old.think = Math.max(old.think ?? 0, call.think ?? 0)
+  } else calls.set(call.key, call)
 }
 
 /**
@@ -197,6 +202,8 @@ export function readClaudeFile(file, since, seen) {
   }
   eachLine(file, onLine)
   for (const [key, c] of calls) {
+    // A reply written once per content block can list thinking from a later block than its output count.
+    c.think = Math.min(c.think ?? 0, c.out)
     c.seen = seen.has(key)
     seen.add(key)
   }

package/src/cli.js

@@ -29,7 +29,7 @@ Output
   --json             all the numbers as JSON
   --csv              every session as CSV
   --md               a Markdown summary, to paste into an issue or a pull request
-  --by <what>        add a breakdown to the summary: project, model, tool or day
+  --by <what>        add a breakdown to the summary: project, model, tool, effort or day
   --top <n>          sessions in the summary (default 10)
   --anon             replace project names with "project 1", "project 2", ... and leave branches out
 
@@ -91,6 +91,11 @@ async function run(argv) {
     onProgress: progress ? (n, total) => process.stderr.write(`\rReading ${n} of ${total} session files…`) : undefined,
   })
   if (progress) process.stderr.write('\r\x1b[K')
+  if (a.unread.length) {
+    process.stderr.write(
+      `reread: ${a.unread.length} compressed Codex session ${a.unread.length === 1 ? 'file was' : 'files were'} not read, so their usage is missing: reading them needs Node.js 22.15 or newer (this is ${process.version})\n`,
+    )
+  }
   if (a.skipped.length) {
     const [first] = a.skipped
     const more = a.skipped.length > 1 ? ` and ${a.skipped.length - 1} more` : ''

package/src/codex.js

@@ -1,7 +1,7 @@
 // @ts-check
 // Reading Codex's session files ("rollouts"): ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl, and archived ones in
 // ~/.codex/archived_sessions (zstd-compressed, read where Node.js can decompress zstd). As with Claude Code, only token
-// counts, the model, the time and ids are kept, plus the folder and git branch from the session's header.
+// counts, the model, the effort level, the time and ids are kept, plus the folder and git branch from the session's header.
 import { readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import path from 'node:path'
@@ -43,9 +43,10 @@ const n = (v) => (typeof v === 'number' && v > 0 ? v : 0)
  * @param {string} key
  * @param {number} ts
  * @param {string} model
+ * @param {string} effort
  * @returns {Call}
  */
-function callFrom(u, key, ts, model) {
+function callFrom(u, key, ts, model, effort) {
   const read = n(u.cached_input_tokens)
   const cw = n(u.cache_write_input_tokens)
   return {
@@ -57,6 +58,8 @@ function callFrom(u, key, ts, model) {
     cw1: 0,
     read,
     out: n(u.output_tokens),
+    think: Math.min(n(u.reasoning_output_tokens), n(u.output_tokens)),
+    effort,
   }
 }
 
@@ -75,6 +78,7 @@ export function readCodexFile(file, since, seen) {
   let cwd = ''
   let branch = ''
   let model = ''
+  let effort = ''
   /** @type {Map<string, Call>} */
   const records = new Map()
   /** @type {Map<string, Call>} */
@@ -100,12 +104,13 @@ export function readCodexFile(file, since, seen) {
     }
     if (j.type === 'turn_context') {
       if (typeof p.model === 'string' && p.model) model = p.model
+      if (typeof p.effort === 'string') effort = p.effort
       return
     }
     const ts = Date.parse(j.timestamp)
     if (j.type === 'token_usage_record' && p.usage && typeof p.usage === 'object') {
       const key = `codex|${p.response_id ?? `${id}|${j.ordinal}`}`
-      if (ts >= since && !records.has(key)) records.set(key, callFrom(p.usage, key, ts, model))
+      if (ts >= since && !records.has(key)) records.set(key, callFrom(p.usage, key, ts, model, effort))
       return
     }
     if (j.type === 'event_msg' && p.type === 'token_count') {
@@ -114,12 +119,12 @@ export function readCodexFile(file, since, seen) {
       if (typeof total !== 'number' || total === lastTotal || !last) return
       lastTotal = total
       const key = `codex|${id}|${total}`
-      if (ts >= since) counts.set(key, callFrom(last, key, ts, model))
+      if (ts >= since) counts.set(key, callFrom(last, key, ts, model, effort))
     }
   }
 
   if (file.endsWith('.zst')) {
-    if (!canReadZstd) return { id, sub: false, cwd, branch, calls: [] }
+    if (!canReadZstd) return { id, sub: false, cwd, branch, calls: [], unread: true }
     const data = /** @type {any} */ (zlib).zstdDecompressSync(readFileSync(file))
     splitLines(data, onLine)
   } else {

package/src/findings.js

@@ -47,6 +47,17 @@ function freshAction(tools) {
   return `Compact earlier, or start fresh when you switch task (${tools.map((t) => TOOLS[t].fresh).join(', ')}).`
 }
 
+/**
+ * How to lower the effort level, in the tools used that record thinking.
+ * @param {import('./tools.js').Tool[]} tools
+ */
+function effortAction(tools) {
+  const ways = []
+  if (tools.includes('claude')) ways.push('claude --effort low in Claude Code')
+  if (tools.includes('codex')) ways.push('model_reasoning_effort in ~/.codex/config.toml for Codex')
+  return `For routine tasks, use a lower effort level (${ways.join('; ') || 'in your tool'}); keep the higher levels for hard problems.`
+}
+
 /**
  * @param {import('./analyze.js').Analysis} a
  * @param {import('./tools.js').Tool[]} [tools]  the tools the sessions came from
@@ -118,5 +129,24 @@ export function findingsOf(a, tools = ['claude']) {
     })
   }
 
+  const thinkShare = pct(total.thinkCost, total.cost)
+  if (thinkShare >= 3) {
+    const levels = [...a.efforts.values()].filter((e) => e.out > 0 && e.calls >= 20)
+    const lo = levels.reduce((m, e) => (!m || e.think / e.out < m.think / m.out ? e : m), /** @type {any} */ (null))
+    const hi = levels.reduce((m, e) => (!m || e.think / e.out > m.think / m.out ? e : m), /** @type {any} */ (null))
+    const spread =
+      lo && hi && lo !== hi
+        ? ` At ${hi.effort} effort in ${TOOLS[/** @type {import('./tools.js').Tool} */ (hi.tool)].name}, ${pct(hi.think, hi.out).toFixed(0)}% of the output was thinking; at ${lo.effort} effort in ${TOOLS[/** @type {import('./tools.js').Tool} */ (lo.tool)].name}, ${pct(lo.think, lo.out).toFixed(0)}%.`
+        : ''
+    out.push({
+      id: 'thinking',
+      value: usd(total.thinkCost),
+      title: `Thinking made ${pct(total.think, total.out).toFixed(0)}% of your output tokens, ${thinkShare.toFixed(1)}% of your usage`,
+      text: `${tokens(total.think)} thinking tokens, billed as output.${spread}`,
+      action: effortAction(tools),
+      usd: round2(total.thinkCost),
+    })
+  }
+
   return out.sort((x, y) => (y.usd ?? 0) - (x.usd ?? 0))
 }

package/src/prices.js

@@ -124,6 +124,8 @@ function isOf(model, id) {
  * @property {number} cw1    tokens written to Anthropic's 1-hour cache
  * @property {number} read   tokens read from the cache
  * @property {number} out    output, reasoning included
+ * @property {number} [think]  of the output, thinking (reasoning) tokens, where the tool records them
+ * @property {string} [effort]  the effort level the reply ran at, where the tool records it
  * @property {boolean} [seen]  counted already in an earlier file
  */
 
@@ -156,6 +158,16 @@ export function priceOf(model = '', context = 0) {
   return entry.long && context > entry.long.above ? entry.long.price : entry.base
 }
 
+/**
+ * Whether ReRead knows a price for a model id: a listed model, a dated or variant id of one, or a known family. Any
+ * other id (a DeepSeek or Qwen model run through Claude Code, say) has no price, and its replies are left out of costs.
+ * @param {string} [model]
+ */
+export function hasPrice(model = '') {
+  if (!model) return false
+  return IDS.some((k) => isOf(model, k)) || FAMILIES.some(([re]) => re.test(model.toLowerCase()))
+}
+
 /**
  * The tokens a reply sent: new input, cache writes and cache reads.
  * @param {Call} c

package/src/render.js

@@ -25,7 +25,7 @@ const REASON_TEXT = {
 /**
  * The summary for the terminal.
  * @param {Report} data
- * @param {{ top: number, by: '' | 'project' | 'model' | 'day' | 'tool', color: boolean }} opts
+ * @param {{ top: number, by: '' | 'project' | 'model' | 'day' | 'tool' | 'effort', color: boolean }} opts
  */
 export function renderText(data, { top, by, color }) {
   const paint = (/** @type {number} */ code) => (/** @type {unknown} */ t) =>
@@ -44,12 +44,26 @@ export function renderText(data, { top, by, color }) {
     dim(
       `  ${data.span} · ${plural(S.sessions, 'session')} · ${plural(S.calls, 'reply', 'replies')} · ${usd(S.apiEquivalentUSD)} at API prices`,
     ),
+    ...(S.unpriced.calls
+      ? [
+          yellow(
+            `  ${plural(S.unpriced.calls, 'reply', 'replies')} from models with no known price (${S.unpriced.models.join(', ')}) are left out of the cost.`,
+          ),
+        ]
+      : []),
     '',
     `  ${pad('Reading history from the cache', 34)}${lpad(`${S.cacheReadShare.toFixed(1)}%`, 7)}  ${dim(`${S.tokensReadFromCache}% of all tokens read`)}`,
     `  ${pad('Writing history again', 34)}${lpad(`${S.rebuildShare.toFixed(1)}%`, 7)}  ${dim('after the cache was lost')}`,
     `  ${pad('Everything else', 34)}${lpad(`${S.otherShare.toFixed(1)}%`, 7)}  ${dim('new input, first cache writes, output')}`,
     '',
   ]
+  if (S.thinking.tokens) {
+    out.splice(
+      -1,
+      0,
+      `  ${pad('Of which thinking', 34)}${lpad(`${S.thinking.share.toFixed(1)}%`, 7)}  ${dim(`${S.thinking.shareOfOutput}% of output tokens`)}`,
+    )
+  }
 
   const reasons = REASONS.filter((w) => S.rebuilds[w].count)
   if (reasons.length) {
@@ -62,7 +76,19 @@ export function renderText(data, { top, by, color }) {
     out.push('')
   }
 
-  if (by) {
+  if (by === 'effort') {
+    out.push(bold('  By effort level'))
+    out.push(
+      dim(`  ${pad('tool', 14)}${pad('effort', 16)}${lpad('replies', 9)}${lpad('cost', 10)}${lpad('thinking', 10)}`),
+    )
+    for (const e of data.efforts) {
+      out.push(
+        `  ${pad(e.name.slice(0, 13), 14)}${pad(e.effort.slice(0, 15), 16)}${lpad(int(e.calls), 9)}${lpad(usd(e.usd), 10)}${lpad(`${e.thinkingShareOfOutput.toFixed(0)}%`, 10)}`,
+      )
+    }
+    if (!data.efforts.length) out.push(dim('  No effort levels recorded in these sessions.'))
+    out.push(dim('  thinking: share of the output tokens'), '')
+  } else if (by) {
     /** @type {[string, number, number, number][]} */
     const rows =
       by === 'project'
@@ -122,11 +148,20 @@ export function renderMarkdown(data, { top }) {
     '',
     `_${data.span} · ${plural(S.sessions, 'session')} · ${plural(S.calls, 'reply', 'replies')} · ${usd(S.apiEquivalentUSD)} at API prices · [ReRead](${HOMEPAGE}) ${VERSION}_`,
     '',
+    ...(S.unpriced.calls
+      ? [
+          `> ${plural(S.unpriced.calls, 'reply', 'replies')} from models with no known price (${S.unpriced.models.map((m) => `\`${cell(m)}\``).join(', ')}) are left out of the cost.`,
+          '',
+        ]
+      : []),
     '| Where the usage went | Share |',
     '|---|---:|',
     `| Reading history from the cache | ${S.cacheReadShare.toFixed(1)}% |`,
     `| Writing history again, after the cache was lost | ${S.rebuildShare.toFixed(1)}% |`,
     `| Everything else (new input, first cache writes, output) | ${S.otherShare.toFixed(1)}% |`,
+    ...(S.thinking.tokens
+      ? [`| Of all usage, thinking (${S.thinking.shareOfOutput}% of output tokens) | ${S.thinking.share.toFixed(1)}% |`]
+      : []),
     '',
   ]
   const reasons = REASONS.filter((w) => S.rebuilds[w].count)

package/src/report.html

@@ -373,6 +373,12 @@ footer .links { display: flex; flex-wrap: wrap; gap: 8px 20px; margin-bottom: 12
     </section>
   </div>
 
+  <section class="card" style="margin-top:16px" id="efforts-box" aria-labelledby="h-efforts" hidden>
+    <h2 id="h-efforts">By effort level</h2>
+    <p class="sub" id="efforts-sub">The effort level each reply ran at, and how much of its output was thinking.</p>
+    <div id="efforts"></div>
+  </section>
+
   <section class="card" style="margin-top:16px" id="sessions" aria-labelledby="h-sessions">
     <div class="card-head">
       <div>
@@ -471,7 +477,7 @@ footer .links { display: flex; flex-wrap: wrap; gap: 8px 20px; margin-bottom: 12
   const D = {
     version: S(raw.version), generatedAt: S(raw.generatedAt), span: S(raw.span) || 'your sessions', anon: !!raw.anon,
     daily: arr(raw.daily), buckets: arr(raw.buckets), models: arr(raw.models), projects: arr(raw.projects),
-    sessions: arr(raw.sessions), findings: arr(raw.findings), share: S(raw.share),
+    sessions: arr(raw.sessions), findings: arr(raw.findings), share: S(raw.share), efforts: arr(raw.efforts),
     product: S(raw.product) || 'Claude Code', tools: arr(raw.tools),
   }
   const REASONS = ['cold', 'model', 'prefix']
@@ -796,15 +802,34 @@ footer .links { display: flex; flex-wrap: wrap; gap: 8px 20px; margin-bottom: 12
       return el('tr', null,
         el('td', { class: 'name mono', title: S(m.model), text: S(m.model) || '(unknown)' }),
         el('td', { class: 'num opt', text: int(m.calls) }),
-        el('td', { class: 'num', text: usd(u) }),
+        m.priced === false ? el('td', { class: 'num muted', text: 'no price' }) : el('td', { class: 'num', text: usd(u) }),
         el('td', { class: 'num' }, minibar([['read', r], ['rebuild', b]], pct(r + b, 0))))
     })
-    box.replaceChildren(simpleTable([['Model'], ['Replies', 1, 1], ['Cost', 1], ['Re-reading', 1]], rows),
+    const unpriced = sm.unpriced || {}
+    const note = N(unpriced.calls)
+      ? el('p', { class: 'sub', style: 'margin:12px 0 0', text: `${plural(N(unpriced.calls), 'reply', 'replies')} from models with no known price are left out of every cost and share.` })
+      : ''
+    box.replaceChildren(simpleTable([['Model'], ['Replies', 1, 1], ['Cost', 1], ['Re-reading', 1]], rows), note,
       el('div', { class: 'chart-legend', style: 'margin:12px 0 0' },
         el('span', null, el('i', { class: 'sw read' }), 'Cache reads'),
         el('span', null, el('i', { class: 'sw rebuild' }), 'Written again')))
   }
 
+  function renderEfforts() {
+    if (!D.efforts.length) return
+    const th = sm.thinking || {}
+    $('efforts-box').hidden = false
+    if (N(th.tokens)) $('efforts-sub').textContent = `Thinking was ${pct(N(th.shareOfOutput), 0)} of all output tokens and cost ${usd(N(th.usd))}, ${pct(N(th.share), 1)} of your usage. Effort levels are each tool's own; a level in one tool is not the same as in another.`
+    const rows = D.efforts.map((e) => el('tr', null,
+      el('td', { class: 'name', text: S(e.name) }),
+      el('td', { class: 'name mono', text: S(e.effort) }),
+      el('td', { class: 'num opt', text: int(N(e.calls)) }),
+      el('td', { class: 'num', text: usd(N(e.usd)) }),
+      el('td', { class: 'num' }, minibar([['read', N(e.thinkingShareOfOutput)]], pct(N(e.thinkingShareOfOutput), 0))),
+      el('td', { class: 'num opt', text: usd(N(e.thinkingUsd)) })))
+    $('efforts').replaceChildren(simpleTable([['Tool'], ['Effort'], ['Replies', 1, 1], ['Cost', 1], ['Thinking', 1], ['Thinking cost', 1, 1]], rows))
+  }
+
   // ---------- sessions ----------
   const rebuildsOf = (s) => { const r = s.rebuilds || {}; return { cold: N(r.cold), model: N(r.model), prefix: N(r.prefix) } }
   const rebuildTotal = (s) => { const r = rebuildsOf(s); return r.cold + r.model + r.prefix }
@@ -1182,6 +1207,7 @@ footer .links { display: flex; flex-wrap: wrap; gap: 8px 20px; margin-bottom: 12
   renderWhy()
   renderProjects()
   renderModels()
+  renderEfforts()
   renderSessions()
   renderFindings()
   renderShare()

package/src/statusline.js

@@ -22,7 +22,7 @@ import { walk } from './analyze.js'
 import { pct, tokens } from './format.js'
 import { callOf, collect } from './claude.js'
 import { readLines } from './files.js'
-import { contextOf, priceOf } from './prices.js'
+import { contextOf, hasPrice, priceOf } from './prices.js'
 
 /** @typedef {import('./prices.js').Call} Call */
 
@@ -52,8 +52,11 @@ export function statusline(input, { now = Date.now(), color = false, cacheDir =
   const left = s.warmUntil - now
   const parts = [`ctx ${tokens(s.ctx)}`]
   if (left > 0) parts.push(paint(left < 60e3 ? 33 : 32)(`cache warm ${clock(left)}`))
-  else parts.push(paint(31)(`cache cold: next reply rewrites ${tokens(s.ctx)} (~$${s.rewriteUsd.toFixed(2)})`))
-  parts.push(`re-read ${s.rereadPct.toFixed(0)}%`)
+  else {
+    const price = s.rewriteUsd === null ? '' : ` (~$${s.rewriteUsd.toFixed(2)})`
+    parts.push(paint(31)(`cache cold: next reply rewrites ${tokens(s.ctx)}${price}`))
+  }
+  if (s.rereadPct !== null) parts.push(`re-read ${s.rereadPct.toFixed(0)}%`)
   return parts.join(' · ')
 }
 
@@ -74,6 +77,7 @@ export function sessionState(file, { cacheDir = defaultCacheDir() } = {}) {
   const s = walk([...calls.values()].sort((a, b) => a.ts - b.ts))
   if (!s.lastCall) return null
   const ctx = contextOf(s.lastCall)
+  const priced = hasPrice(s.lastCall.model)
   const p = priceOf(s.lastCall.model, ctx)
   return {
     model: s.lastCall.model,
@@ -82,8 +86,9 @@ export function sessionState(file, { cacheDir = defaultCacheDir() } = {}) {
     /** the cache's life: 5 minutes, or 1 hour once the session has written to the 1-hour cache */
     ttl: s.ttl,
     warmUntil: s.lastCall.ts + s.ttl,
-    rewriteUsd: (ctx * (s.ttl > 300e3 ? p.write1h : p.write5m)) / 1e6,
-    rereadPct: pct(s.readCost + s.rebuildCost, s.cost),
+    /** null when the model has no known price */
+    rewriteUsd: priced ? (ctx * (s.ttl > 300e3 ? p.write1h : p.write5m)) / 1e6 : null,
+    rereadPct: priced && s.cost > 0 ? pct(s.readCost + s.rebuildCost, s.cost) : null,
     usd: s.cost,
     replies: calls.size,
   }

package/src/tools.js

@@ -16,6 +16,7 @@ import { existingDirs, filesUnder } from './files.js'
  * @property {string} cwd     the folder it ran in, or ''
  * @property {string} branch  its git branch, or ''
  * @property {import('./prices.js').Call[]} calls  its replies, oldest first
+ * @property {boolean} [unread]  a file this Node.js cannot read (a compressed one), so its replies are missing
  */
 
 /**