changebook 0.5.0 → 0.7.0

package/dist/tools.js

@@ -4,12 +4,12 @@
  * All tools are read-only queries over the user's own ChangeBook data
  * (Row Level Security scopes every request to the signed-in user).
  */
-import path from "node:path";
 import { z } from "zod";
-import { execFileAsync } from "./git.js";
+import { execFileAsync, projectNameFor } from "./git.js";
 import { avisoRefutado, contarEnRepo, dondeApareceElSimbolo, dondeComprobarlo, ficherosEnRepo, slugifyProject, unoPorTexto, } from "./guard.js";
 import { SupabaseError } from "./supabase.js";
 import { coChangePairs } from "./sync.js";
+import { aliasesFor, canonicalizeModuleRows, canonicalModule, etiquetaPorSlug, expandModuleNames, projectIdOf, slugModule, } from "./aliasDeModulo.js";
 const CHARACTER_LIMIT = 25_000;
 /**
  * El contrato temporal de las respuestas del atlas (benchmark 2026-07-20: el
@@ -104,24 +104,40 @@ const MAX_DEPENDENTS = 6;
  *  o se pregunte al atlas. Paridad fijada en test/radioDeImpacto. */
 const MODULE_GRAPH_WINDOW_ROWS = 1000;
 export function dependentsOf(targets, rows) {
+    // POR SLUG, NO POR toLowerCase(): media normalizacion se lee igual que una
+    // entera (invariante 16). Espejo de supabase/functions/mcp/scope.ts.
+    const etiqueta = etiquetaPorSlug(rows.map((r) => r.module ?? ""));
+    // Memo de slugModule: se llama una vez por fila y por dep. Espejo de
+    // supabase/functions/mcp/scope.ts (medido: 0,510 ms -> 2,698 ms sin esto).
+    const memo = new Map();
+    const slug = (s) => {
+        let v = memo.get(s);
+        if (v === undefined) {
+            v = slugModule(s);
+            memo.set(s, v);
+        }
+        return v;
+    };
     const graph = new Map();
     for (const r of rows) {
         const label = (r.module ?? "").trim();
-        if (!label || graph.has(label.toLowerCase()))
+        if (!label || graph.has(slug(label)))
             continue;
         const deps = Array.isArray(r.deps)
             ? r.deps.map((d) => (typeof d === "string" ? d.trim() : "")).filter(Boolean)
             : [];
-        graph.set(label.toLowerCase(), deps);
+        graph.set(slug(label), deps);
     }
     const reverse = new Map();
     for (const r of rows) {
-        const from = (r.module ?? "").trim();
-        if (!from)
+        const crudo = (r.module ?? "").trim();
+        if (!crudo)
             continue;
-        for (const to of graph.get(from.toLowerCase()) ?? []) {
-            const key = to.toLowerCase();
-            if (key === from.toLowerCase())
+        const slugFrom = slug(crudo);
+        const from = etiqueta.get(slugFrom) ?? crudo;
+        for (const to of graph.get(slugFrom) ?? []) {
+            const key = slug(to);
+            if (key === slugFrom)
                 continue;
             const set = reverse.get(key) ?? new Set();
             set.add(from);
@@ -133,7 +149,7 @@ export function dependentsOf(targets, rows) {
         const label = (t ?? "").trim();
         if (!label)
             continue;
-        const found = reverse.get(label.toLowerCase());
+        const found = reverse.get(slug(label));
         if (!found || found.size === 0)
             continue;
         out.set(label, [...found].sort((a, b) => a.localeCompare(b)).slice(0, MAX_DEPENDENTS));
@@ -147,18 +163,58 @@ export function dependentsOf(targets, rows) {
  * antecedentes (>= 2). Plain distinto, no filas, para que el re-levantado no
  * infle. No se refuta: cuenta historia, no vigencia.
  */
+/**
+ * ESPEJO de `RecidivismMap` en supabase/functions/mcp/scope.ts. Un Map de
+ * verdad —se itera y se muestra con la etiqueta buena— cuyo `get`/`has`
+ * normalizan la clave por slug antes de buscar, para que ningún consumidor
+ * tenga que acordarse de canonicalizar. Ver allí el razonamiento entero.
+ */
+export class RecidivismMap extends Map {
+    #porSlug = new Map();
+    set(clave, valor) {
+        this.#porSlug.set(slugModule(clave), valor);
+        return super.set(clave, valor);
+    }
+    get(clave) {
+        return super.get(clave) ?? this.#porSlug.get(slugModule(clave));
+    }
+    has(clave) {
+        return super.has(clave) || this.#porSlug.has(slugModule(clave));
+    }
+}
 export function computeRecidivism(rows) {
+    // Agrupado por slug y presentado con la etiqueta representante: si las
+    // alertas de un módulo partido están escritas con las dos grafías, sus
+    // regresiones distintas son las de UN módulo, no las de dos.
+    const etiqueta = etiquetaPorSlug(rows.map((r) => r.module ?? ""));
     const plainsByModule = new Map();
     for (const r of rows) {
-        const m = (r.module ?? "").trim();
+        // SOLO LAS CONFIRMADAS. Hasta el 2026-08-02 esto contaba TODA fila de
+        // `regression_alerts`, o sea avisos que el propio atlas se generó: sumaba
+        // los confirmados, los que el dueño refutó, los que se cerraron solos al
+        // re-tocar el módulo y los 79 que son anteriores al campo `resolution`.
+        // Medido en producción: decía 110 y las confirmadas eran 20 — «Análisis de
+        // cambios» salía con 13 y tenía CERO.
+        //
+        // La migración que añadió `resolution` (20260725100000) dice en su propio
+        // comentario que existe para impedir «el número bonito y falso». Este
+        // contador nunca lo adoptó. Ahora sí.
+        //
+        // `fixed` lo escribe el agente que actuó sobre el aviso, no un oráculo
+        // independiente, así que sigue siendo autocertificado — pero es la mejor
+        // etiqueta que hay, y desde luego mejor que no mirar.
+        if ((r.resolution ?? "").trim().toLowerCase() !== "fixed")
+            continue;
+        const crudo = (r.module ?? "").trim();
         const p = (r.plain ?? "").trim();
-        if (!m || !p)
+        if (!crudo || !p)
             continue;
+        const m = etiqueta.get(slugModule(crudo)) ?? crudo;
         const set = plainsByModule.get(m) ?? new Set();
         set.add(p);
         plainsByModule.set(m, set);
     }
-    const out = new Map();
+    const out = new RecidivismMap();
     for (const [m, set] of plainsByModule) {
         if (set.size >= 2)
             out.set(m, set.size);
@@ -245,14 +301,20 @@ function ilikePattern(search) {
  * `project` como argumento, pero el proceso corre donde el cliente lo arrancó.
  * En un repo válido pero AJENO, un símbolo ausente da un 0 REAL (no null) y
  * avisoRefutado con expect='present' lo tomaría como refutación — silenciar
- * una alerta verdadera por mirar donde no era es peor que el ruido. Misma
- * identidad que usa el guardián: CHANGEBOOK_PROJECT o el basename del
- * directorio, pasados por la slugify del servidor.
+ * una alerta verdadera por mirar donde no era es peor que el ruido.
+ *
+ * La identidad sale de `projectNameFor`, la MISMA que usan el guardián, el hook
+ * y sync: `CHANGEBOOK_PROJECT`, si no el nombre del árbol PRINCIPAL, y solo como
+ * último recurso el basename del cwd. Usar `path.basename(cwd)` a secas era el
+ * fallo: en un worktree enlazado el basename es el del worktree (`seo-wt`,
+ * `wt-3`…), NO el del repo, así que el grep de refutación y el ancla temporal se
+ * apagaban en todo worktree aunque fuera el mismo proyecto. `projectNameFor` ya
+ * resolvió esto para el resto del CLI el 2026-07-25; este gate se había quedado
+ * atrás.
  */
 function cwdEsElProyecto(project) {
-    const candidato = process.env.CHANGEBOOK_PROJECT?.trim() ||
-        path.basename(path.resolve(process.cwd()));
-    return slugifyProject(candidato) === slugifyProject(project.trim());
+    return (slugifyProject(projectNameFor(process.cwd())) ===
+        slugifyProject(project.trim()));
 }
 /**
  * "Atlas current up to commit X — your HEAD is N ahead": la señal MECÁNICA de
@@ -281,76 +343,6 @@ export async function derivaContraHead(dir, hash) {
 }
 // ── Registration ──────────────────────────────────────────────────────────────
 export function registerTools(server, db) {
-    // Espejo del hospedado (T3 del benchmark 2026-07-20): definiciones
-    // exportadas por archivo, sin grep. Usos y tests siguen fuera y se dice.
-    server.registerTool("atlas_symbol_lookup", {
-        title: "Where is this symbol defined?",
-        description: `Files where an exported symbol (function/class/const/interface/type/enum) is DEFINED, with its kind and the commit that last touched it. Mechanical index built from every ingested diff.
-
-Definitions only — usages and tests are not indexed; grep for those. Exact match first, substring fallback.
-
-Args:
-  - symbol (required): the identifier to look up.
-  - project (recommended): the repo you are working in (folder name or slug).
-
-Returns (structured): { symbol, exact_match, matches: [{ symbol, file, kind, commit }] }`,
-        inputSchema: {
-            symbol: z
-                .string()
-                .min(2)
-                .max(120)
-                .describe("Identifier to look up (exported definition)"),
-            project: z
-                .string()
-                .min(1)
-                .max(120)
-                .describe("Project to scope to (repo folder name or slug)"),
-        },
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, async ({ symbol, project }) => {
-        try {
-            const t0 = Date.now();
-            const pf = await db.projectFilterFor(project);
-            const base = `symbol_index?select=symbol,file,kind,commit_hash&order=symbol.asc&limit=20` +
-                pf;
-            let matches = await db.rest(`${base}&symbol=eq.${encodeURIComponent(symbol)}`);
-            let exact = true;
-            if (matches.length === 0) {
-                exact = false;
-                matches = await db.rest(`${base}&symbol=ilike.${ilikePattern(symbol)}`);
-            }
-            const lines = [`# Symbol lookup: ${symbol}`, ""];
-            if (matches.length === 0) {
-                lines.push("Not in the index. It may be unexported, renamed, or defined before the index existed — fall back to grep and SAY you did, instead of guessing.");
-            }
-            for (const m of matches) {
-                lines.push(`- ${m.symbol} (${m.kind}) — ${m.file}${m.commit_hash ? ` · commit ${m.commit_hash.slice(0, 7)}` : ""}`);
-            }
-            if (matches.length > 0) {
-                lines.push("", "Definitions only — usages and tests are not indexed; grep for those.");
-            }
-            const salida = toolResult(lines.join("\n"), {
-                symbol,
-                exact_match: exact,
-                matches: matches.map((m) => ({
-                    symbol: m.symbol,
-                    file: m.file,
-                    kind: m.kind,
-                    commit: m.commit_hash?.slice(0, 7) ?? null,
-                })),
-            });
-            recordRead(db, "atlas_symbol_lookup", pf, servedCharsOf(salida), Date.now() - t0);
-            return salida;
-        }
-        catch (error) {
-            return errorResult(error);
-        }
-    });
     server.registerTool("atlas_recent_changes", {
         title: "Recent ChangeBook changes",
         description: `List the most recent analyzed code changes from the ChangeBook changelog (newest first).
@@ -500,23 +492,42 @@ Returns (structured): { count, modules: [{ module, domain, risk, changes, last_c
             // The aggregation below uses only these columns; note/tech/excerpt
             // (up to ~1.5k each × 1000 rows) would move 1-2 MB per call for nothing.
             `change_module?select=module,domain,risk,created_at` +
-                `&order=created_at.desc&limit=1000` +
+                // LA CONSTANTE, no un 1000 a mano. Este era el tercer deletreo de la
+                // misma ventana en el CLI (la constante, este literal, y el
+                // MODULE_COUNT_WINDOW_ROWS del servidor), y el contrato que prohibe
+                // escribirla a mano solo leia los ficheros del servidor.
+                `&order=created_at.desc&limit=${MODULE_GRAPH_WINDOW_ROWS}` +
                 pf;
             if (domain)
                 query += `&domain=eq.${encodeURIComponent(domain)}`;
-            const rows = await db.rest(query);
+            // Canonicalizar ANTES de agrupar, o el catálogo listaría dos entradas
+            // para un módulo ya fusionado: la que más duele, porque el catálogo es
+            // justo la pantalla donde el dueño va a mirar si la fusión ha surtido
+            // efecto. Los alias van en el mismo Promise.all, sin ronda extra.
+            const [rowsCrudas, { aliases }] = await Promise.all([
+                db.rest(query),
+                aliasesFor(db, projectIdOf(pf)),
+            ]);
+            const rows = canonicalizeModuleRows(rowsCrudas, aliases);
+            // POR SLUG, no por el nombre crudo — gemelo del arreglo del hospedado
+            // (03/08). Este catalogo servia un modulo escrito de dos maneras como
+            // dos modulos, y es la pantalla donde el dueño mira si su fusion ha
+            // surtido efecto. `canonicalizeModuleRows` resuelve ALIAS, que es otra
+            // cosa: no colapsa tildes ni mayusculas (invariante 16).
+            const etiqueta = etiquetaPorSlug(rows.map((r) => r.module ?? ''));
             const byModule = new Map();
             for (const row of rows) {
-                const list = byModule.get(row.module);
+                const clave = slugModule((row.module ?? '').trim());
+                const list = byModule.get(clave);
                 if (list)
                     list.push(row);
                 else
-                    byModule.set(row.module, [row]);
+                    byModule.set(clave, [row]);
             }
-            const modules = [...byModule.entries()].map(([name, list]) => {
+            const modules = [...byModule.entries()].map(([clave, list]) => {
                 const latest = list[0]; // rows arrive newest-first
                 return {
-                    module: name,
+                    module: etiqueta.get(clave) ?? latest.module,
                     domain: latest.domain,
                     risk: latest.risk,
                     changes: list.length,
@@ -525,7 +536,17 @@ Returns (structured): { count, modules: [{ module, domain, risk, changes, last_c
             });
             modules.sort((a, b) => (a.last_changed < b.last_changed ? 1 : -1));
             const output = { count: modules.length, modules };
-            const lines = [`# ChangeBook module map (${modules.length} modules)`, ""];
+            // LA VENTANA VA DICHA. Esto contaba "(N modules)" a secas y el brief
+            // mandaba aqui a por "el mapa completo": las dos cosas prometian de
+            // mas. Son los modulos vistos en los ultimos MODULE_GRAPH_WINDOW_ROWS
+            // cambios, y esa ventana estaba LLENA AL RAS el 03/08 (la suma de
+            // `changes` daba 1.000 clavados), o sea que el numero baja segun se
+            // trabaja. Un contador que se encoge cuando trabajas y se llama
+            // "total" dice lo contrario de lo que pasa.
+            const lines = [
+                `# ChangeBook module map (${modules.length} modules seen in the last ${MODULE_GRAPH_WINDOW_ROWS} changes)`,
+                "",
+            ];
             for (const m of modules) {
                 lines.push(`- **${m.module}**${m.domain ? ` (${m.domain})` : ""} — ` +
                     `${m.changes} change(s), last ${m.last_changed}` +
@@ -547,9 +568,7 @@ Returns (structured): { count, modules: [{ module, domain, risk, changes, last_c
     });
     server.registerTool("atlas_module_detail", {
         title: "ChangeBook module detail",
-        description: `Get the change history of one module: what changed, why it matters, the files touched and (when available) a verbatim excerpt of each diff.
-
-This is the token-saving alternative to re-reading a module's source: it gives an agent the recent evolution and risk picture in one call.
+        description: `Call this WHEN you need a module's recent history instead of re-reading its source: what changed, why it matters, the files touched and (when available) a verbatim excerpt of each diff. The token-saving way to catch up on a module — its recent evolution and risk picture — in one call before you touch it.
 
 Args:
   - module (required): exact module name as returned by atlas_modules.
@@ -581,9 +600,18 @@ Returns (structured): { module, count, changes: [{ date, commit, risk, note, tec
         try {
             const t0 = Date.now();
             const pf = await db.projectFilterFor(project);
-            const rows = await db.rest(`change_module?select=changelog_id,module,domain,category,risk,files,note,tech,excerpt,created_at` +
-                `&module=eq.${encodeURIComponent(module)}&order=created_at.desc&limit=${limit}` +
+            // Los alias ANTES de la consulta, y aquí sí cuesta una ronda: el filtro
+            // por nombre va al servidor, así que no hay forma de expandirlo sin
+            // saber las hermanas. Se paga porque esta tool la invoca un agente de
+            // vez en cuando, no el guardián en cada edición — y porque la
+            // alternativa es que el historial de un módulo fusionado salga a medias
+            // sin decirlo, que es la peor forma de estar mal.
+            const { aliases, hermanas } = await aliasesFor(db, projectIdOf(pf));
+            const nombresParaConsultar = expandModuleNames([module], hermanas);
+            const rowsCrudas = await db.rest(`change_module?select=changelog_id,module,domain,category,risk,files,note,tech,excerpt,created_at` +
+                `&module=in.(${encodeURIComponent(quotedInList(nombresParaConsultar))})&order=created_at.desc&limit=${limit}` +
                 pf);
+            const rows = canonicalizeModuleRows(rowsCrudas, aliases);
             if (rows.length === 0) {
                 return {
                     content: [
@@ -646,15 +674,20 @@ Returns (structured): { module, count, changes: [{ date, commit, risk, note, tec
                 }
             }
             const latest = rows[0];
+            // Se responde con el nombre CANÓNICO, no con el que preguntó el agente:
+            // preguntar por la etiqueta vieja de un módulo fusionado tiene que
+            // devolver su historia completa BAJO EL NOMBRE BUENO, o la respuesta
+            // enseñaría un nombre que ya no está en el mapa.
+            const nombreCanonico = canonicalModule(module, aliases);
             const output = {
-                module,
+                module: nombreCanonico,
                 domain: latest.domain,
                 category: latest.category,
                 count: changes.length,
                 changes,
             };
             const lines = [
-                `# Module: ${module}` +
+                `# Module: ${nombreCanonico}` +
                     (latest.domain ? ` (${latest.domain}` +
                         (latest.category ? ` / ${latest.category}` : "") + ")" : ""),
             ];
@@ -692,9 +725,9 @@ Returns (structured): { module, count, changes: [{ date, commit, risk, note, tec
     });
     server.registerTool("atlas_file_context", {
         title: "Context of the files you are about to edit",
-        description: `Everything the atlas knows about specific FILES: which module each belongs to, its risk, open regression alerts on those modules, how often they changed recently, the recent commits that touched each file (cite these instead of running git log), and the CURRENT value of watched config constants (with the commit it comes from — no need to re-read the file for those).
+        description: `Call this BEFORE you edit, change, fix or refactor any file or function: it tells you how many times each file's module already broke here (recidivism) and its open regression alerts, so you touch it knowing what bit people last time. One cheap call instead of re-reading the code and its git history.
 
-Call this BEFORE editing a file — one cheap call instead of re-reading the code and its git history.
+It also returns, per file: the module it belongs to and its risk, how often it changed recently, the recent commits that touched it (cite these instead of running git log), and the CURRENT value of watched config constants (with the commit it comes from — no need to re-read the file for those).
 
 Args:
   - files (required): 1-8 repo-relative paths.
@@ -717,10 +750,22 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
         try {
             const t0 = Date.now();
             const pf = await db.projectFilterFor(project);
+            // La lectura de alias ARRANCA aquí y se espera dentro de cada fichero:
+            // corre en paralelo con las consultas por archivo, así que no cuesta
+            // ronda. Es la tool que el agente llama antes de cada edición. (Mismo
+            // patrón que el MCP hospedado, `aliasFileP`.)
+            const aliasP = aliasesFor(db, projectIdOf(pf));
             const paths = [...new Set(files.map(normalizeRepoPath).filter(Boolean))];
             const perFile = await Promise.all(paths.map(async (file) => {
-                const rows = await db.rest(`change_module?select=changelog_id,module,risk,note,created_at&${fileContainsFilter(file)}&order=created_at.desc&limit=20` +
-                    pf);
+                const [rowsCrudas, { aliases }] = await Promise.all([
+                    db.rest(`change_module?select=changelog_id,module,risk,note,created_at&${fileContainsFilter(file)}&order=created_at.desc&limit=20` +
+                        pf),
+                    aliasP,
+                ]);
+                // ANTES de agrupar: el bucle de abajo cuenta cambios POR NOMBRE, y
+                // canonicalizar después dejaría el mismo módulo partido en dos
+                // entradas con la mitad de los cambios cada una.
+                const rows = canonicalizeModuleRows(rowsCrudas, aliases);
                 const byModule = new Map();
                 // Commits que tocaron ESTE archivo, del más nuevo al más viejo,
                 // deduplicados (un mismo análisis puede traer varias filas de
@@ -749,9 +794,15 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                 }
                 return { file, modules: [...byModule.values()], changelogIds };
             }));
+            // Los nombres YA canonicalizados: es lo que se enseña y con lo que se
+            // agrupa. Pero las consultas de abajo filtran EN EL SERVIDOR por
+            // nombre, y en la base siguen las etiquetas viejas, así que van con las
+            // hermanas — el alias se resuelve al leer, no reescribe nada.
+            const { aliases: aliasesFile, hermanas: hermanasFile } = await aliasP;
             const moduleNames = [
                 ...new Set(perFile.flatMap((f) => f.modules.map((m) => m.module))),
             ];
+            const nombresParaConsultar = expandModuleNames(moduleNames, hermanasFile);
             // Commits recientes por archivo (T2: el agente que va a editar dejaba
             // de necesitar `git log -- <archivo>`). UNA consulta batcheada para
             // TODOS los archivos, no una por archivo: es la tool que corre antes
@@ -779,14 +830,14 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
             for (const f of perFile) {
                 commitsByFile.set(f.file, recentCommitsForFile(f.changelogIds, commitById));
             }
-            const [alerts, watched, recidivismRows, depsRows, coChangeRows] = await Promise.all([
+            const [alertsCrudas, watched, recidivismCrudas, depsCrudas, coChangeCrudas,] = await Promise.all([
                 moduleNames.length
                     ? db.rest(
                     // Con `evidence_scope`: sin él ni se refuta (alcanceDelRepo dice
                     // "sin_declarar" siempre) ni se sirve la línea NOT CHECKABLE
                     // HERE, que es la única forma de que un aviso sobre producción
                     // no se compruebe con un grep del repo. Ver guard.ts.
-                    `regression_alerts?select=module,plain,evidence_symbol,evidence_expect,evidence_scope,evidence_line&resolved_at=is.null&module=in.(${encodeURIComponent(quotedInList(moduleNames))})&order=created_at.desc&limit=10` +
+                    `regression_alerts?select=module,plain,evidence_symbol,evidence_expect,evidence_scope,evidence_line&resolved_at=is.null&module=in.(${encodeURIComponent(quotedInList(nombresParaConsultar))})&order=created_at.desc&limit=10` +
                         pf)
                     : Promise.resolve([]),
                 // Constantes vigiladas (espejo del hospedado): el valor VIGENTE con
@@ -798,13 +849,22 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                     pf)
                     .catch(() => []),
                 // Reincidencia (edit-time, espejo del hospedado): problemas de
-                // regresión de TODO el tiempo (sin filtro resolved) de los módulos
-                // tocados. Depende de moduleNames como las alertas → mismo Promise.all,
-                // sin ronda extra. Se cuenta distinct plain abajo (mismo criterio que
-                // el RPC del brief).
+                // regresión CONFIRMADOS de todo el tiempo, de los módulos tocados.
+                // Se trae `resolution` porque el recuento solo cuenta las `fixed`:
+                // hasta el 2026-08-02 sumaba toda fila y decía 110 donde había 20.
+                // Depende de moduleNames como las alertas → mismo Promise.all, sin
+                // ronda extra. Se cuenta distinct plain abajo.
                 moduleNames.length
                     ? db
-                        .rest(`regression_alerts?select=module,plain&module=in.(${encodeURIComponent(quotedInList(moduleNames))})&limit=500` +
+                        .rest(
+                    // `order` añadido el 03/08 (AUD-C9), a la vez que en el
+                    // hospedado: son las dos mitades de la paridad que vigila
+                    // reincidenciaFileContext. Sin orden, el tope de 500 no daba
+                    // «las 500 más recientes» sino 500 cualesquiera, distintas en
+                    // cada llamada, así que la reincidencia que sale de aquí
+                    // podía cambiar entre dos lecturas seguidas sin que la base
+                    // hubiera cambiado.
+                    `regression_alerts?select=module,plain,resolution&module=in.(${encodeURIComponent(quotedInList(nombresParaConsultar))})&order=created_at.desc&limit=500` +
                         pf)
                         .catch(() => [])
                     : Promise.resolve([]),
@@ -834,6 +894,14 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                     pf)
                     .catch(() => []),
             ]);
+            // Los CUATRO conjuntos, sobre filas ya canonicalizadas. Si uno solo se
+            // quedara crudo, la respuesta hablaría de un módulo con la reincidencia
+            // o las dependencias de otro — y esta tool corre antes de cada edición,
+            // así que el error viajaría dentro de una decisión de código.
+            const alerts = canonicalizeModuleRows(alertsCrudas, aliasesFile);
+            const recidivismRows = canonicalizeModuleRows(recidivismCrudas, aliasesFile);
+            const depsRows = canonicalizeModuleRows(depsCrudas, aliasesFile);
+            const coChangeRows = canonicalizeModuleRows(coChangeCrudas, aliasesFile);
             const watchedByFile = new Map();
             for (const w of watched) {
                 watchedByFile.set(w.file, [...(watchedByFile.get(w.file) ?? []), w]);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "changebook",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "mcpName": "io.github.raulbr90/changebook",
-  "description": "ChangeBook for coding agents: MCP server (product memory for Claude Code/Codex) + CLI to sign in, analyze changes and sync the product map.",
+  "description": "Your agent already broke this three times. ChangeBook tells it before the fourth. MCP server + CLI: the history of what broke in your repo, served to Claude Code, Cursor or Codex before they edit.",
   "type": "module",
   "main": "dist/index.js",
   "bin": {

package/server.json

@@ -1,8 +1,8 @@
 {
   "$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.5.0",
+  "description": "Your agent already broke this three times. ChangeBook tells it before the fourth.",
+  "version": "0.7.0",
   "websiteUrl": "https://changebook.dev",
   "remotes": [
     {
@@ -15,7 +15,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "changebook",
-      "version": "0.5.0",
+      "version": "0.7.0",
       "transport": {
         "type": "stdio"
       }