reread-cli 0.2.0 → 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 both.
+- **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
@@ -76,6 +78,14 @@ Then add it to `~/.claude/settings.json`:
 
 More in [docs/statusline.md](docs/statusline.md).
 
+## In VS Code
+
+The [ReRead extension](vscode/README.md) shows the same countdown in the editor's status bar, for the latest Claude Code
+session in your workspace, whether Claude Code runs in the terminal or in the editor. Click it for the report of that
+workspace, in an editor tab. Install it from the
+[VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=hamperpick.reread), or from
+[Open VSX](https://open-vsx.org/extension/hamperpick/reread) for Cursor, Antigravity and other editors that use it.
+
 ## Options
 
 ```
@@ -95,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
 ```
@@ -104,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
@@ -132,8 +143,13 @@ 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.
 
-The details, with every rule and threshold: [docs/how-it-counts.md](docs/how-it-counts.md). Neither tool documents its
-session format, and either may change it; if ReRead reads yours wrong, please
+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).
 
 Want to see what caching saves for a prompt of your own? The
@@ -173,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
@@ -189,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/bin/reread.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// ReRead: how much of your Claude Code usage was re-reading context.
+// ReRead: how much of your coding agent's usage was re-reading context.
 import { main } from '../src/cli.js'
 
 process.exitCode = await main(process.argv.slice(2))

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reread-cli",
-  "version": "0.2.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, 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

@@ -2,9 +2,10 @@
 // Counting: what each reply cost, how much of it was re-reading history, and when the whole history had to be
 // written again.
 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 */
@@ -55,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]
@@ -71,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 },
 })
@@ -90,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
@@ -108,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
  */
@@ -137,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
@@ -166,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
@@ -182,15 +218,17 @@ 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
  */
 
 /**
  * Read and count session files.
  * @param {string[]} files  in the order sessionFiles() gives
- * @param {{ since: number, project?: string, onProgress?: (done: number, total: number) => void }} opts
+ * @param {{ since: number, project?: string, folders?: string[], onProgress?: (done: number, total: number) => void }} opts
+ *   folders: only sessions that ran in one of these folders or a folder inside one.
  *   A file that cannot be read (removed meanwhile, no permission, a broken archive) is skipped and listed in `skipped`.
  */
-export function analyze(files, { since, project = '', onProgress }) {
+export function analyze(files, { since, project = '', folders = [], onProgress }) {
   const needle = project.toLowerCase()
   /** @type {Set<string>} */
   const seen = new Set()
@@ -203,6 +241,8 @@ export function analyze(files, { since, project = '', 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
@@ -220,6 +260,8 @@ export function analyze(files, { since, project = '', 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)
@@ -234,16 +276,30 @@ export function analyze(files, { since, project = '', onProgress }) {
       return
     }
     const { id, sub, cwd, branch, calls } = read
+    if (read.unread) unread.push(file)
     if (!calls.some((c) => !c.seen)) return
-    if (!(/** @type {import('./tools.js').ToolInfo} */ (TOOLS[tool]).projectInPath) && needle) {
+    const info = /** @type {import('./tools.js').ToolInfo} */ (TOOLS[tool])
+    if (!info.projectInPath && needle) {
       if (!cwd.toLowerCase().includes(needle)) return
     }
+    // A file with no folder in it (a subagent's) was already chosen by its path, where the path holds the project.
+    if (folders.length && !(cwd ? folders.some((f) => isInside(cwd, f)) : info.projectInPath)) return
     const cur = sessions.get(id) ?? { id, tool, project: '', branch: '', points: [], ...emptyTotals() }
     const s = walk(calls, (c, x) => {
       tally(daily, dayOf(c.ts), x)
       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)
@@ -252,7 +308,16 @@ export function analyze(files, { since, project = '', 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,
+  }
 }
 
 /**
@@ -352,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(
@@ -379,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

@@ -2,12 +2,17 @@
 // Reading Claude Code's session files: ~/.claude/projects/<folder>/<session-id>.jsonl, a subagent's in
 // <session-id>/subagents/. Each line is one JSON event; ReRead keeps only the token counts, model, time and id of each
 // reply, plus the folder and git branch of the session. It never keeps or prints what was written in the conversation.
+import { closeSync, openSync, readdirSync, readSync, statSync } from 'node:fs'
 import { homedir } from 'node:os'
 import path from 'node:path'
-import { eachLine } from './files.js'
+import { eachLine, existingDirs, isInside, splitLines } from './files.js'
 
 /** @typedef {import('./prices.js').Call} Call */
 
+const USAGE = Buffer.from('"usage"')
+const CWD = Buffer.from('"cwd"')
+const BRANCH = Buffer.from('"gitBranch"')
+
 /**
  * The folders Claude Code may keep sessions in, most specific first.
  * @param {NodeJS.ProcessEnv} [env]
@@ -22,8 +27,94 @@ export function claudeDirs(env = process.env, home = homedir()) {
 }
 
 /**
- * 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.
+ * The folder name Claude Code gives a project: its path, with every character that is not a letter or digit as '-'.
+ * Different paths can share a name ('a b' and 'a-b'), so a session's own `cwd` is what decides.
+ * @param {string} cwd
+ */
+export const claudeFolderName = (cwd) => cwd.replace(/[^a-zA-Z0-9]/g, '-')
+
+/**
+ * The folder a session ran in, from the first line that names it (near the top of the file), or ''.
+ * @param {string} file
+ */
+export function cwdOf(file) {
+  let fd
+  try {
+    fd = openSync(file, 'r')
+    const buf = Buffer.alloc(256 * 1024)
+    const got = readSync(fd, buf, 0, buf.length, 0)
+    let cwd = ''
+    splitLines(buf.subarray(0, got), (line) => {
+      if (cwd || !line.includes(CWD)) return
+      try {
+        const v = JSON.parse(line.toString('utf8')).cwd
+        if (typeof v === 'string') cwd = v
+      } catch {
+        /* not JSON, or cut off at the end of the buffer */
+      }
+    })
+    return cwd
+  } catch {
+    return ''
+  } finally {
+    if (fd !== undefined) closeSync(fd)
+  }
+}
+
+/**
+ * The session file written to last, of the sessions that ran in one of these folders or a folder inside one. Subagent
+ * files are left out: the status of a session is its main file's.
+ * @param {string[]} folders
+ * @param {{ dirs?: string[], cwdCache?: Map<string, string> }} [opts]  cwdCache: file to cwd, kept between calls
+ * @returns {string | null}
+ */
+export function latestClaudeSession(folders, { dirs = claudeDirs(), cwdCache = new Map() } = {}) {
+  const root = existingDirs(dirs)[0]
+  if (!root || !folders.length) return null
+  const names = folders.map(claudeFolderName)
+  let best = null
+  let bestTime = -1
+  let entries
+  try {
+    entries = readdirSync(root, { withFileTypes: true })
+  } catch {
+    return null
+  }
+  for (const d of entries) {
+    if (!d.isDirectory() || !names.some((n) => d.name === n || d.name.startsWith(`${n}-`))) continue
+    const dir = path.join(root, d.name)
+    let files
+    try {
+      files = readdirSync(dir)
+    } catch {
+      continue
+    }
+    for (const name of files) {
+      if (!name.endsWith('.jsonl')) continue
+      const f = path.join(dir, name)
+      let t
+      try {
+        t = statSync(f).mtimeMs
+      } catch {
+        continue
+      }
+      if (t <= bestTime) continue
+      let cwd = cwdCache.get(f)
+      if (cwd === undefined) {
+        cwd = cwdOf(f)
+        if (cwd) cwdCache.set(f, cwd)
+      }
+      if (!cwd || !folders.some((folder) => isInside(cwd, folder))) continue
+      best = f
+      bestTime = t
+    }
+  }
+  return best
+}
+
+/**
+ * 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}
@@ -45,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,
@@ -53,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 : '',
   }
 }
 
@@ -65,14 +159,12 @@ 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)
 }
 
-const USAGE = Buffer.from('"usage"')
-const CWD = Buffer.from('"cwd"')
-const BRANCH = Buffer.from('"gitBranch"')
-
 /**
  * Read the replies of one session file. A resumed or forked session copies the replies it carries over into its new
  * file: those are marked `seen` (walked for the cache, counted once) and every key is added to `seen`.
@@ -110,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/files.js

@@ -28,6 +28,20 @@ export function filesUnder(dir, keep) {
   return out
 }
 
+/**
+ * Whether a path is a folder or inside it. Paths are compared as written, ignoring case on macOS and Windows, whose
+ * disks usually do.
+ * @param {string} p
+ * @param {string} folder
+ */
+export function isInside(p, folder) {
+  const fold = process.platform === 'darwin' || process.platform === 'win32'
+  const a = path.resolve(p)
+  const b = path.resolve(folder)
+  const [x, y] = fold ? [a.toLowerCase(), b.toLowerCase()] : [a, b]
+  return x === y || x.startsWith(y.endsWith(path.sep) ? y : y + path.sep)
+}
+
 /** The folders that exist. */
 export const existingDirs = (/** @type {string[]} */ dirs) => dirs.filter((d) => existsSync(d))
 

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 }
@@ -1100,7 +1125,15 @@ footer .links { display: flex; flex-wrap: wrap; gap: 8px 20px; margin-bottom: 12
     ctx.fillStyle = '#f0efec'; ctx.fillText(cmd, W - P - cw - 18, H - 72)
     return c
   }
+  // Inside the VS Code extension the page cannot download; it hands the file to the editor, which asks where to save it.
+  const editor = typeof acquireVsCodeApi === 'function' ? acquireVsCodeApi() : null
   function download(name, blob) {
+    if (editor) {
+      const r = new FileReader()
+      r.onload = () => editor.postMessage({ type: 'save', name, data: r.result })
+      r.readAsDataURL(blob)
+      return
+    }
     const url = URL.createObjectURL(blob)
     const a = el('a', { href: url, download: name, style: 'display:none' })
     document.body.append(a); a.click(); a.remove()
@@ -1126,7 +1159,7 @@ footer .links { display: flex; flex-wrap: wrap; gap: 8px 20px; margin-bottom: 12
     $('copy-text').addEventListener('click', async () => say((await copy(shareText())) ? 'Copied.' : 'Could not copy. Select the text above instead.'))
     $('download-image').addEventListener('click', () => {
       const c = drawCard()
-      if (c.toBlob) c.toBlob((b) => { if (b) { download(`reread-${stamp()}.png`, b); say('Image saved.') } }, 'image/png')
+      if (c.toBlob) c.toBlob((b) => { if (b) { download(`reread-${stamp()}.png`, b); if (!editor) say('Image saved.') } }, 'image/png')
     })
   }
 
@@ -1174,9 +1207,11 @@ footer .links { display: flex; flex-wrap: wrap; gap: 8px 20px; margin-bottom: 12
   renderWhy()
   renderProjects()
   renderModels()
+  renderEfforts()
   renderSessions()
   renderFindings()
   renderShare()
+  if (editor) editor.postMessage({ type: 'ready' })
 })()
 </script>
 </body>

package/src/statusline.js

@@ -20,9 +20,9 @@ import { tmpdir } from 'node:os'
 import path from 'node:path'
 import { walk } from './analyze.js'
 import { pct, tokens } from './format.js'
-import { contextOf, priceOf } from './prices.js'
 import { callOf, collect } from './claude.js'
 import { readLines } from './files.js'
+import { contextOf, hasPrice, priceOf } from './prices.js'
 
 /** @typedef {import('./prices.js').Call} Call */
 
@@ -45,25 +45,53 @@ export function statusline(input, { now = Date.now(), color = false, cacheDir =
   }
   if (!file || !existsSync(file)) return 'reread: no session yet'
 
-  const calls = readCalls(file, cacheDir)
-  const s = walk([...calls.values()].sort((a, b) => a.ts - b.ts))
-  if (!s.lastCall) return 'reread: no replies yet'
+  const s = sessionState(file, { cacheDir })
+  if (!s) return 'reread: no replies yet'
 
   const paint = (/** @type {number} */ code) => (/** @type {string} */ t) => (color ? `\x1b[${code}m${t}\x1b[0m` : t)
+  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 {
+    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(' · ')
+}
+
+/**
+ * Minutes and seconds, as 3:41.
+ * @param {number} ms
+ */
+export const clock = (ms) => `${Math.floor(ms / 60e3)}:${String(Math.floor((ms % 60e3) / 1e3)).padStart(2, '0')}`
+
+/**
+ * Where a session stands: the context its last reply sent, until when the cache stays warm, what writing the context
+ * to the cache again would cost, and how much of the session so far was re-reading. Null before the first reply.
+ * @param {string} file
+ * @param {{ cacheDir?: string | null }} [opts]  cacheDir null: no cache
+ */
+export function sessionState(file, { cacheDir = defaultCacheDir() } = {}) {
+  const calls = readCalls(file, cacheDir)
+  const s = walk([...calls.values()].sort((a, b) => a.ts - b.ts))
+  if (!s.lastCall) return null
   const ctx = contextOf(s.lastCall)
-  const left = s.ttl - (now - s.lastCall.ts)
+  const priced = hasPrice(s.lastCall.model)
   const p = priceOf(s.lastCall.model, ctx)
-  const parts = [`ctx ${tokens(ctx)}`]
-  if (left > 0) {
-    const m = Math.floor(left / 60e3)
-    const sec = Math.floor((left % 60e3) / 1e3)
-    parts.push(paint(left < 60e3 ? 33 : 32)(`cache warm ${m}:${String(sec).padStart(2, '0')}`))
-  } else {
-    const rewrite = (ctx * (s.ttl > 300e3 ? p.write1h : p.write5m)) / 1e6
-    parts.push(paint(31)(`cache cold: next reply rewrites ${tokens(ctx)} (~$${rewrite.toFixed(2)})`))
+  return {
+    model: s.lastCall.model,
+    ctx,
+    lastReply: s.lastCall.ts,
+    /** 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,
+    /** 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,
   }
-  parts.push(`re-read ${pct(s.readCost + s.rebuildCost, s.cost).toFixed(0)}%`)
-  return parts.join(' · ')
 }
 
 /**
@@ -107,7 +135,7 @@ function readCalls(file, cacheDir) {
  * A per-user folder for the cache, or null when one cannot be made safely.
  * @returns {string | null}
  */
-function defaultCacheDir() {
+export function defaultCacheDir() {
   const uid = typeof process.getuid === 'function' ? process.getuid() : null
   const dir = path.join(tmpdir(), `reread-${uid ?? 'user'}`)
   try {

package/src/tools.js

@@ -4,7 +4,7 @@
 import { statSync } from 'node:fs'
 import path from 'node:path'
 import { antigravityDirs, isAntigravityFile, isAntigravityOther, readAntigravityFile } from './antigravity.js'
-import { claudeDirs, readClaudeFile } from './claude.js'
+import { claudeDirs, claudeFolderName, readClaudeFile } from './claude.js'
 import { codexDirs, isCodexFile, readCodexFile } from './codex.js'
 import { existingDirs, filesUnder } from './files.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
  */
 
 /**
@@ -28,6 +29,7 @@ import { existingDirs, filesUnder } from './files.js'
  * @property {(file: string) => boolean} [ignores]  a file in its folders that is not a session
  * @property {(file: string, since: number, seen: Set<string>) => Read} read
  * @property {boolean} [projectInPath]  its folder names hold the project, so --project filters paths
+ * @property {(cwd: string) => string} [folderName]  the name of the folder it keeps a project's sessions in
  */
 
 /** In the order a file is matched: the more specific names first, Claude Code's plain .jsonl last. */
@@ -55,6 +57,7 @@ export const TOOLS = /** @type {const} */ ({
     owns: (/** @type {string} */ f) => f.endsWith('.jsonl'),
     read: readClaudeFile,
     projectInPath: true,
+    folderName: claudeFolderName,
   },
 })
 /** @typedef {keyof typeof TOOLS} Tool */
@@ -101,12 +104,19 @@ export function rootsFor(tool, dir) {
 /**
  * The session files to read: changed at or after `since`, of the chosen tool, oldest first, so a reply copied into a
  * resumed session is counted in the session that made it. Where a tool's folder names hold the project, `project`
- * filters paths here; the other tools name the folder inside, so analyze() filters those.
+ * and `folders` filter paths here; the other tools name the folder inside, so analyze() filters those.
  * @param {string[]} roots
- * @param {{ since: number, project: string, tool: 'all' | Tool }} filter
+ * @param {{ since: number, project: string, tool: 'all' | Tool, folders?: string[] }} filter
  */
-export function sessionFiles(roots, { since, project, tool }) {
+export function sessionFiles(roots, { since, project, tool, folders = [] }) {
   const needle = project.toLowerCase()
+  /** @param {Tool} t @param {string} root @param {string} f */
+  const inFolders = (t, root, f) => {
+    const name = INFO[t].folderName
+    if (!folders.length || !name) return true
+    const top = path.relative(root, f).split(path.sep)[0]
+    return folders.some((d) => top === name(d) || top.startsWith(`${name(d)}-`))
+  }
   /** @type {[string, number, number][]} */
   const found = []
   for (const root of roots) {
@@ -114,6 +124,7 @@ export function sessionFiles(roots, { since, project, tool }) {
       const t = /** @type {Tool} */ (toolOf(f))
       if (tool !== 'all' && t !== tool) continue
       if (needle && INFO[t].projectInPath && !path.relative(root, f).toLowerCase().includes(needle)) continue
+      if (!inFolders(t, root, f)) continue
       let st
       try {
         st = statSync(f)