changebook 0.4.9 → 0.5.0

package/dist/import.js

@@ -10,7 +10,7 @@
  */
 import * as path from "node:path";
 import { atlasWebUrl } from "./browser.js";
-import { commitDiff, execFileAsync, GIT_MAX_BUFFER_BYTES, gitErrorMessage, MAX_DIFF_CHARACTERS, usableSummary, } from "./git.js";
+import { commitDiff, execFileAsync, GIT_MAX_BUFFER_BYTES, gitErrorMessage, MAX_DIFF_CHARACTERS, projectNameFor, usableSummary, } from "./git.js";
 import { canonicalDiffHash } from "./canonical.js";
 import { optimizeTokensForAI } from "./optimize.js";
 // Under the server's MAX_BATCH_ITEMS (25) to leave headroom.
@@ -29,7 +29,7 @@ const SKIP_FILE_PATTERNS = [
 ];
 export async function importHistory(db, options = {}) {
     const cwd = path.resolve(options.dir ?? process.cwd());
-    const projectName = path.basename(cwd);
+    const projectName = projectNameFor(cwd);
     const count = Math.max(1, Math.min(options.commits ?? 25, 100));
     // A previous run may have been interrupted after submitting: the Anthropic
     // batch keeps running server-side, so finish those before spending more.

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

@@ -285,23 +285,25 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
             ...taskTitles.map((t) => `- ${sanitizeCell(t.slice(0, 120))}`),
         ]
         : [];
-    // El orden de renderizado (legibilidad) y la prioridad de presupuesto
-    // (utilidad para el agente) son independientes: si no cabe todo, caen
-    // primero los últimos cambios y los módulos, nunca las regresiones.
+    // El orden de renderizado (legibilidad) y la prioridad de presupuesto (qué se
+    // recorta primero) son independientes. Los dos importan, y hasta el 2026-07-26
+    // solo uno estaba bien.
+    //
+    // EL RIESGO VA PRIMERO AL LEER, y eso es el cambio. El presupuesto ya
+    // priorizaba las regresiones sobre el mapa, pero el ORDEN DE LECTURA ponía
+    // `### Módulos` en cabeza, así que lo que estaba frágil quedaba debajo de una
+    // lista de quince módulos. Medido ese día con 30 corridas: el bloque empujado
+    // al prompt del agente entrega 0,40 de los hechos de riesgo contra 0,60 de la
+    // tool, y las cinco corridas del brazo con empuje van de 0,4 a 0,6 mientras las
+    // de git puro van de 0 a 0,2. O sea: el canal llega, el agente lo tiene
+    // delante, y no lo usa. La hipótesis que queda es la posición.
+    //
+    // Y `hotspots` sube de prioridad 4 a 1. Con 4 era la penúltima en caer, así que
+    // en un proyecto con muchos módulos se recortaba y los críticos solo aparecían
+    // como un ⚠ inline dentro de la lista del mapa — el sitio exacto donde no se
+    // leen. Los módulos bajan a 3: el mapa se puede pedir con una tool, el riesgo
+    // de hoy no está en ningún sitio más.
     const sections = [
-        { key: 'modules', priority: 2, title: '### Módulos', lines: moduleLines },
-        {
-            key: 'tasks',
-            priority: 1,
-            title: '### Encargos pendientes del dueño (proponte atacarlos)',
-            lines: taskLines,
-        },
-        {
-            key: 'couplings',
-            priority: 3,
-            title: '### Módulos que cambian juntos (si tocas uno, revisa el otro)',
-            lines: couplingLines,
-        },
         {
             key: 'alerts',
             priority: 0,
@@ -316,10 +318,23 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
         },
         {
             key: 'hotspots',
-            priority: 4,
-            title: '### Avisos abiertos (revisar antes de modificar)',
+            priority: 1,
+            title: '### Módulos críticos (frágiles por diseño: revisa antes de modificar)',
             lines: hotspotLines,
         },
+        {
+            key: 'couplings',
+            priority: 2,
+            title: '### Módulos que cambian juntos (si tocas uno, revisa el otro)',
+            lines: couplingLines,
+        },
+        {
+            key: 'tasks',
+            priority: 1,
+            title: '### Encargos pendientes del dueño (proponte atacarlos)',
+            lines: taskLines,
+        },
+        { key: 'modules', priority: 3, title: '### Módulos', lines: moduleLines },
         {
             key: 'changes',
             priority: 5,
@@ -328,21 +343,62 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
         },
     ];
     let budget = SYNC_BUDGET_CHARS - head.join('\n').length - END.length;
+    // ── El suelo del mapa ──────────────────────────────────────────────────────
+    //
+    // El presupuesto es de suma cero, así que poner el riesgo primero se lo come.
+    // Medido el 2026-07-26 al hacerlo: con datos de producción reales (1 regresión,
+    // 1 control en riesgo, 2 módulos críticos, 2 encargos) el mapa cayó de 18
+    // módulos a DOS.
+    //
+    // Y eso no es un detalle estético: el estudio de 76 agentes del 2026-07-20
+    // concluyó que el mapa expulsado era «la causa nº 1 de que el agente ignore o
+    // desconfíe del atlas». Cambiar un fallo medido por otro fallo medido no es una
+    // mejora.
+    //
+    // Así que el reparto deja de ser el-que-llega-primero-se-lo-lleva-todo: se
+    // reserva lo que cuestan las primeras MIN_LINEAS_MAPA líneas del mapa, y solo
+    // el resto se disputa por prioridad. Si el mapa tiene menos líneas que el
+    // suelo, sobra menos reserva; si no hay mapa, no se reserva nada.
+    const MIN_LINEAS_MAPA = 6;
+    const mapa = sections.find((x) => x.key === 'modules');
+    let reservaMapa = 0;
+    if (mapa && mapa.lines.length > 0) {
+        reservaMapa = mapa.title.length + 2;
+        for (const line of mapa.lines.slice(0, MIN_LINEAS_MAPA)) {
+            reservaMapa += line.length + 1;
+        }
+        // Nunca más de un tercio: el suelo protege al mapa, no lo convierte en el
+        // dueño del bloque.
+        reservaMapa = Math.min(reservaMapa, Math.floor(budget / 3));
+        // Se APARTA del fondo común aquí. Sin esto, dárselo luego al mapa como
+        // `budget + reserva` lo contaba dos veces y el bloque se pasaba del tope
+        // (medido: 2.344 de 2.000).
+        budget -= reservaMapa;
+    }
     const includedCount = new Map();
     for (const s of [...sections].sort((a, b) => a.priority - b.priority)) {
         if (s.lines.length === 0)
             continue;
+        // El mapa gasta su reserva ADEMÁS de lo que haya quedado libre.
+        const disponible = s.key === 'modules' ? budget + reservaMapa : budget;
         let cost = s.title.length + 2; // título + línea en blanco separadora
         let count = 0;
         for (const line of s.lines) {
-            if (cost + line.length > budget)
+            if (cost + line.length > disponible)
                 break;
             cost += line.length + 1;
             count += 1;
         }
         if (count > 0) {
             includedCount.set(s.key, count);
-            budget -= cost;
+            if (s.key === 'modules') {
+                // Lo que consumió por encima de su reserva sale del fondo común.
+                budget -= Math.max(0, cost - reservaMapa);
+                reservaMapa = 0;
+            }
+            else {
+                budget -= cost;
+            }
         }
     }
     const lines = [...head];
@@ -371,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) {
@@ -397,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

@@ -7,8 +7,9 @@
 import path from "node:path";
 import { z } from "zod";
 import { execFileAsync } from "./git.js";
-import { avisoRefutado, contarEnRepo, slugifyProject, } from "./guard.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) {
@@ -822,23 +845,67 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
             // evidencia, sin repo o con la búsqueda rota, la alerta pasa; y si el
             // cwd no es el proyecto consultado, no se refuta nada (ver
             // cwdEsElProyecto).
-            const refutada = cwdEsElProyecto(project)
+            const enElProyecto = cwdEsElProyecto(project);
+            const refutada = enElProyecto
                 ? (a) => avisoRefutado(a, (s) => contarEnRepo(process.cwd(), s))
                 : () => false;
-            const alertsByModule = new Map();
+            // La otra mitad, desde el 2026-07-26: un aviso 'absent' cuyo símbolo
+            // SIGUE apareciendo ya no se descarta (era ambiguo y tiraba las dos
+            // alertas que predijeron el desfase de esquema de producción). Se sirve
+            // diciendo dónde aparece, que es contestar el condicional del texto
+            // ("...si los hubiera") en vez de prohibir la redacción.
+            //
+            // Mismas palabras que el hook (impactText) a propósito: dos redacciones
+            // del mismo hecho son dos hechos para el agente.
+            const localizada = enElProyecto
+                ? (a) => dondeApareceElSimbolo(a, (s) => ficherosEnRepo(process.cwd(), s))
+                : () => null;
+            // Se construye la lista ANTES de renderizar para poder dejar una linea
+            // por texto: dos avisos con la misma frase se leen como una repeticion
+            // aunque por dentro sean afirmaciones opuestas, y sobre dos frases
+            // identicas no se puede actuar distinto. Gana el que trae comprobacion.
+            const porModulo = new Map();
             for (const a of alerts) {
                 const m = (a.module ?? "").trim();
                 if (!m || !a.plain)
                     continue;
                 if (refutada(a))
                     continue;
-                alertsByModule.set(m, [...(alertsByModule.get(m) ?? []), a.plain]);
+                const donde = localizada(a);
+                const fuera = dondeComprobarlo(a);
+                let extra = "";
+                if (donde) {
+                    extra +=
+                        `\n    → CHECKED NOW: "${(a.evidence_symbol ?? "").trim()}" still appears in ${donde.join(", ")}` +
+                            ` — alert expects it gone: either a reference was missed, or the alert is stale`;
+                }
+                // El repo no puede contestar esta afirmacion: se dice, en vez de
+                // 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();
+            for (const [m, entradas] of porModulo) {
+                alertsByModule.set(m, unoPorTexto(entradas, (e) => e.plain, (e) => e.extra.length > 0).map((e) => e.plain + e.extra));
             }
             // Reincidencia: nº de problemas de regresión DISTINTOS por módulo
             // (count(distinct plain), all-time), solo los con antecedentes (>= 2).
             // 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.
@@ -885,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.9",
+  "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.9",
+  "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.9",
+      "version": "0.5.0",
       "transport": {
         "type": "stdio"
       }