cctop / Reference
Every reading on the dashboard, panel by panel: its unit, how cctop works it out, which of Claude Code's own records it comes from, what to keep in mind, and whether it is exact or carries the ≈ mark. Most estimates become exact after cctop install, which adds the status line and hook events as sources.
| Reading | Unit | How it is measured | From | Caveats | Exact? |
|---|---|---|---|---|---|
| Status | enum | status from the session registry (busy/idle); WAITING when a permission request is pending; ENDED when the pid is gone | session registry · hook events (after cctop install) | — | exact |
| Turn | count | Prompts the person wrote so far, one per promptId (promptSource typed / suggestion_accepted / queued, or origin.kind human); interrupts, slash commands, task notifications, teammate messages and the compaction summary are not turns | transcript | A resumed session starts counting at the resume point; before Claude Code 2.1.220 every non-meta text line counts | exact |
| Turn elapsed | ms | turn_duration.durationMs once the turn ended, else now − turn start | transcript | Claude Code writes turn duration per attempt and re-drives the same prompt (after /login) with no new user line: a response after it reopens the turn, which is live again until the next one. Panel 4 reads the turn; the header's phase word is the classifier over the last calls, and the two are labelled as such | exact |
| Effort | enum | perTurnEffort of the latest assistant line when set, else its effort, else the status line's effort.level; with thinking on/off and fast mode from the status line | transcript · status line (after cctop install) | — | exact |
| Plan | enum | oauthAccount.userRateLimitTier (else organizationRateLimitTier) from ~/.claude.json | D12 | The status line never carries a plan; keys are read, never the account's names | exact |
| CPU | % | CPU share of the claude process over the last sample interval | process tree | — | exact |
| Memory | bytes | Resident set size of the claude process | process tree | — | exact |
| Reading | Unit | How it is measured | From | Caveats | Exact? |
|---|---|---|---|---|---|
| Context size | tokens | cache_read + cache_write + input of the turn's last API call — everything the model read | transcript · status line (after cctop install) | The status line's total_input_tokens is preferred when the shim is installed | ≈ when read from the transcript alone |
| Context window | tokens | context_window_size from the status line, else the model's default window | status line (after cctop install) | — | ≈ until cctop install |
| Fixed prefix | tokens | cache_read + cache_write of the session's first API call: system prompt, CLAUDE.md, tool schemas — lowered to the context right after any boundary that lands below it, and replaced by the /context table's own categories (all but Messages) when the person ran one and no model switch followed | transcript | With a warm cache the first call is a read, so both fields are summed. The first call also carries the opening message and its attachments, so the figure overstates the fixed part (+33 % on the one ground truth); a /context run corrects it | ≈ until a /context has run |
| Context sources | tokens | One row per kind of content in the window since the last boundary: prefix · files · bash output · mcp results · agent returns · web · other results · prompts · harness · thinking · tool inputs · prose · other. Results, inputs and prompts are chars / 4 placed on the API call that first carried them and reconciled per step against Δcontext − previous output_tokens; thinking and prose are exact | transcript | The rows sum to the context size by construction, so the sum is not the test — overflow_raw (what the estimates would have exceeded the size by with no reconciliation) and reconciled (what came off) are. The inspector opens with m on the Context panel | ≈ on every row but thinking and prose |
| Tokens by source | tokens | Σ tokens → context of the calls whose results a step carried, by kind: Read and a Bash cat / sed -n / head / tail of exactly one path → files; other Bash → bash output; mcp:* → mcp results; Agent → agent returns; WebFetch / WebSearch → web; the rest → other results. Prompts: prompt_chars / 4 + 1 500 per pasted image. Harness: the attachments' tokens | transcript | Scaled down on a step whose estimates exceed its exact growth; a Bash command that reads two or more files stays in bash output | ≈ |
| Per-file tokens | tokens | A file's Read results in the window (read: in the files row) and the bytes the model wrote into Edit / Write of it (written: in tool inputs), with its read count | transcript | Relative Bash paths resolve against the session's cwd; a file read before the last boundary shows nothing — its content left with it | ≈ |
| Context reference | enum | Where the window's accounting starts: session-start, or the last boundary's kind with the index of its first call and the Δcontext that opened it | transcript | A model switch that did not shrink the window keeps the rows in the old model's tokens and is reported as model_switch_kept | exact |
| Context velocity | tokens/turn | Exponential moving average (α = 1/5) of Δ context size per turn | transcript | Turns that compacted are excluded from the average; — until a second turn has made a call (no sample is not zero growth) | exact |
| Turns until autocompact | turns | (autocompact threshold − context size) / context velocity | transcript · status line (after cctop install) | Threshold = Claude Code's effective window − 13 000 tokens, the effective window being the nominal one less a 20 000-token output reserve (967 000 on native-1M models, 167 000 on 200 k windows) until a compaction has been observed for the model, then the observed value is used | ≈ until the first compaction has been seen |
| Context anatomy | tokens | The stacked bar: prefix · tool inputs (chars the model wrote / 4, capped per call at its output less its thinking) · tool results (tokens → context, each placed on the API call that first carried it) · retained thinking (exact) · harness (attachments, each placed on the call that first carried it) · prose (exact: output − thinking − inputs per call) · unattributed (prompts and the rest of the size), since the last boundary. Every step's estimates are reconciled against that step's exact growth, Δcontext − previous output_tokens, before they are summed | transcript | A boundary is /clear, a compaction, a microcompact, a resume or fork, a ≥ 30 % drop with no marker, any smaller drop with no marker, or a model switch that re-measured the window smaller; the in-flight call and results after it are not resident. Encoding: the slices are drawn in order of agency and coloured by the theme's series ramp derived from its accent — dim for what cannot change this session (prefix, harness), mid for what the next boundary drops (thinking), bright for what the person can move (inputs, results, prose) — never by the status palette, and adjacent slices alternate the fill glyph so the order survives 16 colours, NO_COLOR and the pane | ≈ on every slice but thinking and prose |
| Harness per turn | tokens | Attachment tokens (reminders, injected files, listings) ÷ human turns since the last boundary | transcript | rendered[].content since Claude Code 2.1.266; per-subtype ratios before | ≈ before 2.1.266 |
| Context band | enum | ok below threshold − 20 000 · warn inside that band (Claude Code's footer turns to "Context low") · blocked at the threshold or window − 3 000; the footer text is Claude Code's own (N% until auto-compact, N% context used when autocompact is off); precompute armed at 80 % of the window | transcript · status line (after cctop install) · D12 | Overrides come from settings.json and the claude process environment (CLAUDE_CODE_AUTO_COMPACT_WINDOW, CLAUDE_AUTOCOMPACT_PCT_OVERRIDE, DISABLE_AUTO_COMPACT, autoCompactWindow, autoCompactEnabled) | exact |
| Compactions | count | system/compact_boundary lines (exact: trigger, pre/post tokens, duration), or a PreCompact hook | transcript · hook events (after cctop install) | API-error lines (<synthetic>, zero usage) never count | Before Claude Code 2.1.263 (no compact_boundary) a drop between two API calls is a compaction when the compaction summary or a /compact sits between them, or when it is ≥ 30 % on the same model with no /model between (a model switch or a handover re-measures the window) |
| Reading | Unit | How it is measured | From | Caveats | Exact? |
|---|---|---|---|---|---|
| Cache read | tokens | Σ cache_read_input_tokens over distinct API responses | transcript | Counted once per message.id; Claude Code writes one line per content block | exact |
| Cache write | tokens | Σ cache_creation_input_tokens, split into 5-minute and 1-hour TTL from cache_creation.ephemeral_* | transcript | — | exact |
| Fresh input | tokens | Σ input → context (in→ctx) (uncached) | transcript | — | exact |
| Output | tokens | Σ output_tokens | transcript | — | exact |
| Thinking | tokens | Σ output_tokens_details.thinking_tokens (a subset of output) | transcript | — | exact |
| Cache hit ratio | ratio | cache read / (cache read + cache write + fresh input) | transcript | Green ≥ 0.8, amber ≥ 0.5, red below | exact |
| Cache TTL | enum | prompt_cache.ttl from the status line; else 1h if the latest call reports ephemeral_1h_input_tokens > 0, else 5m | status line (after cctop install) · transcript | — | ≈ without the shim |
| Cache warm | bool | prompt_cache.warm from the status line; else whether the last API call is younger than the observed TTL | status line (after cctop install) · transcript | — | ≈ without the shim |
| Cache expires in | ms | prompt_cache.expires_at − now, clock-driven between status rewrites; else last API call + observed TTL − now | status line (after cctop install) · transcript | The status file is rewritten only at expiry, so the countdown runs on cctop's clock; the shim's figure is ignored when the file predates the last assistant line | ≈ without the shim, or when the status file is stale |
| Re-cache if cold | tokens | prompt_cache.recache_tokens_if_cold: what the next call re-writes if the cache expires first | status line (after cctop install) | — | exact |
| Cache misses | count | prompt_cache.misses with miss_causes (model_changed, tools_changed, messages_rewritten, ttl_expired_1h/5m, likely_server_side…) and expected_rebuilds | status line (after cctop install) | Claude Code counts a miss when the cache read is < 95 % of the input and ≥ 2 000 tokens were re-processed | exact |
| Cost | USD | Claude Code's cost-state.totalCostUSD, the latest per writing process (startTime: a --resume beside the live session or a bridge appends a second process's own running total to the same file) summed, plus a priced estimate of responses newer than the last ledger | Claude Code's cost record · transcript · price table | Subscription plans have no per-token bill; the figure is the API-equivalent list price. A ledger that covers less than the transcript's own responses are worth is another process's (this one's is still to come) and does not displace the estimate — so two readers of one file never disagree by a process, and a $0 ledger from a process that did nothing never zeroes a busy session | ≈ when any part is estimated, or while the ledgers cover less than the responses |
| Combined cost | USD | The session's whole spend: cost-state.totalCostUSD (every process's, as cost; it already holds the subagents' calls and calls no transcript shows), plus the priced main responses after it, plus the priced subagent calls whose line timestamp is after the ledger's moment (the last timestamped line before the cost-state); with no cost-state, every main and agent call priced. Panel 2's headline, dashboard row 2, cctop report and cctop query's combined cost | transcript · subagent transcripts · price table · Claude Code's cost record | Never a subtraction: main and agents are not derived from the ledger. A fork's replayed parent message is not priced. source says ledger / priced / mixed; cost keeps the main-only meaning for one release | ≈ when any priced part is non-zero |
| Cost by model | USD | cost-state.modelUsage[*].costUSD plus estimates per model | Claude Code's cost record · price table | — | ≈ when any part is estimated |
| Cost per call | USD | context × cache-read price + median output × output price, at the current context; at the cache-write price of the observed TTL when the cache is cold | transcript · status line (after cctop install) · price table | What the next API call costs, not what the last one did | always an estimate — priced from the list table |
| Cost per turn | USD | cost per call × the session's own median calls per turn (turns with ≥ 1 call), also given at 100 k of context; next 30 calls = cost per call × 30 | transcript · price table | The median is the session's, never a constant | always an estimate — priced from the list table |
| Where the tokens went | ratio | Input tokens of API responses by their attributionSkill / attributionPlugin / attributionAgent / attributionMcpServer owner, machine-originated turns under idle, the subagents' own usage under agents; shares of all input tokens | transcript · D6 | A response without an where the tokens went key is the person's own work | exact |
| Agents cost | USD | Priced usage of every subagent transcript (incl. subagents/workflows/**) and its share of the session's total | subagent transcripts · price table | — | ≈ (priced from the table) |
| Team cost | USD | Σ over the teammates of the team this session leads, each from its own transcript: its cost-state.totalCostUSD where one exists, plus its priced calls after that line (all of them while it has none); members found from ~/.claude/teams/<team>/config.json, the lead's teammate_spawned results and a scan of the transcripts naming the team (teamName == session-<lead id8>). Part of combined cost, toggled with the agents by a | D12 · D2c · Claude Code's cost record · price table | A teammate's ledger already holds its own subagents and hidden calls; never a subtraction. A member whose transcript is not found adds nothing and marks the sum | ≈ for a teammate's calls after its last cost-state, or all of them while it runs; ≈ and "N of M read" when a transcript is missing |
| Limit weight | ratio | /usage's weight of a call: (cached + uncached × 10 + cache-create × 12.5 + output × 50) × tier (fable 10, opus 5, sonnet 3, haiku 1) | transcript · D12 | Why the limit bar moves faster than dollars | exact |
| Behaviour flags | % | /usage's five flags as shares of the weighted usage: cache_miss (requests with > 100 k uncached tokens), long_context (> 150 k context), subagent_heavy, high_parallel (≥ 4 live sessions), cron (active ≥ 8 h); shown with Claude Code's own tip text at ≥ 10 % | transcript · session registry · D12 | — | exact |
| Burn rate | USD/h | Cost of turns active in the trailing 15 minutes, scaled to an hour over the part of the window they cover | transcript · price table | A turn counts from its start (clamped to the window) to its last line; windows shorter than 1 minute are treated as 1 minute | always an estimate — priced from the list table |
| Input rate | tokens/min | Total input tokens of turns started in the trailing 15 minutes ÷ window | transcript | — | exact |
| Reading | Unit | How it is measured | From | Caveats | Exact? |
|---|---|---|---|---|---|
| 5-hour usage | % | rate_limits.five_hour.used_percentage from the status line | status line (after cctop install) | Account-wide: other live sessions contribute | exact |
| 7-day usage | % | rate_limits.seven_day.used_percentage from the status line | status line (after cctop install) | Account-wide | exact |
| Resets in | duration | resets_at − now | status line (after cctop install) | — | exact |
| Rate limited | enum | The newest API-error line with error: rate_limit (or status 429): quotaLimits.rateLimitType, resetsAt, lowPriorityRetryAfterSeconds — cleared by the next successful call | transcript | Exact without the shim: Claude Code writes the 429 into the transcript | exact |
| Spend limit | % | rate_limits.spend_limit.used_percentage from the status line, for accounts with a monthly limit | status line (after cctop install) | — | exact |
| Other sessions | list | Live registry entries other than this one: busy/idle and how long (statusUpdatedAt) | session registry | They share the rate limit | exact |
| Projected exhaustion | duration | Least-squares slope of used_percentage samples over the last 30 min, extrapolated to 100 % | status line (after cctop install) | Needs ≥ 3 samples; rate-limit units are plan-specific, so tokens are not used | always an estimate |
| Reading | Unit | How it is measured | From | Caveats | Exact? |
|---|---|---|---|---|---|
| Turn duration | ms | turn_duration.durationMs system line written when the turn ends | transcript | — | exact |
| API calls | count | Distinct message.ids in the turn | transcript | — | exact |
| API time | ms | cost-state.totalAPIDuration for the session; per turn, gaps between a user/tool_result line and the next assistant line | Claude Code's cost record · transcript | — | exact per session, ≈ per turn |
| Retry time | ms | totalAPIDuration − totalAPIDurationWithoutRetries | Claude Code's cost record | — | exact |
| Phase | enum | The last call's phase over the last seven calls (phase.rs: EXPLORING / IMPLEMENTING / VERIFYING / COMMITTING / PLANNING / DELEGATING / BROWSING / OPS / WAITING) and its run length; WAITING when a permission dialog, an AskUserQuestion or a Notification is pending | transcript · hook events (after cctop install) | A test-class command is VERIFYING only once its output confirmed a run | exact |
| Last check | enum | The newest test-class Bash call whose output confirmed a run (test result:, N passed, # pass…), its verdict and age; edits since counts Edit/Write calls after it | transcript | — | exact |
| Waiting on you | enum | A pending permission dialog (hook), a running AskUserQuestion / ExitPlanMode, an idle_prompt / agent_needs_input notification, or a finished turn whose last text ended with ?; with the wait's duration | transcript · hook events (after cctop install) | — | exact |
| Steers | count | Human queued_command attachments folded into the turn (absorbed mid-turn); task notifications are machine turns, not steers | transcript | — | exact |
| Interrupts | count | [Request interrupted by user…] lines with interruptedMessageId, and the output tokens the cut turns had produced | transcript | — | exact |
| Hook time by command | ms | stop_hook_summary.hookInfos[].command and hook_success attachments summed per command over the session; preventedContinuation marks a blocked stop | transcript | — | exact |
| Goal | enum | The last goal_status attachment (/goal): met, iterations, tokens | transcript | — | exact |
| Hook runs | count | Number of hookInfos entries in the turn's stop_hook_summary | transcript | Only Stop hooks are summarised by Claude Code; other hook events need cctop install | exact |
| Hook time | ms | Σ hookInfos[].durationMs for the turn | transcript · hook events (after cctop install) | — | exact |
| Permission wait | ms | PermissionRequest → PostToolUse for the same tool_use_id, minus the tool's median duration | hook events (after cctop install) | PreToolUse fires before the prompt, so it cannot bound the wait | always an estimate |
| Queued prompts | count | queue-operation enqueue − dequeue/remove; popAll resets to 0 | transcript | — | exact |
| Reading | Unit | How it is measured | From | Caveats | Exact? |
|---|---|---|---|---|---|
| Calls | count | tool_use blocks per tool name; MCP tools grouped as mcp:<server> | transcript | — | exact |
| Errors | count | tool_result blocks with is_error per tool | transcript | — | exact |
| p50 duration | ms | Median of tool_use → tool_result durations | transcript · hook events (after cctop install) | Transcript timings include any permission wait | ≈ until hook timings replace it |
| p95 duration | ms | 95th percentile (nearest rank) of durations | transcript · hook events (after cctop install) | — | ≈ until hook timings replace it |
| Last call | duration | now − the tool's most recent tool_use timestamp | transcript | — | exact |
| Tokens → context | tokens | Σ len(result text) / 4 per tool, plus w·h/750 per image (1 500 when the size is unknown); cleared results count 0 | transcript · OpenTelemetry | Heuristic; exact with OpenTelemetry. Uses the text in the transcript, not offloaded tool-results/ files (their size is shown beside it) | ≈ unless OpenTelemetry is on |
| Input → context (IN→CTX) | tokens | Characters the model wrote as tool inputs / 4, per tool — they stay in context like results do | transcript | Bash command text is the largest share | always an estimate |
| Bash by class | count | Bash calls by the phase classifier's class: explore / implement / test / build-lint / commit / gitread / ops / wait (Bash·test rows) | transcript | — | exact |
| Error class | count | Failed calls by Claude Code's own taxonomy (Command Failed / User Rejected / Edit Failed / File Changed / File Too Large / File Not Found / Other) plus Content Not Found, Timeout, Tool Not Found and Denied (toolDenialKind) | transcript | Classified from the result text, in Claude Code's order | exact |
| Top context consumers | tokens | The n single results with the largest tokens → context; ⊘ marks a result cut at a cap (truncatedByTokenCap, a persisted spill) | transcript | — | ≈ unless OpenTelemetry is on |
| Re-read tax | USD | API calls since the result landed × its tokens × the cache-read price: what re-reading it has cost so far | transcript · price table | — | always an estimate |
| ToolSearch loads | count | Deferred tools loaded through ToolSearch per MCP server (matches of its result); each load rewrites the cached prefix | transcript | — | exact |
| Reading | Unit | How it is measured | From | Caveats | Exact? |
|---|---|---|---|---|---|
| Agent state | enum | running while tool_uses are pending; done when the last response ends with text and no pending tool_use; failed when the last result is an error and nothing followed for 60 s | subagent transcripts · hook events (after cctop install) | — | exact |
| Agent cost | USD | The agent's own calls priced from the table (a fork's replayed parent message excluded); — with the token count on a model the table does not know | subagent transcripts · price table | — | always an estimate |
| Agent status | enum | <status> of the agent's <task-notification> (completed / failed / killed), by whichever of Claude Code's three deliveries it came — a user line, a queue-operation enqueue or a queued_command attachment; absent until it lands | transcript | Claude Code's word beats the 60 s heuristic of agent state where both exist | exact |
| Agent returned | tokens | Length of the notification's <result> ÷ 4 (a synchronous Agent result's content ÷ 4): what came back into the session; absent until a result exists, 0 for an empty one | transcript | A size, never a judgement of the result; the text is not kept | always an estimate |
| Agent waste | USD | The agent's priced cost under one reason, tested in order: failed (the notification, a workflow-journal failed entry, or the 60 s heuristic without a notification), killed, no ret (completed with an absent or empty result), idle (no notification, running, no line for 5 min, nothing in flight — no tool the hook spool saw start and not finish, none the transcript shows unanswered); a finished agent without a notification is not waste, and a notification's completed outranks the journal | transcript · subagent transcripts · hook events (after cctop install) · price table | Structural evidence only: statuses, lengths, counts, timings | always an estimate |
| Agents waste | USD | Σ agent waste by reason over every subagent, and the agents classified | transcript · subagent transcripts · hook events (after cctop install) · price table | — | always an estimate |
| Cold starts | count | Agents (forks excluded) whose first call wrote more cache than it read, and the cache-write dollars of those first calls | subagent transcripts · price table | A cost of the design, not counted as waste | ≈ for the dollars |
| Return ratio | ratio | Σ agent returned ÷ Σ agent output tokens: the share of what the agents wrote that came back | transcript · subagent transcripts | — | always an estimate |
| Workflow failed | count | Agents of a workflow run with a failed journal entry, by phase, each with one cause from its last API-error line (apiErrorStatus, error token) and its call count | subagent transcripts | A 429 on the first call costs ≈$0: read it with the count, not the dollars | exact |
| Workflow failed $ | USD | Σ agent cost of the run's failed agents | subagent transcripts · price table | — | always an estimate |
| Workflow waste | % | Σ agent waste of the run's agents ÷ the run's priced cost | transcript · subagent transcripts · hook events (after cctop install) · price table | — | always an estimate |
| Workflow overhead | ratio | The run's priced cost ÷ the main thread's priced responses between the run's start and its end (or now) | transcript · subagent transcripts · price table | A ratio, not a counterfactual: the main thread would not necessarily have done the work cheaper; — under $0.01 of main spend | always an estimate |
| Workflow cold starts | % | Cache-write $ of the first call of the run's cold-started agents ÷ the run's priced cost | subagent transcripts · price table | A cost of the design, not waste | always an estimate |
| Agent tokens | tokens | Deduplicated usage of the agent's own transcript: the last line of each message.id (subagent transcripts stream output_tokens), without a fork's replayed first message (the parent's launching response, billed in the parent) | subagent transcripts | — | exact |
| MCP memory | bytes | RSS of the MCP server process | process tree | — | exact |
| MCP calls | count | Calls of tools named mcp__<server>__* | transcript | — | exact |
| Workflow runs | count | subagents/workflows/<run>/journal.jsonl: agents launched, finished (result) and failed per run; the run's agents are scanned like the top-level ones | subagent transcripts | — | exact |
| Spawn depth | count | Deepest spawnDepth among the agents (Claude Code caps it at 3) | subagent transcripts | — | exact |
| Teammates | list | Members of ~/.claude/teams/<team>/config.json when this session leads the team | D12 | — | exact |
| Teammate cost | USD | The teammate's own cost-state.totalCostUSD plus its priced calls after that line; all of them priced while it has none; — with no transcript when its file is not found | D2c · Claude Code's cost record · price table | Claude Code's own number once the teammate ended | ≈ while it runs or after its ledger's moment |
| Teammate context | tokens | The teammate's current context: the input of its last API call, as Panel 1 computes the lead's | D2c | — | exact |
| Teammate tokens | tokens | Deduplicated usage of the teammate's transcript (one figure per message.id), as the lead's Panel 2 | D2c | — | exact |
| Teammate turns | count | Turns of the teammate's transcript, human / machine: a <teammate-message> starts a machine turn | D2c | — | exact |
| Teammate state | enum | active (isActive: true in the team config) · recent (no config; a line in the last 5 min) · ended (its file ends with a cost-state, or isActive: false) · gone (no ledger, no config, no recent line) · missing (known from the config or a spawn, no transcript found) | D12 · D2c | No process mapping: liveness is Claude Code's flag or line recency | exact |
| Teammate waste | USD | The cost of the teammate's current turn under one reason: idle (alive, no API call for 5 min, no tool call unanswered in its transcript) or errored (its last response was an API-error line and nothing followed for 60 s) | D2c · price table | Structural evidence of its own transcript only; no inbox, no message body | always an estimate |
| Team waste | USD | Σ teammate waste over the team | D2c · price table | — | always an estimate |
| MCP needs auth | list | deferred_tools_delta.needsAuthMcpServers / failedMcpServers from the transcript | transcript | — | exact |
| Reading | Unit | How it is measured | From | Caveats | Exact? |
|---|---|---|---|---|---|
| Touches | count | Read / Edit / Write / MultiEdit / NotebookEdit calls per file path, plus Bash cat / sed -n / head / tail reads of it | file tool calls | A read counts when its result arrives | exact |
| Lines ± | lines | git diff --numstat against HEAD at attach time | git | Outside a git repo the column is empty | exact |
| Uncommitted | lines | git diff --numstat HEAD (added, removed, files) and the last commit Claude Code summarised (gitOperation.commit) with the edits since it | git · transcript | — | exact |
| Rewind points | count | file-history-snapshot lines in the current turn (checkpoints /rewind can restore) and the Bash writes of the turn no checkpoint covers; per file: the checkpoint version (file-history-delta, ⚠ at v8+), IDE edits (edited_text_file), stale markers (staleRecovered, staleReadFileStateHint), edit → re-read → edit churn | transcript | — | exact |
| Re-reads | count | Whole-file reads (Read or a Bash reader) with no Edit/Write in between; ⚠ at ≥ 3 | file tool calls | Ranged reads (offset/limit) and file_unchanged results do not count; the counter resets when the file changed under the model (an IDE edit, a stale-read recovery) and at every context boundary | exact |
| Reading | Unit | How it is measured | From | Caveats | Exact? |
|---|---|---|---|---|---|
| Estimated saving | tokens or seconds | Rule-specific estimate of what following the advice saves per remaining turn | transcript | Ranking key; always an estimate | always an estimate |
| Reading | Unit | How it is measured | From | Caveats | Exact? |
|---|---|---|---|---|---|
| Context light | percent | The context size as % of the exact window; ○ below 150k, ◐ from 150k (or ≥ 300k on a 1M window while a turn runs), ● inside the autocompact warn band (effective window − 13 000 − 20 000) or at ≥ 300k with a clean stop available | session registry · status line (after cctop install) | Never a fixed 80 %: a deliberate 1M session sits amber | ≈ when the window is the model default |
| Cache light | minutes or tokens | Minutes of cache left (prompt_cache.expires_at, else last call + observed TTL ≈), or the re-write size when cold; ◐ inside the countdown band (the last 5 min of a 1 h entry, 2 min of a 5 m one), ● when a reply now would save ≥ 50k | session registry · status line (after cctop install) | — | ≈ without the status-line shim |
| Limits light | percent | The 5 h window used; ◐ when the exhaustion fit lands before the reset or ≥ 80 %, ● on a rate-limit or spend-limit error line; — without the status line | status line (after cctop install) · session registry | — | exact |
| Rework light | state | Open issues: consecutive failed calls of the turn (denials excluded), corrections (interrupts, rejected calls) in the last three turns, blocked calls; else the source edits since the last confirmed test run. The figure is a state word — N open, N unchecked, ok, or — before the session has called anything — never a 0 that means healthy and no data alike. ◐ after 10 min or 14 calls unverified, two fails, a PR without a review, an uncommitted tail; ● on a cascade, a denial streak, a correction streak, destructive git on a dirty tree, a commit without a check | session registry · git | — | exact |