burner-cc 0.1.2 → 0.3.1

package/README.md

@@ -1,35 +1,95 @@
-<img src="assets/logo-mark.png" alt="Burner" width="90" />
+<img src="assets/logo-mark.png" alt="Burner" width="90" />
 
 # burner
 
-Itemized dollar-and-token cost receipts for Claude Code sessions.
+What your Claude Code sessions cost, and what they were for — itemized receipts, projects, intent tagging, and a local analytics app.
 
-## Usage
+Zero runtime dependencies. Reads `~/.claude/projects/` on your machine. Only network use by default is refreshing public model prices (optional).
 
+## Install
+
+```bash
+npm install -g burner-cc
+# commands: burner  (alias entry: burner-cc)
 ```
-npx burner-cc                 # latest session -> opens a receipt
-npx burner-cc <session-id>    # specific session (accepts a title, slug, or id prefix)
-npx burner-cc --all           # every session found, sliding through one receipt each
-npx burner-cc list            # quick terminal table, no browser
-npx burner-cc --json          # machine-readable, no browser
+
+Or without installing:
+
+```bash
+npx burner-cc
 ```
 
-Or install it globally: `npm install -g burner-cc`, then run `burner-cc` directly.
+**Node 18+** required.
 
-### Local development
+## Quick start
 
+```bash
+burner                 # opens http://127.0.0.1:4777 (report + Settings)
+burner serve           # same; --port N, --no-open
+burner install         # global /burner-tag skill + tagging level from ~/.burner/config.yaml
 ```
-node bin/burner-cc.js <same args as above>
+
+Settings covers **projects**, **categories**, **pricing** (pin/refresh per model), and **tagging** (slider, session-end model, train your intent model).
+
+## Commands
+
+```bash
+burner list [--json] [--project NAME] [--from YYYY-MM-DD] [--to YYYY-MM-DD]
+burner receipt [session-id|title]     # one receipt HTML under ~/.burner/
+burner report [--no-open]               # static report.html + receipt-*.html
+
+burner tag <category> [--session ID] [--reason TEXT] [--task]
+burner tag --clear [--session ID]
+burner install | uninstall | status
+
+burner pricing refresh
+burner model train [--data FILE.jsonl] [--swe-chat] [--prior]
 ```
 
-## How it works
+`burner tag` is what `/burner-tag` runs. After `npm i -g burner-cc`, hooks and the skill use the `burner` command on your PATH.
+
+## Categories
+
+Intent, not tool counts — e.g. reading files to fix a bug is **debugging**, not research.
+
+Default ids: `coding` · `debugging` · `planning` · `research` · `writing` · `analysis` · `review` · `learning` · `other` (editable in Settings).
+
+Resolution order:
+
+1. Tag (`/burner-tag`, receipt picker, session-end model, or CLI)
+2. Project default category
+3. **Your trained model** (optional; only if enabled and confidence ≥ 60%)
+4. Otherwise **untagged** — no folder-name or tool-ratio guessing
+
+## Tagging levels (Settings)
+
+| Level | Behavior |
+|--------|----------|
+| Off | Removes global skill / hooks |
+| Manual | `/burner-tag` only; skill stays installed |
+| Session end | SessionEnd hook + optional Anthropic model id, or CLAUDE.md asks Claude to tag via `/burner-tag` |
+| Every task | CLAUDE.md asks Claude to tag each task (`--task`) |
+
+Moving the slider (or saving session-end model) updates `~/.claude` automatically. Use **Train from my tags** in Settings for a local naive-Bayes model (`~/.burner/model/intent-nb.json`). Training is pure Node — no GPU or Python. CLI `burner model train` does the same; `--prior` / `--swe-chat` are optional extras.
+
+## Tokens & pricing
+
+- One API request → several transcript lines; burner bills the **last** chunk per `requestId`, dedupes continued sessions, rolls subagents into the parent.
+- Totals: fresh input, cache write (5m/1h), cache read, output.
+- **Claude** models: public LiteLLM price list (daily refresh, offline snapshot fallback).
+- **Other** models (gateway, on-prem, local): **$0** until you set a price in Settings.
+
+## Files
 
-- **Discovery** (`src/discover.js`) walks `~/.claude/projects/**/*.jsonl`, matching each top-level session transcript with any `subagents/agent-*.jsonl` files spawned inside it (those are billed separately by the API and get folded into the parent session's receipt).
-- **Parsing** (`src/parse.js`) reads each assistant turn's `usage` block (input/output/cache-write/cache-read tokens) straight from the transcript.
-- **Pricing** (`src/pricing.js`) is fetched automatically — no file to hand-edit. It pulls Anthropic's per-model rates from [LiteLLM's community-maintained pricing JSON](https://github.com/BerriAI/litellm) (sourced from `platform.claude.com/docs/.../pricing`), caches it locally for 6 hours, and falls back to a stale cache or a small bundled snapshot (`src/pricing-fallback.json`) if offline.
-- **Receipt** (`src/build-receipt.js`) groups tokens by model and computes cost per token-type line.
-- **Rendering** (`src/render.js` + `web/`) injects the receipt JSON into `web/receipt.html` and opens it in the default browser. Theme buttons (paper / thermal / matrix / dark) switch CSS variables client-side.
+| Path | Purpose |
+|------|---------|
+| `~/.burner/config.yaml` | projects, categories, tagging, UI theme/range |
+| `~/.burner/pricing.yaml` | your USD/1M overrides |
+| `~/.burner/tags.json` | session tags |
+| `~/.burner/assignments.json` | per-session project overrides |
+| `~/.burner/model/intent-nb.json` | your trained intent model |
+| `~/.claude/skills/burner-tag/` | global skill (`burner install`) |
 
-## What this is not
+`BURNER_HOME` and `CLAUDE_CONFIG_DIR` override `~/.burner` and `~/.claude`. Legacy `~/.ti-burner` data is migrated on first run.
 
-Not official billing. Composition breakdown by *source* (system prompt vs. skills vs. MCP tool schemas) isn't available from local transcripts alone — that needs request interception, which this tool doesn't do. The receipt instead itemizes by token *type*: fresh input, cache write, cache read, output.
+*Not official Anthropic billing.*

package/bin/burner.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../src/cli.js';

package/package.json

@@ -1,16 +1,23 @@
 {
   "name": "burner-cc",
-  "version": "0.1.2",
-  "description": "Itemized dollar-and-token cost receipts for Claude Code sessions.",
+  "version": "0.3.1",
+  "description": "What your Claude Code sessions cost, and what they were for — itemized receipts, projects, intent tagging.",
   "type": "module",
   "bin": {
+    "burner": "bin/burner.js",
     "burner-cc": "bin/burner-cc.js"
   },
   "files": [
     "bin",
     "src",
-    "web"
+    "assets",
+    "vendor"
   ],
+  "scripts": {
+    "test": "node --test",
+    "train-prior": "node scripts/train-prior.mjs",
+    "train-prior:offline": "node scripts/train-prior.mjs --offline"
+  },
   "keywords": [
     "claude-code",
     "claude",
@@ -19,16 +26,12 @@
     "tokens",
     "cli",
     "usage",
-    "billing"
+    "analytics"
   ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shoryasethia/burner.git"
   },
-  "homepage": "https://github.com/shoryasethia/burner#readme",
-  "bugs": {
-    "url": "https://github.com/shoryasethia/burner/issues"
-  },
   "engines": {
     "node": ">=18"
   },

package/src/analyze.js

@@ -0,0 +1,241 @@
+// Reads every session, prices it, resolves its project and category, and
+// returns the data behind the report, receipts and settings pages.
+
+import { discoverSessions } from './discover.js';
+import { parseTranscript, timeRange, mergeParsed } from './parse.js';
+import { priceAttribution, summarizeSubagentsByType, activityFrom } from './build-receipt.js';
+import { loadPricingTable, lookupPricing, costFor, pricingInfo } from './pricing.js';
+import { loadConfig, resolveProject, UNTAGGED } from './config.js';
+import { loadTags, segmentTurns, loadAssignments, resolveSessionProject } from './tags.js';
+import { resolveCategory, buildDigest, loadLearned } from './classifier.js';
+
+const zeroTokens = () => ({ input: 0, output: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0 });
+const zeroCost = () => ({ input: 0, output: 0, cacheWrite: 0, cacheRead: 0, total: 0 });
+
+function addTokens(into, t) {
+  into.input += t.input;
+  into.output += t.output;
+  into.cacheWrite5m += t.cacheWrite5m;
+  into.cacheWrite1h += t.cacheWrite1h;
+  into.cacheRead += t.cacheRead;
+}
+
+function addCost(into, c) {
+  if (!c) return;
+  for (const k of Object.keys(into)) into[k] += c[k];
+}
+
+export function tokenTotal(t) {
+  return t.input + t.output + (t.cacheWrite ?? t.cacheWrite5m + t.cacheWrite1h) + t.cacheRead;
+}
+
+function priceTurns(turns, table) {
+  const byModel = new Map();
+  for (const t of turns) {
+    if (!byModel.has(t.model)) byModel.set(t.model, { rawModel: t.model, tokens: zeroTokens(), turnCount: 0, unreported: 0 });
+    const b = byModel.get(t.model);
+    b.turnCount += 1;
+    if (t.unreported) b.unreported += 1;
+    addTokens(b.tokens, t);
+  }
+  const models = [];
+  const tokens = zeroTokens();
+  const cost = zeroCost();
+  for (const b of byModel.values()) {
+    const priced = lookupPricing(b.rawModel, table);
+    const c = costFor(b.tokens, priced.rates);
+    models.push({ rawModel: b.rawModel, fidelity: priced.fidelity, turnCount: b.turnCount, unreported: b.unreported, tokens: b.tokens, cost: c, unpriced: priced.fidelity === 'unpriced' });
+    addTokens(tokens, b.tokens);
+    addCost(cost, c);
+  }
+  models.sort((a, b) => b.cost.total - a.cost.total || tokenTotal(b.tokens) - tokenTotal(a.tokens));
+  return { models, tokens, cost };
+}
+
+// Spend per calendar day (UTC, like the session date): a session that ran for
+// weeks should not show up as one lump on the day it started.
+function dailySpend(turns, table) {
+  const byDay = new Map();
+  for (const t of turns) {
+    if (!t.timestamp) continue;
+    const day = new Date(t.timestamp).toISOString().slice(0, 10);
+    if (!byDay.has(day)) byDay.set(day, []);
+    byDay.get(day).push(t);
+  }
+  return [...byDay.entries()].sort((x, y) => (x[0] < y[0] ? -1 : 1)).map(([date, ts]) => {
+    const p = priceTurns(ts, table);
+    return { date, turns: ts.length, cost: p.cost.total, tokens: tokenTotal(p.tokens) };
+  });
+}
+
+function agentInvocations(parsedList) {
+  const counts = {};
+  for (const p of parsedList) {
+    for (const step of p.digest?.tools ?? []) {
+      if (step.startsWith('Task(') || step.startsWith('Agent(')) counts[step] = (counts[step] ?? 0) + 1;
+    }
+  }
+  return counts;
+}
+
+function ccReportedCost(reported) {
+  if (!reported?.modelUsage) return null;
+  let total = 0;
+  for (const u of Object.values(reported.modelUsage)) {
+    const n = u?.costUSD ?? u?.totalCost ?? u?.cost;
+    if (typeof n === 'number') total += n;
+  }
+  return total > 0 ? total : null;
+}
+
+function within(s, opts) {
+  if (opts.from && s.mtime < new Date(opts.from).getTime()) return false;
+  if (opts.to && s.mtime > new Date(opts.to + 'T23:59:59').getTime()) return false;
+  return true;
+}
+
+export async function analyzeSessions(opts = {}) {
+  const cfg = opts.config ?? loadConfig();
+  const table = opts.table ?? (await loadPricingTable({ offline: opts.offline }));
+  const tags = loadTags();
+  const assignments = loadAssignments();
+  const learned = loadLearned();
+  const discovered = discoverSessions(opts.claudeHome);
+
+  // Oldest first: a continued session re-logs requests from its parent;
+  // they're billed to the session that made them.
+  const seenRequests = new Set();
+  const results = [];
+  const digests = new Map();
+  const modelIndex = new Map();
+  const cwdIndex = new Map();
+  const projectTotals = new Map();
+
+  for (const session of [...discovered].reverse()) {
+    const main = parseTranscript(session.mainFile);
+    const subs = session.subagentFiles.map(({ file, meta }) => ({ file, meta, parsed: parseTranscript(file) }));
+    const fresh = (turns) => turns.filter((t) => {
+      if (seenRequests.has(t.requestId)) return false;
+      seenRequests.add(t.requestId);
+      return true;
+    });
+    const mainTurns = fresh(main.turns);
+    const subTurns = subs.flatMap((s) => fresh(s.parsed.turns));
+    const turns = [...mainTurns, ...subTurns];
+    if (!turns.length && !main.digest.prompts.length) continue;
+
+    const cwd = main.digest.cwd;
+    const project = resolveSessionProject(session.sessionId, cwd, cfg, assignments);
+    const dirProject = resolveProject(cwd, cfg);
+    const digest = buildDigest(main, { title: session.title, projectName: project.name });
+    const { models, tokens, cost } = priceTurns(turns, table);
+    const tag = tags[session.sessionId];
+
+    let { category, source, confidence } = resolveCategory({ tag, project, cfg, digest, learned });
+    let split = null;
+    const groups = segmentTurns(turns, tag?.segments);
+    if (groups && groups.length > 1) {
+      const byCat = new Map();
+      for (const g of groups) {
+        const p = priceTurns(g.turns, table);
+        const row = byCat.get(g.category) ?? { category: g.category, tokens: 0, cost: 0, turns: 0 };
+        row.tokens += tokenTotal(p.tokens);
+        row.cost += p.cost.total;
+        row.turns += g.turns.length;
+        byCat.set(g.category, row);
+      }
+      split = [...byCat.values()].sort((a, b) => b.cost - a.cost || b.tokens - a.tokens);
+      if (split[0].cost > 0 || split[0].tokens > 0) category = split[0].category;
+    }
+
+    const range = timeRange(turns);
+    const totalTokens = { input: tokens.input, output: tokens.output, cacheWrite: tokens.cacheWrite5m + tokens.cacheWrite1h, cacheRead: tokens.cacheRead };
+    totalTokens.total = tokenTotal(totalTokens);
+    const promptSide = totalTokens.input + totalTokens.cacheWrite + totalTokens.cacheRead;
+
+    const row = {
+      sessionId: session.sessionId,
+      title: session.customTitle ?? main.digest.aiTitle ?? session.slug ?? session.sessionId.slice(0, 8),
+      project: project.name,
+      projectImplicit: project.implicit,
+      projectSource: project.bySession ? 'session' : project.implicit ? 'none' : 'directory',
+      cwd,
+      gitBranch: main.digest.gitBranch,
+      date: new Date(range.startedAt ?? session.mtime).toISOString().slice(0, 10),
+      mtime: session.mtime,
+      startedAt: range.startedAt,
+      endedAt: range.endedAt,
+      durationMin: range.startedAt && range.endedAt ? Math.round((new Date(range.endedAt) - new Date(range.startedAt)) / 60000) : null,
+      turnCount: mainTurns.length,
+      subagentTurnCount: subTurns.length,
+      subagentCount: session.subagentFiles.length,
+      promptCount: main.digest.prompts.length,
+      models,
+      daily: dailySpend(turns, table),
+      totalTokens,
+      totalCost: cost,
+      hasUnpriced: models.some((m) => m.unpriced),
+      cacheHitRate: promptSide ? Math.round((totalTokens.cacheRead / promptSide) * 100) : 0,
+      category,
+      categorySource: source,
+      confidence: confidence ?? null,
+      categorySplit: split,
+      tagReason: tag?.reason ?? null,
+      activity: activityFrom(mergeParsed([main, ...subs.map((s) => s.parsed)])),
+      attribution: priceAttribution(mergeParsed([main, ...subs.map((s) => s.parsed)]), table),
+      subagentGroups: summarizeSubagentsByType(session.subagentFiles, table),
+      subagentRuns: subs.map(({ meta }) => ({
+        type: meta?.agentType ?? 'unknown',
+        description: meta?.description ?? null,
+        spawnDepth: meta?.spawnDepth ?? null,
+      })),
+      agents: agentInvocations([main, ...subs.map((s) => s.parsed)]),
+      ccReportedCost: ccReportedCost(main.reported),
+    };
+    if (opts.project && !row.project.toLowerCase().includes(opts.project.toLowerCase())) continue;
+    if (!within(session, opts)) continue;
+    results.push(row);
+    digests.set(session.sessionId, digest);
+
+    for (const m of models) {
+      const e = modelIndex.get(m.rawModel) ?? { rawModel: m.rawModel, sessions: 0, unreported: 0, tokens: zeroTokens(), cost: 0 };
+      e.sessions += 1;
+      e.unreported += m.unreported ?? 0;
+      addTokens(e.tokens, m.tokens);
+      e.cost += m.cost.total;
+      modelIndex.set(m.rawModel, e);
+    }
+    if (cwd) {
+      const e = cwdIndex.get(cwd) ?? { cwd, project: dirProject.name, implicit: dirProject.implicit, sessions: 0, moved: 0, cost: 0, lastUsed: 0 };
+      if (project.bySession) e.moved += 1;
+      else { e.sessions += 1; e.cost += cost.total; }
+      e.lastUsed = Math.max(e.lastUsed, session.mtime);
+      cwdIndex.set(cwd, e);
+    }
+    const pt = projectTotals.get(project.name) ?? { name: project.name, sessions: 0, cost: 0, implicit: project.implicit };
+    pt.sessions += 1;
+    pt.cost += cost.total;
+    projectTotals.set(project.name, pt);
+  }
+
+  results.sort((a, b) => b.mtime - a.mtime);
+
+  const models = [...modelIndex.values()].map((e) => {
+    const p = lookupPricing(e.rawModel, table);
+    return { ...e, fidelity: p.fidelity, rates: p.rates, suggested: p.suggested };
+  }).sort((a, b) => b.sessions - a.sessions);
+
+  return {
+    sessions: results,
+    models,
+    directories: [...cwdIndex.values()].filter((d) => d.sessions || d.moved).sort((a, b) => b.lastUsed - a.lastUsed),
+    projectTotals: [...projectTotals.values()],
+    categories: [...cfg.categories, UNTAGGED],
+    config: cfg,
+    pricing: pricingInfo(table),
+    pricingSource: table.source,
+    generatedAt: new Date().toISOString(),
+    unpricedModels: models.filter((m) => m.fidelity === 'unpriced').map((m) => m.rawModel),
+    digests,
+  };
+}

package/src/build-receipt.js

@@ -1,17 +1,20 @@
-import { parseTranscript, timeRange, mergeActivity } from './parse.js';
+import { parseTranscript, timeRange, mergeParsed } from './parse.js';
 import { lookupPricing, costFor, loadPricingTable } from './pricing.js';
 
+// Shown on the receipt and in --json. The dollars below are a slice of the
+// session total, not a second charge.
+export const ATTRIBUTION_NOTE =
+  'Call output is that API request\'s output tokens. Context added is the next request\'s fresh input and cache write — an upper bound, since it also includes the call message. These amounts are already inside the session total. MCP tool schemas cached in the prompt are not in the transcript.';
+
 function summarizeTurns(turns, table) {
-  // Group by the *priced* model identity (post lookup), not the raw string,
-  // so aliases like "sonnet" fold into the concrete model they resolved to.
   const byModel = new Map();
 
   for (const t of turns) {
-    const priced = lookupPricing(t.model, table);
-    const key = priced.displayName;
+    const key = t.model;
     if (!byModel.has(key)) {
+      const priced = lookupPricing(t.model, table);
       byModel.set(key, {
-        displayName: priced.displayName,
+        rawModel: t.model,
         fidelity: priced.fidelity,
         rates: priced.rates,
         tokens: { input: 0, output: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0 },
@@ -31,7 +34,7 @@ function summarizeTurns(turns, table) {
   for (const bucket of byModel.values()) {
     const cost = costFor(bucket.tokens, bucket.rates);
     models.push({
-      displayName: bucket.displayName,
+      rawModel: bucket.rawModel,
       fidelity: bucket.fidelity,
       turnCount: bucket.turnCount,
       tokens: bucket.tokens,
@@ -67,7 +70,7 @@ function sumTokens(models) {
 // Groups subagent runs by their agentType (from the sidecar .meta.json),
 // each with its own real, measured cost — instead of lumping every
 // subagent run into one "SUBAGENTS" blob.
-function summarizeSubagentsByType(subagentFiles, table) {
+export function summarizeSubagentsByType(subagentFiles, table) {
   const byType = new Map();
 
   for (const { file, meta } of subagentFiles) {
@@ -86,22 +89,125 @@ function summarizeSubagentsByType(subagentFiles, table) {
   }));
 }
 
+export function activityFrom(parsed) {
+  const mcp = {};
+  for (const server of Object.values(parsed.mcp)) {
+    const calls = Object.values(server.tools).reduce((sum, bucket) => sum + bucket.calls, 0);
+    if (calls) mcp[server.displayName] = (mcp[server.displayName] ?? 0) + calls;
+  }
+  const skills = {};
+  for (const [name, bucket] of Object.entries(parsed.skills)) skills[name] = bucket.calls;
+  return { mcp, skills, web: parsed.web };
+}
+
+function priceBucket(bucket, table) {
+  let outputCost = 0;
+  let contextCost = 0;
+  let pricedOutput = 0;
+  let pricedContext = 0;
+  let unpriced = false;
+
+  for (const [model, tokens] of Object.entries(bucket.outputByModel)) {
+    const { rates } = lookupPricing(model, table);
+    if (!rates) {
+      unpriced = true;
+      continue;
+    }
+    outputCost += (tokens / 1_000_000) * rates.output;
+    pricedOutput += tokens;
+  }
+
+  for (const [model, usage] of Object.entries(bucket.contextByModel)) {
+    const { rates } = lookupPricing(model, table);
+    if (!rates) {
+      unpriced = true;
+      continue;
+    }
+    const cost = costFor({ ...usage, output: 0, cacheRead: 0 }, rates);
+    contextCost += cost.input + cost.cacheWrite;
+    pricedContext += usage.input + usage.cacheWrite5m + usage.cacheWrite1h;
+  }
+
+  return {
+    outputCost: pricedOutput === 0 && bucket.outputTokens > 0 ? null : outputCost,
+    contextCost: pricedContext === 0 && bucket.contextTokens > 0 ? null : contextCost,
+    unpriced,
+  };
+}
+
+function finishBucket(bucket, table) {
+  const priced = priceBucket(bucket, table);
+  const via = Object.entries(bucket.via)
+    .map(([skill, calls]) => ({ skill, calls }))
+    .sort((a, b) => b.calls - a.calls);
+  return {
+    calls: bucket.calls,
+    outputTokens: bucket.outputTokens,
+    contextTokens: bucket.contextTokens,
+    contextMissing: bucket.contextMissing,
+    outputCost: priced.outputCost,
+    contextCost: priced.contextCost,
+    unpriced: priced.unpriced,
+    ...(via.length ? { via } : {}),
+  };
+}
+
+function sumField(rows, field) {
+  if (rows.every((row) => row[field] == null)) return null;
+  return rows.reduce((sum, row) => sum + (row[field] ?? 0), 0);
+}
+
+function byWeight(a, b) {
+  const cost = (row) => (row.contextCost ?? 0) + (row.outputCost ?? 0);
+  return cost(b) - cost(a) || (b.contextTokens + b.outputTokens) - (a.contextTokens + a.outputTokens);
+}
+
+export function priceAttribution(parsed, table) {
+  const mcp = Object.entries(parsed.mcp).map(([slug, server]) => {
+    const tools = Object.entries(server.tools)
+      .map(([name, bucket]) => ({ name, ...finishBucket(bucket, table) }))
+      .sort(byWeight);
+    return {
+      server: slug,
+      displayName: server.displayName,
+      calls: tools.reduce((sum, tool) => sum + tool.calls, 0),
+      outputTokens: tools.reduce((sum, tool) => sum + tool.outputTokens, 0),
+      contextTokens: tools.reduce((sum, tool) => sum + tool.contextTokens, 0),
+      contextMissing: tools.reduce((sum, tool) => sum + tool.contextMissing, 0),
+      outputCost: sumField(tools, 'outputCost'),
+      contextCost: sumField(tools, 'contextCost'),
+      unpriced: tools.some((tool) => tool.unpriced),
+      tools,
+    };
+  }).sort(byWeight);
+
+  const skills = Object.entries(parsed.skills)
+    .map(([name, bucket]) => ({ name, ...finishBucket(bucket, table) }))
+    .sort(byWeight);
+
+  return { note: ATTRIBUTION_NOTE, mcp, skills };
+}
+
 // Builds one receipt object for a discovered session (main transcript +
 // any subagent transcripts spawned within it). `table` is the pricing
 // table already resolved once via loadPricingTable() by the caller.
+// Attribution dollars are not added into totals — they are a slice of them.
 export function buildReceipt(session, table) {
-  const { turns: mainTurns, activity: mainActivity } = parseTranscript(session.mainFile);
+  const main = parseTranscript(session.mainFile);
   const subagentParsed = session.subagentFiles.map(({ file }) => parseTranscript(file));
+  const mainTurns = main.turns;
   const subagentTurns = subagentParsed.flatMap((p) => p.turns);
+  const merged = mergeParsed([main, ...subagentParsed]);
 
   const mainModels = summarizeTurns(mainTurns, table);
   const subagentGroups = summarizeSubagentsByType(session.subagentFiles, table);
   const allSubagentModels = subagentGroups.flatMap((g) => g.models);
 
-  const activity = mergeActivity([mainActivity, ...subagentParsed.map((p) => p.activity)]);
+  const activity = activityFrom(merged);
+  const attribution = priceAttribution(merged, table);
 
   const { startedAt, endedAt } = timeRange([...mainTurns, ...subagentTurns]);
-  const hasUnpriced = [...mainModels, ...allSubagentModels].some((m) => !m.cost);
+  const hasUnpriced = [...mainModels, ...allSubagentModels].some((m) => m.fidelity === 'unpriced');
 
   const totals = {
     tokens: sumTokens([...mainModels, ...allSubagentModels]),
@@ -119,6 +225,7 @@ export function buildReceipt(session, table) {
     models: mainModels,
     subagentGroups,
     activity,
+    attribution,
     totals,
     hasUnpriced,
     pricingSource: table.source,