xonecode 0.38.41 → 0.39.2

package/dist/core/notify.d.ts

@@ -0,0 +1,77 @@
+/**
+ * La política de ruido: una línea por RACHA de la misma tool, no por llamada.
+ *
+ * Es del TURNO: se construye al empezar el turno y muere con él. Un colapsador de proceso
+ * contaría las llamadas de todos los turnos juntos.
+ *
+ * La línea lleva ICONO por familia (`→` leer, `←` escribir, `✱` buscar) y VERBO en
+ * español, no el nombre crudo de la tool — «→ lee app.xne» cuenta lo mismo que
+ * «🔧 read_file» y se lee a la primera, que es lo que llena los 100-300 s de un turno.
+ * Una tool desconocida no se disfraza: `⚙` y su nombre tal cual, porque un nombre que
+ * no está en el mapa puede significar cualquier cosa (una tool MCP de Studio, por
+ * ejemplo) y inventarle un verbo sería mentir.
+ *
+ * Devuelve una LISTA de líneas, nunca una cadena con dos pegadas: cuando una racha se
+ * cierra Y otra tool arranca en el mismo evento —el caso normal de "tres read_file y luego
+ * un glob"— hay DOS cosas que decir, y quien pinta escribe tantas líneas como haya.
+ */
+import type { OrigenDeLaTool } from "./events.js";
+export interface EventoTool {
+    nombre: string;
+    /**
+     * Ruta o patrón, SOLO eso: lo permite la lista blanca de `agent/turno/resumenDeTool.ts`
+     * (file_path/path/pattern según la tool). El contenido del fichero y los tokens de
+     * autenticación NO caben aquí por diseño — ver la cabecera de `core/events.ts`.
+     */
+    detalle?: string;
+    /** Vacío si fue bien. Un error nunca se colapsa. */
+    error?: string;
+    /** Quién la pidió (`core/events.ts#OrigenDeLaTool`). Ausente = no consta. */
+    origen?: OrigenDeLaTool;
+}
+/**
+ * Una línea del colapsador, con la tool de la que habla.
+ *
+ * El texto ya no viaja solo porque quien pinta necesita saber DE QUÉ es la línea sin
+ * re-parsear la prosa: «→ lee» no dice `read_file` en ninguna parte, y deducirlo del icono
+ * sería reconstruir a mano el mapa que está diez líneas más arriba — con la garantía de que
+ * las dos copias divergen el día que alguien añada un verbo. El nombre ya lo tenía el
+ * evento; lo que se arregla es que dejara de estar al llegar a la piel.
+ *
+ * `nombre` es el de la tool de la RACHA que la línea cuenta, que en un cierre es la
+ * ANTERIOR y no la que acaba de llegar — es justo el caso que un `piel.tool(evento)`
+ * ingenuo habría etiquetado mal.
+ */
+export interface LineaDeTool {
+    texto: string;
+    nombre: string;
+    /** Presente solo en la línea de un error, que nunca se colapsa. */
+    error?: string;
+    /** El origen de la RACHA, que es uno solo: dos orígenes son dos rachas. */
+    origen?: OrigenDeLaTool;
+    /**
+     * El `detalle` del evento —la ruta o el patrón que eligió la lista blanca de
+     * `resumenDeTool.ts`— cuando la línea cuenta UNA llamada. Es lo mismo que ya va dentro de
+     * `texto`, como DATO: quien pinta lo necesita aparte para poner el verbo a su manera sin
+     * re-parsear la frase. Ausente = la tool no tiene detalle en la lista blanca.
+     */
+    blanco?: string;
+    /** En el CIERRE de una racha: cuántas llamadas cuenta (≥ 2). */
+    veces?: number;
+    /** En el cierre: los blancos DISTINTOS de la racha, los tres primeros (los de `listaDe`). */
+    blancos?: string[];
+    /** En el cierre: cuántos blancos distintos más hubo, aparte de `blancos`. */
+    masBlancos?: number;
+}
+export declare class Colapsador {
+    private nombre;
+    private origen;
+    private cuenta;
+    private detalles;
+    /** Las líneas que toca escribir por este evento, EN ORDEN. 0, 1 o 2. */
+    lineas(evento: EventoTool): LineaDeTool[];
+    /** La cuenta de la última racha. Se llama al terminar el turno, incluso si reventó. */
+    cierre(): LineaDeTool | null;
+    private cerrarRacha;
+    private reiniciar;
+}

package/dist/core/nucleoXone.d.ts

@@ -0,0 +1,28 @@
+/**
+ * El NÚCLEO DE TRABAJO: lo fundamental que se midió sobre apps reales, en el prompt de sistema de quien
+ * ESCRIBE el proyecto o CONDUCE el aparato (IXCODE-18).
+ *
+ * ## Por qué existe, medido
+ *
+ * Nueve pasadas de una calculadora hecha por los agentes, y lo mismo se perdía una y otra vez: un display
+ * que no se repintaba vivió siete pasadas, un comentario con `--` tumbó la app, `elevation` recortaba las
+ * teclas y `getText` daba por bueno lo que no se veía. Cada hallazgo estaba en una skill, en un informe o
+ * en la cabeza de una sesión que ya no existía; **el modelo no abre la skill que no sabe que necesita**
+ * (medido: cargaba unas referencias y se saltaba justo la de la regla). Lo que tiene que cumplirse va donde el
+ * modelo mira SIEMPRE: el prompt de sistema. Cuesta tokens en cada llamada —por eso el tope duro de líneas y
+ * por eso solo lo recibe quien escribe o conduce—, y la caché absorbe casi todo.
+ *
+ * ## Qué entra y qué no
+ *
+ * Entra lo que (1) falla EN SILENCIO —`validate` en verde y la app rota—, (2) se midió y no se deduce de la
+ * documentación, o (3) es una disciplina de verificación que se saltó. No entra lo que ya dice un mensaje de
+ * error, ni lo que es de UN encargo (eso va en su plan: `## Hallazgos`), ni lo que cambia con la versión de
+ * XOne sin medirse otra vez: cada regla lleva su medida en `docs/DECISIONES.md`.
+ *
+ * **El encabezado entero —`REGLAS_XONE` más esto— tiene un tope de `TOPE_DE_LINEAS_DEL_ENCABEZADO`**, y un
+ * test lo vigila: un núcleo que crece sin freno acaba diluyendo justo lo que quería asegurar.
+ */
+export declare const TOPE_DE_LINEAS_DEL_ENCABEZADO = 100;
+export declare const NUCLEO_XONE: string;
+export declare function nucleoXoneExterno(nucleo?: string): string;
+export declare const NUCLEO_XONE_EXTERNO: string;

package/dist/core/panorama.d.ts

@@ -0,0 +1,68 @@
+/**
+ * El PANORAMA: lo que ve el móvil de todo el anfitrión a la vez (consolas abiertas y tareas en background).
+ * Puro: compone a partir de datos ya reducidos (sin raíces, sin rutas de la máquina). Quien lo llama pone los ids
+ * OPACOS de consola y los nombres; aquí solo se ordena, se recorta y se cuenta. Spec: `docs/superpowers/specs/2026-10-13-panel-movil-design.md`.
+ */
+import type { LineaDeDiff } from "./diff.js";
+import type { PendienteDeAprobacion } from "./events.js";
+/** Cuántas tareas terminadas viajan (las más recientes por `acabada`). */
+export declare const TAREAS_TERMINADAS_EN_PANORAMA = 5;
+export declare const CARACTERES_DE_TITULO = 120;
+export declare const CARACTERES_DE_MOTIVO = 400;
+/** Líneas de diff por fichero; pasadas esas, se recorta y se marca `recortada`. */
+export declare const LINEAS_DE_DIFF_EN_PANORAMA = 200;
+/** El feedback que el móvil manda a una tarea se recorta a esto. */
+export declare const CARACTERES_DE_FEEDBACK = 4000;
+/** Como mucho una vez por este intervalo se manda un panorama nuevo a los móviles. */
+export declare const INTERVALO_DE_PANORAMA_MS = 1000;
+export type EstadoDeConsola = "trabajando" | "esperando-aprobacion" | "esperando-respuesta" | "parada";
+export type EstadoDeTareaEnPanorama = "nuevo" | "en-proceso" | "requiere-atencion" | "terminada";
+export interface AprobacionDePanorama {
+    pendientes: PendienteDeAprobacion[];
+    ficheros: Record<string, string>;
+    diffs: Record<string, LineaDeDiff[]>;
+    recortada?: true;
+}
+export interface ConsolaDePanorama {
+    id: string;
+    proyecto: string;
+    sesion?: string;
+    foco: boolean;
+    estado: EstadoDeConsola;
+    ultimaActividad?: string;
+    aprobacion?: AprobacionDePanorama;
+}
+export interface TareaDePanorama {
+    id: string;
+    titulo: string;
+    proyecto: string;
+    estado: EstadoDeTareaEnPanorama;
+    tras?: string;
+    motivo?: string;
+    creada: string;
+    acabada?: string;
+}
+export interface Panorama {
+    clase: "panorama";
+    consolas: ConsolaDePanorama[];
+    tareas: TareaDePanorama[];
+    esperando: number;
+}
+export interface EntradaDePanorama {
+    consolas: Array<{
+        id: string;
+        proyecto: string;
+        sesion?: string;
+        foco: boolean;
+        turnoEnVuelo: boolean;
+        aprobacion?: {
+            pendientes: PendienteDeAprobacion[];
+            ficheros: Record<string, string>;
+            diffs: Record<string, LineaDeDiff[]>;
+        };
+        preguntaPendiente: boolean;
+        ultimaActividad?: string;
+    }>;
+    tareas: TareaDePanorama[];
+}
+export declare function componerPanorama(entrada: EntradaDePanorama): Panorama;

package/dist/core/paqueteDeSoporte.d.ts

@@ -0,0 +1,100 @@
+/**
+ * El paquete de SOPORTE: lo que se exporta desde la pestaña Soporte para que alguien analice
+ * qué hizo un chat, una tarea o el proyecto entero. Las REGLAS, puras; el disco y el zip
+ * viven en `agent/soporte/paqueteEnDisco.ts`.
+ *
+ * ## Qué entra y qué no
+ *
+ * Es una LISTA NEGRA de lo que nunca viaja sobre lo que ya se recorre (el proyecto y su
+ * `.xonecode/`), y no una lista blanca de extensiones, porque la pregunta de soporte es
+ * «qué había»: una lista blanca dejaría fuera justo el fichero raro que explica el fallo.
+ * Lo que nunca viaja es lo que da acceso a algo —claves, tokens, el `.env`— y el historial
+ * de git, que el usuario no pidió (se decidió con él).
+ *
+ * Los secretos de xonecode viven en la CASA del usuario, no en el proyecto, así que aquí no
+ * deberían aparecer nunca. Los nombres se niegan igual: es la segunda llave, por si un día
+ * alguien copia uno donde no toca.
+ *
+ * ## Qué líneas de traza son de UN chat
+ *
+ * Solo las que traen su `chat`. **No se reparte nada por fechas**: las sesiones se reabren,
+ * así que la ventana `creada`→`ultimoTurno` de dos chats se solapa y la mayoría de las líneas
+ * caerían en el chat equivocado. Lo que no lleva `chat` —líneas anteriores a que existiera,
+ * y `traza-errores.jsonl`, cuyo sumidero es de todo el proceso— va solo en el paquete del
+ * PROYECTO, y el manifiesto dice por qué.
+ *
+ * ## Rutas de la máquina
+ *
+ * Los mensajes del hilo y el `detalle` de un comando de shell pueden llevar rutas absolutas.
+ * Es una excepción DECLARADA a `sinRutas`: esa regla es del cable, y esto es un fichero que la
+ * persona descarga y entrega a mano. El manifiesto lo avisa.
+ */
+export type TipoDePaquete = "proyecto" | "chat" | "tarea";
+/** Lo que admite un paquete, sumado en disco. Lo que no cabe se OMITE y se dice. */
+export declare const TOPE_DEL_PAQUETE_DE_SOPORTE: number;
+/** Carpetas que no viajan, estén donde estén. */
+export declare const CARPETAS_QUE_NO_VIAJAN: ReadonlySet<string>;
+/** Ficheros de credenciales de xonecode. Viven en la casa; negarlos aquí es la segunda llave. */
+export declare const SECRETOS_QUE_NO_VIAJAN: ReadonlySet<string>;
+/**
+ * El checkpoint no se recorre como un fichero más: con la conexión abierta, copiar sus bytes
+ * da una base a medio escribir. Se copia aparte con la copia en caliente de SQLite, y sus
+ * auxiliares (`-wal`, `-shm`) no viajan porque la copia ya los lleva dentro.
+ */
+export declare const NOMBRE_DEL_CHECKPOINT = "checkpoint.sqlite";
+/**
+ * ¿Viaja esta ruta en un paquete de soporte? `relativa` es POSIX, relativa a la raíz de lo
+ * que se recorre, sin barra delante.
+ */
+export declare function viajaEnSoporte(relativa: string): boolean;
+/** Las líneas de una traza que son de ESTE chat: las que traen su id. Nada por fechas. */
+export declare function lineasDelChat<T extends {
+    chat?: unknown;
+}>(lineas: readonly T[], chat: string): T[];
+/** Cuántas líneas NO llevan chat: se dice en el manifiesto del proyecto. */
+export declare function lineasSinChat(lineas: readonly {
+    chat?: unknown;
+}[]): number;
+/**
+ * El nombre del zip lo DERIVA el código, nunca llega del cliente: va en una cabecera
+ * `Content-Disposition` y un nombre con comillas o barras sería otra cosa.
+ */
+export declare function nombreDelPaquete(tipo: TipoDePaquete, nombre: string, ahora: Date): string;
+export interface Candidato {
+    /** La ruta DENTRO del zip. */
+    ruta: string;
+    bytes: number;
+}
+export interface Omitido {
+    ruta: string;
+    motivo: string;
+}
+/**
+ * Lo que cabe bajo el tope. Si no cabe todo, se omite empezando por lo MÁS GRANDE: una imagen
+ * de veinte megas explica menos que cien ficheros de texto, y soltar lo grande primero deja
+ * dentro el mayor número de ficheros. Lo omitido se DICE en el manifiesto, con su tamaño.
+ */
+export declare function repartirPorTope<T extends Candidato>(candidatos: readonly T[], tope: number): {
+    entran: T[];
+    omitidos: Omitido[];
+};
+export interface ManifiestoDeSoporte {
+    v: 1;
+    tipo: TipoDePaquete;
+    /** Versión de xonecode que lo generó, si se sabe. */
+    version?: string;
+    generado: string;
+    proyecto: string;
+    /** El id del chat o de la tarea exportados. */
+    id?: string;
+    motor?: string;
+    /** Había un turno o una tarea EN VUELO al exportar: la foto puede estar a medias. */
+    enVuelo?: boolean;
+    incluidos: string[];
+    omitidos: Omitido[];
+    /** Lo que el paquete NO puede afirmar, dicho en una frase cada uno. */
+    avisos: string[];
+}
+export declare const AVISO_DE_RUTAS = "Los mensajes del hilo y los comandos de shell pueden llevar rutas absolutas de la m\u00E1quina de quien exporta.";
+export declare const AVISO_DE_TRAZA_SIN_CHAT = "Las l\u00EDneas de traza sin id de chat (anteriores a que existiera, y toda traza-errores.jsonl) no se pueden atribuir a un chat: solo van en el paquete del proyecto.";
+export declare const AVISO_EN_VUELO = "Hab\u00EDa un turno o una tarea en marcha al exportar: lo \u00FAltimo puede estar a medias.";

package/dist/core/planDeSubida.d.ts

@@ -0,0 +1,56 @@
+/**
+ * De un diff de git a una lista de operaciones de subida.
+ *
+ * Es PURA a propósito: aquí vive la regla que evita una pérdida de datos, y una regla así
+ * no puede depender de que el disco o la red se porten bien para poder probarse.
+ */
+import type { OperacionDeSubida, OperacionOmitida } from "./cloudstudio.js";
+/** Medido: `studio_upload_file` en modo base64 admite hasta 5 MB decodificados. */
+export declare const TOPE_BASE64: number;
+/**
+ * Medido contra el servidor: `studio_get_file` (y por tanto `studio_edit_file`) solo
+ * trata estas extensiones como texto. Todo lo demás es binario y va por `upload_file`.
+ */
+export declare const EXTENSIONES_DE_TEXTO: Set<string>;
+export interface CambioLocal {
+    clase: "nuevo" | "modificado" | "borrado";
+    ruta: string;
+}
+export interface EntradaDelPlan {
+    cambios: CambioLocal[];
+    /** Lo que la descarga trajo DE VERDAD. El candado se apoya en esto. */
+    descargados: ReadonlySet<string>;
+    /** Tamaño local de cada ruta; sin él, un binario no se puede subir. */
+    tamanos: ReadonlyMap<string, number>;
+    /** Los `.xne` presentes, para reconocer las vistas aplanadas. */
+    fuentesXne?: ReadonlySet<string>;
+}
+/**
+ * La extensión de una ruta POSIX, en minúsculas, o `""` si no tiene.
+ *
+ * Dos trampas que la versión ingenua (`ruta.lastIndexOf(".")` sobre la ruta entera) no
+ * veía, y que se exporta para que no vuelva a haber dos copias divergentes de esta regla:
+ *
+ * - **Un punto en la posición 0 no es una extensión**: es un fichero OCULTO sin ella.
+ *   `".env".lastIndexOf(".")` es 0, así que devolvía `".env"` como si `.env` fuera un tipo
+ *   de fichero. No está en la lista de texto, con lo cual `.env` se clasificaba como
+ *   BINARIO y podía subirse al proyecto del cliente entero.
+ * - **El punto puede estar en un DIRECTORIO**: en `iconos.v2/logo` el último punto está en
+ *   el directorio, y devolvía `".v2/logo"`. Se mira solo el último segmento.
+ */
+export declare const extensionDe: (ruta: string) => string;
+/**
+ * El plan: lo que SE PUEDE hacer y lo que NO, por separado.
+ *
+ * Separarlos es el camino de escape de la subida. Antes, una operación imposible (un
+ * binario de más de 5 MB, el borrado de un binario) se quedaba en el plan, fallaba contra
+ * el servidor, y como la ref solo avanza con `fallos` vacío, el siguiente `/sync`
+ * recalculaba el MISMO plan y volvía a fallar: `/sync subir` quedaba inútil para siempre
+ * a partir de la primera imagen borrada. Ahora sale del plan, se declara, y la ref avanza
+ * con el resto.
+ */
+export interface Plan {
+    operaciones: OperacionDeSubida[];
+    omitidas: OperacionOmitida[];
+}
+export declare function planDeSubida(entrada: EntradaDelPlan): Plan;

package/dist/core/planes.d.ts

@@ -0,0 +1,53 @@
+/** La ruta virtual. La barra final es obligatoria: `CompositeBackend` la retira al delegar. */
+export declare const RUTA_PLANES = "/planes/";
+/** Dónde caen de verdad, relativo a la raíz del proyecto. */
+export declare const CARPETA_DE_PLANES = ".xonecode/planes";
+/**
+ * **Un plan es una CARPETA, no un fichero**, porque dentro de una sesión puede haber varios y
+ * porque un plan son tres cosas que se acompañan (`PLAN.md`, `TASKS.md`, `CONTEXT.md`) más sus
+ * ADRs. Con ficheros sueltos, dos planes a la vez se pisan.
+ */
+export declare const FICHEROS_DE_UN_PLAN: readonly ["PLAN.md", "TASKS.md", "CONTEXT.md"];
+/**
+ * Por qué un nombre de plan no vale, o `undefined` si vale.
+ *
+ * **La MISMA regla que la de un subagente o una skill**, y a propósito: el nombre se convierte
+ * en un segmento de ruta, y tres reglas distintas para lo mismo son tres sitios donde discrepar
+ * sobre qué es un nombre seguro.
+ */
+export declare function motivoDePlanInaceptable(nombre: string): string | undefined;
+/**
+ * ¿Es una ruta de plan bien formada? Lista BLANCA de forma, no un `startsWith`.
+ *
+ * Tiene que ser `/planes/<slug>/<algo>`: con el slug validado y sin salirse por un `..`, un
+ * `\` ni una barra de más. Es la misma clase de criba que `esRutaDeArtefacto`, y existe por lo
+ * mismo: lo que el modelo escribe es texto, y de ahí sale una ruta del disco.
+ */
+export declare function esRutaDePlan(ruta: string | undefined): boolean;
+/** La carpeta de un plan, tal como la ve el agente. */
+export declare function rutaDelPlan(nombre: string): string;
+/**
+ * Dónde cae un plan cuando se PUBLICA, y por qué publicar es un acto aparte.
+ *
+ * `.xonecode/planes/` es estado de trabajo: no entra en git, no sube a CloudStudio y no lo
+ * ve nadie más que la copia que lo escribió. Eso es lo que hace barato trabajarlo —el que
+ * desarrolla marca una tarea como hecha sin sacar un modal, y eso está medido: cuando salía,
+ * se rechazaba y el plan se quedaba viejo en silencio; en una tarea de fondo no lo pulsa
+ * nadie—. El precio es que el plan no viaja: si se borra la copia local, se fue con ella.
+ *
+ * Así que compartirlo es un PASO EXPLÍCITO y no un efecto. Se copia a `doc/planes/<nombre>`,
+ * que sí es del proyecto: entra en el commit del turno y sube a Studio con lo demás. La
+ * decisión de publicar se ve, en vez de ocurrir sola la primera vez que alguien planifica.
+ *
+ * **Y lo hace el HARNESS, no el agente** — el mismo reparto que `/pdf`: la autorización es
+ * teclear el comando, el destino lo DERIVA el código del nombre, y no hay prompt que pueda
+ * torcerlo hacia otra carpeta.
+ */
+export declare const CARPETA_PUBLICA_DE_PLANES = "doc/planes";
+/**
+ * La carpeta publicada de un plan, relativa a la raíz del proyecto.
+ *
+ * Devuelve `undefined` si el nombre no vale, en vez de componer una ruta con él: de aquí sale
+ * una ruta del disco, y es la misma criba que `esRutaDePlan` aplica del otro lado.
+ */
+export declare function rutaPublicaDelPlan(nombre: string): string | undefined;

package/dist/core/podaDeCheckpoint.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Cuándo adelgazar el `checkpoint.sqlite` de un proyecto, y qué se queda dentro.
+ *
+ * **El problema, medido**: un fichero de un proyecto real llegó a 918 MB con UNA sesión
+ * dentro. No es basura acumulada — es que un checkpoint guarda la lista de mensajes ENTERA y
+ * se escribe uno por paso del grafo, así que el coste crece con el CUADRADO de la
+ * conversación: el primer checkpoint de esa sesión ocupaba 3 KB y el mayor 3.885 KB, con
+ * 2.794 pasos. Y el 70 % no era del hilo: eran los 21 espacios `tools:*` de los subagentes,
+ * cada delegación con su propia cadena.
+ *
+ * **Y no hay nada oficial que adoptar.** Comprobado contra el paquete instalado, no contra un
+ * blog: `BaseCheckpointSaver` declara cinco métodos —`getTuple`, `list`, `put`, `putWrites`,
+ * `deleteThread`— y ninguno poda; no existe `prune()` en JavaScript, y el único `ttl` del
+ * paquete es el de `InMemoryCache`, que es la caché de un NODO y otra cosa. La doc de
+ * persistencia reconoce el problema («prune old checkpoints periodically») sin dar una sola
+ * API ni decir qué filas hacen falta para reanudar, y el issue de langgraph.js que pregunta
+ * exactamente esto sigue abierto y sin contestar. Como el `SqliteSaver` es NUESTRO
+ * (`vendor/sqliteSaver.ts`), el SQL lo escribimos aquí y no se espera a nadie.
+ *
+ * Este módulo es la REGLA y no toca disco: decide SI se poda. El SQL vive en
+ * `agent/sesiones/checkpointer.ts`, que es quien ya tiene la conexión.
+ */
+/**
+ * A partir de cuánto estorba, en bytes.
+ *
+ * **Dimensionada con lo medido, no elegida**: una sesión de 2.794 pasos YA PODADA ocupa
+ * ~21 MB, así que 256 MB deja un orden de magnitud de margen y esto no puede cortar por lo
+ * sano en un proyecto que se porta bien. Es un TECHO, no un objetivo: un proyecto que nunca
+ * lo alcance no ejecuta la poda jamás.
+ *
+ * **Y la histéresis sale gratis de aquí**: podar deja el fichero en decenas de MB, o sea muy
+ * por debajo de la cota, así que no puede reengancharse turno tras turno. El propio tamaño es
+ * el estado, y por eso esto no necesita un fichero de marca ni recordar cuándo se podó — que
+ * es justo el trasto que se acumula en este repo.
+ */
+export declare const COTA_DE_PODA_BYTES: number;
+export interface SituacionDeLaBase {
+    /** Lo que ocupa el fichero AHORA. */
+    bytes: number;
+    /**
+     * Si hay algo del grafo a medias: un subagente parado en una aprobación, una tarea
+     * pendiente. Ausente es «no se pudo mirar».
+     */
+    hayPendientes?: boolean;
+}
+/**
+ * ¿Toca podar?
+ *
+ * Dos condiciones, y la segunda es la que hace esto seguro:
+ *
+ * - **Pasa de la cota.** Si no, no hay nada que arreglar y mirar el tamaño cuesta un
+ *   `statSync`, o sea nada.
+ * - **No hay NADA pendiente.** Un subagente parado en una aprobación vive en su espacio
+ *   `tools:*`, y podarlo a media aprobación se lleva la reanudación por delante. Es un
+ *   predicado sobre datos que la base ya tiene, no una heurística.
+ *
+ * **Fail-closed: lo que no se sabe NO se poda** (`hayPendientes` ausente). La dirección
+ * segura aquí es la que no borra: un fichero grande es un incordio, y una sesión que no
+ * reanuda es trabajo perdido. La misma regla que «un verificador que no corrió no es verde».
+ */
+export declare function debePodar(situacion: SituacionDeLaBase): boolean;
+export interface ResultadoDePoda {
+    antes: number;
+    despues: number;
+    checkpointsBorrados: number;
+    writesBorrados: number;
+}
+/**
+ * Lo que se cuenta de una poda, y **solo cuando cambió algo de verdad**.
+ *
+ * Un mantenimiento que anuncia su propia rutina es un aviso que enseña a ignorar los avisos,
+ * que es lo que la bitácora existe para evitar: si no se recuperó nada, esto se calla. Y no
+ * lleva la RUTA del fichero, porque esta línea puede viajar por el cable (`sinRutas`).
+ */
+export declare function resumenDePoda(r: ResultadoDePoda): string | undefined;