changebook 0.4.10 → 0.5.0

package/dist/guard.js

@@ -14,8 +14,10 @@
  */
 import * as fs from "node:fs";
 import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { execFileAsync, gitPath, projectNameFor } from "./git.js";
 import { feedWarningFor } from "./feed.js";
+import { avisoDeRamaPara } from "./rama.js";
 /** Exit code that asks the pre-commit hook to abort the commit. */
 export const EXIT_BLOCK = 3;
 // A commit should never feel slow because of us: whatever the network hasn't
@@ -308,7 +310,11 @@ export function dondeApareceElSimbolo(alert, buscarFicheros) {
  */
 export function guardFindings(staged, alerts, filesByModule, refutado, ficherosDelSimbolo) {
     const stagedSet = new Set(staged);
-    const seen = new Set();
+    // Map y no Set: al colapsar dos avisos con el mismo (modulo, texto) hay que
+    // QUEDARSE con los dos ids, no descartar el segundo. Se sirve una linea —dos
+    // frases identicas no dejan actuar distinto— pero se registran las dos
+    // alertas, que es lo que permitira atribuir el veredicto a la que toca.
+    const porClave = new Map();
     const findings = [];
     for (const alert of alerts) {
         const module = (alert.module ?? "").trim();
@@ -332,10 +338,22 @@ export function guardFindings(staged, alerts, filesByModule, refutado, ficherosD
         if (refutado?.(alert))
             continue;
         const key = module + "\u0000" + plain;
-        if (seen.has(key))
+        const id = alert.id ?? null;
+        const ya = porClave.get(key);
+        if (ya) {
+            // El aviso ya se sirve; lo unico que queda por recoger es su identidad.
+            if (id && !ya.alertIds.includes(id))
+                ya.alertIds.push(id);
             continue;
-        seen.add(key);
-        findings.push({ module, plain, staged: touched });
+        }
+        const finding = {
+            module,
+            plain,
+            staged: touched,
+            alertIds: id ? [id] : [],
+        };
+        porClave.set(key, finding);
+        findings.push(finding);
     }
     return findings;
 }
@@ -403,6 +421,16 @@ function grepDelRepo(dir, simbolo, modo) {
             // aviso de tipo "esto sigue usandose" encontraria su propia cita y no
             // podria refutarse jamas. Lo cazo el test, no el diseno.
             ":!*.md",
+            // Y tampoco en el resto de la PROSA, por la misma razon exacta. El
+            // 2026-07-30, usando el producto sobre si mismo, un aviso sobre
+            // `reason` se sirvio diciendo «still appears in privacidad.html,
+            // terminos.html» — la comprobacion encontro la PALABRA en dos paginas
+            // legales y la presento como si hablara del codigo. Un simbolo en un
+            // parrafo no es una referencia: es una coincidencia de idioma.
+            ":!*.html",
+            ":!*.txt",
+            ":!*.csv",
+            ":!*.svg",
             // Con comodín a propósito: un pathspec sin comodín ("docs/") hace
             // abortar a git grep si la carpeta no existe — en cualquier repo de
             // usuario sin docs/ el buscador devolvía null y la refutación moría
@@ -417,6 +445,23 @@ function grepDelRepo(dir, simbolo, modo) {
         return code === 1 ? "" : null;
     }
 }
+/**
+ * LA VERSIÓN DE LA FORMA DE LA CACHÉ. Súbela cuando cambie QUÉ se guarda —las
+ * columnas del select, un campo del que dependa una decisión—, no cuando cambie
+ * el código de alrededor.
+ *
+ * El caso concreto que la trae: el commit anterior añadió `evidence_scope` al
+ * select de las alertas. Sin versión, la caché escrita por el binario de antes
+ * se deserializa sin error y el guardián decide sobre ella cinco minutos más,
+ * con el ámbito ausente — o sea, sin refutar nada. Y no hay forma de notarlo: la
+ * caché vieja no está rota, solo incompleta, así que el guardián se calla en vez
+ * de fallar. Mismo modo de fallo que la caché de `{project_id: null}` que costó
+ * cinco minutos de silencio el 2026-07-26.
+ *
+ * Empieza en 1: una caché SIN `v` es anterior al versionado y se descarta
+ * siempre.
+ */
+const GUARD_CACHE_V = 1;
 export async function stagedFiles(dir) {
     // -z: NUL-separated, and crucially git does NOT octal-quote non-ASCII paths
     // (default quotepath would emit "m\303\263dulo.ts", which never matches the
@@ -425,12 +470,25 @@ export async function stagedFiles(dir) {
     const { stdout } = await execFileAsync("git", ["diff", "--cached", "--name-only", "-z"], { cwd: dir, encoding: "utf8" });
     return stdout.split("\0").filter(Boolean);
 }
+/**
+ * ¿Se puede decidir sobre esta caché? De esta forma Y fresca.
+ *
+ * Otra forma → se trata como si no hubiera caché: se vuelve a consultar. El
+ * guardián ya sabe hacer eso (es el camino en frío), así que descartar no añade
+ * ningún modo de fallo nuevo. Pura y exportada porque lo que evita —decidir
+ * sobre campos que no están— no se ve desde fuera: la caché vieja no está rota.
+ */
+export function cacheDelGuardianServible(cache, ahora) {
+    if (!cache)
+        return false;
+    if (cache.v !== GUARD_CACHE_V)
+        return false;
+    return ahora - cache.fetched_at <= CACHE_TTL_MS;
+}
 function loadCache(file) {
     try {
         const cache = JSON.parse(fs.readFileSync(file, "utf8"));
-        if (Date.now() - cache.fetched_at > CACHE_TTL_MS)
-            return null;
-        return cache;
+        return cacheDelGuardianServible(cache, Date.now()) ? cache : null;
     }
     catch {
         return null;
@@ -461,7 +519,17 @@ async function fetchSignals(db, dir, env) {
     let filesByModule = new Map();
     const projectId = projects[0]?.id ?? null;
     if (projectId) {
-        alerts = await db.rest(`regression_alerts?select=module,plain,created_at,evidence_symbol,evidence_expect,files&project_id=eq.${projectId}&resolved_at=is.null&order=created_at.desc&limit=${MAX_ALERTS}`);
+        alerts = await db.rest(
+        // `evidence_scope` NO es opcional aquí, por mucho que el tipo lo sea: sin
+        // él, `alcanceDelRepo` devuelve "sin_declarar" para TODA alerta y la
+        // refutación de `avisoRefutado` no descarta nada nunca. El campo se
+        // escribe en la base desde el 2026-07-26 y ningún cliente lo pedía; el
+        // comentario de `avisoRefutado` decía que esa rama "disparó 0 veces en
+        // producción", y disparó cero porque el dato no llegaba, no porque el gate
+        // 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}`);
         const modules = [
             ...new Set(alerts.map((a) => (a.module ?? "").trim()).filter(Boolean)),
         ];
@@ -472,6 +540,7 @@ async function fetchSignals(db, dir, env) {
     }
     if (cacheFile) {
         const cache = {
+            v: GUARD_CACHE_V,
             fetched_at: Date.now(),
             project_id: projectId,
             alerts,
@@ -536,6 +605,71 @@ export function findingsMessage(findings, block) {
         : "\nReview or dismiss the alert in your atlas: changebook open\n");
     return lines.join("\n");
 }
+/** Tope de rutas por fila: un registro no puede crecer sin limite por un commit gigante. */
+const MAX_FICHEROS_EN_LA_ENTREGA = 50;
+/**
+ * EL NUCLEO, sin la forma del guardian.
+ *
+ * Existe porque hay DOS canales que sirven avisos —el guardian en el commit y el
+ * hook antes de editar— y el libro tiene que registrar lo mismo en los dos. Si
+ * cada uno armara su fila, el tope de ficheros o el dedup de ids podrian
+ * divergir y "en total" empezaria a significar dos cosas distintas segun el
+ * canal. Un criterio, un sitio.
+ *
+ * `message` es lo que de verdad se sirvio, no un resumen: el hash ata la fila al
+ * texto exacto que se imprimio, y eso es lo que impide reescribir el consejo a
+ * posteriori para que parezca que acerto.
+ */
+export function entregaDe(input) {
+    if (input.message.trim().length === 0)
+        return null;
+    const alertIds = [
+        ...new Set(input.alertIds.filter((id) => typeof id === "string" && id.length > 0)),
+    ];
+    return {
+        advice_hash: input.hash(input.message),
+        alert_ids: alertIds,
+        advice_files: [...new Set(input.files)].slice(0, MAX_FICHEROS_EN_LA_ENTREGA),
+        head_sha: input.headSha,
+    };
+}
+export function entregaDeAviso(findings, message, headSha, hash) {
+    if (findings.length === 0)
+        return null;
+    return entregaDe({
+        // flatMap y no map: un finding puede venir de varias alertas colapsadas por
+        // texto (ver GuardFinding.alertIds). El Set de `entregaDe` quita ademas el
+        // mismo aviso servido por dos rutas, que es otra cosa.
+        alertIds: findings.flatMap((f) => f.alertIds),
+        files: findings.flatMap((f) => f.staged),
+        message,
+        headSha,
+        hash,
+    });
+}
+/** sha256 en hex. Aparte para que `entregaDeAviso` se pueda probar sin crypto. */
+export function hashDelTexto(texto) {
+    return createHash("sha256").update(texto, "utf8").digest("hex");
+}
+/**
+ * El commit en el que esta el repo. `null` si no se puede saber — y ese null se
+ * guarda tal cual: un ancla inventada es peor que ninguna. Repo recien creado
+ * sin commits incluido, que es el caso que devuelve error de verdad.
+ */
+export function headShaDe(dir) {
+    try {
+        const salida = execFileSync("git", ["rev-parse", "HEAD"], {
+            cwd: dir,
+            encoding: "utf8",
+            timeout: 1_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return /^[0-9a-f]{7,40}$/.test(salida) ? salida : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Returns the process exit code. Everything that can go wrong resolves to 0
  * (pass): the guard informs, it does not gatekeep — except when the user
@@ -553,6 +687,13 @@ export async function runGuard(db, dir, env = process.env) {
     const pulse = await feedWarningFor(dir);
     if (pulse)
         console.error(pulse);
+    // ANTES del corte por credenciales a proposito: que tu rama vaya a revertir el
+    // trabajo de otro es un hecho de git, no del atlas. Quien no tenga sesion —o
+    // no tenga cuenta— tambien merece enterarse. Ver rama.ts para el porque de la
+    // señal (solapamiento, no "vas atrasado").
+    const rama = await avisoDeRamaPara(dir);
+    if (rama)
+        console.error(rama);
     if (!db.hasCredentials())
         return 0;
     let staged;
@@ -635,6 +776,9 @@ export async function runGuard(db, dir, env = process.env) {
                 tool: "guard_precommit",
                 source: "guard",
                 chars_served: message.length,
+                // El libro de entregas. Solo viaja cuando de verdad se avisó: una
+                // corrida limpia sigue siendo una fila normal, purgable como siempre.
+                ...(entregaDeAviso(findings, message, headShaDe(dir), hashDelTexto) ?? {}),
             })
                 .catch(() => { }),
             new Promise((resolve) => {

package/dist/impact.js

@@ -42,7 +42,8 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { presupuestoDeTiempo } from "./context.js";
 import { execFileAsync, gitPath, projectNameFor } from "./git.js";
-import { avisoRefutado, contarEnRepo, dondeApareceElSimbolo, dondeComprobarlo, ficherosEnRepo, slugifyProject, unoPorTexto, } from "./guard.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,6 +90,19 @@ 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;
 /**
@@ -162,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?
  *
@@ -181,20 +329,67 @@ 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(`  - ⚠ OPEN ALERT: ${a.plain}`);
+            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.
@@ -207,27 +402,48 @@ export function impactText(file, modules) {
             // 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(`    → CHECKED NOW: "${a.simbolo}" still appears in ${a.donde.join(", ")}` +
-                    ` — alert expects it gone: either a reference was missed, or the alert is stale`);
+                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(`    → NOT CHECKABLE HERE: ${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(`  - Note from last analysis${m.noteDate ? ` (${m.noteDate})` : ""}: ${m.note}`);
+            lines.push({
+                prio: 3,
+                text: `  - Note from last analysis${m.noteDate ? ` (${m.noteDate})` : ""}: ${m.note}`,
+            });
         }
     }
     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 →
@@ -237,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.
@@ -282,9 +506,185 @@ export function modulosDelArchivo(file, rows) {
     }
     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;
@@ -318,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
@@ -336,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,note,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.
@@ -371,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);
@@ -409,10 +837,16 @@ 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.
@@ -515,8 +949,23 @@ async function buildImpact(db, payload) {
         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)
@@ -529,10 +978,11 @@ async function buildImpact(db, payload) {
             note: m.note,
             noteDate: m.noteDate,
             dependents: dependientes.get(m.module) ?? [],
+            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: unoPorTexto(abiertas
+            alerts: conIdentidad(unoPorTexto(abiertas
                 .filter((a) => (a.module ?? "").trim() === m.module && a.plain)
                 .filter((a) => !refutada(a))
                 .map((a) => {
@@ -540,12 +990,16 @@ async function buildImpact(db, payload) {
                 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)),
+            }), (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)
@@ -564,15 +1018,44 @@ async function buildImpact(db, payload) {
             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,

package/dist/rama.js

@@ -0,0 +1,139 @@
+/**
+ * ¿Va tu rama a revertir el trabajo de otro al mergearse?
+ *
+ * Segunda de las tres comprobaciones del vigilante («¿está mi proyecto como yo
+ * creo?»), acordadas el 2026-07-26 eligiéndolas por lo que ya había dolido.
+ *
+ * ── EL INCIDENTE QUE LA PIDE ────────────────────────────────────────────────
+ *
+ * Las PRs #358 y #359 hubo que CERRARLAS en vez de mergearlas: sus ramas venían
+ * de un `main` viejo y mergearlas habría revertido 667 y 856 líneas. Y el
+ * 2026-07-27 pasó otra vez con la #360. Ninguna de las tres avisó de nada — CI
+ * en verde las tres, porque los tests pasan perfectamente sobre un árbol viejo.
+ *
+ * ── LA SEÑAL NO ES "VAS ATRASADO" ───────────────────────────────────────────
+ *
+ * Estar 50 commits por detrás en ficheros que no tocas es inofensivo, y avisar de
+ * eso es el ruido que enseña a ignorar los avisos. Lo que revierte trabajo es el
+ * SOLAPAMIENTO: ficheros que ha tocado tu rama Y que main ha tocado desde que os
+ * separasteis. Ahí tu versión es más vieja y al mergear gana la tuya.
+ *
+ * Es la misma lección del guardián de hoy: no avises por el módulo, avisa por el
+ * fichero.
+ *
+ * ── LO QUE NO HACE ──────────────────────────────────────────────────────────
+ *
+ * No hace `fetch`. Corre en el camino de un commit y una llamada de red ahí es
+ * inaceptable, así que mira el `origin/main` que ya tengas. Si no lo actualizas
+ * nunca, esto avisa de menos — nunca de más, que es el lado correcto para algo
+ * que interrumpe.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+async function git(dir, args) {
+    const { stdout } = await exec("git", args, {
+        cwd: dir,
+        encoding: "utf8",
+        maxBuffer: 16 * 1024 * 1024,
+    });
+    return stdout;
+}
+/** Cuántos ficheros se nombran antes de cortar: es una pista, no un informe. */
+const MAX_FICHEROS = 5;
+/**
+ * El aviso, o cadena vacía. Separado de la parte que habla con git para poder
+ * probarlo sin montar repos: mismo patrón que `guardFindings`.
+ */
+export function avisoDeRamaVieja(estado) {
+    if (!estado || estado.solapan.length === 0)
+        return "";
+    const { rama, base, detras, solapan } = estado;
+    const muestra = solapan.slice(0, MAX_FICHEROS).join(", ");
+    const resto = solapan.length > MAX_FICHEROS
+        ? ` (+${solapan.length - MAX_FICHEROS} más)`
+        : "";
+    return (`⚠ ChangeBook — tu rama "${rama}" está ${detras} commit(s) por detrás de ${base}, ` +
+        `y ${solapan.length} fichero(s) que tocas ya cambiaron ahí: ${muestra}${resto}.\n` +
+        `   Al mergear, tu versión —más vieja— gana y REVIERTE esos cambios. ` +
+        `Las PRs #358 y #359 se cerraron por esto (667 y 856 líneas).\n` +
+        `   Arreglo: git fetch && git rebase ${base}`);
+}
+/** La rama por defecto del remoto, o `origin/main` si no se puede saber. */
+async function baseDelRemoto(dir) {
+    try {
+        const ref = (await git(dir, ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"])).trim();
+        // refs/remotes/origin/main -> origin/main
+        const m = /^refs\/remotes\/(.+)$/.exec(ref);
+        if (m)
+            return m[1];
+    }
+    catch {
+        // Sin origin/HEAD configurado: se prueba el nombre habitual.
+    }
+    return "origin/main";
+}
+/**
+ * Lee el estado de la rama. `null` cuando no aplica o no se puede saber — y esos
+ * casos son la mayoría en repos ajenos, así que fallan en SILENCIO: un guardián
+ * que grita en cada commit de quien no usa ramas se desinstala el primer día.
+ */
+export async function estadoDeRama(dir) {
+    let rama;
+    try {
+        rama = (await git(dir, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+    }
+    catch {
+        return null;
+    }
+    if (!rama || rama === "HEAD")
+        return null; // detached
+    const base = await baseDelRemoto(dir);
+    // Estar EN la rama por defecto no es ir por detrás de nadie.
+    if (base.endsWith(`/${rama}`))
+        return null;
+    let mergeBase;
+    try {
+        mergeBase = (await git(dir, ["merge-base", "HEAD", base])).trim();
+    }
+    catch {
+        return null; // sin remoto, sin esa rama, o repo recién creado
+    }
+    if (!mergeBase)
+        return null;
+    let detras = 0;
+    try {
+        detras = Number((await git(dir, ["rev-list", "--count", `HEAD..${base}`])).trim());
+    }
+    catch {
+        return null;
+    }
+    if (!Number.isFinite(detras) || detras <= 0)
+        return null;
+    // Los dos lados del triángulo, desde el punto de separación.
+    const ficheros = async (desde, hasta) => new Set((await git(dir, ["diff", "--name-only", `${desde}..${hasta}`]))
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean));
+    let mios;
+    let suyos;
+    try {
+        mios = await ficheros(mergeBase, "HEAD");
+        suyos = await ficheros(mergeBase, base);
+    }
+    catch {
+        return null;
+    }
+    const solapan = [...mios].filter((f) => suyos.has(f)).sort();
+    return { rama, base, detras, solapan };
+}
+/** Lo que imprime el guardián. Cadena vacía = nada que decir. */
+export async function avisoDeRamaPara(dir) {
+    try {
+        return avisoDeRamaVieja(await estadoDeRama(dir));
+    }
+    catch {
+        return "";
+    }
+}
+//# sourceMappingURL=rama.js.map

package/dist/sync.js

@@ -427,6 +427,63 @@ const PAIR_SEP = '\u0000';
 // (supabase/functions/mcp/scope.ts): si las dos implementaciones derivan, el
 // mismo repo enseñaría acoplamientos distintos según por dónde entre el
 // agente — y la deriva sería silenciosa.
+/**
+ * Un fichero de pruebas, por convencion de ruta o de nombre.
+ *
+ * Se mira la RUTA y no el `domain` del modulo a proposito: el dominio es prosa
+ * que inventa el modelo, y medido en prod el 2026-07-27 llega con variantes
+ * ("Calidad y pruebas" 215 veces, pero tambien "Testing" 2, "Interfaz" e
+ * "Interfaz de Usuario" por separado). En un proyecto en ingles no funcionaria
+ * nunca. La ruta es un hecho.
+ */
+const ES_FICHERO_DE_PRUEBAS = /(^|\/)(tests?|__tests__|spec)\/|\.(test|spec)\.[A-Za-z0-9]+$/i;
+/**
+ * Cuando un modulo es "casi todo tests", su co-cambio no informa de nada.
+ *
+ * POR QUE 0,8: medido sobre los 65 modulos de AppAtlas el 2026-07-27, el reparto
+ * tiene un hueco limpio y el umbral cae dentro — «Pruebas automatizadas» 93%,
+ * «Verificación manual y de consola» 81%, y el siguiente ya baja a 56%. Y esos
+ * DOS son exactamente los que producian las parejas ruidosas: «Pruebas
+ * automatizadas ↔ Radio de impacto» era, por debajo, `impact.ts ↔
+ * hookDeImpacto.test.ts` — un fichero y su propio test servido como
+ * acoplamiento de producto, 1 de las 5 parejas.
+ *
+ * Ningun modulo llega al 100%, asi que exigir 100% no filtraria nada. Y dos
+ * reglas que se probaron y se cayeron, para que nadie las reintente: por
+ * `domain` (prosa libre) y por PROMISCUIDAD — suena bien y NO discrimina:
+ * «Pruebas automatizadas» tiene 28 socios distintos, MENOS que «Análisis de
+ * cambios» (39).
+ *
+ * ESPEJO EXACTO de supabase/functions/mcp/scope.ts. Paridad en
+ * test/paridadCoCambios.test.ts.
+ */
+const RATIO_MODULO_DE_PRUEBAS = 0.8;
+export function modulosDePruebas(rows) {
+    const porModulo = new Map();
+    for (const r of rows) {
+        const label = (r.module ?? '').trim();
+        if (!label || !Array.isArray(r.files))
+            continue;
+        const set = porModulo.get(label) ?? new Set();
+        for (const f of r.files) {
+            if (typeof f === 'string' && f.trim())
+                set.add(f.trim());
+        }
+        porModulo.set(label, set);
+    }
+    const fuera = new Set();
+    for (const [label, ficheros] of porModulo) {
+        if (ficheros.size === 0)
+            continue;
+        let pruebas = 0;
+        for (const f of ficheros)
+            if (ES_FICHERO_DE_PRUEBAS.test(f))
+                pruebas += 1;
+        if (pruebas / ficheros.size >= RATIO_MODULO_DE_PRUEBAS)
+            fuera.add(label);
+    }
+    return fuera;
+}
 export function coChangePairs(rows) {
     const byAnalysis = new Map();
     for (const r of rows) {
@@ -453,11 +510,16 @@ export function coChangePairs(rows) {
             }
         }
     }
+    // Los modulos de pruebas cambian con lo que sea, por construccion: su pareja
+    // no es un acoplamiento, es la definicion de tener tests.
+    const dePruebas = modulosDePruebas(rows);
     const pairs = [];
     for (const [key, count] of together) {
         if (count < MIN_PAIR_COUNT)
             continue;
         const [a, b] = key.split(PAIR_SEP);
+        if (dePruebas.has(a) || dePruebas.has(b))
+            continue;
         const rate = count / Math.min(appear.get(a) ?? 1, appear.get(b) ?? 1);
         if (rate >= MIN_PAIR_RATE)
             pairs.push({ a, b, rate });

package/dist/tools.js

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { execFileAsync } from "./git.js";
 import { avisoRefutado, contarEnRepo, dondeApareceElSimbolo, dondeComprobarlo, ficherosEnRepo, slugifyProject, unoPorTexto, } from "./guard.js";
 import { SupabaseError } from "./supabase.js";
+import { coChangePairs } from "./sync.js";
 const CHARACTER_LIMIT = 25_000;
 /**
  * El contrato temporal de las respuestas del atlas (benchmark 2026-07-20: el
@@ -778,9 +779,14 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
             for (const f of perFile) {
                 commitsByFile.set(f.file, recentCommitsForFile(f.changelogIds, commitById));
             }
-            const [alerts, watched, recidivismRows, depsRows] = await Promise.all([
+            const [alerts, watched, recidivismRows, depsRows, coChangeRows] = await Promise.all([
                 moduleNames.length
-                    ? db.rest(`regression_alerts?select=module,plain,evidence_symbol,evidence_expect&resolved_at=is.null&module=in.(${encodeURIComponent(quotedInList(moduleNames))})&order=created_at.desc&limit=10` +
+                    ? db.rest(
+                    // Con `evidence_scope`: sin él ni se refuta (alcanceDelRepo dice
+                    // "sin_declarar" siempre) ni se sirve la línea NOT CHECKABLE
+                    // HERE, que es la única forma de que un aviso sobre producción
+                    // no se compruebe con un grep del repo. Ver guard.ts.
+                    `regression_alerts?select=module,plain,evidence_symbol,evidence_expect,evidence_scope,evidence_line&resolved_at=is.null&module=in.(${encodeURIComponent(quotedInList(moduleNames))})&order=created_at.desc&limit=10` +
                         pf)
                     : Promise.resolve([]),
                 // Constantes vigiladas (espejo del hospedado): el valor VIGENTE con
@@ -810,6 +816,23 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                     .rest(`change_module?select=module,deps&deps=not.is.null&order=created_at.desc&limit=${MODULE_GRAPH_WINDOW_ROWS}` +
                     pf)
                     .catch(() => []),
+                // Co-cambio: qué se toca JUNTO en la práctica. Es la otra mitad del
+                // radio de impacto — `deps` es la arista DECLARADA (quién llama a
+                // quién) y esto es la HISTÓRICA (qué acabó cambiando a la vez), que
+                // solo sale del historial y es la señal que menos gente tiene.
+                //
+                // Es una CUARTA consulta y no se disimula. Lo que la hace aceptable es
+                // que entra en el MISMO Promise.all: en paralelo, la latencia de la
+                // tool es la de su consulta más lenta, no la suma — así que el p50
+                // solo sube si esta resulta ser la más lenta de las cuatro. Cuesta
+                // carga de servidor, no espera del agente.
+                //
+                // No se puede reutilizar la del grafo: aquella filtra `deps=not.is
+                // .null` y el co-cambio necesita TODAS las filas de la ventana.
+                db
+                    .rest(`change_module?select=changelog_id,module,files&order=created_at.desc&limit=${MODULE_GRAPH_WINDOW_ROWS}` +
+                    pf)
+                    .catch(() => []),
             ]);
             const watchedByFile = new Map();
             for (const w of watched) {
@@ -860,6 +883,10 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                 // dejar que se compruebe donde no era.
                 if (fuera)
                     extra += `\n    → NOT CHECKABLE HERE: ${fuera}`;
+                // La linea que lo provoco. Mismas palabras que el hook (impactText).
+                if (a.evidence_line) {
+                    extra += `\n    → TRIGGERED BY: ${String(a.evidence_line).trim()}`;
+                }
                 porModulo.set(m, [...(porModulo.get(m) ?? []), { plain: a.plain, extra }]);
             }
             const alertsByModule = new Map();
@@ -871,6 +898,14 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
             // Fuente única compartida (computeRecidivism) — antes 3 copias.
             const recidivismByModule = computeRecidivism(recidivismRows);
             const dependentsByModule = dependentsOf(moduleNames, depsRows);
+            // MISMA función que el bloque de CLAUDE.md y que el hook: una sola
+            // respuesta a "¿con qué cambia junto esto?". Sus umbrales viven en ella
+            // (3 apariciones, 60%, tope 5) y excluye los módulos de pruebas, que
+            // cambian con todo por construcción.
+            const parejas = coChangePairs(coChangeRows);
+            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 }));
             // Ancla temporal: el último commit analizado del proyecto vs el HEAD
             // de este árbol (misma puerta de proyecto que la refutación).
             // Best-effort: el ancla jamás rompe la lectura que ancla.
@@ -917,6 +952,12 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                     if (dependents?.length) {
                         lines.push(`  - ↘ DEPENDS ON THIS: ${dependents.join(", ")} — check these too before you finish`);
                     }
+                    // PALABRA POR PALABRA como el hook (impactText). Dos redacciones del
+                    // mismo hecho son dos hechos para el agente, y aquí importa el doble
+                    // porque el mismo agente ve las dos superficies en la misma sesión.
+                    for (const cc of coCambiosDe(m.module)) {
+                        lines.push(`  - ↔ CHANGES WITH: ${cc.module} (together in ${Math.round(cc.rate * 100)}% of its changes) — check it before you finish`);
+                    }
                 }
                 for (const w of watchedByFile.get(f.file) ?? []) {
                     lines.push(`- Current value: ${w.name} = ${w.value}` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "changebook",
-  "version": "0.4.10",
+  "version": "0.5.0",
   "mcpName": "io.github.raulbr90/changebook",
   "description": "ChangeBook for coding agents: MCP server (product memory for Claude Code/Codex) + CLI to sign in, analyze changes and sync the product map.",
   "type": "module",

package/server.json

@@ -2,7 +2,7 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.raulbr90/changebook",
   "description": "Query your product's living memory: module map + analyzed change history. Read-only MCP tools.",
-  "version": "0.4.10",
+  "version": "0.5.0",
   "websiteUrl": "https://changebook.dev",
   "remotes": [
     {
@@ -15,7 +15,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "changebook",
-      "version": "0.4.10",
+      "version": "0.5.0",
       "transport": {
         "type": "stdio"
       }