Skip to main content
skill CX Codex

cost-track — Claude Code skill: what it does, how to install

Reads the session jsonl of a Claude Code run, adds up token usage per model, prices it and stores a record in the cost-tracking namespace.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add ruvnet/ruflo --skill cost-track -a claude-code
Open on GitHub

What cost-track does

Give it a session and you get figures instead of guesses. The skill parses ~/.claude/projects/<encoded-cwd>/<session>.jsonl, tallies the usage block of assistant messages for each model, applies the prices listed in REFERENCE.md and saves one record under session-<sessionId> in the cost-tracking AgentDB namespace. Cache writes are billed at the cache_write rate, cache reads at cache_read.

From the project root, run node plugins/ruflo-cost-tracker/scripts/track.mjs. The script picks the most recent jsonl for the current directory by itself, prints a markdown summary with per-model and per-tier breakdowns, then calls memory_store. Node.js and that MCP memory tool are what it needs. TRACK_DRY_RUN=1 skips the write and leaves you the summary. Other switches cover the rest: TRACK_CWD to scan another project, TRACK_SESSION to pin a file, TRACK_OUT to dump the JSON.

The jsonl is the only source of numbers, and it sits inside the Claude Code project folder. Load the skill under Cursor or Codex and there is often nothing to read. So check the namespace after the first run, because cost-report and cost-optimize take their data from cost-tracking alone.

What it helps with

  • find out what a finished session actually cost
  • break spending down by model and tier
  • keep a record of token use across projects
  • see how much goes to cache writes versus cache reads
  • hand real numbers to cost-report

Example prompts for the agent

  • Run cost-track on this session and show me the breakdown by model
  • How much did opus cost us in this project? Run cost-track
  • Run node plugins/ruflo-cost-tracker/scripts/track.mjs with TRACK_DRY_RUN=1, skip the memory write for now

How to install cost-track

1Skills CLI (Vercel)

npx skills add ruvnet/ruflo --skill cost-track -a claude-code

2Manually: put the files in place

~/.claude/skills/cost-track/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/cost-track/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about cost-track

How do I install cost-track in Claude Code?

Run npx skills add ruvnet/ruflo --skill cost-track -a claude-code. The skill file lands at ~/.claude/skills/cost-track/SKILL.md.

What does cost-track do?

It walks the session jsonl, sums token usage per model and turns that into USD. The result is written to the cost-tracking namespace, where the reporting skills pick it up.

What else does it need to run?

Node.js, plus a working memory_store MCP tool, otherwise you only get the console summary. Point it at a specific file with TRACK_SESSION or change the target with TRACK_NAMESPACE.

Source text

SKILL.md · MIT
---
name: cost-track
description: Auto-capture per-session token usage from the Claude Code session jsonl and persist to the cost-tracking namespace
argument-hint: ""
allowed-tools: Bash mcp__plugin_ruflo-core_ruflo__memory_store
---

# Cost Track

Reads the active Claude Code session jsonl (`~/.claude/projects/<encoded-cwd>/<session>.jsonl`), tallies assistant-message `usage` per model, computes USD cost using REFERENCE.md pricing, and writes a structured record to the `cost-tracking` AgentDB namespace. This is the **producer** that gives `cost-report` and `cost-optimize` real data to consume.

## When to use

- After a meaningful chunk of work, to capture spend for the report.
- At session-end to persist the final tally.
- Periodically during long sessions (cron-friendly — see `/loop 30m`).

## Steps

1. **Run the tracker** from the project root:

   ```bash
   node plugins/ruflo-cost-tracker/scripts/track.mjs
   ```

   The script auto-discovers the session jsonl from the current working directory. To pin a specific session: `TRACK_SESSION=/path/to/session.jsonl`. To dry-run (no memory write): `TRACK_DRY_RUN=1`.

2. **Inspect the markdown summary** — total cost, per-model and per-tier breakdowns, and the persisted memory key.

3. **Verify persistence** — `mcp__plugin_ruflo-core_ruflo__memory_search({ query: "session-", namespace: "cost-tracking" })` should list the new record. `cost-report` step 1 reads from this namespace.

## Record shape (in `cost-tracking` namespace)

Key: `session-<sessionId>`. Value (JSON):

```json
{
  "sessionId": "1dba3b8c-...",
  "cwd": "/Users/cohen/Projects/ruflo",
  "startedAt": "2026-05-04T...",
  "endedAt": "2026-05-05T...",
  "messageCount": 234,
  "byModel": {
    "claude-opus-4-7": {
      "tier": "opus",
      "input_tokens": 12345,
      "output_tokens": 6789,
      "cache_creation_input_tokens": 800000,
      "cache_read_input_tokens": 2000000,
      "messages": 50,
      "cost_usd": 1.23
    }
  },
  "byTier": { "haiku": 0.0, "sonnet": 0.45, "opus": 1.23, "unknown": 0 },
  "total_cost_usd": 1.68,
  "capturedAt": "2026-05-05T..."
}
```

## Pricing source of truth

The script's `PRICING` constant mirrors REFERENCE.md "Model pricing (USD per 1M tokens)". Update both together when prices change. Cache-write tokens are billed at `cache_write` rate; cache-read tokens at `cache_read` (per Anthropic billing docs).

## Env overrides

| Env | Default | Purpose |
|---|---|---|
| `TRACK_CWD` | `process.cwd()` | Override which project's sessions to scan |
| `TRACK_SESSION` | most-recent jsonl | Pin a specific session file |
| `TRACK_OUT` | unset | Also write the JSON summary to this path |
| `TRACK_DRY_RUN=1` | unset | Skip the `memory store` call |
| `TRACK_QUIET=1` | unset | Suppress markdown output |
| `TRACK_NAMESPACE` | `cost-tracking` | Override target namespace |

## Cross-references

- `cost-report` (consumer) — reads records produced by this skill
- REFERENCE.md "Cost attribution formula" — the math the script implements
- `cost-budget-check` (consumer; landing in P2) — reads totals to evaluate alerts

© ruvnet · MIT · ruvnet/ruflo

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set146

browser-screenshot-diff Compares two recorded browser sessions by matching steps, screenshots, and accessibility snapshots. Use it for visual regression and replay checks. CX Codex +1 696installs cost-budget-check Adds up what the project has spent, compares it with the budget limit and names the alert level. Worth running before you spawn another round of agents. CX Codex +1 692installs browser-auth-flow Drives your login flow once, then probes it for redirect leaks, missing CSRF tokens, weak session cookies and OAuth mistakes. Writes a findings.md with a verdict. CX Codex +1 689installs adr-verify Reads the stored ADR graph back and flags dangling references, supersede cycles and status mismatches. Useful right after adr-index or as a CI gate. CX Codex +1 688installs cost-booster-route Sorts a batch of tasks across the router's three tiers and shows how many landed in Agent Booster with no LLM call. CX Codex +1 684installs vector-setup Bootstraps [email protected], installs missing add-ons, and registers the MCP server. Useful when /vector subcommands fail on missing dependencies. CX Codex +1 683installs intelligence-transfer Copies learned patterns from another local project, or moves them through the IPFS pattern marketplace, so a new project can start from what an older one already knows. CX Codex +1 683installs cost-trend A skill that reads benchmark runs from docs/benchmarks/runs/*.json and surfaces how win rate, latency, escalation rate, and cost change over time. Catches regressions that smoke tests miss. CX Codex +1 683installs

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor