changebook 0.4.8 → 0.4.9

package/README.md

@@ -50,6 +50,9 @@ your other servers.
 | `changebook analyze [dir]` | Analyze the repo's uncommitted changes (`git diff HEAD`) and update the atlas — same pipeline as the VS Code extension, no editor needed. |
 | `changebook analyze --commit [ref]` | Analyze one commit. Deduped by hash server-side, so re-runs never bill. |
 | `changebook hook install\|uninstall\|status [dir]` | Git hooks: every new commit is analyzed in the background (post-commit, never blocks), and the signal guard warns before you commit to a module with an open alert (pre-commit). One pair of hooks covers Claude Code, Codex and manual commits — they all commit through git. |
+| `changebook hook-context install\|uninstall\|status [dir]` | Claude Code `SessionStart` hook: pushes the fresh atlas map into **every** session at turn 0 — no tool call to remember, and generated on the spot so it can't go stale. Writes to `.claude/settings.json`; running the command **is** the consent, and it refuses to touch a config it can't parse. |
+| `changebook hook-impact install\|uninstall\|status [dir]` | Claude Code `PreToolUse` hook: **before every edit**, tells the agent which modules depend on the file it is about to touch, plus any open alert and repeat-offender history. Never blocks an edit, never touches the network on the critical path (reads a short-lived cache in `.git/` and refreshes it out of band), warns once per file per session, and stays **silent** when there is nothing to say. |
+| `changebook impact` / `changebook context [dir]` | What those two hooks run. Both read from stdin/disk, print a JSON payload (or nothing) and always exit 0 — you don't call them by hand. |
 | `changebook guard [dir]` | What the pre-commit hook runs: checks staged files against the atlas' open alerts. Warn-only and fail-open by default; `CHANGEBOOK_GUARD=block` makes findings abort the commit (bypass once with `git commit --no-verify`), `CHANGEBOOK_GUARD=off` silences it. |
 | `changebook sync [dir]` | Refresh the product map inside `CLAUDE.md`/`AGENTS.md`. |
 | `changebook init [dir]` | login + register MCP server + install hook + sync, in one go. |

package/dist/analyze.js

@@ -6,7 +6,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, FICHEROS_GENERADOS, GIT_MAX_BUFFER_BYTES, gitErrorMessage, MAX_DIFF_CHARACTERS, usableSummary, } from "./git.js";
 import { canonicalDiffHash } from "./canonical.js";
 import { optimizeTokensForAI, truncateAtFileBoundary } from "./optimize.js";
 export async function analyze(db, options = {}) {
@@ -124,7 +124,9 @@ async function commitMeta(cwd, ref) {
 }
 async function gitDiffHead(cwd) {
     try {
-        const { stdout } = await execFileAsync("git", ["diff", "HEAD", "-U0"], {
+        // Mismos ficheros excluidos que en commitDiff: el atlas no se analiza a sí
+        // mismo (ver FICHEROS_GENERADOS).
+        const { stdout } = await execFileAsync("git", ["diff", "HEAD", "-U0", "--", ...FICHEROS_GENERADOS], {
             cwd,
             encoding: "utf8",
             maxBuffer: GIT_MAX_BUFFER_BYTES,

package/dist/context.js

@@ -28,6 +28,38 @@ import { fetchBriefSection } from "./sync.js";
 import { commitAliasesShort, derivaContraHead } from "./tools.js";
 /** Hard ceiling on the critical path: past this, emit nothing and move on. */
 const CONTEXT_TIMEOUT_MS = 2_000;
+/**
+ * A timeout that can lose the race without punishing the winner.
+ *
+ * The naive form — `new Promise(r => setTimeout(r, ms))` raced against the real
+ * work — has a bug that measurement makes obvious and reading never does: when
+ * the work wins, the timer is still pending, and Node will not exit until it
+ * fires. The process is done and just sits there. Measured 2026-07-26:
+ * `changebook context` took 2.18s wall clock to produce a payload it already had
+ * in ~200ms, on the session-start path, under a doc comment promising it would
+ * "never block it, slow it, or exit non-zero". It had been slowing every session
+ * by two seconds.
+ *
+ * `unref()` is the fix: the timer still fires if anything else is keeping the
+ * loop alive, but it never keeps the loop alive by itself. `cancelar()` is belt
+ * and braces for the long-lived case (the MCP server), where an unref'd timer
+ * would still fire pointlessly.
+ *
+ * Shared by both hooks on purpose. The defect existed independently in two
+ * places, which is the usual sign that the shape — not the instance — was wrong.
+ */
+export function presupuestoDeTiempo(ms) {
+    let cancelar = () => { };
+    const vencido = new Promise((resolve) => {
+        const t = setTimeout(() => resolve(null), ms);
+        t.unref?.();
+        cancelar = () => {
+            clearTimeout(t);
+            resolve(null);
+        };
+    });
+    return { vencido, cancelar };
+}
 async function buildPayload(db, dir) {
     // Logged out → silent no-op. A fresh clone with the hook installed but no
     // session must open exactly as fast as before.
@@ -60,24 +92,20 @@ async function buildPayload(db, dir) {
     }
     return drift ? `${section}\n\n${drift}` : section;
 }
-// ── SessionStart hook install (opt-in, per repo) ─────────────────────────────
-//
-// The push channel lives in `.claude/settings.json` under hooks.SessionStart.
-// Consent is the act of running `changebook hook-context install` (or saying
-// yes to init's offer) — this file is often committed and shared, so we NEVER
-// write it silently and NEVER clobber a config we can't parse.
 // `2>/dev/null || true`: if `changebook` isn't on PATH for some teammate, the
 // shell error is swallowed and the hook exits 0 — a missing binary must not
-// make a session-start hook look failed. printContext already emits only the
-// JSON payload (or nothing) on stdout.
-const HOOK_COMMAND = "changebook context 2>/dev/null || true";
-// Recognisable substring to find/remove our own entry without touching others.
-const HOOK_MARKER = "changebook context";
+// make a hook look failed. Both commands emit only the JSON payload (or
+// nothing) on stdout.
+export const CONTEXT_HOOK = {
+    event: "SessionStart",
+    command: "changebook context 2>/dev/null || true",
+    marker: "changebook context",
+};
 function settingsPath(dir) {
     return path.join(path.resolve(dir), ".claude", "settings.json");
 }
-function groupHasMarker(g) {
-    return (g.hooks ?? []).some((h) => (h.command ?? "").includes(HOOK_MARKER));
+function groupHasMarker(g, marker) {
+    return (g.hooks ?? []).some((h) => (h.command ?? "").includes(marker));
 }
 function readSettings(file) {
     let raw;
@@ -97,53 +125,71 @@ function readSettings(file) {
         return null; // unparseable → caller must refuse, never clobber
     }
 }
-export function contextHookInstalled(dir) {
+export function settingsHookInstalled(dir, spec) {
     const s = readSettings(settingsPath(dir));
-    return Boolean(s?.hooks?.SessionStart?.some(groupHasMarker));
+    return Boolean(s?.hooks?.[spec.event]?.some((g) => groupHasMarker(g, spec.marker)));
 }
-export function installContextHook(dir) {
+export function installSettingsHook(dir, spec) {
     const file = settingsPath(dir);
     const settings = readSettings(file);
     if (settings === null) {
         throw new Error(`Refusing to touch ${file}: it isn't valid JSON. Fix or remove it, then retry.`);
     }
     const hooks = (settings.hooks ??= {});
-    const sessionStart = (hooks.SessionStart ??= []);
-    if (sessionStart.some(groupHasMarker))
+    const list = (hooks[spec.event] ??= []);
+    if (list.some((g) => groupHasMarker(g, spec.marker)))
         return "already";
-    sessionStart.push({
-        hooks: [{ type: "command", command: HOOK_COMMAND }],
+    // El matcher solo se escribe si lo hay: un `matcher` presente y vacío es
+    // "todas las tools" en Claude Code, y en SessionStart no significa nada.
+    // Escribir la clave igualmente dejaría un campo mudo en un archivo que la
+    // gente lee y commitea.
+    list.push({
+        ...(spec.matcher ? { matcher: spec.matcher } : {}),
+        hooks: [{ type: "command", command: spec.command }],
     });
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, JSON.stringify(settings, null, 2) + "\n");
     return "installed";
 }
-export function uninstallContextHook(dir) {
+export function uninstallSettingsHook(dir, spec) {
     const file = settingsPath(dir);
     const settings = readSettings(file);
-    if (!settings || !settings.hooks?.SessionStart)
+    if (!settings?.hooks?.[spec.event])
         return "absent";
-    const before = settings.hooks.SessionStart;
+    const before = settings.hooks[spec.event];
     // Drop our command from every group, then drop groups left empty. Foreign
     // hooks in the same group (unusual, but possible) are preserved.
     const after = before
         .map((g) => ({
         ...g,
-        hooks: (g.hooks ?? []).filter((h) => !(h.command ?? "").includes(HOOK_MARKER)),
+        hooks: (g.hooks ?? []).filter((h) => !(h.command ?? "").includes(spec.marker)),
     }))
         .filter((g) => (g.hooks ?? []).length > 0);
-    if (after.length === before.length && before.every((g) => !groupHasMarker(g))) {
+    if (after.length === before.length &&
+        before.every((g) => !groupHasMarker(g, spec.marker))) {
         return "absent";
     }
     if (after.length > 0)
-        settings.hooks.SessionStart = after;
+        settings.hooks[spec.event] = after;
     else
-        delete settings.hooks.SessionStart;
+        delete settings.hooks[spec.event];
     if (Object.keys(settings.hooks).length === 0)
         delete settings.hooks;
     fs.writeFileSync(file, JSON.stringify(settings, null, 2) + "\n");
     return "removed";
 }
+// Envoltorios del canal SessionStart. Se mantienen con su nombre porque son la
+// superficie que ya consume index.ts (y, a través de él, `init`): generalizar
+// por dentro no es motivo para renombrar por fuera.
+export function contextHookInstalled(dir) {
+    return settingsHookInstalled(dir, CONTEXT_HOOK);
+}
+export function installContextHook(dir) {
+    return installSettingsHook(dir, CONTEXT_HOOK);
+}
+export function uninstallContextHook(dir) {
+    return uninstallSettingsHook(dir, CONTEXT_HOOK);
+}
 /**
  * The pulse and the brief, composed. Separate from printContext so the WHOLE
  * thing — including the pulse — stays inside the single timeout race: adding
@@ -170,11 +216,12 @@ async function buildSessionContext(db, dir) {
 }
 export async function printContext(db, dir) {
     try {
-        const timeout = new Promise((resolve) => setTimeout(() => resolve(null), CONTEXT_TIMEOUT_MS));
+        const { vencido, cancelar } = presupuestoDeTiempo(CONTEXT_TIMEOUT_MS);
         const additionalContext = await Promise.race([
             buildSessionContext(db, dir),
-            timeout,
+            vencido,
         ]);
+        cancelar();
         if (!additionalContext)
             return;
         // The SessionStart contract: stdout JSON whose additionalContext is

package/dist/credentials.js

@@ -61,6 +61,48 @@ export function clearCredentials() {
         return false;
     }
 }
+const INFLIGHT_FILE = path.join(DIR, "refresh-inflight.json");
+/**
+ * Deja constancia en disco de que ALGUIEN va a gastar el refresh token.
+ *
+ * Supabase lo rota **al recibir la peticion**, asi que entre "sale la peticion"
+ * y "guardamos el token nuevo" hay una ventana en la que el token del disco ya
+ * esta muerto sin que nadie lo sepa. Si el proceso no sobrevive a esa ventana
+ * —el `analyze` post-commit corre desacoplado en segundo plano, y basta con
+ * apagar el equipo o matar la terminal— el siguiente arranque reenvia el viejo,
+ * Supabase lo trata como robo y cierra la sesion.
+ *
+ * Esta marca no PUEDE evitarlo: nada del lado del cliente sobrevive a un
+ * `kill -9`. Lo que evita es que sea inexplicable. Sin ella, el usuario ve
+ * "Invalid Refresh Token: Already Used" y no tiene forma de saber por que; con
+ * ella se le puede decir cuando se quedo a medias la renovacion.
+ */
+export function markRefreshInFlight(now = new Date()) {
+    try {
+        fs.mkdirSync(DIR, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(INFLIGHT_FILE, JSON.stringify({ at: now.toISOString(), pid: process.pid }), { mode: 0o600 });
+    }
+    catch {
+        // Es un diagnostico, no una garantia: si no se puede escribir, seguimos.
+    }
+}
+export function clearRefreshInFlight() {
+    try {
+        fs.rmSync(INFLIGHT_FILE, { force: true });
+    }
+    catch {
+        // idem
+    }
+}
+export function readRefreshInFlight() {
+    try {
+        const data = JSON.parse(fs.readFileSync(INFLIGHT_FILE, "utf8"));
+        return typeof data.at === "string" ? data : null;
+    }
+    catch {
+        return null;
+    }
+}
 const LOCK_FILE = path.join(DIR, "refresh.lock");
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));

package/dist/git.js

@@ -60,12 +60,44 @@ export function usableSummary(message) {
     return (lastBreak > MIN_USEFUL_SUMMARY_CHARS ? cut.slice(0, lastBreak) : cut).trim();
 }
 /** `git show <hash> -U0` — the unified diff of a single commit, no context. */
+/**
+ * Ficheros que ESCRIBE el propio ChangeBook y que por tanto no puede analizar.
+ *
+ * `sync` regenera el bloque del mapa dentro de CLAUDE.md/AGENTS.md, y `analyze`
+ * lo dispara en cada commit. Sin excluirlos se cierra un bucle: commiteas el
+ * mapa regenerado -> el análisis lo ve -> nace/actualiza el módulo "Mapeo de
+ * módulos" -> pasa a ser el más reciente -> el mapa se reordena -> vuelve a
+ * estar sucio. Cuesta un diff de una línea cada dos por tres y el 2026-07-25
+ * costó un conflicto de merge real.
+ *
+ * No es una preferencia de ruido: una herramienta que se mide a sí misma
+ * inventa actividad que no existe. Los 6 "cambios" del módulo del mapa son
+ * exactamente eso.
+ *
+ * Un commit que SOLO toca estos ficheros produce un diff vacío y `analyze` lo
+ * salta con su mensaje de siempre — que es la respuesta correcta: regenerar el
+ * mapa no es un cambio de producto.
+ */
+export const FICHEROS_GENERADOS = [
+    ":(exclude)CLAUDE.md",
+    ":(exclude)AGENTS.md",
+    ":(exclude)**/CLAUDE.md",
+    ":(exclude)**/AGENTS.md",
+];
 export async function commitDiff(cwd, hash) {
     try {
         const { stdout } = await execFileAsync("git", 
         // --end-of-options so a ref that starts with "-" (e.g. "-n5") is treated
         // as a revision, never as a git option (argument injection).
-        ["show", "--pretty=format:", "-U0", "--end-of-options", hash], { cwd, encoding: "utf8", maxBuffer: GIT_MAX_BUFFER_BYTES });
+        [
+            "show",
+            "--pretty=format:",
+            "-U0",
+            "--end-of-options",
+            hash,
+            "--",
+            ...FICHEROS_GENERADOS,
+        ], { cwd, encoding: "utf8", maxBuffer: GIT_MAX_BUFFER_BYTES });
         return stdout;
     }
     catch (error) {

package/dist/impact.js

@@ -0,0 +1,512 @@
+/**
+ * `changebook impact` — el radio de impacto, EMPUJADO. Un hook `PreToolUse` de
+ * Claude Code que, justo antes de que el agente escriba en un archivo, le mete
+ * en contexto quién depende de lo que está a punto de tocar.
+ *
+ * POR QUÉ EXISTE, medido y no supuesto:
+ *
+ * El 2026-07-26, la tarea T4 del benchmark («vas a cambiar el comportamiento de
+ * computeRecidivism, ¿qué más hay que revisar?») se corrió con el atlas
+ * instalado y disponible. El agente hizo 32 turnos de grep, gastó 1.464.591
+ * tokens y llamó al atlas CERO veces: `atlas_adoption: 0`. El radio de impacto
+ * —desplegado, testado y en producción— fue invisible.
+ *
+ * La lección no es que faltara una tool. Es que un canal que depende de que el
+ * agente se acuerde de usarlo es un canal que se puede ignorar, y quien programa
+ * a base de «hazme esto» no pregunta nada: no hay turno en el que decida
+ * orientarse. Los disparadores literales de `sync.ts` mueven la aguja (60→100%
+ * medido el 2026-07-21) pero no la clavan: siguen necesitando que el agente
+ * reconozca una frase.
+ *
+ * Este canal no lo necesita. Salta porque va a editar, y punto.
+ *
+ * TRES REGLAS, y las tres son de supervivencia del producto:
+ *
+ *  1. NUNCA bloquea. Se emite `additionalContext` y nada más — sin
+ *     `permissionDecision`, así que el sistema de permisos del usuario decide
+ *     como si no estuviéramos. Un hook que puede tumbar una edición se
+ *     desinstala el día que se equivoca.
+ *  2. NUNCA cuesta tiempo perceptible. Corre antes de CADA edición, así que la
+ *     red se paga una vez cada CACHE_TTL_MS y el resto de las ediciones son una
+ *     lectura de disco. Con presupuesto duro por encima: pasado eso, silencio.
+ *  3. NUNCA repite. Un aviso idéntico en las 20 ediciones seguidas del mismo
+ *     archivo es ruido que se paga en tokens y que entrena al agente a
+ *     ignorarlo. Se avisa una vez por (sesión, archivo).
+ *
+ * Y una cuarta que es la que hace que se lea: SILENCIO cuando no hay nada que
+ * decir. Sin dependientes, sin alerta abierta y sin reincidencia, no se emite
+ * una sola letra.
+ */
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { presupuestoDeTiempo } from "./context.js";
+import { execFileAsync, gitPath } from "./git.js";
+import { avisoRefutado, contarEnRepo, slugifyProject, } from "./guard.js";
+import { computeRecidivism, dependentsOf } from "./tools.js";
+/**
+ * Techo duro del camino crítico. Más corto que el de `context` (2 s) porque
+ * este corre por edición y no por sesión: 20 ediciones × 2 s serían 40 s de
+ * impuesto sobre el bucle que este producto dice acelerar.
+ */
+const IMPACT_TIMEOUT_MS = 1_200;
+/** Igual que el guardián: las alertas se mueven a velocidad de análisis. */
+const CACHE_TTL_MS = 5 * 60_000;
+/**
+ * Ventana del grafo. Espejo de MODULE_GRAPH_WINDOW_ROWS en tools.ts: dos
+ * ventanas distintas darían dependientes distintos según se pregunte o se
+ * empuje, y el agente no tiene forma de saber cuál de las dos le mintió.
+ */
+const GRAPH_WINDOW_ROWS = 1_000;
+/** Tope de filas de alertas; alimenta reincidencia (all-time) y abiertas. */
+const ALERT_WINDOW_ROWS = 500;
+/** Un archivo vuelve a avisar si se vuelve a él mucho después. */
+const SEEN_TTL_MS = 30 * 60_000;
+/** Cota del archivo de estado: es una nota, no un historial. */
+const SEEN_MAX = 200;
+/** Cuántos módulos se describen si el archivo pertenece a varios. */
+const MAX_MODULES = 3;
+/** Tope de greps de refutación: son síncronos y el techo no los desaloja. */
+const MAX_REFUTACIONES = 3;
+export const IMPACT_HOOK = {
+    event: "PreToolUse",
+    // Mismo `2>/dev/null || true` que CONTEXT_HOOK y por lo mismo: un
+    // `changebook` que no está en el PATH de un compañero no puede convertirse en
+    // un hook que parece roto en cada edición.
+    command: "changebook impact 2>/dev/null || true",
+    marker: "changebook impact",
+    // Las cuatro tools que escriben en un archivo. El matcher es lo que evita
+    // arrancar un proceso por cada Read, Grep o Bash del agente.
+    matcher: "Edit|Write|MultiEdit|NotebookEdit",
+};
+/**
+ * La(s) ruta(s) que la tool va a escribir. `file_path` cubre Edit, Write y
+ * MultiEdit; `notebook_path` cubre NotebookEdit. Se devuelve lista porque el
+ * contrato puede crecer, no porque hoy haya dos.
+ */
+export function pathsFromPayload(payload) {
+    const input = payload.tool_input ?? {};
+    return [input.file_path, input.notebook_path]
+        .filter((v) => typeof v === "string" && v.trim().length > 0)
+        .map((v) => v.trim());
+}
+/**
+ * Ruta con los enlaces simbólicos resueltos, incluso si la ruta no existe.
+ *
+ * No es defensa preventiva: sin esto el hook callaba SIEMPRE en macOS. `git
+ * rev-parse --show-toplevel` devuelve la ruta real (`/private/var/…`) y el
+ * payload del hook trae la que se usó para llegar (`/var/…`, que es un enlace al
+ * anterior). Son el mismo directorio, pero `path.relative` entre las dos daba
+ * `../../…`, la ruta se descartaba por «caer fuera del árbol», y no se avisaba
+ * de nada nunca. Fallo real, cazado por los tests el 2026-07-26.
+ *
+ * Sube hasta el primer ancestro que existe y recompone el resto, porque
+ * `realpathSync` falla con lo inexistente y con `Write` no tiene por qué existir
+ * ni el archivo ni sus carpetas.
+ */
+function rutaRealProfunda(p) {
+    const abs = path.resolve(p);
+    const cola = [];
+    let actual = abs;
+    for (;;) {
+        try {
+            const real = fs.realpathSync(actual);
+            return cola.length > 0 ? path.join(real, ...cola.reverse()) : real;
+        }
+        catch {
+            const padre = path.dirname(actual);
+            if (padre === actual)
+                return abs; // se llegó a la raíz sin resolver nada
+            cola.push(path.basename(actual));
+            actual = padre;
+        }
+    }
+}
+/**
+ * Ruta absoluta (lo que manda el hook) → ruta relativa al repo (lo que guarda
+ * el atlas). `null` cuando queda fuera del árbol: un archivo de /tmp o del home
+ * no tiene módulo, y colarlo como ruta con `../` produciría cero coincidencias
+ * de forma silenciosa.
+ */
+export function repoRelative(toplevel, filePath) {
+    const raiz = rutaRealProfunda(toplevel);
+    const abs = path.isAbsolute(filePath)
+        ? rutaRealProfunda(filePath)
+        : path.resolve(raiz, filePath);
+    const rel = path.relative(raiz, abs);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel))
+        return null;
+    // El atlas guarda rutas de git: siempre con "/", también en Windows.
+    return rel.split(path.sep).join("/");
+}
+/**
+ * ¿Merece este módulo un aviso?
+ *
+ * Es LA decisión del archivo. Se dice algo solo cuando hay algo que el agente
+ * no puede deducir del archivo que tiene delante: quién depende de él (no está
+ * escrito en ninguna parte del código), una alerta abierta (historia), o
+ * reincidencia (historia). El riesgo por sí solo NO cuenta: "risk: medium" en
+ * cada edición es exactamente el ruido que hace que se deje de leer.
+ */
+export function valeLaPena(m) {
+    return (m.dependents.length > 0 || m.alerts.length > 0 || m.priorRegressions >= 2);
+}
+/**
+ * El texto que se inyecta. Deliberadamente calcado a `atlas_file_context`
+ * ("↘ DEPENDS ON THIS", "⚠ OPEN ALERT", "prior regressions"): el agente ya sabe
+ * qué hacer con esas palabras porque las ve cuando pregunta él. Dos redacciones
+ * para el mismo hecho serían dos hechos para él.
+ */
+export function impactText(file, modules) {
+    const lines = [`⚠ ChangeBook — impact radius of ${file}, before you edit it:`];
+    for (const m of modules.slice(0, MAX_MODULES)) {
+        // El riesgo se nombra solo cuando es alto: ver valeLaPena.
+        const alto = m.risk === "high" || m.risk === "hotspot";
+        lines.push(`- Module **${m.module}**` +
+            (alto ? ` · risk: ${m.risk}` : "") +
+            (m.priorRegressions >= 2
+                ? ` · ⚠ ${m.priorRegressions} prior regressions`
+                : ""));
+        if (m.dependents.length > 0) {
+            lines.push(`  - ↘ DEPENDS ON THIS: ${m.dependents.join(", ")} — check these too before you finish`);
+        }
+        for (const plain of m.alerts)
+            lines.push(`  - ⚠ OPEN ALERT: ${plain}`);
+    }
+    if (modules.length > MAX_MODULES) {
+        lines.push(`- (+${modules.length - MAX_MODULES} more module(s) affected)`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Rutas que ya se avisaron en ESTA sesión y siguen frescas. Sesión distinta →
+ * borrón y cuenta nueva: cada sesión abre con un contexto vacío, así que el
+ * aviso vuelve a hacer falta.
+ */
+export function rutasYaAvisadas(state, sessionId, ahora) {
+    if (!state || state.session_id !== sessionId)
+        return new Set();
+    const vivas = Object.entries(state.seen ?? {}).filter(([, at]) => typeof at === "number" && ahora - at < SEEN_TTL_MS);
+    return new Set(vivas.map(([ruta]) => ruta));
+}
+/** El estado siguiente, podado por TTL y por tamaño (más recientes primero). */
+export function estadoSiguiente(state, sessionId, nuevas, ahora) {
+    const base = state && state.session_id === sessionId ? { ...(state.seen ?? {}) } : {};
+    for (const ruta of nuevas)
+        base[ruta] = ahora;
+    const podado = Object.entries(base)
+        .filter(([, at]) => typeof at === "number" && ahora - at < SEEN_TTL_MS)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, SEEN_MAX);
+    return { session_id: sessionId, seen: Object.fromEntries(podado) };
+}
+/**
+ * Módulos a los que pertenece un archivo, del más reciente al más antiguo.
+ *
+ * UNIÓN de filas y no la última foto, por la misma razón que `moduleFilesUnion`
+ * del guardián: los archivos que toca un módulo cambian en cada análisis, y
+ * quedarse con la fila más nueva silenciaba coincidencias reales (visto en vivo
+ * el 2026-07-18). El riesgo, en cambio, sí es el de la fila más nueva: es
+ * estado, no historia.
+ */
+export function modulosDelArchivo(file, rows) {
+    const out = new Map();
+    for (const row of rows) {
+        const label = (row.module ?? "").trim();
+        if (!label || out.has(label))
+            continue;
+        const files = Array.isArray(row.files) ? row.files.map(String) : [];
+        if (files.includes(file))
+            out.set(label, row.risk);
+    }
+    return [...out.entries()].map(([module, risk]) => ({ module, risk }));
+}
+async function cachePath(dir) {
+    return gitPath(dir, "changebook-impact-cache.json").catch(() => null);
+}
+function leerJson(file) {
+    if (!file)
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function escribirJson(file, data) {
+    if (!file)
+        return;
+    try {
+        fs.writeFileSync(file, JSON.stringify(data));
+    }
+    catch {
+        // Un .git de solo lectura no puede convertirse en una edición fallida.
+    }
+}
+async function fetchAtlas(db, dir, env) {
+    // Mismo proyecto al que reporta analyze/hook: CHANGEBOOK_PROJECT manda, si no
+    // el nombre del directorio, casado por slug del servidor primero.
+    const candidate = env.CHANGEBOOK_PROJECT?.trim() || path.basename(path.resolve(dir));
+    const slug = slugifyProject(candidate);
+    let projects = slug
+        ? await db.rest(`projects?select=id&slug=eq.${encodeURIComponent(slug)}&limit=1`)
+        : [];
+    if (projects.length === 0) {
+        projects = await db.rest(`projects?select=id&name=eq.${encodeURIComponent(candidate)}&limit=1`);
+    }
+    const projectId = projects[0]?.id ?? null;
+    if (!projectId) {
+        return { fetched_at: Date.now(), project_id: null, rows: [], deps: [], alerts: [] };
+    }
+    // TRES consultas en paralelo, una vez cada 5 minutos y fuera del camino
+    // crítico, así que el número de rondas aquí da igual. Lo que NO da igual es
+    // que sean tres y no dos: `deps` y `files` viven en la misma tabla, pero no en
+    // la misma ventana.
+    //
+    // El grafo se pide con `deps=not.is.null`, exactamente como tools.ts. Traerlo
+    // de la ventana general costó un fallo real, cazado en el E2E del 2026-07-26:
+    // de 931 filas recientes solo 613 tenían grafo, así que el mismo módulo salía
+    // con 3 dependientes empujado y 4 preguntado. Dos respuestas para el mismo
+    // hecho, y el agente sin forma de saber cuál le mintió — el fallo contra el
+    // que yo mismo había escrito el comentario de GRAPH_WINDOW_ROWS.
+    //
+    // Y las alertas se traen SIN filtrar por resolved_at, porque las abiertas y la
+    // reincidencia (all-time) salen del mismo conjunto.
+    const [rows, deps, alerts] = await Promise.all([
+        db
+            .rest(`change_module?select=module,files,risk,created_at&project_id=eq.${projectId}&order=created_at.desc&limit=${GRAPH_WINDOW_ROWS}`)
+            .catch(() => []),
+        db
+            .rest(`change_module?select=module,deps&project_id=eq.${projectId}&deps=not.is.null&order=created_at.desc&limit=${GRAPH_WINDOW_ROWS}`)
+            .catch(() => []),
+        db
+            .rest(`regression_alerts?select=module,plain,files,resolved_at,evidence_symbol,evidence_expect&project_id=eq.${projectId}&order=created_at.desc&limit=${ALERT_WINDOW_ROWS}`)
+            .catch(() => []),
+    ]);
+    return { fetched_at: Date.now(), project_id: projectId, rows, deps, alerts };
+}
+/**
+ * Las señales, SIEMPRE de disco. Nunca de la red.
+ *
+ * Esto empezó consultando en línea y no funcionaba, y el fallo enseña más que el
+ * arreglo: medido contra producción el 2026-07-26, resolver el proyecto tarda
+ * ~590 ms y las dos consultas otros ~320 ms. Con el techo por edición no llegaba
+ * — y como no llegaba, nunca escribía la caché, así que TODAS las llamadas eran
+ * en frío para siempre. Una caché que solo se escribe al final de un camino que
+ * no termina no es una caché.
+ *
+ * Así que el camino crítico no toca la red jamás: lee el archivo, y si está frío
+ * o caducado lanza un refresco DESACOPLADO (`impact --warm`) y calla esta vez.
+ * Mismo patrón que el hook post-commit. El coste real es que la primera edición
+ * de cada ventana de 5 minutos no avisa; a cambio, las otras cuarenta cuestan
+ * una lectura de disco. En una sesión de vibe coding ese cambio es todo a favor.
+ */
+async function atlasSignals(db, dir) {
+    const file = await cachePath(dir);
+    // Sin sitio donde guardar (no es un repo git, .git de solo lectura) no hay
+    // canal: calentar sería gastar un proceso y tres consultas para tirar el
+    // resultado a la basura.
+    if (!file)
+        return null;
+    const cached = leerJson(file);
+    if (cached && Date.now() - cached.fetched_at < CACHE_TTL_MS)
+        return cached;
+    if (db.hasCredentials())
+        calentarDesacoplado(dir);
+    return null;
+}
+/**
+ * Lanza el refresco de la caché en un proceso aparte y se olvida de él.
+ *
+ * `stdio: "ignore"` no es higiene, es obligatorio: el stdout del hijo llegaría
+ * a la misma tubería que Claude Code lee como salida del hook, y un JSON a
+ * medias o dos objetos pegados sería basura inyectada en el contexto del agente.
+ * `detached` + `unref` para que el padre pueda morir ya y no retenga la edición.
+ */
+function calentarDesacoplado(dir) {
+    try {
+        const hijo = spawn(process.execPath, [process.argv[1], "impact", "--warm", dir], {
+            detached: true,
+            stdio: "ignore",
+        });
+        hijo.unref();
+    }
+    catch {
+        // Sin poder lanzarlo, la caché se quedará fría y no habrá avisos. Mal, pero
+        // no tan mal como que falle una edición.
+    }
+}
+/**
+ * `changebook impact --warm [dir]` — el lado desacoplado. Consulta y escribe la
+ * caché. Sin stdin, sin stdout, sin código de salida que importe.
+ */
+export async function warmImpactCache(db, dir, env = process.env) {
+    try {
+        if (!db.hasCredentials())
+            return;
+        const file = await cachePath(dir);
+        if (!file)
+            return;
+        // Carrera entre dos ediciones seguidas: si otro proceso ya dejó una caché
+        // fresca mientras este arrancaba, no gastar dos veces la misma consulta.
+        const cached = leerJson(file);
+        if (cached && Date.now() - cached.fetched_at < CACHE_TTL_MS)
+            return;
+        escribirJson(file, await fetchAtlas(db, dir, env));
+    }
+    catch {
+        // Nadie está mirando esta salida; el síntoma de un fallo aquí es que no hay
+        // avisos, y eso ya lo cubre `hook-impact status`.
+    }
+}
+// ── El cuerpo ────────────────────────────────────────────────────────────────
+/** stdin completo, acotado. El hook manda un objeto pequeño; nada más cabe. */
+async function readStdin(limit = 256 * 1024) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of process.stdin) {
+        const buf = Buffer.from(chunk);
+        total += buf.length;
+        if (total > limit)
+            break;
+        chunks.push(buf);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function buildImpact(db, payload) {
+    const rutas = pathsFromPayload(payload);
+    if (rutas.length === 0)
+        return null;
+    const dir = payload.cwd?.trim() || process.cwd();
+    // El toplevel de git, no el cwd: el agente puede estar en un subdirectorio y
+    // el atlas guarda rutas relativas a la raíz del repo.
+    const toplevel = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+        cwd: dir,
+        encoding: "utf8",
+    })
+        .then(({ stdout }) => stdout.trim())
+        .catch(() => dir);
+    const relativas = [
+        ...new Set(rutas
+            .map((r) => repoRelative(toplevel, r))
+            .filter((r) => Boolean(r))),
+    ];
+    if (relativas.length === 0)
+        return null;
+    const ahora = Date.now();
+    const sessionId = payload.session_id?.trim() || "sin-sesion";
+    const seenFile = await gitPath(dir, "changebook-impact-seen.json").catch(() => null);
+    const yaAvisadas = rutasYaAvisadas(leerJson(seenFile), sessionId, ahora);
+    const pendientes = relativas.filter((r) => !yaAvisadas.has(r));
+    if (pendientes.length === 0)
+        return null;
+    const signals = await atlasSignals(db, dir);
+    if (!signals?.project_id)
+        return null;
+    const recidivism = computeRecidivism(signals.alerts);
+    const abiertas = signals.alerts.filter((a) => !a.resolved_at);
+    // Refutación al servir, igual que en atlas_file_context: el mismo grep que
+    // corre el guardián en el pre-commit. De 7 alertas abiertas, 4 se caían con
+    // un grep. Aquí importa el doble: un aviso empujado que ya no es verdad
+    // enseña al agente a ignorar los empujados.
+    //
+    // Acotada a mano, y por una razón que no es cosmética: contarEnRepo usa
+    // execFileSync, o sea que BLOQUEA el bucle de eventos y el techo de arriba no
+    // puede desalojarlo — un Promise.race no gana a una llamada síncrona. Un
+    // archivo con muchas alertas vivas podría comerse el presupuesto entero a
+    // 30 ms por grep. Tres es lo que cabe de sobra; el resto pasa sin refutar,
+    // que es el lado seguro (la duda deja pasar el aviso).
+    let grepsRestantes = MAX_REFUTACIONES;
+    const refutada = (a) => {
+        if (grepsRestantes <= 0)
+            return false;
+        grepsRestantes -= 1;
+        return avisoRefutado(a, (s) => contarEnRepo(toplevel, s));
+    };
+    const depsRows = signals.deps ?? [];
+    const bloques = [];
+    const avisadas = [];
+    for (const file of pendientes) {
+        const modulos = modulosDelArchivo(file, signals.rows);
+        if (modulos.length === 0)
+            continue;
+        const dependientes = dependentsOf(modulos.map((m) => m.module), depsRows);
+        const impactos = modulos
+            .map((m) => ({
+            module: m.module,
+            risk: m.risk,
+            dependents: dependientes.get(m.module) ?? [],
+            alerts: abiertas
+                .filter((a) => (a.module ?? "").trim() === m.module && a.plain)
+                .filter((a) => !refutada(a))
+                .map((a) => a.plain),
+            priorRegressions: recidivism.get(m.module) ?? 0,
+        }))
+            .filter(valeLaPena);
+        if (impactos.length === 0)
+            continue;
+        bloques.push(impactText(file, impactos));
+        avisadas.push(file);
+    }
+    // Solo se marca como avisado lo que de verdad se dijo: si el archivo no tenía
+    // nada hoy pero mañana sale una alerta suya, el aviso tiene que poder salir.
+    if (avisadas.length > 0) {
+        escribirJson(seenFile, estadoSiguiente(leerJson(seenFile), sessionId, avisadas, ahora));
+    }
+    return bloques.length > 0 ? bloques.join("\n\n") : null;
+}
+/**
+ * El comando. Falla abierto SIEMPRE: sin credenciales, sin red, sin proyecto,
+ * con el JSON roto o pasado el presupuesto, se emite cero y se sale con 0.
+ *
+ * Se emite `additionalContext` a secas, sin `permissionDecision`: la decisión de
+ * permisos se queda en manos del usuario, exactamente como si este hook no
+ * existiera. Y por contrato de Claude Code, salir con 2 bloquearía la edición —
+ * de ahí que aquí no se lance nunca nada hacia fuera.
+ */
+export async function printImpact(db) {
+    try {
+        // UN presupuesto para todo, no uno por etapa: dos carreras de 1,2 s en
+        // serie son 2,4 s de impuesto real por edición, que es justo lo que este
+        // techo existe para impedir. Se comparte entre leer stdin y leer la caché.
+        //
+        // Y se cancela en `finally`, no al final del camino feliz: los caminos que
+        // CALLAN son los más frecuentes (archivo limpio, ya avisado, caché fría) y
+        // cada `return` temprano dejaba el temporizador en pie. Medido el
+        // 2026-07-26: 1,39 s por edición silenciosa contra 0,23 s de la que habla —
+        // el proceso ya había terminado y se quedaba esperando a su propio reloj.
+        const { vencido, cancelar } = presupuestoDeTiempo(IMPACT_TIMEOUT_MS);
+        try {
+            const raw = await Promise.race([readStdin(), vencido.then(() => "")]);
+            if (!raw.trim())
+                return;
+            let payload;
+            try {
+                payload = JSON.parse(raw);
+            }
+            catch {
+                return;
+            }
+            const additionalContext = await Promise.race([
+                buildImpact(db, payload).catch(() => null),
+                vencido,
+            ]);
+            if (!additionalContext)
+                return;
+            process.stdout.write(JSON.stringify({
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    additionalContext,
+                },
+            }));
+        }
+        finally {
+            cancelar();
+        }
+    }
+    catch {
+        // Editar un archivo no puede fallar por nosotros.
+    }
+}
+//# sourceMappingURL=impact.js.map

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,7 +281,7 @@ 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))}`),
         ]
         : [];

package/dist/tools.js

@@ -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) {
@@ -787,6 +838,7 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
             // (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 +881,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 +920,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.9",
   "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.9",
   "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.9",
       "transport": {
         "type": "stdio"
       }