@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/audit/registro-sesion.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Todo lo que Ada añade alrededor de una llamada a herramienta, en una pieza.
+ *
+ * Reúne tres cosas que empezaron sueltas dentro de `agent-session.ts` —el libro
+ * de sesión, la política de aprobación y el observador de ediciones— porque las
+ * tres cuelgan de los mismos dos ganchos y comparten el ciclo de vida de la
+ * llamada.
+ *
+ * El motivo de agruparlas no es estético. `agent-session.ts` es de upstream y
+ * cada región nuestra que vive ahí es un hunk que se reaplica en cada
+ * sincronización y se rompe cuando upstream refactoriza. Tres campos y un
+ * método sueltos partían el hunk de declaraciones en dos y se pasaban del
+ * presupuesto; un campo y dos llamadas, no. La regla está escrita en
+ * `core/ada.ts`: si vas a tocar `agent-session.ts`, mira antes si lo tuyo cabe
+ * en un módulo propio.
+ */
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import { type Decision } from "../aprobacion/politica.ts";
+import { LibroDeSesion } from "./libro.ts";
+/** El trozo de configuración del motor que le hace falta a esto. */
+interface ConfigConPermisos {
+    permissions?: Record<string, unknown>;
+    goalEngine?: {
+        planOnly?: boolean;
+    };
+}
+export declare class RegistroDeSesion {
+    private readonly agentDir;
+    private readonly sesionId;
+    private readonly observador;
+    /** Decisión de cada llamada, de `beforeToolCall` a `afterToolCall`. */
+    private readonly decisiones;
+    /**
+     * Llamadas que el modelo ANUNCIÓ y de las que el libro aún no sabe nada.
+     *
+     * Existe porque había un hueco medido: `validateToolArguments` corre ANTES
+     * que `beforeToolCall`, así que una llamada rechazada por sus argumentos
+     * —el error más común de los modelos pequeños— no llegaba a ninguno de
+     * nuestros dos enganches y desaparecía del libro. Ocurrió de verdad en una
+     * comparación contra un modelo gratuito: el transcript tenía dos `edit` y el
+     * libro solo una. Un registro que se vende como «qué hizo el agente» no puede
+     * callarse lo que el agente intentó hacer.
+     */
+    private readonly anunciadas;
+    private _libro?;
+    constructor(agentDir: () => string, sesionId: () => string, cwd: () => string, completar?: (prompt: string) => Promise<string | null>);
+    /**
+     * El libro, creado en la primera anotación.
+     *
+     * Perezoso a propósito: abrirlo al construir la sesión crearía el directorio
+     * incluso para sesiones que no llegan a hacer nada, y entonces "no hay
+     * registro" y "no hizo nada" dejarían de distinguirse.
+     */
+    libro(): LibroDeSesion;
+    /**
+     * Antes de ejecutar: decide si se permite y guarda la preimagen del fichero.
+     *
+     * Devuelve la decisión. Quien llama corta si es `denegada`; la denegación ya
+     * queda anotada aquí.
+     */
+    antesDeLlamada(idLlamada: string, tool: string, args: Record<string, unknown>, config: ConfigConPermisos): Promise<Decision>;
+    /**
+     * Después de ejecutar: anota lo ocurrido y devuelve el aviso de edición rota,
+     * o `null` si no hay nada que decir — que es el caso de casi todas.
+     */
+    trasLlamada(idLlamada: string, tool: string, args: Record<string, unknown>, huboError: boolean): Promise<string | null>;
+    /**
+     * Una llamada al modelo.
+     *
+     * Se anota por llamada y no por turno porque un turno puede gastar varias, y
+     * "qué modelo se usó y cuánto costó" hay que poder responderlo con ese grano.
+     * Las que fallan también: `motivoParada: "error"` es justo lo que hay que
+     * poder enseñar.
+     */
+    anotarModelo(asistente: AssistantMessage): void;
+}
+export {};
+//# sourceMappingURL=registro-sesion.d.ts.map

package/dist/core/audit/registro-sesion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registro-sesion.d.ts","sourceRoot":"","sources":["../../../src/core/audit/registro-sesion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,KAAK,QAAQ,EAA0B,MAAM,2BAA2B,CAAC;AAIlF,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,qEAAoE;AACpE,UAAU,iBAAiB;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,UAAU,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACpC;AAED,qBAAa,gBAAgB;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwB;IACnD,wEAAuE;IACvE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA+B;IAC1D;;;;;;;;;;OAUG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,MAAM,CAAC,CAAgB;IAW/B,YACC,QAAQ,EAAE,MAAM,MAAM,EACtB,QAAQ,EAAE,MAAM,MAAM,EACtB,GAAG,EAAE,MAAM,MAAM,EACjB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,EAatD;IAED;;;;;;OAMG;IACH,KAAK,IAAI,aAAa,CAGrB;IAED;;;;;OAKG;IACG,cAAc,CACnB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,MAAM,EAAE,iBAAiB,GACvB,OAAO,CAAC,QAAQ,CAAC,CA6BnB;IAED;;;OAGG;IACG,WAAW,CAChB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,SAAS,EAAE,OAAO,GAChB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA+CxB;IAED;;;;;;;OAOG;IACH,YAAY,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAqC9C;CACD","sourcesContent":["/**\n * Todo lo que Ada añade alrededor de una llamada a herramienta, en una pieza.\n *\n * Reúne tres cosas que empezaron sueltas dentro de `agent-session.ts` —el libro\n * de sesión, la política de aprobación y el observador de ediciones— porque las\n * tres cuelgan de los mismos dos ganchos y comparten el ciclo de vida de la\n * llamada.\n *\n * El motivo de agruparlas no es estético. `agent-session.ts` es de upstream y\n * cada región nuestra que vive ahí es un hunk que se reaplica en cada\n * sincronización y se rompe cuando upstream refactoriza. Tres campos y un\n * método sueltos partían el hunk de declaraciones en dos y se pasaban del\n * presupuesto; un campo y dos llamadas, no. La regla está escrita en\n * `core/ada.ts`: si vas a tocar `agent-session.ts`, mira antes si lo tuyo cabe\n * en un módulo propio.\n */\n\nimport type { AssistantMessage } from \"@earendil-works/pi-ai\";\nimport { type Decision, decidir, leerDenegadas } from \"../aprobacion/politica.ts\";\nimport { ObservadorDeEdiciones } from \"../edicion/observador.ts\";\nimport { publicarLibroDeSesion } from \"../extensiones/vigilancia.ts\";\nimport { nivelDesdeConfig } from \"../hooks/session-hooks.ts\";\nimport { LibroDeSesion } from \"./libro.ts\";\n\n/** El trozo de configuración del motor que le hace falta a esto. */\ninterface ConfigConPermisos {\n\tpermissions?: Record<string, unknown>;\n\tgoalEngine?: { planOnly?: boolean };\n}\n\nexport class RegistroDeSesion {\n\tprivate readonly agentDir: () => string;\n\tprivate readonly sesionId: () => string;\n\tprivate readonly observador: ObservadorDeEdiciones;\n\t/** Decisión de cada llamada, de `beforeToolCall` a `afterToolCall`. */\n\tprivate readonly decisiones = new Map<string, Decision>();\n\t/**\n\t * Llamadas que el modelo ANUNCIÓ y de las que el libro aún no sabe nada.\n\t *\n\t * Existe porque había un hueco medido: `validateToolArguments` corre ANTES\n\t * que `beforeToolCall`, así que una llamada rechazada por sus argumentos\n\t * —el error más común de los modelos pequeños— no llegaba a ninguno de\n\t * nuestros dos enganches y desaparecía del libro. Ocurrió de verdad en una\n\t * comparación contra un modelo gratuito: el transcript tenía dos `edit` y el\n\t * libro solo una. Un registro que se vende como «qué hizo el agente» no puede\n\t * callarse lo que el agente intentó hacer.\n\t */\n\tprivate readonly anunciadas = new Map<string, string>();\n\tprivate _libro?: LibroDeSesion;\n\n\t// Los tres primeros son funciones y no valores: este objeto se construye en\n\t// un inicializador de campo de `AgentSession`, que corre ANTES del cuerpo\n\t// del constructor. `this.sessionId` es un getter sobre estado que todavía\n\t// no existe ahí, y leerlo en ese momento reventaba la sesión entera —76\n\t// ficheros de prueba en rojo— sin que los tipos dijeran nada.\n\t//\n\t// `completar` es opcional: sin modelo (sesiones de prueba, subagentes sin\n\t// auth) la auto-reparación de ediciones rotas queda \"no-aplicable\" en vez\n\t// de intentarlo con `undefined` y reventar.\n\tconstructor(\n\t\tagentDir: () => string,\n\t\tsesionId: () => string,\n\t\tcwd: () => string,\n\t\tcompletar?: (prompt: string) => Promise<string | null>,\n\t) {\n\t\tthis.agentDir = agentDir;\n\t\tthis.sesionId = sesionId;\n\t\tthis.observador = new ObservadorDeEdiciones(cwd, agentDir, completar);\n\t\t// `pi.exec` de una extensión escribe en el MISMO libro que las llamadas\n\t\t// del agente. Sin esto, la extensión abriría su propio fichero de sesión\n\t\t// y quien auditara el de la conversación no vería nada — que es el mismo\n\t\t// agujero de antes con un rastro más difícil de encontrar.\n\t\t//\n\t\t// Se publica un getter para no forzar la creación del libro aquí: sigue\n\t\t// siendo perezoso, y una sesión que no hace nada no deja directorio.\n\t\tpublicarLibroDeSesion(() => this.libro());\n\t}\n\n\t/**\n\t * El libro, creado en la primera anotación.\n\t *\n\t * Perezoso a propósito: abrirlo al construir la sesión crearía el directorio\n\t * incluso para sesiones que no llegan a hacer nada, y entonces \"no hay\n\t * registro\" y \"no hizo nada\" dejarían de distinguirse.\n\t */\n\tlibro(): LibroDeSesion {\n\t\tthis._libro ??= new LibroDeSesion(this.agentDir(), this.sesionId());\n\t\treturn this._libro;\n\t}\n\n\t/**\n\t * Antes de ejecutar: decide si se permite y guarda la preimagen del fichero.\n\t *\n\t * Devuelve la decisión. Quien llama corta si es `denegada`; la denegación ya\n\t * queda anotada aquí.\n\t */\n\tasync antesDeLlamada(\n\t\tidLlamada: string,\n\t\ttool: string,\n\t\targs: Record<string, unknown>,\n\t\tconfig: ConfigConPermisos,\n\t): Promise<Decision> {\n\t\tconst decision = decidir({\n\t\t\ttool,\n\t\t\targs,\n\t\t\tmodo: nivelDesdeConfig(config),\n\t\t\tagentDir: this.agentDir(),\n\t\t\tdenegadas: leerDenegadas(config),\n\t\t});\n\n\t\tif (decision.veredicto === \"denegada\") {\n\t\t\tvoid this.libro().anotar({\n\t\t\t\ttipo: \"tool\",\n\t\t\t\tnombre: tool,\n\t\t\t\tok: false,\n\t\t\t\tdecision: \"denegada\",\n\t\t\t\tmotivo: decision.politica,\n\t\t\t});\n\t\t\t// Una llamada bloqueada no llega a `trasLlamada`, así que no se guarda\n\t\t\t// nada que luego nadie recogería. Y ya está anotada arriba: se saca de\n\t\t\t// las pendientes para que la reconciliación no la cuente dos veces.\n\t\t\tthis.anunciadas.delete(idLlamada);\n\t\t\treturn decision;\n\t\t}\n\n\t\t// Tope por si alguna llamada muere antes de consumirse.\n\t\tif (this.decisiones.size > 256) this.decisiones.clear();\n\t\tthis.decisiones.set(idLlamada, decision);\n\t\tawait this.observador.antesDe(idLlamada, tool, args);\n\t\treturn decision;\n\t}\n\n\t/**\n\t * Después de ejecutar: anota lo ocurrido y devuelve el aviso de edición rota,\n\t * o `null` si no hay nada que decir — que es el caso de casi todas.\n\t */\n\tasync trasLlamada(\n\t\tidLlamada: string,\n\t\ttool: string,\n\t\targs: Record<string, unknown>,\n\t\thuboError: boolean,\n\t): Promise<string | null> {\n\t\tconst aprobacion = this.decisiones.get(idLlamada);\n\t\tthis.decisiones.delete(idLlamada);\n\t\tthis.anunciadas.delete(idLlamada);\n\n\t\tconst comando = (args as { command?: unknown } | undefined)?.command;\n\t\tvoid this.libro().anotar(\n\t\t\ttool === \"bash\" && typeof comando === \"string\"\n\t\t\t\t? { tipo: \"comando\", argv: [comando], codigo: huboError ? 1 : 0, origen: \"agente\" }\n\t\t\t\t: {\n\t\t\t\t\t\ttipo: \"tool\",\n\t\t\t\t\t\tnombre: tool,\n\t\t\t\t\t\tok: !huboError,\n\t\t\t\t\t\t// Qué regla la dejó pasar. Sin esto el libro dice que algo\n\t\t\t\t\t\t// ocurrió pero no por qué se permitió, que es justo la mitad\n\t\t\t\t\t\t// que pregunta una auditoría.\n\t\t\t\t\t\tdecision: aprobacion?.veredicto,\n\t\t\t\t\t\tmotivo: aprobacion?.politica,\n\t\t\t\t\t},\n\t\t);\n\n\t\tconst aviso = await this.observador.despuesDe(idLlamada, huboError);\n\n\t\t// El suceso `fichero` del libro: art. 30 RGPD, qué ficheros se trataron.\n\t\t//\n\t\t// El tipo existía en `libro.ts` desde el primer día y NADIE lo anotaba: el\n\t\t// comentario de `agent-session.ts` decía \"los hashes de fichero llegan con\n\t\t// el observador de ediciones\", en futuro, y nunca llegaron. La auditoría\n\t\t// enterprise lo encontró preguntando lo que pregunta un DPO. Es el defecto\n\t\t// número uno de esta casa: capacidad construida y desenchufada, con el tipo\n\t\t// compilando y las pruebas en verde porque las pruebas anotaban a mano.\n\t\t//\n\t\t// Se toma del observador, que ya leyó las dos versiones, en vez de releer el\n\t\t// fichero aquí. El libro hashea `antes` y `despues` al escribir, así que el\n\t\t// contenido pasa por aquí pero no llega a disco.\n\t\tconst cambio = this.observador.ultimoCambio(idLlamada);\n\t\tif (cambio) {\n\t\t\tvoid this.libro().anotar({\n\t\t\t\ttipo: \"fichero\",\n\t\t\t\truta: cambio.ruta,\n\t\t\t\tantes: cambio.antes,\n\t\t\t\tdespues: cambio.despues,\n\t\t\t\ttool,\n\t\t\t});\n\t\t}\n\n\t\treturn aviso;\n\t}\n\n\t/**\n\t * Una llamada al modelo.\n\t *\n\t * Se anota por llamada y no por turno porque un turno puede gastar varias, y\n\t * \"qué modelo se usó y cuánto costó\" hay que poder responderlo con ese grano.\n\t * Las que fallan también: `motivoParada: \"error\"` es justo lo que hay que\n\t * poder enseñar.\n\t */\n\tanotarModelo(asistente: AssistantMessage): void {\n\t\t// RECONCILIAR PRIMERO. Para cuando llega este mensaje, las herramientas del\n\t\t// anterior ya se ejecutaron —el bucle las espera—, así que todo lo que siga\n\t\t// pendiente es una llamada que el modelo pidió y que nunca llegó a\n\t\t// ejecutarse: argumentos que no validaron, o una herramienta inexistente.\n\t\tfor (const [id, nombre] of this.anunciadas) {\n\t\t\tvoid this.libro().anotar({\n\t\t\t\ttipo: \"tool\",\n\t\t\t\tnombre,\n\t\t\t\tok: false,\n\t\t\t\tdecision: \"no-ejecutada\",\n\t\t\t\t// El motivo no se inventa: desde aquí no se ve la causa exacta, y\n\t\t\t\t// escribir una supuesta sería peor que nombrar lo que sí se sabe.\n\t\t\t\tmotivo: \"el modelo la pidió y no llegó a ejecutarse (argumentos inválidos o herramienta inexistente)\",\n\t\t\t});\n\t\t\tthis.anunciadas.delete(id);\n\t\t}\n\n\t\tif (!asistente.usage) return;\n\n\t\t// Y se apuntan las de ESTE mensaje, para poder reconciliarlas en el\n\t\t// siguiente.\n\t\tfor (const bloque of asistente.content) {\n\t\t\tif (bloque.type === \"toolCall\") this.anunciadas.set(bloque.id, bloque.name);\n\t\t}\n\t\tvoid this.libro().anotar({\n\t\t\ttipo: \"modelo\",\n\t\t\tproveedor: asistente.provider,\n\t\t\t// `responseModel` es el modelo CONCRETO cuando lo pedido era un alias\n\t\t\t// (el `auto` de OpenRouter, por ejemplo). Para un registro de\n\t\t\t// cumplimiento importa el que respondió, no el que se pidió.\n\t\t\tmodelo: asistente.responseModel ?? asistente.model,\n\t\t\tentrada: asistente.usage.input,\n\t\t\tsalida: asistente.usage.output,\n\t\t\tcoste: asistente.usage.cost?.total,\n\t\t\tmotivoParada: asistente.stopReason,\n\t\t});\n\t}\n}\n"]}

package/dist/core/audit/registro-sesion.js

@@ -0,0 +1,202 @@
+/**
+ * Todo lo que Ada añade alrededor de una llamada a herramienta, en una pieza.
+ *
+ * Reúne tres cosas que empezaron sueltas dentro de `agent-session.ts` —el libro
+ * de sesión, la política de aprobación y el observador de ediciones— porque las
+ * tres cuelgan de los mismos dos ganchos y comparten el ciclo de vida de la
+ * llamada.
+ *
+ * El motivo de agruparlas no es estético. `agent-session.ts` es de upstream y
+ * cada región nuestra que vive ahí es un hunk que se reaplica en cada
+ * sincronización y se rompe cuando upstream refactoriza. Tres campos y un
+ * método sueltos partían el hunk de declaraciones en dos y se pasaban del
+ * presupuesto; un campo y dos llamadas, no. La regla está escrita en
+ * `core/ada.ts`: si vas a tocar `agent-session.ts`, mira antes si lo tuyo cabe
+ * en un módulo propio.
+ */
+import { decidir, leerDenegadas } from "../aprobacion/politica.js";
+import { ObservadorDeEdiciones } from "../edicion/observador.js";
+import { publicarLibroDeSesion } from "../extensiones/vigilancia.js";
+import { nivelDesdeConfig } from "../hooks/session-hooks.js";
+import { LibroDeSesion } from "./libro.js";
+export class RegistroDeSesion {
+    agentDir;
+    sesionId;
+    observador;
+    /** Decisión de cada llamada, de `beforeToolCall` a `afterToolCall`. */
+    decisiones = new Map();
+    /**
+     * Llamadas que el modelo ANUNCIÓ y de las que el libro aún no sabe nada.
+     *
+     * Existe porque había un hueco medido: `validateToolArguments` corre ANTES
+     * que `beforeToolCall`, así que una llamada rechazada por sus argumentos
+     * —el error más común de los modelos pequeños— no llegaba a ninguno de
+     * nuestros dos enganches y desaparecía del libro. Ocurrió de verdad en una
+     * comparación contra un modelo gratuito: el transcript tenía dos `edit` y el
+     * libro solo una. Un registro que se vende como «qué hizo el agente» no puede
+     * callarse lo que el agente intentó hacer.
+     */
+    anunciadas = new Map();
+    _libro;
+    // Los tres primeros son funciones y no valores: este objeto se construye en
+    // un inicializador de campo de `AgentSession`, que corre ANTES del cuerpo
+    // del constructor. `this.sessionId` es un getter sobre estado que todavía
+    // no existe ahí, y leerlo en ese momento reventaba la sesión entera —76
+    // ficheros de prueba en rojo— sin que los tipos dijeran nada.
+    //
+    // `completar` es opcional: sin modelo (sesiones de prueba, subagentes sin
+    // auth) la auto-reparación de ediciones rotas queda "no-aplicable" en vez
+    // de intentarlo con `undefined` y reventar.
+    constructor(agentDir, sesionId, cwd, completar) {
+        this.agentDir = agentDir;
+        this.sesionId = sesionId;
+        this.observador = new ObservadorDeEdiciones(cwd, agentDir, completar);
+        // `pi.exec` de una extensión escribe en el MISMO libro que las llamadas
+        // del agente. Sin esto, la extensión abriría su propio fichero de sesión
+        // y quien auditara el de la conversación no vería nada — que es el mismo
+        // agujero de antes con un rastro más difícil de encontrar.
+        //
+        // Se publica un getter para no forzar la creación del libro aquí: sigue
+        // siendo perezoso, y una sesión que no hace nada no deja directorio.
+        publicarLibroDeSesion(() => this.libro());
+    }
+    /**
+     * El libro, creado en la primera anotación.
+     *
+     * Perezoso a propósito: abrirlo al construir la sesión crearía el directorio
+     * incluso para sesiones que no llegan a hacer nada, y entonces "no hay
+     * registro" y "no hizo nada" dejarían de distinguirse.
+     */
+    libro() {
+        this._libro ??= new LibroDeSesion(this.agentDir(), this.sesionId());
+        return this._libro;
+    }
+    /**
+     * Antes de ejecutar: decide si se permite y guarda la preimagen del fichero.
+     *
+     * Devuelve la decisión. Quien llama corta si es `denegada`; la denegación ya
+     * queda anotada aquí.
+     */
+    async antesDeLlamada(idLlamada, tool, args, config) {
+        const decision = decidir({
+            tool,
+            args,
+            modo: nivelDesdeConfig(config),
+            agentDir: this.agentDir(),
+            denegadas: leerDenegadas(config),
+        });
+        if (decision.veredicto === "denegada") {
+            void this.libro().anotar({
+                tipo: "tool",
+                nombre: tool,
+                ok: false,
+                decision: "denegada",
+                motivo: decision.politica,
+            });
+            // Una llamada bloqueada no llega a `trasLlamada`, así que no se guarda
+            // nada que luego nadie recogería. Y ya está anotada arriba: se saca de
+            // las pendientes para que la reconciliación no la cuente dos veces.
+            this.anunciadas.delete(idLlamada);
+            return decision;
+        }
+        // Tope por si alguna llamada muere antes de consumirse.
+        if (this.decisiones.size > 256)
+            this.decisiones.clear();
+        this.decisiones.set(idLlamada, decision);
+        await this.observador.antesDe(idLlamada, tool, args);
+        return decision;
+    }
+    /**
+     * Después de ejecutar: anota lo ocurrido y devuelve el aviso de edición rota,
+     * o `null` si no hay nada que decir — que es el caso de casi todas.
+     */
+    async trasLlamada(idLlamada, tool, args, huboError) {
+        const aprobacion = this.decisiones.get(idLlamada);
+        this.decisiones.delete(idLlamada);
+        this.anunciadas.delete(idLlamada);
+        const comando = args?.command;
+        void this.libro().anotar(tool === "bash" && typeof comando === "string"
+            ? { tipo: "comando", argv: [comando], codigo: huboError ? 1 : 0, origen: "agente" }
+            : {
+                tipo: "tool",
+                nombre: tool,
+                ok: !huboError,
+                // Qué regla la dejó pasar. Sin esto el libro dice que algo
+                // ocurrió pero no por qué se permitió, que es justo la mitad
+                // que pregunta una auditoría.
+                decision: aprobacion?.veredicto,
+                motivo: aprobacion?.politica,
+            });
+        const aviso = await this.observador.despuesDe(idLlamada, huboError);
+        // El suceso `fichero` del libro: art. 30 RGPD, qué ficheros se trataron.
+        //
+        // El tipo existía en `libro.ts` desde el primer día y NADIE lo anotaba: el
+        // comentario de `agent-session.ts` decía "los hashes de fichero llegan con
+        // el observador de ediciones", en futuro, y nunca llegaron. La auditoría
+        // enterprise lo encontró preguntando lo que pregunta un DPO. Es el defecto
+        // número uno de esta casa: capacidad construida y desenchufada, con el tipo
+        // compilando y las pruebas en verde porque las pruebas anotaban a mano.
+        //
+        // Se toma del observador, que ya leyó las dos versiones, en vez de releer el
+        // fichero aquí. El libro hashea `antes` y `despues` al escribir, así que el
+        // contenido pasa por aquí pero no llega a disco.
+        const cambio = this.observador.ultimoCambio(idLlamada);
+        if (cambio) {
+            void this.libro().anotar({
+                tipo: "fichero",
+                ruta: cambio.ruta,
+                antes: cambio.antes,
+                despues: cambio.despues,
+                tool,
+            });
+        }
+        return aviso;
+    }
+    /**
+     * Una llamada al modelo.
+     *
+     * Se anota por llamada y no por turno porque un turno puede gastar varias, y
+     * "qué modelo se usó y cuánto costó" hay que poder responderlo con ese grano.
+     * Las que fallan también: `motivoParada: "error"` es justo lo que hay que
+     * poder enseñar.
+     */
+    anotarModelo(asistente) {
+        // RECONCILIAR PRIMERO. Para cuando llega este mensaje, las herramientas del
+        // anterior ya se ejecutaron —el bucle las espera—, así que todo lo que siga
+        // pendiente es una llamada que el modelo pidió y que nunca llegó a
+        // ejecutarse: argumentos que no validaron, o una herramienta inexistente.
+        for (const [id, nombre] of this.anunciadas) {
+            void this.libro().anotar({
+                tipo: "tool",
+                nombre,
+                ok: false,
+                decision: "no-ejecutada",
+                // El motivo no se inventa: desde aquí no se ve la causa exacta, y
+                // escribir una supuesta sería peor que nombrar lo que sí se sabe.
+                motivo: "el modelo la pidió y no llegó a ejecutarse (argumentos inválidos o herramienta inexistente)",
+            });
+            this.anunciadas.delete(id);
+        }
+        if (!asistente.usage)
+            return;
+        // Y se apuntan las de ESTE mensaje, para poder reconciliarlas en el
+        // siguiente.
+        for (const bloque of asistente.content) {
+            if (bloque.type === "toolCall")
+                this.anunciadas.set(bloque.id, bloque.name);
+        }
+        void this.libro().anotar({
+            tipo: "modelo",
+            proveedor: asistente.provider,
+            // `responseModel` es el modelo CONCRETO cuando lo pedido era un alias
+            // (el `auto` de OpenRouter, por ejemplo). Para un registro de
+            // cumplimiento importa el que respondió, no el que se pidió.
+            modelo: asistente.responseModel ?? asistente.model,
+            entrada: asistente.usage.input,
+            salida: asistente.usage.output,
+            coste: asistente.usage.cost?.total,
+            motivoParada: asistente.stopReason,
+        });
+    }
+}
+//# sourceMappingURL=registro-sesion.js.map

package/dist/core/audit/registro-sesion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registro-sesion.js","sourceRoot":"","sources":["../../../src/core/audit/registro-sesion.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Todo lo que Ada añade alrededor de una llamada a herramienta, en una pieza.\n *\n * Reúne tres cosas que empezaron sueltas dentro de `agent-session.ts` —el libro\n * de sesión, la política de aprobación y el observador de ediciones— porque las\n * tres cuelgan de los mismos dos ganchos y comparten el ciclo de vida de la\n * llamada.\n *\n * El motivo de agruparlas no es estético. `agent-session.ts` es de upstream y\n * cada región nuestra que vive ahí es un hunk que se reaplica en cada\n * sincronización y se rompe cuando upstream refactoriza. Tres campos y un\n * método sueltos partían el hunk de declaraciones en dos y se pasaban del\n * presupuesto; un campo y dos llamadas, no. La regla está escrita en\n * `core/ada.ts`: si vas a tocar `agent-session.ts`, mira antes si lo tuyo cabe\n * en un módulo propio.\n */\n\nimport type { AssistantMessage } from \"@earendil-works/pi-ai\";\nimport { type Decision, decidir, leerDenegadas } from \"../aprobacion/politica.ts\";\nimport { ObservadorDeEdiciones } from \"../edicion/observador.ts\";\nimport { publicarLibroDeSesion } from \"../extensiones/vigilancia.ts\";\nimport { nivelDesdeConfig } from \"../hooks/session-hooks.ts\";\nimport { LibroDeSesion } from \"./libro.ts\";\n\n/** El trozo de configuración del motor que le hace falta a esto. */\ninterface ConfigConPermisos {\n\tpermissions?: Record<string, unknown>;\n\tgoalEngine?: { planOnly?: boolean };\n}\n\nexport class RegistroDeSesion {\n\tprivate readonly agentDir: () => string;\n\tprivate readonly sesionId: () => string;\n\tprivate readonly observador: ObservadorDeEdiciones;\n\t/** Decisión de cada llamada, de `beforeToolCall` a `afterToolCall`. */\n\tprivate readonly decisiones = new Map<string, Decision>();\n\t/**\n\t * Llamadas que el modelo ANUNCIÓ y de las que el libro aún no sabe nada.\n\t *\n\t * Existe porque había un hueco medido: `validateToolArguments` corre ANTES\n\t * que `beforeToolCall`, así que una llamada rechazada por sus argumentos\n\t * —el error más común de los modelos pequeños— no llegaba a ninguno de\n\t * nuestros dos enganches y desaparecía del libro. Ocurrió de verdad en una\n\t * comparación contra un modelo gratuito: el transcript tenía dos `edit` y el\n\t * libro solo una. Un registro que se vende como «qué hizo el agente» no puede\n\t * callarse lo que el agente intentó hacer.\n\t */\n\tprivate readonly anunciadas = new Map<string, string>();\n\tprivate _libro?: LibroDeSesion;\n\n\t// Los tres primeros son funciones y no valores: este objeto se construye en\n\t// un inicializador de campo de `AgentSession`, que corre ANTES del cuerpo\n\t// del constructor. `this.sessionId` es un getter sobre estado que todavía\n\t// no existe ahí, y leerlo en ese momento reventaba la sesión entera —76\n\t// ficheros de prueba en rojo— sin que los tipos dijeran nada.\n\t//\n\t// `completar` es opcional: sin modelo (sesiones de prueba, subagentes sin\n\t// auth) la auto-reparación de ediciones rotas queda \"no-aplicable\" en vez\n\t// de intentarlo con `undefined` y reventar.\n\tconstructor(\n\t\tagentDir: () => string,\n\t\tsesionId: () => string,\n\t\tcwd: () => string,\n\t\tcompletar?: (prompt: string) => Promise<string | null>,\n\t) {\n\t\tthis.agentDir = agentDir;\n\t\tthis.sesionId = sesionId;\n\t\tthis.observador = new ObservadorDeEdiciones(cwd, agentDir, completar);\n\t\t// `pi.exec` de una extensión escribe en el MISMO libro que las llamadas\n\t\t// del agente. Sin esto, la extensión abriría su propio fichero de sesión\n\t\t// y quien auditara el de la conversación no vería nada — que es el mismo\n\t\t// agujero de antes con un rastro más difícil de encontrar.\n\t\t//\n\t\t// Se publica un getter para no forzar la creación del libro aquí: sigue\n\t\t// siendo perezoso, y una sesión que no hace nada no deja directorio.\n\t\tpublicarLibroDeSesion(() => this.libro());\n\t}\n\n\t/**\n\t * El libro, creado en la primera anotación.\n\t *\n\t * Perezoso a propósito: abrirlo al construir la sesión crearía el directorio\n\t * incluso para sesiones que no llegan a hacer nada, y entonces \"no hay\n\t * registro\" y \"no hizo nada\" dejarían de distinguirse.\n\t */\n\tlibro(): LibroDeSesion {\n\t\tthis._libro ??= new LibroDeSesion(this.agentDir(), this.sesionId());\n\t\treturn this._libro;\n\t}\n\n\t/**\n\t * Antes de ejecutar: decide si se permite y guarda la preimagen del fichero.\n\t *\n\t * Devuelve la decisión. Quien llama corta si es `denegada`; la denegación ya\n\t * queda anotada aquí.\n\t */\n\tasync antesDeLlamada(\n\t\tidLlamada: string,\n\t\ttool: string,\n\t\targs: Record<string, unknown>,\n\t\tconfig: ConfigConPermisos,\n\t): Promise<Decision> {\n\t\tconst decision = decidir({\n\t\t\ttool,\n\t\t\targs,\n\t\t\tmodo: nivelDesdeConfig(config),\n\t\t\tagentDir: this.agentDir(),\n\t\t\tdenegadas: leerDenegadas(config),\n\t\t});\n\n\t\tif (decision.veredicto === \"denegada\") {\n\t\t\tvoid this.libro().anotar({\n\t\t\t\ttipo: \"tool\",\n\t\t\t\tnombre: tool,\n\t\t\t\tok: false,\n\t\t\t\tdecision: \"denegada\",\n\t\t\t\tmotivo: decision.politica,\n\t\t\t});\n\t\t\t// Una llamada bloqueada no llega a `trasLlamada`, así que no se guarda\n\t\t\t// nada que luego nadie recogería. Y ya está anotada arriba: se saca de\n\t\t\t// las pendientes para que la reconciliación no la cuente dos veces.\n\t\t\tthis.anunciadas.delete(idLlamada);\n\t\t\treturn decision;\n\t\t}\n\n\t\t// Tope por si alguna llamada muere antes de consumirse.\n\t\tif (this.decisiones.size > 256) this.decisiones.clear();\n\t\tthis.decisiones.set(idLlamada, decision);\n\t\tawait this.observador.antesDe(idLlamada, tool, args);\n\t\treturn decision;\n\t}\n\n\t/**\n\t * Después de ejecutar: anota lo ocurrido y devuelve el aviso de edición rota,\n\t * o `null` si no hay nada que decir — que es el caso de casi todas.\n\t */\n\tasync trasLlamada(\n\t\tidLlamada: string,\n\t\ttool: string,\n\t\targs: Record<string, unknown>,\n\t\thuboError: boolean,\n\t): Promise<string | null> {\n\t\tconst aprobacion = this.decisiones.get(idLlamada);\n\t\tthis.decisiones.delete(idLlamada);\n\t\tthis.anunciadas.delete(idLlamada);\n\n\t\tconst comando = (args as { command?: unknown } | undefined)?.command;\n\t\tvoid this.libro().anotar(\n\t\t\ttool === \"bash\" && typeof comando === \"string\"\n\t\t\t\t? { tipo: \"comando\", argv: [comando], codigo: huboError ? 1 : 0, origen: \"agente\" }\n\t\t\t\t: {\n\t\t\t\t\t\ttipo: \"tool\",\n\t\t\t\t\t\tnombre: tool,\n\t\t\t\t\t\tok: !huboError,\n\t\t\t\t\t\t// Qué regla la dejó pasar. Sin esto el libro dice que algo\n\t\t\t\t\t\t// ocurrió pero no por qué se permitió, que es justo la mitad\n\t\t\t\t\t\t// que pregunta una auditoría.\n\t\t\t\t\t\tdecision: aprobacion?.veredicto,\n\t\t\t\t\t\tmotivo: aprobacion?.politica,\n\t\t\t\t\t},\n\t\t);\n\n\t\tconst aviso = await this.observador.despuesDe(idLlamada, huboError);\n\n\t\t// El suceso `fichero` del libro: art. 30 RGPD, qué ficheros se trataron.\n\t\t//\n\t\t// El tipo existía en `libro.ts` desde el primer día y NADIE lo anotaba: el\n\t\t// comentario de `agent-session.ts` decía \"los hashes de fichero llegan con\n\t\t// el observador de ediciones\", en futuro, y nunca llegaron. La auditoría\n\t\t// enterprise lo encontró preguntando lo que pregunta un DPO. Es el defecto\n\t\t// número uno de esta casa: capacidad construida y desenchufada, con el tipo\n\t\t// compilando y las pruebas en verde porque las pruebas anotaban a mano.\n\t\t//\n\t\t// Se toma del observador, que ya leyó las dos versiones, en vez de releer el\n\t\t// fichero aquí. El libro hashea `antes` y `despues` al escribir, así que el\n\t\t// contenido pasa por aquí pero no llega a disco.\n\t\tconst cambio = this.observador.ultimoCambio(idLlamada);\n\t\tif (cambio) {\n\t\t\tvoid this.libro().anotar({\n\t\t\t\ttipo: \"fichero\",\n\t\t\t\truta: cambio.ruta,\n\t\t\t\tantes: cambio.antes,\n\t\t\t\tdespues: cambio.despues,\n\t\t\t\ttool,\n\t\t\t});\n\t\t}\n\n\t\treturn aviso;\n\t}\n\n\t/**\n\t * Una llamada al modelo.\n\t *\n\t * Se anota por llamada y no por turno porque un turno puede gastar varias, y\n\t * \"qué modelo se usó y cuánto costó\" hay que poder responderlo con ese grano.\n\t * Las que fallan también: `motivoParada: \"error\"` es justo lo que hay que\n\t * poder enseñar.\n\t */\n\tanotarModelo(asistente: AssistantMessage): void {\n\t\t// RECONCILIAR PRIMERO. Para cuando llega este mensaje, las herramientas del\n\t\t// anterior ya se ejecutaron —el bucle las espera—, así que todo lo que siga\n\t\t// pendiente es una llamada que el modelo pidió y que nunca llegó a\n\t\t// ejecutarse: argumentos que no validaron, o una herramienta inexistente.\n\t\tfor (const [id, nombre] of this.anunciadas) {\n\t\t\tvoid this.libro().anotar({\n\t\t\t\ttipo: \"tool\",\n\t\t\t\tnombre,\n\t\t\t\tok: false,\n\t\t\t\tdecision: \"no-ejecutada\",\n\t\t\t\t// El motivo no se inventa: desde aquí no se ve la causa exacta, y\n\t\t\t\t// escribir una supuesta sería peor que nombrar lo que sí se sabe.\n\t\t\t\tmotivo: \"el modelo la pidió y no llegó a ejecutarse (argumentos inválidos o herramienta inexistente)\",\n\t\t\t});\n\t\t\tthis.anunciadas.delete(id);\n\t\t}\n\n\t\tif (!asistente.usage) return;\n\n\t\t// Y se apuntan las de ESTE mensaje, para poder reconciliarlas en el\n\t\t// siguiente.\n\t\tfor (const bloque of asistente.content) {\n\t\t\tif (bloque.type === \"toolCall\") this.anunciadas.set(bloque.id, bloque.name);\n\t\t}\n\t\tvoid this.libro().anotar({\n\t\t\ttipo: \"modelo\",\n\t\t\tproveedor: asistente.provider,\n\t\t\t// `responseModel` es el modelo CONCRETO cuando lo pedido era un alias\n\t\t\t// (el `auto` de OpenRouter, por ejemplo). Para un registro de\n\t\t\t// cumplimiento importa el que respondió, no el que se pidió.\n\t\t\tmodelo: asistente.responseModel ?? asistente.model,\n\t\t\tentrada: asistente.usage.input,\n\t\t\tsalida: asistente.usage.output,\n\t\t\tcoste: asistente.usage.cost?.total,\n\t\t\tmotivoParada: asistente.stopReason,\n\t\t});\n\t}\n}\n"]}

package/dist/core/audit/retencion.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Purgar el libro sin que la purga parezca una manipulación.
+ *
+ * EL CALLEJÓN SIN SALIDA, medido antes de escribir nada. El artículo 5.1.e del
+ * RGPD obliga a no conservar los datos más de lo necesario, así que un DPO
+ * TIENE que poder borrar lo viejo. Pero hoy:
+ *
+ *   · Si borra los ficheros de `sesion/`, el ancla del índice los sigue
+ *     esperando y `verificar` contesta
+ *     «FALTAN 1 fichero(s) con 3 entrada(s): alguien los ha borrado». Cumplir
+ *     la ley nos acusa de manipular.
+ *   · Si borra también el índice, el libro queda «íntegro» con menos entradas y
+ *     la purga desaparece sin rastro. Es indistinguible de un borrado hostil.
+ *
+ * Las dos salidas son malas, y el subcomando ni siquiera existe: `audit purge`,
+ * `audit purgar`, `audit retencion` → «Subcomando desconocido». El único camino
+ * era `rm`.
+ *
+ * LA IDEA: una purga no es una ausencia, es un HECHO. Y un hecho se anota.
+ *
+ * En vez de borrar y callar, se escribe una LÁPIDA en el libro —encadenada como
+ * cualquier otra entrada— que dice qué periodo se purgó, cuántas entradas
+ * había, bajo qué política, y el hash de cierre del tramo que se va. Con eso:
+ *
+ *   · `verificar` distingue «esto se purgó el día D bajo la política P» de
+ *     «esto ha desaparecido», que es la diferencia entre cumplir y encubrir.
+ *   · El artículo 5.2 —responsabilidad proactiva: hay que poder DEMOSTRAR que
+ *     se cumple— queda cubierto por el propio mecanismo.
+ *   · Y quien reciba el libro años después puede reconstruir qué pasó con lo
+ *     que ya no está.
+ *
+ * LO QUE LA LÁPIDA NO ES. No es una prueba de que lo purgado fuera lo que dice
+ * la lápida: quien controla el disco puede escribir la lápida que quiera. Es
+ * una prueba de INTENCIÓN DECLARADA, y sirve para lo que sirve — que un borrado
+ * legítimo no se confunda con uno hostil, y que uno hostil tenga que mentir por
+ * escrito en vez de limitarse a borrar. Contra un adversario con acceso al
+ * disco no hay defensa local; para eso hace falta un ancla externa.
+ */
+import type { EntradaDelLibro, LibroDeSesion } from "./libro.ts";
+/** Lo que la lápida deja escrito. Todo es dato de forma, nunca contenido. */
+export interface Lapida {
+    /** Qué fichero de sesión se fue. */
+    fichero: string;
+    /** Cuántas entradas tenía, para que el hueco sea contable. */
+    entradas: number;
+    /** El sello de tiempo de la primera y la última, que delimitan el periodo. */
+    desde: string;
+    hasta: string;
+    /** Hash del último eslabón del tramo purgado: ancla de lo que se fue. */
+    hashDeCierre: string;
+    /** Bajo qué regla. Un texto libre que el DPO reconozca en su documentación. */
+    politica: string;
+}
+export interface ResultadoDePurga {
+    purgados: Lapida[];
+    /** Los que se miraron y NO se purgaron, con su motivo. */
+    conservados: Array<{
+        fichero: string;
+        porque: string;
+    }>;
+}
+/**
+ * Purga los ficheros de sesión anteriores a `antesDe`, dejando una lápida.
+ *
+ * `antesDe` se compara contra el sello de la ÚLTIMA entrada del fichero: una
+ * sesión que empezó en enero y terminó en marzo se conserva si el corte está en
+ * febrero. Purgar por la fecha de inicio borraría actividad posterior al corte,
+ * que es justo lo que no se puede hacer.
+ *
+ * No purga el fichero de la sesión EN CURSO aunque cumpla la fecha: quitarle el
+ * suelo a un libro que se está escribiendo rompería su cadena en memoria.
+ */
+export declare function purgarAntesDe(libro: LibroDeSesion, agentDir: string, antesDe: Date, politica: string, 
+/** Con `true` se decide igual pero no se escribe ni se borra nada. */
+simular?: boolean): Promise<ResultadoDePurga>;
+/**
+ * Los ficheros que una lápida declara purgados, leídos del propio libro.
+ *
+ * `verificar` lo usa para distinguir un hueco explicado de uno que no lo está.
+ */
+export declare function ficherosPurgados(entradas: readonly EntradaDelLibro[]): Map<string, Lapida>;
+//# sourceMappingURL=retencion.d.ts.map

package/dist/core/audit/retencion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retencion.d.ts","sourceRoot":"","sources":["../../../src/core/audit/retencion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGjE,8EAA6E;AAC7E,MAAM,WAAW,MAAM;IACtB,sCAAoC;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,gEAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,+EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,2EAAyE;IACzE,YAAY,EAAE,MAAM,CAAC;IACrB,iFAA+E;IAC/E,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAChC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,0DAA0D;IAC1D,WAAW,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACxD;AAcD;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CAClC,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,IAAI,EACb,QAAQ,EAAE,MAAM;AAChB,sEAAsE;AACtE,OAAO,UAAQ,GACb,OAAO,CAAC,gBAAgB,CAAC,CAiE3B;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAe1F","sourcesContent":["/**\n * Purgar el libro sin que la purga parezca una manipulación.\n *\n * EL CALLEJÓN SIN SALIDA, medido antes de escribir nada. El artículo 5.1.e del\n * RGPD obliga a no conservar los datos más de lo necesario, así que un DPO\n * TIENE que poder borrar lo viejo. Pero hoy:\n *\n *   · Si borra los ficheros de `sesion/`, el ancla del índice los sigue\n *     esperando y `verificar` contesta\n *     «FALTAN 1 fichero(s) con 3 entrada(s): alguien los ha borrado». Cumplir\n *     la ley nos acusa de manipular.\n *   · Si borra también el índice, el libro queda «íntegro» con menos entradas y\n *     la purga desaparece sin rastro. Es indistinguible de un borrado hostil.\n *\n * Las dos salidas son malas, y el subcomando ni siquiera existe: `audit purge`,\n * `audit purgar`, `audit retencion` → «Subcomando desconocido». El único camino\n * era `rm`.\n *\n * LA IDEA: una purga no es una ausencia, es un HECHO. Y un hecho se anota.\n *\n * En vez de borrar y callar, se escribe una LÁPIDA en el libro —encadenada como\n * cualquier otra entrada— que dice qué periodo se purgó, cuántas entradas\n * había, bajo qué política, y el hash de cierre del tramo que se va. Con eso:\n *\n *   · `verificar` distingue «esto se purgó el día D bajo la política P» de\n *     «esto ha desaparecido», que es la diferencia entre cumplir y encubrir.\n *   · El artículo 5.2 —responsabilidad proactiva: hay que poder DEMOSTRAR que\n *     se cumple— queda cubierto por el propio mecanismo.\n *   · Y quien reciba el libro años después puede reconstruir qué pasó con lo\n *     que ya no está.\n *\n * LO QUE LA LÁPIDA NO ES. No es una prueba de que lo purgado fuera lo que dice\n * la lápida: quien controla el disco puede escribir la lápida que quiera. Es\n * una prueba de INTENCIÓN DECLARADA, y sirve para lo que sirve — que un borrado\n * legítimo no se confunda con uno hostil, y que uno hostil tenga que mentir por\n * escrito en vez de limitarse a borrar. Contra un adversario con acceso al\n * disco no hay defensa local; para eso hace falta un ancla externa.\n */\n\nimport { readFileSync, rmSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport type { EntradaDelLibro, LibroDeSesion } from \"./libro.ts\";\nimport { DIR_INDICE, DIR_SESION } from \"./rutas.ts\";\n\n/** Lo que la lápida deja escrito. Todo es dato de forma, nunca contenido. */\nexport interface Lapida {\n\t/** Qué fichero de sesión se fue. */\n\tfichero: string;\n\t/** Cuántas entradas tenía, para que el hueco sea contable. */\n\tentradas: number;\n\t/** El sello de tiempo de la primera y la última, que delimitan el periodo. */\n\tdesde: string;\n\thasta: string;\n\t/** Hash del último eslabón del tramo purgado: ancla de lo que se fue. */\n\thashDeCierre: string;\n\t/** Bajo qué regla. Un texto libre que el DPO reconozca en su documentación. */\n\tpolitica: string;\n}\n\nexport interface ResultadoDePurga {\n\tpurgados: Lapida[];\n\t/** Los que se miraron y NO se purgaron, con su motivo. */\n\tconservados: Array<{ fichero: string; porque: string }>;\n}\n\n/** Un fichero del libro leído, o `null` si no se pudo. */\nfunction leerEntradas(ruta: string): EntradaDelLibro[] | null {\n\ttry {\n\t\treturn readFileSync(ruta, \"utf-8\")\n\t\t\t.split(\"\\n\")\n\t\t\t.filter(Boolean)\n\t\t\t.map((l) => JSON.parse(l) as EntradaDelLibro);\n\t} catch {\n\t\treturn null;\n\t}\n}\n\n/**\n * Purga los ficheros de sesión anteriores a `antesDe`, dejando una lápida.\n *\n * `antesDe` se compara contra el sello de la ÚLTIMA entrada del fichero: una\n * sesión que empezó en enero y terminó en marzo se conserva si el corte está en\n * febrero. Purgar por la fecha de inicio borraría actividad posterior al corte,\n * que es justo lo que no se puede hacer.\n *\n * No purga el fichero de la sesión EN CURSO aunque cumpla la fecha: quitarle el\n * suelo a un libro que se está escribiendo rompería su cadena en memoria.\n */\nexport async function purgarAntesDe(\n\tlibro: LibroDeSesion,\n\tagentDir: string,\n\tantesDe: Date,\n\tpolitica: string,\n\t/** Con `true` se decide igual pero no se escribe ni se borra nada. */\n\tsimular = false,\n): Promise<ResultadoDePurga> {\n\tconst purgados: Lapida[] = [];\n\tconst conservados: Array<{ fichero: string; porque: string }> = [];\n\n\tconst { readdirSync } = await import(\"node:fs\");\n\tlet nombres: string[];\n\ttry {\n\t\tnombres = readdirSync(join(agentDir, DIR_SESION)).filter((f) => f.endsWith(\".jsonl\"));\n\t} catch {\n\t\treturn { purgados, conservados };\n\t}\n\n\tfor (const nombre of nombres) {\n\t\t// Se pregunta DENTRO del bucle: la primera lápida es la que da nombre al\n\t\t// fichero de esta sesión, así que antes de escribirla el libro todavía no\n\t\t// tiene ninguno —y si no tiene, tampoco está en `nombres`—.\n\t\tif (nombre === libro.ficheroEnCurso) {\n\t\t\tconservados.push({ fichero: nombre, porque: \"es la sesión en curso\" });\n\t\t\tcontinue;\n\t\t}\n\t\tconst ruta = join(agentDir, DIR_SESION, nombre);\n\t\tconst entradas = leerEntradas(ruta);\n\t\t// No se borra lo que no se ha podido leer: sin saber qué había, la lápida\n\t\t// sería una declaración inventada, que es peor que no purgar.\n\t\tif (!entradas || entradas.length === 0) {\n\t\t\tconservados.push({\n\t\t\t\tfichero: nombre,\n\t\t\t\tporque: \"no se ha podido leer, y no se purga lo que no se puede describir\",\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\t\tconst ultima = entradas[entradas.length - 1];\n\t\tif (new Date(ultima.ts) >= antesDe) {\n\t\t\tconservados.push({\n\t\t\t\tfichero: nombre,\n\t\t\t\tporque: `su última entrada (${ultima.ts.slice(0, 10)}) es posterior al corte`,\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst lapida: Lapida = {\n\t\t\tfichero: nombre,\n\t\t\tentradas: entradas.length,\n\t\t\tdesde: entradas[0].ts,\n\t\t\thasta: ultima.ts,\n\t\t\thashDeCierre: ultima.hash,\n\t\t\tpolitica,\n\t\t};\n\t\t// La lápida PRIMERO, el borrado después. Si el proceso muere en medio, el\n\t\t// libro tiene una lápida de más y el fichero todavía ahí — un estado\n\t\t// incómodo pero legible. Al revés quedaría un hueco sin explicación, que\n\t\t// es exactamente lo que este módulo existe para no producir.\n\t\t//\n\t\t// Con `simular` se decide EXACTAMENTE igual y no se toca nada: lo que se\n\t\t// enseña antes de un borrado irreversible tiene que salir del mismo camino\n\t\t// que lo ejecuta, o es una promesa sobre otro código.\n\t\tif (!simular) {\n\t\t\tawait libro.anotar({ tipo: \"purga\", ...lapida } as never);\n\t\t\trmSync(ruta, { force: true });\n\t\t\trmSync(join(agentDir, DIR_INDICE, nombre), { force: true });\n\t\t}\n\t\tpurgados.push(lapida);\n\t}\n\n\treturn { purgados, conservados };\n}\n\n/**\n * Los ficheros que una lápida declara purgados, leídos del propio libro.\n *\n * `verificar` lo usa para distinguir un hueco explicado de uno que no lo está.\n */\nexport function ficherosPurgados(entradas: readonly EntradaDelLibro[]): Map<string, Lapida> {\n\tconst mapa = new Map<string, Lapida>();\n\tfor (const e of entradas) {\n\t\tconst s = e.suceso as Record<string, unknown>;\n\t\tif (s.tipo !== \"purga\" || typeof s.fichero !== \"string\") continue;\n\t\tmapa.set(s.fichero, {\n\t\t\tfichero: s.fichero,\n\t\t\tentradas: Number(s.entradas ?? 0),\n\t\t\tdesde: String(s.desde ?? \"\"),\n\t\t\thasta: String(s.hasta ?? \"\"),\n\t\t\thashDeCierre: String(s.hashDeCierre ?? \"\"),\n\t\t\tpolitica: String(s.politica ?? \"\"),\n\t\t});\n\t}\n\treturn mapa;\n}\n"]}

package/dist/core/audit/retencion.js

@@ -0,0 +1,152 @@
+/**
+ * Purgar el libro sin que la purga parezca una manipulación.
+ *
+ * EL CALLEJÓN SIN SALIDA, medido antes de escribir nada. El artículo 5.1.e del
+ * RGPD obliga a no conservar los datos más de lo necesario, así que un DPO
+ * TIENE que poder borrar lo viejo. Pero hoy:
+ *
+ *   · Si borra los ficheros de `sesion/`, el ancla del índice los sigue
+ *     esperando y `verificar` contesta
+ *     «FALTAN 1 fichero(s) con 3 entrada(s): alguien los ha borrado». Cumplir
+ *     la ley nos acusa de manipular.
+ *   · Si borra también el índice, el libro queda «íntegro» con menos entradas y
+ *     la purga desaparece sin rastro. Es indistinguible de un borrado hostil.
+ *
+ * Las dos salidas son malas, y el subcomando ni siquiera existe: `audit purge`,
+ * `audit purgar`, `audit retencion` → «Subcomando desconocido». El único camino
+ * era `rm`.
+ *
+ * LA IDEA: una purga no es una ausencia, es un HECHO. Y un hecho se anota.
+ *
+ * En vez de borrar y callar, se escribe una LÁPIDA en el libro —encadenada como
+ * cualquier otra entrada— que dice qué periodo se purgó, cuántas entradas
+ * había, bajo qué política, y el hash de cierre del tramo que se va. Con eso:
+ *
+ *   · `verificar` distingue «esto se purgó el día D bajo la política P» de
+ *     «esto ha desaparecido», que es la diferencia entre cumplir y encubrir.
+ *   · El artículo 5.2 —responsabilidad proactiva: hay que poder DEMOSTRAR que
+ *     se cumple— queda cubierto por el propio mecanismo.
+ *   · Y quien reciba el libro años después puede reconstruir qué pasó con lo
+ *     que ya no está.
+ *
+ * LO QUE LA LÁPIDA NO ES. No es una prueba de que lo purgado fuera lo que dice
+ * la lápida: quien controla el disco puede escribir la lápida que quiera. Es
+ * una prueba de INTENCIÓN DECLARADA, y sirve para lo que sirve — que un borrado
+ * legítimo no se confunda con uno hostil, y que uno hostil tenga que mentir por
+ * escrito en vez de limitarse a borrar. Contra un adversario con acceso al
+ * disco no hay defensa local; para eso hace falta un ancla externa.
+ */
+import { readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { DIR_INDICE, DIR_SESION } from "./rutas.js";
+/** Un fichero del libro leído, o `null` si no se pudo. */
+function leerEntradas(ruta) {
+    try {
+        return readFileSync(ruta, "utf-8")
+            .split("\n")
+            .filter(Boolean)
+            .map((l) => JSON.parse(l));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Purga los ficheros de sesión anteriores a `antesDe`, dejando una lápida.
+ *
+ * `antesDe` se compara contra el sello de la ÚLTIMA entrada del fichero: una
+ * sesión que empezó en enero y terminó en marzo se conserva si el corte está en
+ * febrero. Purgar por la fecha de inicio borraría actividad posterior al corte,
+ * que es justo lo que no se puede hacer.
+ *
+ * No purga el fichero de la sesión EN CURSO aunque cumpla la fecha: quitarle el
+ * suelo a un libro que se está escribiendo rompería su cadena en memoria.
+ */
+export async function purgarAntesDe(libro, agentDir, antesDe, politica, 
+/** Con `true` se decide igual pero no se escribe ni se borra nada. */
+simular = false) {
+    const purgados = [];
+    const conservados = [];
+    const { readdirSync } = await import("node:fs");
+    let nombres;
+    try {
+        nombres = readdirSync(join(agentDir, DIR_SESION)).filter((f) => f.endsWith(".jsonl"));
+    }
+    catch {
+        return { purgados, conservados };
+    }
+    for (const nombre of nombres) {
+        // Se pregunta DENTRO del bucle: la primera lápida es la que da nombre al
+        // fichero de esta sesión, así que antes de escribirla el libro todavía no
+        // tiene ninguno —y si no tiene, tampoco está en `nombres`—.
+        if (nombre === libro.ficheroEnCurso) {
+            conservados.push({ fichero: nombre, porque: "es la sesión en curso" });
+            continue;
+        }
+        const ruta = join(agentDir, DIR_SESION, nombre);
+        const entradas = leerEntradas(ruta);
+        // No se borra lo que no se ha podido leer: sin saber qué había, la lápida
+        // sería una declaración inventada, que es peor que no purgar.
+        if (!entradas || entradas.length === 0) {
+            conservados.push({
+                fichero: nombre,
+                porque: "no se ha podido leer, y no se purga lo que no se puede describir",
+            });
+            continue;
+        }
+        const ultima = entradas[entradas.length - 1];
+        if (new Date(ultima.ts) >= antesDe) {
+            conservados.push({
+                fichero: nombre,
+                porque: `su última entrada (${ultima.ts.slice(0, 10)}) es posterior al corte`,
+            });
+            continue;
+        }
+        const lapida = {
+            fichero: nombre,
+            entradas: entradas.length,
+            desde: entradas[0].ts,
+            hasta: ultima.ts,
+            hashDeCierre: ultima.hash,
+            politica,
+        };
+        // La lápida PRIMERO, el borrado después. Si el proceso muere en medio, el
+        // libro tiene una lápida de más y el fichero todavía ahí — un estado
+        // incómodo pero legible. Al revés quedaría un hueco sin explicación, que
+        // es exactamente lo que este módulo existe para no producir.
+        //
+        // Con `simular` se decide EXACTAMENTE igual y no se toca nada: lo que se
+        // enseña antes de un borrado irreversible tiene que salir del mismo camino
+        // que lo ejecuta, o es una promesa sobre otro código.
+        if (!simular) {
+            await libro.anotar({ tipo: "purga", ...lapida });
+            rmSync(ruta, { force: true });
+            rmSync(join(agentDir, DIR_INDICE, nombre), { force: true });
+        }
+        purgados.push(lapida);
+    }
+    return { purgados, conservados };
+}
+/**
+ * Los ficheros que una lápida declara purgados, leídos del propio libro.
+ *
+ * `verificar` lo usa para distinguir un hueco explicado de uno que no lo está.
+ */
+export function ficherosPurgados(entradas) {
+    const mapa = new Map();
+    for (const e of entradas) {
+        const s = e.suceso;
+        if (s.tipo !== "purga" || typeof s.fichero !== "string")
+            continue;
+        mapa.set(s.fichero, {
+            fichero: s.fichero,
+            entradas: Number(s.entradas ?? 0),
+            desde: String(s.desde ?? ""),
+            hasta: String(s.hasta ?? ""),
+            hashDeCierre: String(s.hashDeCierre ?? ""),
+            politica: String(s.politica ?? ""),
+        });
+    }
+    return mapa;
+}
+//# sourceMappingURL=retencion.js.map

package/dist/core/audit/retencion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retencion.js","sourceRoot":"","sources":["../../../src/core/audit/retencion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAuBpD,2DAA0D;AAC1D,SAAS,YAAY,CAAC,IAAY,EAA4B;IAC7D,IAAI,CAAC;QACJ,OAAO,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC;aAChC,KAAK,CAAC,IAAI,CAAC;aACX,MAAM,CAAC,OAAO,CAAC;aACf,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAoB,CAAC,CAAC;IAChD,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,IAAI,CAAC;IACb,CAAC;AAAA,CACD;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAClC,KAAoB,EACpB,QAAgB,EAChB,OAAa,EACb,QAAgB;AAChB,sEAAsE;AACtE,OAAO,GAAG,KAAK,EACa;IAC5B,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,MAAM,WAAW,GAA+C,EAAE,CAAC;IAEnE,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,CAAC;IAChD,IAAI,OAAiB,CAAC;IACtB,IAAI,CAAC;QACJ,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;IACvF,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;IAClC,CAAC;IAED,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC9B,0EAAyE;QACzE,6EAA0E;QAC1E,iEAA4D;QAC5D,IAAI,MAAM,KAAK,KAAK,CAAC,cAAc,EAAE,CAAC;YACrC,WAAW,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,wBAAuB,EAAE,CAAC,CAAC;YACvE,SAAS;QACV,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;QAChD,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;QACpC,6EAA0E;QAC1E,gEAA8D;QAC9D,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxC,WAAW,CAAC,IAAI,CAAC;gBAChB,OAAO,EAAE,MAAM;gBACf,MAAM,EAAE,kEAAkE;aAC1E,CAAC,CAAC;YACH,SAAS;QACV,CAAC;QACD,MAAM,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC7C,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,OAAO,EAAE,CAAC;YACpC,WAAW,CAAC,IAAI,CAAC;gBAChB,OAAO,EAAE,MAAM;gBACf,MAAM,EAAE,uBAAsB,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,yBAAyB;aAC7E,CAAC,CAAC;YACH,SAAS;QACV,CAAC;QAED,MAAM,MAAM,GAAW;YACtB,OAAO,EAAE,MAAM;YACf,QAAQ,EAAE,QAAQ,CAAC,MAAM;YACzB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE;YACrB,KAAK,EAAE,MAAM,CAAC,EAAE;YAChB,YAAY,EAAE,MAAM,CAAC,IAAI;YACzB,QAAQ;SACR,CAAC;QACF,4EAA0E;QAC1E,2EAAqE;QACrE,6EAAyE;QACzE,8DAA6D;QAC7D,EAAE;QACF,yEAAyE;QACzE,4EAA2E;QAC3E,uDAAsD;QACtD,IAAI,CAAC,OAAO,EAAE,CAAC;YACd,MAAM,KAAK,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,EAAW,CAAC,CAAC;YAC1D,MAAM,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;YAC9B,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAC7D,CAAC;QACD,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACvB,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;AAAA,CACjC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAoC,EAAuB;IAC3F,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;IACvC,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QAC1B,MAAM,CAAC,GAAG,CAAC,CAAC,MAAiC,CAAC;QAC9C,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ;YAAE,SAAS;QAClE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,EAAE;YACnB,OAAO,EAAE,CAAC,CAAC,OAAO;YAClB,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC;YACjC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YAC5B,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YAC5B,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,YAAY,IAAI,EAAE,CAAC;YAC1C,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,IAAI,EAAE,CAAC;SAClC,CAAC,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AAAA,CACZ","sourcesContent":["/**\n * Purgar el libro sin que la purga parezca una manipulación.\n *\n * EL CALLEJÓN SIN SALIDA, medido antes de escribir nada. El artículo 5.1.e del\n * RGPD obliga a no conservar los datos más de lo necesario, así que un DPO\n * TIENE que poder borrar lo viejo. Pero hoy:\n *\n *   · Si borra los ficheros de `sesion/`, el ancla del índice los sigue\n *     esperando y `verificar` contesta\n *     «FALTAN 1 fichero(s) con 3 entrada(s): alguien los ha borrado». Cumplir\n *     la ley nos acusa de manipular.\n *   · Si borra también el índice, el libro queda «íntegro» con menos entradas y\n *     la purga desaparece sin rastro. Es indistinguible de un borrado hostil.\n *\n * Las dos salidas son malas, y el subcomando ni siquiera existe: `audit purge`,\n * `audit purgar`, `audit retencion` → «Subcomando desconocido». El único camino\n * era `rm`.\n *\n * LA IDEA: una purga no es una ausencia, es un HECHO. Y un hecho se anota.\n *\n * En vez de borrar y callar, se escribe una LÁPIDA en el libro —encadenada como\n * cualquier otra entrada— que dice qué periodo se purgó, cuántas entradas\n * había, bajo qué política, y el hash de cierre del tramo que se va. Con eso:\n *\n *   · `verificar` distingue «esto se purgó el día D bajo la política P» de\n *     «esto ha desaparecido», que es la diferencia entre cumplir y encubrir.\n *   · El artículo 5.2 —responsabilidad proactiva: hay que poder DEMOSTRAR que\n *     se cumple— queda cubierto por el propio mecanismo.\n *   · Y quien reciba el libro años después puede reconstruir qué pasó con lo\n *     que ya no está.\n *\n * LO QUE LA LÁPIDA NO ES. No es una prueba de que lo purgado fuera lo que dice\n * la lápida: quien controla el disco puede escribir la lápida que quiera. Es\n * una prueba de INTENCIÓN DECLARADA, y sirve para lo que sirve — que un borrado\n * legítimo no se confunda con uno hostil, y que uno hostil tenga que mentir por\n * escrito en vez de limitarse a borrar. Contra un adversario con acceso al\n * disco no hay defensa local; para eso hace falta un ancla externa.\n */\n\nimport { readFileSync, rmSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport type { EntradaDelLibro, LibroDeSesion } from \"./libro.ts\";\nimport { DIR_INDICE, DIR_SESION } from \"./rutas.ts\";\n\n/** Lo que la lápida deja escrito. Todo es dato de forma, nunca contenido. */\nexport interface Lapida {\n\t/** Qué fichero de sesión se fue. */\n\tfichero: string;\n\t/** Cuántas entradas tenía, para que el hueco sea contable. */\n\tentradas: number;\n\t/** El sello de tiempo de la primera y la última, que delimitan el periodo. */\n\tdesde: string;\n\thasta: string;\n\t/** Hash del último eslabón del tramo purgado: ancla de lo que se fue. */\n\thashDeCierre: string;\n\t/** Bajo qué regla. Un texto libre que el DPO reconozca en su documentación. */\n\tpolitica: string;\n}\n\nexport interface ResultadoDePurga {\n\tpurgados: Lapida[];\n\t/** Los que se miraron y NO se purgaron, con su motivo. */\n\tconservados: Array<{ fichero: string; porque: string }>;\n}\n\n/** Un fichero del libro leído, o `null` si no se pudo. */\nfunction leerEntradas(ruta: string): EntradaDelLibro[] | null {\n\ttry {\n\t\treturn readFileSync(ruta, \"utf-8\")\n\t\t\t.split(\"\\n\")\n\t\t\t.filter(Boolean)\n\t\t\t.map((l) => JSON.parse(l) as EntradaDelLibro);\n\t} catch {\n\t\treturn null;\n\t}\n}\n\n/**\n * Purga los ficheros de sesión anteriores a `antesDe`, dejando una lápida.\n *\n * `antesDe` se compara contra el sello de la ÚLTIMA entrada del fichero: una\n * sesión que empezó en enero y terminó en marzo se conserva si el corte está en\n * febrero. Purgar por la fecha de inicio borraría actividad posterior al corte,\n * que es justo lo que no se puede hacer.\n *\n * No purga el fichero de la sesión EN CURSO aunque cumpla la fecha: quitarle el\n * suelo a un libro que se está escribiendo rompería su cadena en memoria.\n */\nexport async function purgarAntesDe(\n\tlibro: LibroDeSesion,\n\tagentDir: string,\n\tantesDe: Date,\n\tpolitica: string,\n\t/** Con `true` se decide igual pero no se escribe ni se borra nada. */\n\tsimular = false,\n): Promise<ResultadoDePurga> {\n\tconst purgados: Lapida[] = [];\n\tconst conservados: Array<{ fichero: string; porque: string }> = [];\n\n\tconst { readdirSync } = await import(\"node:fs\");\n\tlet nombres: string[];\n\ttry {\n\t\tnombres = readdirSync(join(agentDir, DIR_SESION)).filter((f) => f.endsWith(\".jsonl\"));\n\t} catch {\n\t\treturn { purgados, conservados };\n\t}\n\n\tfor (const nombre of nombres) {\n\t\t// Se pregunta DENTRO del bucle: la primera lápida es la que da nombre al\n\t\t// fichero de esta sesión, así que antes de escribirla el libro todavía no\n\t\t// tiene ninguno —y si no tiene, tampoco está en `nombres`—.\n\t\tif (nombre === libro.ficheroEnCurso) {\n\t\t\tconservados.push({ fichero: nombre, porque: \"es la sesión en curso\" });\n\t\t\tcontinue;\n\t\t}\n\t\tconst ruta = join(agentDir, DIR_SESION, nombre);\n\t\tconst entradas = leerEntradas(ruta);\n\t\t// No se borra lo que no se ha podido leer: sin saber qué había, la lápida\n\t\t// sería una declaración inventada, que es peor que no purgar.\n\t\tif (!entradas || entradas.length === 0) {\n\t\t\tconservados.push({\n\t\t\t\tfichero: nombre,\n\t\t\t\tporque: \"no se ha podido leer, y no se purga lo que no se puede describir\",\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\t\tconst ultima = entradas[entradas.length - 1];\n\t\tif (new Date(ultima.ts) >= antesDe) {\n\t\t\tconservados.push({\n\t\t\t\tfichero: nombre,\n\t\t\t\tporque: `su última entrada (${ultima.ts.slice(0, 10)}) es posterior al corte`,\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst lapida: Lapida = {\n\t\t\tfichero: nombre,\n\t\t\tentradas: entradas.length,\n\t\t\tdesde: entradas[0].ts,\n\t\t\thasta: ultima.ts,\n\t\t\thashDeCierre: ultima.hash,\n\t\t\tpolitica,\n\t\t};\n\t\t// La lápida PRIMERO, el borrado después. Si el proceso muere en medio, el\n\t\t// libro tiene una lápida de más y el fichero todavía ahí — un estado\n\t\t// incómodo pero legible. Al revés quedaría un hueco sin explicación, que\n\t\t// es exactamente lo que este módulo existe para no producir.\n\t\t//\n\t\t// Con `simular` se decide EXACTAMENTE igual y no se toca nada: lo que se\n\t\t// enseña antes de un borrado irreversible tiene que salir del mismo camino\n\t\t// que lo ejecuta, o es una promesa sobre otro código.\n\t\tif (!simular) {\n\t\t\tawait libro.anotar({ tipo: \"purga\", ...lapida } as never);\n\t\t\trmSync(ruta, { force: true });\n\t\t\trmSync(join(agentDir, DIR_INDICE, nombre), { force: true });\n\t\t}\n\t\tpurgados.push(lapida);\n\t}\n\n\treturn { purgados, conservados };\n}\n\n/**\n * Los ficheros que una lápida declara purgados, leídos del propio libro.\n *\n * `verificar` lo usa para distinguir un hueco explicado de uno que no lo está.\n */\nexport function ficherosPurgados(entradas: readonly EntradaDelLibro[]): Map<string, Lapida> {\n\tconst mapa = new Map<string, Lapida>();\n\tfor (const e of entradas) {\n\t\tconst s = e.suceso as Record<string, unknown>;\n\t\tif (s.tipo !== \"purga\" || typeof s.fichero !== \"string\") continue;\n\t\tmapa.set(s.fichero, {\n\t\t\tfichero: s.fichero,\n\t\t\tentradas: Number(s.entradas ?? 0),\n\t\t\tdesde: String(s.desde ?? \"\"),\n\t\t\thasta: String(s.hasta ?? \"\"),\n\t\t\thashDeCierre: String(s.hashDeCierre ?? \"\"),\n\t\t\tpolitica: String(s.politica ?? \"\"),\n\t\t});\n\t}\n\treturn mapa;\n}\n"]}