changebook 0.7.1 → 0.9.0

package/dist/toolProjectBrief.js

@@ -0,0 +1,310 @@
+/**
+ * `atlas_project_brief`: el brief de orientación, la herramienta que abre cada
+ * sesión.
+ *
+ * PORTADA DEL HOSPEDADO EL 09/08. Existía allí desde el 18/07 (`9a8387a`) y el
+ * bloque de CLAUDE.md que escribe este mismo paquete decía «orientarte →
+ * `atlas_project_brief`» desde entonces. Quien instalaba por npm leía la orden
+ * en cada sesión y no tenía con qué cumplirla.
+ *
+ * VIVE EN SU PROPIO FICHERO, y no por estética: `tools.ts` iba por 1.900 líneas
+ * y esto son otras 300. Es el mismo corte que el hospedado hizo el 03/08
+ * (AUD-C11). Los agregados puros que necesita salieron antes a `agregados.ts`,
+ * porque pedírselos a `tools.ts` —que importa este módulo para registrarlo—
+ * cerraría un ciclo.
+ *
+ * UNA LLAMADA, NO CUATRO. Cada llamada extra del agente relee ~45k tokens de
+ * contexto fijo (anatomía medida en el benchmark del 2026-07-20), mientras que
+ * los joins de aquí cuestan milisegundos. Por eso `intent` ENSANCHA esta misma
+ * llamada en vez de sugerir otra.
+ */
+import { z } from "zod";
+import { MODULE_GRAPH_WINDOW_ROWS, aggregateFileContext, briefModules, commitLabel, computeRecidivism, fileContainsFilter, filesUnionByChange, normalizeRepoPath, projectIdFromFilter, quotedInList, recordRead, } from "./agregados.js";
+import { aliasesFor, canonicalizeModuleRows } from "./aliasDeModulo.js";
+import { bloqueDeFriccion, consultaDeSucesos, friccionParaStructured, } from "./friccionDelBrief.js";
+import { RO, day, errorResult, ilikePattern, servedCharsOf, toolResult, } from "./respuestas.js";
+import { coChangePairs, summarizeHealth } from "./sync.js";
+/**
+ * Ventana de filas de `change_module` sobre la que se calcula el mapa.
+ *
+ * ES UNA VENTANA, NO UN CENSO, y el brief lo dice con esas palabras. Medido el
+ * 2026-08-03: la ventana estaba llena al ras, así que el número de módulos BAJA
+ * según se trabaja. Llamarlo «total» hacía leer eso como módulos que
+ * desaparecen.
+ */
+const MODULE_WINDOW = MODULE_GRAPH_WINDOW_ROWS;
+const MAX_ALERTS = 10;
+const MAX_TASKS = 10;
+export function registrarProjectBrief(server, db) {
+    server.registerTool("atlas_project_brief", {
+        title: "Project brief (start here)",
+        description: "Call this FIRST, the moment a session opens, to get your bearings: it hands you the module map with risks, the open regression alerts, the project health (which safety controls the analysis has evidenced as passing or at-risk), the tasks the owner queued for you, and the latest analyzed changes — ONE call that replaces atlas_modules + atlas_pending_tasks + atlas_recent_changes. Optional intent widens the SAME call (never a second trip): intent=orient serves 10 recent changes with commit+files; intent=pre_edit with files=[paths] appends each file's modules, notes and current watched values; intent=feature with feature=\"text\" appends the changes matching that text. After reading it, tell the user in 1-3 lines what you found and what you plan to do, and WAIT for their OK before editing any code — announcing and then editing in the same turn leaves the owner nothing to decide. " +
+            "project: the repo you are working in (folder name or slug).",
+        inputSchema: {
+            project: z.string().min(1).max(120),
+            intent: z.enum(["orient", "pre_edit", "feature"]).optional(),
+            files: z.array(z.string().min(1).max(300)).min(1).max(8).optional(),
+            feature: z.string().min(2).max(120).optional(),
+        },
+        annotations: RO,
+    }, async ({ project, intent, files, feature }) => {
+        const t0 = Date.now();
+        try {
+            const pf = await db.projectFilterFor(project);
+            const projectId = projectIdFromFilter(pf);
+            // intent=orient sirve 10 cambios en vez de 5: la tarea de orientación
+            // del benchmark pide «los 10 commits más recientes», y con 5 el agente
+            // gastaba una segunda llamada para el resto.
+            const changesLimit = intent === "orient" ? 10 : 5;
+            // TODO EN PARALELO. Son consultas independientes y el arranque del
+            // agente es tiempo que el usuario ve. Las que pueden faltar por tabla
+            // ausente caen a vacío en vez de tumbar el brief entero.
+            const [modRowsCrudas, alertsCrudas, changes, healthRows, tasks, unanalyzed, { aliases }, filasDeFriccion,] = await Promise.all([
+                db.rest(`change_module?select=changelog_id,module,domain,risk,files,note,created_at` +
+                    `&order=created_at.desc&limit=${MODULE_WINDOW}${pf}`),
+                db
+                    .rest(`regression_alerts?select=id,module,plain,created_at,evidence_symbol,evidence_expect,evidence_scope,evidence_line,evidence_in_diff` +
+                    `&resolved_at=is.null&order=created_at.desc&limit=${MAX_ALERTS}${pf}`)
+                    .catch(() => []),
+                db.rest(`changelog?select=id,business_impact,summary_tech,created_at,diff_character_count,commit_hash,hash_aliases` +
+                    `&order=created_at.desc&limit=${changesLimit}${pf}`),
+                db
+                    .rest(`project_checks?select=check_id,status,evidence,updated_at&order=updated_at.desc&limit=8${pf}`)
+                    .catch(() => []),
+                projectId
+                    ? db
+                        .callRpc("list_agent_tasks", {
+                        p_project_id: projectId,
+                    })
+                        .then((rows) => rows.filter((r) => r.status === "pending").slice(0, MAX_TASKS))
+                        .catch(() => [])
+                    : Promise.resolve([]),
+                db
+                    .rest(`unanalyzed_commits?select=commit_hash,committed_at,reason&order=committed_at.asc&limit=200${pf}`)
+                    .catch(() => []),
+                aliasesFor(db, projectId),
+                // Dónde hay que rehacer el trabajo. Va en el MISMO viaje: son 8 filas
+                // en 30 días (medido), así que no añade latencia al arranque. Cae a
+                // vacío si la tabla no está, en vez de tumbar el brief.
+                db
+                    .rest(consultaDeSucesos(pf, Date.now()))
+                    .catch(() => []),
+            ]);
+            // SE CANONICALIZA AQUÍ Y UNA VEZ. `briefModules`, `coChangePairs` y
+            // `computeRecidivism` son puras sobre estas filas: resolviendo alias
+            // antes, las tres ven lo mismo. Resolver dentro de cada una es cómo la
+            // identidad del módulo acabó viviendo en tres sitios y divergiendo.
+            const modRows = canonicalizeModuleRows(modRowsCrudas, aliases);
+            const alerts = canonicalizeModuleRows(alertsCrudas, aliases);
+            const { modules, total: modulesTotal } = briefModules(modRows);
+            const parejas = coChangePairs(modRows);
+            const recidivism = computeRecidivism(alertsCrudas.map((a) => ({
+                module: a.module ?? null,
+                plain: a.plain ?? null,
+                resolution: a.resolution,
+            })));
+            const health = summarizeHealth(healthRows);
+            const filesByChange = filesUnionByChange(modRowsCrudas);
+            const lines = [`# ${project} — project brief`, ""];
+            // ARRIBA DEL TODO. Si el mapa está incompleto, eso condiciona todo lo
+            // que viene detrás y hay que saberlo ANTES de leerlo, no en una nota al
+            // pie.
+            if (unanalyzed.length > 0) {
+                const oldest = unanalyzed[0]?.committed_at;
+                // LA CAUSA CAMBIA LO QUE EL USUARIO TIENE QUE HACER, así que cambia
+                // lo que se le dice. Culparle de su cuota cuando el que falló fue
+                // ChangeBook sería mentirle, y encima le empujaría a pagar por algo
+                // que no arregla nada (incidente del 2026-07-19).
+                const provider = unanalyzed.filter((u) => u.reason === "provider_error").length;
+                const quota = unanalyzed.length - provider;
+                const causa = provider > 0 && quota > 0
+                    ? `${quota} because the monthly analysis quota ran out, and ${provider} because ChangeBook could not reach the AI (a ChangeBook-side failure, not the user's fault)`
+                    : provider > 0
+                        ? `because ChangeBook could not reach the AI. This is a ChangeBook-side failure, NOT the user's quota and NOT their fault — they do not need to upgrade or pay anything`
+                        : `because the monthly analysis quota ran out`;
+                const salida = provider > 0 && quota === 0
+                    ? `They will be analyzable once the service recovers.`
+                    : `Their atlas will keep drifting until the quota renews on the 1st or they upgrade.`;
+                lines.push(`> **This atlas is out of date.** ${unanalyzed.length} commit(s) ` +
+                    `could not be analyzed${oldest ? ` (oldest: ${day(oldest)})` : ""} ` +
+                    `${causa}. Their files and commit messages were recorded, but they ` +
+                    `have no narrated summary and no regression check. Treat the module ` +
+                    `map below as missing those changes, and TELL THE USER. ${salida}`, "");
+            }
+            lines.push(modulesTotal > modules.length
+                ? `## Modules (${modules.length} most recent of ${modulesTotal} seen in the last ${MODULE_WINDOW} changes — all of them in atlas_modules, same window)`
+                : `## Modules (${modulesTotal} in the last ${MODULE_WINDOW} changes)`);
+            for (const m of modules) {
+                // Reincidente: N problemas de regresión DISTINTOS a lo largo del
+                // tiempo. Es un hecho de los datos, no una corazonada.
+                const previas = recidivism.get(m.module);
+                lines.push(`- **${m.module}**${m.domain ? ` · ${m.domain}` : ""} — ${m.changes} change(s), last ${m.last_changed}` +
+                    (m.risk ? `, risk: ${m.risk}` : "") +
+                    (previas ? ` · ⚠ ${previas} prior regressions` : ""));
+            }
+            if (parejas.length > 0) {
+                lines.push("", "## Change together (touch one, check the other)");
+                for (const p of parejas) {
+                    lines.push(`- **${p.a}** ↔ **${p.b}** — together in ${Math.round(p.rate * 100)}% of their changes`);
+                }
+            }
+            // Devuelve [] cuando no hay nada que decir, así que no deja cabecera
+            // huérfana. Va ANTES de los avisos abiertos, igual que en el hospedado.
+            lines.push(...bloqueDeFriccion(filasDeFriccion));
+            lines.push("", `## Open regression alerts (${alerts.length})`);
+            if (alerts.length === 0)
+                lines.push("None — no open alerts.");
+            for (const a of alerts) {
+                lines.push(`- ${(a.created_at ?? "").slice(0, 10)}${a.module ? ` · **${a.module}**` : ""} — ${a.plain ?? ""}`);
+            }
+            if (alerts.length > 0) {
+                lines.push("", "SAY THIS OUT LOUD to the user, in one or two lines, before you start " +
+                    "working. They cannot see this brief. A warning you absorb silently and " +
+                    "route around is indistinguishable, from where they sit, from a product " +
+                    "that does nothing: they paid for this and never learn it fired. Name the " +
+                    "module and what it puts at risk, in plain language, and only then get on " +
+                    "with the task. Once you FIX or verify one, call atlas_resolve_alert({ " +
+                    "project, module, verdict }) so it stops being re-raised and stops re-queuing " +
+                    "the owner's task — an alert nobody closes is billed forever.");
+            }
+            lines.push("", `## Project health (${health.passed} passed, ${health.at_risk.length} at risk)`);
+            if (healthRows.length === 0) {
+                lines.push("Not yet evidenced — no analyzed change has touched a health control yet.");
+            }
+            else if (health.at_risk.length === 0) {
+                lines.push("All evidenced controls passing.");
+            }
+            else {
+                for (const h of health.at_risk) {
+                    lines.push(`- ⚠ **${h.check}** at risk${h.since ? ` (since ${h.since})` : ""} — ${h.evidence}`);
+                }
+                lines.push("", "SAY THIS OUT LOUD to the user before you edit: a health control the " +
+                    "analysis already caught as at-risk (an unauthorized endpoint, a " +
+                    "hardcoded secret, a table-wide grant) is exactly what they cannot " +
+                    "see. Name it in plain language, then get on with the task.");
+            }
+            lines.push("", `## Tasks the owner queued for you (${tasks.length})`);
+            if (tasks.length === 0)
+                lines.push("None pending.");
+            for (const t of tasks)
+                lines.push(`- [${t.id}] ${t.title}`);
+            if (tasks.length > 0) {
+                lines.push("", "Fetch a task's full body with atlas_pending_tasks({ task_id }). Tell the user which task you picked and your plan, and WAIT for their OK before touching code.");
+            }
+            lines.push("", `## Latest changes`);
+            for (const c of changes) {
+                // Con aliases post-squash: `abc1234 (=def5678)` — si el primero no
+                // existe en el main del lector, el segundo sí.
+                const commit = commitLabel(c.commit_hash, c.hash_aliases);
+                lines.push(`- ${day(c.created_at)}${commit ? ` · ${commit}` : ""} — ${c.business_impact ?? ""}`);
+                const served = filesByChange.get(c.id);
+                if (served && served.files.length > 0) {
+                    lines.push(`  files: ${served.files.join(", ")}${served.more > 0 ? ` (+${served.more} more)` : ""}`);
+                }
+            }
+            // ── intent=pre_edit: el contexto por fichero, en ESTA misma llamada ──
+            let preEdit = [];
+            if (intent === "pre_edit" && files && files.length > 0) {
+                const paths = [...new Set(files.map(normalizeRepoPath).filter(Boolean))];
+                const [perFileCrudo, watchedRows] = await Promise.all([
+                    Promise.all(paths.map((p) => db
+                        .rest(`change_module?select=changelog_id,module,risk,note,created_at&${fileContainsFilter(p)}&order=created_at.desc&limit=20${pf}`)
+                        .then((rows) => ({ p, rows })))),
+                    db
+                        .rest(`watched_values?select=file,name,value,commit_hash&file=in.(${encodeURIComponent(quotedInList(paths))})&order=name.asc&limit=40${pf}`)
+                        .catch(() => []),
+                ]);
+                // La agregación va DESPUÉS de canonicalizar: `aggregateFileContext`
+                // agrupa por slug, y canonicalizar después dejaría dos grupos para el
+                // mismo módulo.
+                preEdit = perFileCrudo.map(({ p, rows }) => {
+                    const { file, modules: mods } = aggregateFileContext(p, canonicalizeModuleRows(rows, aliases));
+                    return {
+                        file,
+                        modules: mods,
+                        watched_values: watchedRows
+                            .filter((w) => w.file === file)
+                            .map((w) => ({
+                            name: w.name,
+                            value: w.value,
+                            commit: w.commit_hash?.slice(0, 7) ?? null,
+                        })),
+                    };
+                });
+                lines.push("", `## Pre-edit context (${preEdit.length} file(s))`);
+                for (const f of preEdit) {
+                    lines.push(`### ${f.file}`);
+                    if (f.modules.length === 0) {
+                        lines.push("No atlas history for this file yet (new or never analyzed).");
+                    }
+                    for (const m of f.modules) {
+                        lines.push(`- Module **${m.module}** — ${m.changes} change(s), last ${m.last_changed}` +
+                            (m.risk ? `, risk: ${m.risk}` : ""));
+                        if (m.last_note) {
+                            lines.push(`  - Note from last analysis (${m.last_changed}): ${m.last_note}`);
+                        }
+                    }
+                    for (const w of f.watched_values) {
+                        lines.push(`- Current value: ${w.name} = ${w.value}` +
+                            (w.commit ? ` (as of commit ${w.commit})` : ""));
+                    }
+                }
+            }
+            else if (intent === "pre_edit") {
+                lines.push("", "intent=pre_edit needs files=[paths]; nothing appended.");
+            }
+            // ── intent=feature: los cambios que casan con un texto ───────────────
+            let featureMatches = [];
+            if (intent === "feature" && feature) {
+                const patron = ilikePattern(feature);
+                const rows = await db.rest(`changelog?select=id,business_impact,summary_tech,created_at,diff_character_count,commit_hash,hash_aliases` +
+                    `&or=(business_impact.ilike.${patron},summary_tech.ilike.${patron})&order=created_at.desc&limit=5${pf}`);
+                featureMatches = rows.map((r) => ({
+                    date: day(r.created_at),
+                    commit: commitLabel(r.commit_hash, r.hash_aliases),
+                    business_impact: r.business_impact ?? "",
+                }));
+                lines.push("", `## Changes matching "${feature}" (${rows.length})`);
+                if (rows.length === 0) {
+                    lines.push("No analyzed change mentions it.");
+                }
+                for (const m of featureMatches) {
+                    lines.push(`- ${m.date}${m.commit ? ` · ${m.commit}` : ""} — ${m.business_impact}`);
+                }
+            }
+            else if (intent === "feature") {
+                lines.push("", 'intent=feature needs feature="text"; nothing appended.');
+            }
+            const salida = toolResult(lines.join("\n"), {
+                project,
+                modules,
+                modules_total: modulesTotal,
+                couplings: parejas,
+                // Paridad con el texto, igual que en el hospedado: sin esto, lo único
+                // que dice dónde se rehace trabajo vive SÓLO dentro del markdown.
+                friction: friccionParaStructured(filasDeFriccion),
+                alerts: alerts.map((a) => ({
+                    module: a.module,
+                    plain: a.plain,
+                    created_at: a.created_at ?? null,
+                })),
+                health,
+                tasks: tasks.map((t) => ({ id: t.id, title: t.title })),
+                changes: changes.map((c) => ({
+                    date: day(c.created_at),
+                    commit: commitLabel(c.commit_hash, c.hash_aliases),
+                    business_impact: c.business_impact ?? "",
+                })),
+                unanalyzed: unanalyzed.length,
+                ...(preEdit.length > 0 ? { pre_edit: preEdit } : {}),
+                ...(featureMatches.length > 0 ? { feature_matches: featureMatches } : {}),
+            });
+            recordRead(db, "atlas_project_brief", pf, servedCharsOf(salida), Date.now() - t0);
+            return salida;
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
+}
+//# sourceMappingURL=toolProjectBrief.js.map

package/dist/toolUsage.js

@@ -0,0 +1,128 @@
+/**
+ * `atlas_usage`: coste, ahorro y valor de las consultas al atlas.
+ *
+ * PORTADA DEL HOSPEDADO EL 09/08. Nació allí de una pregunta de Raúl el
+ * 2026-07-18: «¿cuánto llevamos gastado / ahorrado?» era incontestable para
+ * cualquier agente, porque el dato solo vivía detrás de la sesión web. Las
+ * preguntas de dinero son preguntas de fundador; el atlas tiene que
+ * responderlas.
+ *
+ * NIVEL DE CUENTA, NO DE PROYECTO: la facturación es por cuenta, así que esta
+ * herramienta NO lleva `project`. Es la única del servidor que no lo lleva, y
+ * es a propósito.
+ */
+import { z } from "zod";
+import { recordRead } from "./agregados.js";
+import { RO, errorResult, servedCharsOf, toolResult, } from "./respuestas.js";
+import { fmtUsd, latencyByTool, summarizeUsage, } from "./usage.js";
+/**
+ * Tope de filas por consulta de PostgREST. Se pagina hasta agotarlo y se AVISA
+ * si se alcanzó: un truncamiento leído como total convierte «has ahorrado $X»
+ * en una cifra que nadie puede auditar (AUD-C9). El techo de 20 páginas es un
+ * cortafuegos, no un limite de negocio — al alcanzarlo se marca truncado.
+ */
+const PAGINA = 1000;
+const MAX_PAGINAS = 20;
+async function paginar(db, tabla, query, orden) {
+    const filas = [];
+    for (let i = 0; i < MAX_PAGINAS; i += 1) {
+        const page = await db.rest(`${tabla}?${query}&order=${orden}&limit=${PAGINA}&offset=${i * PAGINA}`);
+        filas.push(...page);
+        if (page.length < PAGINA)
+            return { filas, truncado: false };
+    }
+    return { filas, truncado: true };
+}
+export function registrarUsage(server, db) {
+    server.registerTool("atlas_usage", {
+        title: "Cost, savings and consultation value",
+        description: "Account-level usage summary: what the owner paid for analyses this period, what ChangeBook's optimizations avoided (compression, prompt cache, Batch API, model routing, dedup skips) and how much agents consulted the atlas (with a conservative exploration-avoided estimate). Use when the owner asks about spend, savings, cost or usage. Args: period 'month' (default) or 'all'.",
+        inputSchema: { period: z.enum(["month", "all"]).default("month") },
+        annotations: RO,
+    }, async ({ period }) => {
+        const t0 = Date.now();
+        try {
+            const now = new Date();
+            const since = period === "month"
+                ? new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1)).toISOString()
+                : "1970-01-01T00:00:00Z";
+            const [ledgerP, skipsP, readsP, rolledUpP] = await Promise.all([
+                paginar(db, "usage_ledger", `select=model,action,input_tokens,output_tokens,cache_creation_input_tokens,cache_read_input_tokens,diff_chars,raw_diff_chars&created_at=gte.${since}`, "id.asc"),
+                paginar(db, "analysis_skips", `select=id&created_at=gte.${since}`, "id.asc").catch(() => ({ filas: [], truncado: false })),
+                paginar(db, "atlas_reads", `select=chars_served,source,tool,latency_ms&created_at=gte.${since}`, "id.asc").catch(() => ({ filas: [], truncado: false })),
+                // El resumen mensual de lo ya purgado. Sin esto, «all time» empezaría
+                // a significar «el último año» en cuanto la purga se llevara el primer
+                // mes, sin dejar de llamarse total (QA 2026-07-19). En period=month no
+                // aporta nada: el mes en curso nunca está purgado.
+                period === "all"
+                    ? paginar(db, "atlas_reads_monthly", "select=reads,chars_served", "month.asc").catch(() => ({ filas: [], truncado: false }))
+                    : Promise.resolve({ filas: [], truncado: false }),
+            ]);
+            const ledger = ledgerP.filas;
+            const reads = readsP.filas;
+            const rolledUp = rolledUpP.filas;
+            // SI CUALQUIERA SE TRUNCÓ, todo lo de abajo es un SUELO. Se dice en la
+            // salida en vez de servir la cifra a secas: quien lee «has ahorrado $X»
+            // tiene derecho a saber si eso es X o «al menos X».
+            const truncado = ledgerP.truncado ||
+                skipsP.truncado ||
+                readsP.truncado ||
+                rolledUpP.truncado;
+            // Los caracteres del guardián quedan FUERA de la estimación de
+            // exploración evitada: su contrafáctico es otro (evita un error, no una
+            // lectura). El resumen mensual ya viene guardado con esa exclusión.
+            const readsChars = reads
+                .filter((r) => r.source !== "guard")
+                .reduce((a, r) => a + (r.chars_served ?? 0), 0) +
+                rolledUp.reduce((a, r) => a + (r.chars_served ?? 0), 0);
+            const readsCount = reads.length + rolledUp.reduce((a, r) => a + (r.reads ?? 0), 0);
+            const u = summarizeUsage(ledger, skipsP.filas.length, readsCount, readsChars);
+            const naive = u.realCost + u.savedTotal;
+            const pct = naive > 0 ? Math.round((u.savedTotal / naive) * 100) : 0;
+            const lines = [
+                `# ChangeBook usage (${period === "month" ? "this month" : "all time"})`,
+                "",
+                ...(truncado
+                    ? [
+                        `> **These numbers are a FLOOR, not a total.** The usage tables for this period exceeded the read cap, so some rows were not counted. Every figure below is at least this much, possibly more.`,
+                        "",
+                    ]
+                    : []),
+                `- Analyses paid: ${u.analyses} → ${fmtUsd(u.realCost)}`,
+                `- Avoided by optimizations: ${fmtUsd(u.savedTotal)} (${pct}% of the naive cost ${fmtUsd(naive)})`,
+                `  - Dedup skips (${u.skipsCount}): ${fmtUsd(u.saved.skips)}`,
+                `  - Batch API: ${fmtUsd(u.saved.batch)}`,
+                `  - Model routing: ${fmtUsd(u.saved.routing)}`,
+                `  - Prompt cache: ${fmtUsd(u.saved.cache)}`,
+                `  - Diff compression: ${fmtUsd(u.saved.compression)}`,
+                `- Agent consultations: ${u.reads.count} (≈${Math.round(u.reads.chars / 4)} tokens served; estimated exploration avoided ${fmtUsd(u.reads.explorationEstimate)} — conservative estimate, kept OUT of the hard savings above)`,
+            ];
+            const latency = latencyByTool(reads);
+            if (latency.length > 0) {
+                lines.push(`- Read latency by tool (server-side, ms):`);
+                for (const t of latency) {
+                    lines.push(`  - ${t.tool}: p50 ${t.p50_ms} · p95 ${t.p95_ms} (n=${t.n})`);
+                }
+            }
+            const salida = toolResult(lines.join("\n"), {
+                period,
+                // Que el consumidor programático también pueda distinguir un total de
+                // un suelo: si esto solo saliera en la prosa, cualquier panel que lea
+                // el JSON volvería a publicar la cifra truncada como exacta.
+                truncated: truncado,
+                analyses: u.analyses,
+                real_cost_usd: u.realCost,
+                saved_usd: u.saved,
+                saved_total_usd: u.savedTotal,
+                reads: u.reads,
+                latency_by_tool: latency,
+            });
+            recordRead(db, "atlas_usage", "", servedCharsOf(salida), Date.now() - t0);
+            return salida;
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
+}
+//# sourceMappingURL=toolUsage.js.map