trailix

What did your AI agent actually do — and how thorough was it, really?

You delegate a task to Claude Code, it works for twenty minutes, and hands back three bullet points. But what happened in those twenty minutes? How much did it read, what did it decide at each crossroads, which files did it change and by how much? trailix shows you the whole scope of the work at a glance — a visual session map in your browser, and a thoroughness report card in your terminal.

Every verdict ships with an evidence line — no vibes, no LLM judging. The grade is the worst of ≤5 structural rules, and any rule that can't be judged is shown as ◌ no verdict, never guessed.

Try it

npx trailix map --open  # THE session map: the whole scope of the work, visually
npx trailix demo        # show an example card (no session needed)
npx trailix             # grade the most recent session in this project
npx trailix --done      # grade the session that just ended (from a new terminal)
npx trailix list        # list recent sessions
npx trailix --ascii     # portable ASCII output (no box, ASCII glyphs)
npx trailix --lang ko   # 한국어 카드/지도

Requires Node 24+. Nothing to configure — trailix reads your local Claude Code session logs directly.

The session map (trailix map)

One command turns the session log into a single self-contained HTML page — no server, no external resources, readable even with JavaScript off, printable:

• One-line summary — "In 1h 12m, it read 18 files, changed 7 files (+412/−96 lines) and ran 31 commands. At 2 of 4 crossroads it asked you."
• The trail ribbon — a real-timestamp timeline of the whole session: research/decide/edit/run coloured runs, idle gaps compressed and labelled honestly ("≈ 23m idle"), decision markers that are never dropped, a delegation track, and a turn-by-turn list underneath.
• Decisions, verbatim and complete — every question it asked you (with all the options and what you chose), every plan approval, and estimated self-decisions. This list is never truncated: it exists because "the model showed me only 3 curated judgements" was the original pain.
• Research and work detail — per-file read depth (deep/partial/skim, measured from lines actually read), web search queries verbatim, per-file +added/−removed line counts, commands classified (test/build/inspect).
• Subagents — what each spawned agent (or workflow fleet) did, from their own transcripts.
• The scorecard — the same 5-rule verdict layer, embedded at the bottom.

Everything is counted from the local log by fixed rules; estimates are labelled (est.), missing data shows as "—", and the AI's own final report is included verbatim in the appendix so you can compare its claims with the measured facts yourself.

The automatic report card

Install the Claude Code plugin and trailix posts a card automatically when a delegation turn ends (a turn that used a subagent or made ≥10 tool calls) — no command needed. It also adds the /trailix skill to grade the current session on demand.

The card appears through the Stop hook's systemMessage: it's shown to you, and never enters the model's context — trailix watches, it doesn't participate.

What it checks (v1)

| Rule | Flags when… | |---|---| | blind edits | files were edited without being read first (or repeated blind-edit attempts the harness had to block) | | source cross-check | a research turn leaned on too few distinct sources | | read depth | files were skimmed (a partial read) right before being edited | | delegation review | subagents were spawned but their output was never verified | | repeat reads | the same file was re-read enough times to waste real tokens |

Thresholds are calibrated against real session history and recorded in the CHANGELOG — the goal is zero false positives: an audit tool that cries wolf is worse than none.

Principles

trailix is a read-only observer. It follows three invariants:

1. Never modifies your session data — it only reads ~/.claude/projects.
2. Never blocks or slows a session — the hook is fail-silent (always exits 0; a bug means "no card", never a stuck session).
3. Never pollutes the conversation — the card is display-only, and trailix excludes its own activity from scoring.

Local only. Zero runtime dependencies. Nothing leaves your machine.

FAQ

Does it send my code or sessions anywhere? No. trailix reads your local session logs and prints to your terminal. There is no network call, no telemetry, no account. (To share a session in a bug report, node scripts/sanitize.ts redacts secrets and paths first.)

Won't a rule-based grader produce false positives? That's the failure mode it's designed against. Every threshold is calibrated against real session history (see the CHANGELOG and scripts/backtest.ts), a rule that can't be sure returns no verdict instead of guessing, and anything uncertain is capped at caution — never poor on a hunch. The flagship rule was retuned when the backtest showed it firing on 61% of sessions; it now fires on ~13%, all genuine.

Why rules instead of asking an LLM to judge the session? Because you can't audit an audit you can't reproduce. Rules are deterministic, every verdict cites the exact evidence from your log, there's no token cost, and the result is the same every run. An LLM judge would be a vibe with extra steps.

Status

v0.1.0 — first release, live on npm. Engine, CLI, Stop hook and skill are implemented and tested (110+ tests, CI green), with thresholds calibrated against a full-history backtest. Early days — feedback on the rules is very welcome (see the rule-suggestion issue template).

License

MIT