changebook 0.7.1 → 0.9.0

package/README.md

@@ -53,6 +53,11 @@ 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 audit [dir]` | Static check of your agent setup — no network, no credentials, nothing written. Flags rules in `CLAUDE.md`/`AGENTS.md` that cite files which no longer exist (with a «did you mean…»), how much context you pay every session, and whether the impact hook is actually installed. Every check here was written after it found something real, not from a best-practices list. |
 | `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