changebook 0.4.9 → 0.5.0

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 { execFileAsync, gitPath } from "./git.js";
-import { avisoRefutado, contarEnRepo, slugifyProject, } from "./guard.js";
+import { execFileAsync, gitPath, projectNameFor } from "./git.js";
+import { avisoRefutado, contarEnRepo, dondeApareceElSimbolo, dondeComprobarlo, entregaDe, ficherosEnRepo, hashDelTexto, headShaDe, slugifyProject, unoPorTexto, } from "./guard.js";
+import { coChangePairs } from "./sync.js";
 import { computeRecidivism, dependentsOf } from "./tools.js";
 /**
  * Techo duro del camino crítico. Más corto que el de `context` (2 s) porque
@@ -52,6 +53,31 @@ import { computeRecidivism, dependentsOf } from "./tools.js";
 const IMPACT_TIMEOUT_MS = 1_200;
 /** Igual que el guardián: las alertas se mueven a velocidad de análisis. */
 const CACHE_TTL_MS = 5 * 60_000;
+/**
+ * LA VERSIÓN DE LA FORMA DE LA CACHÉ. Súbela cuando cambie QUÉ se guarda: las
+ * columnas de un select, un campo nuevo del que dependa el render, una clave de
+ * agrupación. No cuando cambie el código alrededor.
+ *
+ * Sin esto, una caché escrita por el binario ANTERIOR se deserializa sin error y
+ * se sirve entera durante los 5 minutos del TTL, en cada máquina que actualice.
+ * No es hipotético: el commit que añadió `evidence_scope` a este mismo select
+ * dejó exactamente esa ventana abierta, y el fallo no se ve —la caché vieja no
+ * está corrupta, solo le faltan campos, así que el render calla en vez de
+ * romperse. Un silencio se lee igual que "no hay nada que decir".
+ *
+ * Empieza en 1 y no en 2: toda caché SIN `v` es, por definición, anterior al
+ * versionado, así que se descarta pase lo que pase.
+ *
+ * ── v2 (2026-07-28): `changelog_id` en las filas ────────────────────────────
+ *
+ * Y aquí es donde esto deja de ser precaución. `coChangePairs` AGRUPA POR
+ * `changelog_id`: sin esa columna, todas las filas caen bajo la clave
+ * `undefined`, se leen como un único análisis gigantesco, y salen TODOS los
+ * módulos acoplados con TODOS. No es un fallo ruidoso — es una caché que
+ * responde, con datos que parecen razonables, durante los cinco minutos del
+ * TTL, en cada máquina que actualice. Con la versión, esas cachés se tiran.
+ */
+export const IMPACT_CACHE_V = 2;
 /**
  * Ventana del grafo. Espejo de MODULE_GRAPH_WINDOW_ROWS en tools.ts: dos
  * ventanas distintas darían dependientes distintos según se pregunte o se
@@ -64,8 +90,44 @@ const ALERT_WINDOW_ROWS = 500;
 const SEEN_TTL_MS = 30 * 60_000;
 /** Cota del archivo de estado: es una nota, no un historial. */
 const SEEN_MAX = 200;
+/**
+ * Versión de la forma del estado "ya avisado". Mismo mecanismo que
+ * IMPACT_CACHE_V, con UNA diferencia deliberada: aquí un `v` AUSENTE se acepta.
+ *
+ * Porque la forma de este fichero no ha cambiado, y decir lo contrario tirando
+ * el estado sería afirmar un desajuste que no existe. Un `v` presente y
+ * DISTINTO sí se descarta, que es la protección para el día que cambie.
+ *
+ * Y el reparto de riesgo no es el mismo: una ImpactCache vieja sirve datos
+ * 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;
 /** Cuántos módulos se describen si el archivo pertenece a varios. */
 const MAX_MODULES = 3;
+/**
+ * Cuánto de la nota del análisis se sirve.
+ *
+ * SE SIRVE, y ese es el cambio del 2026-07-26 por la tarde. El hook nacía
+ * escueto a propósito —dependientes, alertas, reincidencia— y las notas se
+ * quedaron fuera por miedo al ruido. Midiendo se vio el coste de esa decisión:
+ * la nota de `Carga y arranque de la aplicación` sobre sync.ts dice «el
+ * SYNC_BUDGET_CHARS se rebaja de 3.000 a 2.000 porque la prosa gorda expulsaba
+ * el mapa», que es EXACTAMENTE el fallo en el que caí dos veces ese mismo día. Y
+ * es lo único que ningún grep puede encontrar: no está en el código, está en la
+ * historia del análisis. El canal estaba construido y servía lo que git ya sabe.
+ *
+ * Acotada, no libre: 320 chars por nota y solo en los módulos que YA se
+ * reportan (los que tienen dependientes, alerta abierta o reincidencia). Sin el
+ * tope, un archivo de diez módulos volcaría diez párrafos y el hook volvería a
+ * ser ruido que se aprende a ignorar.
+ *
+ * 320 y no 220: con 220, la nota de sync.ts se cortaba en «…porque la prosa
+ * gord…», justo antes de la conclusión. Estas notas describen primero y concluyen
+ * al final, así que un tope corto se come exactamente la carga útil y deja la
+ * paja. Tres notas de 320 son ~250 tokens una vez por archivo y sesión.
+ */
+const MAX_NOTE_CHARS = 320;
 /** Tope de greps de refutación: son síncronos y el techo no los desaloja. */
 const MAX_REFUTACIONES = 3;
 export const IMPACT_HOOK = {
@@ -139,6 +201,115 @@ export function repoRelative(toplevel, filePath) {
     // El atlas guarda rutas de git: siempre con "/", también en Windows.
     return rel.split(path.sep).join("/");
 }
+/**
+ * Devuelve los avisos servidos con la identidad de TODAS las alertas que decian
+ * lo mismo, no solo la que sobrevivio al colapso por texto.
+ *
+ * Es la mitad de impacto del arreglo que el guardian ya lleva en
+ * `guardFindings`: la PANTALLA colapsa dos frases identicas —sobre dos frases
+ * iguales no se puede actuar distinto— pero el REGISTRO no puede, porque su
+ * trabajo es la atribucion. Con una sola identidad, el veredicto sobre esta
+ * entrega se le colgaria a la alerta equivocada.
+ *
+ * Se hace aparte y no dentro de `unoPorTexto` a proposito: esa funcion es
+ * generica y de presentacion, la comparten tres sitios y no sabe —ni debe— que
+ * es un id de alerta.
+ */
+export function conIdentidad(servidas, todas) {
+    const idsPorTexto = new Map();
+    for (const a of todas) {
+        const texto = (a.plain ?? "").trim();
+        if (!texto || !a.id)
+            continue;
+        const lista = idsPorTexto.get(texto) ?? [];
+        if (!lista.includes(a.id))
+            lista.push(a.id);
+        idsPorTexto.set(texto, lista);
+    }
+    return servidas.map((s) => ({
+        ...s,
+        alertIds: idsPorTexto.get(s.plain.trim()) ?? s.alertIds,
+    }));
+}
+/**
+ * EL TECHO DEL CANAL EMPUJADO.
+ *
+ * `sync.ts` tiene `SYNC_BUDGET_CHARS` desde hace tiempo, con toda una historia
+ * detrás (2.000 → 3.000 → vuelta a 2.000, y el comentario que lo explica:
+ * «subir el techo alimenta al que se lo come»). Esto no tenía equivalente: hay
+ * `MAX_MODULES` y `MAX_NOTE_CHARS`, pero nada acotaba el TOTAL. Tres módulos con
+ * nota larga, sus dependientes, sus alertas y ahora sus co-cambios pasan de dos
+ * mil caracteres sin que nada los pare — y si la edición toca varios ficheros,
+ * se multiplica.
+ *
+ * MÁS BAJO QUE EL DEL BLOQUE, y no por simetría: el bloque de `CLAUDE.md` se
+ * lee UNA vez por sesión y esto dispara en CADA edición. Un canal que cuesta
+ * 2.000 caracteres cuarenta veces por sesión no es un canal, es un impuesto.
+ *
+ * Y el techo no recorta al tuntún: cae primero la prosa (nota), luego la
+ * correlación (co-cambio), luego la estructura (dependientes). La alerta abierta
+ * tiene suelo y no cae nunca — si eso se recortara, el canal dejaría de tener
+ * motivo para existir.
+ */
+const IMPACT_BUDGET_CHARS = 1_500;
+/**
+ * Recorta a `budget` quitando por prioridad descendente, no por orden de
+ * aparición.
+ *
+ * DOS PROPIEDADES QUE NO SE NEGOCIAN:
+ *
+ *   Las alertas abiertas (prio 0) NO se recortan jamás, aunque solas pasen del
+ *   techo. Es el suelo, y es el mismo argumento que el «suelo del mapa» de
+ *   sync.ts: un presupuesto de suma cero sin suelo acaba comiéndose justo lo
+ *   que justifica el canal.
+ *
+ *   CONSECUENCIA, dicha aquí para que nadie la descubra depurando: el texto
+ *   devuelto PUEDE pasar de `budget`. El techo acota lo discrecional, no el
+ *   suelo. Si una edición toca módulos con veinte alertas abiertas, se sirven
+ *   las veinte — un canal que se calla justo cuando hay veinte cosas rotas
+ *   sería exactamente lo contrario de lo que promete.
+ *
+ *   Una cabecera sin contenido no se queda. `- Module **X**` a secas no dice
+ *   nada que el agente no tenga delante; servirla sería gastar caracteres en
+ *   ruido y, peor, parecer que se dijo algo.
+ */
+export function recortarAlPresupuesto(lineas, budget = IMPACT_BUDGET_CHARS) {
+    const coste = (xs) => xs.reduce((n, x) => n + x.text.length + 1, 0);
+    const dentro = new Set(lineas);
+    // De la prioridad más alta (más prescindible) a la más baja, y dentro de cada
+    // una por el final: si hay que perder co-cambios, se pierden los últimos, que
+    // `coChangePairs` ya ordenó de más fuerte a más débil.
+    const prios = [...new Set(lineas.map((l) => l.prio))].sort((a, b) => b - a);
+    for (const p of prios) {
+        if (p === 0)
+            break; // El suelo.
+        for (const l of [...lineas].reverse()) {
+            if (coste([...dentro]) <= budget)
+                break;
+            if (l.prio === p)
+                dentro.delete(l);
+        }
+    }
+    // Cabeceras huérfanas: un módulo cuyas líneas se fueron todas, y un bloque de
+    // fichero que se quedó sin módulos.
+    const quedan = lineas.filter((l) => dentro.has(l));
+    const util = [];
+    for (let i = 0; i < quedan.length; i++) {
+        const l = quedan[i];
+        if (l.ancla === "modulo" && quedan[i + 1]?.ancla !== undefined)
+            continue;
+        if (l.ancla === "modulo" && i === quedan.length - 1)
+            continue;
+        util.push(l);
+    }
+    const conContenido = util.filter((l, i) => l.ancla !== "bloque" || util[i + 1]?.ancla === "modulo");
+    // La línea en blanco entre bloques se pone AQUÍ y no al concatenar: si la
+    // pusiera quien llama, un bloque recortado entero dejaría su separador
+    // suelto — dos saltos de línea que se leen como "aquí falta algo".
+    return conContenido
+        .map((l, i) => (l.ancla === "bloque" && i > 0 ? `\n${l.text}` : l.text))
+        .join("\n");
+}
 /**
  * ¿Merece este módulo un aviso?
  *
@@ -158,25 +329,121 @@ export function valeLaPena(m) {
  * para el mismo hecho serían dos hechos para él.
  */
 export function impactText(file, modules) {
-    const lines = [`⚠ ChangeBook — impact radius of ${file}, before you edit it:`];
+    return lineasDeImpacto(file, modules)
+        .map((x) => x.text)
+        .join("\n");
+}
+/**
+ * EL ORDEN DE CAÍDA, y por qué es ese.
+ *
+ * 0 · ALERTA ABIERTA — algo ya se rompió aquí. Es lo único con suelo: si esto se
+ *     recorta, el canal deja de tener motivo para existir.
+ * 1 · DEPENDIENTES — quién se rompe si tocas esto. No está escrito en ninguna
+ *     parte del código, así que el agente no puede deducirlo.
+ * 2 · CO-CAMBIO — más débil que lo anterior: una correlación, no una arista.
+ * 3 · NOTA — contexto, no una orden. Y es lo más caro: hasta MAX_NOTE_CHARS por
+ *     módulo, o sea que tres módulos con nota se comen casi mil caracteres de
+ *     prosa antes que ningún hecho.
+ */
+export function lineasDeImpacto(file, modules) {
+    const lines = [
+        {
+            prio: 0,
+            ancla: "bloque",
+            text: `⚠ ChangeBook — impact radius of ${file}, before you edit it:`,
+        },
+    ];
     for (const m of modules.slice(0, MAX_MODULES)) {
         // El riesgo se nombra solo cuando es alto: ver valeLaPena.
         const alto = m.risk === "high" || m.risk === "hotspot";
-        lines.push(`- Module **${m.module}**` +
-            (alto ? ` · risk: ${m.risk}` : "") +
-            (m.priorRegressions >= 2
-                ? ` · ⚠ ${m.priorRegressions} prior regressions`
-                : ""));
+        lines.push({
+            prio: 0,
+            ancla: "modulo",
+            // La reincidencia viaja EN la cabecera y no en su propia línea, así que
+            // no se recorta aparte. El plan la ponía en prioridad 2; se queda porque
+            // son ~25 caracteres de señal de peligro pegados a una cabecera de 60 que
+            // igualmente se sirve — tirarla ahorraría poco y quitaría lo que más pesa
+            // de la línea. Si algún día hay que recortarla, se recorta la cabecera
+            // entera con su módulo.
+            text: `- Module **${m.module}**` +
+                (alto ? ` · risk: ${m.risk}` : "") +
+                (m.priorRegressions >= 2
+                    ? ` · ⚠ ${m.priorRegressions} prior regressions`
+                    : ""),
+        });
         if (m.dependents.length > 0) {
-            lines.push(`  - ↘ DEPENDS ON THIS: ${m.dependents.join(", ")} — check these too before you finish`);
+            lines.push({
+                prio: 1,
+                text: `  - ↘ DEPENDS ON THIS: ${m.dependents.join(", ")} — check these too before you finish`,
+            });
+        }
+        // El co-cambio es HISTORIA, no estructura: «quién llama a quién» sale de un
+        // grafo y lo tiene medio mercado; «qué se toca junto en la práctica» solo
+        // sale del historial. Va DESPUÉS de los dependientes porque es más débil —
+        // una correlación, no una arista declarada— y el orden de las líneas es lo
+        // que dice cuál de las dos merece más confianza.
+        for (const cc of m.coChanges ?? []) {
+            lines.push({
+                prio: 2,
+                text: `  - ↔ CHANGES WITH: ${cc.module} (together in ${Math.round(cc.rate * 100)}% of its changes) — check it before you finish`,
+            });
+        }
+        for (const a of m.alerts) {
+            lines.push({ prio: 0, text: `  - ⚠ OPEN ALERT: ${a.plain}` });
+            // La condicion, resuelta. Va en su propia linea y con el simbolo delante
+            // para que se lea como un hecho comprobado y no como parte de la prosa del
+            // modelo, que es justo la que hedgea.
+            //
+            // Y DICE LAS DOS LECTURAS a proposito, porque el hecho no distingue: un
+            // simbolo que sigue apareciendo cuando se esperaba ausente puede ser una
+            // referencia que se quedo sin actualizar (el caso `noscriptFor`, que rompio
+            // el build) o un aviso que ya no vale (el caso `registerTools`). Antes se
+            // elegia la segunda en silencio y se tiraba el aviso; ahora se le dan al
+            // agente el hecho y las dos salidas, que es mas informacion que la que
+            // habia en cualquiera de las dos versiones anteriores.
+            if (a.donde && a.donde.length > 0) {
+                lines.push({
+                    // Prioridad 0 como su alerta: es la COMPROBACIÓN de lo que se afirma,
+                    // y servir la afirmación sin ella deja al agente con el condicional
+                    // que esta línea existe para contestar.
+                    prio: 0,
+                    text: `    → CHECKED NOW: "${a.simbolo}" still appears in ${a.donde.join(", ")}` +
+                        ` — alert expects it gone: either a reference was missed, or the alert is stale`,
+                });
+            }
+            // 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.
+            if (a.fueraDelRepo) {
+                lines.push({
+                    prio: 0,
+                    text: `    → NOT CHECKABLE HERE: ${a.fueraDelRepo}`,
+                });
+            }
+            // LA LINEA que lo provocó. Prioridad 0 como su aviso: es la evidencia, y
+            // un aviso servido sin ella obliga al agente a reconstruir de qué se
+            // habla — que es el trabajo que este canal existe para ahorrarle.
+            if (a.linea) {
+                lines.push({ prio: 0, text: `    → TRIGGERED BY: ${a.linea}` });
+            }
+        }
+        // Con fecha y con la misma etiqueta que atlas_file_context: una nota es una
+        // observación fechada, no estado vigente. Va DESPUÉS de dependientes y
+        // alertas porque es contexto, no una orden.
+        if (m.note) {
+            lines.push({
+                prio: 3,
+                text: `  - Note from last analysis${m.noteDate ? ` (${m.noteDate})` : ""}: ${m.note}`,
+            });
         }
-        for (const plain of m.alerts)
-            lines.push(`  - ⚠ OPEN ALERT: ${plain}`);
     }
     if (modules.length > MAX_MODULES) {
-        lines.push(`- (+${modules.length - MAX_MODULES} more module(s) affected)`);
+        lines.push({
+            prio: 3,
+            text: `- (+${modules.length - MAX_MODULES} more module(s) affected)`,
+        });
     }
-    return lines.join("\n");
+    return lines;
 }
 /**
  * Rutas que ya se avisaron en ESTA sesión y siguen frescas. Sesión distinta →
@@ -186,19 +453,27 @@ export function impactText(file, modules) {
 export function rutasYaAvisadas(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)
+        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));
 }
 /** 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.seen ?? {}) } : {};
+    const base = state &&
+        state.session_id === sessionId &&
+        (state.v ?? SEEN_STATE_V) === SEEN_STATE_V
+        ? { ...(state.seen ?? {}) }
+        : {};
     for (const ruta of nuevas)
         base[ruta] = ahora;
     const podado = Object.entries(base)
         .filter(([, at]) => typeof at === "number" && ahora - at < SEEN_TTL_MS)
         .sort((a, b) => b[1] - a[1])
         .slice(0, SEEN_MAX);
-    return { session_id: sessionId, seen: Object.fromEntries(podado) };
+    return { session_id: sessionId, seen: Object.fromEntries(podado), v: SEEN_STATE_V };
 }
 /**
  * Módulos a los que pertenece un archivo, del más reciente al más antiguo.
@@ -216,14 +491,200 @@ export function modulosDelArchivo(file, rows) {
         if (!label || out.has(label))
             continue;
         const files = Array.isArray(row.files) ? row.files.map(String) : [];
-        if (files.includes(file))
-            out.set(label, row.risk);
+        if (!files.includes(file))
+            continue;
+        const nota = (row.note ?? "").trim();
+        out.set(label, {
+            risk: row.risk,
+            note: nota
+                ? nota.length > MAX_NOTE_CHARS
+                    ? `${nota.slice(0, MAX_NOTE_CHARS - 1).trimEnd()}…`
+                    : nota
+                : null,
+            noteDate: (row.created_at ?? "").slice(0, 10) || null,
+        });
     }
-    return [...out.entries()].map(([module, risk]) => ({ module, risk }));
+    return [...out.entries()].map(([module, v]) => ({ module, ...v }));
+}
+/**
+ * ¿Se puede servir esta caché? Fresca Y de esta forma.
+ *
+ * Exportada para poder probar el descarte sin montar un repo: es una función
+ * pura y el fallo que evita —servir campos que no están— no se ve desde fuera.
+ */
+export function cacheServible(cached, ahora) {
+    if (!cached)
+        return false;
+    if (cached.v !== IMPACT_CACHE_V)
+        return false;
+    return ahora - cached.fetched_at < CACHE_TTL_MS;
 }
 async function cachePath(dir) {
     return gitPath(dir, "changebook-impact-cache.json").catch(() => null);
 }
+// ── El libro de entregas del canal empujado ──────────────────────────────────
+//
+// El hook PreToolUse es el canal MÁS frecuente del atlas —dispara en cada
+// edición— y hasta hoy servía consejo sin dejar rastro: "¿acertó el aviso?" solo
+// se podía responder del guardián pre-commit, que es el que menos corre.
+//
+// EL DISEÑO LO COMPLICA A PROPÓSITO, y hay que respetarlo: el camino crítico de
+// `printImpact` no toca la red JAMÁS (ver `atlasSignals`) y tiene techo de
+// 1.200 ms. Un insert síncrono rompería la regla que sostiene todo esto — el
+// hook nunca puede costar tiempo perceptible.
+//
+// Por eso la entrega se ANOTA en disco (un append, sin leer ni parsear nada) y
+// la sirve al servidor `impact --warm`, que ya corre desacoplado y ya toca la
+// red. Escribir y enviar quedan separados por un proceso: si el editor mata al
+// hook entre las dos cosas, la línea sigue en el fichero y se manda en la
+// siguiente ronda.
+/** Cota de la cola. Mismo patrón que el log del guardián: por tamaño, no por olvido. */
+const QUEUE_MAX_BYTES = 65_536;
+const QUEUE_KEEP_BYTES = 32_768;
+async function queuePath(dir) {
+    return gitPath(dir, "changebook-impact-queue.jsonl").catch(() => null);
+}
+/**
+ * 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
+ * como sí harían leyendo-modificando-escribiendo un array.
+ *
+ * Best-effort de principio a fin: registrar la entrega no puede romper la
+ * edición que la provocó.
+ */
+export function encolarEntrega(file, entrega) {
+    if (!file)
+        return;
+    try {
+        // Recortar ANTES de anexar, igual que el log del guardián. El recorte parte
+        // por la mitad de una línea a propósito: reconstruirla costaría leer y
+        // parsear el fichero entero en el camino crítico, y la línea rota se tira
+        // sola al drenar (ver `entregasDeLaCola`). Se pierde UNA entrega de hace
+        // rato antes que gastar milisegundos de cada edición.
+        try {
+            if (fs.statSync(file).size > QUEUE_MAX_BYTES) {
+                const keep = fs.readFileSync(file).subarray(-QUEUE_KEEP_BYTES);
+                fs.writeFileSync(file, keep);
+            }
+        }
+        catch {
+            // Aún no existe: nada que recortar.
+        }
+        fs.appendFileSync(file, `${JSON.stringify(entrega)}\n`);
+    }
+    catch {
+        // Sin sitio donde anotar, el hook sigue avisando igual. El registro es una
+        // segunda lectura del mismo hecho, nunca el hecho.
+    }
+}
+/**
+ * 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
+ * error del que haya que informar a nadie — es una que no se pudo registrar.
+ */
+export function entregasDeLaCola(contenido) {
+    const fuera = [];
+    for (const linea of contenido.split("\n")) {
+        if (!linea.trim())
+            continue;
+        try {
+            const e = JSON.parse(linea);
+            // El CHECK de la migración exige sha256 en hex; una fila que no lo cumpla
+            // haría fallar el insert de TODAS las demás si fueran en lote.
+            if (typeof e?.advice_hash === "string" && /^[0-9a-f]{64}$/.test(e.advice_hash)) {
+                fuera.push(e);
+            }
+        }
+        catch {
+            // Línea partida por el recorte, o basura. Se ignora.
+        }
+    }
+    return fuera;
+}
+/**
+ * Las que TODAVÍA no están registradas, por (advice_hash, head_sha).
+ *
+ * Es la respuesta a "y si el proceso muere entre insertar y vaciar la cola":
+ * la cola se vacía DESPUÉS de insertar, así que morir en medio deja las líneas
+ * puestas y la siguiente ronda las volvería a mandar. Preguntar primero cuáles
+ * ya están hace que reenviar sea gratis, que es la misma propiedad que ya tiene
+ * `atlas_record_change`.
+ *
+ * Pura para poder probar el caso sin red, que es el que no se ve venir.
+ */
+export function entregasSinRegistrar(cola, yaRegistradas) {
+    const clave = (h, s) => `${h ?? ""}\u0000${s ?? ""}`;
+    const vistas = new Set(yaRegistradas.map((r) => clave(r.advice_hash, r.head_sha)));
+    const fuera = [];
+    for (const e of cola) {
+        const k = clave(e.advice_hash, e.head_sha);
+        // Contra el servidor Y contra sí misma: la misma edición repetida dentro de
+        // la cola es una sola entrega, no dos.
+        if (vistas.has(k))
+            continue;
+        vistas.add(k);
+        fuera.push(e);
+    }
+    return fuera;
+}
+/**
+ * Vacía la cola contra `atlas_reads`. Corre en `impact --warm`, o sea en un
+ * proceso aparte del que edita y que ya paga la red de todas formas.
+ *
+ * NO se drena también en `changebook guard`: el warm corre en cuanto la caché
+ * caduca (5 minutos), así que durante una sesión de edición la cola se vacía
+ * sola una y otra vez. Lo que queda sin mandar al cerrar el editor sigue en el
+ * fichero y se manda en la siguiente sesión — se retrasa, no se pierde.
+ */
+async function drenarCola(db, dir) {
+    const file = await queuePath(dir);
+    if (!file)
+        return;
+    let contenido;
+    try {
+        contenido = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return; // No hay cola: el caso normal.
+    }
+    const cola = entregasDeLaCola(contenido);
+    if (cola.length === 0) {
+        try {
+            fs.rmSync(file, { force: true });
+        }
+        catch {
+            /* da igual */
+        }
+        return;
+    }
+    const hashes = [...new Set(cola.map((e) => e.advice_hash))];
+    const yaRegistradas = await db
+        .rest(`atlas_reads?select=advice_hash,head_sha&advice_hash=in.(${hashes.join(",")})&limit=${hashes.length * 4}`)
+        .catch(() => []);
+    const pendientes = entregasSinRegistrar(cola, yaRegistradas);
+    for (const e of pendientes) {
+        const { project_id, chars_served, ...entrega } = e;
+        // Una a una y no en lote: un insert que falle no puede llevarse por delante
+        // las otras entregas, que ya no estarían en ningún sitio.
+        await db
+            .insertRow("atlas_reads", {
+            project_id,
+            tool: "impact_pretooluse",
+            source: "stdio",
+            chars_served,
+            ...entrega,
+        })
+            .catch(() => { });
+    }
+    // Se vacía DESPUÉS. Si el proceso muere aquí, la siguiente ronda pregunta y
+    // no duplica (ver `entregasSinRegistrar`).
+    try {
+        fs.rmSync(file, { force: true });
+    }
+    catch {
+        // La cola se recortará sola por tamaño; el dedup impide que se repitan.
+    }
+}
 function leerJson(file) {
     if (!file)
         return null;
@@ -247,7 +708,7 @@ function escribirJson(file, data) {
 async function fetchAtlas(db, dir, env) {
     // Mismo proyecto al que reporta analyze/hook: CHANGEBOOK_PROJECT manda, si no
     // el nombre del directorio, casado por slug del servidor primero.
-    const candidate = env.CHANGEBOOK_PROJECT?.trim() || path.basename(path.resolve(dir));
+    const candidate = projectNameFor(dir, env);
     const slug = slugifyProject(candidate);
     let projects = slug
         ? await db.rest(`projects?select=id&slug=eq.${encodeURIComponent(slug)}&limit=1`)
@@ -257,7 +718,14 @@ async function fetchAtlas(db, dir, env) {
     }
     const projectId = projects[0]?.id ?? null;
     if (!projectId) {
-        return { fetched_at: Date.now(), project_id: null, rows: [], deps: [], alerts: [] };
+        return {
+            v: IMPACT_CACHE_V,
+            fetched_at: Date.now(),
+            project_id: null,
+            rows: [],
+            deps: [],
+            alerts: [],
+        };
     }
     // TRES consultas en paralelo, una vez cada 5 minutos y fuera del camino
     // crítico, así que el número de rondas aquí da igual. Lo que NO da igual es
@@ -275,16 +743,34 @@ async function fetchAtlas(db, dir, env) {
     // reincidencia (all-time) salen del mismo conjunto.
     const [rows, deps, alerts] = await Promise.all([
         db
-            .rest(`change_module?select=module,files,risk,created_at&project_id=eq.${projectId}&order=created_at.desc&limit=${GRAPH_WINDOW_ROWS}`)
+            .rest(
+        // `changelog_id` para el co-cambio (ver ImpactCache["rows"]). Va en la
+        // consulta que YA se hacía, no en una cuarta: el co-cambio no puede
+        // costar una ronda de red más en el canal que corre en cada edición.
+        `change_module?select=module,files,risk,note,created_at,changelog_id&project_id=eq.${projectId}&order=created_at.desc&limit=${GRAPH_WINDOW_ROWS}`)
             .catch(() => []),
         db
             .rest(`change_module?select=module,deps&project_id=eq.${projectId}&deps=not.is.null&order=created_at.desc&limit=${GRAPH_WINDOW_ROWS}`)
             .catch(() => []),
         db
-            .rest(`regression_alerts?select=module,plain,files,resolved_at,evidence_symbol,evidence_expect&project_id=eq.${projectId}&order=created_at.desc&limit=${ALERT_WINDOW_ROWS}`)
+            .rest(
+        // `evidence_scope` decide si el grep de refutación significa algo (ver
+        // el comentario del mismo select en guard.ts). `id` y `created_at` no
+        // los lee nadie TODAVÍA: son la identidad de la alerta, que es lo que
+        // 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}`)
             .catch(() => []),
     ]);
-    return { fetched_at: Date.now(), project_id: projectId, rows, deps, alerts };
+    return {
+        v: IMPACT_CACHE_V,
+        fetched_at: Date.now(),
+        project_id: projectId,
+        rows,
+        deps,
+        alerts,
+    };
 }
 /**
  * Las señales, SIEMPRE de disco. Nunca de la red.
@@ -310,7 +796,10 @@ async function atlasSignals(db, dir) {
     if (!file)
         return null;
     const cached = leerJson(file);
-    if (cached && Date.now() - cached.fetched_at < CACHE_TTL_MS)
+    // Una caché de otra versión NO se sirve y además dispara el recalentado, que
+    // es lo mismo que hace una caducada: en las dos, lo que hay en disco no
+    // responde a la pregunta que se está haciendo.
+    if (cacheServible(cached, Date.now()))
         return cached;
     if (db.hasCredentials())
         calentarDesacoplado(dir);
@@ -348,12 +837,32 @@ export async function warmImpactCache(db, dir, env = process.env) {
         const file = await cachePath(dir);
         if (!file)
             return;
+        // El libro de entregas ANTES de la puerta de frescura: si se pusiera
+        // después, una caché todavía fresca haría volver a este proceso por donde
+        // vino y la cola no se vaciaría nunca. El fallo sería invisible —el hook
+        // 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);
         // 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);
-        if (cached && Date.now() - cached.fetched_at < CACHE_TTL_MS)
+        if (cacheServible(cached, Date.now()))
+            return;
+        const fresco = await fetchAtlas(db, dir, env);
+        // Un calentamiento que NO resolvió el proyecto no se cachea.
+        //
+        // Cazado el 2026-07-26 montando el banco de pruebas: `impact --warm` sin
+        // CHANGEBOOK_PROJECT en un directorio cuyo nombre no es el del proyecto
+        // guardaba `{project_id: null, rows: []}`, y `atlasSignals` lo tomaba por
+        // caché válida durante CACHE_TTL_MS. Resultado: cinco minutos de silencio
+        // que se leen EXACTAMENTE igual que "no hay nada que decir" — la clase de
+        // fallo que este producto existe para cazar, dentro del producto.
+        //
+        // Sin cachearlo, el siguiente intento vuelve a preguntar. Cuesta un
+        // calentamiento desacoplado más; callar cinco minutos cuesta el canal.
+        if (!fresco.project_id)
             return;
-        escribirJson(file, await fetchAtlas(db, dir, env));
+        escribirJson(file, fresco);
     }
     catch {
         // Nadie está mirando esta salida; el síntoma de un fallo aquí es que no hay
@@ -417,16 +926,46 @@ async function buildImpact(db, payload) {
     // archivo con muchas alertas vivas podría comerse el presupuesto entero a
     // 30 ms por grep. Tres es lo que cabe de sobra; el resto pasa sin refutar,
     // que es el lado seguro (la duda deja pasar el aviso).
+    //
+    // El presupuesto lo comparten refutar y localizar, porque son el mismo grep
+    // 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;
     const refutada = (a) => {
+        if (a.evidence_expect !== "present")
+            return false;
         if (grepsRestantes <= 0)
             return false;
         grepsRestantes -= 1;
         return avisoRefutado(a, (s) => contarEnRepo(toplevel, s));
     };
+    /** Donde sigue apareciendo el simbolo de un aviso 'absent'. Contesta el condicional. */
+    const localizar = (a) => {
+        if (a.evidence_expect !== "absent")
+            return null;
+        if (grepsRestantes <= 0)
+            return null;
+        grepsRestantes -= 1;
+        return dondeApareceElSimbolo(a, (s) => ficherosEnRepo(toplevel, s));
+    };
     const depsRows = signals.deps ?? [];
-    const bloques = [];
+    // 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,
+    // MIN_PAIR_RATE=0.6, MAX_COUPLINGS=5) y su exclusión de módulos de pruebas.
+    // Se importa de sync.ts en vez de copiarla: es la MISMA pregunta que contesta
+    // el bloque de CLAUDE.md, y dos respuestas distintas al mismo hecho es lo que
+    // enseña al agente a no fiarse de ninguna.
+    const parejas = coChangePairs(signals.rows.filter((r) => typeof r.changelog_id === "string" && r.changelog_id.length > 0));
+    /** Con quién cambia junto un módulo, mirando la pareja por los dos lados. */
+    const coCambiosDe = (modulo) => parejas
+        .filter((p) => p.a === modulo || p.b === modulo)
+        .map((p) => ({ module: p.a === modulo ? p.b : p.a, rate: p.rate }));
+    // 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 = [];
     const avisadas = [];
+    /** Las alertas que de verdad salieron en el texto. Ver el encolado del final. */
+    const idsServidos = [];
     for (const file of pendientes) {
         const modulos = modulosDelArchivo(file, signals.rows);
         if (modulos.length === 0)
@@ -436,25 +975,87 @@ async function buildImpact(db, payload) {
             .map((m) => ({
             module: m.module,
             risk: m.risk,
+            note: m.note,
+            noteDate: m.noteDate,
             dependents: dependientes.get(m.module) ?? [],
-            alerts: abiertas
+            coChanges: coCambiosDe(m.module),
+            // Una linea por texto: dos avisos con la MISMA frase no le dejan al
+            // agente hacer nada distinto, por mucho que por dentro sean
+            // afirmaciones opuestas. Gana el que trae linea de comprobacion.
+            alerts: conIdentidad(unoPorTexto(abiertas
                 .filter((a) => (a.module ?? "").trim() === m.module && a.plain)
                 .filter((a) => !refutada(a))
-                .map((a) => a.plain),
+                .map((a) => {
+                const donde = localizar(a);
+                const fuera = dondeComprobarlo(a);
+                return {
+                    plain: a.plain,
+                    alertIds: a.id ? [a.id] : [],
+                    ...(donde
+                        ? { donde, simbolo: (a.evidence_symbol ?? "").trim() }
+                        : {}),
+                    ...(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)),
             priorRegressions: recidivism.get(m.module) ?? 0,
         }))
-            .filter(valeLaPena);
+            .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
+            // «la prosa gorda expulsaba el mapa» —6 regresiones previas, y el fallo
+            // exacto en el que caí dos veces el 2026-07-26— quedaba en el «+N more».
+            // 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×
+            // en vez de una lectura a 0,1×.
+            .sort((a, b) => b.alerts.length - a.alerts.length ||
+            b.priorRegressions - a.priorRegressions ||
+            b.dependents.length - a.dependents.length ||
+            a.module.localeCompare(b.module));
         if (impactos.length === 0)
             continue;
-        bloques.push(impactText(file, impactos));
+        lineas.push(...lineasDeImpacto(file, impactos));
         avisadas.push(file);
+        for (const m of impactos.slice(0, MAX_MODULES)) {
+            idsServidos.push(...m.alerts.flatMap((a) => a.alertIds));
+        }
     }
     // 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));
     }
-    return bloques.length > 0 ? bloques.join("\n\n") : null;
+    if (lineas.length === 0)
+        return null;
+    // 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);
+    if (!texto)
+        return null;
+    // 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.
+    //
+    // 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), {
+        project_id: signals.project_id,
+        chars_served: texto.length,
+        ...entregaDe({
+            alertIds: idsServidos,
+            files: avisadas,
+            message: texto,
+            headSha: headShaDe(dir),
+            hash: hashDelTexto,
+        }),
+    });
+    return texto;
 }
 /**
  * El comando. Falla abierto SIEMPRE: sin credenciales, sin red, sin proyecto,