changebook 0.5.0 → 0.7.0

package/dist/hookMudo.js

@@ -0,0 +1,172 @@
+import * as fs from 'node:fs';
+import { settingsHookInstalled } from './context.js';
+import { gitPath } from './git.js';
+import { IMPACT_HOOK } from './impact.js';
+/**
+ * C6 · Un hook que se rompe deja de romperse en silencio.
+ *
+ * POR QUÉ, y es el fallo de toda esta categoría de producto: `hook-impact` es de
+ * RETENCIÓN PASIVA. Una vez instalado, el usuario no tiene que acordarse de
+ * nada, y por eso **un hook desinstalado se ve exactamente igual que un repo
+ * tranquilo**: los dos son silencio. Es la invariante 17 del repo, y este
+ * fichero es su caso más caro — el que le pasa a los usuarios y no al dueño, que
+ * desinstalan sin saber por qué dejó de servirles.
+ *
+ * SE MIDEN DOS COSAS INDEPENDIENTES, y esa es toda la gracia:
+ *
+ *   `declarado`    ¿sigue el hook en `.claude/settings.json`?
+ *   `ultimaSenal`  ¿cuándo dejó rastro por última vez?
+ *
+ * Cruzarlas separa cuatro situaciones que un solo dato confunde:
+ *
+ *   declarado + fresco   → sano. SILENCIO ABSOLUTO.
+ *   declarado + rancio   → está puesto y no corre. Lo más difícil de ver solo.
+ *   sin declarar + hubo  → alguien lo quitó. El caso de la ficha.
+ *   sin declarar + nunca → no se instaló jamás. NO es una rotura, y avisar aquí
+ *                          convertiría este canal en publicidad. Se calla.
+ *
+ * La última línea es la que decide si esto sirve: un aviso que también sale
+ * cuando no pasa nada es ruido, y el ruido enseña a ignorar el canal — que es
+ * justo lo que hace que el hook se desinstale.
+ */
+/** El rastro se considera vivo si es de los últimos 14 días (ficha C6). */
+export const DIAS_SIN_SENAL = 14;
+/** Cada cuánto se repite un aviso que sigue vigente. */
+const DIAS_ENTRE_AVISOS = 30;
+/**
+ * Los cuatro estados. Pura a propósito: la tabla de verdad es lo que hay que
+ * poder probar, y leer ficheros dentro la haría dependiente del disco.
+ */
+export function estadoDelHook(h) {
+    const dias = h.ultimaSenal === null
+        ? Infinity
+        : (h.ahora - h.ultimaSenal) / 86_400_000;
+    if (h.declarado)
+        return dias <= DIAS_SIN_SENAL ? 'sano' : 'declarado-mudo';
+    // Sin declarar: lo que distingue «lo quitaron» de «nunca lo hubo» es que
+    // exista rastro, no cuánto de viejo sea. Un repo con el hook retirado hace
+    // seis meses sigue siendo un repo al que le quitaron el hook.
+    return h.ultimaSenal === null ? 'nunca' : 'retirado';
+}
+/**
+ * El texto. Cadena vacía cuando no hay nada que decir — un hook sano tiene que
+ * callar del todo, igual que `feedWarning`.
+ */
+export function avisoDeHookMudo(estado, opts = {}) {
+    const { audience = 'human', dias } = opts;
+    if (estado === 'sano' || estado === 'nunca')
+        return '';
+    const cuanto = typeof dias === 'number' && Number.isFinite(dias)
+        ? ` (último rastro hace ${Math.floor(dias)} días)`
+        : '';
+    if (estado === 'retirado') {
+        const que = `El hook de ChangeBook que avisa ANTES de editar ya no está en .claude/settings.json${cuanto}.`;
+        return audience === 'agent'
+            ? [
+                '⚠ ChangeBook: el aviso previo a editar está retirado en este repo.',
+                `${que} Vas a editar sin saber quién depende de cada fichero: dilo antes de dar por bueno un cambio grande.`,
+                'Si el dueño lo quiere de vuelta: `changebook hook-impact install`.',
+            ].join('\n')
+            : [
+                '\n⚠ ChangeBook: el aviso previo a editar está retirado.',
+                `  ${que}`,
+                '  Si lo quitaste a propósito, ignora esto — no se repetirá.',
+                '  Para volver a ponerlo: changebook hook-impact install\n',
+            ].join('\n');
+    }
+    // declarado-mudo: lo más difícil de ver solo, porque el fichero DICE que está.
+    const que = `Está declarado en .claude/settings.json pero no ha dejado rastro${cuanto}.`;
+    return audience === 'agent'
+        ? [
+            '⚠ ChangeBook: el aviso previo a editar está puesto pero no corre.',
+            `${que} O sea que lleva ese tiempo sin decirte quién depende de lo que tocas — no lo tomes como que no había nada que decir.`,
+            'Díselo al dueño; se comprueba con `changebook hook-impact status`.',
+        ].join('\n')
+        : [
+            '\n⚠ ChangeBook: el aviso previo a editar está puesto pero no corre.',
+            `  ${que}`,
+            '  No es lo mismo que "no había nada que avisar": lleva ese tiempo mudo.',
+            '  Compruébalo con: changebook hook-impact status\n',
+        ].join('\n');
+}
+/**
+ * Leer y escribir la marca. Locales y no importados de `impact.ts`: sus
+ * `leerJson`/`escribirJson` son privados de aquel módulo, y exportarlos solo
+ * para esto ensancharía su superficie pública por comodidad.
+ */
+function leerMarca(file) {
+    if (!file)
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function escribirMarca(file, marca) {
+    if (!file)
+        return;
+    try {
+        fs.writeFileSync(file, JSON.stringify(marca));
+    }
+    catch {
+        // Sin sitio donde anotar, el aviso se repetirá. Es el lado seguro.
+    }
+}
+async function marcaPath(dir) {
+    return gitPath(dir, 'changebook-hook-mudo.json').catch(() => null);
+}
+/** El rastro del hook: la marca de tiempo del acumulado de silencios. */
+async function ultimaSenal(dir) {
+    const file = await gitPath(dir, 'changebook-impact-silencio.json').catch(() => null);
+    if (!file)
+        return null;
+    try {
+        return fs.statSync(file).mtimeMs;
+    }
+    catch {
+        return null; // No existe: nunca dejó rastro.
+    }
+}
+/**
+ * El aviso para un directorio, y la marca para no repetirlo.
+ *
+ * SE AVISA UNA VEZ POR EPISODIO, no una vez y nunca más: si el estado cambia
+ * —se retiró y luego se quedó mudo, o volvió a romperse tras arreglarse— eso es
+ * un suceso nuevo y merece decirse. Y si el mismo estado sigue vigente 30 días
+ * después, se repite: callar para siempre convierte «no molestar» en «no
+ * enterarse», que es el fallo que este fichero existe para arreglar.
+ *
+ * Best-effort de principio a fin: esto corre dentro del pre-commit y del arranque
+ * de sesión, y ninguno de los dos puede caerse porque no se pueda leer un JSON.
+ */
+export async function avisoDeHookMudoPara(dir, opts = {}) {
+    try {
+        const ahora = Date.now();
+        const senal = await ultimaSenal(dir);
+        const estado = estadoDelHook({
+            declarado: settingsHookInstalled(dir, IMPACT_HOOK),
+            ultimaSenal: senal,
+            ahora,
+        });
+        if (estado === 'sano' || estado === 'nunca')
+            return '';
+        const file = await marcaPath(dir);
+        const previa = leerMarca(file);
+        if (previa?.estado === estado &&
+            ahora - previa.en < DIAS_ENTRE_AVISOS * 86_400_000) {
+            return '';
+        }
+        escribirMarca(file, { estado, en: ahora });
+        return avisoDeHookMudo(estado, {
+            ...opts,
+            dias: senal === null ? null : (ahora - senal) / 86_400_000,
+        });
+    }
+    catch {
+        // Un aviso que no se puede calcular no puede romper el commit.
+        return '';
+    }
+}
+//# sourceMappingURL=hookMudo.js.map

package/dist/impact.js

@@ -43,6 +43,7 @@ import * as path from "node:path";
 import { presupuestoDeTiempo } from "./context.js";
 import { execFileAsync, gitPath, projectNameFor } from "./git.js";
 import { avisoRefutado, contarEnRepo, dondeApareceElSimbolo, dondeComprobarlo, entregaDe, ficherosEnRepo, hashDelTexto, headShaDe, slugifyProject, unoPorTexto, } from "./guard.js";
+import { aliasesFor, canonicalizeModuleRows, } from "./aliasDeModulo.js";
 import { coChangePairs } from "./sync.js";
 import { computeRecidivism, dependentsOf } from "./tools.js";
 /**
@@ -544,6 +545,36 @@ const QUEUE_KEEP_BYTES = 32_768;
 async function queuePath(dir) {
     return gitPath(dir, "changebook-impact-queue.jsonl").catch(() => null);
 }
+/**
+ * El acumulado de la tasa de silencio. Fichero aparte de la cola y con otra
+ * vida: la cola se vacía en cada drenado, esto NO se trunca ni se sube nunca.
+ *
+ * Local a propósito, y esa es la decisión de diseño, no una limitación. Una
+ * medición vale por el tiempo que lleva acumulando: un contador local empieza a
+ * contar esta noche, y un panel con migración empieza a contar dentro de dos
+ * días. Cuando haya semanas de número propio se sabrá qué forma debe tener el
+ * dato en el servidor, porque se habrá mirado — diseñar el esquema antes de ver
+ * un solo número es el orden equivocado.
+ */
+async function tallyPath(dir) {
+    return gitPath(dir, "changebook-impact-silencio.json").catch(() => null);
+}
+/** Suma y guarda. Best-effort como todo lo de este fichero. */
+function acumularSilencios(file, nuevo) {
+    if (!file)
+        return;
+    try {
+        const previo = leerJson(file);
+        fs.writeFileSync(file, `${JSON.stringify(tallyActualizado(previo, nuevo), null, 2)}\n`);
+    }
+    catch {
+        // Un contador que no se puede escribir no puede tumbar el drenado.
+    }
+}
+/** Lo acumulado hasta ahora, para el comando que lo enseña. */
+export async function silenciosAcumulados(dir) {
+    return leerJson(await tallyPath(dir)) ?? {};
+}
 /**
  * Anota una entrega. JSONL y no JSON: un append no tiene que leer lo que ya hay,
  * y dos procesos solapados (dos ediciones seguidas) no pueden pisarse el fichero
@@ -553,6 +584,10 @@ async function queuePath(dir) {
  * edición que la provocó.
  */
 export function encolarEntrega(file, entrega) {
+    anexarALaCola(file, entrega);
+}
+/** El append en sí, compartido por la entrega y por el silencio. */
+function anexarALaCola(file, linea) {
     if (!file)
         return;
     try {
@@ -570,13 +605,23 @@ export function encolarEntrega(file, entrega) {
         catch {
             // Aún no existe: nada que recortar.
         }
-        fs.appendFileSync(file, `${JSON.stringify(entrega)}\n`);
+        fs.appendFileSync(file, `${JSON.stringify(linea)}\n`);
     }
     catch {
         // Sin sitio donde anotar, el hook sigue avisando igual. El registro es una
         // segunda lectura del mismo hecho, nunca el hecho.
     }
 }
+/** Los dos motivos que responden «¿es ruidoso el hook?». El resto describe por
+ *  qué no pudo contestar, que es otra pregunta. */
+export const MOTIVOS_DE_PUNTERIA = [
+    "fuera-de-modulo",
+    "sin-lineas",
+];
+/** Anota una edición en la que el hook no dijo nada. Un append y nada más. */
+export function anotarSilencio(file, muda) {
+    anexarALaCola(file, { muda });
+}
 /**
  * Las entregas legibles de la cola. Las líneas rotas se tiran en silencio: la
  * primera puede venir cortada por el recorte, y una entrega ilegible no es un
@@ -601,6 +646,130 @@ export function entregasDeLaCola(contenido) {
     }
     return fuera;
 }
+/**
+ * Cuenta las líneas mudas de la cola, por motivo. Pura, y separada de
+ * `entregasDeLaCola` a propósito: aquella devuelve lo que se SUBE, ésta lo que
+ * solo se cuenta. Un motivo desconocido se ignora en vez de crear una categoría
+ * nueva por una línea corrupta.
+ */
+export function silenciosDeLaCola(contenido) {
+    const cuenta = {};
+    const conocidos = new Set([
+        "fuera-de-modulo",
+        "sin-lineas",
+        "ya-avisado",
+        "sin-atlas",
+        "fuera-del-repo",
+        "timeout",
+        "error",
+    ]);
+    for (const linea of contenido.split("\n")) {
+        if (!linea.trim())
+            continue;
+        try {
+            const e = JSON.parse(linea);
+            if (typeof e?.muda === "string" && conocidos.has(e.muda)) {
+                const k = e.muda;
+                cuenta[k] = (cuenta[k] ?? 0) + 1;
+            }
+        }
+        catch {
+            // Línea partida por el recorte, o basura. Se ignora, igual que arriba.
+        }
+    }
+    return cuenta;
+}
+/**
+ * Los avisos que el grep tumbó, sacados de la cola. Pura, como las otras dos.
+ *
+ * Tercer tipo de línea del mismo fichero: `advice_hash` es una entrega, `muda`
+ * un silencio y `refutados` un veredicto del grep. Se filtra por forma de UUID
+ * porque el PATCH va contra `id=in.(...)`: una línea corrupta que colara texto
+ * arbitrario ahí es la diferencia entre un 400 y algo peor.
+ */
+export function refutacionesDeLaCola(contenido) {
+    const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    const fuera = new Set();
+    for (const linea of contenido.split("\n")) {
+        if (!linea.trim())
+            continue;
+        try {
+            const e = JSON.parse(linea);
+            if (!Array.isArray(e?.refutados))
+                continue;
+            for (const id of e.refutados) {
+                if (typeof id === "string" && UUID.test(id))
+                    fuera.add(id);
+            }
+        }
+        catch {
+            // Línea partida por el recorte, o basura. Se ignora, igual que arriba.
+        }
+    }
+    return [...fuera];
+}
+/**
+ * Suma un recuento nuevo al acumulado. Pura para poder probar la aritmética sin
+ * disco: es un acumulador que NO se trunca nunca, así que un error aquí no se
+ * arregla con la siguiente ronda como sí pasa con la cola.
+ */
+export function tallyActualizado(previo, nuevo) {
+    const fuera = { ...(previo ?? {}) };
+    for (const [k, v] of Object.entries(nuevo)) {
+        if (typeof v !== "number" || !Number.isFinite(v) || v < 0)
+            continue;
+        fuera[k] = (fuera[k] ?? 0) + v;
+    }
+    return fuera;
+}
+/**
+ * La tasa, con los dos números crudos a la vista. El porcentaje solo miente por
+ * omisión: 90 % sobre 10 ediciones y 90 % sobre 900 son cosas distintas.
+ *
+ * DENOMINADOR: solo las ediciones en las que el hook PUDO contestar, o sea las
+ * que tenían atlas y un fichero dentro del repo. Meter `sin-atlas` o
+ * `ya-avisado` aquí subiría la tasa sin que la puntería hubiera mejorado, que
+ * es la forma más fácil de fabricar un número bonito.
+ */
+export function tasaDeSilencio(cuenta) {
+    const calladas = MOTIVOS_DE_PUNTERIA.reduce((a, m) => a + (cuenta[m] ?? 0), 0);
+    const hablo = cuenta.hablo ?? 0;
+    return { calladas, total: calladas + hablo, hablo };
+}
+/**
+ * El informe que imprime `changebook silence`.
+ *
+ * LOS DOS NÚMEROS CRUDOS SIEMPRE, y el porcentaje después. Un 90 % sobre 10
+ * ediciones y un 90 % sobre 900 son afirmaciones distintas, y la que se toma
+ * por buena decide si se toca el generador de avisos o no. Con el denominador a
+ * la vista, quien lo lee sabe cuánto pesa.
+ */
+export function informeDeSilencio(cuenta) {
+    const { calladas, total, hablo } = tasaDeSilencio(cuenta);
+    const fuera = [
+        "ya-avisado",
+        "sin-atlas",
+        "fuera-del-repo",
+        "timeout",
+        "error",
+    ];
+    const l = ["Silencio del hook PreToolUse, este repo:", ""];
+    if (total === 0) {
+        l.push("  Todavía no hay ninguna edición con contexto que contar.", "  El contador lo llena `impact --warm` al drenar la cola; edita algo y", "  vuelve dentro de unos minutos.");
+    }
+    else {
+        const pct = Math.round((calladas / total) * 1000) / 10;
+        l.push(`  ediciones con contexto   ${String(total).padStart(6)}`, `  de ellas, calló          ${String(calladas).padStart(6)}   ${pct}%`, `  de ellas, avisó          ${String(hablo).padStart(6)}`, "", "  por qué calló:", ...MOTIVOS_DE_PUNTERIA.map((m) => `    ${m.padEnd(20)} ${String(cuenta[m] ?? 0).padStart(6)}`));
+    }
+    const otras = fuera.filter((m) => (cuenta[m] ?? 0) > 0);
+    if (otras.length > 0) {
+        l.push("", "  fuera del cómputo (no miden puntería, describen por qué no pudo):", ...otras.map((m) => `    ${m.padEnd(20)} ${String(cuenta[m] ?? 0).padStart(6)}`));
+    }
+    if (total > 0) {
+        l.push("", "  Sano entre 85% y 95%. Por debajo del 80%, el hook es ruido.");
+    }
+    return l.join("\n");
+}
 /**
  * Las que TODAVÍA no están registradas, por (advice_hash, head_sha).
  *
@@ -648,6 +817,40 @@ async function drenarCola(db, dir) {
         return; // No hay cola: el caso normal.
     }
     const cola = entregasDeLaCola(contenido);
+    // EL RECUENTO, ANTES DE TOCAR LA RED Y ANTES DE BORRAR NADA. Las mudas se
+    // cuentan aquí y se tiran: NO suben a `atlas_reads`, porque una edición
+    // silenciosa no es una consulta al atlas y el rollup mensual barre por
+    // `advice_hash is null` — subirlas inflaría `reads`, que es literalmente el
+    // número que dice «tu agente consultó el atlas N veces».
+    //
+    // Va en el drenado y no en el camino caliente a propósito: esto ya corre
+    // desacoplado (`impact --warm`) y ya paga red, así que la edición solo gana
+    // un append. Si el proceso muere entre acumular y borrar la cola, la ronda
+    // siguiente vuelve a contar esas líneas: se prefiere sobrecontar un número
+    // local a perder ediciones del denominador, y se dice aquí en vez de fingir
+    // que es exacto.
+    acumularSilencios(await tallyPath(dir), { ...silenciosDeLaCola(contenido), hablo: cola.length });
+    // LOS VEREDICTOS DEL GREP, antes del corto que borra la cola cuando no hay
+    // entregas: una ronda puede refutar sin servir texto, y ese veredicto es
+    // exactamente el que llevaba meses perdiéndose.
+    //
+    // `resolved_at=is.null` en el filtro hace el PATCH idempotente sin preguntar
+    // primero: si la alerta ya se cerró —por una persona, por el agente o por una
+    // ronda anterior— este UPDATE no toca ninguna fila, así que el grep NUNCA
+    // pisa un juicio de otro. Reenviar sale gratis, igual que en las entregas.
+    const refutados = refutacionesDeLaCola(contenido);
+    if (refutados.length > 0) {
+        await db
+            .patchRows("regression_alerts", `id=in.(${refutados.join(",")})&resolved_at=is.null`, {
+            resolved_at: new Date().toISOString(),
+            resolution: "dismissed",
+            resolution_by: "grep",
+        })
+            .catch(() => {
+            // Best-effort, como todo lo del hook: el veredicto se pierde y la
+            // siguiente ronda lo vuelve a calcular, porque la alerta sigue abierta.
+        });
+    }
     if (cola.length === 0) {
         try {
             fs.rmSync(file, { force: true });
@@ -741,7 +944,10 @@ async function fetchAtlas(db, dir, env) {
     //
     // Y las alertas se traen SIN filtrar por resolved_at, porque las abiertas y la
     // reincidencia (all-time) salen del mismo conjunto.
-    const [rows, deps, alerts] = await Promise.all([
+    // Los alias entran en el MISMO Promise.all: el canal del guardian corre en
+    // CADA edicion y no puede pagar una ronda de red mas. Se canonicaliza abajo,
+    // antes de que coChangePairs/computeRecidivism/dependentsOf agrupen por nombre.
+    const [rows, deps, alerts, { aliases }] = await Promise.all([
         db
             .rest(
         // `changelog_id` para el co-cambio (ver ImpactCache["rows"]). Va en la
@@ -760,16 +966,20 @@ async function fetchAtlas(db, dir, env) {
         // hace falta para poder atribuir después "se te avisó de esto" a la fila
         // que lo dijo. Vienen en la misma consulta porque son gratis aquí y una
         // caché escrita sin ellos sobreviviría 5 minutos a quien los espere.
-        `regression_alerts?select=id,module,plain,created_at,files,resolved_at,evidence_symbol,evidence_expect,evidence_scope,evidence_line&project_id=eq.${projectId}&order=created_at.desc&limit=${ALERT_WINDOW_ROWS}`)
+        `regression_alerts?select=id,module,plain,resolution,created_at,files,resolved_at,evidence_symbol,evidence_expect,evidence_scope,evidence_line&project_id=eq.${projectId}&order=created_at.desc&limit=${ALERT_WINDOW_ROWS}`)
             .catch(() => []),
+        aliasesFor(db, projectId),
     ]);
+    // La cache se guarda YA CANONICALIZADA: todo lo que la lee (co-cambio,
+    // reincidencia, dependientes, el aviso del guardian) agrupa por nombre, y
+    // resolver en cada lector seria la cuarta copia de la misma regla.
     return {
         v: IMPACT_CACHE_V,
         fetched_at: Date.now(),
         project_id: projectId,
-        rows,
-        deps,
-        alerts,
+        rows: canonicalizeModuleRows(rows, aliases),
+        deps: canonicalizeModuleRows(deps, aliases),
+        alerts: canonicalizeModuleRows(alerts, aliases),
     };
 }
 /**
@@ -883,37 +1093,62 @@ async function readStdin(limit = 256 * 1024) {
     }
     return Buffer.concat(chunks).toString("utf8");
 }
-async function buildImpact(db, payload) {
+async function buildImpact(db, payload, 
+/** Una edición, un apunte. Lo comparte con printImpact, que anota `timeout` y
+ *  `error` desde fuera; sin él, una carrera perdida se contaría dos veces. */
+marca = { contado: false }) {
     const rutas = pathsFromPayload(payload);
+    // Sin ruta no hay edición de fichero que contar: no entra ni en el numerador
+    // ni en el denominador. Un payload sin `file_path` no es un silencio del
+    // hook, es una llamada que no iba con él.
     if (rutas.length === 0)
         return null;
     const dir = payload.cwd?.trim() || process.cwd();
     // El toplevel de git, no el cwd: el agente puede estar en un subdirectorio y
     // el atlas guarda rutas relativas a la raíz del repo.
-    const toplevel = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
-        cwd: dir,
-        encoding: "utf8",
-    })
-        .then(({ stdout }) => stdout.trim())
-        .catch(() => dir);
+    //
+    // La ruta de la cola se resuelve EN PARALELO, no después: es otro
+    // `git rev-parse` y en serie costaría su latencia entera a cada edición
+    // silenciosa, que son la mayoría. Concurrente no cuesta reloj.
+    const [toplevel, colaFile] = await Promise.all([
+        execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+            cwd: dir,
+            encoding: "utf8",
+        })
+            .then(({ stdout }) => stdout.trim())
+            .catch(() => dir),
+        queuePath(dir),
+    ]);
+    /** Anota por qué se calló y devuelve el `null` que ya devolvía. */
+    const callar = (muda) => {
+        if (marca.contado)
+            return null;
+        marca.contado = true;
+        anotarSilencio(colaFile, muda);
+        return null;
+    };
     const relativas = [
         ...new Set(rutas
             .map((r) => repoRelative(toplevel, r))
             .filter((r) => Boolean(r))),
     ];
     if (relativas.length === 0)
-        return null;
+        return callar("fuera-del-repo");
     const ahora = Date.now();
     const sessionId = payload.session_id?.trim() || "sin-sesion";
     const seenFile = await gitPath(dir, "changebook-impact-seen.json").catch(() => null);
     const yaAvisadas = rutasYaAvisadas(leerJson(seenFile), sessionId, ahora);
     const pendientes = relativas.filter((r) => !yaAvisadas.has(r));
     if (pendientes.length === 0)
-        return null;
+        return callar("ya-avisado");
     const signals = await atlasSignals(db, dir);
     if (!signals?.project_id)
-        return null;
-    const recidivism = computeRecidivism(signals.alerts);
+        return callar("sin-atlas");
+    // `resolution` puede faltar si estas alertas vienen de la caché en disco de
+    // una versión anterior, que no la guardaba. Ausente → `null` → NO cuenta como
+    // confirmada. Es el lado seguro: una caché vieja hace que el hook diga «este
+    // módulo no tiene antecedentes» de menos, nunca de más.
+    const recidivism = computeRecidivism(signals.alerts.map((a) => ({ ...a, resolution: a.resolution ?? null })));
     const abiertas = signals.alerts.filter((a) => !a.resolved_at);
     // Refutación al servir, igual que en atlas_file_context: el mismo grep que
     // corre el guardián en el pre-commit. De 7 alertas abiertas, 4 se caían con
@@ -931,13 +1166,34 @@ async function buildImpact(db, payload) {
     // sobre el mismo simbolo y solo uno de los dos aplica a cada aviso: 'present'
     // se refuta, 'absent' se localiza (ver avisoRefutado). Nunca se gastan dos.
     let grepsRestantes = MAX_REFUTACIONES;
+    /**
+     * LOS VEREDICTOS DEL GREP, QUE HASTA HOY SE TIRABAN.
+     *
+     * `refutada` decidía si el aviso se enseña y ahí se acababa: el veredicto no
+     * salía de este proceso. Medido el 02/08 en producción: de 119 avisos, 48
+     * traen símbolo, 30 son del tipo comprobable y 28 caen dentro de lo que este
+     * grep puede juzgar — uno de cada cuatro, a la basura. Y mientras tanto el
+     * producto publicaba «100% de acierto» porque el lado `refutado` estaba vacío:
+     * marcar acierto le cuesta al agente una llamada, y refutar exigía a una
+     * persona.
+     *
+     * Este juez es el que hacía falta y ya estaba aquí: NO es un modelo. Cuenta
+     * apariciones del símbolo en el árbol de trabajo. No es el autor del aviso
+     * —ése es un modelo del servidor que solo vio un diff—, no opina y no tiene
+     * interés en el resultado. Por eso se guarda firmado como `grep` y nunca se
+     * suma con los otros dos jueces.
+     */
+    const refutados = [];
     const refutada = (a) => {
         if (a.evidence_expect !== "present")
             return false;
         if (grepsRestantes <= 0)
             return false;
         grepsRestantes -= 1;
-        return avisoRefutado(a, (s) => contarEnRepo(toplevel, s));
+        const cae = avisoRefutado(a, (s) => contarEnRepo(toplevel, s));
+        if (cae && a.id)
+            refutados.push(a.id);
+        return cae;
     };
     /** Donde sigue apareciendo el simbolo de un aviso 'absent'. Contesta el condicional. */
     const localizar = (a) => {
@@ -966,10 +1222,15 @@ async function buildImpact(db, payload) {
     const avisadas = [];
     /** Las alertas que de verdad salieron en el texto. Ver el encolado del final. */
     const idsServidos = [];
+    /** Cuántos de los ficheros pendientes pertenecían a algún módulo. Es lo que
+     *  separa «no era de nadie» de «era de alguien y aun así no había nada que
+     *  decir», que son los dos silencios que la tasa NO puede mezclar. */
+    let conModulo = 0;
     for (const file of pendientes) {
         const modulos = modulosDelArchivo(file, signals.rows);
         if (modulos.length === 0)
             continue;
+        conModulo += 1;
         const dependientes = dependentsOf(modulos.map((m) => m.module), depsRows);
         const impactos = modulos
             .map((m) => ({
@@ -1024,19 +1285,31 @@ async function buildImpact(db, payload) {
             idsServidos.push(...m.alerts.flatMap((a) => a.alertIds));
         }
     }
+    // Los veredictos del grep se encolan ANTES de los dos `callar` de abajo: que
+    // no haya nada que decir no borra lo que el grep acaba de averiguar. Un append
+    // y nada de red, igual que la entrega — la subida es del `--warm`.
+    if (refutados.length > 0) {
+        anexarALaCola(colaFile, { refutados });
+    }
     // Solo se marca como avisado lo que de verdad se dijo: si el archivo no tenía
     // nada hoy pero mañana sale una alerta suya, el aviso tiene que poder salir.
     if (avisadas.length > 0) {
         escribirJson(seenFile, estadoSiguiente(leerJson(seenFile), sessionId, avisadas, ahora));
     }
-    if (lineas.length === 0)
-        return null;
+    // Los dos silencios, separados por `conModulo`. Sin esa distinción la tasa
+    // sube sola cada vez que alguien edita un README y no dice nada de la
+    // puntería del hook, que es lo único que se quería medir.
+    if (lineas.length === 0) {
+        return callar(conModulo === 0 ? "fuera-de-modulo" : "sin-lineas");
+    }
     // EL TECHO, sobre el total y no por fichero: una edición que toca cuatro
     // archivos servía cuatro bloques enteros, y el coste del canal se multiplicaba
     // sin que ningún tope lo viera. Ver IMPACT_BUDGET_CHARS.
     const texto = recortarAlPresupuesto(lineas);
+    // Había líneas y el presupuesto las dejó en nada: el fichero tenía módulo, así
+    // que esto es silencio con contexto, no ausencia de contexto.
     if (!texto)
-        return null;
+        return callar("sin-lineas");
     // La entrega, anotada en disco. `MAX_MODULES` arriba no es cosmético: los
     // módulos que caen en el «+N more» NO se sirvieron, así que sus alertas no
     // pueden entrar en el registro de lo servido.
@@ -1044,7 +1317,7 @@ async function buildImpact(db, payload) {
     // headShaDe es un `git rev-parse` síncrono (~5 ms) y cabe de sobra en el
     // presupuesto; el hash de un texto de dos kilobytes no se mide. Lo que NO
     // entra aquí es la red: eso es del `--warm`.
-    encolarEntrega(await queuePath(dir), {
+    encolarEntrega(colaFile, {
         project_id: signals.project_id,
         chars_served: texto.length,
         ...entregaDe({
@@ -1089,12 +1362,33 @@ export async function printImpact(db) {
             catch {
                 return;
             }
+            // El motivo del silencio lo anota quien lo conoce, y solo UNA vez: el
+            // token viaja a buildImpact para que un `timeout` de aquí no se sume al
+            // motivo que aquél anotaría al terminar (sigue corriendo un rato después
+            // de perder la carrera). Contar dos veces la misma edición es peor que no
+            // contarla: infla el denominador con algo que nunca pasó.
+            const marca = { contado: false };
+            let vencio = false;
+            let fallo = false;
             const additionalContext = await Promise.race([
-                buildImpact(db, payload).catch(() => null),
-                vencido,
+                buildImpact(db, payload, marca).catch(() => {
+                    fallo = true;
+                    return null;
+                }),
+                vencido.then(() => {
+                    vencio = true;
+                    return null;
+                }),
             ]);
-            if (!additionalContext)
+            if (!additionalContext) {
+                // `timeout` y `error` no los ve buildImpact: uno lo decide la carrera y
+                // el otro se lo come el catch. Los demás motivos ya se anotaron dentro.
+                if (!marca.contado && (vencio || fallo)) {
+                    marca.contado = true;
+                    anotarSilencio(await queuePath(payload.cwd?.trim() || process.cwd()), vencio ? "timeout" : "error");
+                }
                 return;
+            }
             process.stdout.write(JSON.stringify({
                 hookSpecificOutput: {
                     hookEventName: "PreToolUse",