changebook 0.4.10 → 0.6.0

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

@@ -97,7 +97,7 @@ export async function fetchBriefSection(db, targetDir) {
     }
     const projectId = /project_id=eq\.([0-9a-f-]+)/.exec(projectFilter)?.[1] ?? null;
     const since = new Date(Date.now() - ALERT_WINDOW_DAYS * 24 * 3600 * 1000).toISOString();
-    const [moduleRows, changes, alerts, pendingTasks, healthRows] = await Promise.all([
+    const [moduleRows, changes, alerts, historial, pendingTasks, healthRows] = await Promise.all([
         db.rest('change_module?select=changelog_id,module,domain,risk,files,note,created_at&order=created_at.desc&limit=500' +
             projectFilter),
         db.rest(`changelog?select=business_impact,created_at&order=created_at.desc&limit=${MAX_CHANGES}` +
@@ -106,6 +106,12 @@ export async function fetchBriefSection(db, targetDir) {
             .rest(`regression_alerts?select=module,plain,created_at&created_at=gte.${since}&resolved_at=is.null&order=created_at.desc&limit=${MAX_ALERTS}` +
             projectFilter)
             .catch(() => []),
+        // HISTORIA de regresiones: todas, sin ventana y sin filtrar por abiertas.
+        // Es lo que sustituye al mapa de modulos en el bloque — ver `hechosCaros`.
+        db
+            .rest('regression_alerts?select=module,plain,created_at,changelog_id&order=created_at.desc&limit=500' +
+            projectFilter)
+            .catch(() => []),
         projectResolved && projectId
             ? db
                 .callRpc('list_agent_tasks', {
@@ -121,7 +127,27 @@ export async function fetchBriefSection(db, targetDir) {
             .catch(() => []),
     ]);
     const health = summarizeHealth(healthRows);
-    const section = buildSection(moduleRows, changes, alerts, projectName, pendingTasks, health.at_risk);
+    // El commit de cada regresion, para poder citarlo. Una consulta mas, y solo
+    // por los analisis que de verdad rompieron algo: es la diferencia entre «este
+    // modulo ha roto 3 veces» y «este modulo ha roto 3 veces, aqui, aqui y aqui».
+    // Sin el hash, la frase es una etiqueta; con el, es algo que se puede ir a
+    // mirar. El sync corre UNA vez por sesion, asi que la ronda extra se paga una
+    // vez y no por edicion.
+    const idsDeRegresion = [
+        ...new Set(historial.map((h) => h.changelog_id).filter((x) => Boolean(x))),
+    ].slice(0, 60);
+    const commitPorAnalisis = new Map();
+    if (idsDeRegresion.length > 0) {
+        const filas = await db
+            .rest(`changelog?select=id,commit_hash&id=in.(${idsDeRegresion.join(',')})` +
+            projectFilter)
+            .catch(() => []);
+        for (const f of filas) {
+            if (f.commit_hash)
+                commitPorAnalisis.set(f.id, f.commit_hash.slice(0, 7));
+        }
+    }
+    const section = buildSection(moduleRows, changes, alerts, projectName, pendingTasks, health.at_risk, historial, commitPorAnalisis);
     return { section, projectId, projectResolved };
 }
 export async function syncContextFiles(db, targetDir, opts = {}) {
@@ -146,7 +172,67 @@ export async function syncContextFiles(db, targetDir, opts = {}) {
     }
 }
 /** Exported for tests. */
-export function buildSection(rows, changes, alerts = [], projectName, pendingTasks = [], atRiskHealth = []) {
+/**
+ * LO QUE YA COSTO CARO AQUI: modulos que han roto algo, con fecha y commit.
+ *
+ * ── POR QUE ESTO Y NO EL MAPA DE MODULOS ────────────────────────────────────
+ *
+ * La documentacion de Claude Code lo dice de su propio `/doctor`: recorta del
+ * CLAUDE.md «directory layouts, dependency lists, and architecture overviews»
+ * y conserva «pitfalls, rationale, and conventions that differ from tool
+ * defaults». La lista de modulos con su dominio es DERIVABLE: el agente la saca
+ * leyendo el repo, y la herramienta la recorta por su cuenta.
+ *
+ * Esto no. Que un modulo haya roto tres veces sale del HISTORIAL, no del
+ * codigo: ni un grep ni un glob pueden encontrarlo, y es exactamente la
+ * categoria que /doctor conserva.
+ *
+ * ── DOS DECISIONES QUE PARECEN DETALLES ─────────────────────────────────────
+ *
+ * FECHA Y HASH POR ENTRADA, NUNCA EN LA CABECERA. Una fecha en la cabecera
+ * cambiaria a diario e invalidaria el prefijo de prompt-cache de TODO el
+ * fichero en cada sesion. Por entrada no: una linea que no cambia no invalida
+ * nada, y `upsertSection` sigue devolviendo `unchanged` cuando no ha pasado
+ * nada, asi que hechos con fecha no producen churn diario en `git status`.
+ *
+ * SE CUENTAN PROBLEMAS DISTINTOS, no filas. Mismo criterio que
+ * `computeRecidivism`: la misma regresion re-levantada tres veces es UNA, y
+ * contarla tres veces convertiria el churn del generador en falsa gravedad.
+ */
+export function hechosCaros(historial, commitPorAnalisis, tope = 6) {
+    const porModulo = new Map();
+    for (const h of historial) {
+        const modulo = (h.module ?? '').trim();
+        const texto = (h.plain ?? '').trim();
+        if (!modulo || !texto)
+            continue;
+        const entrada = porModulo.get(modulo) ?? { textos: new Set(), citas: [] };
+        if (!entrada.textos.has(texto)) {
+            entrada.textos.add(texto);
+            entrada.citas.push({
+                fecha: h.created_at.slice(5, 10).split('-').reverse().join('/'),
+                commit: h.changelog_id
+                    ? (commitPorAnalisis.get(h.changelog_id) ?? null)
+                    : null,
+            });
+        }
+        porModulo.set(modulo, entrada);
+    }
+    return [...porModulo.entries()]
+        .sort((a, b) => b[1].textos.size - a[1].textos.size || a[0].localeCompare(b[0]))
+        .slice(0, tope)
+        .map(([modulo, { textos, citas }]) => {
+        const n = textos.size;
+        // Tres citas como mucho: la linea es una pista para ir a mirar, no un
+        // informe. Con mas, la seccion se come el presupuesto del bloque.
+        const cuando = citas
+            .slice(0, 3)
+            .map((c) => (c.commit ? `${c.fecha} \`${c.commit}\`` : c.fecha))
+            .join(', ');
+        return `- **${modulo}**: ${n} regresi${n === 1 ? 'ón' : 'ones'}${cuando ? ` (${cuando})` : ''}`;
+    });
+}
+export function buildSection(rows, changes, alerts = [], projectName, pendingTasks = [], atRiskHealth = [], historial = [], commitPorAnalisis = new Map()) {
     // Newest-first rows: the first occurrence of a module is its latest state.
     const seen = new Map();
     for (const row of rows) {
@@ -210,7 +296,7 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
         // disparador abstracto: hay que nombrar sus verbos.
         'Disparador → tool: orientarte → `atlas_project_brief` (`intent:"orient"`) · antes de editar/cambiar/arreglar/refactorizar un archivo o función → `atlas_file_context` (dice QUIÉN DEPENDE de eso) · riesgos/acoplamientos → el brief. Tras cada commit: `atlas_record_change` (diff, hash, fecha, `summary` tuyo; reenviar es gratis).',
         '',
-        'Tools diferidas, en UNA llamada: ToolSearch `select:mcp__changebook__atlas_project_brief,mcp__changebook__atlas_file_context,mcp__changebook__atlas_symbol_lookup`.',
+        'Tools diferidas, en UNA llamada: ToolSearch `select:mcp__changebook__atlas_project_brief,mcp__changebook__atlas_file_context`.',
         '',
         // Proyecto + conducta en UNA línea: cada char de cabecera expulsa mapa.
         //
@@ -334,7 +420,18 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
             title: '### Encargos pendientes del dueño (proponte atacarlos)',
             lines: taskLines,
         },
-        { key: 'modules', priority: 3, title: '### Módulos', lines: moduleLines },
+        {
+            key: 'costoso',
+            priority: 1,
+            title: '### Lo que ya costó caro aquí (revisa antes de tocarlo)',
+            lines: hechosCaros(historial, commitPorAnalisis),
+        },
+        // El mapa baja de 3 a 4, y no es una degradación caprichosa: `/doctor` de
+        // Claude Code recorta por su cuenta «architecture overviews» de un
+        // CLAUDE.md porque el agente los deriva del repo. Lo que no puede derivar
+        // es qué ha roto antes. Se conserva la sección —quitarla del todo cambia
+        // más de lo necesario— pero deja de competir con los hechos.
+        { key: 'modules', priority: 4, title: '### Módulos', lines: moduleLines },
         {
             key: 'changes',
             priority: 5,
@@ -359,8 +456,17 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
     // 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');
+    // EL SUELO CAMBIA DE DUEÑO. Lo tenía el mapa porque el estudio de 76 agentes
+    // del 2026-07-20 concluyó que un mapa expulsado era «la causa nº 1 de que el
+    // agente ignore o desconfíe del atlas». Sigue siendo cierto, pero el mapa ya
+    // no es lo irreemplazable: el agente lo deriva leyendo el repo, y la propia
+    // herramienta lo recorta. Lo que nadie puede derivar es qué rompió antes, así
+    // que el suelo protege ahora eso.
+    //
+    // Y baja de 6 líneas a 3: son entradas mucho más densas —un módulo, un
+    // número y hasta tres commits— así que tres ya dicen dónde pisar con cuidado.
+    const MIN_LINEAS_MAPA = 3;
+    const mapa = sections.find((x) => x.key === 'costoso');
     let reservaMapa = 0;
     if (mapa && mapa.lines.length > 0) {
         reservaMapa = mapa.title.length + 2;
@@ -380,7 +486,7 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
         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;
+        const disponible = s.key === 'costoso' ? 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) {
@@ -391,8 +497,14 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
         }
         if (count > 0) {
             includedCount.set(s.key, count);
-            if (s.key === 'modules') {
+            if (s.key === 'costoso') {
                 // Lo que consumió por encima de su reserva sale del fondo común.
+                //
+                // La clave tiene que ser la MISMA que la de arriba: al mover el suelo
+                // del mapa a los hechos se me quedó aquí `modules`, así que la sección
+                // nueva gastaba la reserva Y descontaba su coste entero del fondo —
+                // doble gasto— y el mapa se llevaba luego una reserva ya usada. El
+                // bloque no reventaba el techo por casualidad, no por diseño.
                 budget -= Math.max(0, cost - reservaMapa);
                 reservaMapa = 0;
             }
@@ -427,6 +539,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 +622,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
@@ -280,76 +281,6 @@ export async function derivaContraHead(dir, hash) {
 }
 // ── Registration ──────────────────────────────────────────────────────────────
 export function registerTools(server, db) {
-    // Espejo del hospedado (T3 del benchmark 2026-07-20): definiciones
-    // exportadas por archivo, sin grep. Usos y tests siguen fuera y se dice.
-    server.registerTool("atlas_symbol_lookup", {
-        title: "Where is this symbol defined?",
-        description: `Files where an exported symbol (function/class/const/interface/type/enum) is DEFINED, with its kind and the commit that last touched it. Mechanical index built from every ingested diff.
-
-Definitions only — usages and tests are not indexed; grep for those. Exact match first, substring fallback.
-
-Args:
-  - symbol (required): the identifier to look up.
-  - project (recommended): the repo you are working in (folder name or slug).
-
-Returns (structured): { symbol, exact_match, matches: [{ symbol, file, kind, commit }] }`,
-        inputSchema: {
-            symbol: z
-                .string()
-                .min(2)
-                .max(120)
-                .describe("Identifier to look up (exported definition)"),
-            project: z
-                .string()
-                .min(1)
-                .max(120)
-                .describe("Project to scope to (repo folder name or slug)"),
-        },
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, async ({ symbol, project }) => {
-        try {
-            const t0 = Date.now();
-            const pf = await db.projectFilterFor(project);
-            const base = `symbol_index?select=symbol,file,kind,commit_hash&order=symbol.asc&limit=20` +
-                pf;
-            let matches = await db.rest(`${base}&symbol=eq.${encodeURIComponent(symbol)}`);
-            let exact = true;
-            if (matches.length === 0) {
-                exact = false;
-                matches = await db.rest(`${base}&symbol=ilike.${ilikePattern(symbol)}`);
-            }
-            const lines = [`# Symbol lookup: ${symbol}`, ""];
-            if (matches.length === 0) {
-                lines.push("Not in the index. It may be unexported, renamed, or defined before the index existed — fall back to grep and SAY you did, instead of guessing.");
-            }
-            for (const m of matches) {
-                lines.push(`- ${m.symbol} (${m.kind}) — ${m.file}${m.commit_hash ? ` · commit ${m.commit_hash.slice(0, 7)}` : ""}`);
-            }
-            if (matches.length > 0) {
-                lines.push("", "Definitions only — usages and tests are not indexed; grep for those.");
-            }
-            const salida = toolResult(lines.join("\n"), {
-                symbol,
-                exact_match: exact,
-                matches: matches.map((m) => ({
-                    symbol: m.symbol,
-                    file: m.file,
-                    kind: m.kind,
-                    commit: m.commit_hash?.slice(0, 7) ?? null,
-                })),
-            });
-            recordRead(db, "atlas_symbol_lookup", pf, servedCharsOf(salida), Date.now() - t0);
-            return salida;
-        }
-        catch (error) {
-            return errorResult(error);
-        }
-    });
     server.registerTool("atlas_recent_changes", {
         title: "Recent ChangeBook changes",
         description: `List the most recent analyzed code changes from the ChangeBook changelog (newest first).
@@ -778,9 +709,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 +746,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 +813,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 +828,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 +882,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.6.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.6.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.6.0",
       "transport": {
         "type": "stdio"
       }