@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/memory-engine/audit-indice.js

@@ -0,0 +1,271 @@
+/**
+ * El índice del audit del motor de memoria: lo que DEBERÍA existir.
+ *
+ * EL AGUJERO, medido antes de escribir nada, sobre un directorio temporal con
+ * cinco entradas y la implementación de `audit.ts` tal como estaba:
+ *
+ *   1) las 5 entradas intactas      : {"valid":true,"entriesChecked":5}
+ *   2) editada la del medio         : {"valid":false,"entriesChecked":2}
+ *   3) fichero BORRADO entero       : {"valid":true,"entriesChecked":0}   <- éxito
+ *   4) TRUNCADO (-2 últimas)        : {"valid":true,"entriesChecked":3}   <- éxito
+ *   5) QUITADA una del medio        : {"valid":false,"entriesChecked":2}
+ *
+ * Y las dos que sacan la forma completa:
+ *
+ *   B) directorio `audit/` borrado  : {"valid":false,"entriesChecked":0}
+ *   C) instalación nueva            : {"valid":false,"entriesChecked":0}   <- lo mismo
+ *
+ * O sea: no había tres estados, había dos, y ninguno caía donde debía. Un
+ * borrado se leía como éxito y una instalación virgen se leía como
+ * manipulación — un detector que acusa a toda instalación limpia deja de
+ * leerse, y con él se va también la señal de la manipulación real.
+ *
+ * LA RAZÓN DE FONDO, y por eso esto es un módulo aparte y no un `if` más en
+ * `verify`: la cadena de hashes NO PUEDE, por construcción, hablar de lo que ya
+ * no está. `readdir(audit/)` solo sabe contestar «lo que hay». Para contestar
+ * «lo que debería haber» hace falta un registro APARTE, que es exactamente lo
+ * que `audit/libro.ts` resolvió con su índice de dos directorios.
+ *
+ * LA DIFERENCIA CON `libro.ts`, que es la que decide el diseño: allí el ancla
+ * es un ENLACE DURO por fichero, y basta porque el ataque que importa es `rm`.
+ * Aquí no basta. Un enlace duro comparte inodo, así que `truncate` recorta los
+ * bytes de los DOS nombres a la vez y el caso 4 seguiría pasando entero. Y el
+ * caso 4 tiene una variante peor, la que de verdad ocurre: truncar y dejar que
+ * el proceso siga: `load()` lee la última entrada superviviente, retoma `seq` y
+ * `lastHash` desde ahí y encadena por encima del hueco. Quedan `seq` 1,2,3,4
+ * correlativos y cadena perfecta, con dos entradas desaparecidas y ni una sola
+ * señal.
+ *
+ * Por eso el ancla de aquí es por ENTRADA y no por fichero: un fichero
+ * `<nombre>.ancla` en `audit-indice/`, append-only, con el hash de cada entrada
+ * escrita, uno por línea. Verificar es entonces una resta de conjuntos: los
+ * hashes que el índice recuerda y que ya no aparecen en el log son entradas que
+ * han desaparecido, se las hayan llevado borrando el fichero, recortándole la
+ * cola o quitándolas del medio.
+ *
+ * DOS DECISIONES QUE CONVIENE NO DESHACER SIN PENSARLAS:
+ *
+ * 1. **Se ancla DESPUÉS de escribir la entrada, nunca antes.** Al revés —
+ *    escribir el ancla primero— un proceso que muera entre las dos escrituras
+ *    dejaría un hash anclado cuya entrada no llegó nunca, y la siguiente
+ *    verificación acusaría de manipulación a un simple corte de luz. Se prefiere
+ *    el fallo del otro lado: durante esa ventana de microsegundos la última
+ *    entrada está sin anclar y su desaparición no se detectaría. Un falso
+ *    negativo estrechísimo es mejor que un falso positivo en cada caída.
+ * 2. **Lo que sobra no acusa.** Entradas del log que no estén en el índice NO
+ *    son un hallazgo: son logs escritos antes de que el índice existiera, o la
+ *    ventana del punto anterior. Solo cuenta lo que el índice recuerda y ya no
+ *    está. Sin esta asimetría, el día de la actualización toda instalación
+ *    existente gritaría «manipulado».
+ *
+ * HASTA DÓNDE LLEGA, dicho sin adornos: quien borre los DOS directorios deja un
+ * registro vacío indistinguible de una instalación nueva. Contra eso no hay
+ * ancla local que valga —cualquier ancla en el mismo disco y con los mismos
+ * permisos se borra igual—; hace falta un ancla externa. Lo que esto elimina es
+ * que un solo `rm` o un solo `truncate` pasen desapercibidos.
+ */
+import { appendFile, mkdir, readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+/** Donde vive el log: `<rootDir>/audit/audit-YYYY-MM-DD.jsonl`. */
+export const DIR_AUDIT = "audit";
+/**
+ * El índice: `<rootDir>/audit-indice/<nombre del log>.ancla`.
+ *
+ * Va FUERA de `audit/` a propósito. Dentro, el `rm -rf audit/` que este
+ * mecanismo existe para detectar se llevaría por delante también la prueba.
+ */
+export const DIR_INDICE_AUDIT = "audit-indice";
+const RE_LOG = /^audit-.*\.jsonl$/;
+const SUFIJO_ANCLA = ".ancla";
+/**
+ * Anota en el índice el hash de una entrada recién escrita.
+ *
+ * Append-only y una línea por entrada: sobrescribir un ancla con «la última»
+ * la volvería inútil justo en el caso que importa, porque tras un truncado el
+ * proceso siguiente la sobrescribiría con un número MENOR y borraría la prueba.
+ */
+export async function anclarEntrada(raiz, fichero, hash) {
+    const dir = join(raiz, DIR_INDICE_AUDIT);
+    await mkdir(dir, { recursive: true });
+    await appendFile(join(dir, fichero + SUFIJO_ANCLA), `${hash}\n`, "utf-8");
+}
+/** `null` = no se ha podido mirar, que no es lo mismo que «no hay nada». */
+async function listar(dir, filtro) {
+    try {
+        return (await readdir(dir)).filter((f) => filtro.test(f)).sort();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        return null;
+    }
+}
+function veredictoIlegible(motivo, comprobadas = 0) {
+    return { estado: "alterado", valid: false, entriesChecked: comprobadas, causa: "ilegible", motivo };
+}
+/**
+ * Verifica el registro entero y contesta TRES estados.
+ *
+ * Reparto de tareas, que es lo que hace que esto no sea un parche:
+ *
+ *   · la cadena de hashes dice si lo que HAY está intacto y en orden;
+ *   · el índice dice si lo que hay es TODO lo que hubo.
+ *
+ * Ninguna de las dos puede contestar la pregunta de la otra.
+ *
+ * `rehash` se inyecta en vez de importarse para no crear un ciclo con
+ * `audit.ts`, que es quien tiene la única canonicalización buena — la misma que
+ * usa al escribir, reconstruida con un rest para que las dos caras no puedan
+ * divergir.
+ */
+export async function verificarRegistro(raiz, rehash) {
+    const dirAudit = join(raiz, DIR_AUDIT);
+    const dirIndice = join(raiz, DIR_INDICE_AUDIT);
+    const logs = await listar(dirAudit, RE_LOG);
+    if (logs === null)
+        return veredictoIlegible("no se ha podido leer el directorio del registro: no es «está bien», es «no lo sé»");
+    const anclas = await listar(dirIndice, new RegExp(`^audit-.*\\.jsonl\\${SUFIJO_ANCLA}$`));
+    if (anclas === null)
+        return veredictoIlegible("no se ha podido leer el índice del registro: no es «está bien», es «no lo sé»");
+    // Lo que el índice recuerda, por fichero.
+    const recordados = new Map();
+    for (const ancla of anclas) {
+        const nombre = ancla.slice(0, -SUFIJO_ANCLA.length);
+        try {
+            const hashes = (await readFile(join(dirIndice, ancla), "utf-8")).split("\n").filter(Boolean);
+            if (hashes.length > 0)
+                recordados.set(nombre, hashes);
+        }
+        catch {
+            return veredictoIlegible(`no se ha podido leer el ancla de ${nombre}: no es «está bien», es «no lo sé»`);
+        }
+    }
+    // Un registro que nunca se escribió NO es un registro íntegro. Este es el
+    // caso C: sin esto, la instalación virgen daba el mismo veredicto que el
+    // directorio borrado del caso B.
+    if (logs.length === 0 && recordados.size === 0) {
+        return { estado: "vacio", valid: true, entriesChecked: 0 };
+    }
+    const presentes = new Set(logs);
+    const borrados = [];
+    const incompletos = [];
+    const sinAncla = [];
+    // Los ficheros que el índice recuerda y ya NO están. Se cuentan antes de
+    // recorrer la cadena porque son la EXPLICACIÓN de los enlaces rotos que
+    // vengan después: sin esto, un fichero borrado se denunciaría como «enlace
+    // roto» en el fichero siguiente, acusando de mover entradas a quien borró un
+    // día entero.
+    for (const [nombre, hashes] of recordados) {
+        if (!presentes.has(nombre))
+            borrados.push({ fichero: nombre, entradas: hashes.length });
+    }
+    let prevHash = null;
+    let comprobadas = 0;
+    // La cadena del audit de memoria es GLOBAL entre ficheros —`append` nunca
+    // reinicia `prevHash` al cambiar de día—, así que se arrastra de un fichero
+    // al siguiente. Es justo al revés que en `libro.ts`, donde cada fichero es
+    // una sesión y empieza en `null`.
+    for (const nombre of logs) {
+        const anclados = recordados.get(nombre);
+        if (!anclados)
+            sinAncla.push(nombre);
+        let crudo;
+        try {
+            crudo = await readFile(join(dirAudit, nombre), "utf-8");
+        }
+        catch {
+            return {
+                ...veredictoIlegible(`no se ha podido leer ${nombre}: no es «está bien», es «no lo sé»`, comprobadas),
+                ficheroAlterado: nombre,
+            };
+        }
+        const vistos = new Set();
+        for (const linea of crudo.split("\n").filter(Boolean)) {
+            let entrada;
+            try {
+                entrada = JSON.parse(linea);
+            }
+            catch {
+                return {
+                    estado: "alterado",
+                    valid: false,
+                    entriesChecked: comprobadas,
+                    causa: "editada",
+                    motivo: "hay una línea que no es JSON válido",
+                    ficheroAlterado: nombre,
+                    ...(borrados.length ? { borrados } : {}),
+                };
+            }
+            const { hash, prevHash: declarado, ...carga } = entrada;
+            // Dos preguntas distintas que antes iban juntas y contestaban lo mismo:
+            //
+            //   · ¿el hash cuadra con SU PROPIO contenido? -> la han editado.
+            //   · ¿su `prevHash` apunta a la anterior?     -> faltan entradas o
+            //     están cambiadas de orden.
+            if (typeof hash !== "string" || hash !== rehash(declarado ?? null, carga)) {
+                return {
+                    estado: "alterado",
+                    valid: false,
+                    entriesChecked: comprobadas,
+                    tamperedAt: entrada.ts,
+                    causa: "editada",
+                    motivo: "el hash de una entrada no cuadra con su contenido: la han editado",
+                    ficheroAlterado: nombre,
+                    ...(borrados.length ? { borrados } : {}),
+                };
+            }
+            if ((declarado ?? null) !== prevHash) {
+                // Un enlace roto DESPUÉS de una ausencia ya conocida no es un
+                // hallazgo nuevo: es su consecuencia. Se sigue leyendo para poder
+                // contar lo que queda, y la causa se decide al final.
+                if (borrados.length === 0 && incompletos.length === 0) {
+                    return {
+                        estado: "alterado",
+                        valid: false,
+                        entriesChecked: comprobadas,
+                        tamperedAt: entrada.ts,
+                        causa: "enlace-roto",
+                        motivo: "el enlace de una entrada no apunta a la anterior: faltan entradas o están cambiadas de orden",
+                        ficheroAlterado: nombre,
+                    };
+                }
+            }
+            vistos.add(hash);
+            prevHash = hash;
+            comprobadas++;
+        }
+        // La resta que la cadena no puede hacer: lo que el índice recuerda y el
+        // fichero ya no enseña. Cubre el truncado, el truncado-y-seguir-
+        // escribiendo, y la entrada quitada del medio.
+        if (anclados) {
+            const faltan = anclados.filter((h) => !vistos.has(h)).length;
+            if (faltan > 0)
+                incompletos.push({ fichero: nombre, entradas: anclados.length, faltan });
+        }
+    }
+    if (borrados.length > 0 || incompletos.length > 0) {
+        const soloBorrados = incompletos.length === 0;
+        return {
+            estado: "alterado",
+            valid: false,
+            entriesChecked: comprobadas,
+            causa: soloBorrados ? "borrado" : "faltan-entradas",
+            motivo: soloBorrados
+                ? "el índice recuerda ficheros que ya no están: los han borrado"
+                : "faltan entradas que el índice recuerda haber escrito: las han quitado del registro",
+            ...(borrados.length ? { borrados } : {}),
+            ...(incompletos.length ? { incompletos } : {}),
+            ...(sinAncla.length ? { sinAncla } : {}),
+        };
+    }
+    // Un registro con ancla y sin entradas todavía sigue siendo un registro
+    // vacío: `estado: "vacio"` y no `"integro"`, para que la respuesta no
+    // dependa de si el índice llegó a crearse antes de la primera entrada.
+    return {
+        estado: comprobadas === 0 ? "vacio" : "integro",
+        valid: true,
+        entriesChecked: comprobadas,
+        ...(sinAncla.length ? { sinAncla } : {}),
+    };
+}
+//# sourceMappingURL=audit-indice.js.map

package/dist/core/memory-engine/audit-indice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-indice.js","sourceRoot":"","sources":["../../../src/core/memory-engine/audit-indice.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * El índice del audit del motor de memoria: lo que DEBERÍA existir.\n *\n * EL AGUJERO, medido antes de escribir nada, sobre un directorio temporal con\n * cinco entradas y la implementación de `audit.ts` tal como estaba:\n *\n *   1) las 5 entradas intactas      : {\"valid\":true,\"entriesChecked\":5}\n *   2) editada la del medio         : {\"valid\":false,\"entriesChecked\":2}\n *   3) fichero BORRADO entero       : {\"valid\":true,\"entriesChecked\":0}   <- éxito\n *   4) TRUNCADO (-2 últimas)        : {\"valid\":true,\"entriesChecked\":3}   <- éxito\n *   5) QUITADA una del medio        : {\"valid\":false,\"entriesChecked\":2}\n *\n * Y las dos que sacan la forma completa:\n *\n *   B) directorio `audit/` borrado  : {\"valid\":false,\"entriesChecked\":0}\n *   C) instalación nueva            : {\"valid\":false,\"entriesChecked\":0}   <- lo mismo\n *\n * O sea: no había tres estados, había dos, y ninguno caía donde debía. Un\n * borrado se leía como éxito y una instalación virgen se leía como\n * manipulación — un detector que acusa a toda instalación limpia deja de\n * leerse, y con él se va también la señal de la manipulación real.\n *\n * LA RAZÓN DE FONDO, y por eso esto es un módulo aparte y no un `if` más en\n * `verify`: la cadena de hashes NO PUEDE, por construcción, hablar de lo que ya\n * no está. `readdir(audit/)` solo sabe contestar «lo que hay». Para contestar\n * «lo que debería haber» hace falta un registro APARTE, que es exactamente lo\n * que `audit/libro.ts` resolvió con su índice de dos directorios.\n *\n * LA DIFERENCIA CON `libro.ts`, que es la que decide el diseño: allí el ancla\n * es un ENLACE DURO por fichero, y basta porque el ataque que importa es `rm`.\n * Aquí no basta. Un enlace duro comparte inodo, así que `truncate` recorta los\n * bytes de los DOS nombres a la vez y el caso 4 seguiría pasando entero. Y el\n * caso 4 tiene una variante peor, la que de verdad ocurre: truncar y dejar que\n * el proceso siga: `load()` lee la última entrada superviviente, retoma `seq` y\n * `lastHash` desde ahí y encadena por encima del hueco. Quedan `seq` 1,2,3,4\n * correlativos y cadena perfecta, con dos entradas desaparecidas y ni una sola\n * señal.\n *\n * Por eso el ancla de aquí es por ENTRADA y no por fichero: un fichero\n * `<nombre>.ancla` en `audit-indice/`, append-only, con el hash de cada entrada\n * escrita, uno por línea. Verificar es entonces una resta de conjuntos: los\n * hashes que el índice recuerda y que ya no aparecen en el log son entradas que\n * han desaparecido, se las hayan llevado borrando el fichero, recortándole la\n * cola o quitándolas del medio.\n *\n * DOS DECISIONES QUE CONVIENE NO DESHACER SIN PENSARLAS:\n *\n * 1. **Se ancla DESPUÉS de escribir la entrada, nunca antes.** Al revés —\n *    escribir el ancla primero— un proceso que muera entre las dos escrituras\n *    dejaría un hash anclado cuya entrada no llegó nunca, y la siguiente\n *    verificación acusaría de manipulación a un simple corte de luz. Se prefiere\n *    el fallo del otro lado: durante esa ventana de microsegundos la última\n *    entrada está sin anclar y su desaparición no se detectaría. Un falso\n *    negativo estrechísimo es mejor que un falso positivo en cada caída.\n * 2. **Lo que sobra no acusa.** Entradas del log que no estén en el índice NO\n *    son un hallazgo: son logs escritos antes de que el índice existiera, o la\n *    ventana del punto anterior. Solo cuenta lo que el índice recuerda y ya no\n *    está. Sin esta asimetría, el día de la actualización toda instalación\n *    existente gritaría «manipulado».\n *\n * HASTA DÓNDE LLEGA, dicho sin adornos: quien borre los DOS directorios deja un\n * registro vacío indistinguible de una instalación nueva. Contra eso no hay\n * ancla local que valga —cualquier ancla en el mismo disco y con los mismos\n * permisos se borra igual—; hace falta un ancla externa. Lo que esto elimina es\n * que un solo `rm` o un solo `truncate` pasen desapercibidos.\n */\n\nimport { appendFile, mkdir, readdir, readFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\n\n/** Donde vive el log: `<rootDir>/audit/audit-YYYY-MM-DD.jsonl`. */\nexport const DIR_AUDIT = \"audit\";\n\n/**\n * El índice: `<rootDir>/audit-indice/<nombre del log>.ancla`.\n *\n * Va FUERA de `audit/` a propósito. Dentro, el `rm -rf audit/` que este\n * mecanismo existe para detectar se llevaría por delante también la prueba.\n */\nexport const DIR_INDICE_AUDIT = \"audit-indice\";\n\nconst RE_LOG = /^audit-.*\\.jsonl$/;\nconst SUFIJO_ANCLA = \".ancla\";\n\n/** Los tres estados. «Vacío» NO es «íntegro»: ver la cabecera de este fichero. */\nexport type EstadoDelRegistro = \"integro\" | \"alterado\" | \"vacio\";\n\n/**\n * Por qué está alterado, que no es lo mismo que el hecho de que lo esté.\n *\n * Un detector que diera el mismo veredicto a tres causas distintas no\n * distinguiría ninguna, y el mensaje acabaría acusando de lo que no es.\n *\n * `ilegible` es el que no acusa de nada: es «no lo he podido mirar», y va\n * separado de los demás porque para quien responde a una auditoría no es lo\n * mismo que «lo he mirado y no cuadra».\n */\nexport type CausaDeAlteracion = \"editada\" | \"enlace-roto\" | \"borrado\" | \"faltan-entradas\" | \"ilegible\";\n\nexport interface VeredictoDelRegistro {\n\testado: EstadoDelRegistro;\n\t/**\n\t * Compat con quien ya lee este veredicto: el modo interactivo, la ruta\n\t * `/api/memory/audit` del escritorio y `audit-export.ts`. Es `estado ===\n\t * \"integro\" || estado === \"vacio\"` — una instalación virgen no está\n\t * manipulada, y quien quiera distinguirlas tiene `estado`.\n\t */\n\tvalid: boolean;\n\tentriesChecked: number;\n\t/** Sello de tiempo de la primera entrada que no cuadra. */\n\ttamperedAt?: string;\n\tcausa?: CausaDeAlteracion;\n\t/** Por qué no verifica, en una frase estable. */\n\tmotivo?: string;\n\t/** Dónde mirar. Sin esto el aviso de manipulación se queda en susto. */\n\tficheroAlterado?: string;\n\t/** Ficheros que el índice recuerda y que ya no están, con cuántas entradas tenían. */\n\tborrados?: { fichero: string; entradas: number }[];\n\t/** Ficheros que siguen ahí pero a los que les faltan entradas ancladas. */\n\tincompletos?: { fichero: string; entradas: number; faltan: number }[];\n\t/**\n\t * Ficheros del log sin ancla en el índice: logs anteriores al índice.\n\t *\n\t * NO es una acusación y por eso va aparte: meterlo en `estado: \"alterado\"`\n\t * habría hecho que toda instalación ya existente gritara «manipulado» el día\n\t * de la actualización.\n\t */\n\tsinAncla?: string[];\n}\n\n/** Carga a hashear de una entrada, tal y como `audit.ts` la reconstruye. */\ntype Rehasheador = (prevHash: string | null, carga: Record<string, unknown>) => string;\n\n/** Lo mínimo que la verificación necesita saber de una entrada. */\ninterface EntradaLeida {\n\tts?: string;\n\thash?: string;\n\tprevHash?: string | null;\n\t[campo: string]: unknown;\n}\n\n/**\n * Anota en el índice el hash de una entrada recién escrita.\n *\n * Append-only y una línea por entrada: sobrescribir un ancla con «la última»\n * la volvería inútil justo en el caso que importa, porque tras un truncado el\n * proceso siguiente la sobrescribiría con un número MENOR y borraría la prueba.\n */\nexport async function anclarEntrada(raiz: string, fichero: string, hash: string): Promise<void> {\n\tconst dir = join(raiz, DIR_INDICE_AUDIT);\n\tawait mkdir(dir, { recursive: true });\n\tawait appendFile(join(dir, fichero + SUFIJO_ANCLA), `${hash}\\n`, \"utf-8\");\n}\n\n/** `null` = no se ha podido mirar, que no es lo mismo que «no hay nada». */\nasync function listar(dir: string, filtro: RegExp): Promise<string[] | null> {\n\ttry {\n\t\treturn (await readdir(dir)).filter((f) => filtro.test(f)).sort();\n\t} catch (error) {\n\t\tif ((error as NodeJS.ErrnoException).code === \"ENOENT\") return [];\n\t\treturn null;\n\t}\n}\n\nfunction veredictoIlegible(motivo: string, comprobadas = 0): VeredictoDelRegistro {\n\treturn { estado: \"alterado\", valid: false, entriesChecked: comprobadas, causa: \"ilegible\", motivo };\n}\n\n/**\n * Verifica el registro entero y contesta TRES estados.\n *\n * Reparto de tareas, que es lo que hace que esto no sea un parche:\n *\n *   · la cadena de hashes dice si lo que HAY está intacto y en orden;\n *   · el índice dice si lo que hay es TODO lo que hubo.\n *\n * Ninguna de las dos puede contestar la pregunta de la otra.\n *\n * `rehash` se inyecta en vez de importarse para no crear un ciclo con\n * `audit.ts`, que es quien tiene la única canonicalización buena — la misma que\n * usa al escribir, reconstruida con un rest para que las dos caras no puedan\n * divergir.\n */\nexport async function verificarRegistro(raiz: string, rehash: Rehasheador): Promise<VeredictoDelRegistro> {\n\tconst dirAudit = join(raiz, DIR_AUDIT);\n\tconst dirIndice = join(raiz, DIR_INDICE_AUDIT);\n\n\tconst logs = await listar(dirAudit, RE_LOG);\n\tif (logs === null)\n\t\treturn veredictoIlegible(\"no se ha podido leer el directorio del registro: no es «está bien», es «no lo sé»\");\n\tconst anclas = await listar(dirIndice, new RegExp(`^audit-.*\\\\.jsonl\\\\${SUFIJO_ANCLA}$`));\n\tif (anclas === null)\n\t\treturn veredictoIlegible(\"no se ha podido leer el índice del registro: no es «está bien», es «no lo sé»\");\n\n\t// Lo que el índice recuerda, por fichero.\n\tconst recordados = new Map<string, string[]>();\n\tfor (const ancla of anclas) {\n\t\tconst nombre = ancla.slice(0, -SUFIJO_ANCLA.length);\n\t\ttry {\n\t\t\tconst hashes = (await readFile(join(dirIndice, ancla), \"utf-8\")).split(\"\\n\").filter(Boolean);\n\t\t\tif (hashes.length > 0) recordados.set(nombre, hashes);\n\t\t} catch {\n\t\t\treturn veredictoIlegible(`no se ha podido leer el ancla de ${nombre}: no es «está bien», es «no lo sé»`);\n\t\t}\n\t}\n\n\t// Un registro que nunca se escribió NO es un registro íntegro. Este es el\n\t// caso C: sin esto, la instalación virgen daba el mismo veredicto que el\n\t// directorio borrado del caso B.\n\tif (logs.length === 0 && recordados.size === 0) {\n\t\treturn { estado: \"vacio\", valid: true, entriesChecked: 0 };\n\t}\n\n\tconst presentes = new Set(logs);\n\tconst borrados: { fichero: string; entradas: number }[] = [];\n\tconst incompletos: { fichero: string; entradas: number; faltan: number }[] = [];\n\tconst sinAncla: string[] = [];\n\n\t// Los ficheros que el índice recuerda y ya NO están. Se cuentan antes de\n\t// recorrer la cadena porque son la EXPLICACIÓN de los enlaces rotos que\n\t// vengan después: sin esto, un fichero borrado se denunciaría como «enlace\n\t// roto» en el fichero siguiente, acusando de mover entradas a quien borró un\n\t// día entero.\n\tfor (const [nombre, hashes] of recordados) {\n\t\tif (!presentes.has(nombre)) borrados.push({ fichero: nombre, entradas: hashes.length });\n\t}\n\n\tlet prevHash: string | null = null;\n\tlet comprobadas = 0;\n\t// La cadena del audit de memoria es GLOBAL entre ficheros —`append` nunca\n\t// reinicia `prevHash` al cambiar de día—, así que se arrastra de un fichero\n\t// al siguiente. Es justo al revés que en `libro.ts`, donde cada fichero es\n\t// una sesión y empieza en `null`.\n\tfor (const nombre of logs) {\n\t\tconst anclados = recordados.get(nombre);\n\t\tif (!anclados) sinAncla.push(nombre);\n\t\tlet crudo: string;\n\t\ttry {\n\t\t\tcrudo = await readFile(join(dirAudit, nombre), \"utf-8\");\n\t\t} catch {\n\t\t\treturn {\n\t\t\t\t...veredictoIlegible(`no se ha podido leer ${nombre}: no es «está bien», es «no lo sé»`, comprobadas),\n\t\t\t\tficheroAlterado: nombre,\n\t\t\t};\n\t\t}\n\t\tconst vistos = new Set<string>();\n\t\tfor (const linea of crudo.split(\"\\n\").filter(Boolean)) {\n\t\t\tlet entrada: EntradaLeida;\n\t\t\ttry {\n\t\t\t\tentrada = JSON.parse(linea) as EntradaLeida;\n\t\t\t} catch {\n\t\t\t\treturn {\n\t\t\t\t\testado: \"alterado\",\n\t\t\t\t\tvalid: false,\n\t\t\t\t\tentriesChecked: comprobadas,\n\t\t\t\t\tcausa: \"editada\",\n\t\t\t\t\tmotivo: \"hay una línea que no es JSON válido\",\n\t\t\t\t\tficheroAlterado: nombre,\n\t\t\t\t\t...(borrados.length ? { borrados } : {}),\n\t\t\t\t};\n\t\t\t}\n\t\t\tconst { hash, prevHash: declarado, ...carga } = entrada;\n\t\t\t// Dos preguntas distintas que antes iban juntas y contestaban lo mismo:\n\t\t\t//\n\t\t\t//   · ¿el hash cuadra con SU PROPIO contenido? -> la han editado.\n\t\t\t//   · ¿su `prevHash` apunta a la anterior?     -> faltan entradas o\n\t\t\t//     están cambiadas de orden.\n\t\t\tif (typeof hash !== \"string\" || hash !== rehash(declarado ?? null, carga)) {\n\t\t\t\treturn {\n\t\t\t\t\testado: \"alterado\",\n\t\t\t\t\tvalid: false,\n\t\t\t\t\tentriesChecked: comprobadas,\n\t\t\t\t\ttamperedAt: entrada.ts,\n\t\t\t\t\tcausa: \"editada\",\n\t\t\t\t\tmotivo: \"el hash de una entrada no cuadra con su contenido: la han editado\",\n\t\t\t\t\tficheroAlterado: nombre,\n\t\t\t\t\t...(borrados.length ? { borrados } : {}),\n\t\t\t\t};\n\t\t\t}\n\t\t\tif ((declarado ?? null) !== prevHash) {\n\t\t\t\t// Un enlace roto DESPUÉS de una ausencia ya conocida no es un\n\t\t\t\t// hallazgo nuevo: es su consecuencia. Se sigue leyendo para poder\n\t\t\t\t// contar lo que queda, y la causa se decide al final.\n\t\t\t\tif (borrados.length === 0 && incompletos.length === 0) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\testado: \"alterado\",\n\t\t\t\t\t\tvalid: false,\n\t\t\t\t\t\tentriesChecked: comprobadas,\n\t\t\t\t\t\ttamperedAt: entrada.ts,\n\t\t\t\t\t\tcausa: \"enlace-roto\",\n\t\t\t\t\t\tmotivo:\n\t\t\t\t\t\t\t\"el enlace de una entrada no apunta a la anterior: faltan entradas o están cambiadas de orden\",\n\t\t\t\t\t\tficheroAlterado: nombre,\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t}\n\t\t\tvistos.add(hash);\n\t\t\tprevHash = hash;\n\t\t\tcomprobadas++;\n\t\t}\n\t\t// La resta que la cadena no puede hacer: lo que el índice recuerda y el\n\t\t// fichero ya no enseña. Cubre el truncado, el truncado-y-seguir-\n\t\t// escribiendo, y la entrada quitada del medio.\n\t\tif (anclados) {\n\t\t\tconst faltan = anclados.filter((h) => !vistos.has(h)).length;\n\t\t\tif (faltan > 0) incompletos.push({ fichero: nombre, entradas: anclados.length, faltan });\n\t\t}\n\t}\n\n\tif (borrados.length > 0 || incompletos.length > 0) {\n\t\tconst soloBorrados = incompletos.length === 0;\n\t\treturn {\n\t\t\testado: \"alterado\",\n\t\t\tvalid: false,\n\t\t\tentriesChecked: comprobadas,\n\t\t\tcausa: soloBorrados ? \"borrado\" : \"faltan-entradas\",\n\t\t\tmotivo: soloBorrados\n\t\t\t\t? \"el índice recuerda ficheros que ya no están: los han borrado\"\n\t\t\t\t: \"faltan entradas que el índice recuerda haber escrito: las han quitado del registro\",\n\t\t\t...(borrados.length ? { borrados } : {}),\n\t\t\t...(incompletos.length ? { incompletos } : {}),\n\t\t\t...(sinAncla.length ? { sinAncla } : {}),\n\t\t};\n\t}\n\n\t// Un registro con ancla y sin entradas todavía sigue siendo un registro\n\t// vacío: `estado: \"vacio\"` y no `\"integro\"`, para que la respuesta no\n\t// dependa de si el índice llegó a crearse antes de la primera entrada.\n\treturn {\n\t\testado: comprobadas === 0 ? \"vacio\" : \"integro\",\n\t\tvalid: true,\n\t\tentriesChecked: comprobadas,\n\t\t...(sinAncla.length ? { sinAncla } : {}),\n\t};\n}\n"]}

package/dist/core/memory-engine/audit.d.ts

@@ -7,6 +7,7 @@
  * detectable by re-verifying the chain (enterprise security auditing).
  */
 import { existsSync } from "node:fs";
+import { type VeredictoDelRegistro } from "./audit-indice.ts";
 export interface AuditEntry {
     seq: number;
     ts: string;
@@ -23,6 +24,8 @@ export interface AuditEntry {
 }
 export declare class AuditLog {
     private dir;
+    /** La raíz, porque el índice vive FUERA de `audit/`. Ver `audit-indice.ts`. */
+    private raiz;
     private seq;
     private lastHash;
     constructor(rootDir: string);
@@ -35,12 +38,21 @@ export declare class AuditLog {
     }): Promise<void>;
     /** Read the most recent entries across audit files. */
     read(limit?: number, since?: string): Promise<AuditEntry[]>;
-    /** Verify the hash chain. Returns the first tampered entry, or null. */
-    verify(): Promise<{
-        valid: boolean;
-        tamperedAt?: string;
-        entriesChecked: number;
-    }>;
+    /**
+     * Verifica el registro y contesta TRES estados: íntegro, alterado y vacío.
+     *
+     * El recorrido de la cadena vive ahora en `audit-indice.ts` junto a lo que le
+     * faltaba —el registro de lo que DEBERÍA existir—, porque separarlos era el
+     * agujero: la cadena de hashes prueba integridad DENTRO de lo que hay y no
+     * puede, por construcción, hablar de lo que ya no está. Aquí se queda solo la
+     * canonicalización, que es lo único que tiene que compartir con `append` y no
+     * puede divergir de ella.
+     *
+     * Medido: con esto, borrar el fichero pasa de `{valid:true, entriesChecked:0}`
+     * a `{estado:"alterado"}` nombrando lo que falta, y una instalación nueva pasa
+     * de `{valid:false}` —acusar a toda instalación limpia— a `{estado:"vacio"}`.
+     */
+    verify(): Promise<VeredictoDelRegistro>;
     get lastSeq(): number;
 }
 export { existsSync };

package/dist/core/memory-engine/audit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../../src/core/memory-engine/audit.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGrC,MAAM,WAAW,UAAU;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,KAAK,GAAG,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,aAAa,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,WAAW,CAAC;IACzI,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,GAAG,KAAK,CAAC;IAC9D,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,OAAO,CAAC;IACZ,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAOD,qBAAa,QAAQ;IACpB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,QAAQ,CAAuB;IAEvC,YAAY,OAAO,EAAE,MAAM,EAE1B;IAED,OAAO,CAAC,OAAO;IAIf,4EAA4E;IACtE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CA0B1B;IAEK,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,KAAK,GAAG,IAAI,GAAG,MAAM,GAAG,UAAU,CAAC,GAAG;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAwBvH;IAED,uDAAuD;IACjD,IAAI,CAAC,KAAK,SAAK,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CA2B5D;IAED,wEAAwE;IAClE,MAAM,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CAsCvF;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;CACD;AAED,OAAO,EAAE,UAAU,EAAE,CAAC","sourcesContent":["/**\n * Audit log for the Ada Memory Engine — append-only JSONL with a hash chain.\n *\n * Every memory write, rejection, consolidation and (optionally) search is\n * recorded with: timestamp, actor, target, outcome and reason. Each entry\n * carries the hash of the previous entry, so tampering with any record is\n * detectable by re-verifying the chain (enterprise security auditing).\n */\n\nimport { createHash } from \"node:crypto\";\nimport { readFile, writeFile, appendFile, mkdir } from \"node:fs/promises\";\nimport { existsSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\nexport interface AuditEntry {\n\tseq: number;\n\tts: string; // ISO\n\taction: \"add\" | \"replace\" | \"remove\" | \"rejected\" | \"consolidate\" | \"search\" | \"migrate\" | \"flush\" | \"review\" | \"detected\" | \"vault-use\";\n\tsource: \"agent\" | \"user\" | \"auto\" | \"cli\" | \"desktop\" | \"api\";\n\ttarget: string; // global | user | project | failure | session\n\tscope: string; // project hash or \"global\"\n\tsessionId?: string;\n\tok: boolean;\n\tcategories?: string[];\n\treason?: string;\n\thash: string;\n\tprevHash: string | null;\n}\n\nfunction hashEntry(prevHash: string | null, payload: Omit<AuditEntry, \"hash\" | \"prevHash\">): string {\n\tconst canonical = JSON.stringify({ prevHash, ...payload });\n\treturn createHash(\"sha256\").update(canonical).digest(\"hex\");\n}\n\nexport class AuditLog {\n\tprivate dir: string;\n\tprivate seq = 0;\n\tprivate lastHash: string | null = null;\n\n\tconstructor(rootDir: string) {\n\t\tthis.dir = join(rootDir, \"audit\");\n\t}\n\n\tprivate fileFor(date: string): string {\n\t\treturn join(this.dir, `audit-${date}.jsonl`);\n\t}\n\n\t/** Load the latest sequence number + hash from the newest existing file. */\n\tasync load(): Promise<void> {\n\t\ttry {\n\t\t\tawait mkdir(this.dir, { recursive: true });\n\t\t} catch {\n\t\t\treturn;\n\t\t}\n\t\t// Find the most recent audit file.\n\t\tlet latest: string | null = null;\n\t\ttry {\n\t\t\tconst { readdir } = await import(\"node:fs/promises\");\n\t\t\tconst files = (await readdir(this.dir)).filter((f) => /^audit-\\d{4}-\\d{2}-\\d{2}\\.jsonl$/.test(f)).sort();\n\t\t\tlatest = files.length > 0 ? files[files.length - 1] : null;\n\t\t} catch {\n\t\t\treturn;\n\t\t}\n\t\tif (!latest) return;\n\t\ttry {\n\t\t\tconst raw = await readFile(join(this.dir, latest), \"utf-8\");\n\t\t\tconst lines = raw.split(\"\\n\").filter(Boolean);\n\t\t\tif (lines.length === 0) return;\n\t\t\tconst last = JSON.parse(lines[lines.length - 1]) as AuditEntry;\n\t\t\tthis.seq = typeof last.seq === \"number\" ? last.seq : 0;\n\t\t\tthis.lastHash = typeof last.hash === \"string\" ? last.hash : null;\n\t\t} catch {\n\t\t\t// Corrupt tail: restart sequence (previous records remain intact).\n\t\t}\n\t}\n\n\tasync append(entry: Omit<AuditEntry, \"seq\" | \"ts\" | \"hash\" | \"prevHash\"> & { ts?: string; seq?: number }): Promise<void> {\n\t\ttry {\n\t\t\tconst date = new Date().toISOString().slice(0, 10);\n\t\t\tconst file = this.fileFor(date);\n\t\t\tawait mkdir(this.dir, { recursive: true });\n\t\t\tconst payload = {\n\t\t\t\tseq: entry.seq ?? ++this.seq,\n\t\t\t\tts: entry.ts ?? new Date().toISOString(),\n\t\t\t\taction: entry.action,\n\t\t\t\tsource: entry.source,\n\t\t\t\ttarget: entry.target,\n\t\t\t\tscope: entry.scope,\n\t\t\t\tok: entry.ok,\n\t\t\t\tcategories: entry.categories,\n\t\t\t\treason: entry.reason,\n\t\t\t\tsessionId: entry.sessionId,\n\t\t\t};\n\t\t\tconst hash = hashEntry(this.lastHash, payload);\n\t\t\tconst full: AuditEntry = { ...payload, hash, prevHash: this.lastHash };\n\t\t\tthis.lastHash = hash;\n\t\t\tawait appendFile(file, `${JSON.stringify(full)}\\n`, \"utf-8\");\n\t\t} catch {\n\t\t\t// Audit must never break the conversation.\n\t\t}\n\t}\n\n\t/** Read the most recent entries across audit files. */\n\tasync read(limit = 50, since?: string): Promise<AuditEntry[]> {\n\t\ttry {\n\t\t\tconst { readdir } = await import(\"node:fs/promises\");\n\t\t\tconst files = (await readdir(this.dir)).filter((f) => /^audit-.*\\.jsonl$/.test(f)).sort().reverse();\n\t\t\tconst out: AuditEntry[] = [];\n\t\t\tfor (const file of files) {\n\t\t\t\ttry {\n\t\t\t\t\tconst raw = await readFile(join(this.dir, file), \"utf-8\");\n\t\t\t\t\tconst lines = raw.split(\"\\n\").filter(Boolean);\n\t\t\t\t\tfor (const line of lines.reverse()) {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst entry = JSON.parse(line) as AuditEntry;\n\t\t\t\t\t\t\tif (since && entry.ts < since) continue;\n\t\t\t\t\t\t\tout.push(entry);\n\t\t\t\t\t\t\tif (out.length >= limit) return out;\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} catch {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn out;\n\t\t} catch {\n\t\t\treturn [];\n\t\t}\n\t}\n\n\t/** Verify the hash chain. Returns the first tampered entry, or null. */\n\tasync verify(): Promise<{ valid: boolean; tamperedAt?: string; entriesChecked: number }> {\n\t\ttry {\n\t\t\tconst { readdir } = await import(\"node:fs/promises\");\n\t\t\tconst files = (await readdir(this.dir)).filter((f) => /^audit-.*\\.jsonl$/.test(f)).sort();\n\t\t\tlet prevHash: string | null = null;\n\t\t\tlet checked = 0;\n\t\t\tfor (const file of files) {\n\t\t\t\tconst raw = await readFile(join(this.dir, file), \"utf-8\");\n\t\t\t\tfor (const line of raw.split(\"\\n\").filter(Boolean)) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tconst entry = JSON.parse(line) as AuditEntry;\n\t\t\t\t\t\tconst payload = {\n\t\t\t\t\t\t\tseq: entry.seq,\n\t\t\t\t\t\t\tts: entry.ts,\n\t\t\t\t\t\t\taction: entry.action,\n\t\t\t\t\t\t\tsource: entry.source,\n\t\t\t\t\t\t\ttarget: entry.target,\n\t\t\t\t\t\t\tscope: entry.scope,\n\t\t\t\t\t\t\tok: entry.ok,\n\t\t\t\t\t\t\tcategories: entry.categories,\n\t\t\t\t\t\t\treason: entry.reason,\n\t\t\t\t\t\t\tsessionId: entry.sessionId,\n\t\t\t\t\t\t};\n\t\t\t\t\t\tconst expected = hashEntry(prevHash, payload);\n\t\t\t\t\t\tif (entry.hash !== expected || entry.prevHash !== prevHash) {\n\t\t\t\t\t\t\treturn { valid: false, tamperedAt: entry.ts, entriesChecked: checked };\n\t\t\t\t\t\t}\n\t\t\t\t\t\tprevHash = entry.hash;\n\t\t\t\t\t\tchecked++;\n\t\t\t\t\t} catch {\n\t\t\t\t\t\treturn { valid: false, tamperedAt: undefined, entriesChecked: checked };\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn { valid: true, entriesChecked: checked };\n\t\t} catch {\n\t\t\treturn { valid: false, entriesChecked: 0 };\n\t\t}\n\t}\n\n\tget lastSeq(): number {\n\t\treturn this.seq;\n\t}\n}\n\nexport { existsSync };\n"]}
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../../src/core/memory-engine/audit.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGrC,OAAO,EAA4B,KAAK,oBAAoB,EAAqB,MAAM,mBAAmB,CAAC;AAE3G,MAAM,WAAW,UAAU;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EACH,KAAK,GACL,SAAS,GACT,QAAQ,GACR,UAAU,GACV,aAAa,GACb,QAAQ,GACR,SAAS,GACT,OAAO,GACP,QAAQ,GACR,UAAU,GACV,WAAW,CAAC;IACf,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,GAAG,KAAK,CAAC;IAC9D,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,OAAO,CAAC;IACZ,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAOD,qBAAa,QAAQ;IACpB,OAAO,CAAC,GAAG,CAAS;IACpB,iFAA+E;IAC/E,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,QAAQ,CAAuB;IAEvC,YAAY,OAAO,EAAE,MAAM,EAG1B;IAED,OAAO,CAAC,OAAO;IAIf,4EAA4E;IACtE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CA0B1B;IAEK,MAAM,CACX,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,KAAK,GAAG,IAAI,GAAG,MAAM,GAAG,UAAU,CAAC,GAAG;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,GACzF,OAAO,CAAC,IAAI,CAAC,CA4Bf;IAED,uDAAuD;IACjD,IAAI,CAAC,KAAK,SAAK,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CA0B5D;IAED;;;;;;;;;;;;;OAaG;IACG,MAAM,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAE5C;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;CACD;AAED,OAAO,EAAE,UAAU,EAAE,CAAC","sourcesContent":["/**\n * Audit log for the Ada Memory Engine — append-only JSONL with a hash chain.\n *\n * Every memory write, rejection, consolidation and (optionally) search is\n * recorded with: timestamp, actor, target, outcome and reason. Each entry\n * carries the hash of the previous entry, so tampering with any record is\n * detectable by re-verifying the chain (enterprise security auditing).\n */\n\nimport { createHash } from \"node:crypto\";\nimport { existsSync } from \"node:fs\";\nimport { appendFile, mkdir, readFile } from \"node:fs/promises\";\nimport { basename, join } from \"node:path\";\nimport { anclarEntrada, DIR_AUDIT, type VeredictoDelRegistro, verificarRegistro } from \"./audit-indice.ts\";\n\nexport interface AuditEntry {\n\tseq: number;\n\tts: string; // ISO\n\taction:\n\t\t| \"add\"\n\t\t| \"replace\"\n\t\t| \"remove\"\n\t\t| \"rejected\"\n\t\t| \"consolidate\"\n\t\t| \"search\"\n\t\t| \"migrate\"\n\t\t| \"flush\"\n\t\t| \"review\"\n\t\t| \"detected\"\n\t\t| \"vault-use\";\n\tsource: \"agent\" | \"user\" | \"auto\" | \"cli\" | \"desktop\" | \"api\";\n\ttarget: string; // global | user | project | failure | session\n\tscope: string; // project hash or \"global\"\n\tsessionId?: string;\n\tok: boolean;\n\tcategories?: string[];\n\treason?: string;\n\thash: string;\n\tprevHash: string | null;\n}\n\nfunction hashEntry(prevHash: string | null, payload: Record<string, unknown>): string {\n\tconst canonical = JSON.stringify({ prevHash, ...payload });\n\treturn createHash(\"sha256\").update(canonical).digest(\"hex\");\n}\n\nexport class AuditLog {\n\tprivate dir: string;\n\t/** La raíz, porque el índice vive FUERA de `audit/`. Ver `audit-indice.ts`. */\n\tprivate raiz: string;\n\tprivate seq = 0;\n\tprivate lastHash: string | null = null;\n\n\tconstructor(rootDir: string) {\n\t\tthis.raiz = rootDir;\n\t\tthis.dir = join(rootDir, DIR_AUDIT);\n\t}\n\n\tprivate fileFor(date: string): string {\n\t\treturn join(this.dir, `audit-${date}.jsonl`);\n\t}\n\n\t/** Load the latest sequence number + hash from the newest existing file. */\n\tasync load(): Promise<void> {\n\t\ttry {\n\t\t\tawait mkdir(this.dir, { recursive: true });\n\t\t} catch {\n\t\t\treturn;\n\t\t}\n\t\t// Find the most recent audit file.\n\t\tlet latest: string | null = null;\n\t\ttry {\n\t\t\tconst { readdir } = await import(\"node:fs/promises\");\n\t\t\tconst files = (await readdir(this.dir)).filter((f) => /^audit-\\d{4}-\\d{2}-\\d{2}\\.jsonl$/.test(f)).sort();\n\t\t\tlatest = files.length > 0 ? files[files.length - 1] : null;\n\t\t} catch {\n\t\t\treturn;\n\t\t}\n\t\tif (!latest) return;\n\t\ttry {\n\t\t\tconst raw = await readFile(join(this.dir, latest), \"utf-8\");\n\t\t\tconst lines = raw.split(\"\\n\").filter(Boolean);\n\t\t\tif (lines.length === 0) return;\n\t\t\tconst last = JSON.parse(lines[lines.length - 1]) as AuditEntry;\n\t\t\tthis.seq = typeof last.seq === \"number\" ? last.seq : 0;\n\t\t\tthis.lastHash = typeof last.hash === \"string\" ? last.hash : null;\n\t\t} catch {\n\t\t\t// Corrupt tail: restart sequence (previous records remain intact).\n\t\t}\n\t}\n\n\tasync append(\n\t\tentry: Omit<AuditEntry, \"seq\" | \"ts\" | \"hash\" | \"prevHash\"> & { ts?: string; seq?: number },\n\t): Promise<void> {\n\t\ttry {\n\t\t\tconst date = new Date().toISOString().slice(0, 10);\n\t\t\tconst file = this.fileFor(date);\n\t\t\tawait mkdir(this.dir, { recursive: true });\n\t\t\tconst payload = {\n\t\t\t\tseq: entry.seq ?? ++this.seq,\n\t\t\t\tts: entry.ts ?? new Date().toISOString(),\n\t\t\t\taction: entry.action,\n\t\t\t\tsource: entry.source,\n\t\t\t\ttarget: entry.target,\n\t\t\t\tscope: entry.scope,\n\t\t\t\tok: entry.ok,\n\t\t\t\tcategories: entry.categories,\n\t\t\t\treason: entry.reason,\n\t\t\t\tsessionId: entry.sessionId,\n\t\t\t};\n\t\t\tconst hash = hashEntry(this.lastHash, payload);\n\t\t\tconst full: AuditEntry = { ...payload, hash, prevHash: this.lastHash };\n\t\t\tthis.lastHash = hash;\n\t\t\tawait appendFile(file, `${JSON.stringify(full)}\\n`, \"utf-8\");\n\t\t\t// DESPUÉS de la entrada, nunca antes: al revés, una caída entre las dos\n\t\t\t// escrituras dejaría un hash anclado sin entrada y `verify` acusaría de\n\t\t\t// manipulación a un corte de luz. Ver `audit-indice.ts`.\n\t\t\tawait anclarEntrada(this.raiz, basename(file), hash);\n\t\t} catch {\n\t\t\t// Audit must never break the conversation.\n\t\t}\n\t}\n\n\t/** Read the most recent entries across audit files. */\n\tasync read(limit = 50, since?: string): Promise<AuditEntry[]> {\n\t\ttry {\n\t\t\tconst { readdir } = await import(\"node:fs/promises\");\n\t\t\tconst files = (await readdir(this.dir))\n\t\t\t\t.filter((f) => /^audit-.*\\.jsonl$/.test(f))\n\t\t\t\t.sort()\n\t\t\t\t.reverse();\n\t\t\tconst out: AuditEntry[] = [];\n\t\t\tfor (const file of files) {\n\t\t\t\ttry {\n\t\t\t\t\tconst raw = await readFile(join(this.dir, file), \"utf-8\");\n\t\t\t\t\tconst lines = raw.split(\"\\n\").filter(Boolean);\n\t\t\t\t\tfor (const line of lines.reverse()) {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst entry = JSON.parse(line) as AuditEntry;\n\t\t\t\t\t\t\tif (since && entry.ts < since) continue;\n\t\t\t\t\t\t\tout.push(entry);\n\t\t\t\t\t\t\tif (out.length >= limit) return out;\n\t\t\t\t\t\t} catch {}\n\t\t\t\t\t}\n\t\t\t\t} catch {}\n\t\t\t}\n\t\t\treturn out;\n\t\t} catch {\n\t\t\treturn [];\n\t\t}\n\t}\n\n\t/**\n\t * Verifica el registro y contesta TRES estados: íntegro, alterado y vacío.\n\t *\n\t * El recorrido de la cadena vive ahora en `audit-indice.ts` junto a lo que le\n\t * faltaba —el registro de lo que DEBERÍA existir—, porque separarlos era el\n\t * agujero: la cadena de hashes prueba integridad DENTRO de lo que hay y no\n\t * puede, por construcción, hablar de lo que ya no está. Aquí se queda solo la\n\t * canonicalización, que es lo único que tiene que compartir con `append` y no\n\t * puede divergir de ella.\n\t *\n\t * Medido: con esto, borrar el fichero pasa de `{valid:true, entriesChecked:0}`\n\t * a `{estado:\"alterado\"}` nombrando lo que falta, y una instalación nueva pasa\n\t * de `{valid:false}` —acusar a toda instalación limpia— a `{estado:\"vacio\"}`.\n\t */\n\tasync verify(): Promise<VeredictoDelRegistro> {\n\t\treturn verificarRegistro(this.raiz, hashEntry);\n\t}\n\n\tget lastSeq(): number {\n\t\treturn this.seq;\n\t}\n}\n\nexport { existsSync };\n"]}

package/dist/core/memory-engine/audit.js

@@ -7,19 +7,23 @@
  * detectable by re-verifying the chain (enterprise security auditing).
  */
 import { createHash } from "node:crypto";
-import { readFile, appendFile, mkdir } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { anclarEntrada, DIR_AUDIT, verificarRegistro } from "./audit-indice.js";
 function hashEntry(prevHash, payload) {
     const canonical = JSON.stringify({ prevHash, ...payload });
     return createHash("sha256").update(canonical).digest("hex");
 }
 export class AuditLog {
     dir;
+    /** La raíz, porque el índice vive FUERA de `audit/`. Ver `audit-indice.ts`. */
+    raiz;
     seq = 0;
     lastHash = null;
     constructor(rootDir) {
-        this.dir = join(rootDir, "audit");
+        this.raiz = rootDir;
+        this.dir = join(rootDir, DIR_AUDIT);
     }
     fileFor(date) {
         return join(this.dir, `audit-${date}.jsonl`);
@@ -78,6 +82,10 @@ export class AuditLog {
             const full = { ...payload, hash, prevHash: this.lastHash };
             this.lastHash = hash;
             await appendFile(file, `${JSON.stringify(full)}\n`, "utf-8");
+            // DESPUÉS de la entrada, nunca antes: al revés, una caída entre las dos
+            // escrituras dejaría un hash anclado sin entrada y `verify` acusaría de
+            // manipulación a un corte de luz. Ver `audit-indice.ts`.
+            await anclarEntrada(this.raiz, basename(file), hash);
         }
         catch {
             // Audit must never break the conversation.
@@ -87,7 +95,10 @@ export class AuditLog {
     async read(limit = 50, since) {
         try {
             const { readdir } = await import("node:fs/promises");
-            const files = (await readdir(this.dir)).filter((f) => /^audit-.*\.jsonl$/.test(f)).sort().reverse();
+            const files = (await readdir(this.dir))
+                .filter((f) => /^audit-.*\.jsonl$/.test(f))
+                .sort()
+                .reverse();
             const out = [];
             for (const file of files) {
                 try {
@@ -102,14 +113,10 @@ export class AuditLog {
                             if (out.length >= limit)
                                 return out;
                         }
-                        catch {
-                            continue;
-                        }
+                        catch { }
                     }
                 }
-                catch {
-                    continue;
-                }
+                catch { }
             }
             return out;
         }
@@ -117,47 +124,22 @@ export class AuditLog {
             return [];
         }
     }
-    /** Verify the hash chain. Returns the first tampered entry, or null. */
+    /**
+     * Verifica el registro y contesta TRES estados: íntegro, alterado y vacío.
+     *
+     * El recorrido de la cadena vive ahora en `audit-indice.ts` junto a lo que le
+     * faltaba —el registro de lo que DEBERÍA existir—, porque separarlos era el
+     * agujero: la cadena de hashes prueba integridad DENTRO de lo que hay y no
+     * puede, por construcción, hablar de lo que ya no está. Aquí se queda solo la
+     * canonicalización, que es lo único que tiene que compartir con `append` y no
+     * puede divergir de ella.
+     *
+     * Medido: con esto, borrar el fichero pasa de `{valid:true, entriesChecked:0}`
+     * a `{estado:"alterado"}` nombrando lo que falta, y una instalación nueva pasa
+     * de `{valid:false}` —acusar a toda instalación limpia— a `{estado:"vacio"}`.
+     */
     async verify() {
-        try {
-            const { readdir } = await import("node:fs/promises");
-            const files = (await readdir(this.dir)).filter((f) => /^audit-.*\.jsonl$/.test(f)).sort();
-            let prevHash = null;
-            let checked = 0;
-            for (const file of files) {
-                const raw = await readFile(join(this.dir, file), "utf-8");
-                for (const line of raw.split("\n").filter(Boolean)) {
-                    try {
-                        const entry = JSON.parse(line);
-                        const payload = {
-                            seq: entry.seq,
-                            ts: entry.ts,
-                            action: entry.action,
-                            source: entry.source,
-                            target: entry.target,
-                            scope: entry.scope,
-                            ok: entry.ok,
-                            categories: entry.categories,
-                            reason: entry.reason,
-                            sessionId: entry.sessionId,
-                        };
-                        const expected = hashEntry(prevHash, payload);
-                        if (entry.hash !== expected || entry.prevHash !== prevHash) {
-                            return { valid: false, tamperedAt: entry.ts, entriesChecked: checked };
-                        }
-                        prevHash = entry.hash;
-                        checked++;
-                    }
-                    catch {
-                        return { valid: false, tamperedAt: undefined, entriesChecked: checked };
-                    }
-                }
-            }
-            return { valid: true, entriesChecked: checked };
-        }
-        catch {
-            return { valid: false, entriesChecked: 0 };
-        }
+        return verificarRegistro(this.raiz, hashEntry);
     }
     get lastSeq() {
         return this.seq;

package/dist/core/memory-engine/audit.js.map

@@ -1 +1 @@
-{"version":3,"file":"audit.js","sourceRoot":"","sources":["../../../src/core/memory-engine/audit.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Audit log for the Ada Memory Engine — append-only JSONL with a hash chain.\n *\n * Every memory write, rejection, consolidation and (optionally) search is\n * recorded with: timestamp, actor, target, outcome and reason. Each entry\n * carries the hash of the previous entry, so tampering with any record is\n * detectable by re-verifying the chain (enterprise security auditing).\n */\n\nimport { createHash } from \"node:crypto\";\nimport { readFile, writeFile, appendFile, mkdir } from \"node:fs/promises\";\nimport { existsSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\nexport interface AuditEntry {\n\tseq: number;\n\tts: string; // ISO\n\taction: \"add\" | \"replace\" | \"remove\" | \"rejected\" | \"consolidate\" | \"search\" | \"migrate\" | \"flush\" | \"review\" | \"detected\" | \"vault-use\";\n\tsource: \"agent\" | \"user\" | \"auto\" | \"cli\" | \"desktop\" | \"api\";\n\ttarget: string; // global | user | project | failure | session\n\tscope: string; // project hash or \"global\"\n\tsessionId?: string;\n\tok: boolean;\n\tcategories?: string[];\n\treason?: string;\n\thash: string;\n\tprevHash: string | null;\n}\n\nfunction hashEntry(prevHash: string | null, payload: Omit<AuditEntry, \"hash\" | \"prevHash\">): string {\n\tconst canonical = JSON.stringify({ prevHash, ...payload });\n\treturn createHash(\"sha256\").update(canonical).digest(\"hex\");\n}\n\nexport class AuditLog {\n\tprivate dir: string;\n\tprivate seq = 0;\n\tprivate lastHash: string | null = null;\n\n\tconstructor(rootDir: string) {\n\t\tthis.dir = join(rootDir, \"audit\");\n\t}\n\n\tprivate fileFor(date: string): string {\n\t\treturn join(this.dir, `audit-${date}.jsonl`);\n\t}\n\n\t/** Load the latest sequence number + hash from the newest existing file. */\n\tasync load(): Promise<void> {\n\t\ttry {\n\t\t\tawait mkdir(this.dir, { recursive: true });\n\t\t} catch {\n\t\t\treturn;\n\t\t}\n\t\t// Find the most recent audit file.\n\t\tlet latest: string | null = null;\n\t\ttry {\n\t\t\tconst { readdir } = await import(\"node:fs/promises\");\n\t\t\tconst files = (await readdir(this.dir)).filter((f) => /^audit-\\d{4}-\\d{2}-\\d{2}\\.jsonl$/.test(f)).sort();\n\t\t\tlatest = files.length > 0 ? files[files.length - 1] : null;\n\t\t} catch {\n\t\t\treturn;\n\t\t}\n\t\tif (!latest) return;\n\t\ttry {\n\t\t\tconst raw = await readFile(join(this.dir, latest), \"utf-8\");\n\t\t\tconst lines = raw.split(\"\\n\").filter(Boolean);\n\t\t\tif (lines.length === 0) return;\n\t\t\tconst last = JSON.parse(lines[lines.length - 1]) as AuditEntry;\n\t\t\tthis.seq = typeof last.seq === \"number\" ? last.seq : 0;\n\t\t\tthis.lastHash = typeof last.hash === \"string\" ? last.hash : null;\n\t\t} catch {\n\t\t\t// Corrupt tail: restart sequence (previous records remain intact).\n\t\t}\n\t}\n\n\tasync append(entry: Omit<AuditEntry, \"seq\" | \"ts\" | \"hash\" | \"prevHash\"> & { ts?: string; seq?: number }): Promise<void> {\n\t\ttry {\n\t\t\tconst date = new Date().toISOString().slice(0, 10);\n\t\t\tconst file = this.fileFor(date);\n\t\t\tawait mkdir(this.dir, { recursive: true });\n\t\t\tconst payload = {\n\t\t\t\tseq: entry.seq ?? ++this.seq,\n\t\t\t\tts: entry.ts ?? new Date().toISOString(),\n\t\t\t\taction: entry.action,\n\t\t\t\tsource: entry.source,\n\t\t\t\ttarget: entry.target,\n\t\t\t\tscope: entry.scope,\n\t\t\t\tok: entry.ok,\n\t\t\t\tcategories: entry.categories,\n\t\t\t\treason: entry.reason,\n\t\t\t\tsessionId: entry.sessionId,\n\t\t\t};\n\t\t\tconst hash = hashEntry(this.lastHash, payload);\n\t\t\tconst full: AuditEntry = { ...payload, hash, prevHash: this.lastHash };\n\t\t\tthis.lastHash = hash;\n\t\t\tawait appendFile(file, `${JSON.stringify(full)}\\n`, \"utf-8\");\n\t\t} catch {\n\t\t\t// Audit must never break the conversation.\n\t\t}\n\t}\n\n\t/** Read the most recent entries across audit files. */\n\tasync read(limit = 50, since?: string): Promise<AuditEntry[]> {\n\t\ttry {\n\t\t\tconst { readdir } = await import(\"node:fs/promises\");\n\t\t\tconst files = (await readdir(this.dir)).filter((f) => /^audit-.*\\.jsonl$/.test(f)).sort().reverse();\n\t\t\tconst out: AuditEntry[] = [];\n\t\t\tfor (const file of files) {\n\t\t\t\ttry {\n\t\t\t\t\tconst raw = await readFile(join(this.dir, file), \"utf-8\");\n\t\t\t\t\tconst lines = raw.split(\"\\n\").filter(Boolean);\n\t\t\t\t\tfor (const line of lines.reverse()) {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst entry = JSON.parse(line) as AuditEntry;\n\t\t\t\t\t\t\tif (since && entry.ts < since) continue;\n\t\t\t\t\t\t\tout.push(entry);\n\t\t\t\t\t\t\tif (out.length >= limit) return out;\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} catch {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn out;\n\t\t} catch {\n\t\t\treturn [];\n\t\t}\n\t}\n\n\t/** Verify the hash chain. Returns the first tampered entry, or null. */\n\tasync verify(): Promise<{ valid: boolean; tamperedAt?: string; entriesChecked: number }> {\n\t\ttry {\n\t\t\tconst { readdir } = await import(\"node:fs/promises\");\n\t\t\tconst files = (await readdir(this.dir)).filter((f) => /^audit-.*\\.jsonl$/.test(f)).sort();\n\t\t\tlet prevHash: string | null = null;\n\t\t\tlet checked = 0;\n\t\t\tfor (const file of files) {\n\t\t\t\tconst raw = await readFile(join(this.dir, file), \"utf-8\");\n\t\t\t\tfor (const line of raw.split(\"\\n\").filter(Boolean)) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tconst entry = JSON.parse(line) as AuditEntry;\n\t\t\t\t\t\tconst payload = {\n\t\t\t\t\t\t\tseq: entry.seq,\n\t\t\t\t\t\t\tts: entry.ts,\n\t\t\t\t\t\t\taction: entry.action,\n\t\t\t\t\t\t\tsource: entry.source,\n\t\t\t\t\t\t\ttarget: entry.target,\n\t\t\t\t\t\t\tscope: entry.scope,\n\t\t\t\t\t\t\tok: entry.ok,\n\t\t\t\t\t\t\tcategories: entry.categories,\n\t\t\t\t\t\t\treason: entry.reason,\n\t\t\t\t\t\t\tsessionId: entry.sessionId,\n\t\t\t\t\t\t};\n\t\t\t\t\t\tconst expected = hashEntry(prevHash, payload);\n\t\t\t\t\t\tif (entry.hash !== expected || entry.prevHash !== prevHash) {\n\t\t\t\t\t\t\treturn { valid: false, tamperedAt: entry.ts, entriesChecked: checked };\n\t\t\t\t\t\t}\n\t\t\t\t\t\tprevHash = entry.hash;\n\t\t\t\t\t\tchecked++;\n\t\t\t\t\t} catch {\n\t\t\t\t\t\treturn { valid: false, tamperedAt: undefined, entriesChecked: checked };\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn { valid: true, entriesChecked: checked };\n\t\t} catch {\n\t\t\treturn { valid: false, entriesChecked: 0 };\n\t\t}\n\t}\n\n\tget lastSeq(): number {\n\t\treturn this.seq;\n\t}\n}\n\nexport { existsSync };\n"]}
+{"version":3,"file":"audit.js","sourceRoot":"","sources":["../../../src/core/memory-engine/audit.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Audit log for the Ada Memory Engine — append-only JSONL with a hash chain.\n *\n * Every memory write, rejection, consolidation and (optionally) search is\n * recorded with: timestamp, actor, target, outcome and reason. Each entry\n * carries the hash of the previous entry, so tampering with any record is\n * detectable by re-verifying the chain (enterprise security auditing).\n */\n\nimport { createHash } from \"node:crypto\";\nimport { existsSync } from \"node:fs\";\nimport { appendFile, mkdir, readFile } from \"node:fs/promises\";\nimport { basename, join } from \"node:path\";\nimport { anclarEntrada, DIR_AUDIT, type VeredictoDelRegistro, verificarRegistro } from \"./audit-indice.ts\";\n\nexport interface AuditEntry {\n\tseq: number;\n\tts: string; // ISO\n\taction:\n\t\t| \"add\"\n\t\t| \"replace\"\n\t\t| \"remove\"\n\t\t| \"rejected\"\n\t\t| \"consolidate\"\n\t\t| \"search\"\n\t\t| \"migrate\"\n\t\t| \"flush\"\n\t\t| \"review\"\n\t\t| \"detected\"\n\t\t| \"vault-use\";\n\tsource: \"agent\" | \"user\" | \"auto\" | \"cli\" | \"desktop\" | \"api\";\n\ttarget: string; // global | user | project | failure | session\n\tscope: string; // project hash or \"global\"\n\tsessionId?: string;\n\tok: boolean;\n\tcategories?: string[];\n\treason?: string;\n\thash: string;\n\tprevHash: string | null;\n}\n\nfunction hashEntry(prevHash: string | null, payload: Record<string, unknown>): string {\n\tconst canonical = JSON.stringify({ prevHash, ...payload });\n\treturn createHash(\"sha256\").update(canonical).digest(\"hex\");\n}\n\nexport class AuditLog {\n\tprivate dir: string;\n\t/** La raíz, porque el índice vive FUERA de `audit/`. Ver `audit-indice.ts`. */\n\tprivate raiz: string;\n\tprivate seq = 0;\n\tprivate lastHash: string | null = null;\n\n\tconstructor(rootDir: string) {\n\t\tthis.raiz = rootDir;\n\t\tthis.dir = join(rootDir, DIR_AUDIT);\n\t}\n\n\tprivate fileFor(date: string): string {\n\t\treturn join(this.dir, `audit-${date}.jsonl`);\n\t}\n\n\t/** Load the latest sequence number + hash from the newest existing file. */\n\tasync load(): Promise<void> {\n\t\ttry {\n\t\t\tawait mkdir(this.dir, { recursive: true });\n\t\t} catch {\n\t\t\treturn;\n\t\t}\n\t\t// Find the most recent audit file.\n\t\tlet latest: string | null = null;\n\t\ttry {\n\t\t\tconst { readdir } = await import(\"node:fs/promises\");\n\t\t\tconst files = (await readdir(this.dir)).filter((f) => /^audit-\\d{4}-\\d{2}-\\d{2}\\.jsonl$/.test(f)).sort();\n\t\t\tlatest = files.length > 0 ? files[files.length - 1] : null;\n\t\t} catch {\n\t\t\treturn;\n\t\t}\n\t\tif (!latest) return;\n\t\ttry {\n\t\t\tconst raw = await readFile(join(this.dir, latest), \"utf-8\");\n\t\t\tconst lines = raw.split(\"\\n\").filter(Boolean);\n\t\t\tif (lines.length === 0) return;\n\t\t\tconst last = JSON.parse(lines[lines.length - 1]) as AuditEntry;\n\t\t\tthis.seq = typeof last.seq === \"number\" ? last.seq : 0;\n\t\t\tthis.lastHash = typeof last.hash === \"string\" ? last.hash : null;\n\t\t} catch {\n\t\t\t// Corrupt tail: restart sequence (previous records remain intact).\n\t\t}\n\t}\n\n\tasync append(\n\t\tentry: Omit<AuditEntry, \"seq\" | \"ts\" | \"hash\" | \"prevHash\"> & { ts?: string; seq?: number },\n\t): Promise<void> {\n\t\ttry {\n\t\t\tconst date = new Date().toISOString().slice(0, 10);\n\t\t\tconst file = this.fileFor(date);\n\t\t\tawait mkdir(this.dir, { recursive: true });\n\t\t\tconst payload = {\n\t\t\t\tseq: entry.seq ?? ++this.seq,\n\t\t\t\tts: entry.ts ?? new Date().toISOString(),\n\t\t\t\taction: entry.action,\n\t\t\t\tsource: entry.source,\n\t\t\t\ttarget: entry.target,\n\t\t\t\tscope: entry.scope,\n\t\t\t\tok: entry.ok,\n\t\t\t\tcategories: entry.categories,\n\t\t\t\treason: entry.reason,\n\t\t\t\tsessionId: entry.sessionId,\n\t\t\t};\n\t\t\tconst hash = hashEntry(this.lastHash, payload);\n\t\t\tconst full: AuditEntry = { ...payload, hash, prevHash: this.lastHash };\n\t\t\tthis.lastHash = hash;\n\t\t\tawait appendFile(file, `${JSON.stringify(full)}\\n`, \"utf-8\");\n\t\t\t// DESPUÉS de la entrada, nunca antes: al revés, una caída entre las dos\n\t\t\t// escrituras dejaría un hash anclado sin entrada y `verify` acusaría de\n\t\t\t// manipulación a un corte de luz. Ver `audit-indice.ts`.\n\t\t\tawait anclarEntrada(this.raiz, basename(file), hash);\n\t\t} catch {\n\t\t\t// Audit must never break the conversation.\n\t\t}\n\t}\n\n\t/** Read the most recent entries across audit files. */\n\tasync read(limit = 50, since?: string): Promise<AuditEntry[]> {\n\t\ttry {\n\t\t\tconst { readdir } = await import(\"node:fs/promises\");\n\t\t\tconst files = (await readdir(this.dir))\n\t\t\t\t.filter((f) => /^audit-.*\\.jsonl$/.test(f))\n\t\t\t\t.sort()\n\t\t\t\t.reverse();\n\t\t\tconst out: AuditEntry[] = [];\n\t\t\tfor (const file of files) {\n\t\t\t\ttry {\n\t\t\t\t\tconst raw = await readFile(join(this.dir, file), \"utf-8\");\n\t\t\t\t\tconst lines = raw.split(\"\\n\").filter(Boolean);\n\t\t\t\t\tfor (const line of lines.reverse()) {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst entry = JSON.parse(line) as AuditEntry;\n\t\t\t\t\t\t\tif (since && entry.ts < since) continue;\n\t\t\t\t\t\t\tout.push(entry);\n\t\t\t\t\t\t\tif (out.length >= limit) return out;\n\t\t\t\t\t\t} catch {}\n\t\t\t\t\t}\n\t\t\t\t} catch {}\n\t\t\t}\n\t\t\treturn out;\n\t\t} catch {\n\t\t\treturn [];\n\t\t}\n\t}\n\n\t/**\n\t * Verifica el registro y contesta TRES estados: íntegro, alterado y vacío.\n\t *\n\t * El recorrido de la cadena vive ahora en `audit-indice.ts` junto a lo que le\n\t * faltaba —el registro de lo que DEBERÍA existir—, porque separarlos era el\n\t * agujero: la cadena de hashes prueba integridad DENTRO de lo que hay y no\n\t * puede, por construcción, hablar de lo que ya no está. Aquí se queda solo la\n\t * canonicalización, que es lo único que tiene que compartir con `append` y no\n\t * puede divergir de ella.\n\t *\n\t * Medido: con esto, borrar el fichero pasa de `{valid:true, entriesChecked:0}`\n\t * a `{estado:\"alterado\"}` nombrando lo que falta, y una instalación nueva pasa\n\t * de `{valid:false}` —acusar a toda instalación limpia— a `{estado:\"vacio\"}`.\n\t */\n\tasync verify(): Promise<VeredictoDelRegistro> {\n\t\treturn verificarRegistro(this.raiz, hashEntry);\n\t}\n\n\tget lastSeq(): number {\n\t\treturn this.seq;\n\t}\n}\n\nexport { existsSync };\n"]}