@hoilab/ada-cli 0.84.22 → 0.85.1

package/dist/core/audit/libro.js

@@ -0,0 +1,508 @@
+/**
+ * Libro de sesión — qué HIZO el agente, en una cadena de hashes verificable.
+ *
+ * `memory-engine/audit.ts` ya tenía el mecanismo: JSONL append-only donde cada
+ * entrada lleva el hash de la anterior, de modo que alterar un registro se
+ * detecta reverificando la cadena. Lo que no tenía era ALCANCE: solo lo usaba
+ * el motor de memoria, así que auditábamos escrituras de memoria y no
+ * ejecuciones de tool, llamadas al modelo, ficheros tocados ni comandos.
+ *
+ * Este módulo aplica el mismo mecanismo a lo que un DPO pregunta de verdad, que
+ * es el registro del artículo 12 del AI Act y el 30 del RGPD.
+ *
+ * Dos decisiones de diseño que conviene no deshacer sin pensarlo:
+ *
+ * 1. **Minimización por defecto.** El libro guarda la FORMA de lo que pasó, no
+ *    su contenido: del fichero, su hash antes y después, nunca el texto. Un
+ *    registro de cumplimiento que copiara los datos sería un segundo almacén de
+ *    justo aquello que el RGPD quiere minimizar.
+ * 2. **Una sola canonicalización.** `memory-engine/audit.ts` construye la carga
+ *    a hashear dos veces, en `append` y en `verify`, con dos listas de campos
+ *    escritas a mano. Añadir un campo a una y olvidar la otra rompe la
+ *    verificación en silencio y solo para las entradas nuevas. Aquí la
+ *    verificación reconstruye la carga con un rest (`{hash, prevHash, ...resto}`),
+ *    así que un campo nuevo entra solo y las dos caras no pueden divergir.
+ */
+import { createHash } from "node:crypto";
+import { appendFileSync, linkSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { taparAntesDeEscribir } from "../privacidad/tapar.js";
+import { ficherosPurgados } from "./retencion.js";
+import { DIR_INDICE, DIR_SESION } from "./rutas.js";
+/** Hash de un contenido de fichero. `null` = el fichero no existía. */
+function hashContenido(texto) {
+    return texto === null ? null : createHash("sha256").update(texto).digest("hex").slice(0, 16);
+}
+/**
+ * Redacta cada hoja de texto por separado.
+ *
+ * Se hace hoja a hoja y no sobre el JSON ya serializado a propósito: un patrón
+ * que se pasara de largo sobre el texto serializado podría comerse una comilla
+ * y dejar el registro sin parsear. Sobre la hoja, lo peor que puede pasar es
+ * que redacte de más.
+ */
+function redactarHoja(valor) {
+    if (typeof valor === "string")
+        return taparAntesDeEscribir(valor, "strict");
+    if (Array.isArray(valor))
+        return valor.map(redactarHoja);
+    if (valor && typeof valor === "object") {
+        return Object.fromEntries(Object.entries(valor).map(([k, v]) => [k, redactarHoja(v)]));
+    }
+    return valor;
+}
+/** Pasa del suceso que da quien llama al registro que se guarda. */
+function aRegistro(suceso) {
+    const base = suceso.tipo === "fichero"
+        ? { ...suceso, antes: hashContenido(suceso.antes), despues: hashContenido(suceso.despues) }
+        : suceso;
+    return redactarHoja(base);
+}
+function hashDe(prevHash, carga) {
+    return createHash("sha256")
+        .update(JSON.stringify({ prevHash, ...carga }))
+        .digest("hex");
+}
+export class LibroDeSesion {
+    dir;
+    /** El índice: un enlace duro por fichero de sesión. Ver `DIR_INDICE`. */
+    dirIndice;
+    sesion;
+    seq = 0;
+    ultimoHash = null;
+    /** Fijado en la primera escritura por `reservarFichero`; no cambia despues. */
+    rutaFichero = null;
+    constructor(raiz, sesionId) {
+        this.dir = join(raiz, DIR_SESION);
+        this.dirIndice = join(raiz, DIR_INDICE);
+        this.sesion = sesionId;
+    }
+    /**
+     * Un fichero por sesión, no uno por día.
+     *
+     * Compartir fichero entre sesiones parecía más ordenado y hacía el libro
+     * INVERIFICABLE, cosa que solo se vio ejecutando: cada proceso arranca su
+     * `seq` en 1 y su hash anterior en `null`, así que tres sesiones seguidas
+     * dejaban tres cadenas encadenadas dentro del mismo fichero y `verificar`
+     * fallaba en la primera entrada de la segunda.
+     *
+     * Arreglarlo cargando el último hash al abrir no habría bastado: el CLI y el
+     * escritorio corren a la vez, y dos procesos que leyeran el mismo hash
+     * anterior escribirían dos entradas con el mismo `prevHash`.
+     *
+     * El límite que esto dejaba, y que era el agujero: borrar el fichero de una
+     * sesión entera no lo detecta la cadena, que solo ve la modificación DENTRO
+     * de una sesión. Se documentaba aquí mientras el veredicto seguía diciendo
+     * `valido: true` — o sea, un fallo que se leía como éxito en la pieza que se
+     * vende como prueba. Lo cierra el índice de `reservarFichero`.
+     *
+     * «Un fichero, un escritor» es la PRECONDICIÓN de todo lo anterior, y por eso
+     * `reservarFichero` la impone en vez de confiar en ella. Se rompía por dos
+     * caminos distintos, los dos encontrados sobre el libro real de esta máquina:
+     *
+     *   1. Dos escritores en un fichero. El escritorio usa el id fijo `desktop`,
+     *      así que cada encarnación del proceso —cada recompilación de Next—
+     *      abría el MISMO fichero creyéndose la primera y escribía otra entrada
+     *      con `seq 1` y `prevHash null`. Encontrado en
+     *      `sesion-2026-08-24-desktop.jsonl`: dos entradas, las dos `seq 1`.
+     *   2. Un escritor que cruza la medianoche. El nombre salía de la fecha de
+     *      CADA entrada, así que a las 00:00 la sesión saltaba a un fichero nuevo
+     *      cuya primera entrada llevaba el `prevHash` del fichero anterior —
+     *      mientras `verificar` arranca cada fichero esperando `null`.
+     *
+     * Los dos daban `CADENA ALTERADA` sobre un libro que nadie había tocado. Y el
+     * daño no es el ruido: es que una alteración de verdad queda indistinguible
+     * del caso benigno, y un medidor que grita siempre deja de leerse.
+     */
+    nombreBase(fecha) {
+        const id = this.sesion.replace(/[^a-zA-Z0-9-]/g, "_").slice(0, 40);
+        return `sesion-${fecha}-${id}.jsonl`;
+    }
+    /**
+     * Reserva el fichero de ESTA instancia, una sola vez, y no lo suelta.
+     *
+     * Fijarlo en la primera escritura mata el caso 2 de golpe: la sesión se queda
+     * en su fichero aunque cambie el día.
+     *
+     * Para el caso 1 se reclama el nombre con `wx` —crear-o-fallar—, que es
+     * atómico en el sistema de ficheros. Quien lo gana lo tiene; quien lo pierde
+     * prueba el siguiente. Así el «un escritor por fichero» deja de ser un
+     * acuerdo entre quienes llaman y pasa a ser cierto por construcción, incluso
+     * entre procesos distintos que no se conocen.
+     *
+     * Se prefiere partir en dos ficheros antes que leer la cola del ajeno y
+     * continuarlo: dos procesos que leyeran el mismo último hash escribirían dos
+     * entradas con el mismo `prevHash`, que es otra vez una cadena rota sin nadie
+     * manipulando nada. Dos ficheros íntegros son mejor que uno dudoso, y
+     * `verificar` ya los trata por separado.
+     *
+     * EL ANCLA. El nombre se reclama en el ÍNDICE y el fichero de `sesion/` es un
+     * ENLACE DURO al del índice, no una copia. Tres propiedades que hacen falta
+     * las tres:
+     *
+     *   1. `rm -rf sesion/` —el movimiento del agente que quiere tapar sus
+     *      pasos— borra un NOMBRE, no el fichero: los bytes siguen ahí bajo el
+     *      otro nombre, así que `verificar` no solo detecta la desaparición sino
+     *      que puede seguir leyendo lo que se quiso esconder.
+     *   2. El ancla no puede desincronizarse del libro, porque no es un
+     *      resumen que haya que mantener al día: es el mismo inodo. Un índice
+     *      con su propio contador tendría que escribirse en cada anotación, y
+     *      dos procesos escribiendo el mismo índice es la carrera que ya nos
+     *      dejó el libro inverificable una vez.
+     *   3. El nombre se reclama en el índice y no en `sesion/`, así que un
+     *      nombre gastado no se puede reutilizar aunque su fichero de sesión
+     *      haya desaparecido. Sin esto, borrar y reescribir con una entrada
+     *      dejaba el libro con el mismo aspecto que uno legítimo de una entrada.
+     *
+     * Hasta dónde llega, dicho sin adornos: quien borre los DOS directorios deja
+     * un libro vacío indistinguible de una instalación nueva. Contra eso está la
+     * otra mitad del trabajo —la política, que deniega la carpeta al agente
+     * incluso en `yolo`— y no un tercer ancla, porque un ancla que viva en el
+     * mismo disco y con los mismos permisos siempre se puede borrar igual. Lo que
+     * esto elimina es que un solo `rm` pase desapercibido.
+     */
+    /**
+     * El fichero que esta sesión está escribiendo, o `null` si aún no ha escrito.
+     *
+     * La purga lo necesita para no llevarse el suelo de un libro vivo, y tiene que
+     * saberlo por IDENTIDAD, no por fecha: fiarlo a «su última entrada es de hoy»
+     * deja el caso raro —un reloj movido, una sesión larga— rompiendo la cadena en
+     * memoria sin avisar.
+     */
+    get ficheroEnCurso() {
+        return this.rutaFichero ? basename(this.rutaFichero) : null;
+    }
+    reservarFichero(fecha) {
+        if (this.rutaFichero)
+            return this.rutaFichero;
+        mkdirSync(this.dirIndice, { recursive: true });
+        const base = this.nombreBase(fecha);
+        for (let n = 1;; n++) {
+            const nombre = n === 1 ? base : base.replace(/\.jsonl$/, `-${n}.jsonl`);
+            const ancla = join(this.dirIndice, nombre);
+            try {
+                writeFileSync(ancla, "", { flag: "wx" });
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                continue; // nombre gastado (otro escritor, u otra ejecución): el siguiente
+            }
+            const ruta = join(this.dir, nombre);
+            try {
+                linkSync(ancla, ruta);
+            }
+            catch (error) {
+                // El nombre estaba libre en el índice pero ocupado en `sesion/`: es un
+                // libro escrito ANTES de que el índice existiera. Se suelta el ancla
+                // vacía y se prueba el siguiente nombre. Soltarla no es cosmético:
+                // dejar un ancla de 0 bytes junto a un fichero de sesión con
+                // contenido son dos inodos con el mismo nombre, y `verificar` lo
+                // leería como suplantación en toda instalación que se actualice.
+                rmSync(ancla, { force: true });
+                if (error.code === "EEXIST")
+                    continue;
+                // Sin enlaces duros (FS exótico, montaje raro) el libro sigue
+                // funcionando SIN ancla, porque un libro que no se escribe es peor
+                // que uno sin ancla; `verificar` lo dirá como `sinAncla`, que es un
+                // tercer estado y no una acusación.
+                writeFileSync(ruta, "", { flag: "wx" });
+            }
+            this.rutaFichero = ruta;
+            return ruta;
+        }
+    }
+    /**
+     * Anota un suceso. Nunca lanza: un fallo del libro no puede tumbar la
+     * conversación, igual que en el audit del motor de memoria.
+     */
+    anotar(suceso) {
+        // SÍNCRONO, y no es una simplificación perezosa: es lo correcto aquí.
+        //
+        // Antes esto encolaba una escritura asíncrona y devolvía la promesa, y casi
+        // todos los llamantes hacen `void libro.anotar(...)` — no la esperan, porque
+        // un fallo del libro no puede tumbar la conversación. Eso deja dos agujeros:
+        //
+        //   1. Las últimas entradas se pierden si el proceso termina antes de que
+        //      la cola se vacíe. En un registro de cumplimiento, perder justo lo
+        //      último que hizo el agente es perder lo que más se va a mirar.
+        //   2. Escrituras que aterrizan DESPUÉS de que la sesión se haya cerrado.
+        //      Salió en una prueba de regresión de upstream: al borrar su
+        //      directorio temporal, el libro seguía creando ficheros dentro y
+        //      `rmSync` fallaba con ENOTEMPTY. La prueba pasaba en HEAD~1 y falló
+        //      al fusionar el índice — el ancla ensanchó una carrera que ya existía.
+        //
+        // El coste está MEDIDO, y sale a favor: 40 µs por entrada en síncrono
+        // frente a 56 µs en asíncrono (1.000 escrituras de 268 bytes). Es más
+        // rápido porque para una escritura tan pequeña la promesa pesa más que el
+        // `write`. Y 40 µs contra una llamada a herramienta que tarda milisegundos
+        // o segundos no se nota.
+        //
+        // Además desaparece la cola entera: JavaScript es de un solo hilo, así que
+        // dos `anotar` seguidos ya no pueden leer el mismo `ultimoHash`. La carrera
+        // que la cola existía para evitar deja de ser posible por construcción, que
+        // es mejor que evitarla con disciplina.
+        //
+        // Se mantiene la firma `Promise<void>` para no tocar a los llamantes.
+        this.escribir(suceso);
+        return Promise.resolve();
+    }
+    escribir(suceso) {
+        try {
+            mkdirSync(this.dir, { recursive: true });
+            const carga = {
+                seq: ++this.seq,
+                ts: new Date().toISOString(),
+                sesion: this.sesion,
+                suceso: aRegistro(suceso),
+            };
+            const hash = hashDe(this.ultimoHash, carga);
+            const entrada = { ...carga, hash, prevHash: this.ultimoHash };
+            this.ultimoHash = hash;
+            const ruta = this.reservarFichero(carga.ts.slice(0, 10));
+            appendFileSync(ruta, `${JSON.stringify(entrada)}\n`, "utf-8");
+        }
+        catch {
+            // El libro nunca rompe la sesión.
+        }
+    }
+    async listar(dir) {
+        try {
+            return (await readdir(dir)).filter((f) => /^sesion-.*\.jsonl$/.test(f)).sort();
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Los ficheros del libro vistos desde los DOS directorios.
+     *
+     * Esta es la comparación que antes no existía: `readdir(sesion/)` solo puede
+     * contestar «lo que hay», nunca «lo que debería haber», y por eso un borrado
+     * salía como un libro vacío.
+     */
+    async inventario() {
+        const enSesion = new Set(await this.listar(this.dir));
+        const enIndice = new Set(await this.listar(this.dirIndice));
+        const out = [];
+        for (const nombre of [...new Set([...enSesion, ...enIndice])].sort()) {
+            const s = enSesion.has(nombre);
+            const i = enIndice.has(nombre);
+            // Con los dos nombres presentes tienen que ser el MISMO inodo, porque
+            // así los creó `reservarFichero`. Si no lo son, alguien borró el de
+            // `sesion/` y puso otro en su sitio — y como el algoritmo de la cadena
+            // es público, ese otro puede tener una cadena interna perfecta. Sin
+            // esta comprobación la suplantación se leería como «cadena íntegra».
+            let suplantado = false;
+            if (s && i) {
+                try {
+                    const [a, b] = await Promise.all([stat(join(this.dir, nombre)), stat(join(this.dirIndice, nombre))]);
+                    suplantado = a.ino !== b.ino;
+                }
+                catch {
+                    // No se pudo mirar: no se acusa. «No lo he podido comprobar» no es
+                    // «está manipulado», y el fichero se verifica igual más abajo.
+                }
+            }
+            out.push({
+                nombre,
+                // Se lee del índice cuando el de `sesion/` no está (es el caso del
+                // borrado) o cuando no coincide con él: el índice es el ancla.
+                ruta: s && !suplantado ? join(this.dir, nombre) : join(this.dirIndice, nombre),
+                falta: i && !s,
+                sinAncla: s && !i,
+                suplantado,
+            });
+        }
+        return out;
+    }
+    /** Las últimas entradas, de la más reciente hacia atrás. */
+    async leer(limite = 50) {
+        const out = [];
+        for (const f of (await this.inventario()).reverse()) {
+            let crudo;
+            try {
+                // Por `f.ruta` y no por `sesion/`: las entradas de un fichero borrado
+                // sobreviven en el índice y quien investiga tiene que poder verlas.
+                crudo = await readFile(f.ruta, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            for (const linea of crudo.split("\n").filter(Boolean).reverse()) {
+                try {
+                    out.push(JSON.parse(linea));
+                    if (out.length >= limite)
+                        return out;
+                }
+                catch {
+                    // Línea ilegible: la verificación es quien lo denuncia, no la lectura.
+                }
+            }
+        }
+        return out;
+    }
+    /**
+     * Reverifica la cadena entera y contesta TRES estados, no dos.
+     *
+     * «Íntegra», «alterada» y «FALTA algo que debería estar». El tercero es el
+     * que faltaba: la cadena de hashes detecta la modificación DENTRO de un
+     * fichero y no puede, por construcción, notar la desaparición del fichero —
+     * para eso hace falta saber qué debería haber, que es lo que aporta el índice
+     * (ver `reservarFichero`).
+     *
+     * De la cadena rota devuelve en la PRIMERA entrada que no cuadra, y
+     * `comprobadas` cuenta las que sí cuadraban antes de ella — así el número
+     * dice dónde empieza la manipulación, no cuántas hay en total. Lo que ya se
+     * hubiera detectado como ausente viaja con esa respuesta: no se pierde por
+     * salir antes.
+     */
+    async verificar() {
+        let comprobadas = 0;
+        const faltan = [];
+        const reinicios = [];
+        const sinAncla = [];
+        // Las lápidas se leen ANTES de recorrer: una purga anotada en el fichero de
+        // hoy explica un hueco de un fichero de hace un año.
+        const purgados = ficherosPurgados(await this.leer());
+        for (const f of await this.inventario()) {
+            if (f.suplantado) {
+                return {
+                    valido: false,
+                    comprobadas,
+                    ficheroAlterado: f.nombre,
+                    motivo: "el fichero de sesión ya no es el mismo que el del índice: lo han sustituido",
+                    ...(faltan.length ? { faltan } : {}),
+                    ...(sinAncla.length ? { sinAncla } : {}),
+                };
+            }
+            // La cadena empieza de cero en CADA fichero, porque cada fichero es una
+            // sesión y su primera entrada lleva `prevHash: null`. Arrastrar el hash
+            // de un fichero al siguiente es lo que hacía fallar la verificación en
+            // cuanto había más de una sesión.
+            let prevHash = null;
+            let enEste = 0;
+            let crudo;
+            try {
+                crudo = await readFile(f.ruta, "utf-8");
+            }
+            catch {
+                return {
+                    valido: false,
+                    comprobadas,
+                    ficheroAlterado: f.nombre,
+                    motivo: "no se ha podido leer el fichero: no es «está bien», es «no lo sé»",
+                    ...(faltan.length ? { faltan } : {}),
+                };
+            }
+            for (const linea of crudo.split("\n").filter(Boolean)) {
+                let entrada;
+                try {
+                    entrada = JSON.parse(linea);
+                }
+                catch {
+                    return {
+                        valido: false,
+                        comprobadas,
+                        ficheroAlterado: f.nombre,
+                        motivo: "hay una línea que no es JSON válido",
+                        ...(faltan.length ? { faltan } : {}),
+                    };
+                }
+                // El rest es lo que impide que esta lista y la de `escribir`
+                // se separen: aquí no hay lista.
+                const { hash, prevHash: declarado, ...resto } = entrada;
+                // Se separan DOS preguntas que antes iban juntas y contestaban lo
+                // mismo, acusando siempre de lo primero:
+                //
+                //   · ¿el hash cuadra con SU PROPIO contenido? Si no, alguien editó la
+                //     entrada. Eso es manipulación y se dice así.
+                //   · ¿su `prevHash` apunta a la entrada anterior? Si no, el enlace
+                //     está roto, que es otra cosa: faltan entradas o están cambiadas
+                //     de orden.
+                //
+                // Medido sobre el libro real de esta máquina: un fichero de dos
+                // entradas, las dos con `seq: 1` y `prevHash: null`, salía como «el
+                // hash de una entrada no cuadra con su contenido». Cuadraba
+                // perfectamente. Eran dos procesos del escritorio escribiendo el mismo
+                // fichero antes de que `reservarFichero` diera nombres distintos.
+                if (hash !== hashDe(declarado, resto)) {
+                    return {
+                        valido: false,
+                        comprobadas,
+                        alteradaEn: entrada.ts,
+                        ficheroAlterado: f.nombre,
+                        motivo: "el hash de una entrada no cuadra con su contenido: la han editado",
+                        ...(faltan.length ? { faltan } : {}),
+                    };
+                }
+                if (declarado !== prevHash) {
+                    // Una cadena que vuelve a empezar dentro del mismo fichero. Lo
+                    // produce un reinicio del proceso —y lo produce igual quien quite
+                    // entradas del medio y escriba una cadena nueva—. Desde el fichero
+                    // no se distinguen, así que NO se llama manipulación ni se da por
+                    // bueno: es el tercer estado, y se dice entero en `reinicios`.
+                    if (declarado === null && prevHash !== null) {
+                        reinicios.push({ fichero: f.nombre, ts: entrada.ts, entradasAntes: enEste });
+                        prevHash = hash;
+                        comprobadas++;
+                        enEste++;
+                        continue;
+                    }
+                    return {
+                        valido: false,
+                        comprobadas,
+                        alteradaEn: entrada.ts,
+                        ficheroAlterado: f.nombre,
+                        motivo: "el enlace de una entrada no apunta a la anterior: faltan entradas o están cambiadas de orden",
+                        ...(faltan.length ? { faltan } : {}),
+                    };
+                }
+                prevHash = hash;
+                comprobadas++;
+                enEste++;
+            }
+            // Un fichero VACÍO que falta no es una ausencia: es una reserva de
+            // nombre que nunca llegó a escribirse (la sesión murió entre reservar y
+            // anotar). Contarlo habría hecho que una sesión nueva y legítima, sin
+            // una sola entrada todavía, se reportara como manipulada — la mitad que
+            // decide, porque un detector que grita siempre no distingue nada.
+            if (enEste === 0)
+                continue;
+            // Un hueco EXPLICADO no es una manipulación.
+            //
+            // Si el propio libro lleva una lápida diciendo que ese fichero se purgó
+            // —cuándo, cuántas entradas, bajo qué política y con qué hash de
+            // cierre—, la ausencia es un hecho declarado y no una desaparición. Sin
+            // esto, cumplir el art. 5.1.e del RGPD hacía que `verificar` contestara
+            // «alguien los ha borrado»: la ley nos acusaba de manipular. Ver
+            // `audit/retencion.ts`.
+            if (f.falta && !purgados.has(f.nombre))
+                faltan.push({ fichero: f.nombre, entradas: enEste });
+            if (f.sinAncla)
+                sinAncla.push(f.nombre);
+        }
+        // Las lápidas se enseñan TODAS, no solo las que tapan un hueco del
+        // inventario. Una purga completa se lleva el fichero Y su ancla, así que no
+        // deja hueco ninguno: si solo se informara de las que explican una ausencia,
+        // el caso normal —el que de verdad ocurre— saldría mudo y el DPO leería
+        // «cadena íntegra, 1 entrada» sin enterarse de que se purgaron tres. Que es
+        // exactamente el «desaparece sin rastro» que este mecanismo existe para
+        // impedir.
+        const explicados = [...purgados.values()].map((l) => ({
+            fichero: l.fichero,
+            entradas: l.entradas,
+            politica: l.politica,
+        }));
+        return {
+            valido: faltan.length === 0,
+            ...(explicados.length ? { purgados: explicados } : {}),
+            ...(reinicios.length ? { reinicios } : {}),
+            comprobadas,
+            ...(faltan.length ? { faltan } : {}),
+            ...(sinAncla.length ? { sinAncla } : {}),
+        };
+    }
+}
+//# sourceMappingURL=libro.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"libro.js","sourceRoot":"","sources":["../../../src/core/audit/libro.ts"],"names":[],"mappings":"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"}

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,oEAAoE;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,uEAAuE;IACvE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA+B;IAC1D;;;;;;;;;;OAUG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,MAAM,CAAC,CAAgB;gBAY9B,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;IAevD;;;;;;OAMG;IACH,KAAK,IAAI,aAAa;IAKtB;;;;;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;IA+BpB;;;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;IAiDzB;;;;;;;OAOG;IACH,YAAY,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI;CAsC/C"}