burnie 0.1.0__tar.gz

burnie-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Install uv
+        run: pip install uv
+
+      - name: Build
+        run: uv build
+
+      - name: Test the built wheel
+        run: |
+          uv venv /tmp/testenv
+          uv pip install --python /tmp/testenv/bin/python dist/*.whl
+          /tmp/testenv/bin/burnie --help

burnie-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,81 @@
+name: Release
+
+on:
+  push:
+    branches: [main]
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  draft:
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Extract version from pyproject.toml
+        id: version
+        run: |
+          VERSION="$(python3 -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")"
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+
+      - name: Remove old release drafts
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          DRAFT_IDS=$(gh api repos/${{ github.repository }}/releases --jq '.[] | select(.draft == true) | .id')
+          if [ -n "$DRAFT_IDS" ]; then
+            echo "$DRAFT_IDS" | xargs -I '{}' gh api -X DELETE repos/${{ github.repository }}/releases/'{}'
+          fi
+
+      - name: Create release draft
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create "v${{ steps.version.outputs.version }}" \
+            --draft --title "v${{ steps.version.outputs.version }}" --generate-notes
+
+  publish:
+    if: github.event_name == 'release'
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/burnie/
+    permissions:
+      id-token: write # required for PyPI Trusted Publishing
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Install uv
+        run: pip install uv
+
+      - name: Check tag matches pyproject.toml version
+        run: |
+          TAG_VERSION="${GITHUB_REF_NAME#v}"
+          PYPROJECT_VERSION="$(python3 -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")"
+          if [ "$TAG_VERSION" != "$PYPROJECT_VERSION" ]; then
+            echo "Tag $GITHUB_REF_NAME does not match pyproject.toml version $PYPROJECT_VERSION"
+            exit 1
+          fi
+
+      - name: Build
+        run: uv build
+
+      - name: Test the built wheel
+        run: |
+          uv venv /tmp/testenv
+          uv pip install --python /tmp/testenv/bin/python dist/*.whl
+          /tmp/testenv/bin/burnie --help
+
+      - name: Publish to PyPI
+        run: uv publish --trusted-publishing always

burnie-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+burnie-report.html
+.DS_Store
+METRICS.md
+__pycache__
+burnie-report.md
+uv.lock
+dist/
+*.egg-info/

burnie-0.1.0/CLAUDE.md

@@ -0,0 +1,53 @@
+# burnie: project context
+
+## What this is
+
+A local cost analytics tool for Claude Code. Reads `~/.claude/projects/**/*.jsonl` session transcripts and surfaces token costs.
+
+Python package (src-layout), installed/run via `uv`/`uvx`/`pip`, published as `burnie` on PyPI. Ported from an earlier Node.js implementation because `burnie` was already taken on npm.
+
+## Main component
+
+**CLI / report (`src/burnie/cli.py`)**
+- Scans all local session files, generates an HTML report (`burnie-report.html`)
+- Visual breakdown: total spend, daily avg, cache savings, cost by model
+- Per-session detail: context growth, tool usage, agent calls, repeated operations
+- Tooltips on non-obvious metrics, and a link to `claude.ai/new#settings/usage`
+- `src/burnie/report.py` builds the HTML. The CSS and client-side JS (Chart.js-based) inside it are plain static strings, not templated, so edit them as HTML/JS directly
+
+## Data source
+
+Claude Code session files: `~/.claude/projects/<encoded-path>/<session-id>.jsonl`
+
+Each line is a JSON event. Relevant types:
+- `assistant`: has `message.usage` with `input_tokens`, `output_tokens`, `cache_creation_input_tokens`, `cache_read_input_tokens`
+- `user`: user messages and tool results
+- `ai-title`: session title
+
+Encoded path: project's absolute path with `/` replaced by `-`.
+
+## Pricing
+
+Stored in `src/burnie/pricing.py`, the single source of truth. Includes `PRICING_UPDATED` date shown in the report. Use the `/burnie-update` skill to refresh from `anthropic.com/pricing`.
+
+## Skill install
+
+`burnie --install-skill` (`cli.py::_install_skill`): with a repo checkout on disk (`_repo_skills_dir`, detected via `__file__`, which holds true for editable installs and source runs), symlinks `skills/burnie` and `skills/burnie-update` into `~/.claude/skills/` so edits show up live. `burnie-update` edits `src/burnie/pricing.py` in place, so it's only included here, alongside the source tree. Without a checkout (plain PyPI/`uv` install), copies just `skills/burnie/SKILL.md` from the wheel, bundled there via `[tool.hatch.build.targets.wheel.force-include]` in `pyproject.toml`.
+
+`metadata.version` in both `SKILL.md` files is a plain string, bumped by hand alongside `pyproject.toml`'s `version`, the same convention as `PRICING_UPDATED`.
+
+## CI / Releasing
+
+`.github/workflows/ci.yml` builds and smoke-tests the wheel on every push/PR. `.github/workflows/release.yml` drafts a GitHub Release from `pyproject.toml`'s version on every push to `main`, and publishes to PyPI via Trusted Publishing when that draft is published. `src/burnie/__init__.py` reads `__version__` from installed metadata at runtime, so it's not a manual bump point.
+
+## Key decisions
+
+- No backend, no API calls: everything runs locally on the JSONL files
+- Python, packaged with `hatchling`, distributed via PyPI/`uv`
+- Pricing in one file (`src/burnie/pricing.py`) so updates don't touch report logic
+
+## Non-goals
+
+- Not a billing tool (no API key, no Anthropic account access)
+- Not a real-time token counter during generation
+- Not a cloud service

burnie-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 burnie contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

burnie-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: burnie
+Version: 0.1.0
+Summary: Claude Code session cost analytics: your tokens are burning
+Project-URL: Homepage, https://github.com/czoido/burnie
+Project-URL: Repository, https://github.com/czoido/burnie
+Author: Carlos Zoido
+License-Expression: MIT
+License-File: LICENSE
+Keywords: analytics,claude,claude-code,cost,tokens
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="burnie.png" alt="Burnie" width="200" />
+</p>
+
+<p align="center"><em>Some agents just want to watch your tokens burn.</em></p>
+
+---
+
+**burnie** is a local cost analytics tool for Claude Code. It reads the session transcripts Claude Code stores on disk and gives you a clear picture of where your money is going: no API key, no cloud, just your files.
+
+## Features
+
+- **Report:** visual HTML breakdown of token costs across all your Claude Code sessions: total spend, daily average, cache savings, cost by model
+- **Inspect:** drill into any session to see what drove the cost: context growth over time, tool call patterns, agent spawns, repeated operations
+- **Analyze:** the `/burnie` skill runs a condensed report through Claude for a written, reasoned take on where your cost is coming from and what (if anything) to do about it
+
+## Install
+
+```bash
+# run without installing
+uvx burnie
+
+# or install as a persistent command
+uv tool install burnie
+```
+
+No `uv`? `pip install burnie` works too.
+
+Then get the `/burnie` skill into Claude Code:
+
+```bash
+burnie --install-skill
+```
+
+## Usage
+
+```bash
+# Generate HTML report
+burnie
+
+# Highlight a specific session in the report
+burnie --session <session-id>
+
+# Markdown report instead of HTML
+burnie --markdown
+
+# Condensed, LLM-readable report printed to stdout (what the `/burnie` skill uses)
+burnie --raw --session <session-id>
+```
+
+The report is written to `burnie-report.html` in the current directory and opened in your browser. `--markdown` writes `burnie-report.md` instead. `--raw` prints straight to stdout with no file.
+
+## How it works
+
+Claude Code writes every session to a JSONL file at:
+
+```
+~/.claude/projects/<encoded-project-path>/<session-id>.jsonl
+```
+
+Each assistant turn includes token usage. burnie reads those files, applies current model pricing from `src/burnie/pricing.py`, and surfaces the data.
+
+## Pricing
+
+Stored in `src/burnie/pricing.py`, the single source of truth. Run `/burnie-update` to refresh from Anthropic's pricing page.
+
+---
+
+<p align="center">Burnie doesn't judge. It just burnies. 🔥</p>

burnie-0.1.0/README.md

@@ -0,0 +1,69 @@
+<p align="center">
+  <img src="burnie.png" alt="Burnie" width="200" />
+</p>
+
+<p align="center"><em>Some agents just want to watch your tokens burn.</em></p>
+
+---
+
+**burnie** is a local cost analytics tool for Claude Code. It reads the session transcripts Claude Code stores on disk and gives you a clear picture of where your money is going: no API key, no cloud, just your files.
+
+## Features
+
+- **Report:** visual HTML breakdown of token costs across all your Claude Code sessions: total spend, daily average, cache savings, cost by model
+- **Inspect:** drill into any session to see what drove the cost: context growth over time, tool call patterns, agent spawns, repeated operations
+- **Analyze:** the `/burnie` skill runs a condensed report through Claude for a written, reasoned take on where your cost is coming from and what (if anything) to do about it
+
+## Install
+
+```bash
+# run without installing
+uvx burnie
+
+# or install as a persistent command
+uv tool install burnie
+```
+
+No `uv`? `pip install burnie` works too.
+
+Then get the `/burnie` skill into Claude Code:
+
+```bash
+burnie --install-skill
+```
+
+## Usage
+
+```bash
+# Generate HTML report
+burnie
+
+# Highlight a specific session in the report
+burnie --session <session-id>
+
+# Markdown report instead of HTML
+burnie --markdown
+
+# Condensed, LLM-readable report printed to stdout (what the `/burnie` skill uses)
+burnie --raw --session <session-id>
+```
+
+The report is written to `burnie-report.html` in the current directory and opened in your browser. `--markdown` writes `burnie-report.md` instead. `--raw` prints straight to stdout with no file.
+
+## How it works
+
+Claude Code writes every session to a JSONL file at:
+
+```
+~/.claude/projects/<encoded-project-path>/<session-id>.jsonl
+```
+
+Each assistant turn includes token usage. burnie reads those files, applies current model pricing from `src/burnie/pricing.py`, and surfaces the data.
+
+## Pricing
+
+Stored in `src/burnie/pricing.py`, the single source of truth. Run `/burnie-update` to refresh from Anthropic's pricing page.
+
+---
+
+<p align="center">Burnie doesn't judge. It just burnies. 🔥</p>

burnie-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "burnie"
+version = "0.1.0"
+description = "Claude Code session cost analytics: your tokens are burning"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Carlos Zoido" },
+]
+keywords = ["claude-code", "claude", "cost", "tokens", "analytics"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://github.com/czoido/burnie"
+Repository = "https://github.com/czoido/burnie"
+
+[project.scripts]
+burnie = "burnie.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/burnie"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"skills/burnie/SKILL.md" = "burnie/skills/burnie/SKILL.md"

burnie-0.1.0/skills/burnie/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: burnie
+description: Generate and analyze a Claude Code session cost report. Use when the user asks about session costs, token spend, expensive sessions, or wants a cost breakdown of their Claude Code usage.
+compatibility: Designed for Claude Code. Requires Python 3.9+ (run via `uvx burnie` or an installed `burnie`).
+allowed-tools: Bash
+metadata:
+  version: "0.1.0"
+---
+
+Generate a Claude Code cost analytics report and provide a reasoned analysis of where the money is going and how to reduce it.
+
+## Steps
+
+### 1. Generate the raw report
+
+Run burnie in `--raw` mode, passing the current session ID so it's marked in the output:
+
+```bash
+burnie --raw --session $CLAUDE_CODE_SESSION_ID
+```
+
+This reads all session files from `~/.claude/projects/**/*.jsonl`, computes costs, and prints a condensed, annotated report straight to stdout: no file, no browser. Each metric carries an inline one-line explanation of what it means, so read the numbers directly. You don't need extra context to interpret them.
+
+The report has these sections: SUMMARY, TECHNICAL CONTEXT (cache stats: background, rarely worth leading with), GLOBAL PERCENTILES (p50/p75/p90/p95/max for cost, turns, peak context, and each cost component: the real baseline, since the average is skewed by the same expensive sessions you're trying to explain), COST BY COMPONENT, COST BY MODEL, COST BY PROJECT, CURRENT SESSION (this session's own numbers, its percentile rank, its COMPARABLE SESSIONS/peers with cohort size and quality, and its COST CURVE): **only present when `--session` matched a real session. If you ran this without `--session`, or the id didn't match anything on disk, there is no current session, no peers, and no cost curve to analyze, so say so and stick to the global patterns below instead of inventing a per-session read**, TOP 20 MOST EXPENSIVE SESSIONS (global cost patterns, not a baseline for "normal": includes `turns`/`peak_ctx` per session now, useful for comparing shape across the list), RECURRING FAILURES, and FREQUENTLY ACCESSED TARGETS (background, not a finding: targets hit repeatedly by path/command/pattern).
+
+### 2. Provide a reasoned analysis
+
+Write for someone who wants to know what to do, not someone who wants to see the metrics. The raw report's section order is for you to reason with. The response you write follows a different order, built around the conclusion, not the data.
+
+**Output structure (always these three parts, in this order):**
+
+1. **Current session.** If the report has no CURRENT SESSION block (no `--session` was passed, or the id didn't match a session on disk), say plainly that there's no data for the current session and skip straight to part 2. Don't invent a per-session read from the global/top-20 data. Otherwise, open with a plain-language verdict, before any number: does this session show a specific problem, or not? If not, say so directly in the first sentence ("no specific problem here, no action needed based on this session"). Don't make the reader infer that from a pile of percentiles. Then 1-3 sentences of supporting context (peer comparison, cost curve shape, compactions), written as comparisons a non-technical reader can picture, not as statistics. **Never write "P84," "percentile 45," or any raw percentile/rank number in the response**. Translate every one into a plain comparison instead: "more expensive than most sessions overall, but ordinary for this project," "close to the middle of what similar sessions cost," "well above what its peers typically cost." The percentile numbers are for you to reason with while writing the analysis. They should never appear as numbers in what the user reads. Close with one line on what to do (often, correctly, "nothing for now").
+2. **Recommended actions.** Patterns across the whole history, not this session specifically. Cap at 3, ordered by impact, but don't pad to reach 3. Zero, one, or two items is a valid, often correct result. Only include an item if the data supports it. Each one has exactly four parts:
+   - **Conclusion:** what's happening, plain language, no jargon.
+   - **Evidence:** the specific numbers behind it.
+   - **Action:** either a specific behavior change the user can go make (a command, a workflow change) when the report actually links the pattern to that change, or, when it doesn't, an explicit **"Worth inspecting"** framing that names what to go look at before deciding whether to change anything. Never invent a fix for a pattern that's only been observed, not diagnosed, and never pad with vague advice like "reduce token usage."
+   - **Impact:** high/medium/low, and a confidence label when the causal link isn't proven (e.g. "157 rereads of file X" is high-confidence evidence of a *pattern*, only medium-confidence that it's *avoidable*, because the file may have changed between reads).
+3. **Session data.** A short block of plain facts at the very end (cost, turns, model, context range, compactions, files touched) for reference, not part of the narrative above it. If there's no CURRENT SESSION block, just write "not available" here instead of omitting the part.
+
+Keep these separate throughout. Never blend them: what's true about *this session* vs. what's true about *the whole history*, and an *observation* (a pattern exists) vs. a *recommendation* (do this about it).
+
+**Rules (follow all of them):**
+- State the verdict in plain language first. Percentiles/ranks/cohort numbers back it up, they don't replace it.
+- Compare the current session to its **peers** (same project + same model, similar turn count) first. That's the real "is this normal" comparison. Use GLOBAL PERCENTILES for broader context. Use the TOP 20 list only to say whether a global pattern is widespread ("this shows up in N of the 20 priciest sessions"), never as a stand-in for "normal," and never as a reason to flag the *current* session.
+- If `comparison_quality=low` (thin cohort, so check `cohort_candidates`), say so explicitly and treat any cohort comparison as low-confidence rather than drawing firm conclusions from it.
+- Never call `spend_after_first_compaction` "savings" or "recoverable". It explains *where* the cost came from, not money you can get back.
+- Never infer or state whether the session "succeeded," was "efficient," or was "worth it." `files_touched` is a plain fact about size of the work, never a quality verdict.
+- Never use tool-call count, cache-reuse rate, or session duration by themselves as an efficiency score.
+- Context jumps in the COST CURVE list tools active in the *previous* turn as circumstantial context, not a cause: say "context grew after a turn that included these tools," never "X tool added Y tokens." The same caution applies to any jump you tie to a specific turn's own response (e.g. a long summary): say it "coincides with" or "lands on" that turn, never that the response "caused" or "added" a specific token amount.
+- CURRENT SESSION is a snapshot: if the session is still running, say the numbers may not reflect later turns.
+- It's a valid, often correct verdict that "this session is normal for its cohort, no action needed." Don't manufacture a recommendation when the data doesn't support one, and don't let a global recommendation (part 2) read as if it applies to the current session (part 1) unless it actually does.
+- FREQUENTLY ACCESSED TARGETS is not confirmed waste. The report says so, and you must not upgrade it. Repeated calls only prove *repetition*, not that the file/command was unchanged, that different calls targeted the same section, or that the cost was avoidable. If you use it in a Recommended Action, the Action must be phrased as "Worth inspecting: ..." (e.g. whether the repeated calls hit the same section unchanged, or different offsets/versions), never a prescribed workflow change like "keep a summary instead," and never "wasted cost," "avoidable cost," or "confirmed waste."
+- If you group sessions by a pattern in their *titles* (e.g. several "port project to X" sessions) rather than by a field the report actually computes, present it as a hypothesis, not a confirmed finding: "several of the priciest sessions appear to be porting tasks," not "this workflow has been reliably identified." Titles are text you're pattern-matching, not a mechanical signal like `project` or `model`.
+- In RECURRING FAILURES, distinguish by the `sessions` count on each entry: `sessions > 1` is a **cross-session recurring issue** (the same failure across different sessions, worth a permanent fix, e.g. a config change). `sessions == 1` (many occurrences, one session) is an **in-session loop** (worth reviewing the approach taken *in that session*, not a systemic fix). Don't treat them as the same kind of finding.
+- If a RECURRING FAILURES `message` lists more than one possible cause (e.g. "unescaped backslashes... unescaped control characters... or truncated output"), don't pick one and present it as the diagnosis. You have no evidence for which cause applies without inspecting the original failed tool call. Say the failure recurs and name the *set* of possible causes, or say it needs inspecting the actual calls, not guess.
+- A cost recorded after a compaction describes *when* it landed, not that compacting *caused* it. If you want to state a dollar figure for "how much accumulated after the first compaction," only use `spend_after_first_compaction` when the report prints it explicitly for the current session. Never estimate it by eyeballing the COST CURVE.
+- Never invent a counterfactual dollar figure the report doesn't compute (e.g. "starting a new session would have cost about $X less"). Without an explicit field for it, phrase the idea as an untested suggestion for next time, not a quantified saving.
+
+**Before writing the response, verify (do this as a final pass, not while drafting):**
+- Every count you state for distinct items (files, sessions, occurrences, rows) matches an actual recount of the report's rows, not an estimate or a round number that feels right. If you say "N files," N must equal the number of distinct rows you can point to, not one row counted twice under different labels.
+- Every superlative ("most expensive," "highest," "only one") against the *broadest set you actually checked*. "Highest among peers/cohort" must never be written as "highest in the project" or "highest ever." If you haven't checked TOP 20 / COST BY PROJECT for cheaper-but-still-larger sessions, don't claim a project- or history-wide superlative.
+- Every quoted number (cost, turns, peak context, rank) traces back to a single row in the report, not assembled from two different rows (e.g. one peer's cost with another peer's turn count).
+- No sentence evaluates whether the session's work was complex, successful, efficient, or "worth it." Banned phrasing (and equivalents): "genuinely complex work," "the length reflects the problem, not a methodology problem," "it's done what it set out to do," "the cost was justified," "no methodology problem here," "runaway session(s)" (a long, expensive session is a fact, but whether it spiraled versus simply contained a lot of work is not something the report can tell you).
+- Part 1's verdict isn't contradicted by Part 2. If Part 2 recommends a change (e.g. "split long investigations at milestones") using this session as its example, Part 1 should say "no single mistake within this session" rather than an unqualified "no action needed" that Part 2 then undercuts.
+
+This is meant to be a fuller analysis than a quick summary, so don't artificially cap the explanation, but stay focused on what's actionable rather than restating every number in the report.
+
+If the user wants to browse the numbers visually instead, mention they can run `burnie` with no flags to get the interactive HTML report in their browser, but don't generate it as part of this flow.
+
+## Arguments
+
+If `$ARGUMENTS` is provided, treat it as a scope hint for the analysis (e.g. "focus on project X" or "just the last week") rather than a file path. `--raw` has no output file.

burnie-0.1.0/skills/burnie-update/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: burnie-update
+description: Fetch current Claude model prices from anthropic.com/pricing and update src/burnie/pricing.py. Use when the user says prices have changed, wants to refresh pricing, or update model costs.
+compatibility: Designed for Claude Code. Requires internet access to anthropic.com/pricing.
+allowed-tools: WebFetch
+metadata:
+  version: "0.1.0"
+---
+
+Fetch current Claude model prices from anthropic.com/pricing and update `src/burnie/pricing.py`.
+
+## Steps
+
+1. Fetch https://www.anthropic.com/pricing with WebFetch
+2. Extract the $/MTok prices for each model family (input, output, cache write, cache read)
+3. Update `src/burnie/pricing.py`:
+   - Replace the `PRICING` list entries with the new values
+   - Update `PRICING_UPDATED` to today's date (YYYY-MM-DD format)
+4. Report what changed (which models, old vs new values)
+
+## Notes
+
+- Cache write is typically 1.25× input price
+- Cache read is typically 0.1× input price
+- If a model from the current list is no longer on the pricing page, keep it but add a comment `# discontinued?`
+- If a new model appears, add it following the same format
+- Only edit `src/burnie/pricing.py`. The other files import from it

burnie-0.1.0/src/burnie/__init__.py

@@ -0,0 +1,7 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    # Canonical version lives in pyproject.toml [project].version
+    __version__ = version("burnie")
+except PackageNotFoundError:
+    __version__ = "0.0.0"