@hoilab/ada-cli 0.84.22 → 0.85.1

package/dist/core/compactar/registro-denso.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Registro denso: reescribir el historial que se va a compactar como una lista
+ * de HECHOS extraídos literalmente de los turnos, en lugar de un resumen en
+ * prosa escrito por el modelo.
+ *
+ * Por qué existe esto:
+ *
+ * 1. La prosa es cara por token. Un resumen de 4.000 caracteres de la sesión
+ *    real guardada en `test/fixtures/before-compaction.jsonl` gasta la mayor
+ *    parte de su presupuesto en conectores ("The user wants to...", "Note
+ *    that...") que no se pueden verificar contra nada.
+ * 2. La prosa PUEDE INVENTAR. Un resumen generado por un modelo puede afirmar
+ *    que una prueba pasó cuando no pasó, y a partir de ese momento la sesión
+ *    entera trabaja sobre una mentira que nadie puede rastrear. Aquí cada línea
+ *    del registro sale de un turno concreto y `verificarProcedencia()` lo
+ *    comprueba carácter a carácter contra el mensaje de origen.
+ * 3. Comprimir lo ya comprimido degrada en cascada: pedirle al modelo que
+ *    resuma su propio resumen pierde algo en cada vuelta. Aquí el registro
+ *    anterior se ABSORBE tal cual (`absorberRegistro`), no se vuelve a resumir.
+ *
+ * El precio, dicho claramente: no hay síntesis. Este registro no escribe
+ * "decidimos usar bcrypt porque sha1 es inseguro"; escribe la petición del
+ * usuario y el comando que se ejecutó, literales. A cambio, no puede mentir.
+ */
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+/**
+ * Clase de hecho. El orden importa poco; lo que importa es el peso (ver PESO),
+ * que decide qué se cae primero cuando no hay presupuesto.
+ */
+export type ClaseHecho = 
+/** Petición del usuario, literal. */
+"pet"
+/** Comando de shell ejecutado. */
+ | "cmd"
+/** Primera línea de la salida de una herramienta o comando. */
+ | "sal"
+/** Resultado de herramienta marcado como error, o comando con exit != 0. */
+ | "err"
+/** Fichero leído. */
+ | "lee"
+/** Fichero escrito entero. */
+ | "esc"
+/** Fichero editado. */
+ | "ed"
+/** Otra herramienta invocada. */
+ | "her"
+/** Texto del asistente (primera línea). */
+ | "dijo";
+export interface Hecho {
+    /** Índice del mensaje de origen dentro del lote que se está comprimiendo. */
+    turno: number;
+    clase: ClaseHecho;
+    /**
+     * Texto literal. INVARIANTE: `nucleo(texto)` es siempre una subcadena de
+     * `serializarTurno(mensajes[turno])` cuando `heredado` es falso. De ahí sale
+     * la puerta de procedencia.
+     */
+    texto: string;
+    /**
+     * Verdadero si el hecho viene de un registro anterior absorbido. Su
+     * procedencia se fijó en la compactación que lo produjo; no se puede
+     * comprobar contra los mensajes de ESTE lote (que ya no los contienen).
+     */
+    heredado?: boolean;
+}
+/** Texto de un hecho sin la marca de truncado: lo que debe estar en el origen. */
+export declare function nucleo(texto: string): string;
+/**
+ * Texto canónico de un turno: TODO lo que se puede citar de él, aplanado.
+ *
+ * Incluye los argumentos de las tool calls dos veces (el JSON completo y cada
+ * valor de cadena por separado) a propósito: `JSON.stringify` escapa los saltos
+ * de línea, así que un comando multilínea no aparecería como subcadena del
+ * JSON. Sin el valor crudo, `verificarProcedencia` rechazaría hechos correctos.
+ */
+export declare function serializarTurno(mensaje: AgentMessage): string;
+/**
+ * Extrae los hechos de un lote de mensajes.
+ *
+ * Devuelve `[]` cuando NO HAY nada que extraer (lote vacío, o solo mensajes sin
+ * contenido citable). Eso es distinto de "no puedo": aquí siempre se puede,
+ * porque no hay ni red ni modelo de por medio. Quien decide qué hacer con un
+ * registro vacío es `compactarADenso`, que en ese caso devuelve `null` y deja
+ * que la compactación en prosa haga su trabajo.
+ */
+export declare function extraerHechos(mensajes: AgentMessage[]): Hecho[];
+/** Estimación de tokens con la misma heurística que usa la compactación (chars/4). */
+export declare function tokensDeTexto(texto: string): number;
+export interface RegistroFormateado {
+    texto: string;
+    incluidos: Hecho[];
+    omitidos: Hecho[];
+}
+/**
+ * Formatea los hechos como bloque de registro, respetando un presupuesto de
+ * tokens.
+ *
+ * Cuando no caben todos se caen primero los de menor peso (lecturas, prosa del
+ * asistente) y NUNCA en silencio: la última línea dice cuántos se han quitado y
+ * de qué clase. Un registro recortado que no lo dijera se leería como "esto es
+ * todo lo que pasó", que es exactamente el fallo que se lee como éxito.
+ *
+ * `omitidosPrevios` es la cuenta que YA declaraba el registro anterior de la
+ * cascada, y se suma al total. Sin ese arrastre el aviso duraba una sola vuelta:
+ * medido, la 1ª compactación decía "[omitidos 49 hechos]" y la 2ª —con
+ * presupuesto de sobra, sin nada nuevo que quitar— salía sin aviso ninguno. El
+ * registro volvía a leerse como "esto es todo lo que pasó" con 49 hechos ya
+ * perdidos, que es justo lo que este aviso existe para impedir.
+ */
+export declare function formatearRegistro(hechos: Hecho[], presupuestoTokens: number, omitidosPrevios?: number): RegistroFormateado;
+/**
+ * Cuántos hechos declara haber perdido un registro YA ESCRITO. Devuelve 0 si el
+ * texto no es un registro o si el registro no declara ninguna pérdida.
+ *
+ * Existe porque `absorberRegistro` solo recupera las líneas de hecho: el aviso
+ * de recorte no es un hecho y se quedaba fuera, así que la cuenta de lo perdido
+ * moría en la vuelta siguiente de la cascada. Ver `formatearRegistro`.
+ */
+export declare function omitidosDeRegistro(texto: string): number;
+/**
+ * Lee un bloque de registro denso de un texto.
+ *
+ * Tres estados, no dos:
+ * - `null`  → NO ES un registro denso (prosa, o texto sin el bloque). "No lo he
+ *             mirado" no aplica aquí, pero "esto no es lo mío" sí, y no se puede
+ *             confundir con "el registro estaba vacío".
+ * - `[]`    → es un registro denso y NO TIENE hechos.
+ * - `[...]` → los hechos, marcados como heredados.
+ */
+export declare function absorberRegistro(texto: string): Hecho[] | null;
+export interface Procedencia {
+    /** Hechos cuyo texto aparece literalmente en su turno de origen. */
+    validos: Hecho[];
+    /** Hechos que NO aparecen en su turno, o cuyo turno no existe. Inventados. */
+    invalidos: Hecho[];
+    /**
+     * Hechos heredados de un registro anterior. NO son inválidos: su origen está
+     * en un lote que ya no tenemos delante. Se cuentan aparte a propósito, para
+     * no leer "no lo puedo comprobar aquí" como "es válido".
+     */
+    heredados: Hecho[];
+}
+/**
+ * Comprueba que cada hecho se puede rastrear a su turno.
+ *
+ * Esta es la puerta que impide que el registro invente: un hecho cuyo texto no
+ * esté, carácter a carácter, en el mensaje que dice ser su origen, sale por
+ * `invalidos`.
+ */
+export declare function verificarProcedencia(hechos: Hecho[], mensajes: AgentMessage[]): Procedencia;
+/**
+ * Construye el registro denso de un lote, absorbiendo el registro anterior si
+ * lo hay.
+ *
+ * `resumenAnterior` es el resumen de la compactación previa. Si ya era un
+ * registro denso, sus líneas se conservan TAL CUAL (no se re-resumen): esa es
+ * la diferencia entre encadenar compactaciones y degradarlas en cascada.
+ */
+export declare function reescribirADenso(mensajes: AgentMessage[], presupuestoTokens: number, resumenAnterior?: string): RegistroFormateado;
+//# sourceMappingURL=registro-denso.d.ts.map

package/dist/core/compactar/registro-denso.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registro-denso.d.ts","sourceRoot":"","sources":["../../../src/core/compactar/registro-denso.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAMlE;;;GAGG;AACH,MAAM,MAAM,UAAU;AACrB,qCAAqC;AACnC,KAAK;AACP,kCAAkC;GAChC,KAAK;AACP,+DAA+D;GAC7D,KAAK;AACP,4EAA4E;GAC1E,KAAK;AACP,qBAAqB;GACnB,KAAK;AACP,8BAA8B;GAC5B,KAAK;AACP,uBAAuB;GACrB,IAAI;AACN,iCAAiC;GAC/B,KAAK;AACP,2CAA2C;GACzC,MAAM,CAAC;AAEV,MAAM,WAAW,KAAK;IACrB,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;IAClB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AA2BD,kFAAkF;AAClF,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE5C;AAuCD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAyC7D;AAwDD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,KAAK,EAAE,CA6D/D;AAMD,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD;AAuHD,MAAM,WAAW,kBAAkB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,KAAK,EAAE,CAAC;IACnB,QAAQ,EAAE,KAAK,EAAE,CAAC;CAClB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,iBAAiB,EAAE,MAAM,EAAE,eAAe,SAAI,GAAG,kBAAkB,CAuDrH;AA6CD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASxD;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,GAAG,IAAI,CA4B9D;AAMD,MAAM,WAAW,WAAW;IAC3B,oEAAoE;IACpE,OAAO,EAAE,KAAK,EAAE,CAAC;IACjB,8EAA8E;IAC9E,SAAS,EAAE,KAAK,EAAE,CAAC;IACnB;;;;OAIG;IACH,SAAS,EAAE,KAAK,EAAE,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,WAAW,CAoC3F;AAMD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC/B,QAAQ,EAAE,YAAY,EAAE,EACxB,iBAAiB,EAAE,MAAM,EACzB,eAAe,CAAC,EAAE,MAAM,GACtB,kBAAkB,CAQpB"}