Risparmi

PRECC tiene traccia del risparmio stimato di token per ogni intercettazione. Usa precc savings per vedere quanto spreco PRECC ha prevenuto.

Riepilogo rapido

$ 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)

Analisi dettagliata (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>%

Come vengono stimati i risparmi

Ogni tipo di correzione ha un costo stimato in token basato su ciò che sarebbe successo senza PRECC:

Tipo di correzione	Risparmio stimato	Ragionamento
cd prepend	~500 tokens	Output errore + ragionamento Claude + retry
Attivazione skill	~400 tokens	Output errore + ragionamento Claude + retry
RTK rewrite	~250 tokens	Output verbose che Claude avrebbe dovuto leggere
Lean-ctx wrap	~600 tokens	Contenuti di file grandi compressi
Prevenzione appresa	~500 tokens	Pattern di errore noto evitato

Queste sono stime conservative. I risparmi effettivi sono spesso maggiori perché il ragionamento di Claude sugli errori può essere verbose.

Risparmi cumulativi

I risparmi persistono tra le sessioni nel database PRECC. Nel tempo, puoi monitorare l’impatto totale:

$ 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 di stato

Dopo l’installazione, PRECC inserisce una voce statusLine in ~/.claude/settings.json affinché la barra di stato di Claude Code mostri le metriche di sessione in tempo reale:

$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)

Imposta PRECC_LANG per visualizzare le etichette nella tua lingua — vedi il capitolo Localizzazione.

Ogni segmento:

Segmento	Fonte	Significato	Si reimposta al riavvio della sessione?
`$0.42 spent`	`cost.total_cost_usd`	Costo cumulativo della sessione riportato da Claude Code	Sì
`1.2M in/out`	`total_input_tokens + total_output_tokens`	Token di input (non in cache) + output durante la sessione	Sì
`📊 last cmd: −1.2K`	Misurazione PRECC dell’ultimo comando Bash	Risparmio reale misurato rieseguendo l’originale	No (persiste tra le sessioni)
`PRECC: 7 fixes`	`metrics.log`	Numero di correzioni in questa sessione — solo conteggio, nessuna stima fittizia di token	Sì
`5.8ms avg`	Latenza hook PRECC p50	Tempo impiegato da PRECC per elaborare ogni chiamata di strumento	Sì
`bash 18% of total`	`post_observations.log`	Quota dei token di sessione provenienti dall’output Bash — chiarisce perché i risparmi di PRECC siano naturalmente una frazione del costo totale (PRECC ottimizza solo l’output Bash)	Sì
`this session: 320 saved over 7 cmds (~$0.05)`	`.lifetime_summary.json` − baseline	Delta reale per sessione. Nascosto quando il delta è zero (inizio sessione)	Sì (la baseline viene riacquisita)
`lifetime: 8.9K saved over 217 cmds (~$2.85)`	`.lifetime_summary.json`	Token cumulativi risparmiati e comandi rimisurati dalla prima installazione di PRECC, più un valore stimato in USD alla tariffa corrente per token	No

Il segmento lifetime: è posizionato per ultimo in modo che sia il primo a essere troncato se l’interfaccia di Claude Code taglia la barra sul bordo destro.

Perché costo e conteggio token non si dividono

Il 1.2M in/out visualizzato non è il denominatore che ha prodotto $0.42 spent. Il cost.total_cost_usd di Claude Code è calcolato dalla suddivisione completa dei token dell’API — input base, output, più letture di cache e creazioni di cache. I conteggi cumulativi dei token di cache a livello di sessione non sono esposti nello schema statusline, quindi PRECC può mostrare solo la parte visibile (non-cache).

Nelle sessioni lunghe con molte riletture di file, le letture di cache possono essere 10× il conteggio token visibile. Per questo accoppiarli come rapporto sarebbe fuorviante — PRECC li mostra invece come segmenti indipendenti.

Perché PRECC non calcola il costo

Il numero del costo è autorevole. PRECC legge cost.total_cost_usd letteralmente dal JSON che Claude Code invia tramite stdin al comando di stato. È lo stesso numero che Claude Code addebita sul tuo budget di abbonamento/utilizzo. Puoi verificarlo in qualsiasi momento con il comando slash integrato /cost — entrambi dovrebbero coincidere.

Cosa determina il costo

Per 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

I principali fattori nelle sessioni lunghe sono solitamente i token di output (il tipo più costoso per token, specialmente sul livello di contesto 1M), le letture ripetute di cache (economiche singolarmente ma che si accumulano rapidamente in molti turni) e le creazioni di cache (scritte una volta per lettura di file a ~1.25× la tariffa base di input). PRECC riduce il costo dei token visibili comprimendo l’output Bash (il segmento 📊 last cmd: mostra il risparmio per comando), ma non può ridurre le letture di cache dei file che Claude ha già caricato.

Conteggi di sessione stabili

Il segmento “PRECC: N fixes” conta gli eventi dall’inizio della sessione persistito, scritto in ~/.local/share/precc/sessions/<session_id>.start al primo aggiornamento della statusline di ogni sessione. Ciò rende il conteggio monotono — non può diminuire a metà sessione anche se cost.total_duration_ms manca in un particolare aggiornamento.

Snapshot a vita aggiornato automaticamente

Il segmento lifetime: legge ~/.local/share/precc/.lifetime_summary.json, che viene riscritto a ogni misurazione PostToolUse e a ogni invocazione di precc savings. Il segmento this session: legge lo stesso file lifetime ma sottrae una baseline per sessione persistita al primo aggiornamento di ogni sessione. Nessun aggiornamento manuale necessario — i file si aggiornano da soli.

Soppressione della barra di stato

Se preferisci mantenere la tua barra di stato esistente, imposta il tuo comando statusLine in ~/.claude/settings.json. L’installer di PRECC rileverà il valore personalizzato e lo lascerà inalterato negli aggiornamenti successivi.

Per sopprimere solo la riga 📊 PRECC per interazione (in additionalContext), imposta PRECC_QUIET=1 nell’ambiente 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