Ahorros

PRECC rastrea el ahorro estimado de tokens de cada intercepción. Usa precc savings para ver cuánto desperdicio ha evitado PRECC.

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

Desglose detallado (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>%

Cómo se estiman los ahorros

Cada tipo de corrección tiene un costo estimado de tokens basado en lo que habría ocurrido sin PRECC:

Tipo de corrección	Ahorro estimado	Razonamiento
cd prepend	~500 tokens	Salida de error + razonamiento de Claude + reintento
Activación de habilidad	~400 tokens	Salida de error + razonamiento de Claude + reintento
RTK rewrite	~250 tokens	Salida verbose que Claude tendría que leer
Lean-ctx wrap	~600 tokens	Contenido de archivo grande comprimido
Prevención minada	~500 tokens	Patrón de fallo conocido evitado

Estas son estimaciones conservadoras. Los ahorros reales suelen ser mayores porque el razonamiento de Claude sobre errores puede ser extenso.

Ahorros acumulados

Los ahorros se mantienen entre sesiones en la base de datos de PRECC. Con el tiempo, puedes rastrear el 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 estado

Tras la instalación, PRECC añade una entrada statusLine en ~/.claude/settings.json para que la barra de estado de Claude Code muestre métricas de sesión en 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)

Establece PRECC_LANG para mostrar las etiquetas en tu idioma — consulta el capítulo de Localización.

Cada segmento:

Segmento	Fuente	Significado	¿Se reinicia al reiniciar la sesión?
`$0.42 spent`	`cost.total_cost_usd`	Coste acumulado de la sesión informado por Claude Code	Sí
`1.2M in/out`	`total_input_tokens + total_output_tokens`	Tokens de entrada (no cacheados) + salida durante la sesión	Sí
`📊 last cmd: −1.2K`	Medición de PRECC del comando Bash más reciente	Ahorro real medido al volver a ejecutar el original	No (persiste entre sesiones)
`PRECC: 7 fixes`	`metrics.log`	Número de correcciones en esta sesión — solo recuento de correcciones, sin estimación falsa de tokens	Sí
`5.8ms avg`	Latencia p50 del hook PRECC	Tiempo que PRECC tardó en procesar cada llamada a herramienta	Sí
`bash 18% of total`	`post_observations.log`	Proporción de tokens de la sesión provenientes de la salida de Bash — aclara por qué los ahorros de PRECC son naturalmente una fracción del coste total (PRECC solo optimiza la salida de Bash)	Sí
`this session: 320 saved over 7 cmds (~$0.05)`	`.lifetime_summary.json` − baseline	Delta real por sesión. Oculto cuando el delta es cero (inicio de sesión)	Sí (la línea base se vuelve a capturar)
`lifetime: 8.9K saved over 217 cmds (~$2.85)`	`.lifetime_summary.json`	Tokens acumulados ahorrados y comandos re-medidos desde que se instaló PRECC, más un valor estimado en USD a la tarifa actual por token	No

El segmento lifetime: se coloca al final para que sea el primero en truncarse si la interfaz de Claude Code recorta la barra en el borde derecho.

Por qué el coste y el número de tokens no se dividen

El 1.2M in/out mostrado no es el denominador que produjo $0.42 spent. El cost.total_cost_usd de Claude Code se calcula a partir del desglose completo de tokens de la API — entrada base, salida, más lecturas de caché y creaciones de caché. Los conteos acumulados de tokens de caché de toda la sesión no están expuestos en el esquema del statusline, por lo que PRECC solo puede mostrar la porción visible (no caché).

En sesiones largas con muchas relecturas de archivos, las lecturas de caché pueden ser 10× el conteo de tokens visible. Por eso emparejarlos como una proporción sería engañoso — PRECC los muestra como segmentos independientes.

Por qué PRECC no calcula el coste

El número de coste es autoritativo. PRECC lee cost.total_cost_usd literalmente del JSON que Claude Code envía al comando de estado por stdin. Ese es el mismo número que Claude Code carga contra tu presupuesto de suscripción/uso. Puedes verificarlo en cualquier momento con el comando integrado /cost — ambos deben coincidir.

Qué impulsa el coste

Para 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

Los mayores impulsores en sesiones largas suelen ser los tokens de salida (el tipo más caro por token, especialmente en el nivel de contexto 1M), las lecturas de caché repetidas (baratas individualmente pero acumulándose rápido a lo largo de muchos turnos) y las creaciones de caché (escritas una vez por lectura de archivo a ~1.25× la tarifa base de entrada). PRECC reduce el coste de tokens visibles comprimiendo la salida de Bash (el segmento 📊 last cmd: muestra el ahorro por comando), pero no puede reducir las lecturas de caché de archivos que Claude ya ha cargado.

Recuentos de sesión estables

El segmento “PRECC: N fixes” cuenta eventos desde el inicio de la sesión persistido, escrito en ~/.local/share/precc/sessions/<session_id>.start en la primera actualización del statusline de cada sesión. Esto hace que el conteo sea monótono — no puede disminuir a mitad de sesión aunque falte cost.total_duration_ms en una actualización particular.

Instantánea de por vida actualizada automáticamente

El segmento lifetime: lee ~/.local/share/precc/.lifetime_summary.json, que se reescribe en cada medición de PostToolUse y en cada invocación de precc savings. El segmento this session: lee el mismo archivo de por vida pero resta una línea base por sesión persistida en la primera actualización de cada sesión. No se necesita actualización manual — los archivos se actualizan solos.

Suprimir la barra de estado

Si prefieres mantener tu barra de estado existente, define tu propio comando statusLine en ~/.claude/settings.json. El instalador de PRECC detectará el valor personalizado y lo dejará intacto en actualizaciones posteriores.

Para suprimir solo la línea 📊 PRECC por interacción (en additionalContext), define PRECC_QUIET=1 en tu entorno 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