changebook 0.7.0 → 0.8.0

package/README.md

@@ -53,6 +53,10 @@ your other servers.
 | `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 import [dir] [--commits N]` | Backfill the last N commits (default 25) through the Anthropic Batch API — 50% cheaper and non-interactive, for seeding the atlas on an existing repo. |
+| `changebook scan [dir] [--json\|--card\|--badge]` | Coupling report for **any** repo from its git history alone: no account, no network, writes nothing — run it on something you just cloned. `--card` renders a shareable SVG, `--badge` publishes four numbers and prints the README snippet (needs an account; `--badge --off` turns it off). The badge exposes those four numbers and nothing else — not your code, modules or change summaries. |
+| `changebook silence [dir]` | How often the `PreToolUse` hook stays quiet, with both raw numbers. Local by design: it answers the day you install it, not two days later. |
+| `changebook friction [dir]` | Where the agent's work gets redone in this repo, read from the **local** Claude Code transcripts — no prose leaves the machine, only paths, modules, dates and a session hash. Says **MUERTO** if the repo has edits and it read nothing, and reports its own blind spot: edits made through the shell (`sed -i`, heredocs) leave no before/after, so ~25% of writes are invisible to it and it says so. |
 | `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/agregados.js

@@ -0,0 +1,496 @@
+/**
+ * Los agregados del atlas: funciones puras sobre las filas que sirve el MCP.
+ *
+ * POR QUE EXISTE. Espejo de `supabase/functions/mcp/scope.ts`. Salen de
+ * `tools.ts` el 09/08 para que una herramienta pueda vivir en su propio fichero
+ * sin cerrar un ciclo: `toolProjectBrief.ts` necesita `briefModules` y
+ * `aggregateFileContext`, y si los pidiera a `tools.ts` -que a su vez lo importa
+ * para registrarlo- el modulo se importaria a si mismo por el camino largo.
+ *
+ * Aqui NO entra nada que sepa del repo local (git, process.cwd) ni de una tool
+ * concreta: eso se queda en `tools.ts`. `recordRead` es la unica excepcion y
+ * viaja porque la usan TODAS las herramientas y solo necesita el cliente.
+ *
+ * Varias de estas son espejos del hospedado y su paridad esta fijada por
+ * contratos que comparan SALIDAS, no menciones: ver mcpParity, espejoDeCommits,
+ * radioDeImpacto y elPaqueteNoPideToolsQueNoTiene.
+ */
+import { etiquetaPorSlug, slugModule } from "./aliasDeModulo.js";
+// Pre-edit lookup helpers (mirror of the hosted scope.ts — the npm package
+// must stay self-contained, so these three stay tiny and duplicated).
+// Exported so test/mcpParity.test.ts can pin them equal to the hosted copies:
+// drift would break atlas_file_context on stdio silently (audit M7).
+export function normalizeRepoPath(path) {
+    return path.trim().replace(/^\.\//, "").replace(/^\/+/, "");
+}
+export function fileContainsFilter(path) {
+    return `files=cs.${encodeURIComponent(JSON.stringify([path]))}`;
+}
+export function quotedInList(values) {
+    return values
+        .map((v) => `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`)
+        .join(",");
+}
+/**
+ * Filtro PostgREST para resolver alertas de regresión. Espejo de
+ * supabase/functions/mcp/scope.ts::resolveAlertFilter — paridad de SALIDAS
+ * fijada en test/elPaqueteNoPideToolsQueNoTiene.test.ts.
+ *
+ * `userId` es OPCIONAL aquí y obligatorio allí, y la diferencia no es un
+ * descuido: el hospedado consulta con la service key, que se salta RLS, así que
+ * el aislamiento de cuenta tiene que escribirlo él a mano en el filtro. Este
+ * servidor consulta con el token del usuario, y RLS ya acota cada fila a su
+ * dueño. Añadir aquí un `user_id` que no tenemos —el cliente no conoce su
+ * propio uuid sin una llamada extra— sería pedirle a PostgREST que filtre por
+ * `undefined`, que es peor que no filtrar: casa con cero filas y se lee como
+ * «no había nada que cerrar».
+ *
+ * Se acepta el parámetro para poder comparar las dos implementaciones con la
+ * MISMA entrada en un test: sin él, la paridad solo podría afirmarse a medias,
+ * que es exactamente lo que la invariante 16 prohíbe.
+ */
+export function resolveAlertFilter(input) {
+    return ((input.userId ? `user_id=eq.${input.userId}&` : "") +
+        `project_id=eq.${input.projectId}` +
+        `&module=eq.${encodeURIComponent(input.module)}` +
+        `&resolved_at=is.null` +
+        (input.symbol
+            ? `&evidence_symbol=eq.${encodeURIComponent(input.symbol)}`
+            : ""));
+}
+/**
+ * El contexto de UN fichero: qué módulos lo tocan, cuántas veces y con qué nota.
+ *
+ * Espejo de supabase/functions/mcp/scope.ts::aggregateFileContext — paridad de
+ * SALIDAS fijada en test/elPaqueteNoPideToolsQueNoTiene.test.ts.
+ *
+ * ⚠ SE EXTRAE Y ADEMÁS ARREGLA. Esto vivía escrito a mano dentro de
+ * `atlas_file_context` y agrupaba por NOMBRE CRUDO (`byModule.get(name)`),
+ * mientras el hospedado agrupaba por slug. O sea que en stdio un módulo escrito
+ * de dos formas —`Núcleo` y `Nucleo`— servía DOS bloques para el mismo fichero,
+ * cada uno con la mitad de los cambios, y el agente los leía como dos módulos
+ * que no se conocen. Es la invariante 16 exacta: media normalización se lee
+ * igual que una entera, y `canonicalizeModuleRows` resuelve ALIAS, no grafías.
+ *
+ * El alias se sigue resolviendo antes de llamar aquí; esto es la otra mitad.
+ */
+export function aggregateFileContext(file, rows) {
+    const etiqueta = etiquetaPorSlug(rows.map((r) => r.module ?? ""));
+    const byModule = new Map();
+    const changelogIds = [];
+    for (const row of rows) {
+        if (row.changelog_id && !changelogIds.includes(row.changelog_id)) {
+            changelogIds.push(row.changelog_id);
+        }
+        const name = (row.module ?? "").trim();
+        if (!name)
+            continue;
+        const slug = slugModule(name);
+        const existing = byModule.get(slug);
+        if (existing) {
+            existing.changes += 1;
+        }
+        else {
+            byModule.set(slug, {
+                module: etiqueta.get(slug) ?? name,
+                risk: row.risk,
+                changes: 1,
+                last_changed: row.created_at.slice(0, 10),
+                last_note: row.note,
+            });
+        }
+    }
+    return { file, modules: [...byModule.values()], changelogIds };
+}
+/**
+ * El mapa de módulos del brief: los `max` más recientes, y CUÁNTOS hay.
+ *
+ * Espejo de supabase/functions/mcp/scope.ts::briefModules — paridad de SALIDAS
+ * fijada en test/elPaqueteNoPideToolsQueNoTiene.test.ts.
+ *
+ * AGRUPA POR SLUG, no por el nombre crudo, y ahí estaba el bug que más mentía:
+ * `total` contaba 80 módulos donde había 76, y cuatro de ellos eran la mitad
+ * pequeña de un módulo partido por una tilde o una mayúscula (invariante 16).
+ *
+ * Y `total` NO es «todos los módulos del proyecto»: es cuántos distintos hay en
+ * la VENTANA de filas que se le pasa. El brief lo dice con esas palabras porque
+ * medido el 03/08 la ventana estaba llena al ras, o sea que el número BAJA
+ * según se trabaja, y llamarlo «total» hacía leer eso como módulos que
+ * desaparecen.
+ */
+export function briefModules(rows, max = 15) {
+    const etiqueta = etiquetaPorSlug(rows.map((r) => r.module ?? ""));
+    const byModule = new Map();
+    for (const row of rows) {
+        const name = (row.module ?? "").trim();
+        if (!name)
+            continue;
+        const slug = slugModule(name);
+        const existing = byModule.get(slug);
+        if (existing) {
+            existing.changes += 1;
+        }
+        else {
+            byModule.set(slug, {
+                module: etiqueta.get(slug) ?? name,
+                domain: row.domain ?? null,
+                risk: row.risk,
+                changes: 1,
+                last_changed: row.created_at.slice(0, 10),
+            });
+        }
+    }
+    return { modules: [...byModule.values()].slice(0, max), total: byModule.size };
+}
+/** El uuid del proyecto dentro del filtro que devuelve `projectFilterFor`. */
+export function projectIdFromFilter(filter) {
+    return /project_id=eq\.([0-9a-f-]+)/.exec(filter)?.[1] ?? null;
+}
+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. */
+export 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(slug(label)))
+            continue;
+        const deps = Array.isArray(r.deps)
+            ? r.deps.map((d) => (typeof d === "string" ? d.trim() : "")).filter(Boolean)
+            : [];
+        graph.set(slug(label), deps);
+    }
+    const reverse = new Map();
+    for (const r of rows) {
+        const crudo = (r.module ?? "").trim();
+        if (!crudo)
+            continue;
+        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);
+            reverse.set(key, set);
+        }
+    }
+    const out = new Map();
+    for (const t of targets) {
+        const label = (t ?? "").trim();
+        if (!label)
+            continue;
+        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));
+    }
+    return out;
+}
+/**
+ * Reincidencia (espejo de supabase/functions/mcp/scope.ts::computeRecidivism —
+ * paridad en test/reincidenciaFileContext). Por módulo, nº de problemas de
+ * regresión DISTINTOS (count(distinct plain), all-time), solo los con
+ * 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) {
+        // 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 (!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 RecidivismMap();
+    for (const [m, set] of plainsByModule) {
+        if (set.size >= 2)
+            out.set(m, set.size);
+    }
+    return out;
+}
+export function filesUnionByChange(rows, cap = FILES_CAP) {
+    const acc = new Map();
+    for (const r of rows) {
+        if (!Array.isArray(r.files))
+            continue;
+        let list = acc.get(r.changelog_id);
+        if (!list) {
+            list = [];
+            acc.set(r.changelog_id, list);
+        }
+        for (const f of r.files) {
+            if (typeof f === "string" && f.length > 0 && !list.includes(f)) {
+                list.push(f);
+            }
+        }
+    }
+    const out = new Map();
+    for (const [id, list] of acc) {
+        out.set(id, {
+            files: list.slice(0, cap),
+            more: Math.max(0, list.length - cap),
+        });
+    }
+    return out;
+}
+// Espejo de supabase/functions/mcp/scope.ts (paridad en
+// test/espejoDeCommits.test.ts): aliases post-squash del mismo contenido,
+// para que el hash citado exista en el main del consultante.
+export function commitAliasesShort(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .filter((h) => typeof h === "string" && /^[0-9a-f]{7,64}$/i.test(h))
+        .map((h) => h.slice(0, 7));
+}
+export function commitLabel(hash, aliasesRaw) {
+    const corto = hash?.slice(0, 7) ?? null;
+    if (!corto)
+        return null;
+    const aliases = commitAliasesShort(aliasesRaw);
+    return aliases.length > 0 ? `${corto} (=${aliases.join(",")})` : corto;
+}
+export const FILE_COMMITS_CAP = 5;
+export function recentCommitsForFile(changelogIds, commitById, cap = FILE_COMMITS_CAP) {
+    const all = changelogIds
+        .map((id) => commitById.get(id))
+        .filter((c) => Boolean(c));
+    return { commits: all.slice(0, cap), more: Math.max(0, all.length - cap) };
+}
+// Consultation metering (never billing): each successful read leaves a row in
+// atlas_reads so the web can show "your agent consulted the atlas N times".
+// Best-effort and non-blocking — metering must never break or slow a read.
+// user_id is filled server-side (column default auth.uid()).
+export function recordRead(db, tool, projectFilter, charsServed, latencyMs) {
+    const projectId = /project_id=eq\.([0-9a-f-]+)/.exec(projectFilter)?.[1] ?? null;
+    void db
+        .insertRow("atlas_reads", {
+        project_id: projectId,
+        tool,
+        source: "stdio",
+        chars_served: charsServed,
+        // Latencia del handler (encargo 0dbbfbf4): nullable a propósito — es
+        // metering, jamás contrato, y un servidor viejo simplemente no la manda.
+        ...(latencyMs !== undefined
+            ? { latency_ms: Math.max(0, Math.min(Math.round(latencyMs), 600000)) }
+            : {}),
+    })
+        .catch(() => { });
+}
+/** Reincidente a partir de 3 regresiones distintas. Espejo del hospedado. */
+const RECIDIVIST_MIN = 3;
+/** Prefijo normalizado por el que dos avisos se consideran el mismo. */
+const FIRMA_CHARS = 120;
+/**
+ * La firma de un aviso: su prefijo normalizado, sin tildes ni puntuacion.
+ * Espejo de supabase/functions/mcp/scope.ts.
+ */
+export function firmaDeAviso(plain) {
+    return plain
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim()
+        .slice(0, FIRMA_CHARS);
+}
+/**
+ * Un aviso por FIRMA, no por texto exacto.
+ *
+ * `unoPorTexto` ya colapsaba los identicos y no bastaba: dos avisos que
+ * comparten las primeras ~200 letras y divergen en la ultima frase se servian
+ * los DOS y abrian la pantalla. Para quien lo lee es una repeticion, y un
+ * avisador que repite se ignora igual que uno que se equivoca.
+ *
+ * SOBREVIVE EL MAS LARGO, y eso es lo que lo hace seguro: si dos coinciden al
+ * principio y difieren al final, se queda el que trae la diferencia. Colapsar no
+ * puede costar informacion que solo estaba en uno.
+ *
+ * ES LA PANTALLA, NO LA IDENTIDAD: el dedup de creacion sigue distinguiendo por
+ * (simbolo, expectativa), porque «tiene que seguir» y «tiene que desaparecer»
+ * son afirmaciones opuestas y colapsarlas escondería una regresion real.
+ */
+export function colapsaAvisosParecidos(avisos) {
+    const mejor = new Map();
+    for (const a of avisos) {
+        const plain = (a.plain ?? "").trim();
+        if (!plain)
+            continue;
+        const clave = firmaDeAviso(plain);
+        if (!clave)
+            continue;
+        const actual = mejor.get(clave);
+        if (!actual || plain.length > (actual.plain ?? "").trim().length) {
+            mejor.set(clave, a);
+        }
+    }
+    return [...mejor.values()];
+}
+/**
+ * El plan de accion: una sola lista priorizada, lo mas urgente primero.
+ *
+ * POR TIERS EXPLICITOS Y NO POR UNA PUNTUACION. Un numero oculto obliga a
+ * confiar; cuatro tiers con nombre dejan discutir el orden. Espejo de
+ * supabase/functions/mcp/scope.ts::buildActionPlan — paridad de SALIDAS fijada
+ * en test/elPaqueteNoPideToolsQueNoTiene.
+ */
+export function buildActionPlan(input) {
+    const items = [];
+    // Tier 1 — un cambio analizado ya rompio algo.
+    for (const a of colapsaAvisosParecidos(input.alerts)) {
+        const plain = (a.plain ?? "").trim();
+        if (!plain)
+            continue;
+        items.push({
+            tier: 1,
+            kind: "regression",
+            module: a.module,
+            what: `Regresión abierta${a.module ? ` en ${a.module}` : ""}`,
+            why: plain,
+        });
+    }
+    // Tier 2 — un control de salud que el analisis marco roto.
+    for (const h of input.atRiskHealth) {
+        items.push({
+            tier: 2,
+            kind: "health",
+            module: null,
+            what: `Control de salud en riesgo: ${h.check}`,
+            why: h.evidence,
+            check: h.check,
+        });
+    }
+    // Tier 3 — modulo marcado hotspot (fragil por diseno).
+    const seenHotspots = new Set();
+    for (const m of input.modules) {
+        if (m.risk !== "hotspot")
+            continue;
+        const previas = input.recidivism.get(m.module);
+        items.push({
+            tier: 3,
+            kind: "hotspot",
+            module: m.module,
+            what: `Módulo crítico (hotspot): ${m.module}`,
+            why: `${m.changes} cambio(s), últ. ${m.last_changed}` +
+                (previas ? ` · ${previas} regresiones previas` : ""),
+            changes: m.changes,
+            lastChanged: m.last_changed,
+            ...(previas ? { prior: previas } : {}),
+        });
+        seenHotspots.add(m.module);
+    }
+    // Tier 4 — reincidente que NO es ya hotspot (no duplicar).
+    for (const [mod, count] of input.recidivism) {
+        if (count >= RECIDIVIST_MIN && !seenHotspots.has(mod)) {
+            items.push({
+                tier: 4,
+                kind: "recidivist",
+                module: mod,
+                what: `Reincidente: ${mod}`,
+                why: `${count} regresiones distintas a lo largo del tiempo`,
+                count,
+            });
+        }
+    }
+    return items
+        .map((it, i) => ({ it, i }))
+        .sort((a, b) => a.it.tier - b.it.tier || a.i - b.i)
+        .map(({ it }, idx) => ({ ...it, rank: idx + 1 }));
+}
+/**
+ * La linea de precision que acompana al plan. `null` cuando no hay nada honesto
+ * que decir — y esa es la mitad importante: un porcentaje sin refutaciones mide
+ * quien juzga, no los avisos. Espejo del hospedado.
+ */
+export function lineaDePrecision(p) {
+    if (!p)
+        return null;
+    const juzgadas = p.acertado + p.refutado + p.sin_tocar + p.caducado;
+    if (juzgadas === 0)
+        return null;
+    if (p.precision === null) {
+        const unSoloLado = p.motivo === "un_solo_lado" ||
+            (p.motivo == null &&
+                p.denominador >= p.minimo &&
+                (p.acertado === 0 || p.refutado === 0));
+        if (unSoloLado) {
+            const falta = p.refutado === 0 ? "none refuted" : "none confirmed";
+            return (`Warning accuracy: not published yet — ${p.denominador} judged, but ${falta}. ` +
+                `A score with only one kind of verdict in it measures the judging, not the warnings.`);
+        }
+        return (`Warning accuracy: not enough judged warnings yet ` +
+            `(${p.denominador} of ${p.minimo} needed). We publish the number only when it means something.`);
+    }
+    return (`Warning accuracy: ${Math.round(p.precision * 100)}% ` +
+        `(${p.acertado} of ${p.denominador} judged warnings were real). ` +
+        `Warnings nobody judged are excluded, not counted as misses.`);
+}
+/** Ventana de avisos «abiertos» del plan: 14 dias. Espejo de analysis.ts. */
+const ATLAS_ALERT_WINDOW_DAYS = 14;
+export function alertasDesde() {
+    return new Date(Date.now() - ATLAS_ALERT_WINDOW_DAYS * 24 * 3600 * 1000).toISOString();
+}
+//# sourceMappingURL=agregados.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/friccionDelBrief.js

@@ -0,0 +1,102 @@
+/**
+ * La entrega de la fricción por el MCP **local** (stdio), gemela de
+ * `supabase/functions/_shared/friccionConsultas.ts`.
+ *
+ * POR QUÉ EXISTE, medido el 24/08: el bloque de fricción se implementó sólo en
+ * la edge function, así que un agente conectado por el **CLI del paquete npm**
+ * —que es como se conecta la mayoría, y como estaba conectada la sesión que
+ * escribió esto— no veía la fricción JAMÁS. El lector y el comando
+ * `changebook friction` sí estaban en el CLI; lo que faltaba era la entrega.
+ *
+ * Es la misma deriva entre las dos implementaciones que ya costó las once
+ * portadas del paquete: el MCP stdio registraba 4 tools y su propio `sync.ts`
+ * pedía 7. Por eso esto vive en un fichero gemelo del del servidor y no
+ * mezclado con el lector: `test/laFriccionEsLaMismaEnLosDosLados.test.ts` los
+ * compara función a función, y un gemelo que se quede corto pone rojo.
+ *
+ * El corte es el MISMO que en el servidor: `friction.ts` rinde la línea de un
+ * suceso, esto arma la consulta y el bloque.
+ *
+ * ⚠ LO QUE SIGUE SIN CUBRIRSE, Y ES DELIBERADO: el hospedado sirve además la
+ * TASA por fichero en `atlas_file_context`, y el CLI no. No es un olvido: esa
+ * línea exige ≥2 correcciones sobre el mismo fichero y, medido el 24/08 contra
+ * las 1.509 filas de producción, la cumple **1 fichero de 341**. Pagar una
+ * consulta de red en el camino que corre ANTES DE CADA EDICIÓN para eso es un
+ * mal cambio. Si algún día la densidad sube, el gemelo que falta es
+ * `consultaPorFicheros` + `friccionPorRuta`, y el contrato de paridad de
+ * `test/laFriccionEsLaMismaEnLosDosLados.test.ts` es donde se engancha.
+ */
+import { lineaDeSuceso, VENTANA_DIAS } from "./friction.js";
+/**
+ * El techo de PostgREST. Pedir más no trae más: trae 1.000 y se calla.
+ *
+ * Aquí casi no muerde, y a propósito: la consulta filtra por veredicto en el
+ * servidor, así que lo que cuenta contra el techo son las correcciones (8 en 30
+ * días, medido) y no las ediciones (1.509).
+ */
+export const TOPE_DE_FILAS = 1000;
+/**
+ * Cuántos sucesos como mucho en el brief. Es lo PRIMERO que lee el agente al
+ * abrir y ya es largo: cinco caben sin desplazar a los avisos abiertos.
+ */
+export const MAX_SUCESOS = 5;
+export function desdeLaVentana(ahoraMs) {
+    return new Date(ahoraMs - VENTANA_DIAS * 24 * 60 * 60 * 1000).toISOString();
+}
+/**
+ * La consulta de sucesos. Idéntica a la del servidor, y el contrato de paridad
+ * lo exige carácter a carácter: dos URLs que difieran en el `order` o en el
+ * filtro darían briefs distintos según por dónde te conectes.
+ */
+export function consultaDeSucesos(filtroProyecto, ahoraMs) {
+    return (`friction_event?select=occurred_at,path,module` +
+        `&veredicto=eq.correccion` +
+        `&occurred_at=gte.${desdeLaVentana(ahoraMs)}` +
+        `&order=occurred_at.desc&limit=${TOPE_DE_FILAS}${filtroProyecto}`);
+}
+export function sucesosDeFriccion(filas) {
+    // Se reordena aquí aunque la consulta ya pida `order=occurred_at.desc`: esta
+    // función es pura y tiene contrato propio, y un contrato que depende del
+    // `order` de OTRO módulo se rompe el día que alguien reutilice ésta con filas
+    // de otra procedencia.
+    return filas
+        .map((f) => ({ fecha: f.occurred_at, ruta: f.path, modulo: f.module }))
+        .sort((a, b) => (b.fecha ?? "").localeCompare(a.fecha ?? ""));
+}
+/**
+ * Las líneas del bloque del brief, o `[]` si no hay nada que decir.
+ *
+ * Publica SUCESOS, no una tasa: con 8 correcciones en 30 días un porcentaje no
+ * informa de nada, y ocho hechos con su fecha sí. El razonamiento entero está
+ * en `docs/superpowers/specs/2026-08-23-mapa-de-friccion-design.md`.
+ */
+export function bloqueDeFriccion(filas) {
+    if (filas.length === 0)
+        return [];
+    const truncado = filas.length >= TOPE_DE_FILAS;
+    const sucesos = sucesosDeFriccion(filas);
+    const mostrados = sucesos.slice(0, MAX_SUCESOS);
+    // «al menos» cuando el servidor cortó: el conteo sigue siendo cierto como
+    // cota inferior, y decir el número pelado sería afirmar de más.
+    const cuantas = truncado ? `at least ${sucesos.length}` : `${sucesos.length}`;
+    const lineas = [
+        "",
+        `## Where work got redone (${cuantas} in the last ${VENTANA_DIAS} days)`,
+        ...mostrados.map((s) => `- ${lineaDeSuceso(s)}`),
+    ];
+    // No recortar en silencio: un tope alcanzado sin decirlo se lee como «esto es
+    // todo».
+    if (sucesos.length > mostrados.length) {
+        lineas.push(`- …and ${sucesos.length - mostrados.length} more.`);
+    }
+    return lineas;
+}
+/** La forma del structured, armada aquí para que el brief sólo la esparza. */
+export function friccionParaStructured(filas) {
+    return sucesosDeFriccion(filas).map((x) => ({
+        date: (x.fecha ?? "").slice(0, 10),
+        path: x.ruta,
+        module: x.modulo,
+    }));
+}
+//# sourceMappingURL=friccionDelBrief.js.map