changebook 0.4.8 → 0.4.10

package/dist/index.js

@@ -21,7 +21,8 @@ import { runGuard } from "./guard.js";
 import { hookStatus, installHook, uninstallHook } from "./hook.js";
 import { importHistory } from "./import.js";
 import { registerAgents } from "./init.js";
-import { contextHookInstalled, installContextHook, printContext, uninstallContextHook, } from "./context.js";
+import { contextHookInstalled, installContextHook, installSettingsHook, printContext, settingsHookInstalled, uninstallContextHook, uninstallSettingsHook, } from "./context.js";
+import { IMPACT_HOOK, printImpact, warmImpactCache } from "./impact.js";
 import { login } from "./login.js";
 import { AUTH_HELP, Supabase } from "./supabase.js";
 import { syncContextFiles } from "./sync.js";
@@ -52,6 +53,12 @@ Usage:
   changebook hook-context install|uninstall|status [dir]
                           Push the atlas into EVERY Claude Code session at turn 0
                           via a SessionStart hook in .claude/settings.json
+  changebook impact         Print the blast radius of the file a PreToolUse hook
+                          payload (on stdin) is about to edit
+  changebook hook-impact install|uninstall|status [dir]
+                          Tell the agent who depends on a file BEFORE it edits it,
+                          via a PreToolUse hook in .claude/settings.json. Never
+                          blocks an edit; silent when there is nothing to say
   changebook init [dir]     login + register MCP in every agent found + hook + sync
   changebook open           Open the web atlas in the browser
   changebook serve          Run the MCP server on stdio (default with no arguments)
@@ -246,6 +253,43 @@ async function main() {
             }
             return;
         }
+        case "impact": {
+            // --warm es el lado DESACOPLADO, el que sí toca la red: lo lanza el propio
+            // hook en un proceso aparte cuando encuentra la caché fría. No lee stdin y
+            // no escribe en stdout (ver calentarDesacoplado: su salida iría a la
+            // tubería que Claude Code lee como respuesta del hook).
+            if (arg === "--warm") {
+                await warmImpactCache(new Supabase(), process.argv[4] ?? process.cwd());
+                return;
+            }
+            // Camino crítico de CADA edición: como `context`, jamás requireCredentials
+            // (saldría con 1) y jamás help. printImpact falla abierto — sin sesión,
+            // sin caché o lento, cero salida y exit 0. Y nunca sale con 2, que es el
+            // código con el que Claude Code BLOQUEA la edición.
+            await printImpact(new Supabase());
+            return;
+        }
+        case "hook-impact": {
+            const dir = process.argv[4] ?? process.cwd();
+            if (arg === "install") {
+                const r = installSettingsHook(dir, IMPACT_HOOK);
+                console.error(r === "installed"
+                    ? `✓ PreToolUse hook installed (${dir}/.claude/settings.json). Before every edit, the agent now gets told who depends on the file it is about to touch.`
+                    : "PreToolUse hook already installed.");
+            }
+            else if (arg === "uninstall") {
+                const r = uninstallSettingsHook(dir, IMPACT_HOOK);
+                console.error(r === "removed"
+                    ? "✓ PreToolUse hook removed."
+                    : "No ChangeBook PreToolUse hook found.");
+            }
+            else {
+                console.error(settingsHookInstalled(dir, IMPACT_HOOK)
+                    ? `✓ ChangeBook PreToolUse hook installed (${dir}/.claude/settings.json).`
+                    : "✗ No ChangeBook PreToolUse hook. Install with: changebook hook-impact install");
+            }
+            return;
+        }
         case "init": {
             let db = new Supabase();
             if (!db.hasCredentials()) {
@@ -272,6 +316,15 @@ async function main() {
                 console.error("\nOptional: push the atlas into EVERY Claude Code session at turn 0 " +
                     "(no tool call needed, never stale):\n  changebook hook-context install");
             }
+            // El segundo canal se ofrece aparte porque responde a otra pregunta. El
+            // primero da el mapa al abrir; este avisa de a quién te llevas por delante
+            // justo antes de escribir, que es lo que hace falta cuando nadie pregunta
+            // nada. Se ofrece, NUNCA se instala en silencio: mismo motivo que el otro,
+            // .claude/settings.json se commitea y se comparte.
+            if (!settingsHookInstalled(dir, IMPACT_HOOK)) {
+                console.error("\nOptional: before every edit, tell the agent who depends on the file " +
+                    "it is about to touch:\n  changebook hook-impact install");
+            }
             console.error(`✓ Ready. Ask your agent about the atlas, or open ${atlasWebUrl()}`);
             return;
         }

package/dist/login.js

@@ -15,6 +15,38 @@ import * as http from "node:http";
 import { atlasWebUrl, openInBrowser } from "./browser.js";
 import { credentialsPath, saveCredentials } from "./credentials.js";
 const LOGIN_TIMEOUT_MS = 5 * 60_000;
+const SUPABASE_URL = process.env.CHANGEBOOK_SUPABASE_URL ??
+    "https://oyosihxkecspjkiligga.supabase.co";
+const ANON_KEY = process.env.CHANGEBOOK_SUPABASE_ANON_KEY ??
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im95b3NpaHhrZWNzcGpraWxpZ2dhIiwicm9sZSI6ImFub24iLCJpYXQiOjE3ODMwMDYyNTUsImV4cCI6MjA5ODU4MjI1NX0.TU-UK1DToHmLHp9q7QEQ5eAa7V3sq3HtgCxPEa-DvDE";
+/**
+ * Canjea un codigo de un solo uso por una sesion PROPIA de este CLI.
+ *
+ * Espejo de `exchangeTokenHash` de la extension (src/auth/supabaseAuth.ts), que
+ * lleva usando este camino desde que se diagnostico el problema. El backend
+ * acuña el codigo con `generateLink({type:"magiclink"})` en la funcion
+ * editor-handoff — no se manda ningun correo — y aqui se cambia por tokens que
+ * no comparte nadie mas.
+ */
+async function canjearTokenHash(tokenHash) {
+    const res = await fetch(`${SUPABASE_URL}/auth/v1/verify`, {
+        method: "POST",
+        headers: { apikey: ANON_KEY, "Content-Type": "application/json" },
+        body: JSON.stringify({ type: "magiclink", token_hash: tokenHash }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok) {
+        throw new Error(`No se pudo canjear el codigo de acceso (${res.status}). Vuelve a intentarlo.`);
+    }
+    const data = (await res.json());
+    if (!data.refresh_token) {
+        throw new Error("El canje no devolvio una sesion utilizable.");
+    }
+    return {
+        access_token: data.access_token ?? undefined,
+        refresh_token: data.refresh_token,
+    };
+}
 const CALLBACK_PAGE = `<!DOCTYPE html>
 <html><head><meta charset="utf-8"><title>ChangeBook</title></head>
 <body style="font-family: sans-serif; max-width: 480px; margin: 80px auto; text-align: center;">
@@ -22,6 +54,7 @@ const CALLBACK_PAGE = `<!DOCTYPE html>
 <script>
   const params = new URLSearchParams(window.location.hash.slice(1));
   const payload = {
+    token_hash: params.get("token_hash"),
     access_token: params.get("access_token"),
     refresh_token: params.get("refresh_token"),
     state: params.get("state"),
@@ -62,6 +95,28 @@ export async function login() {
                             res.end();
                             return;
                         }
+                        // VIA PREFERIDA: un codigo de un solo uso que se canjea por una
+                        // sesion PROPIA de este CLI. La via heredada —recibir los tokens
+                        // vivos de la pestana web— entrega a dos clientes el MISMO refresh
+                        // token rotatorio, y Supabase revoca la familia entera en cuanto uno
+                        // de los dos lo rota. Como el navegador refresca solo en segundo
+                        // plano, siempre gana el, y la sesion del CLI moria ~30 min despues
+                        // de cada login, con reloj. La extension ya usaba este camino desde
+                        // que se diagnostico; al CLI no se le habia traido.
+                        if (data.token_hash) {
+                            canjearTokenHash(data.token_hash).then((sesion) => {
+                                res.writeHead(200, { "Content-Type": "application/json" });
+                                res.end('{"ok":true}');
+                                server.close();
+                                resolve(sesion);
+                            }, (err) => {
+                                res.writeHead(400);
+                                res.end();
+                                server.close();
+                                reject(err);
+                            });
+                            return;
+                        }
                         if (!data.refresh_token) {
                             res.writeHead(400);
                             res.end();
@@ -93,7 +148,12 @@ export async function login() {
                 reject(new Error("Could not open a loopback port."));
                 return;
             }
-            const url = `${atlasWebUrl()}/?connect=cli&port=${address.port}&state=${state}`;
+            // `th=1` anuncia que este CLI sabe canjear un token_hash. La web solo lo
+            // manda si lo ve: sin la marca, un CLI antiguo recibiria un codigo que no
+            // entiende y el login fallaria sin explicacion. Arreglar un fallo de
+            // sesion rompiendo el login de quien no ha actualizado no seria arreglar
+            // nada.
+            const url = `${atlasWebUrl()}/?connect=cli&port=${address.port}&state=${state}&th=1`;
             console.error("Opening your browser to sign in to ChangeBook…");
             console.error(`If it doesn't open, visit:\n\n  ${url}\n`);
             openInBrowser(url);

package/dist/supabase.js

@@ -5,7 +5,7 @@
  * every query to the signed-in user. Refreshes the access token with the
  * refresh token when needed (refresh does not require a captcha).
  */
-import { loadCredentials, saveCredentials, withCredentialsLock, } from './credentials.js';
+import { clearRefreshInFlight, credentialsPath, loadCredentials, markRefreshInFlight, readRefreshInFlight, saveCredentials, withCredentialsLock, } from './credentials.js';
 import { slugifyProject } from './guard.js';
 // Public defaults — the anon key is the same public key the web app ships.
 const DEFAULT_URL = 'https://oyosihxkecspjkiligga.supabase.co';
@@ -335,10 +335,30 @@ export class Supabase {
             return;
         }
         this.refreshToken = plan.refresh_token;
+        // Una renovacion anterior que quedo a medias: la dejo escrita ANTES de que
+        // esta salga, para no confundirla con la mia.
+        const aMedias = this.persistRotation ? readRefreshInFlight() : null;
+        // Supabase rota el token AL RECIBIR la peticion, asi que desde esta linea y
+        // hasta que se guarde el nuevo, el token del disco esta muerto sin que nadie
+        // lo sepa. Dejar constancia no evita que maten al proceso en esa ventana
+        // —el analyze post-commit corre desacoplado— pero convierte el sintoma de
+        // dentro de media hora en algo explicable.
+        if (this.persistRotation)
+            markRefreshInFlight();
         const res = await this.refreshOnce(this.refreshToken);
         if (!res.ok) {
             const body = (await res.text()).slice(0, 300);
-            throw new SupabaseError(`Could not refresh the ChangeBook session (${res.status}): ${body}\n\n${AUTH_HELP}`, res.status);
+            // El token esta gastado o muerto de todos modos: la marca ya no sirve.
+            if (this.persistRotation)
+                clearRefreshInFlight();
+            const yaUsado = /already[ _]used|refresh[ _]token[ _]not[ _]valid/i.test(body);
+            const explicacion = yaUsado && aMedias
+                ? `\n\nQUE PASO: una renovacion anterior empezo el ${aMedias.at} (proceso ${aMedias.pid}) y no llego a terminar. ` +
+                    `El servidor rotó el token al recibirla, pero este equipo no guardó el nuevo — normalmente porque mataron al proceso ` +
+                    `(el analisis post-commit corre en segundo plano). Al reintentar con el viejo, Supabase lo toma por robado y cierra la sesion. ` +
+                    `No has hecho nada mal y no hay nada que reparar: basta con volver a entrar.`
+                : '';
+            throw new SupabaseError(`Could not refresh the ChangeBook session (${res.status}): ${body}${explicacion}\n\n${AUTH_HELP}`, res.status);
         }
         const data = (await res.json());
         this.accessToken = data.access_token;
@@ -352,9 +372,33 @@ export class Supabase {
                     refresh_token: this.refreshToken,
                     access_token: this.accessToken,
                 });
+                // Guardado: la ventana peligrosa se ha cerrado. Se retira la marca
+                // DESPUES de escribir, no antes — al reves dejaria un hueco en el que
+                // ni hay marca ni hay token nuevo, que es justo el estado que la marca
+                // existe para poder contar.
+                clearRefreshInFlight();
             }
-            catch {
-                // Non-fatal: the in-memory session still works for this process.
+            catch (err) {
+                // NO es inofensivo, aunque lo parezca desde aquí.
+                //
+                // Este proceso sigue funcionando con su sesion en memoria, y por eso el
+                // codigo anterior se lo tragaba en silencio. Pero el token rotado se ha
+                // perdido: Supabase ya invalido el viejo, asi que el SIGUIENTE proceso
+                // leera del disco un token gastado, lo reenviara, y la deteccion de
+                // reutilizacion revocara la sesion entera. El sintoma aparece minutos u
+                // horas despues, sin ninguna relacion visible con este fallo de
+                // escritura — que es lo que lo hacia indiagnosticable.
+                //
+                // Firma en los logs de auth del 2026-07-25: un refresco con 200 a las
+                // 06:51:54 y, diez minutos mas tarde y sin nada en medio, un 400
+                // "Possible abuse attempt". Es exactamente lo que deja este camino.
+                //
+                // No se lanza: tumbar la orden en curso castigaria al usuario por algo
+                // que todavia funciona. Se avisa, alto y con el arreglo puesto.
+                const motivo = err instanceof Error ? err.message : String(err);
+                console.error(`ChangeBook: no se pudo guardar la sesion renovada en ${credentialsPath()} (${motivo}).\n` +
+                    `Esta orden termina bien, pero la siguiente reutilizara un token ya gastado y la sesion se cerrara sola.\n` +
+                    `Comprueba los permisos de ese fichero y vuelve a entrar con:  changebook login`);
             }
         }
     }

package/dist/sync.js

@@ -200,12 +200,27 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
         // la tool solo cubre definiciones y el agente acababa pagando atlas Y
         // grep. Con repo local, grep gana; el sitio de symbol_lookup es el agente
         // hospedado sin repo. Medir → actuar, aunque sea des-haciendo lo de ayer.
-        'Disparador → tool: orientarte → `atlas_project_brief` (`intent:"orient"`) · editar un archivo → `atlas_file_context` con su ruta · riesgos/acoplamientos → el brief. Tras cada commit: `atlas_record_change` (diff, hash, fecha, `summary` tuyo; reenviar es gratis).',
+        // Los VERBOS son literales a propósito. La ley medida el 2026-07-21 fue que
+        // la adopción es coincidencia LITERAL (los disparadores literales la movieron
+        // de 60/100/0 a 100/100/60), y el 2026-07-26 se comprobó el otro lado de la
+        // misma ley: T4 pidió «vas a cambiar el comportamiento de la función X» y el
+        // agente, con el atlas disponible, fue directo a grep — 32 turnos, 1,46M
+        // tokens y CERO llamadas al atlas. «editar un archivo» no casaba con cómo
+        // habla quien programa con un agente. Quien no pregunta nada no reconoce un
+        // 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`.',
         '',
         // Proyecto + conducta en UNA línea: cada char de cabecera expulsa mapa.
-        `${projectName ? `Pasa SIEMPRE \`project: "${sanitizeCell(projectName)}"\`. ` : ''}Anuncia antes de atacar un encargo, y DILE al usuario los riesgos que el atlas te enseñe — él no los ve.`,
+        //
+        // «Anuncia» pasó a «di qué harías y ESPERA su OK» el 2026-07-26, a petición
+        // de Raúl y con razón: anunciar y ponerse a trabajar en el mismo turno no le
+        // deja decidir nada. Y valía para «un encargo», o sea solo para la cola;
+        // ahora vale al abrir, que es cuando el agente elige por su cuenta qué mirar
+        // y qué tocar. Lo que se gasta aquí se recupera en la línea de la cola, que
+        // decía esto mismo por segunda vez.
+        `${projectName ? `Pasa SIEMPRE \`project: "${sanitizeCell(projectName)}"\`. ` : ''}Al abrir: di en 2 líneas qué harías y por qué, y ESPERA su OK antes de tocar código. DILE los riesgos que el atlas te enseñe — él no los ve.`,
         '',
     ];
     if (modules.length === 0) {
@@ -266,27 +281,29 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
     ].slice(0, 3);
     const taskLines = taskTitles.length > 0
         ? [
-            `- Hay ${pendingTasks.length} encargo(s) pendientes en la cola de este proyecto. Al empezar, propón al usuario cuál atacarías y por qué, y espera su OK antes de tocar código. Cola viva: \`atlas_pending_tasks\`; cierra con \`atlas_complete_task\`.`,
+            `- Hay ${pendingTasks.length} encargo(s) pendientes en la cola de este proyecto. Propón cuál atacarías. Cola viva: \`atlas_pending_tasks\`; cierra con \`atlas_complete_task\`.`,
             ...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,
@@ -301,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,
@@ -313,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];

package/dist/tools.js

@@ -7,7 +7,7 @@
 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";
 const CHARACTER_LIMIT = 25_000;
 /**
@@ -96,6 +96,49 @@ export function quotedInList(values) {
         .join(",");
 }
 export const FILES_CAP = 8;
+const MAX_DEPENDENTS = 6;
+/** Espejo de MODULE_COUNT_WINDOW_ROWS (supabase/functions/mcp/scope.ts).
+ *  El mapa de la web dibuja las flechas sobre esta misma ventana: dos
+ *  ventanas distintas darían dependencias distintas según se mire el dibujo
+ *  o se pregunte al atlas. Paridad fijada en test/radioDeImpacto. */
+const MODULE_GRAPH_WINDOW_ROWS = 1000;
+export function dependentsOf(targets, rows) {
+    const graph = new Map();
+    for (const r of rows) {
+        const label = (r.module ?? "").trim();
+        if (!label || graph.has(label.toLowerCase()))
+            continue;
+        const deps = Array.isArray(r.deps)
+            ? r.deps.map((d) => (typeof d === "string" ? d.trim() : "")).filter(Boolean)
+            : [];
+        graph.set(label.toLowerCase(), deps);
+    }
+    const reverse = new Map();
+    for (const r of rows) {
+        const from = (r.module ?? "").trim();
+        if (!from)
+            continue;
+        for (const to of graph.get(from.toLowerCase()) ?? []) {
+            const key = to.toLowerCase();
+            if (key === from.toLowerCase())
+                continue;
+            const set = reverse.get(key) ?? new Set();
+            set.add(from);
+            reverse.set(key, set);
+        }
+    }
+    const out = new Map();
+    for (const t of targets) {
+        const label = (t ?? "").trim();
+        if (!label)
+            continue;
+        const found = reverse.get(label.toLowerCase());
+        if (!found || found.size === 0)
+            continue;
+        out.set(label, [...found].sort((a, b) => a.localeCompare(b)).slice(0, MAX_DEPENDENTS));
+    }
+    return out;
+}
 /**
  * Reincidencia (espejo de supabase/functions/mcp/scope.ts::computeRecidivism —
  * paridad en test/reincidenciaFileContext). Por módulo, nº de problemas de
@@ -735,7 +778,7 @@ 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] = await Promise.all([
+            const [alerts, watched, recidivismRows, depsRows] = 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` +
                         pf)
@@ -759,6 +802,14 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                         pf)
                         .catch(() => [])
                     : Promise.resolve([]),
+                // Radio de impacto: grafo COMPLETO del proyecto (no filtrado por
+                // moduleNames — quién depende de X vive en las filas de OTROS
+                // módulos). En el mismo Promise.all: cero rondas extra, cero turnos
+                // extra. Best-effort: sin columna, el contexto se sirve sin radio.
+                db
+                    .rest(`change_module?select=module,deps&deps=not.is.null&order=created_at.desc&limit=${MODULE_GRAPH_WINDOW_ROWS}` +
+                    pf)
+                    .catch(() => []),
             ]);
             const watchedByFile = new Map();
             for (const w of watched) {
@@ -771,22 +822,55 @@ 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}`;
+                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);
             // 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.
@@ -829,6 +913,10 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                     for (const plain of alertsByModule.get(m.module) ?? []) {
                         lines.push(`  - ⚠ OPEN ALERT: ${plain}`);
                     }
+                    const dependents = dependentsByModule.get(m.module);
+                    if (dependents?.length) {
+                        lines.push(`  - ↘ DEPENDS ON THIS: ${dependents.join(", ")} — check these too before you finish`);
+                    }
                 }
                 for (const w of watchedByFile.get(f.file) ?? []) {
                     lines.push(`- Current value: ${w.name} = ${w.value}` +
@@ -864,6 +952,14 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                         prior_regressions: recidivismByModule.get(m.module) ?? 0,
                     }))
                         .filter((x) => x.prior_regressions >= 2),
+                    // Espejo del hospedado: el structuredContent no puede prometer
+                    // menos que la prosa.
+                    dependents: f.modules
+                        .map((m) => ({
+                        module: m.module,
+                        dependents: dependentsByModule.get(m.module) ?? [],
+                    }))
+                        .filter((x) => x.dependents.length > 0),
                     watched_values: (watchedByFile.get(f.file) ?? []).map((w) => ({
                         name: w.name,
                         value: w.value,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "changebook",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "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.8",
+  "version": "0.4.10",
   "websiteUrl": "https://changebook.dev",
   "remotes": [
     {
@@ -15,7 +15,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "changebook",
-      "version": "0.4.8",
+      "version": "0.4.10",
       "transport": {
         "type": "stdio"
       }