changebook 0.7.1 → 0.9.0

package/dist/respuestas.js

@@ -0,0 +1,111 @@
+/**
+ * Formas de fila y de respuesta del servidor MCP stdio.
+ *
+ * POR QUÉ EXISTE. Espejo de `supabase/functions/mcp/filasYRespuestas.ts`, que el
+ * hospedado sacó de su `index.ts` el 03/08 (AUD-C11) por la misma razón que
+ * aquí: `tools.ts` pasó de 1.400 a 1.900 líneas en un día y las herramientas que
+ * quedaban por portar no caben sin convertirlo en el módulo-dios siguiente.
+ *
+ * Y NO ES SOLO TAMAÑO: sin este corte, una herramienta en su propio fichero
+ * tendría que importar `toolResult` de `tools.ts` mientras `tools.ts` la importa
+ * a ella para registrarla — un ciclo. Estas funciones son puras y no dependen de
+ * ninguna herramienta, así que salir es lo natural.
+ *
+ * REGLA: aquí solo entra lo que no sabe NADA del atlas. Si algo necesita el
+ * cliente de Supabase, el repo o una consulta, no es de este fichero.
+ */
+import { SupabaseError } from './supabase.js';
+/**
+ * Tope de lo que se sirve en una respuesta. Por encima se recorta el texto Y se
+ * deja de mandar el `structuredContent`: mandarlo entero derrotaría el propio
+ * tope que acaba de recortar el texto.
+ */
+export const CHARACTER_LIMIT = 25_000;
+/**
+ * Las anotaciones de una tool de SOLO LECTURA. Espejo del `ro` del hospedado
+ * (`buildServer` en supabase/functions/mcp/index.ts). Vive aquí porque iba
+ * camino de su cuarta copia literal, y cuatro copias de un objeto de
+ * anotaciones es como se acaba teniendo una que miente.
+ */
+export const RO = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+};
+/**
+ * El contrato temporal de las respuestas del atlas (benchmark 2026-07-20: el
+ * agente afirmó un valor revertido porque la nota hablaba en presente). El ancla
+ * de deriva de `derivaContraHead` lo dice con precisión cuando hay árbol y hash;
+ * esta línea fija cubre el resto de los casos — nunca las dos a la vez.
+ */
+export const TEMPORAL_CONTRACT = 'Notes describe the code AS OF their date — concrete values (numbers, limits, names) may have changed since. Verify in the code before asserting them.';
+// ── Respuestas ───────────────────────────────────────────────────────────────
+function truncate(text) {
+    if (text.length <= CHARACTER_LIMIT)
+        return text;
+    return (text.slice(0, CHARACTER_LIMIT) +
+        '\n\n[Truncated. Use a smaller `limit`, an `offset`, or filters to narrow the result.]');
+}
+/**
+ * Construye el resultado de una tool. `structuredContent` duplica el texto
+ * renderizado, así que cuando hay que recortar el texto se deja fuera: mandarlo
+ * entero enviaría igualmente el objeto sin tope y derrotaría al recorte.
+ */
+export function toolResult(text, structured) {
+    if (text.length <= CHARACTER_LIMIT) {
+        return {
+            content: [{ type: 'text', text }],
+            structuredContent: structured,
+        };
+    }
+    return { content: [{ type: 'text', text: truncate(text) }] };
+}
+export function errorResult(error) {
+    const message = error instanceof SupabaseError || error instanceof Error
+        ? error.message
+        : String(error);
+    // isError deja al cliente MCP (y al agente) distinguir una llamada fallida de
+    // un resultado válido cuyo texto empieza por "Error:".
+    return {
+        isError: true,
+        content: [{ type: 'text', text: `Error: ${message}` }],
+    };
+}
+/**
+ * Lo que de VERDAD llega al modelo. Espejo de `servedCharsOf` del hospedado.
+ *
+ * `chars_served` contaba el markdown, y el markdown casi nunca se usa: los
+ * tool_result llegan al modelo como el JSON del `structuredContent`. Solo cuando
+ * la respuesta revienta `CHARACTER_LIMIT` deja de haber JSON y queda el texto.
+ * Contar el markdown infravaloraba el gasto un 35%.
+ */
+export function servedCharsOf(result) {
+    return 'structuredContent' in result && result.structuredContent
+        ? JSON.stringify(result.structuredContent).length
+        : (result.content?.[0]?.text?.length ?? 0);
+}
+export function fileList(files) {
+    return Array.isArray(files) ? files.map(String) : [];
+}
+export function day(iso) {
+    return iso.slice(0, 10);
+}
+/** El patrón de un `or=(...ilike...)` de PostgREST, codificado una sola vez. */
+export function ilikePattern(search) {
+    return encodeURIComponent(`*${search.replace(/[%*,()]/g, ' ').trim()}*`);
+}
+// Extractos resumidos: los excerpts de diff guardados son lo más caro de
+// atlas_module_detail (~1.5k chars cada uno) y la mayoría de las llamadas solo
+// necesita saber QUÉ cambió. Por defecto va una vista previa corta; `full: true`
+// los devuelve verbatim.
+const EXCERPT_PREVIEW_LINES = 4;
+const EXCERPT_PREVIEW_CHARS = 320;
+export function previewExcerpt(excerpt) {
+    let text = excerpt.split('\n').slice(0, EXCERPT_PREVIEW_LINES).join('\n');
+    if (text.length > EXCERPT_PREVIEW_CHARS) {
+        text = text.slice(0, EXCERPT_PREVIEW_CHARS);
+    }
+    return { text: text.trimEnd(), truncated: text.length < excerpt.length };
+}
+//# sourceMappingURL=respuestas.js.map

package/dist/supabase.js

@@ -261,14 +261,50 @@ export class Supabase {
             throw new SupabaseError(`Patch on ${table} failed (${res.status}): ${(await res.text()).slice(0, 200)}`, res.status);
         }
     }
-    patchOnce(table, filter, patch) {
+    /**
+     * Como `patchRows`, pero DEVUELVE las filas escritas (`return=representation`).
+     *
+     * POR QUÉ EXISTE, y no es cosmético (invariante 17). Con `return=minimal` un
+     * PATCH que no tocó nada y un PATCH que tocó cinco filas se ven exactamente
+     * igual: 204 los dos. Quien llama no puede distinguir «no había nada que
+     * cerrar» de «no me dejaron escribir», y esa confusión ya costó cara aquí: el
+     * 25/07 se añadió la columna `resolution` sin meterla en el grant POR COLUMNA
+     * de `regression_alerts` y los tres caminos que la escribían empezaron a
+     * fallar EN SILENCIO —`atlas_resolve_alert` informaba de que había cerrado
+     * cero, como si el aviso ya no estuviera abierto—. Volvió a asomar el 02/08
+     * con `resolution_by`. Ver 20260802120000_quien_juzgo_el_aviso.sql, que lo
+     * cuenta en su propio comentario.
+     *
+     * Devolver la representación no impide que vuelva a pasar; lo que hace es que
+     * cuando pase se VEA: quien llama compara lo que pidió cerrar con lo que
+     * volvió y puede gritar en vez de informar de un cero tranquilizador.
+     */
+    async patchRowsReturning(table, filter, patch) {
+        if (!this.hasCredentials())
+            throw new SupabaseError(AUTH_HELP, 401);
+        if (!this.accessToken)
+            await this.refresh();
+        let res = await this.patchOnce(table, filter, patch, 'return=representation');
+        if (res.status === 401 && this.refreshToken) {
+            await this.refresh();
+            res = await this.patchOnce(table, filter, patch, 'return=representation');
+        }
+        if (!res.ok) {
+            throw new SupabaseError(`Patch on ${table} failed (${res.status}): ${(await res.text()).slice(0, 200)}`, res.status);
+        }
+        return (await res.json());
+    }
+    patchOnce(table, filter, patch, 
+    // `return=minimal` sigue siendo el defecto: cambiarlo para todos haría que
+    // cada PATCH del CLI se trajera filas que nadie lee.
+    prefer = 'return=minimal') {
         return fetch(`${this.url}/rest/v1/${table}?${filter}`, {
             method: 'PATCH',
             headers: {
                 apikey: this.anonKey,
                 Authorization: `Bearer ${this.accessToken}`,
                 'Content-Type': 'application/json',
-                Prefer: 'return=minimal',
+                Prefer: prefer,
             },
             body: JSON.stringify(patch),
             signal: AbortSignal.timeout(10_000),

package/dist/sync.js

@@ -13,6 +13,7 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { aliasesFor, canonicalizeModuleRows, etiquetaPorSlug, projectIdOf, slugModule, } from './aliasDeModulo.js';
+import { consultaDeSucesos } from './friccionDelBrief.js';
 /**
  * Cuántas citas de historial sirve el bloque, según el plan (B5, opción A).
  *
@@ -103,7 +104,7 @@ const MAX_COUPLINGS = 5;
 //
 // Subir el techo alimenta al que se lo come. Adelgazada la cabecera a 271
 // chars, con 2.000 cabe mas contenido REAL que antes con 3.000.
-const SYNC_BUDGET_CHARS = 2_000;
+export const SYNC_BUDGET_CHARS = 2_000;
 // Co-change pair thresholds — same spirit as the web's signals: at least 3
 // shared analyses and a ≥60% rate before we call it a dependency.
 const MIN_PAIR_COUNT = 3;
@@ -155,7 +156,7 @@ export async function fetchBriefSection(db, targetDir) {
     }
     const projectId = projectIdOf(projectFilter);
     const since = new Date(Date.now() - ALERT_WINDOW_DAYS * 24 * 3600 * 1000).toISOString();
-    const [moduleRowsCrudas, changes, alertsCrudas, historialCrudo, pendingTasks, healthRows, { aliases },] = await Promise.all([
+    const [moduleRowsCrudas, changes, alertsCrudas, historialCrudo, pendingTasks, healthRows, { aliases }, friccionCruda,] = await Promise.all([
         db.rest('change_module?select=changelog_id,module,domain,risk,files,note,created_at&order=created_at.desc&limit=500' +
             projectFilter),
         db.rest(`changelog?select=business_impact,created_at&order=created_at.desc&limit=${MAX_CHANGES}` +
@@ -185,6 +186,12 @@ export async function fetchBriefSection(db, targetDir) {
             .catch(() => []),
         // Los alias entran en el MISMO Promise.all que ya se hacía: no cuesta ronda.
         aliasesFor(db, projectId),
+        // FRICCIÓN: dónde hubo que rehacer el trabajo. Es la misma consulta que
+        // sirve el brief —filtrada por veredicto en el servidor—, así que son 8
+        // filas en 30 días y no cuesta ronda tampoco.
+        db
+            .rest(consultaDeSucesos(projectFilter, Date.now()))
+            .catch(() => []),
     ]);
     // El punto de estrangulamiento del bloque: se canonicaliza AQUÍ, nada más
     // traer las filas, y todo lo que hay debajo (el mapa, `hechosCaros`,
@@ -196,6 +203,10 @@ export async function fetchBriefSection(db, targetDir) {
     const moduleRows = canonicalizeModuleRows(moduleRowsCrudas, aliases);
     const alerts = canonicalizeModuleRows(alertsCrudas, aliases);
     const historial = canonicalizeModuleRows(historialCrudo, aliases);
+    // LA CUARTA TABLA. La fricción también trae nombre de módulo, así que sin
+    // esto una fusión resolvería tres secciones y dejaría la fricción citando el
+    // nombre viejo — en la misma pantalla y sin que nada fallara.
+    const friccion = canonicalizeModuleRows(friccionCruda, aliases);
     const health = summarizeHealth(healthRows);
     // El commit de cada regresion, para poder citarlo. Una consulta mas, y solo
     // por los analisis que de verdad rompieron algo: es la diferencia entre «este
@@ -217,8 +228,8 @@ export async function fetchBriefSection(db, targetDir) {
                 commitPorAnalisis.set(f.id, f.commit_hash.slice(0, 7));
         }
     }
-    const section = buildSection(moduleRows, changes, alerts, projectName, pendingTasks, health.at_risk, historial, commitPorAnalisis, await citasSegunPlan(db));
-    return { section, projectId, projectResolved };
+    const { section, omitidas } = buildSectionConInforme(moduleRows, changes, alerts, projectName, pendingTasks, health.at_risk, historial, commitPorAnalisis, await citasSegunPlan(db), friccion);
+    return { section, projectId, projectResolved, omitidas };
 }
 /**
  * Lo que va a cambiar, en corto y para una persona.
@@ -259,12 +270,23 @@ export function resumenDelCambio(previo, siguiente, fichero) {
     return l.join('\n');
 }
 export async function syncContextFiles(db, targetDir, opts = {}) {
-    const { section, projectId, projectResolved } = await fetchBriefSection(db, targetDir);
+    const { section, projectId, projectResolved, omitidas } = await fetchBriefSection(db, targetDir);
     for (const name of ['CLAUDE.md', 'AGENTS.md']) {
         const file = path.join(targetDir, name);
         const updated = await upsertSection(file, section, opts);
         console.error(`${updated} ${name}`);
     }
+    // LO QUE NO CUPO, dicho a la persona. El bloque tiene presupuesto fijo —es
+    // coste que se paga en CADA sesión de CADA agente— y hasta hoy una sección
+    // que no cabía desaparecía sin dejar rastro en ningún sitio. Se dice aquí y
+    // no dentro del bloque: al agente no le falta (la cabecera ya le manda a
+    // `atlas_project_brief`, que no tiene tope), y meterlo dentro gastaría
+    // presupuesto de todas las sesiones para avisar de que falta presupuesto.
+    if (omitidas.length > 0) {
+        console.error(`⚠ No cupo todo en ${SYNC_BUDGET_CHARS} chars — pídelo con \`atlas_project_brief\`:`);
+        for (const o of omitidas)
+            console.error(`  · ${o}`);
+    }
     // El sync ES una consulta del atlas — la más apalancada: el mapa que
     // destila entra en CADA sesión de agente vía CLAUDE.md/AGENTS.md sin
     // pagar tool calls. Cuenta como lectura (best-effort).
@@ -361,11 +383,31 @@ export function hechosCaros(historial, commitPorAnalisis, tope = 6, maxCitas = C
         return `- **${modulo}**: ${n} regresi${n === 1 ? 'ón' : 'ones'}${cuando ? ` (${cuando})` : ''}`;
     });
 }
-export function buildSection(rows, changes, alerts = [], projectName, pendingTasks = [], atRiskHealth = [], historial = [], commitPorAnalisis = new Map(), 
+/**
+ * El bloque, y **qué se quedó fuera por tamaño**.
+ *
+ * POR QUÉ EXISTE ESTA SEGUNDA SALIDA, 24/08: el presupuesto es de suma cero y
+ * una sección entera que no cabe desaparecía **en silencio**. `recorta` avisa
+ * cuando corta una línea —lleva su elipsis desde el 04/08— pero perder la
+ * sección completa no dejaba rastro en ningún sitio.
+ *
+ * El informe NO va dentro del bloque. Al agente no le falta: la cabecera ya le
+ * dice que pida `atlas_project_brief`, que no tiene este tope. A quien le falta
+ * es a la PERSONA que corre `changebook sync`, y a ésa se le dice por stderr
+ * —una vez, cuando puede hacer algo— en vez de gastar presupuesto de cada
+ * sesión para siempre.
+ */
+export function buildSectionConInforme(rows, changes, alerts = [], projectName, pendingTasks = [], atRiskHealth = [], historial = [], commitPorAnalisis = new Map(), 
 // B5 · el que paga ve más historial de regresiones. Por defecto, el gratuito:
 // un fallo al leer el plan tiene que degradar HACIA el plan libre, nunca
 // regalar el de pago por un error de red.
-maxCitas = CITAS_GRATIS) {
+maxCitas = CITAS_GRATIS, 
+// Décimo posicional, y no me gusta: esta firma pide ya un objeto de opciones.
+// Se deja posicional a propósito porque cambiarla toca todos los sitios de
+// llamada y todos los contratos que la prueban, y eso no es parte de esta
+// pieza. Por defecto `[]`: un proyecto sin fricción —o una consulta que
+// falló— produce la sección vacía, que desaparece sola.
+friccion = []) {
     // Newest-first rows: the first occurrence of a module is its latest state.
     //
     // POR SLUG (03/08). Agrupaba por `row.module` crudo, asi que un modulo
@@ -462,11 +504,17 @@ maxCitas = CITAS_GRATIS) {
         '',
     ];
     if (modules.length === 0) {
-        return [
-            ...head,
-            '_Aún no hay módulos analizados. Ejecuta un análisis desde la extensión o importa el historial de git._',
-            END,
-        ].join('\n');
+        // Sin módulos no hay reparto, así que no hay nada omitido — y decir `[]` no
+        // es lo mismo que no decir nada: quien lea el informe sabe que aquí no se
+        // perdió nada por tamaño, sino que no había datos.
+        return {
+            section: [
+                ...head,
+                '_Aún no hay módulos analizados. Ejecuta un análisis desde la extensión o importa el historial de git._',
+                END,
+            ].join('\n'),
+            omitidas: [],
+        };
     }
     // Una linea por modulo, corta a proposito. Antes llevaba 3 ficheros y una
     // nota de 110 chars: ~200 chars por modulo, asi que en el presupuesto cabian
@@ -523,6 +571,41 @@ maxCitas = CITAS_GRATIS) {
             ...taskTitles.map((t) => `- ${sanitizeCell(recorta(t, 120))}`),
         ]
         : [];
+    // ── Fricción: dónde hubo que rehacer el trabajo ────────────────────────────
+    //
+    // POR QUÉ ENTRA, medido el 24/08 contra producción antes de escribirlo: de los
+    // 4 módulos con fricción en 30 días, **3 no aparecen en ninguna otra sección**
+    // (`Badge del README`, `Analítica de producto`, `Consolidación de módulos`).
+    // El único que se solapa es `Reportes de regresiones`, que ya sale en «costó
+    // caro» con 8. Si el solape hubiera sido total, esta sección sería decoración
+    // compitiendo por un presupuesto de suma cero contra señales validadas.
+    //
+    // TRES Y NO CINCO como el brief: esto entra en el contexto de CADA sesión, no
+    // se pide. El listado entero se sirve con `changebook friction` y por
+    // `atlas_project_brief`.
+    //
+    // ⚠ LO QUE ESTA SEÑAL NO ES: una regresión confirmada. Dice «aquí hubo que
+    // rehacer trabajo», con una precisión que NO está validada (n=15, un repo, y
+    // etiquetado por quien escribió el clasificador). Por eso su prioridad de
+    // presupuesto es 2 y no 1: cae antes que los avisos abiertos, la salud, los
+    // módulos críticos y el historial de regresiones, que sí están medidos.
+    //
+    // Y ESO TIENE UNA CONSECUENCIA MEDIDA, dicha aquí para que nadie la
+    // redescubra: en ESTE repo la sección NO SE PINTA. El bloque sale a 1.998 de
+    // 2.000 chars —saturado por tres módulos críticos y cinco entradas de
+    // historial— y la sección cuesta 271. Que pierda esa puja es lo correcto:
+    // enfrente hay regresiones confirmadas. En un repo con menos historial sí
+    // entra (comprobado con `buildSection` sobre un repo nuevo y sobre uno con
+    // una regresión: sale en los dos).
+    //
+    // ⚠ Y el hueco que esto destapa, PREVIO a esta sección y común a todas: una
+    // sección descartada por presupuesto es MUDA. `recorta` avisa cuando corta
+    // una línea, pero nada avisa cuando cae una sección entera. Mientras siga
+    // así, el listado completo se pide con `changebook friction` o por
+    // `atlas_project_brief`, que no tienen este tope.
+    const friccionLines = friccion
+        .slice(0, 3)
+        .map((f) => `- ${(f.occurred_at ?? '').slice(8, 10)}/${(f.occurred_at ?? '').slice(5, 7)} · \`${sanitizeCell(recorta(f.path, 80))}\`${f.module ? ` — **${sanitizeCell(f.module)}**` : ''}`);
     // El orden de renderizado (legibilidad) y la prioridad de presupuesto (qué se
     // recorta primero) son independientes. Los dos importan, y hasta el 2026-07-26
     // solo uno estaba bien.
@@ -578,6 +661,16 @@ maxCitas = CITAS_GRATIS) {
             title: '### Lo que ya costó caro aquí (revisa antes de tocarlo)',
             lines: hechosCaros(historial, commitPorAnalisis, 6, maxCitas),
         },
+        {
+            key: 'friccion',
+            priority: 2,
+            // EL TOTAL VA EN EL TÍTULO. Se enseñan 3 de las que haya, y un recorte
+            // mudo se lee como «esto es todo». Meterlo en el título cuesta CERO
+            // líneas de presupuesto, que es lo que impide que la honestidad compita
+            // con el contenido. El listado entero: `changebook friction`.
+            title: `### Dónde hubo que rehacer el trabajo (${friccionLines.length} de ${friccion.length}, últimos 30 días)`,
+            lines: friccionLines,
+        },
         // El mapa baja de 3 a 4, y no es una degradación caprichosa: `/doctor` de
         // Claude Code recorta por su cuenta «architecture overviews» de un
         // CLAUDE.md porque el agente los deriva del repo. Lo que no puede derivar
@@ -683,7 +776,28 @@ maxCitas = CITAS_GRATIS) {
     // se apartó del presupuesto arriba, así que entra siempre.
     lines.push('', FIRMA);
     lines.push(END);
-    return lines.join('\n');
+    // LO QUE NO CABIÓ. Una sección con líneas que se quedó con `count` 0 —o con
+    // menos líneas de las que traía— no entró entera. Se compara contra lo que la
+    // sección TENÍA, no contra un tope fijo: así también se ve la que entró a
+    // medias, que es igual de muda.
+    const omitidas = sections
+        .filter((x) => x.lines.length > 0)
+        .filter((x) => (includedCount.get(x.key) ?? 0) < x.lines.length)
+        .map((x) => {
+        const dentro = includedCount.get(x.key) ?? 0;
+        const nombre = x.title.replace(/^#+\s*/, '').replace(/\s*\(.*\)\s*$/, '');
+        return dentro === 0
+            ? `${nombre} (entera, ${x.lines.length} línea(s))`
+            : `${nombre} (${x.lines.length - dentro} de ${x.lines.length} línea(s))`;
+    });
+    return { section: lines.join('\n'), omitidas };
+}
+/**
+ * El bloque, a secas. La forma que usan los diez sitios de llamada que no
+ * necesitan el informe.
+ */
+export function buildSection(...args) {
+    return buildSectionConInforme(...args).section;
 }
 /**
  * Symmetric co-change pairs: modules that appear in the same analyses often

package/dist/toolActionPlan.js

@@ -0,0 +1,98 @@
+/**
+ * `atlas_action_plan`: qué arreglar primero, en una sola lista priorizada.
+ *
+ * PORTADA DEL HOSPEDADO EL 09/08. Existía allí desde el 24/07 (`333c49a`).
+ *
+ * POR TIERS EXPLÍCITOS Y NO POR UNA PUNTUACIÓN: un número oculto obliga a
+ * confiar; cuatro tiers con nombre —regresión abierta, control de salud roto,
+ * hotspot, reincidente— dejan discutir el orden. Es agregación pura de señales
+ * que el atlas ya tiene: no dispara ningún análisis nuevo.
+ */
+import { z } from "zod";
+import { alertasDesde, briefModules, buildActionPlan, computeRecidivism, lineaDePrecision, projectIdFromFilter, recordRead, } from "./agregados.js";
+import { aliasesFor, canonicalizeModuleRows } from "./aliasDeModulo.js";
+import { RO, errorResult, servedCharsOf, toolResult, } from "./respuestas.js";
+import { summarizeHealth } from "./sync.js";
+export function registrarActionPlan(server, db) {
+    server.registerTool("atlas_action_plan", {
+        title: "Action plan (what to fix first)",
+        description: "A single prioritized list of what to address in this project, most urgent first: open regressions (a change already broke something), at-risk health controls (a safety posture the analysis flagged), hotspot modules (fragile by design) and repeat-offender modules. Pure aggregation of signals the atlas already holds — no new analysis, ordered by transparent severity tiers rather than a hidden score. Use it to decide where to start, then ANNOUNCE your pick and wait for the user's OK before acting. " +
+            "project: the repo you are working in (folder name or slug).",
+        inputSchema: { project: z.string().min(1).max(120) },
+        annotations: RO,
+    }, async ({ project }) => {
+        const t0 = Date.now();
+        try {
+            const pf = await db.projectFilterFor(project);
+            const projectId = projectIdFromFilter(pf);
+            const [modRowsCrudas, alertRowsCrudas, healthRows, { aliases }] = await Promise.all([
+                db.rest(`change_module?select=changelog_id,module,domain,risk,created_at&order=created_at.desc&limit=1000${pf}`),
+                db
+                    .rest(
+                // SIN `created_at=gte` A PROPÓSITO. Esta lectura sirve a DOS
+                // cosas con criterios de edad OPUESTOS: las regresiones abiertas
+                // (que sí quieren la ventana de 14 días) y la reincidencia (que
+                // la quiere all-time — recortarla borraría el historial que
+                // justifica llamar reincidente a un módulo). La ventana se
+                // aplica abajo, sobre estas mismas filas.
+                `regression_alerts?select=module,plain,resolution,resolved_at,created_at&order=created_at.desc&limit=500${pf}`)
+                    .catch(() => []),
+                db
+                    .rest(`project_checks?select=check_id,status,evidence,updated_at&order=updated_at.desc&limit=8${pf}`)
+                    .catch(() => []),
+                aliasesFor(db, projectId),
+            ]);
+            // LAS DOS, y antes de nada: `modules` alimenta los hotspots del plan y
+            // `alertRows` la reincidencia. Canonicalizar una sola haría que el plan
+            // hablara de un módulo con la reincidencia de otro.
+            const modRows = canonicalizeModuleRows(modRowsCrudas, aliases);
+            const alertRows = canonicalizeModuleRows(alertRowsCrudas, aliases);
+            const { modules } = briefModules(modRows);
+            const desde = alertasDesde();
+            const openAlerts = alertRows.filter((a) => !a.resolved_at && a.created_at >= desde);
+            const recidivism = computeRecidivism(alertRows);
+            const health = summarizeHealth(healthRows);
+            const plan = buildActionPlan({
+                alerts: openAlerts,
+                atRiskHealth: health.at_risk,
+                modules,
+                recidivism,
+            });
+            const lines = [`# ${project} — action plan`, ""];
+            if (plan.length === 0) {
+                lines.push("Nothing flagged: no open regressions, no at-risk health controls, no hotspot or repeat-offender modules. Nothing the atlas can point at right now.");
+            }
+            else {
+                lines.push(`${plan.length} item(s), most urgent first:`, "");
+                for (const it of plan) {
+                    lines.push(`${it.rank}. **${it.what}** — ${it.why}`);
+                }
+                lines.push("", "ANNOUNCE to the user which item you'd start with and why, and wait " +
+                    "for their OK before touching code. They cannot see this plan.");
+            }
+            // ¿ACERTAMOS? Al final, no al principio: el plan es lo accionable y el
+            // número es el respaldo. Del MISMO RPC que sirve el panel del dueño: si
+            // el agente y la persona vieran cifras distintas, el número dejaría de
+            // valer para los dos. Best-effort — un plan útil no puede caerse por su
+            // respaldo.
+            if (projectId) {
+                const precision = await db
+                    .callRpc("atlas_precision", {
+                    p_user_id: null,
+                    p_project_id: projectId,
+                })
+                    .catch(() => null);
+                const linea = lineaDePrecision(precision);
+                if (linea)
+                    lines.push("", linea);
+            }
+            const salida = toolResult(lines.join("\n"), { project, plan });
+            recordRead(db, "atlas_action_plan", pf, servedCharsOf(salida), Date.now() - t0);
+            return salida;
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
+}
+//# sourceMappingURL=toolActionPlan.js.map