Economia

PRECC rastreia a economia estimada de tokens em cada intercepção. Use precc savings para ver quanto desperdício PRECC evitou.

Resumo rápido

$ precc savings
Session Token Savings
=====================
Total estimated savings: <span data-stat="session_tokens_saved">8,741</span> tokens

Breakdown:
  Pillar 1 (cd prepends):         <span data-stat="session_p1_tokens">3,204</span> tokens  (<span data-stat="session_p1_count">6</span> corrections)
  Pillar 4 (skill activations):   <span data-stat="session_p4_tokens">1,560</span> tokens  (<span data-stat="session_p4_count">4</span> activations)
  RTK rewrites:                   <span data-stat="session_rtk_tokens">2,749</span> tokens  (<span data-stat="session_rtk_count">11</span> rewrites)
  Lean-ctx wraps:                 <span data-stat="session_lean_tokens">1,228</span> tokens  (<span data-stat="session_lean_count">2</span> wraps)

Detalhamento completo (Pro)

$ precc savings --all
Session Token Savings (Detailed)
================================
Total estimated savings: <span data-stat="session_tokens_saved">8,741</span> tokens

Command-by-command:
  #  Time   Command                          Saving   Source
  1  09:12  cargo build                      534 tk   cd prepend (cargo-wrong-dir)
  2  09:14  cargo test                       534 tk   cd prepend (cargo-wrong-dir)
  3  09:15  git status                       412 tk   cd prepend (git-wrong-dir)
  4  09:18  npm install                      824 tk   cd prepend (npm-wrong-dir)
  5  09:22  find . -name "*.rs"              387 tk   RTK rewrite (output truncation)
  6  09:25  cat src/main.rs                  249 tk   RTK rewrite (lean-ctx wrap)
  7  09:31  cargo clippy                     534 tk   cd prepend (cargo-wrong-dir)
  ...

Pillar Breakdown:
  Pillar 1 (context resolution):   <span data-stat="session_p1_tokens">3,204</span> tokens  <span data-stat="session_p1_pct">36.6</span>%
  Pillar 2 (GDB debugging):            0 tokens   0.0%
  Pillar 3 (mined preventions):        0 tokens   0.0%
  Pillar 4 (automation skills):    <span data-stat="session_p4_tokens">1,560</span> tokens  <span data-stat="session_p4_pct">17.8</span>%
  RTK rewrites:                    <span data-stat="session_rtk_tokens">2,749</span> tokens  <span data-stat="session_rtk_pct">31.5</span>%
  Lean-ctx wraps:                  <span data-stat="session_lean_tokens">1,228</span> tokens  <span data-stat="session_lean_pct">14.1</span>%

Como as economias são estimadas

Cada tipo de correção tem um custo estimado de tokens baseado no que teria acontecido sem PRECC:

Tipo de correção	Economia estimada	Justificativa
cd prepend	~500 tokens	Saída de erro + raciocínio do Claude + retry
Ativação de habilidade	~400 tokens	Saída de erro + raciocínio do Claude + retry
RTK rewrite	~250 tokens	Saída verbosa que Claude teria que ler
Lean-ctx wrap	~600 tokens	Conteúdo de arquivo grande comprimido
Prevenção minerada	~500 tokens	Padrão de falha conhecido evitado

Estas são estimativas conservadoras. As economias reais são frequentemente maiores porque o raciocínio do Claude sobre erros pode ser extenso.

Economia acumulada

As economias persistem entre sessões no banco de dados PRECC. Ao longo do tempo, você pode acompanhar o impacto total:

$ precc savings
Session Token Savings
=====================
Total estimated savings: <span data-stat="session_tokens_saved">8,741</span> tokens

Lifetime savings: <span data-stat="total_tokens_saved">142,389</span> tokens across <span data-stat="total_sessions">47</span> sessions

Barra de status

Após a instalação, o PRECC adiciona uma entrada statusLine em ~/.claude/settings.json para que a barra de status do Claude Code mostre métricas de sessão ao vivo:

$0.42 spent | 1.2M in/out | 📊 last cmd: −1.2K | PRECC: 7 fixes | 5.8ms avg | this session: 320 saved over 7 cmds (~$0.05) | lifetime: 8.9K saved over 217 cmds (~$2.85)

Defina PRECC_LANG para exibir os rótulos no seu idioma — consulte o capítulo de Localização.

Cada segmento:

Segmento	Fonte	Significado	Reinicia ao reiniciar a sessão?
`$0.42 spent`	`cost.total_cost_usd`	Custo acumulado da sessão informado pelo Claude Code	Sim
`1.2M in/out`	`total_input_tokens + total_output_tokens`	Tokens de entrada (não em cache) + saída durante a sessão	Sim
`📊 last cmd: −1.2K`	Medição do PRECC do comando Bash mais recente	Economia real medida ao reexecutar o original	Não (persiste entre sessões)
`PRECC: 7 fixes`	`metrics.log`	Número de correções nesta sessão — apenas contagem, sem estimativa falsa de tokens	Sim
`5.8ms avg`	Latência p50 do hook PRECC	Tempo que o PRECC gastou processando cada chamada de ferramenta	Sim
`bash 18% of total`	`post_observations.log`	Proporção de tokens da sessão provenientes da saída do Bash — esclarece por que as economias do PRECC são naturalmente uma fração do custo total (o PRECC só otimiza a saída do Bash)	Sim
`this session: 320 saved over 7 cmds (~$0.05)`	`.lifetime_summary.json` − baseline	Delta real por sessão. Oculto quando o delta é zero (início da sessão)	Sim (a linha de base é recapturada)
`lifetime: 8.9K saved over 217 cmds (~$2.85)`	`.lifetime_summary.json`	Tokens cumulativos economizados e comandos re-medidos desde a primeira instalação do PRECC, além de um valor estimado em USD à tarifa atual por token	Não

O segmento lifetime: é colocado por último para que seja o primeiro a ser truncado se a interface do Claude Code cortar a barra na borda direita.

Por que custo e contagem de tokens não se dividem

O 1.2M in/out exibido não é o denominador que produziu $0.42 spent. O cost.total_cost_usd do Claude Code é calculado a partir do detalhamento completo de tokens da API — entrada base, saída, mais leituras de cache e criações de cache. As contagens acumuladas de tokens de cache de toda a sessão não são expostas no esquema do statusline, então o PRECC só pode mostrar a parte visível (não-cache).

Em sessões longas com muitas releituras de arquivos, as leituras de cache podem ser 10× a contagem de tokens visíveis. Por isso emparelhá-los como uma proporção seria enganoso — em vez disso, o PRECC os mostra como segmentos independentes.

Por que o PRECC não calcula o custo

O número do custo é autoritativo. O PRECC lê cost.total_cost_usd literalmente do JSON que o Claude Code envia para o comando de status via stdin. Esse é o mesmo número que o Claude Code cobra contra seu orçamento de assinatura/uso. Você pode verificá-lo a qualquer momento com o comando slash integrado /cost — ambos devem concordar.

O que impulsiona o custo

Para o Claude Opus 4.6:

Token type	Standard (≤200k context)	1M context tier
Input	$15 / MTok	$30 / MTok
Output	$75 / MTok	$150 / MTok
Cache write	$18.75 / MTok	$37.50 / MTok
Cache read	$1.50 / MTok	$3 / MTok

Os maiores impulsionadores em sessões longas geralmente são tokens de saída (o tipo mais caro por token, especialmente no nível de contexto 1M), leituras de cache repetidas (baratas individualmente, mas acumulando-se rapidamente em muitas rodadas) e criações de cache (escritas uma vez por leitura de arquivo a ~1.25× a tarifa base de entrada). O PRECC reduz o custo de tokens visíveis comprimindo a saída do Bash (o segmento 📊 last cmd: mostra a economia por comando), mas não pode reduzir as leituras de cache de arquivos que o Claude já carregou.

Contagens de sessão estáveis

O segmento “PRECC: N fixes” conta eventos desde o início da sessão persistido, gravado em ~/.local/share/precc/sessions/<session_id>.start na primeira atualização do statusline de cada sessão. Isso torna a contagem monotônica — ela não pode diminuir no meio da sessão mesmo que cost.total_duration_ms esteja ausente em uma atualização específica.

Snapshot vitalício atualizado automaticamente

O segmento lifetime: lê ~/.local/share/precc/.lifetime_summary.json, que é reescrito a cada medição PostToolUse e a cada invocação de precc savings. O segmento this session: lê o mesmo arquivo lifetime, mas subtrai uma linha de base por sessão persistida na primeira atualização de cada sessão. Nenhuma atualização manual necessária — os arquivos se atualizam sozinhos.

Suprimir a barra de status

Se preferir manter sua barra de status existente, defina seu próprio comando statusLine em ~/.claude/settings.json. O instalador do PRECC detectará o valor personalizado e o deixará intocado em atualizações posteriores.

Para suprimir apenas a linha 📊 PRECC por interação (em additionalContext), defina PRECC_QUIET=1 no seu ambiente de shell.

PRECC’s three savings mechanisms each have a counterpart in the recent literature. These are related work — the ideas PRECC’s design draws on. Their reported figures are their measurements, not PRECC’s: PRECC only ever quotes numbers measured on your own machine (see “measured, not estimated”, above).

Output/trajectory trimming (PRECC’s diet + bash-output compression) — Reducing Cost of LLM Agents with Trajectory Reduction (AgentDiet), FSE 2026, arXiv:2509.23586. Removes redundant/expired trajectory content post-hoc; reports −39.9–59.7% input tokens. PRECC applies the same idea pre-execution and deterministically (no extra LLM call).
Skills as programs (PRECC’s mined + builtin rewrite skills) — Harnessing LLM Agents with Skill Programs, arXiv:2605.17734. Frames reusable agent skills as executable program functions — the same analogy behind PRECC’s command-rewrite skills (a pattern → a deterministic rewrite).
Context compression (PRECC’s compress + lean-ctx wrapping) — Compress the Context, Keep the Commitments: A Formal Framework for Verifiable LLM Context Compression, arXiv:2605.17304. Recent work on compressing context without losing required information — the property PRECC’s deterministic, cache-stable rewrites aim to preserve.

Keyboard shortcuts

PRECC User Guide