changebook 0.6.0 → 0.7.1

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/analyze.js

@@ -6,9 +6,37 @@
  */
 import * as path from "node:path";
 import { atlasWebUrl } from "./browser.js";
-import { commitDiff, execFileAsync, FICHEROS_GENERADOS, GIT_MAX_BUFFER_BYTES, gitErrorMessage, MAX_DIFF_CHARACTERS, projectNameFor, usableSummary, } from "./git.js";
+import { commitDiff, esFicheroGenerado, execFileAsync, FICHEROS_GENERADOS, ficherosDelCommit, GIT_MAX_BUFFER_BYTES, gitErrorMessage, MAX_DIFF_CHARACTERS, projectNameFor, usableSummary, } from "./git.js";
 import { canonicalDiffHash } from "./canonical.js";
 import { optimizeTokensForAI, truncateAtFileBoundary } from "./optimize.js";
+/**
+ * Por qué se salta un commit sin diff analizable. Tres causas, tres frases.
+ *
+ * HASTA EL 04/08 ERA UNA SOLA, Y ADIVINABA: «has no analyzable diff (merge?)».
+ * `commitDiff` excluye los ficheros que ChangeBook genera —`CLAUDE.md`,
+ * `AGENTS.md`— para no registrar sus propias regeneraciones en bucle, así que un
+ * commit normal que solo toque esos devuelve diff vacío igual que un merge. El
+ * `0bac769` de este repo era exactamente eso y el mensaje mandaba a buscar un
+ * merge que no existía.
+ *
+ * Saltar sigue siendo lo correcto en los tres casos: lo que cambia es que el
+ * instrumento sepa distinguirlos en vez de elegir uno (invariante 17 del repo).
+ *
+ * Es una función aparte y pura para que se pueda medir la ELECCIÓN sin montar
+ * un repo ni capturar `console.error`.
+ */
+export function motivoDelSalto(hash, ficheros) {
+    const corto = hash.slice(0, 8);
+    if (!ficheros.length) {
+        return `Commit ${corto} no toca ningun fichero (merge o commit vacio). Skipped.`;
+    }
+    if (ficheros.every(esFicheroGenerado)) {
+        return `Commit ${corto} solo toca ficheros que genera ChangeBook (${ficheros.join(", ")}). Saltado a proposito: regenerar el mapa no es un cambio de producto.`;
+    }
+    // Ni vacío ni todo generado: aquí no hay explicación conocida, y decirlo así
+    // es el punto. Inventar una tercera causa plausible sería repetir el bug.
+    return `Commit ${corto} toca ${ficheros.length} fichero(s) y aun asi no deja diff que analizar. Skipped. Ficheros: ${ficheros.join(", ")}`;
+}
 export async function analyze(db, options = {}) {
     const cwd = path.resolve(options.dir ?? process.cwd());
     const projectName = projectNameFor(cwd);
@@ -27,7 +55,17 @@ export async function analyze(db, options = {}) {
         agentSummary = usableSummary(meta.message) ?? undefined;
         rawDiff = await commitDiff(cwd, meta.hash);
         if (!rawDiff.trim()) {
-            console.error(`Commit ${meta.hash.slice(0, 8)} has no analyzable diff (merge?). Skipped.`);
+            // Un diff vacío tiene DOS causas y hasta el 04/08 se contaban como una:
+            // el commit no toca nada (un merge), o toca solo ficheros que ChangeBook
+            // genera y que `commitDiff` excluye a propósito. Decir «(merge?)» de lo
+            // segundo es adivinar, y adivinar mal: `0bac769` era un commit normal de
+            // CLAUDE.md y AGENTS.md, y el mensaje mandaba a buscar un merge que no
+            // existía.
+            //
+            // Saltarlo sigue siendo lo correcto en los dos casos. Lo que cambia es
+            // que ahora el instrumento sabe por qué está saltando (invariante 17).
+            const ficheros = await ficherosDelCommit(cwd, meta.hash);
+            console.error(motivoDelSalto(meta.hash, ficheros));
             return;
         }
     }

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/git.js

@@ -75,8 +75,9 @@ export function usableSummary(message) {
  * 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.
+ * salta, que es la respuesta correcta: regenerar el mapa no es un cambio de
+ * producto. Lo que NO era correcto era cómo lo contaba — ver
+ * `ficherosDelCommit` aquí abajo y el mensaje en `analyze.ts`.
  */
 export const FICHEROS_GENERADOS = [
     ":(exclude)CLAUDE.md",
@@ -104,6 +105,45 @@ export async function commitDiff(cwd, hash) {
         throw new Error(`Could not read the diff of ${hash.slice(0, 8)}: ${gitErrorMessage(error)}`);
     }
 }
+/**
+ * Los ficheros que toca un commit, SIN excluir los generados.
+ *
+ * POR QUÉ EXISTE. `commitDiff` excluye `CLAUDE.md`/`AGENTS.md`, así que un
+ * commit que solo toca esos devuelve diff vacío — igual que un merge, que no
+ * tiene diff propio. Dos situaciones distintas, una sola señal, y `analyze`
+ * elegía la equivocada: decía «has no analyzable diff (merge?)» de un commit
+ * normal que ni siquiera era un merge (medido el 04/08 con `0bac769`).
+ *
+ * Es la invariante 17 del repo dentro del producto: la ausencia de diff no
+ * prueba la ausencia de cambio mientras el instrumento no sepa distinguir por
+ * qué está ausente. Esta función es lo que le da esa segunda pregunta.
+ *
+ * Devuelve `[]` si el commit no toca ningún fichero — el caso del merge de
+ * verdad, y también el de un commit vacío.
+ */
+export async function ficherosDelCommit(cwd, hash) {
+    try {
+        const { stdout } = await execFileAsync("git", 
+        // Mismo `--end-of-options` que commitDiff, por el mismo motivo.
+        ["show", "--pretty=format:", "--name-only", "--end-of-options", hash], { cwd, encoding: "utf8", maxBuffer: GIT_MAX_BUFFER_BYTES });
+        return stdout
+            .split("\n")
+            .map((l) => l.trim())
+            .filter(Boolean);
+    }
+    catch (error) {
+        throw new Error(`Could not read the files of ${hash.slice(0, 8)}: ${gitErrorMessage(error)}`);
+    }
+}
+/**
+ * ¿Es un fichero de los que ChangeBook genera? Se decide con las MISMAS rutas
+ * que excluye `commitDiff`, derivadas de ella y no reescritas: dos listas que
+ * pudieran separarse harían que el mensaje explicara un salto que no ocurrió.
+ */
+export function esFicheroGenerado(ruta) {
+    const nombre = ruta.split("/").pop() ?? "";
+    return FICHEROS_GENERADOS.some((patron) => patron.replace(/^:\(exclude\)(\*\*\/)?/, "") === nombre);
+}
 /** Pulls git's stderr out of an execFile rejection for a readable message. */
 export function gitErrorMessage(error) {
     if (typeof error === "object" &&