changebook 0.7.0 → 0.8.0

package/dist/git.js

@@ -75,8 +75,9 @@ export function usableSummary(message) {
  * exactamente eso.
  *
  * Un commit que SOLO toca estos ficheros produce un diff vacío y `analyze` lo
- * salta con su mensaje de siempre — que es la respuesta correcta: regenerar el
- * mapa no es un cambio de producto.
+ * salta, que es la respuesta correcta: regenerar el mapa no es un cambio de
+ * producto. Lo que NO era correcto era cómo lo contaba — ver
+ * `ficherosDelCommit` aquí abajo y el mensaje en `analyze.ts`.
  */
 export const FICHEROS_GENERADOS = [
     ":(exclude)CLAUDE.md",
@@ -104,6 +105,45 @@ export async function commitDiff(cwd, hash) {
         throw new Error(`Could not read the diff of ${hash.slice(0, 8)}: ${gitErrorMessage(error)}`);
     }
 }
+/**
+ * Los ficheros que toca un commit, SIN excluir los generados.
+ *
+ * POR QUÉ EXISTE. `commitDiff` excluye `CLAUDE.md`/`AGENTS.md`, así que un
+ * commit que solo toca esos devuelve diff vacío — igual que un merge, que no
+ * tiene diff propio. Dos situaciones distintas, una sola señal, y `analyze`
+ * elegía la equivocada: decía «has no analyzable diff (merge?)» de un commit
+ * normal que ni siquiera era un merge (medido el 04/08 con `0bac769`).
+ *
+ * Es la invariante 17 del repo dentro del producto: la ausencia de diff no
+ * prueba la ausencia de cambio mientras el instrumento no sepa distinguir por
+ * qué está ausente. Esta función es lo que le da esa segunda pregunta.
+ *
+ * Devuelve `[]` si el commit no toca ningún fichero — el caso del merge de
+ * verdad, y también el de un commit vacío.
+ */
+export async function ficherosDelCommit(cwd, hash) {
+    try {
+        const { stdout } = await execFileAsync("git", 
+        // Mismo `--end-of-options` que commitDiff, por el mismo motivo.
+        ["show", "--pretty=format:", "--name-only", "--end-of-options", hash], { cwd, encoding: "utf8", maxBuffer: GIT_MAX_BUFFER_BYTES });
+        return stdout
+            .split("\n")
+            .map((l) => l.trim())
+            .filter(Boolean);
+    }
+    catch (error) {
+        throw new Error(`Could not read the files of ${hash.slice(0, 8)}: ${gitErrorMessage(error)}`);
+    }
+}
+/**
+ * ¿Es un fichero de los que ChangeBook genera? Se decide con las MISMAS rutas
+ * que excluye `commitDiff`, derivadas de ella y no reescritas: dos listas que
+ * pudieran separarse harían que el mensaje explicara un salto que no ocurrió.
+ */
+export function esFicheroGenerado(ruta) {
+    const nombre = ruta.split("/").pop() ?? "";
+    return FICHEROS_GENERADOS.some((patron) => patron.replace(/^:\(exclude\)(\*\*\/)?/, "") === nombre);
+}
 /** Pulls git's stderr out of an execFile rejection for a readable message. */
 export function gitErrorMessage(error) {
     if (typeof error === "object" &&

package/dist/guard.js

@@ -274,6 +274,151 @@ export function dondeApareceElSimbolo(alert, buscarFicheros) {
         return null;
     return ficheros;
 }
+/**
+ * «El modelo nombro un simbolo que este cambio no toca», si el servidor lo
+ * comprobo y salio que no.
+ *
+ * ES LA SEÑAL QUE YA SE CALCULABA Y SE GUARDABA EN UN CAJON.
+ * `simboloFueraDelCambio` corre en cada analisis desde el 28/07 en modo SOMBRA:
+ * anota en `discarded_warnings` y el aviso se sirve igual. Medido el 08/08
+ * cruzandola con una auditoria a mano de los 21 avisos de FacelessOS, marco
+ * **15 de los 17 falsos**.
+ *
+ * POR QUE SE SIRVE EN VEZ DE DESCARTAR. Desde el servidor, un aviso legitimo
+ * sobre codigo de fuera del cambio —«alguien todavia llama a buildReport con el
+ * formato viejo»— es INDISTINGUIBLE del inventado: los dos afirman una relacion
+ * que el modelo no ha podido ver en el diff. Quien puede separarlos es este
+ * lado, que tiene el arbol: por eso esta linea viaja pegada a `fichaDelSimbolo`,
+ * que dice donde vive el simbolo de verdad. Juntas, el juicio se resuelve sin
+ * salir del aviso; por separado, cada una es media pista.
+ *
+ * SOLO HABLA CUANDO SABE. `true` no se dice —que el simbolo estuviera en el
+ * diff es lo normal y no es noticia— y `null`/ausente tampoco: puede ser un
+ * backfill, un servidor anterior a la columna o una cache vieja, y presentar
+ * «no se comprobo» como «esta comprobado» es la clase de silencio que este
+ * fichero entero existe para no cometer.
+ */
+export function fueraDelCambio(alert) {
+    if (alert.evidence_in_diff !== false)
+        return null;
+    const simbolo = (alert.evidence_symbol ?? "").trim();
+    // LA FRASE DICE EXACTAMENTE LO QUE SE MIDIO, ni una palabra mas. El primer
+    // borrador decia «it is talking about code it did not see in the diff» y era
+    // FALSO: `simboloFueraDelCambio` solo mira las lineas AÑADIDAS Y QUITADAS, no
+    // las de contexto, asi que el modelo pudo verlo perfectamente. Lo cazo su
+    // propio contrato al pasarle un simbolo en linea de contexto. Una linea de
+    // comprobacion que afirma de mas es peor que no tenerla: se sirve con
+    // prioridad 0 y se lee como hecho verificado.
+    return (`${simbolo ? `"${simbolo}"` : "the alert's symbol"} is in no line this change` +
+        " added or removed — the claim may still hold, but nothing in this diff" +
+        " supports it");
+}
+/** Cuantos ficheros se nombran en la ficha antes de resumir. */
+const MAX_FICHEROS_EN_FICHA = 3;
+/**
+ * ¿Es esta linea la DEFINICION del simbolo, y esta exportada?
+ *
+ * Puro y separado del grep a proposito: la decision se puede probar con lineas
+ * escritas a mano, sin repo y sin disco. Conservador — solo reconoce la forma
+ * `[export] [default] [async] function|const|let|var|class|type|interface NOMBRE`,
+ * que es donde vive el 100% de los casos medidos. Un `module.exports.x = ...` o
+ * un `export { x }` a distancia NO se reconocen, y eso hace que la ficha diga
+ * "no exportado" de menos, jamas de mas... salvo por `export {`, que se mira
+ * aparte justo por eso.
+ */
+export function defineElSimbolo(texto, simbolo) {
+    const esc = simbolo.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const decl = new RegExp(`^\\s*(export\\s+)?(default\\s+)?(async\\s+)?(function|const|let|var|class|type|interface|enum)\\s+${esc}\\b`);
+    const m = decl.exec(texto);
+    if (m)
+        return { define: true, exportado: Boolean(m[1]) };
+    // `export { simbolo }` / `export { simbolo as otro }`: exporta sin declarar.
+    // Se mira porque su ausencia SI mentiria — diria "no exportado" de un simbolo
+    // que lo esta, y esa es la unica direccion en la que esta ficha puede hacer
+    // dano (invitar a concluir que no hay llamadores fuera cuando los hay).
+    if (new RegExp(`^\\s*export\\s*\\{[^}]*\\b${esc}\\b`).test(texto)) {
+        return { define: false, exportado: true };
+    }
+    return { define: false, exportado: false };
+}
+/**
+ * La ficha del simbolo de un aviso `present`: donde se define, si se exporta y
+ * en cuantos ficheros aparece.
+ *
+ * ── POR QUE EXISTE, y por que NO descarta ───────────────────────────────────
+ *
+ * Medido el 2026-08-08 auditando los 19 avisos abiertos de FacelessOS: 15 eran
+ * falsos y **8 de esos 15** decian lo mismo — «cualquier llamador que envie N
+ * argumentos fallara» — sobre funciones NO EXPORTADAS con UNA sola llamada, en
+ * su propio fichero. El aviso pedia comprobar algo que un grep contesta en 30 ms.
+ *
+ * La primera version de esta idea era un FILTRO que descartaba esos avisos. Se
+ * descarto al escribirla: contar apariciones no prueba que los llamadores se
+ * actualizaran —eso solo lo prueba el compilador, y el guardian no tiene
+ * presupuesto para un `tsc`—, asi que descartar puede tirar un aviso verdadero.
+ * Es exactamente la catastrofe por la que el 2026-07-26 se quito la rama
+ * 'absent' de `avisoRefutado`.
+ *
+ * Asi que se aplica a `present` la regla que ya estaba escrita para `absent`:
+ * **no descartar, CONTESTAR**. Nombrar el sitio es util en las dos lecturas y
+ * falso en ninguna; descartar es catastrofico en una de las dos.
+ *
+ * Y hay un segundo caso que esto caza solo, tambien medido ese dia: el aviso de
+ * `LIMITE_MS` apuntaba a «ai33.ts» y en ese repo hay TRES ficheros llamados
+ * ai33.ts con ese mismo simbolo. Decir «definido en 3 ficheros» deja ver el
+ * ancla ambigua sin tener que adivinar cual era.
+ *
+ * Devuelve null cuando no hay nada FIABLE que añadir: otro `expect`, sin
+ * simbolo, ambito que no es el repo, el grep fallo, o el simbolo no aparece.
+ */
+export function fichaDelSimbolo(alert, buscarLineas) {
+    const simbolo = (alert.evidence_symbol ?? "").trim();
+    // El espejo exacto de `dondeApareceElSimbolo`, con el `expect` opuesto: alli
+    // se contesta «sigue apareciendo» a quien esperaba que se fuera; aqui se
+    // contesta «vive aqui y se le llama desde aqui» a quien avisa de llamadores.
+    if (!simbolo || alert.evidence_expect !== "present")
+        return null;
+    // Mismo gate que alli, y por lo mismo: una afirmacion sobre produccion no se
+    // contesta con un grep del repo. Para esas va `dondeComprobarlo`.
+    if (alcanceDelRepo(alert) !== "si")
+        return null;
+    let lineas;
+    try {
+        lineas = buscarLineas(simbolo);
+    }
+    catch {
+        return null;
+    }
+    if (!lineas || lineas.length === 0)
+        return null;
+    const ficheros = [...new Set(lineas.map((l) => l.fichero))];
+    const definiciones = [
+        ...new Set(lineas.filter((l) => defineElSimbolo(l.texto, simbolo).define).map((l) => l.fichero)),
+    ];
+    const exportado = lineas.some((l) => defineElSimbolo(l.texto, simbolo).exportado);
+    // Sin definicion a la vista no se dice nada: la ficha entera se apoya en
+    // saber DONDE vive el simbolo, y «aparece en 4 ficheros» sin saber cual lo
+    // declara es ruido que ya sirve `dondeApareceElSimbolo` para los 'absent'.
+    if (definiciones.length === 0)
+        return null;
+    const lista = (xs) => xs.length <= MAX_FICHEROS_EN_FICHA
+        ? xs.join(", ")
+        : `${xs.slice(0, MAX_FICHEROS_EN_FICHA).join(", ")} +${xs.length - MAX_FICHEROS_EN_FICHA}`;
+    // EL ANCLA AMBIGUA MANDA. Si el simbolo se declara en varios ficheros, el
+    // aviso no identifica uno y eso es lo primero que hay que saber: cualquier
+    // otra frase daria por buena una localizacion que no existe.
+    if (definiciones.length > 1) {
+        return (`"${simbolo}" is declared in ${definiciones.length} files (${lista(definiciones)})` +
+            ` — the alert names a symbol, not a file, so check which one it means`);
+    }
+    if (!exportado) {
+        return (`"${simbolo}" is declared in ${definiciones[0]} and is NOT exported;` +
+            ` it appears in ${ficheros.length} file(s) (${lista(ficheros)})` +
+            ` — every caller is in view there`);
+    }
+    return (`"${simbolo}" is exported from ${definiciones[0]}` +
+        ` and appears in ${ficheros.length} file(s) (${lista(ficheros)})`);
+}
 /**
  * Open alerts × staged files → warnings, deduped by (module, message).
  *
@@ -397,6 +542,43 @@ export function ficherosEnRepo(dir, simbolo) {
         return null;
     return out.split("\n").filter(Boolean).slice(0, MAX_FICHEROS_SERVIDOS);
 }
+/**
+ * Las LINEAS donde aparece el simbolo, para poder decir si se declara y si se
+ * exporta (ver `fichaDelSimbolo`). Tercera pregunta del mismo grep.
+ *
+ * El formato de `git grep -n` es `fichero:linea:texto`, y el texto puede llevar
+ * dos puntos, asi que se parte por los DOS primeros y nada mas. Partir por todos
+ * y quedarse con el ultimo trozo se comeria media linea de codigo — y una linea
+ * recortada por la mitad puede perder el `export` del principio, que es
+ * justamente lo que esto viene a leer.
+ */
+export function lineasEnRepo(dir, simbolo) {
+    const out = grepDelRepo(dir, simbolo, "-n");
+    if (out === null)
+        return null;
+    const lineas = [];
+    for (const l of out.split("\n")) {
+        if (!l)
+            continue;
+        const p1 = l.indexOf(":");
+        if (p1 < 0)
+            continue;
+        const p2 = l.indexOf(":", p1 + 1);
+        if (p2 < 0)
+            continue;
+        lineas.push({ fichero: l.slice(0, p1), texto: l.slice(p2 + 1) });
+        if (lineas.length >= MAX_LINEAS_LEIDAS)
+            break;
+    }
+    return lineas;
+}
+/**
+ * Tope de lineas que se leen para hacer la ficha. Un simbolo corriente («id»,
+ * «data») puede salir miles de veces y la ficha solo necesita ver las
+ * declaraciones; leer sin tope convertiria una comprobacion de 30 ms en el
+ * cuello de botella del guardian.
+ */
+const MAX_LINEAS_LEIDAS = 400;
 /** Tope de rutas que se nombran en un aviso: la lista es una pista, no un informe. */
 const MAX_FICHEROS_SERVIDOS = 4;
 /**
@@ -465,7 +647,7 @@ function grepDelRepo(dir, simbolo, modo) {
  * Empieza en 1: una caché SIN `v` es anterior al versionado y se descarta
  * siempre.
  */
-const GUARD_CACHE_V = 1;
+export const GUARD_CACHE_V = 2;
 /**
  * Los hallazgos de B9 que tocan lo que se va a commitear.
  *
@@ -568,7 +750,7 @@ async function fetchSignals(db, dir, env) {
             // fuera barato. Lo vigila `test/alcanceLlegaAlCliente.test.ts`, que lee
             // ESTA línea: un test de comportamiento no lo caza, porque los stubs
             // inyectan el campo a mano.
-            `regression_alerts?select=id,module,plain,created_at,evidence_symbol,evidence_expect,evidence_scope,evidence_line,files&project_id=eq.${projectId}&resolved_at=is.null&order=created_at.desc&limit=${MAX_ALERTS}`),
+            `regression_alerts?select=id,module,plain,created_at,evidence_symbol,evidence_expect,evidence_scope,evidence_line,evidence_in_diff,files&project_id=eq.${projectId}&resolved_at=is.null&order=created_at.desc&limit=${MAX_ALERTS}`),
             aliasesFor(db, projectId),
         ]);
         alerts = canonicalizeModuleRows(alertasCrudas, aliases);

package/dist/impact.js

@@ -41,8 +41,9 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { presupuestoDeTiempo } from "./context.js";
+import { dirDeTranscripciones, drenarFriccion, pendientesDeShellPath, procesarFriccion, tomarPendientesDeShell, } from "./friction.js";
 import { execFileAsync, gitPath, projectNameFor } from "./git.js";
-import { avisoRefutado, contarEnRepo, dondeApareceElSimbolo, dondeComprobarlo, entregaDe, ficherosEnRepo, hashDelTexto, headShaDe, slugifyProject, unoPorTexto, } from "./guard.js";
+import { avisoRefutado, contarEnRepo, dondeApareceElSimbolo, dondeComprobarlo, fueraDelCambio, fichaDelSimbolo, lineasEnRepo, 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";
@@ -103,7 +104,11 @@ const SEEN_MAX = 200;
  * equivocados; un SeenState viejo, como mucho, repite un aviso o se calla uno
  * dentro de una sesión. No justifica tirar el estado de todo el mundo hoy.
  */
-const SEEN_STATE_V = 1;
+// 1 → 2 EL 24/08: el estado pasó de guardar RUTAS a guardar MÓDULOS. Subirla es
+// lo que hace que el estado viejo se olvide en vez de interpretarse mal —una
+// ruta leída como módulo no casaría nunca y el dedup quedaría desactivado en
+// silencio, que es justo el fallo que este cambio viene a arreglar.
+const SEEN_STATE_V = 2;
 /** Cuántos módulos se describen si el archivo pertenece a varios. */
 const MAX_MODULES = 3;
 /**
@@ -412,6 +417,14 @@ export function lineasDeImpacto(file, modules) {
                         ` — alert expects it gone: either a reference was missed, or the alert is stale`,
                 });
             }
+            if (a.fueraDelCambio) {
+                lines.push({ prio: 0, text: `    → NOT IN THE DIFF: ${a.fueraDelCambio}` });
+            }
+            // La misma frase que sirve `atlas_file_context`, a proposito: dos
+            // redacciones del mismo hecho son dos hechos para el agente.
+            if (a.ficha) {
+                lines.push({ prio: 0, text: `    → CHECKED NOW: ${a.ficha}` });
+            }
             // El caso opuesto: el repo NO puede contestar esta afirmacion. Se dice, en
             // vez de dejar que el agente (o el refutador) la compruebe donde no era —
             // que es lo que tiraba las dos alertas del desfase de esquema.
@@ -447,29 +460,29 @@ export function lineasDeImpacto(file, modules) {
     return lines;
 }
 /**
- * Rutas que ya se avisaron en ESTA sesión y siguen frescas. Sesión distinta →
+ * Módulos que ya se avisaron en ESTA sesión y siguen frescos. Sesión distinta →
  * borrón y cuenta nueva: cada sesión abre con un contexto vacío, así que el
  * aviso vuelve a hacer falta.
  */
-export function rutasYaAvisadas(state, sessionId, ahora) {
+export function modulosYaAvisados(state, sessionId, ahora) {
     if (!state || state.session_id !== sessionId)
         return new Set();
     // Otra forma de fichero: no se interpreta, se olvida. Ausente cuenta como la
     // actual (ver SEEN_STATE_V).
-    if ((state.v ?? SEEN_STATE_V) !== SEEN_STATE_V)
+    if ((state.v ?? 1) !== SEEN_STATE_V)
         return new Set();
     const vivas = Object.entries(state.seen ?? {}).filter(([, at]) => typeof at === "number" && ahora - at < SEEN_TTL_MS);
-    return new Set(vivas.map(([ruta]) => ruta));
+    return new Set(vivas.map(([modulo]) => modulo));
 }
 /** El estado siguiente, podado por TTL y por tamaño (más recientes primero). */
 export function estadoSiguiente(state, sessionId, nuevas, ahora) {
     const base = state &&
         state.session_id === sessionId &&
-        (state.v ?? SEEN_STATE_V) === SEEN_STATE_V
+        (state.v ?? 1) === SEEN_STATE_V
         ? { ...(state.seen ?? {}) }
         : {};
-    for (const ruta of nuevas)
-        base[ruta] = ahora;
+    for (const modulo of nuevas)
+        base[modulo] = ahora;
     const podado = Object.entries(base)
         .filter(([, at]) => typeof at === "number" && ahora - at < SEEN_TTL_MS)
         .sort((a, b) => b[1] - a[1])
@@ -507,6 +520,48 @@ export function modulosDelArchivo(file, rows) {
     }
     return [...out.entries()].map(([module, v]) => ({ module, ...v }));
 }
+/**
+ * El resolutor de módulos para el lector de fricción, sacado de la caché.
+ *
+ * Existe para que TODOS los caminos que encolan fricción resuelvan el módulo
+ * igual. Sin él, `changebook friction` encolaba con `modulo: null` y además
+ * avanzaba la marca de agua, así que esos bytes ya no los veía `--warm`: las
+ * filas subían sin módulo para siempre y el bloque del brief —que filtra por
+ * `module=not.is.null`— se quedaba ciego. Medido en prod el 24/08: 1.505 filas,
+ * cero con módulo.
+ *
+ * Sin caché devuelve `() => null` y se dice: es mejor una fila sin módulo que
+ * ninguna, pero quien llama puede avisar.
+ */
+export async function resolutorDeModulos(dir) {
+    const file = await cachePath(dir).catch(() => null);
+    const cache = file ? leerJson(file) : null;
+    if (!cache?.rows?.length)
+        return { moduloDe: () => null, hayCache: false };
+    // `repoRelative` Y NO la ruta tal cual. EL ATLAS GUARDA RUTAS RELATIVAS A LA
+    // RAÍZ DEL REPO (lo dice el comentario de `atlasSignals`, y estaba escrito
+    // antes de que yo lo ignorara). La transcripción da absolutas, así que sin
+    // relativizar `files.includes(...)` NO CASA NUNCA: medido el 24/08, 0 de 1.505
+    // eventos salieron con módulo, en LOS DOS caminos.
+    //
+    // El toplevel de git y no `dir`: el agente puede estar en un subdirectorio.
+    // Mismo `rev-parse` que el hook, y con el mismo fallback: sin repo, `dir`.
+    const toplevel = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+        cwd: dir,
+        encoding: "utf8",
+    })
+        .then(({ stdout }) => stdout.trim())
+        .catch(() => dir);
+    return {
+        moduloDe: (ruta) => {
+            const rel = repoRelative(toplevel, ruta);
+            if (!rel)
+                return null; // Fuera del repo: no es de ningún módulo.
+            return modulosDelArchivo(rel, cache.rows)[0]?.module ?? null;
+        },
+        hayCache: true,
+    };
+}
 /**
  * ¿Se puede servir esta caché? Fresca Y de esta forma.
  *
@@ -966,7 +1021,7 @@ 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,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}`)
+        `regression_alerts?select=id,module,plain,resolution,created_at,files,resolved_at,evidence_symbol,evidence_expect,evidence_scope,evidence_line,evidence_in_diff&project_id=eq.${projectId}&order=created_at.desc&limit=${ALERT_WINDOW_ROWS}`)
             .catch(() => []),
         aliasesFor(db, projectId),
     ]);
@@ -1053,6 +1108,31 @@ export async function warmImpactCache(db, dir, env = process.env) {
         // seguiría avisando igual— y "¿acertó el aviso?" seguiría sin respuesta por
         // el canal más frecuente, que es justo lo que esto viene a arreglar.
         await drenarCola(db, dir);
+        // La fricción va DESPUÉS del drenado y en su propio try: es la función
+        // nueva, y la función nueva no puede tumbar el canal que ya funciona. Si
+        // esto lanza, `atlas_reads` ya se vació y la caché se calienta igual.
+        try {
+            const cacheParaModulos = leerJson(file);
+            // El MISMO resolutor que `changebook friction`. La versión anterior pasaba
+            // la ruta cruda de la transcripción —absoluta— contra una caché de rutas
+            // relativas, así que no resolvía NINGÚN módulo. Los dos caminos estaban
+            // igual de roto, y unificarlos sin arreglar esto no cambió nada.
+            const { moduloDe } = await resolutorDeModulos(dir);
+            await procesarFriccion(dir, {
+                ahoraMs: Date.now(),
+                dirTranscripciones: dirDeTranscripciones(dir),
+                moduloDe,
+            });
+            // `drenarFriccion` NO lanza: captura el fallo de subida, deja la cola
+            // entera y lo anota para el diagnóstico. Si lanzara, este catch se lo
+            // tragaría y un 403 se leería igual que «no había nada que subir».
+            if (cacheParaModulos?.project_id) {
+                await drenarFriccion(db, dir, cacheParaModulos.project_id);
+            }
+        }
+        catch {
+            // Ver arriba: aislamiento a propósito.
+        }
         // Carrera entre dos ediciones seguidas: si otro proceso ya dejó una caché
         // fresca mientras este arrancaba, no gastar dos veces la misma consulta.
         const cached = leerJson(file);
@@ -1137,10 +1217,27 @@ marca = { contado: false }) {
     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 callar("ya-avisado");
+    const modulosAvisados = modulosYaAvisados(leerJson(seenFile), sessionId, ahora);
+    // TODOS los ficheros del repo siguen adelante: lo que se filtra ahora son los
+    // MÓDULOS, más abajo. Un fichero que pertenece a un módulo del que aún no se
+    // ha avisado tiene algo que decir aunque su ruta ya se haya visto.
+    //
+    // Y con ellos, LAS ESCRITURAS POR SHELL que el lector desacoplado apuntó: un
+    // `sed -i` no pasa por este hook, así que su módulo no se avisaba jamás.
+    // Medido el 24/08: 30 pares (sesión, módulo) tocados sólo por shell, de los
+    // que ~19 valían un aviso —`Publicación` con 3 reincidencias entre ellos—.
+    //
+    // Se unen aquí y no en un hook de `Bash` porque esto NO cuesta latencia: la
+    // lista ya está escrita en disco y sólo se lee. El dedup por módulo evita que
+    // repitan lo que la edición en curso ya diga.
+    const pendientes = [
+        ...new Set([
+            ...relativas,
+            ...tomarPendientesDeShell(await pendientesDeShellPath(dir))
+                .map((r) => repoRelative(toplevel, r))
+                .filter((r) => Boolean(r)),
+        ]),
+    ];
     const signals = await atlasSignals(db, dir);
     if (!signals?.project_id)
         return callar("sin-atlas");
@@ -1204,6 +1301,20 @@ marca = { contado: false }) {
         grepsRestantes -= 1;
         return dondeApareceElSimbolo(a, (s) => ficherosEnRepo(toplevel, s));
     };
+    /**
+     * La ficha del simbolo de un aviso 'present'. Gasta del MISMO presupuesto de
+     * greps que las otras dos: el guardian corre pre-commit contra un plazo, y una
+     * comprobacion nueva que no lo respetara lo volveria lento justo cuando mas
+     * avisos abiertos hay — que es cuando mas falta hace que conteste.
+     */
+    const fichar = (a) => {
+        if (a.evidence_expect !== "present")
+            return null;
+        if (grepsRestantes <= 0)
+            return null;
+        grepsRestantes -= 1;
+        return fichaDelSimbolo(a, (s) => lineasEnRepo(toplevel, s));
+    };
     const depsRows = signals.deps ?? [];
     // Co-cambio: UNA vez por corrida, no por módulo. `coChangePairs` recorre la
     // ventana entera y ya trae sus propios umbrales (MIN_PAIR_COUNT=3,
@@ -1219,6 +1330,12 @@ marca = { contado: false }) {
     // Lineas con prioridad, no texto ya cocido: el techo se aplica al TOTAL, asi
     // que hay que poder recortar despues de saber cuanto ocupa todo junto.
     const lineas = [];
+    /** Los MÓDULOS servidos: es lo que se recuerda para no repetir. */
+    const modulosServidos = [];
+    /** Los FICHEROS servidos: es lo que se anota en el libro de entregas.
+     *  Dos listas y no una: repurposar la columna `files` para que llevara
+     *  módulos habría cambiado el significado de un dato ya publicado sin
+     *  renombrarlo — la deriva silenciosa que este repo persigue. */
     const avisadas = [];
     /** Las alertas que de verdad salieron en el texto. Ver el encolado del final. */
     const idsServidos = [];
@@ -1226,6 +1343,14 @@ marca = { contado: false }) {
      *  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;
+    /** ¿Se calló algún módulo por haberse avisado ya en esta sesión?
+     *
+     *  Lo necesita el contador de silencios: «ya avisado» y «no había nada que
+     *  decir» son motivos DISTINTOS, y mezclarlos deja la tasa sin poder explicar
+     *  por qué calló. Al pasar el dedup de fichero a módulo, el filtro dejó de
+     *  estar donde se emitía `ya-avisado` — y sin esta bandera los dos motivos se
+     *  volvían el mismo. */
+    let algunoYaAvisado = false;
     for (const file of pendientes) {
         const modulos = modulosDelArchivo(file, signals.rows);
         if (modulos.length === 0)
@@ -1249,20 +1374,39 @@ marca = { contado: false }) {
                 .map((a) => {
                 const donde = localizar(a);
                 const fuera = dondeComprobarlo(a);
+                const ficha = fichar(a);
+                // No gasta grep: es una columna que ya viene en la fila.
+                const noVisto = fueraDelCambio(a);
                 return {
                     plain: a.plain,
                     alertIds: a.id ? [a.id] : [],
+                    ...(noVisto ? { fueraDelCambio: noVisto } : {}),
                     ...(donde
                         ? { donde, simbolo: (a.evidence_symbol ?? "").trim() }
                         : {}),
+                    ...(ficha ? { ficha } : {}),
                     ...(fuera ? { fueraDelRepo: fuera } : {}),
                     ...(a.evidence_line
                         ? { linea: String(a.evidence_line).trim() }
                         : {}),
                 };
-            }), (x) => x.plain, (x) => Boolean(x.donde || x.fueraDelRepo)), abiertas.filter((a) => (a.module ?? "").trim() === m.module)),
+            }), (x) => x.plain, 
+            // `ficha` cuenta como comprobacion igual que las otras dos: si dos
+            // avisos comparten texto, sobrevive el que trae algo comprobado. Sin
+            // añadirla aqui, el que la trae podia perder el desempate y la
+            // comprobacion se tiraba junto con su duplicado.
+            (x) => Boolean(x.donde || x.fueraDelRepo || x.ficha || x.fueraDelCambio)), abiertas.filter((a) => (a.module ?? "").trim() === m.module)),
             priorRegressions: recidivism.get(m.module) ?? 0,
         }))
+            // El dedup, por MÓDULO y antes de `valeLaPena`: si de este módulo ya se
+            // avisó en esta sesión, su texto sería idéntico y no deja hacer nada
+            // distinto. Medido: la mitad de los avisos eran esto.
+            .filter((m) => {
+            if (!modulosAvisados.has(m.module))
+                return true;
+            algunoYaAvisado = true;
+            return false;
+        })
             .filter(valeLaPena)
             // Por PELIGRO, no por lo más reciente. Solo caben MAX_MODULES y el orden
             // decide qué se ve: con el orden por recencia, el módulo cuya nota decía
@@ -1280,8 +1424,12 @@ marca = { contado: false }) {
         if (impactos.length === 0)
             continue;
         lineas.push(...lineasDeImpacto(file, impactos));
+        // Se recuerdan los MÓDULOS servidos, no el fichero. Y sólo los que de verdad
+        // caben (`MAX_MODULES`): marcar como avisado uno que se quedó en el «+N
+        // more» lo silenciaría sin haberlo dicho nunca.
         avisadas.push(file);
         for (const m of impactos.slice(0, MAX_MODULES)) {
+            modulosServidos.push(m.module);
             idsServidos.push(...m.alerts.flatMap((a) => a.alertIds));
         }
     }
@@ -1294,13 +1442,20 @@ marca = { contado: false }) {
     // 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));
+        escribirJson(seenFile, estadoSiguiente(leerJson(seenFile), sessionId, modulosServidos, ahora));
     }
     // 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");
+        if (conModulo === 0)
+            return callar("fuera-de-modulo");
+        // `ya-avisado` ANTES de `sin-lineas`, y el orden es el punto: si el silencio
+        // vino de que sus módulos ya se dijeron, ése es el motivo. Al pasar el dedup
+        // de fichero a módulo, el filtro dejó de estar donde se emitía este motivo, y
+        // sin esta rama los dos silencios se contaban igual — la tasa perdía la
+        // única distinción que sabe explicar POR QUÉ calló.
+        return callar(algunoYaAvisado ? "ya-avisado" : "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

package/dist/index.js

@@ -22,7 +22,8 @@ import { hookStatus, installHook, uninstallHook } from "./hook.js";
 import { importHistory, planDeImport } from "./import.js";
 import { registerAgents } from "./init.js";
 import { contextHookInstalled, installContextHook, installSettingsHook, printContext, settingsHookInstalled, uninstallContextHook, uninstallSettingsHook, } from "./context.js";
-import { IMPACT_HOOK, informeDeSilencio, printImpact, silenciosAcumulados, warmImpactCache, } from "./impact.js";
+import { IMPACT_HOOK, informeDeSilencio, printImpact, resolutorDeModulos, silenciosAcumulados, tasaDeSilencio, warmImpactCache, } from "./impact.js";
+import { diagnosticoDeFriccion, dirDeTranscripciones, procesarFriccion, rankingDeFriccion, } from "./friction.js";
 import { login } from "./login.js";
 import { confirmar, hayTerminal, preguntar } from "./pregunta.js";
 import { argumentosDeScan, contarCommits, correrScan, informeParaInit, informeDeRepo, } from "./scan.js";
@@ -66,6 +67,9 @@ Usage:
                           blocks an edit; silent when there is nothing to say
   changebook silence [dir]  How often that hook stays quiet, with both raw
                           numbers. Healthy is 85-95%: below 80% it is noise
+  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 scan [dir] [--json|--card|--badge]
                           Coupling report for any repo, from its git history
                           alone. No account, no network, writes nothing — run it
@@ -333,6 +337,32 @@ async function main() {
             await printImpact(new Supabase());
             return;
         }
+        case "friction": {
+            // Sin credenciales y sin red, como `silence`: la fricción se calcula en
+            // local y esta orden sólo la enseña. Lo que sube es cosa del `--warm`.
+            const dir = process.argv[3] ?? process.cwd();
+            // El MISMO resolutor que usa `--warm`. Esta orden también ENCOLA (es un
+            // efecto de `procesarFriccion`) y además avanza la marca de agua, así que
+            // si resolviera distinto envenenaría lo que se sube: pasó: 1.505 filas en
+            // prod sin módulo, y el bloque del brief filtra por módulo no nulo.
+            const { moduloDe, hayCache } = await resolutorDeModulos(dir);
+            const marca = await procesarFriccion(dir, {
+                ahoraMs: Date.now(),
+                dirTranscripciones: dirDeTranscripciones(dir),
+                moduloDe,
+            });
+            if (!hayCache) {
+                console.log("⚠ Sin caché del atlas: los eventos se encolan SIN módulo. Edita algo y vuelve a probar.");
+            }
+            // El denominador del canal de vitalidad: cuántas ediciones vio el hook.
+            // Si hubo ediciones y el lector leyó cero bytes, está muerto — y eso es
+            // lo único que un repo tranquilo no puede parecer.
+            const { total: edicionesVistas } = tasaDeSilencio(await silenciosAcumulados(dir));
+            console.log(diagnosticoDeFriccion(marca, edicionesVistas));
+            console.log("");
+            console.log(rankingDeFriccion(dir));
+            return;
+        }
         case "silence": {
             // Sin credenciales y sin red: el contador es local por diseño (ver
             // tallyPath). Se lee del repo, no del servidor, y por eso contesta el