changebook 0.9.1 → 0.10.0

package/README.md

@@ -57,6 +57,7 @@ your other servers.
 | `changebook scan [dir] [--json\|--card\|--badge]` | Coupling report for **any** repo from its git history alone: no account, no network, writes nothing — run it on something you just cloned. `--card` renders a shareable SVG, `--badge` publishes four numbers and prints the README snippet (needs an account; `--badge --off` turns it off). The badge exposes those four numbers and nothing else — not your code, modules or change summaries. |
 | `changebook silence [dir]` | How often the `PreToolUse` hook stays quiet, with both raw numbers. Local by design: it answers the day you install it, not two days later. |
 | `changebook friction [dir]` | Where the agent's work gets redone in this repo, read from the **local** Claude Code transcripts — no prose leaves the machine, only paths, modules, dates and a session hash. Says **MUERTO** if the repo has edits and it read nothing, and reports its own blind spot: edits made through the shell (`sed -i`, heredocs) leave no before/after, so ~25% of writes are invisible to it and it says so. |
+| `changebook spend [dir]` | Where the model money goes and why: cost by month and model, whether the prompt cache is actually paying for itself (it reports the median gap between calls against the cache window — that gap is what decides it), how often responses hit the output cap, and whether every analysis left a row in the billing ledger. Account-wide: `usage_ledger` has no project column. |
 | `changebook audit [dir]` | Static check of your agent setup — no network, no credentials, nothing written. Flags rules in `CLAUDE.md`/`AGENTS.md` that cite files which no longer exist (with a «did you mean…»), how much context you pay every session, and whether the impact hook is actually installed. Every check here was written after it found something real, not from a best-practices list. |
 | `changebook guard [dir]` | What the pre-commit hook runs: checks staged files against the atlas' open alerts. Warn-only and fail-open by default; `CHANGEBOOK_GUARD=block` makes findings abort the commit (bypass once with `git commit --no-verify`), `CHANGEBOOK_GUARD=off` silences it. |
 | `changebook sync [dir]` | Refresh the product map inside `CLAUDE.md`/`AGENTS.md`. |

package/dist/hook.js

@@ -22,6 +22,7 @@ function cliEntry() {
 }
 const POST_COMMIT_MARKER = "# changebook post-commit hook";
 const PRE_COMMIT_MARKER = "# changebook pre-commit guard";
+const POST_REWRITE_MARKER = "# changebook post-rewrite hook";
 // The hook log grows by one run per commit, so it needs a ceiling — but one
 // that keeps enough history to diagnose a streak of failures, which is the
 // whole reason it is worth keeping at all.
@@ -52,6 +53,40 @@ fi
 ( { date -u +'=== %Y-%m-%dT%H:%M:%SZ'; ${JSON.stringify(process.execPath)} ${JSON.stringify(cliEntry())} analyze --commit HEAD; } >> "$LOG" 2>&1 & ) || true
 `;
 }
+/**
+ * Exported for tests. `post-rewrite` is the hook git runs after `git rebase`
+ * and `git commit --amend` — the two ways commits are born WITHOUT firing
+ * `post-commit`, and therefore the source of the ~3.5% of commits the atlas
+ * never saw (the `unanalyzed` rows).
+ *
+ * git feeds one `<old-sha> <new-sha>` line per rewritten commit on stdin. We
+ * count them and hand that number to ONE background `import --commits N`:
+ *   - one process, not N — a 50-commit rebase must not spawn 50 node processes;
+ *   - `import` dedups server-side, so the already-analyzed commits in that
+ *     window are free and only the genuinely-new (rewritten) ones are billed,
+ *     through the cheaper Batch API;
+ *   - background + `|| true` + fail-open, exactly like post-commit: a rebase is
+ *     never blocked or slowed, and a logged-out/offline CLI can't break it.
+ */
+export function postRewriteScript() {
+    const trimmed = `${LOG_TRIM_KEEP_BYTES}`;
+    return `#!/bin/sh
+${POST_REWRITE_MARKER} — reconciles commits rewritten by rebase/amend, which
+# post-commit never sees. Runs in the background and never blocks. Remove with:
+#   changebook hook uninstall
+LOG="$(git rev-parse --git-path changebook-hook.log)"
+if [ -f "$LOG" ] && [ "$(wc -c < "$LOG")" -gt ${LOG_MAX_BYTES} ]; then
+  tail -c ${trimmed} "$LOG" > "$LOG.tmp" 2>/dev/null && mv -f "$LOG.tmp" "$LOG"
+fi
+# One "<old> <new>" line per rewritten commit; count them so import reconciles
+# exactly that many. Already-analyzed commits are deduped server-side (free).
+n=0
+while read old new rest; do
+  [ -n "$new" ] && n=$((n + 1))
+done
+[ "$n" -gt 0 ] && ( { date -u +'=== %Y-%m-%dT%H:%M:%SZ (post-rewrite)'; ${JSON.stringify(process.execPath)} ${JSON.stringify(cliEntry())} import --commits "$n"; } >> "$LOG" 2>&1 & ) || true
+`;
+}
 /** Exported for tests: the contract between this script and guard.ts. */
 export function preCommitScript() {
     // Foreground (a warning printed after the commit would be pointless) but
@@ -83,6 +118,12 @@ const HOOKS = [
         script: preCommitScript,
         installedNote: "Before each commit, you'll be warned if a staged file belongs to a module with an open alert (set CHANGEBOOK_GUARD=block to make it blocking, =off to silence it).",
     },
+    {
+        name: "post-rewrite",
+        marker: POST_REWRITE_MARKER,
+        script: postRewriteScript,
+        installedNote: "After a rebase or --amend, the rewritten commits are reconciled into the atlas in the background (deduped server-side, so only genuinely new commits are billed).",
+    },
 ];
 async function hookPath(dir, name) {
     // --git-path (not --git-dir + "/hooks") resolves core.hooksPath — set by

package/dist/impact.js

@@ -1415,7 +1415,7 @@ marca = { contado: false }) {
             // Servir la nota no vale nada si la nota que importa no entra.
             //
             // Total y determinista: el desempate por nombre mantiene el string estable
-            // entre sesiones, que es lo que evita pagar una escritura de caché a 1,25×
+            // entre sesiones, que es lo que evita pagar una escritura de caché (×2 desde el 24/08)
             // en vez de una lectura a 0,1×.
             .sort((a, b) => b.alerts.length - a.alerts.length ||
             b.priorRegressions - a.priorRegressions ||

package/dist/index.js

@@ -9,6 +9,7 @@
  * extension: login, analyze, sync, init, open.
  */
 import { auditarSetup, informeDeAuditoria } from "./audit.js";
+import { fugasDelLedger, informeDeGasto, textoDeGasto, } from "./spend.js";
 import { readFileSync } from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -71,6 +72,10 @@ Usage:
   changebook friction [dir] Where the agent's work gets redone in this repo,
                           read from the local Claude Code transcripts. Says
                           MUERTO if the repo has edits and it read nothing
+  changebook spend [dir]  Where the model money goes and why: cost by month and
+                          model, whether the prompt cache is actually paying for
+                          itself, how often responses hit the output cap, and
+                          whether every analysis left a row in the billing ledger
   changebook audit [dir]  Static check of your agent setup: rules in CLAUDE.md
                           that cite files which no longer exist, how much
                           context you pay per session, whether the hook is on.
@@ -368,6 +373,49 @@ async function main() {
             console.log(rankingDeFriccion(dir));
             return;
         }
+        case "spend": {
+            // Lee `usage_ledger` y `changelog` y no escribe nada. El calculo entero
+            // es puro y vive en `spend.ts`; aqui solo esta la red.
+            const db = new Supabase();
+            requireCredentials(db);
+            const filas = [];
+            for (let o = 0;; o += 1000) {
+                const p = await db.rest("usage_ledger?select=model,action,input_tokens,output_tokens," +
+                    "cache_creation_input_tokens,cache_read_input_tokens,diff_chars," +
+                    `raw_diff_chars,created_at,changelog_id&order=created_at.asc&limit=1000&offset=${o}`);
+                filas.push(...p);
+                if (p.length < 1000 || o > 20000)
+                    break;
+            }
+            console.log(textoDeGasto(informeDeGasto(filas)));
+            // La integridad del cobro: un analisis sin fila en el ledger es servicio
+            // regalado, y no se ve en ningun panel. Best-effort — si falla la
+            // consulta, el informe de arriba sigue siendo cierto.
+            // SIN filtro de proyecto: `usage_ledger` no tiene `project_id`, así que
+            // acotar un lado y el otro no compara nada. El informe es de CUENTA.
+            //
+            // Y PAGINADO. `limit=10000` NO sobrepasa el techo de PostgREST: devuelve
+            // 1.000 y se calla, y el informe decía «1000 de 1000 análisis, sin fugas»
+            // — un truncamiento leído como dato completo, que es la Invariante 17 de
+            // este repo mordiendo a la herramienta que la publica.
+            const analisis = [];
+            for (let o = 0;; o += 1000) {
+                const p = await db
+                    .rest(`changelog?select=id&order=created_at.asc&limit=1000&offset=${o}`)
+                    .catch(() => []);
+                analisis.push(...p);
+                if (p.length < 1000 || o > 50000)
+                    break;
+            }
+            if (analisis.length > 0) {
+                const fugas = fugasDelLedger(analisis, filas);
+                console.log("");
+                console.log(fugas === 0
+                    ? `COBRO: ${analisis.length} de ${analisis.length} análisis con fila en el ledger. Sin fugas.`
+                    : `⚠ COBRO: ${fugas} de ${analisis.length} análisis SIN fila en el ledger — servidos sin cobrar.`);
+            }
+            return;
+        }
         case "audit": {
             // Como `silence` y `scan`: sin credenciales, sin red, sin escribir. Todo
             // lo que dice sale de ficheros del repo, así que contesta el mismo día en

package/dist/spend.js

@@ -0,0 +1,153 @@
+/**
+ * `changebook spend` — a dónde va el dinero del modelo, y por qué.
+ *
+ * POR QUÉ EXISTE. El 24/08 todo esto se midió con scripts de usar y tirar, y de
+ * ahí salieron dos arreglos que valían la pena: la caché caducaba justo en el
+ * filo de su ventana (mediana entre llamadas 5,1 min contra 5 de ventana) y el
+ * tope de salida cortaba el 7,2% de los análisis, multiplicando por 17 la
+ * probabilidad de perder el mapa del commit. Ninguna de las dos se veía en
+ * ningún panel: había que ir a contar filas.
+ *
+ * La tabla de precios NO se reimplementa aquí — se importa de `usage.ts`, que
+ * es una de las tres copias que `usageParity.test.ts` mantiene atadas. Una
+ * cuarta sería la que se queda atrás.
+ */
+import { CACHE_1H_DESDE, costOfRow, fmtUsd, percentile, } from "./usage.js";
+/** La ventana de caché que usa el servidor hoy. Sólo para el diagnóstico. */
+export const VENTANA_DE_CACHE_MIN = 60;
+function entrada(f) {
+    return (f.cache_creation_input_tokens ?? 0) + (f.cache_read_input_tokens ?? 0);
+}
+/**
+ * El tope de salida, DEDUCIDO DE LOS DATOS y no escrito a mano.
+ *
+ * Un tope se delata como un pico: decenas de llamadas con exactamente el mismo
+ * número de tokens de salida. Deducirlo importa porque el histórico tiene
+ * VARIOS —1.800 hasta julio, 3.500 después, 7.000 desde el 24/08— y un número
+ * fijo etiquetaría mal las filas viejas, que es peor que no etiquetarlas.
+ */
+export function topeDeducido(filas) {
+    const cuenta = new Map();
+    for (const f of filas) {
+        const o = f.output_tokens ?? 0;
+        if (o > 0)
+            cuenta.set(o, (cuenta.get(o) ?? 0) + 1);
+    }
+    // Un pico de verdad: al menos 10 llamadas clavadas en el mismo valor, y ese
+    // valor por encima de la mediana (un tope corta por arriba, no por abajo).
+    const med = percentile(filas.map((f) => f.output_tokens ?? 0), 50) ?? 0;
+    const picos = [...cuenta].filter(([v, n]) => n >= 10 && v > med);
+    if (picos.length === 0)
+        return null;
+    return Math.max(...picos.map(([v]) => v));
+}
+export function informeDeGasto(filas) {
+    if (filas.length === 0)
+        return null;
+    const orden = [...filas].sort((a, b) => a.created_at.localeCompare(b.created_at));
+    const porMes = new Map();
+    const porModelo = new Map();
+    let total = 0;
+    let leen = 0;
+    let tocan = 0;
+    let R = 0;
+    let W = 0;
+    for (const f of orden) {
+        const c = costOfRow(f);
+        total += c;
+        const mes = f.created_at.slice(0, 7);
+        porMes.set(mes, (porMes.get(mes) ?? 0) + c);
+        const m = f.model ?? "(sin modelo)";
+        porModelo.set(m, (porModelo.get(m) ?? 0) + c);
+        if (entrada(f) > 0)
+            tocan += 1;
+        if ((f.cache_read_input_tokens ?? 0) > 0)
+            leen += 1;
+        R += f.cache_read_input_tokens ?? 0;
+        W += f.cache_creation_input_tokens ?? 0;
+    }
+    const huecos = [];
+    for (let i = 1; i < orden.length; i++) {
+        huecos.push((Date.parse(orden[i].created_at) - Date.parse(orden[i - 1].created_at)) / 60000);
+    }
+    const salidas = orden.map((f) => f.output_tokens ?? 0);
+    const tope = topeDeducido(orden);
+    return {
+        filas: orden.length,
+        desde: orden[0].created_at.slice(0, 10),
+        hasta: orden[orden.length - 1].created_at.slice(0, 10),
+        total,
+        porMes: [...porMes].sort(),
+        porModelo: [...porModelo].sort((a, b) => b[1] - a[1]),
+        cache: {
+            leen,
+            tocan,
+            ratio: W > 0 ? R / W : 0,
+            conVentanaActual: orden.filter((f) => f.created_at >= CACHE_1H_DESDE).length,
+            medianaMin: percentile(huecos, 50),
+            dentroDeVentana: huecos.filter((g) => g <= VENTANA_DE_CACHE_MIN).length,
+            huecos: huecos.length,
+        },
+        salida: {
+            mediana: percentile(salidas, 50),
+            p90: percentile(salidas, 90),
+            tope,
+            // «Cerca» y no «igual»: la respuesta puede parar una pizca antes.
+            enTope: tope === null ? 0 : salidas.filter((o) => o >= tope - 5).length,
+        },
+    };
+}
+const pct = (n, d) => (d > 0 ? Math.round((n / d) * 100) : 0);
+export function textoDeGasto(i) {
+    if (!i)
+        return "Sin llamadas al modelo registradas todavía.";
+    const l = [];
+    l.push(`${i.filas} llamadas al modelo, del ${i.desde} al ${i.hasta}.`, "");
+    l.push("GASTO POR MES");
+    for (const [m, v] of i.porMes)
+        l.push(`  ${m}   ${fmtUsd(v)}`);
+    l.push(`  ${"-".repeat(16)}`, `  TOTAL   ${fmtUsd(i.total)}`, "");
+    l.push("POR MODELO");
+    for (const [m, v] of i.porModelo)
+        l.push(`  ${fmtUsd(v).padStart(9)}  ${m}`);
+    l.push("", "CACHÉ");
+    l.push(`  leen de caché ${i.cache.leen} de ${i.cache.tocan} llamadas (${pct(i.cache.leen, i.cache.tocan)}%)`);
+    l.push(`  lecturas por escritura: ${i.cache.ratio.toFixed(2)}`);
+    if (i.cache.medianaMin !== null) {
+        l.push(`  mediana entre llamadas: ${i.cache.medianaMin.toFixed(1)} min · ventana ${VENTANA_DE_CACHE_MIN} min`);
+        l.push(`  huecos que caben en la ventana: ${i.cache.dentroDeVentana} de ${i.cache.huecos} (${pct(i.cache.dentroDeVentana, i.cache.huecos)}%)`);
+        // EL RATIO DE ARRIBA ES HISTÓRICO, y el histórico se escribió con otra
+        // ventana. Juzgar el ajuste de hoy con él es exactamente el error de
+        // comparar antes y después mezclándolos: por eso el aviso espera a tener
+        // datos suficientes escritos YA con la ventana actual.
+        const MINIMO = 50;
+        if (i.cache.conVentanaActual < MINIMO) {
+            l.push(`  · Sólo ${i.cache.conVentanaActual} llamadas con la ventana actual (hacen falta ${MINIMO}`, "    para juzgarla). El ratio de arriba describe el pasado, no el ajuste de hoy.");
+        }
+        else if (i.cache.ratio < 1.11) {
+            l.push("  ⚠ Por debajo de 1,11 lecturas por escritura la caché NO compensa:", "    una escritura de ventana larga cuesta el doble de la entrada.");
+        }
+    }
+    l.push("", "SALIDA (lo que la caché NO puede abaratar)");
+    l.push(`  mediana ${i.salida.mediana ?? "?"} tokens · p90 ${i.salida.p90 ?? "?"}`);
+    if (i.salida.tope !== null) {
+        l.push(`  tope deducido de los datos: ${i.salida.tope} · llamadas que lo tocan: ${i.salida.enTope} (${pct(i.salida.enTope, i.filas)}%)`);
+        if (i.salida.enTope > 0) {
+            l.push("  ⚠ Una respuesta cortada llega sin el mapa del commit mucho más a menudo.", "    Medido el 24/08: 17 veces más. Subir el tope no cuesta nada en las", "    llamadas que no lo alcanzan — se factura por token producido.");
+        }
+    }
+    return l.join("\n");
+}
+/**
+ * Análisis que no dejaron fila en el ledger: eso es servicio sin cobrar.
+ *
+ * ⚠ ES DE CUENTA, NO DE PROYECTO, y no por comodidad: `usage_ledger` no tiene
+ * `project_id` — sólo `user_id` y `changelog_id`. Filtrar los análisis por
+ * proyecto y el ledger no compararía 741 contra 1.782 y diría «sin fugas» por
+ * accidente. Quien llama tiene que pasarle TODOS los análisis de la cuenta.
+ */
+export function fugasDelLedger(analisis, filas) {
+    const conFila = new Set(filas.map((f) => f.changelog_id).filter(Boolean));
+    return analisis.filter((a) => !conFila.has(a.id)).length;
+}
+//# sourceMappingURL=spend.js.map

package/dist/toolUsage.js

@@ -14,7 +14,7 @@
 import { z } from "zod";
 import { recordRead } from "./agregados.js";
 import { RO, errorResult, servedCharsOf, toolResult, } from "./respuestas.js";
-import { fmtUsd, latencyByTool, summarizeUsage, } from "./usage.js";
+import { fmtUsd, latencyByTool, readsByKind, readsBreakdownLines, summarizeUsage, } from "./usage.js";
 /**
  * Tope de filas por consulta de PostgREST. Se pagina hasta agotarlo y se AVISA
  * si se alcanzó: un truncamiento leído como total convierte «has ahorrado $X»
@@ -75,7 +75,13 @@ export function registrarUsage(server, db) {
                 .filter((r) => r.source !== "guard")
                 .reduce((a, r) => a + (r.chars_served ?? 0), 0) +
                 rolledUp.reduce((a, r) => a + (r.chars_served ?? 0), 0);
-            const readsCount = reads.length + rolledUp.reduce((a, r) => a + (r.reads ?? 0), 0);
+            const rolledUpReads = rolledUp.reduce((a, r) => a + (r.reads ?? 0), 0);
+            const readsCount = reads.length + rolledUpReads;
+            // El desglose por tipo: qué parte de las consultas fue TIRÓN deliberado
+            // (adopción real) y qué parte fue EMPUJE. Lo purgado, que llega sin
+            // source/tool, va a `historical` para que el desglose siga sumando a
+            // readsCount en vez de adivinarle un tipo.
+            const byKind = readsByKind(reads, rolledUpReads);
             const u = summarizeUsage(ledger, skipsP.filas.length, readsCount, readsChars);
             const naive = u.realCost + u.savedTotal;
             const pct = naive > 0 ? Math.round((u.savedTotal / naive) * 100) : 0;
@@ -95,7 +101,10 @@ export function registrarUsage(server, db) {
                 `  - Model routing: ${fmtUsd(u.saved.routing)}`,
                 `  - Prompt cache: ${fmtUsd(u.saved.cache)}`,
                 `  - Diff compression: ${fmtUsd(u.saved.compression)}`,
-                `- Agent consultations: ${u.reads.count} (≈${Math.round(u.reads.chars / 4)} tokens served; estimated exploration avoided ${fmtUsd(u.reads.explorationEstimate)} — conservative estimate, kept OUT of the hard savings above)`,
+                `- Agent consultations: ${u.reads.count} total (≈${Math.round(u.reads.chars / 4)} tokens served; estimated exploration avoided ${fmtUsd(u.reads.explorationEstimate)} — conservative estimate, kept OUT of the hard savings above)`,
+                // Solo el TIRÓN mide adopción: un total alto hecho de empuje dice que
+                // el hook está puesto, no que el agente consulte.
+                ...readsBreakdownLines(byKind),
             ];
             const latency = latencyByTool(reads);
             if (latency.length > 0) {
@@ -114,7 +123,7 @@ export function registrarUsage(server, db) {
                 real_cost_usd: u.realCost,
                 saved_usd: u.saved,
                 saved_total_usd: u.savedTotal,
-                reads: u.reads,
+                reads: { ...u.reads, by_kind: byKind },
                 latency_by_tool: latency,
             });
             recordRead(db, "atlas_usage", "", servedCharsOf(salida), Date.now() - t0);

package/dist/usage.js

@@ -21,7 +21,6 @@ const MODEL_PRICES = [
 ];
 const FALLBACK_PRICE = { input: 3, output: 15 };
 const CACHE_READ_FACTOR = 0.1;
-const CACHE_WRITE_FACTOR = 1.25;
 const BATCH_FACTOR = 0.5;
 const CHARS_PER_TOKEN = 4;
 const READ_EXPLORATION_FACTOR = 3;
@@ -30,13 +29,41 @@ function modelPrice(model) {
     const hit = MODEL_PRICES.find((p) => p.match.test(id));
     return hit ? { input: hit.input, output: hit.output } : FALLBACK_PRICE;
 }
+/**
+ * Cuándo pasó la caché de 5 minutos (escritura ×1,25) a una hora (×2).
+ *
+ * SIN ESTO EL HISTÓRICO SE SOBREVALORA. Las filas anteriores a #438 se
+ * escribieron con la ventana corta, y aplicarles ×2 infla el pasado — medido:
+ * $38,14 se convertían en $43,64, y con eso el «antes y después» del cambio
+ * dejaba de poder compararse.
+ *
+ * El ledger guarda la SUMA de tokens de caché, no el desglose 5m/1h, así que la
+ * ventana de una fila vieja no se puede deducir del dato: sólo de la fecha.
+ *
+ * Sin `created_at` se asume la ventana ACTUAL, que es lo correcto para una fila
+ * recién escrita — el caso de quien no pasa la fecha.
+ */
+export const CACHE_1H_DESDE = "2026-08-24T16:20:00Z";
+function factorDeEscritura(createdAt) {
+    return createdAt && createdAt < CACHE_1H_DESDE ? 1.25 : 2;
+}
 function costAtPrice(row, price) {
     return (((row.input_tokens ?? 0) * price.input +
         (row.cache_read_input_tokens ?? 0) * price.input * CACHE_READ_FACTOR +
-        (row.cache_creation_input_tokens ?? 0) * price.input * CACHE_WRITE_FACTOR +
+        (row.cache_creation_input_tokens ?? 0) * price.input * factorDeEscritura(row.created_at) +
         (row.output_tokens ?? 0) * price.output) /
         1_000_000);
 }
+/**
+ * El coste de UNA fila, con la tabla de precios de este mismo fichero.
+ *
+ * Se exporta para que `spend.ts` no tenga que reimplementarla: el factor de
+ * escritura de caché ya vive en TRES sitios atados por `usageParity.test.ts`, y
+ * una cuarta copia es la que se quedaría atrás el día que cambie la ventana.
+ */
+export function costOfRow(row) {
+    return costAtPrice(row, modelPrice(row.model));
+}
 export function summarizeUsage(rows, skipsCount, readsCount, readsChars) {
     let realCost = 0;
     let compression = 0;
@@ -117,4 +144,48 @@ export function latencyByTool(rows) {
     }))
         .sort((a, b) => b.n - a.n);
 }
+export function readKind(row) {
+    // El guardián pre-commit primero: su `source` es inequívoco y su contrafáctico
+    // es otro (evita un error, no una lectura), como ya lo trata `explorationEstimate`.
+    if (row.source === "guard")
+        return "guard";
+    // El mapa al abrir sesión (`changebook context`) se escribe con `source: "sync"`.
+    if (row.source === "sync")
+        return "push_session";
+    // El radio de impacto antes de editar. Mismo `source` que el tirón: SOLO el
+    // tool lo delata.
+    if (row.tool === "impact_pretooluse")
+        return "push_edit";
+    // Lo demás es una tool con nombre del atlas que el agente llamó a propósito.
+    return "pull";
+}
+export function readsByKind(rows, historical) {
+    const b = {
+        pull: 0,
+        push_edit: 0,
+        push_session: 0,
+        guard: 0,
+        historical,
+    };
+    for (const r of rows)
+        b[readKind(r)] += 1;
+    return b;
+}
+/**
+ * Las líneas del informe que separan tirón de empuje. Vive aquí, compartida por
+ * los dos runtimes, por dos motivos: la paridad (un solo texto, no dos que
+ * deriven) y el techo del módulo-dios `toolUsage.ts`, que no puede engordar con
+ * la presentación. La línea de `historical` solo sale si hay algo purgado, para
+ * no plantar un "0" que se lee como dato donde no hay ninguno.
+ */
+export function readsBreakdownLines(b) {
+    const lines = [
+        `  - deliberate tool calls (adoption): ${b.pull}`,
+        `  - pushed before edits: ${b.push_edit} · pushed at session start: ${b.push_session} · pre-commit guardian: ${b.guard}`,
+    ];
+    if (b.historical > 0) {
+        lines.push(`  - historical (rolled up, type unknown): ${b.historical}`);
+    }
+    return lines;
+}
 //# sourceMappingURL=usage.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "changebook",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "mcpName": "io.github.raulbr90/changebook",
   "description": "Your agent already broke this three times. ChangeBook tells it before the fourth. MCP server + CLI: the history of what broke in your repo, served to Claude Code, Cursor or Codex before they edit.",
   "type": "module",

package/server.json

@@ -2,7 +2,7 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.raulbr90/changebook",
   "description": "Your agent already broke this three times. ChangeBook tells it before the fourth.",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "websiteUrl": "https://changebook.dev",
   "remotes": [
     {
@@ -15,7 +15,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "changebook",
-      "version": "0.9.1",
+      "version": "0.10.0",
       "transport": {
         "type": "stdio"
       }