Multi-model cost and budget dashboard

[doyled-it]

Motivation

Current usage tracking (src/core/usage.rs, __agentview_meta_usage hidden tmux session) tracks Claude usage. agent-deck tracks 14 models including Claude variants, Gemini, GPT-4o, with daily/weekly/monthly budget limits and historical backfill from transcripts.

Scope

• Extend usage tracking to record (runner, model, input_tokens, output_tokens, cost_usd, session_id, ts).
• Pricing table per model — sourced from a config file we maintain, with version pinning.
• Budget config: per-period (daily/weekly/monthly) caps with warning thresholds (e.g. 80%).
• Dashboard view in TUI: current period spend, top sessions by cost, per-model breakdown.
• Historical backfill: parse existing Claude Code transcripts on disk to populate prior cost events.

Depends on

• Pluggable runners issue — model attribution per runner needs the runner trait in place. Could ship a Claude-only version first.

Open questions

• Pricing table maintenance — manual updates vs. fetch from a public source.
• How to attribute cost when a session uses multiple models in one transcript.

[doyled-it]

PR #51 lands the data-collection foundation for this:

• New cost_events table (schema v8) records (session_id, model, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, ts) per Claude turn — see src/core/storage/cost_events.rs.
• Populated automatically from Claude Code's Stop hook → transcript JSONL last-assistant-line parse → row insert. No manual pricing or budget logic yet.
• Public storage helpers: Storage::insert_cost_event, Storage::cost_totals_for_session(session_id) -> CostTotals { input, output, cache_read, cache_creation }, Storage::delete_cost_events_for_session.
• Lifecycle wiring: cost rows are deleted via ON DELETE CASCADE when a session is removed (and explicitly via delete_cost_events_for_session in delete_session/finish_session).

What's still open from this issue's scope:

• Pricing table per model + USD attribution (rows currently store raw token counts; cost is tokens * rate at query time).
• Budget caps + warning thresholds.
• TUI dashboard (current period spend, top sessions, per-model breakdown).
• Historical backfill from existing on-disk transcripts.
• Multi-runner attribution (currently only ClaudeRunner has a hook handler — see CodexRunner: replace Tool::Codex fallback with a real runner impl #47/GeminiRunner: replace Tool::Gemini fallback with a real runner impl #48/OpencodeRunner: replace Tool::Opencode fallback with a real runner impl #49 for sibling runners).

[doyled-it]

Follow-up work to close the data-completeness gap with agent-deck

PR #51 lands the foundation but captures less than agent-deck's internal/costs/ does. Two specific extensions worth tracking under this issue:

1. Capture all assistant + progress entries from transcripts, not just the last assistant per Stop

Currently the Stop hook calls find_last_assistant_line and writes one cost_events row per turn. agent-deck enumerates every entry in the transcript and writes one row per assistant message AND per progress entry (the latter being subagent / Task-tool invocations), deduped by the JSONL line's uuid field.

Gap this fixes:

• Subagent token usage is currently invisible — every Task-tool call has its own usage block under data.message.message.usage and we drop all of it.
• Streaming intermediate chunks with usage — these aren't useful to count separately for billing, but capturing all of them lets us dedupe vs. the final consolidated entry rather than guessing which entry to keep.

Implementation sketch:

• Replace the single-line find_last_assistant_line with a streaming parser that walks the whole tail (or full file on Stop).
• Add a transcript_uuid TEXT column to cost_events for dedup; insert with INSERT OR IGNORE keyed on (session_id, transcript_uuid).
• Handle two entry shapes: entry.type == "assistant" (message.usage directly) and entry.type == "progress" (data.message.message.usage).
• Still triggered by Stop (don't read on every event), but enumerate everything new since the last Stop's high-water mark.

Reference: ~/projects/agent-deck/internal/costs/sync.go (parseTranscriptFile and TranscriptEntry/progressData structs).

2. Add Pricer + USD cost computation to cost_events

cost_events currently stores raw token counts only. agent-deck has a Pricer with a per-model rate table (input/output/cache-read/cache-write per Mtok) and stores cost_microdollars per row.

Implementation sketch:

• New module src/core/cost/pricing.rs:
  • Pricer struct with hardcoded defaults baked at build time (Opus 4.7, Sonnet 4.6, Haiku 4.5; defer non-Anthropic models until those runners exist — see Runner picker in new-session overlay + ship Shell runner as the first non-Claude impl #46–OpencodeRunner: replace Tool::Opencode fallback with a real runner impl #49).
  • User overrides via a new [costs.pricing] section in the existing config file.
  • Pricer::compute_microdollars(model, in, out, cache_r, cache_w) -> i64 returning microdollars (i64 keeps SUM() lossless; UI renders as dollars).
• Schema v9 migration: add cost_microdollars INTEGER NOT NULL DEFAULT 0 to cost_events.
• Compute at row-insert time (cheap) AND backfill old rows on migration via Pricer::compute_microdollars over existing tokens.
• Optional follow-up: a cost recompute CLI subcommand mirroring agent-deck's costs recompute, for re-pricing after a rate-table update.

Reference: ~/projects/agent-deck/internal/costs/{pricing.go, fetcher.go, costs.go}.

Out of scope for both

The 5-hour / weekly subscription quota bars that /usage renders (the data src/core/usage/ regex-parses) — Anthropic does not expose this via API or local file. agent-deck has the same blind spot. The /usage regex parser stays as the only source for quota progress until Anthropic ships an API.

Historical backfill

agent-deck also has a costs sync command that walks every transcript in ~/.claude/projects/**/*.jsonl and ingests historical events. That's already mentioned in the original issue ("Historical backfill: parse existing Claude Code transcripts on disk to populate prior cost events") — folding it together with #1 above makes sense since they share the same parser.