changebook 0.5.0 → 0.7.0

package/dist/aciertos.js

@@ -0,0 +1,100 @@
+import * as fs from 'node:fs';
+import { gitPath } from './git.js';
+/** Cuántos días atrás se mira. Más allá, la noticia ya no es noticia. */
+export const VENTANA_DIAS = 14;
+/**
+ * La línea, o cadena vacía.
+ *
+ * UNA SOLA LÍNEA Y UNA SOLA ALERTA. Con dos aciertos a la vez la tentación es
+ * listarlos, y una lista de autoelogio en cada commit es ruido con otro
+ * nombre. Se dice el más reciente y se callan los demás; ya se dirán cuando
+ * toque, o no se dirán, que tampoco pasa nada.
+ */
+export function lineaDeAcierto(candidatos, yaDichas, ahora = Date.now()) {
+    const frescos = candidatos
+        .filter((a) => a.id && !yaDichas.has(a.id))
+        .filter((a) => (a.resolution ?? '') === 'fixed')
+        .filter((a) => (a.plain ?? '').trim().length > 0)
+        .filter((a) => {
+        const t = Date.parse(a.resolved_at ?? '');
+        return Number.isFinite(t) && ahora - t <= VENTANA_DIAS * 86_400_000;
+    })
+        .sort((a, b) => Date.parse(b.resolved_at ?? '') - Date.parse(a.resolved_at ?? ''));
+    const a = frescos[0];
+    if (!a)
+        return null;
+    const modulo = (a.module ?? '').trim();
+    const donde = modulo ? ` sobre ${modulo}` : '';
+    // QUIÉN lo juzgó va en la frase, no en una nota al pie. «Lo confirmaste tú» y
+    // «lo dio por bueno el agente que lo arregló» no valen lo mismo, y el producto
+    // no puede cobrarse el segundo como si fuera el primero.
+    const quien = a.resolution_by === 'human'
+        ? 'y lo confirmaste tú'
+        : a.resolution_by === 'grep'
+            ? 'y lo confirmó una comprobación en tu código'
+            : 'y lo dio por bueno el agente que lo arregló';
+    return {
+        id: a.id,
+        texto: `\n✓ ChangeBook acertó: el aviso${donde} era real, ${quien}.\n  «${recorta(a.plain ?? '')}»\n`,
+    };
+}
+/** El texto del aviso, acotado: una línea de commit no es un informe. */
+function recorta(s, max = 110) {
+    const limpio = s.trim().replace(/\s+/g, ' ');
+    return limpio.length <= max ? limpio : `${limpio.slice(0, max - 1)}…`;
+}
+/** Las que ya se dijeron. Fichero propio, mismo sitio que el resto del estado. */
+async function memoriaPath(dir) {
+    return gitPath(dir, 'changebook-aciertos.json').catch(() => null);
+}
+function leerDichas(file) {
+    if (!file)
+        return new Set();
+    try {
+        const v = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return new Set(Array.isArray(v) ? v.filter((x) => typeof x === 'string') : []);
+    }
+    catch {
+        return new Set();
+    }
+}
+function guardarDichas(file, ids) {
+    if (!file)
+        return;
+    try {
+        // Se recorta a las últimas 200: es una memoria para no repetirse, no un
+        // registro. Un fichero que solo crece acaba siendo un fichero que nadie
+        // borra y que se lee entero en cada commit.
+        fs.writeFileSync(file, JSON.stringify([...ids].slice(-200)));
+    }
+    catch {
+        // Sin sitio donde anotar se repetirá una vez. Es el lado seguro.
+    }
+}
+/** `CHANGEBOOK_ACIERTOS=off` lo apaga del todo. */
+export function estaSilenciado(env = process.env) {
+    return (env.CHANGEBOOK_ACIERTOS ?? '').trim().toLowerCase() === 'off';
+}
+/**
+ * La línea para este repo, y la marca para no repetirla.
+ *
+ * Best-effort de principio a fin: corre dentro del pre-commit y no puede
+ * romperlo. Y si no hay nada que celebrar, silencio — que es el estado normal.
+ */
+export function acierto(candidatos, dir, env) {
+    if (estaSilenciado(env))
+        return Promise.resolve('');
+    return memoriaPath(dir)
+        .catch(() => null)
+        .then((file) => {
+        const dichas = leerDichas(file);
+        const linea = lineaDeAcierto(candidatos, dichas);
+        if (!linea)
+            return '';
+        dichas.add(linea.id);
+        guardarDichas(file, dichas);
+        return linea.texto;
+    })
+        .catch(() => '');
+}
+//# sourceMappingURL=aciertos.js.map

package/dist/aliasDeModulo.js

@@ -0,0 +1,203 @@
+// ── Alias de módulo, lado CLI ────────────────────────────────────────────────
+//
+// ESPEJO de `fetchModuleAliases` / `canonicalizeModuleRows` en
+// supabase/functions/_shared/analysis.ts. La paridad está testada en
+// test/aliasCliParidad.test.ts, y hace falta: el atlas se alimenta y se lee por
+// TRES superficies —las functions del servidor, el MCP hospedado y este CLI— y
+// una fusión que solo resolviera en dos de ellas haría que el guardián avisara
+// sobre un módulo que el mapa ya no muestra con ese nombre.
+//
+// No se puede importar el original: aquel es código Deno y esto es Node.
+export const SIN_ALIAS = {
+    aliases: new Map(),
+    hermanas: new Map(),
+};
+/** El MISMO slug que usa el servidor (slugModule) y el mapa de la web. */
+export function slugModule(s) {
+    return (s
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '') || 'modulo');
+}
+/** Aplana las cadenas (A→B, B→C deja A en C) con tope y detección de ciclo. */
+export function resolveAliasChains(directo) {
+    const out = new Map();
+    for (const [from, to] of directo) {
+        let actual = to;
+        const visto = new Set([from]);
+        for (let salto = 0; salto < 10; salto++) {
+            const siguiente = directo.get(slugModule(actual));
+            if (!siguiente || visto.has(slugModule(actual)))
+                break;
+            visto.add(slugModule(actual));
+            actual = siguiente;
+        }
+        if (slugModule(actual) !== from)
+            out.set(from, actual);
+    }
+    return out;
+}
+/**
+ * slug → etiqueta que lo representa. ESPEJO de `etiquetaPorSlug` en
+ * supabase/functions/mcp/scope.ts; la paridad la vigila
+ * test/paridadCoCambios.test.ts, porque el CLI y el hospedado calculan los
+ * mismos co-cambios y una discrepancia aquí los haría diferir en silencio.
+ *
+ * Existe porque `canonicalModule` NO cubre esta clase: hace
+ * `if (aliases.size === 0) return limpia`, así que con la tabla de alias vacía
+ * —0 filas en los tres proyectos— «Brief de orientación» y «Brief de
+ * orientacion» siguen siendo dos módulos distintos al agrupar.
+ *
+ * Desempate: la más frecuente; a igualdad, la más reciente. `labels` viene
+ * newest-first, así que la primera vista es la más reciente.
+ */
+export function etiquetaPorSlug(labels) {
+    const cuentas = new Map();
+    for (const raw of labels) {
+        const label = (raw ?? '').trim();
+        if (!label)
+            continue;
+        const slug = slugModule(label);
+        let porEtiqueta = cuentas.get(slug);
+        if (!porEtiqueta) {
+            porEtiqueta = new Map();
+            cuentas.set(slug, porEtiqueta);
+        }
+        porEtiqueta.set(label, (porEtiqueta.get(label) ?? 0) + 1);
+    }
+    const out = new Map();
+    for (const [slug, porEtiqueta] of cuentas) {
+        let mejor = '';
+        let mejorN = -1;
+        // `>` estricto: al recorrer en orden de aparición, la primera etiqueta (la
+        // más reciente) se queda cuando hay empate de frecuencia.
+        for (const [label, n] of porEtiqueta) {
+            if (n > mejorN) {
+                mejor = label;
+                mejorN = n;
+            }
+        }
+        out.set(slug, mejor);
+    }
+    return out;
+}
+export function canonicalModule(label, aliases) {
+    const limpia = (label ?? '').trim();
+    if (!limpia || aliases.size === 0)
+        return limpia;
+    return aliases.get(slugModule(limpia)) ?? limpia;
+}
+/**
+ * El punto de estrangulamiento: se llama al traer las filas, antes de agregar.
+ *
+ * ★ `deps` TAMBIÉN (2026-07-31): `change_module.deps` es un array DE NOMBRES DE
+ * MÓDULO y `dependentsOf` los casa por texto. Resolver solo la columna dejaba
+ * una arista declarada bajo la etiqueta vieja apuntando a un nodo que ya no se
+ * llama así, y el dependiente desaparecía del radio de impacto en silencio.
+ */
+export function canonicalizeModuleRows(rows, aliases) {
+    if (aliases.size === 0)
+        return rows;
+    return rows.map((r) => {
+        const crudo = r;
+        const module = crudo.module
+            ? canonicalModule(crudo.module, aliases)
+            : crudo.module;
+        if (!Array.isArray(crudo.deps)) {
+            return crudo.module ? { ...r, module } : r;
+        }
+        // Se deduplica: dos aristas hacia las dos etiquetas de un módulo fusionado
+        // son UNA arista, y dejarlas contaría dos veces al mismo dependiente.
+        const deps = [
+            ...new Set(crudo.deps.map((d) => typeof d === 'string' ? canonicalModule(d, aliases) : d)),
+        ];
+        return { ...r, module, deps };
+    });
+}
+/**
+ * Todas las etiquetas CRUDAS que acaban en el mismo canónico, incluida la propia.
+ *
+ * ESPEJO de `expandModuleNames` en analysis.ts, y existe por lo mismo: el CLI
+ * también filtra EN EL SERVIDOR por nombre de módulo (`module=in.(…)` sobre
+ * `regression_alerts` y `change_module`). En la base siguen las etiquetas viejas
+ * —el alias se resuelve al leer, no se reescribe nada—, así que preguntar por el
+ * canónico a secas PIERDE justo las filas que la fusión pretendía recuperar.
+ * Se expande ANTES de consultar y se canonicaliza DESPUÉS.
+ */
+export function expandModuleNames(names, hermanas) {
+    if (hermanas.size === 0)
+        return names;
+    const out = new Set();
+    for (const n of names) {
+        out.add(n);
+        for (const h of hermanas.get(slugModule(n)) ?? [])
+            out.add(h);
+    }
+    return [...out];
+}
+/** canónico (slug) → etiquetas crudas que resuelven a él. ESPEJO de analysis.ts. */
+export function siblingLabels(filas, aliases) {
+    // Se agrupa por el canónico YA RESUELTO, no por el de cada fila: una cadena
+    // A→B→C tiene que dejar A, B y C en el mismo grupo, no en dos.
+    const grupos = new Map();
+    for (const f of filas) {
+        const label = (f.alias_label ?? '').trim();
+        if (!label)
+            continue;
+        const canonico = canonicalModule(label, aliases);
+        const clave = slugModule(canonico);
+        const g = grupos.get(clave) ?? new Set([canonico]);
+        g.add(label);
+        grupos.set(clave, g);
+    }
+    // Se indexa por CADA miembro: preguntar por la etiqueta vieja o por la buena
+    // tiene que devolver el grupo entero, porque quien consulta no sabe cuál tiene.
+    const out = new Map();
+    for (const g of grupos.values()) {
+        const miembros = [...g];
+        for (const m of miembros)
+            out.set(slugModule(m), miembros);
+    }
+    return out;
+}
+/**
+ * El id del proyecto que ya lleva dentro el filtro `project_id=eq.…`.
+ *
+ * Los tres lectores del CLI resuelven el proyecto para poder filtrar y ninguno
+ * se queda con el id. Sacarlo de aquí evita una segunda resolución (que en
+ * producción tarda ~590 ms, medido) por el gusto de tener la misma cadena.
+ */
+export function projectIdOf(projectFilter) {
+    return /project_id=eq\.([0-9a-f-]+)/.exec(projectFilter)?.[1] ?? null;
+}
+/**
+ * Los alias del proyecto. Best-effort como el resto del contexto del CLI: sin
+ * tabla (versión vieja del servidor) o con error, contexto vacío y todo se
+ * comporta como antes de que existiera. Un guardián caído por leer alias sería
+ * mucho peor que un guardián que no los resuelve.
+ *
+ * ES LA ÚNICA LECTURA DE `module_alias` EN EL CLI, a propósito: la identidad del
+ * módulo ya vivió en tres sitios una vez y divergió sin ruido.
+ */
+export async function aliasesFor(db, projectId) {
+    if (!projectId)
+        return SIN_ALIAS;
+    try {
+        const rows = await db.rest(`module_alias?select=alias_slug,alias_label,canonical&project_id=eq.${projectId}&limit=500`);
+        const directo = new Map();
+        for (const r of rows) {
+            const from = (r.alias_slug ?? '').trim();
+            const to = (r.canonical ?? '').trim();
+            if (from && to)
+                directo.set(from, to);
+        }
+        const aliases = resolveAliasChains(directo);
+        return { aliases, hermanas: siblingLabels(rows, aliases) };
+    }
+    catch {
+        return SIN_ALIAS;
+    }
+}
+//# sourceMappingURL=aliasDeModulo.js.map

package/dist/badge.js

@@ -0,0 +1,159 @@
+import { projectNameFor } from './git.js';
+import { slugifyProject } from './guard.js';
+import { REPO_JOVEN } from './scan.js';
+/**
+ * Del informe a la fila. Pura, para poder probar la regla del repo joven sin
+ * red: es la que decide si el badge enseña un porcentaje o se calla.
+ */
+export function filaDeBadge(informe, ids, ahora = new Date().toISOString()) {
+    return {
+        ...ids,
+        commits: informe.commits,
+        ficheros_vivos: informe.ficherosVivos,
+        concentracion_ficheros: informe.concentracion.ficheros,
+        concentracion_pct: informe.concentracion.porcentaje,
+        // MISMO umbral que usa `scan` para callar el porcentaje en pantalla. Si los
+        // dos no coinciden, el badge afirma lo que el informe se negó a afirmar.
+        joven: informe.commits < REPO_JOVEN,
+        updated_at: ahora,
+    };
+}
+/** El markdown que el dueño pega en su README. */
+export function snippetDeBadge(base, token) {
+    const img = `${base}/functions/v1/badge?token=${token}`;
+    return `[![ChangeBook](${img})](https://changebook.app)`;
+}
+/**
+ * Lo que se hace público al encender el badge, dicho ANTES de encenderlo.
+ *
+ * No es cortesía: la primera versión ataba el badge a `share_token`, o sea que
+ * pedir una imagen publicaba el atlas entero —módulos, riesgos y el resumen en
+ * llano de cada cambio—. Son dos permisos de tamaños muy distintos y juntarlos
+ * hacía que el pequeño costara el precio del grande.
+ */
+export const LO_QUE_SE_PUBLICA = [
+    'El badge hace públicos CUATRO NÚMEROS, y nada más:',
+    '  · cuántos commits tiene el repo',
+    '  · cuántos ficheros vivos',
+    '  · cuántos de ellos concentran la mitad de los cambios, y su porcentaje',
+    '',
+    'NO se publica: ni código, ni diffs, ni nombres de fichero, ni nombres de',
+    'módulo, ni resúmenes de tus cambios, ni fechas. Es una llave aparte de la de',
+    'compartir el atlas: encender el badge NO publica tu historial.',
+    '',
+    'Se apaga cuando quieras con:  changebook scan --badge --off',
+].join('\n');
+/**
+ * El proyecto de este repo, con la MISMA cascada que usa `projectFilterFor`:
+ * slug primero, luego nombre, y si la cuenta solo tiene uno, ése.
+ *
+ * Buscar por `name=eq.` a secas —que es lo que hacía la primera versión— falla
+ * en cuanto la carpeta no se llama exactamente igual que el proyecto: aquí el
+ * directorio es `AppAtlas` y el proyecto `appatlas`, y el comando contestaba
+ * «no hay ningún proyecto llamado AppAtlas» teniéndolo delante. Se vio
+ * ejecutándolo, no leyéndolo.
+ */
+export async function proyectoDe(db, nombre) {
+    const campos = 'select=id,user_id,badge_token';
+    const slug = slugifyProject(nombre);
+    const buscar = (q) => db.rest(`projects?${campos}&${q}&limit=1`);
+    if (slug) {
+        const porSlug = await buscar(`slug=eq.${encodeURIComponent(slug)}`);
+        if (porSlug[0])
+            return porSlug[0];
+    }
+    const porNombre = await buscar(`name=eq.${encodeURIComponent(nombre)}`);
+    if (porNombre[0])
+        return porNombre[0];
+    // Con UN solo proyecto no hay frontera que proteger: no hay entre qué elegir.
+    const todos = await db.rest(`projects?${campos}&order=created_at.asc&limit=2`);
+    return todos.length === 1 ? todos[0] : null;
+}
+const SIN_PROYECTO = (nombre) => `No hay ningún proyecto llamado "${nombre}" en tu cuenta de ChangeBook.\n` +
+    `Analiza al menos un commit primero (changebook analyze) y vuelve a intentarlo.`;
+/**
+ * Publica los números y devuelve el snippet, encendiendo la llave si hace falta.
+ *
+ * LA LLAVE SE ENCIENDE AQUÍ, y es una decisión que cambió. La primera versión
+ * se apoyaba en `share_token` y se negaba a crear nada: encender ESE token
+ * habría convertido «quiero una imagen» en «publico mi atlas entero», que no es
+ * lo mismo ni de lejos. Con llave propia el cálculo es otro: lo que se expone
+ * son exactamente los cuatro números que el usuario va a ver dibujados, y ha
+ * escrito el comando que los pide. Encenderla en silencio seguiría estando mal,
+ * así que el comando imprime `LO_QUE_SE_PUBLICA` antes.
+ */
+export async function publicarBadge(db, dir, informe) {
+    const nombre = projectNameFor(dir);
+    const proyecto = await proyectoDe(db, nombre);
+    if (!proyecto)
+        return { ok: false, motivo: SIN_PROYECTO(nombre) };
+    // LOS NÚMEROS PRIMERO, LA LLAVE DESPUÉS. El orden no es indiferente: encender
+    // la llave abre una URL pública, y hacerlo antes de saber si hay algo que
+    // servir deja el badge encendido aunque la publicación falle. Pasó de verdad
+    // —el primer intento reventó con un 42501 DESPUÉS de haber encendido la
+    // llave—, y el usuario vio un error creyendo que no había pasado nada
+    // mientras la URL ya existía. Un permiso se abre cuando ya hay algo detrás.
+    //
+    // Por RPC y no por un upsert a la tabla. Un upsert escribe TODAS las columnas
+    // enviadas, incluidas `project_id` y `user_id`, que están fuera del grant por
+    // columna a propósito: son la frontera entre cuentas. Medido ejecutándolo —
+    // 42501— y la salida fácil (añadirlas al grant) es el agujero que
+    // 20260710120000 cerró en `regression_alerts`. La función valida la propiedad
+    // y el cliente se queda sin escritura directa.
+    const fila = filaDeBadge(informe, {
+        project_id: proyecto.id,
+        user_id: proyecto.user_id,
+    });
+    await db.callRpc('badge_publicar', {
+        p_project_id: fila.project_id,
+        p_commits: fila.commits,
+        p_ficheros_vivos: fila.ficheros_vivos,
+        p_concentracion_ficheros: fila.concentracion_ficheros,
+        p_concentracion_pct: fila.concentracion_pct,
+        p_joven: fila.joven,
+    });
+    // El token lo genera la BASE, no el cliente: uno elegido por quien lo usa se
+    // puede adivinar o reutilizar entre proyectos. `coalesce` dentro de la función
+    // hace que reencenderlo devuelva el mismo, así que republicar no invalida el
+    // badge que ya está pegado en un README.
+    const token = proyecto.badge_token ??
+        (await db.callRpc('badge_encender', {
+            p_project_id: proyecto.id,
+        }));
+    // `callRpc` devuelve null ante un cuerpo vacío (204) en vez de lanzar, que es
+    // lo correcto para las RPC `void` — pero aquí un null significaría imprimir
+    // una URL con la palabra «null» dentro y llamarlo éxito. Se para en seco: un
+    // snippet roto pegado en un README es peor que un error en la terminal.
+    if (!token) {
+        return {
+            ok: false,
+            motivo: 'La base no devolvió la llave del badge. No se ha impreso ningún\n' +
+                'snippet: pegar una URL incompleta en tu README sería peor. Vuelve a\n' +
+                'intentarlo, y si sigue, es un fallo del servidor y no tuyo.',
+        };
+    }
+    return {
+        ok: true,
+        snippet: snippetDeBadge(db.baseUrl, token),
+        nuevo: !proyecto.badge_token,
+    };
+}
+/**
+ * Apaga el badge: borra la llave y los números.
+ *
+ * Los números se van con la llave a propósito. Si el dueño retira el badge, los
+ * datos que solo existían para dibujarlo no se quedan ahí esperando a que
+ * alguien los vuelva a exponer.
+ */
+export async function apagarBadge(db, dir) {
+    const nombre = projectNameFor(dir);
+    const proyecto = await proyectoDe(db, nombre);
+    if (!proyecto)
+        return { ok: false, motivo: SIN_PROYECTO(nombre) };
+    if (!proyecto.badge_token) {
+        return { ok: false, motivo: `"${nombre}" no tiene ningún badge encendido.` };
+    }
+    await db.callRpc('badge_apagar', { p_project_id: proyecto.id });
+    return { ok: true, snippet: '', apagado: true };
+}
+//# sourceMappingURL=badge.js.map

package/dist/context.js

@@ -24,6 +24,7 @@
 import * as fs from "node:fs";
 import path from "node:path";
 import { feedWarningFor } from "./feed.js";
+import { avisoDeHookMudoPara } from "./hookMudo.js";
 import { fetchBriefSection } from "./sync.js";
 import { commitAliasesShort, derivaContraHead } from "./tools.js";
 /** Hard ceiling on the critical path: past this, emit nothing and move on. */
@@ -204,6 +205,11 @@ async function buildSessionContext(db, dir) {
     // Local and offline: one small file plus a git rev-parse. It cannot fail
     // because of the network or the session, which is the point.
     const pulse = await feedWarningFor(dir, { audience: "agent" }).catch(() => "");
+    // El segundo silencio (C6): el aviso previo a editar puede llevar semanas sin
+    // darse y el agente no tiene forma de notarlo — para él, «no me dijeron nada»
+    // y «no había nada que decir» son la misma frase. Por eso se le dice a él
+    // también y no solo al humano en el pre-commit.
+    const mudo = await avisoDeHookMudoPara(dir, { audience: "agent" }).catch(() => "");
     let brief = null;
     try {
         brief = await buildPayload(db, dir);
@@ -211,7 +217,7 @@ async function buildSessionContext(db, dir) {
     catch {
         brief = null;
     }
-    const parts = [pulse, brief].filter(Boolean);
+    const parts = [pulse, mudo, brief].filter(Boolean);
     return parts.length > 0 ? parts.join("\n\n") : null;
 }
 export async function printContext(db, dir) {

package/dist/guard.js

@@ -17,7 +17,11 @@ import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { execFileAsync, gitPath, projectNameFor } from "./git.js";
 import { feedWarningFor } from "./feed.js";
+import { VENTANA_DIAS, acierto, estaSilenciado, } from "./aciertos.js";
+import { avisoDeHookMudoPara } from "./hookMudo.js";
+import { correrReglas, informeDeReglas, repoEnDisco, } from "./reglas.js";
 import { avisoDeRamaPara } from "./rama.js";
+import { aliasesFor, canonicalizeModuleRows, expandModuleNames, } from "./aliasDeModulo.js";
 /** Exit code that asks the pre-commit hook to abort the commit. */
 export const EXIT_BLOCK = 3;
 // A commit should never feel slow because of us: whatever the network hasn't
@@ -462,6 +466,38 @@ function grepDelRepo(dir, simbolo, modo) {
  * siempre.
  */
 const GUARD_CACHE_V = 1;
+/**
+ * Los hallazgos de B9 que tocan lo que se va a commitear.
+ *
+ * Las reglas necesitan ver el repo ENTERO —para saber qué función SQL se
+ * redefinió, hay que leer todas las migraciones— pero solo se HABLA de los
+ * ficheros del commit. Sin ese recorte, un repo con seis hallazgos viejos
+ * saluda con seis avisos en cada commit hasta que alguien desinstala el hook.
+ */
+/**
+ * B6 · la línea de reconocimiento, si hay alguna que dar.
+ *
+ * Consulta propia y acotada: las alertas CERRADAS de los últimos días, que la
+ * consulta grande no trae (pide `resolved_at=is.null` a propósito). Trae pocas
+ * filas y va con `.catch` por fuera — si falla, no se dice nada y ya está.
+ */
+export async function aciertoReciente(db, dir, projectId) {
+    if (estaSilenciado())
+        return "";
+    const desde = new Date(Date.now() - VENTANA_DIAS * 86_400_000).toISOString();
+    const filas = await db.rest(`regression_alerts?select=id,module,plain,resolution,resolution_by,resolved_at` +
+        `&project_id=eq.${projectId}&resolution=eq.fixed&resolved_at=gte.${desde}` +
+        `&order=resolved_at.desc&limit=5`);
+    return acierto(filas, dir);
+}
+export async function reglasSobreLoStaged(dir) {
+    const staged = new Set(await stagedFiles(dir));
+    if (staged.size === 0)
+        return [];
+    const { stdout } = await execFileAsync("git", ["ls-files"], { cwd: dir });
+    const todos = stdout.split("\n").filter(Boolean);
+    return correrReglas(repoEnDisco(dir, todos)).filter((h) => staged.has(h.fichero));
+}
 export async function stagedFiles(dir) {
     // -z: NUL-separated, and crucially git does NOT octal-quote non-ASCII paths
     // (default quotepath would emit "m\303\263dulo.ts", which never matches the
@@ -519,23 +555,37 @@ async function fetchSignals(db, dir, env) {
     let filesByModule = new Map();
     const projectId = projects[0]?.id ?? null;
     if (projectId) {
-        alerts = await db.rest(
-        // `evidence_scope` NO es opcional aquí, por mucho que el tipo lo sea: sin
-        // él, `alcanceDelRepo` devuelve "sin_declarar" para TODA alerta y la
-        // refutación de `avisoRefutado` no descarta nada nunca. El campo se
-        // escribe en la base desde el 2026-07-26 y ningún cliente lo pedía; el
-        // comentario de `avisoRefutado` decía que esa rama "disparó 0 veces en
-        // producción", y disparó cero porque el dato no llegaba, no porque el gate
-        // fuera barato. Lo vigila `test/alcanceLlegaAlCliente.test.ts`, que lee
-        // ESTA línea: un test de comportamiento no lo caza, porque los stubs
-        // inyectan el campo a mano.
-        `regression_alerts?select=id,module,plain,created_at,evidence_symbol,evidence_expect,evidence_scope,evidence_line,files&project_id=eq.${projectId}&resolved_at=is.null&order=created_at.desc&limit=${MAX_ALERTS}`);
+        // Los alias van en PARALELO con las alertas, no después: este camino corre
+        // en cada pre-commit y una ronda de red más se paga en cada commit del día.
+        const [alertasCrudas, { aliases, hermanas }] = await Promise.all([
+            db.rest(
+            // `evidence_scope` NO es opcional aquí, por mucho que el tipo lo sea: sin
+            // él, `alcanceDelRepo` devuelve "sin_declarar" para TODA alerta y la
+            // refutación de `avisoRefutado` no descarta nada nunca. El campo se
+            // escribe en la base desde el 2026-07-26 y ningún cliente lo pedía; el
+            // comentario de `avisoRefutado` decía que esa rama "disparó 0 veces en
+            // producción", y disparó cero porque el dato no llegaba, no porque el gate
+            // fuera barato. Lo vigila `test/alcanceLlegaAlCliente.test.ts`, que lee
+            // ESTA línea: un test de comportamiento no lo caza, porque los stubs
+            // inyectan el campo a mano.
+            `regression_alerts?select=id,module,plain,created_at,evidence_symbol,evidence_expect,evidence_scope,evidence_line,files&project_id=eq.${projectId}&resolved_at=is.null&order=created_at.desc&limit=${MAX_ALERTS}`),
+            aliasesFor(db, projectId),
+        ]);
+        alerts = canonicalizeModuleRows(alertasCrudas, aliases);
         const modules = [
             ...new Set(alerts.map((a) => (a.module ?? "").trim()).filter(Boolean)),
         ];
         if (modules.length > 0) {
-            const rows = await db.rest(`change_module?select=module,files,created_at&project_id=eq.${projectId}&module=in.(${encodeURIComponent(pgInList(modules))})&order=created_at.desc&limit=200`);
-            filesByModule = moduleFilesUnion(rows);
+            // EXPANDIR ANTES DE CONSULTAR. El filtro va al servidor por nombre y en la
+            // base siguen las etiquetas viejas, así que preguntar solo por el canónico
+            // devolvería un trozo de los ficheros del módulo — y el guardián se
+            // callaría ante una alerta abierta por un fichero que sí es suyo, que es
+            // exactamente el fallo que `moduleFilesUnion` documenta del 2026-07-18.
+            const rows = await db.rest(`change_module?select=module,files,created_at&project_id=eq.${projectId}&module=in.(${encodeURIComponent(pgInList(expandModuleNames(modules, hermanas)))})&order=created_at.desc&limit=200`);
+            // Y canonicalizar DESPUÉS: la unión tiene que agrupar los ficheros de las
+            // dos etiquetas bajo una sola clave, o el aviso buscaría por un nombre que
+            // no está en el mapa.
+            filesByModule = moduleFilesUnion(canonicalizeModuleRows(rows, aliases));
         }
     }
     if (cacheFile) {
@@ -687,6 +737,27 @@ export async function runGuard(db, dir, env = process.env) {
     const pulse = await feedWarningFor(dir);
     if (pulse)
         console.error(pulse);
+    // Y el pulso del OTRO hook (C6). Son dos silencios distintos y hasta hoy solo
+    // se vigilaba uno: `feedWarningFor` dice si el atlas deja de alimentarse;
+    // esto dice si el aviso PREVIO A EDITAR dejó de darse. Un hook de retención
+    // pasiva desinstalado se ve igual que un repo tranquilo, así que sin esto la
+    // única señal de que se rompió es que el usuario deje de usar el producto.
+    // Offline y de un `stat`, como el de arriba: no puede frenar un commit.
+    const mudo = await avisoDeHookMudoPara(dir);
+    if (mudo)
+        console.error(mudo);
+    // B9 · los patrones que ya rompieron aquí. Offline y sin cuenta, como los dos
+    // de arriba: son hechos del repo, no del atlas.
+    //
+    // ACOTADO A LO QUE SE VA A COMMITEAR, y esa decisión es lo que lo hace
+    // usable: medidas sobre este repo, las reglas encuentran seis cosas ciertas
+    // pero VIEJAS. Avisar de las seis en cada commit sería ruido desde el primer
+    // día, y un pre-commit ruidoso se desinstala. Se habla solo de los ficheros
+    // que el commit toca; el resto sale en el informe, no aquí.
+    const hallazgos = await reglasSobreLoStaged(dir).catch(() => []);
+    const informe = informeDeReglas(hallazgos);
+    if (informe)
+        console.error(informe);
     // ANTES del corte por credenciales a proposito: que tu rama vaya a revertir el
     // trabajo de otro es un hecho de git, no del atlas. Quien no tenga sesion —o
     // no tenga cuenta— tambien merece enterarse. Ver rama.ts para el porque de la
@@ -724,6 +795,18 @@ export async function runGuard(db, dir, env = process.env) {
         await logRun(dir, `timeout after ${GUARD_TIMEOUT_MS}ms — passing`);
         return 0;
     }
+    // B6 · cuando el aviso acierta, se dice. Va DESPUÉS de tener señales —así
+    // reusa el project_id que ya se resolvió— y es best-effort entero: una línea
+    // de reconocimiento no puede costar un commit. Se dice una vez por alerta.
+    //
+    // Es lo único que este producto dice cuando algo va BIEN. Sin ello solo habla
+    // de riesgos, y un producto que solo trae malas noticias se lee como una
+    // molestia hasta que se desinstala.
+    if (signals.projectId) {
+        const linea = await aciertoReciente(db, dir, signals.projectId).catch(() => "");
+        if (linea)
+            console.error(linea);
+    }
     // Presupuesto de greps para decidir A QUIEN se avisa. `contarEnRepo` y
     // `ficherosEnRepo` son execFileSync, o sea que BLOQUEAN el bucle de eventos y
     // el techo de GUARD_TIMEOUT_MS no puede desalojarlos — un Promise.race no gana