@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/compactar/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Compactación a registro denso.
+ *
+ * Punto de entrada que usa la sesión: toma la `CompactionPreparation` (lo que
+ * upstream ya calculó sobre qué se descarta y qué se conserva) y produce un
+ * registro de hechos, sin llamar al modelo y sin poder inventar.
+ *
+ * Por qué el registro se AÑADE al resumen en prosa en vez de sustituirlo
+ * (`anadirRegistroDenso`): sustituirlo dejaba 12 pruebas de upstream en rojo, y
+ * no por capricho suyo — la prosa es el único camino por el que pasan los
+ * reintentos de summarización (#6647), la `usage` que alimenta el contador de
+ * coste de la sesión y la baseUrl resuelta por auth (#6768). Matar ese camino
+ * para ahorrar tokens sale caro: se pierde la síntesis (los "Next Steps", el
+ * porqué de una decisión) y se pierde la contabilidad. Sumar los dos cabe de
+ * sobra en el presupuesto que upstream YA reserva para el resumen: en la sesión
+ * real la prosa gastó 1.073 de los 13.107 tokens disponibles.
+ */
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { CompactionPreparation, CompactionResult } from "../compaction/compaction.ts";
+export * from "./registro-denso.ts";
+/**
+ * Mensajes del lote en el mismo orden en que se numeran los turnos del
+ * registro. Se expone porque las pruebas de procedencia necesitan exactamente
+ * este array: si aquí y en `compactarADenso` se ordenaran distinto, la puerta
+ * de procedencia comprobaría contra los turnos equivocados.
+ */
+export declare function mensajesDelLote(preparation: CompactionPreparation): AgentMessage[];
+/**
+ * Construye SOLO el registro denso de un lote, sin prosa.
+ *
+ * Devuelve `null` cuando no hay ni un hecho que registrar, o cuando no queda
+ * presupuesto para escribirlo. Quien llama se queda con la prosa a secas.
+ *
+ * OJO: `null` NO distingue "no hay hechos" de "no cabe" — son dos cosas
+ * distintas y aquí salen por la misma puerta. Es deliberado y es lo único que
+ * puede serlo: el consumidor (`anadirRegistroDenso`) hace lo mismo en los dos
+ * casos, devolver la prosa intacta. Lo que el registro NO puede hacer es callar
+ * un recorte PARCIAL, y eso no pasa por aquí: lo anuncia `formatearRegistro`
+ * con su línea `[omitidos N hechos por presupuesto: ...]`.
+ */
+export declare function compactarADenso(preparation: CompactionPreparation, presupuestoTokens?: number): CompactionResult | null;
+/**
+ * Añade el registro denso al resultado de la compactación en prosa.
+ *
+ * Este es el punto que llama `AgentSession._runDefaultCompaction`. Si no cabe o
+ * no hay hechos, devuelve el resultado TAL CUAL: la compactación nunca falla ni
+ * se degrada por culpa del registro. `usage`, `details` y `firstKeptEntryId` de
+ * la prosa se respetan — el registro no toca la contabilidad de tokens porque
+ * no ha gastado ninguno.
+ */
+export declare function anadirRegistroDenso(resultado: CompactionResult, preparation: CompactionPreparation): CompactionResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/compactar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/compactar/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAI3F,cAAc,qBAAqB,CAAC;AAEpC;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,qBAAqB,GAAG,YAAY,EAAE,CAElF;AAeD;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC9B,WAAW,EAAE,qBAAqB,EAClC,iBAAiB,SAAgC,GAC/C,gBAAgB,GAAG,IAAI,CAoBzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,EAAE,WAAW,EAAE,qBAAqB,GAAG,gBAAgB,CAKrH","sourcesContent":["/**\n * Compactación a registro denso.\n *\n * Punto de entrada que usa la sesión: toma la `CompactionPreparation` (lo que\n * upstream ya calculó sobre qué se descarta y qué se conserva) y produce un\n * registro de hechos, sin llamar al modelo y sin poder inventar.\n *\n * Por qué el registro se AÑADE al resumen en prosa en vez de sustituirlo\n * (`anadirRegistroDenso`): sustituirlo dejaba 12 pruebas de upstream en rojo, y\n * no por capricho suyo — la prosa es el único camino por el que pasan los\n * reintentos de summarización (#6647), la `usage` que alimenta el contador de\n * coste de la sesión y la baseUrl resuelta por auth (#6768). Matar ese camino\n * para ahorrar tokens sale caro: se pierde la síntesis (los \"Next Steps\", el\n * porqué de una decisión) y se pierde la contabilidad. Sumar los dos cabe de\n * sobra en el presupuesto que upstream YA reserva para el resumen: en la sesión\n * real la prosa gastó 1.073 de los 13.107 tokens disponibles.\n */\n\nimport type { AgentMessage } from \"@earendil-works/pi-agent-core\";\nimport type { CompactionPreparation, CompactionResult } from \"../compaction/compaction.ts\";\nimport { computeFileLists } from \"../compaction/utils.ts\";\nimport { reescribirADenso, tokensDeTexto } from \"./registro-denso.ts\";\n\nexport * from \"./registro-denso.ts\";\n\n/**\n * Mensajes del lote en el mismo orden en que se numeran los turnos del\n * registro. Se expone porque las pruebas de procedencia necesitan exactamente\n * este array: si aquí y en `compactarADenso` se ordenaran distinto, la puerta\n * de procedencia comprobaría contra los turnos equivocados.\n */\nexport function mensajesDelLote(preparation: CompactionPreparation): AgentMessage[] {\n\treturn [...preparation.messagesToSummarize, ...preparation.turnPrefixMessages];\n}\n\n/**\n * Techo de tokens del resumen completo: el mismo que `generateSummaryWithUsage`\n * le da a la prosa (0,8 * reserveTokens). El registro se queda con lo que la\n * prosa no haya gastado, así que el resumen entero nunca crece por encima de lo\n * que upstream ya reservaba.\n */\nfunction presupuestoTotal(preparation: CompactionPreparation): number {\n\treturn Math.floor(0.8 * preparation.settings.reserveTokens);\n}\n\n/** Por debajo de esto no cabe ni la cabecera del bloque: no vale la pena. */\nconst MINIMO_UTIL = 40;\n\n/**\n * Construye SOLO el registro denso de un lote, sin prosa.\n *\n * Devuelve `null` cuando no hay ni un hecho que registrar, o cuando no queda\n * presupuesto para escribirlo. Quien llama se queda con la prosa a secas.\n *\n * OJO: `null` NO distingue \"no hay hechos\" de \"no cabe\" — son dos cosas\n * distintas y aquí salen por la misma puerta. Es deliberado y es lo único que\n * puede serlo: el consumidor (`anadirRegistroDenso`) hace lo mismo en los dos\n * casos, devolver la prosa intacta. Lo que el registro NO puede hacer es callar\n * un recorte PARCIAL, y eso no pasa por aquí: lo anuncia `formatearRegistro`\n * con su línea `[omitidos N hechos por presupuesto: ...]`.\n */\nexport function compactarADenso(\n\tpreparation: CompactionPreparation,\n\tpresupuestoTokens = presupuestoTotal(preparation),\n): CompactionResult | null {\n\tconst mensajes = mensajesDelLote(preparation);\n\tif (mensajes.length === 0) return null;\n\tif (presupuestoTokens < MINIMO_UTIL) return null;\n\n\tconst registro = reescribirADenso(mensajes, presupuestoTokens, preparation.previousSummary);\n\tif (registro.incluidos.length === 0) return null;\n\n\t// Las listas de ficheros siguen yendo en `details` aunque el registro ya\n\t// nombre cada fichero: upstream las reinyecta en la SIGUIENTE compactación\n\t// (`extractFileOperations`), y romper esa cadena perdería los ficheros de\n\t// hace dos compactaciones.\n\tconst { readFiles, modifiedFiles } = computeFileLists(preparation.fileOps);\n\n\treturn {\n\t\tsummary: registro.texto,\n\t\tfirstKeptEntryId: preparation.firstKeptEntryId,\n\t\ttokensBefore: preparation.tokensBefore,\n\t\tdetails: { readFiles, modifiedFiles },\n\t};\n}\n\n/**\n * Añade el registro denso al resultado de la compactación en prosa.\n *\n * Este es el punto que llama `AgentSession._runDefaultCompaction`. Si no cabe o\n * no hay hechos, devuelve el resultado TAL CUAL: la compactación nunca falla ni\n * se degrada por culpa del registro. `usage`, `details` y `firstKeptEntryId` de\n * la prosa se respetan — el registro no toca la contabilidad de tokens porque\n * no ha gastado ninguno.\n */\nexport function anadirRegistroDenso(resultado: CompactionResult, preparation: CompactionPreparation): CompactionResult {\n\tconst restante = presupuestoTotal(preparation) - tokensDeTexto(resultado.summary);\n\tconst denso = compactarADenso(preparation, restante);\n\tif (!denso) return resultado;\n\treturn { ...resultado, summary: `${resultado.summary}\\n\\n${denso.summary}` };\n}\n"]}

package/dist/core/compactar/index.js

@@ -0,0 +1,91 @@
+/**
+ * Compactación a registro denso.
+ *
+ * Punto de entrada que usa la sesión: toma la `CompactionPreparation` (lo que
+ * upstream ya calculó sobre qué se descarta y qué se conserva) y produce un
+ * registro de hechos, sin llamar al modelo y sin poder inventar.
+ *
+ * Por qué el registro se AÑADE al resumen en prosa en vez de sustituirlo
+ * (`anadirRegistroDenso`): sustituirlo dejaba 12 pruebas de upstream en rojo, y
+ * no por capricho suyo — la prosa es el único camino por el que pasan los
+ * reintentos de summarización (#6647), la `usage` que alimenta el contador de
+ * coste de la sesión y la baseUrl resuelta por auth (#6768). Matar ese camino
+ * para ahorrar tokens sale caro: se pierde la síntesis (los "Next Steps", el
+ * porqué de una decisión) y se pierde la contabilidad. Sumar los dos cabe de
+ * sobra en el presupuesto que upstream YA reserva para el resumen: en la sesión
+ * real la prosa gastó 1.073 de los 13.107 tokens disponibles.
+ */
+import { computeFileLists } from "../compaction/utils.js";
+import { reescribirADenso, tokensDeTexto } from "./registro-denso.js";
+export * from "./registro-denso.js";
+/**
+ * Mensajes del lote en el mismo orden en que se numeran los turnos del
+ * registro. Se expone porque las pruebas de procedencia necesitan exactamente
+ * este array: si aquí y en `compactarADenso` se ordenaran distinto, la puerta
+ * de procedencia comprobaría contra los turnos equivocados.
+ */
+export function mensajesDelLote(preparation) {
+    return [...preparation.messagesToSummarize, ...preparation.turnPrefixMessages];
+}
+/**
+ * Techo de tokens del resumen completo: el mismo que `generateSummaryWithUsage`
+ * le da a la prosa (0,8 * reserveTokens). El registro se queda con lo que la
+ * prosa no haya gastado, así que el resumen entero nunca crece por encima de lo
+ * que upstream ya reservaba.
+ */
+function presupuestoTotal(preparation) {
+    return Math.floor(0.8 * preparation.settings.reserveTokens);
+}
+/** Por debajo de esto no cabe ni la cabecera del bloque: no vale la pena. */
+const MINIMO_UTIL = 40;
+/**
+ * Construye SOLO el registro denso de un lote, sin prosa.
+ *
+ * Devuelve `null` cuando no hay ni un hecho que registrar, o cuando no queda
+ * presupuesto para escribirlo. Quien llama se queda con la prosa a secas.
+ *
+ * OJO: `null` NO distingue "no hay hechos" de "no cabe" — son dos cosas
+ * distintas y aquí salen por la misma puerta. Es deliberado y es lo único que
+ * puede serlo: el consumidor (`anadirRegistroDenso`) hace lo mismo en los dos
+ * casos, devolver la prosa intacta. Lo que el registro NO puede hacer es callar
+ * un recorte PARCIAL, y eso no pasa por aquí: lo anuncia `formatearRegistro`
+ * con su línea `[omitidos N hechos por presupuesto: ...]`.
+ */
+export function compactarADenso(preparation, presupuestoTokens = presupuestoTotal(preparation)) {
+    const mensajes = mensajesDelLote(preparation);
+    if (mensajes.length === 0)
+        return null;
+    if (presupuestoTokens < MINIMO_UTIL)
+        return null;
+    const registro = reescribirADenso(mensajes, presupuestoTokens, preparation.previousSummary);
+    if (registro.incluidos.length === 0)
+        return null;
+    // Las listas de ficheros siguen yendo en `details` aunque el registro ya
+    // nombre cada fichero: upstream las reinyecta en la SIGUIENTE compactación
+    // (`extractFileOperations`), y romper esa cadena perdería los ficheros de
+    // hace dos compactaciones.
+    const { readFiles, modifiedFiles } = computeFileLists(preparation.fileOps);
+    return {
+        summary: registro.texto,
+        firstKeptEntryId: preparation.firstKeptEntryId,
+        tokensBefore: preparation.tokensBefore,
+        details: { readFiles, modifiedFiles },
+    };
+}
+/**
+ * Añade el registro denso al resultado de la compactación en prosa.
+ *
+ * Este es el punto que llama `AgentSession._runDefaultCompaction`. Si no cabe o
+ * no hay hechos, devuelve el resultado TAL CUAL: la compactación nunca falla ni
+ * se degrada por culpa del registro. `usage`, `details` y `firstKeptEntryId` de
+ * la prosa se respetan — el registro no toca la contabilidad de tokens porque
+ * no ha gastado ninguno.
+ */
+export function anadirRegistroDenso(resultado, preparation) {
+    const restante = presupuestoTotal(preparation) - tokensDeTexto(resultado.summary);
+    const denso = compactarADenso(preparation, restante);
+    if (!denso)
+        return resultado;
+    return { ...resultado, summary: `${resultado.summary}\n\n${denso.summary}` };
+}
+//# sourceMappingURL=index.js.map

package/dist/core/compactar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/compactar/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEtE,cAAc,qBAAqB,CAAC;AAEpC;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,WAAkC,EAAkB;IACnF,OAAO,CAAC,GAAG,WAAW,CAAC,mBAAmB,EAAE,GAAG,WAAW,CAAC,kBAAkB,CAAC,CAAC;AAAA,CAC/E;AAED;;;;;GAKG;AACH,SAAS,gBAAgB,CAAC,WAAkC,EAAU;IACrE,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,WAAW,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;AAAA,CAC5D;AAED,6EAA6E;AAC7E,MAAM,WAAW,GAAG,EAAE,CAAC;AAEvB;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,eAAe,CAC9B,WAAkC,EAClC,iBAAiB,GAAG,gBAAgB,CAAC,WAAW,CAAC,EACvB;IAC1B,MAAM,QAAQ,GAAG,eAAe,CAAC,WAAW,CAAC,CAAC;IAC9C,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACvC,IAAI,iBAAiB,GAAG,WAAW;QAAE,OAAO,IAAI,CAAC;IAEjD,MAAM,QAAQ,GAAG,gBAAgB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,WAAW,CAAC,eAAe,CAAC,CAAC;IAC5F,IAAI,QAAQ,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEjD,yEAAyE;IACzE,4EAA2E;IAC3E,2EAA0E;IAC1E,2BAA2B;IAC3B,MAAM,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,gBAAgB,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IAE3E,OAAO;QACN,OAAO,EAAE,QAAQ,CAAC,KAAK;QACvB,gBAAgB,EAAE,WAAW,CAAC,gBAAgB;QAC9C,YAAY,EAAE,WAAW,CAAC,YAAY;QACtC,OAAO,EAAE,EAAE,SAAS,EAAE,aAAa,EAAE;KACrC,CAAC;AAAA,CACF;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAAC,SAA2B,EAAE,WAAkC,EAAoB;IACtH,MAAM,QAAQ,GAAG,gBAAgB,CAAC,WAAW,CAAC,GAAG,aAAa,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAClF,MAAM,KAAK,GAAG,eAAe,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;IACrD,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7B,OAAO,EAAE,GAAG,SAAS,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC,OAAO,OAAO,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;AAAA,CAC7E","sourcesContent":["/**\n * Compactación a registro denso.\n *\n * Punto de entrada que usa la sesión: toma la `CompactionPreparation` (lo que\n * upstream ya calculó sobre qué se descarta y qué se conserva) y produce un\n * registro de hechos, sin llamar al modelo y sin poder inventar.\n *\n * Por qué el registro se AÑADE al resumen en prosa en vez de sustituirlo\n * (`anadirRegistroDenso`): sustituirlo dejaba 12 pruebas de upstream en rojo, y\n * no por capricho suyo — la prosa es el único camino por el que pasan los\n * reintentos de summarización (#6647), la `usage` que alimenta el contador de\n * coste de la sesión y la baseUrl resuelta por auth (#6768). Matar ese camino\n * para ahorrar tokens sale caro: se pierde la síntesis (los \"Next Steps\", el\n * porqué de una decisión) y se pierde la contabilidad. Sumar los dos cabe de\n * sobra en el presupuesto que upstream YA reserva para el resumen: en la sesión\n * real la prosa gastó 1.073 de los 13.107 tokens disponibles.\n */\n\nimport type { AgentMessage } from \"@earendil-works/pi-agent-core\";\nimport type { CompactionPreparation, CompactionResult } from \"../compaction/compaction.ts\";\nimport { computeFileLists } from \"../compaction/utils.ts\";\nimport { reescribirADenso, tokensDeTexto } from \"./registro-denso.ts\";\n\nexport * from \"./registro-denso.ts\";\n\n/**\n * Mensajes del lote en el mismo orden en que se numeran los turnos del\n * registro. Se expone porque las pruebas de procedencia necesitan exactamente\n * este array: si aquí y en `compactarADenso` se ordenaran distinto, la puerta\n * de procedencia comprobaría contra los turnos equivocados.\n */\nexport function mensajesDelLote(preparation: CompactionPreparation): AgentMessage[] {\n\treturn [...preparation.messagesToSummarize, ...preparation.turnPrefixMessages];\n}\n\n/**\n * Techo de tokens del resumen completo: el mismo que `generateSummaryWithUsage`\n * le da a la prosa (0,8 * reserveTokens). El registro se queda con lo que la\n * prosa no haya gastado, así que el resumen entero nunca crece por encima de lo\n * que upstream ya reservaba.\n */\nfunction presupuestoTotal(preparation: CompactionPreparation): number {\n\treturn Math.floor(0.8 * preparation.settings.reserveTokens);\n}\n\n/** Por debajo de esto no cabe ni la cabecera del bloque: no vale la pena. */\nconst MINIMO_UTIL = 40;\n\n/**\n * Construye SOLO el registro denso de un lote, sin prosa.\n *\n * Devuelve `null` cuando no hay ni un hecho que registrar, o cuando no queda\n * presupuesto para escribirlo. Quien llama se queda con la prosa a secas.\n *\n * OJO: `null` NO distingue \"no hay hechos\" de \"no cabe\" — son dos cosas\n * distintas y aquí salen por la misma puerta. Es deliberado y es lo único que\n * puede serlo: el consumidor (`anadirRegistroDenso`) hace lo mismo en los dos\n * casos, devolver la prosa intacta. Lo que el registro NO puede hacer es callar\n * un recorte PARCIAL, y eso no pasa por aquí: lo anuncia `formatearRegistro`\n * con su línea `[omitidos N hechos por presupuesto: ...]`.\n */\nexport function compactarADenso(\n\tpreparation: CompactionPreparation,\n\tpresupuestoTokens = presupuestoTotal(preparation),\n): CompactionResult | null {\n\tconst mensajes = mensajesDelLote(preparation);\n\tif (mensajes.length === 0) return null;\n\tif (presupuestoTokens < MINIMO_UTIL) return null;\n\n\tconst registro = reescribirADenso(mensajes, presupuestoTokens, preparation.previousSummary);\n\tif (registro.incluidos.length === 0) return null;\n\n\t// Las listas de ficheros siguen yendo en `details` aunque el registro ya\n\t// nombre cada fichero: upstream las reinyecta en la SIGUIENTE compactación\n\t// (`extractFileOperations`), y romper esa cadena perdería los ficheros de\n\t// hace dos compactaciones.\n\tconst { readFiles, modifiedFiles } = computeFileLists(preparation.fileOps);\n\n\treturn {\n\t\tsummary: registro.texto,\n\t\tfirstKeptEntryId: preparation.firstKeptEntryId,\n\t\ttokensBefore: preparation.tokensBefore,\n\t\tdetails: { readFiles, modifiedFiles },\n\t};\n}\n\n/**\n * Añade el registro denso al resultado de la compactación en prosa.\n *\n * Este es el punto que llama `AgentSession._runDefaultCompaction`. Si no cabe o\n * no hay hechos, devuelve el resultado TAL CUAL: la compactación nunca falla ni\n * se degrada por culpa del registro. `usage`, `details` y `firstKeptEntryId` de\n * la prosa se respetan — el registro no toca la contabilidad de tokens porque\n * no ha gastado ninguno.\n */\nexport function anadirRegistroDenso(resultado: CompactionResult, preparation: CompactionPreparation): CompactionResult {\n\tconst restante = presupuestoTotal(preparation) - tokensDeTexto(resultado.summary);\n\tconst denso = compactarADenso(preparation, restante);\n\tif (!denso) return resultado;\n\treturn { ...resultado, summary: `${resultado.summary}\\n\\n${denso.summary}` };\n}\n"]}

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,sCAAqC;AACnC,KAAK;AACP,kCAAkC;GAChC,KAAK;AACP,gEAA+D;GAC7D,KAAK;AACP,4EAA4E;GAC1E,KAAK;AACP,sBAAqB;GACnB,KAAK;AACP,8BAA8B;GAC5B,KAAK;AACP,uBAAuB;GACrB,IAAI;AACN,iCAAiC;GAC/B,KAAK;AACP,4CAA2C;GACzC,MAAM,CAAC;AAEV,MAAM,WAAW,KAAK;IACrB,+EAA6E;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,yFAAsF;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","sourcesContent":["/**\n * Registro denso: reescribir el historial que se va a compactar como una lista\n * de HECHOS extraídos literalmente de los turnos, en lugar de un resumen en\n * prosa escrito por el modelo.\n *\n * Por qué existe esto:\n *\n * 1. La prosa es cara por token. Un resumen de 4.000 caracteres de la sesión\n *    real guardada en `test/fixtures/before-compaction.jsonl` gasta la mayor\n *    parte de su presupuesto en conectores (\"The user wants to...\", \"Note\n *    that...\") que no se pueden verificar contra nada.\n * 2. La prosa PUEDE INVENTAR. Un resumen generado por un modelo puede afirmar\n *    que una prueba pasó cuando no pasó, y a partir de ese momento la sesión\n *    entera trabaja sobre una mentira que nadie puede rastrear. Aquí cada línea\n *    del registro sale de un turno concreto y `verificarProcedencia()` lo\n *    comprueba carácter a carácter contra el mensaje de origen.\n * 3. Comprimir lo ya comprimido degrada en cascada: pedirle al modelo que\n *    resuma su propio resumen pierde algo en cada vuelta. Aquí el registro\n *    anterior se ABSORBE tal cual (`absorberRegistro`), no se vuelve a resumir.\n *\n * El precio, dicho claramente: no hay síntesis. Este registro no escribe\n * \"decidimos usar bcrypt porque sha1 es inseguro\"; escribe la petición del\n * usuario y el comando que se ejecutó, literales. A cambio, no puede mentir.\n */\n\nimport type { AgentMessage } from \"@earendil-works/pi-agent-core\";\n\n// ============================================================================\n// Tipos\n// ============================================================================\n\n/**\n * Clase de hecho. El orden importa poco; lo que importa es el peso (ver PESO),\n * que decide qué se cae primero cuando no hay presupuesto.\n */\nexport type ClaseHecho =\n\t/** Petición del usuario, literal. */\n\t| \"pet\"\n\t/** Comando de shell ejecutado. */\n\t| \"cmd\"\n\t/** Primera línea de la salida de una herramienta o comando. */\n\t| \"sal\"\n\t/** Resultado de herramienta marcado como error, o comando con exit != 0. */\n\t| \"err\"\n\t/** Fichero leído. */\n\t| \"lee\"\n\t/** Fichero escrito entero. */\n\t| \"esc\"\n\t/** Fichero editado. */\n\t| \"ed\"\n\t/** Otra herramienta invocada. */\n\t| \"her\"\n\t/** Texto del asistente (primera línea). */\n\t| \"dijo\";\n\nexport interface Hecho {\n\t/** Índice del mensaje de origen dentro del lote que se está comprimiendo. */\n\tturno: number;\n\tclase: ClaseHecho;\n\t/**\n\t * Texto literal. INVARIANTE: `nucleo(texto)` es siempre una subcadena de\n\t * `serializarTurno(mensajes[turno])` cuando `heredado` es falso. De ahí sale\n\t * la puerta de procedencia.\n\t */\n\ttexto: string;\n\t/**\n\t * Verdadero si el hecho viene de un registro anterior absorbido. Su\n\t * procedencia se fijó en la compactación que lo produjo; no se puede\n\t * comprobar contra los mensajes de ESTE lote (que ya no los contienen).\n\t */\n\theredado?: boolean;\n}\n\n/** Peso: más alto = se conserva más tiempo cuando falta presupuesto. */\nconst PESO: Record<ClaseHecho, number> = {\n\terr: 100,\n\tpet: 95,\n\ted: 90,\n\tesc: 90,\n\tcmd: 80,\n\tsal: 50,\n\ther: 40,\n\tlee: 30,\n\tdijo: 20,\n};\n\n/** Marca de truncado. Se quita antes de comparar con el origen (ver `nucleo`). */\nconst ELIPSIS = \"…\";\n\nconst MARCA_ABRE = \"<registro-denso>\";\nconst MARCA_CIERRA = \"</registro-denso>\";\n\n/**\n * Aviso de recorte de un registro YA ESCRITO. Solo se lee el total; el detalle\n * por clases describe la vuelta en que se escribió y no se reconstruye.\n */\nconst RE_OMITIDOS = /^\\[omitidos (\\d+) hechos? por presupuesto:/;\n\n/** Texto de un hecho sin la marca de truncado: lo que debe estar en el origen. */\nexport function nucleo(texto: string): string {\n\treturn texto.endsWith(ELIPSIS) ? texto.slice(0, -ELIPSIS.length) : texto;\n}\n\n// ============================================================================\n// Normalización\n// ============================================================================\n\n/**\n * Colapsa todos los espacios en blanco a un solo espacio y recorta.\n *\n * Es idempotente y distributiva sobre el salto de línea\n * (`aplanar(a + \"\\n\" + b) === aplanar(a) + \" \" + aplanar(b)` con a y b no\n * vacíos), que es justo lo que hace que \"primera línea aplanada\" siga siendo\n * un prefijo del turno aplanado entero. Sin esa propiedad la puerta de\n * procedencia daría falsos negativos en cuanto un comando llevara un salto.\n */\nfunction aplanar(texto: string): string {\n\treturn texto.replace(/\\s+/g, \" \").trim();\n}\n\nfunction recortar(texto: string, maxChars: number): string {\n\tconst plano = aplanar(texto);\n\tif (plano.length <= maxChars) return plano;\n\treturn plano.slice(0, maxChars) + ELIPSIS;\n}\n\n/** Texto de un contenido que puede ser cadena o bloques. */\nfunction textoDeContenido(contenido: unknown): string {\n\tif (typeof contenido === \"string\") return contenido;\n\tif (!Array.isArray(contenido)) return \"\";\n\tconst partes: string[] = [];\n\tfor (const bloque of contenido) {\n\t\tif (bloque && typeof bloque === \"object\" && (bloque as { type?: string }).type === \"text\") {\n\t\t\tconst t = (bloque as { text?: string }).text;\n\t\t\tif (typeof t === \"string\") partes.push(t);\n\t\t}\n\t}\n\treturn partes.join(\"\\n\");\n}\n\n/**\n * Texto canónico de un turno: TODO lo que se puede citar de él, aplanado.\n *\n * Incluye los argumentos de las tool calls dos veces (el JSON completo y cada\n * valor de cadena por separado) a propósito: `JSON.stringify` escapa los saltos\n * de línea, así que un comando multilínea no aparecería como subcadena del\n * JSON. Sin el valor crudo, `verificarProcedencia` rechazaría hechos correctos.\n */\nexport function serializarTurno(mensaje: AgentMessage): string {\n\tconst partes: string[] = [];\n\tconst msg = mensaje;\n\n\tswitch (msg.role) {\n\t\tcase \"user\":\n\t\tcase \"custom\":\n\t\t\tpartes.push(textoDeContenido(msg.content));\n\t\t\tbreak;\n\t\tcase \"toolResult\":\n\t\t\tpartes.push(textoDeContenido(msg.content));\n\t\t\tpartes.push(msg.toolName);\n\t\t\tbreak;\n\t\tcase \"assistant\": {\n\t\t\tfor (const bloque of msg.content) {\n\t\t\t\tif (bloque.type === \"text\") partes.push(bloque.text);\n\t\t\t\telse if (bloque.type === \"thinking\") partes.push(bloque.thinking);\n\t\t\t\telse if (bloque.type === \"toolCall\") {\n\t\t\t\t\tpartes.push(bloque.name);\n\t\t\t\t\tconst args = bloque.arguments as Record<string, unknown> | undefined;\n\t\t\t\t\tif (args) {\n\t\t\t\t\t\tpartes.push(JSON.stringify(args));\n\t\t\t\t\t\tfor (const valor of Object.values(args)) {\n\t\t\t\t\t\t\tif (typeof valor === \"string\") partes.push(valor);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\tcase \"bashExecution\":\n\t\t\tpartes.push(msg.command);\n\t\t\tpartes.push(msg.output);\n\t\t\tbreak;\n\t\tcase \"branchSummary\":\n\t\tcase \"compactionSummary\":\n\t\t\tpartes.push(msg.summary);\n\t\t\tbreak;\n\t}\n\n\treturn aplanar(partes.join(\"\\n\"));\n}\n\n// ============================================================================\n// Extracción\n// ============================================================================\n\n// 160 y no 300: medido sobre la sesión real de `before-compaction.jsonl`, las\n// 12 peticiones del usuario a 300 caracteres se comían 900 de los 1073 tokens\n// del presupuesto y dejaban fuera 247 hechos. La petición recortada sigue\n// diciendo qué se pidió; las 140 caracteres de más solo decían cómo.\nconst MAX_PET = 160;\nconst MAX_CMD = 200;\nconst MAX_SAL = 160;\nconst MAX_DIJO = 140;\n/** Por encima de esto, la salida de una herramienta es contenido, no estado. */\nconst MAX_ESTADO = 100;\n\n/** Primera línea no vacía de un texto. */\nfunction primeraLinea(texto: string): string {\n\tfor (const linea of texto.split(\"\\n\")) {\n\t\tif (linea.trim().length > 0) return linea;\n\t}\n\treturn \"\";\n}\n\nfunction anadir(hechos: Hecho[], turno: number, clase: ClaseHecho, crudo: string, maxChars: number): void {\n\tconst texto = recortar(crudo, maxChars);\n\tif (nucleo(texto).length === 0) return;\n\thechos.push({ turno, clase, texto });\n}\n\nfunction hechosDeToolCall(hechos: Hecho[], turno: number, nombre: string, args: Record<string, unknown>): void {\n\tconst ruta = typeof args.path === \"string\" ? args.path : undefined;\n\tswitch (nombre) {\n\t\tcase \"read\":\n\t\t\tif (ruta) anadir(hechos, turno, \"lee\", ruta, MAX_CMD);\n\t\t\treturn;\n\t\tcase \"write\":\n\t\t\tif (ruta) anadir(hechos, turno, \"esc\", ruta, MAX_CMD);\n\t\t\treturn;\n\t\tcase \"edit\":\n\t\t\tif (ruta) anadir(hechos, turno, \"ed\", ruta, MAX_CMD);\n\t\t\treturn;\n\t\tcase \"bash\":\n\t\t\tif (typeof args.command === \"string\") anadir(hechos, turno, \"cmd\", args.command, MAX_CMD);\n\t\t\treturn;\n\t\tdefault: {\n\t\t\t// Para el resto de herramientas guardamos el nombre y el primer\n\t\t\t// argumento de cadena: suficiente para saber QUÉ se hizo sin pagar el\n\t\t\t// JSON entero. El nombre solo no distingue dos búsquedas distintas.\n\t\t\tconst primerValor = Object.values(args).find((v) => typeof v === \"string\") as string | undefined;\n\t\t\tanadir(hechos, turno, \"her\", primerValor ? `${nombre} ${primerValor}` : nombre, MAX_CMD);\n\t\t}\n\t}\n}\n\n/**\n * Extrae los hechos de un lote de mensajes.\n *\n * Devuelve `[]` cuando NO HAY nada que extraer (lote vacío, o solo mensajes sin\n * contenido citable). Eso es distinto de \"no puedo\": aquí siempre se puede,\n * porque no hay ni red ni modelo de por medio. Quien decide qué hacer con un\n * registro vacío es `compactarADenso`, que en ese caso devuelve `null` y deja\n * que la compactación en prosa haga su trabajo.\n */\nexport function extraerHechos(mensajes: AgentMessage[]): Hecho[] {\n\tconst hechos: Hecho[] = [];\n\n\tfor (let turno = 0; turno < mensajes.length; turno++) {\n\t\tconst msg = mensajes[turno];\n\t\tswitch (msg.role) {\n\t\t\tcase \"user\":\n\t\t\t\tanadir(hechos, turno, \"pet\", textoDeContenido(msg.content), MAX_PET);\n\t\t\t\tbreak;\n\t\t\tcase \"assistant\": {\n\t\t\t\tfor (const bloque of msg.content) {\n\t\t\t\t\tif (bloque.type === \"text\") {\n\t\t\t\t\t\tanadir(hechos, turno, \"dijo\", primeraLinea(bloque.text), MAX_DIJO);\n\t\t\t\t\t} else if (bloque.type === \"toolCall\") {\n\t\t\t\t\t\thechosDeToolCall(hechos, turno, bloque.name, (bloque.arguments as Record<string, unknown>) ?? {});\n\t\t\t\t\t}\n\t\t\t\t\t// El pensamiento no entra: no es un hecho, es deliberación.\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase \"toolResult\": {\n\t\t\t\tconst primera = primeraLinea(textoDeContenido(msg.content));\n\t\t\t\tif (msg.isError === true) {\n\t\t\t\t\tanadir(hechos, turno, \"err\", primera, MAX_SAL);\n\t\t\t\t} else if (aplanar(primera).length <= MAX_ESTADO) {\n\t\t\t\t\t// Solo la salida CORTA es un hecho (\"Switched to a new branch\n\t\t\t\t\t// 'refactor'\", \"(no output)\"). La primera línea de un `read` es la\n\t\t\t\t\t// primera línea del fichero: en la sesión real eran 3.545 tokens de\n\t\t\t\t\t// `import { ... }` que no dicen nada de lo que pasó, y la llamada que\n\t\t\t\t\t// los produjo ya está registrada.\n\t\t\t\t\tanadir(hechos, turno, \"sal\", primera, MAX_SAL);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase \"bashExecution\": {\n\t\t\t\tanadir(hechos, turno, \"cmd\", msg.command, MAX_CMD);\n\t\t\t\tconst fallo = typeof msg.exitCode === \"number\" && msg.exitCode !== 0;\n\t\t\t\tanadir(hechos, turno, fallo ? \"err\" : \"sal\", primeraLinea(msg.output), MAX_SAL);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase \"compactionSummary\":\n\t\t\tcase \"branchSummary\": {\n\t\t\t\t// Cascada: un resumen anterior que YA es un registro denso se\n\t\t\t\t// absorbe línea a línea. Si es prosa (compactación anterior a este\n\t\t\t\t// módulo, o de una extensión), se guarda su primera línea y nada\n\t\t\t\t// más: no vamos a fingir que sabemos de dónde salió cada frase.\n\t\t\t\tconst previos = absorberRegistro(msg.summary);\n\t\t\t\tif (previos) {\n\t\t\t\t\thechos.push(...previos);\n\t\t\t\t} else {\n\t\t\t\t\tanadir(hechos, turno, \"dijo\", primeraLinea(msg.summary), MAX_DIJO);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase \"custom\":\n\t\t\t\tanadir(hechos, turno, \"dijo\", primeraLinea(textoDeContenido(msg.content)), MAX_DIJO);\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\treturn hechos;\n}\n\n// ============================================================================\n// Formato y presupuesto\n// ============================================================================\n\n/** Estimación de tokens con la misma heurística que usa la compactación (chars/4). */\nexport function tokensDeTexto(texto: string): number {\n\treturn Math.ceil(texto.length / 4);\n}\n\n/**\n * Marca de raíz abreviada. La abreviatura vive solo en el texto formateado y\n * `absorberRegistro` la deshace, así que `Hecho.texto` sigue siendo literal en\n * memoria.\n *\n * Que sea reversible NO es gratis: depende de que ninguna línea del bloque\n * contenga este carácter por su cuenta, y `»` es comilla latina corriente en\n * español. Lo garantiza la guardia de `raizComun`, no el carácter en sí.\n */\nconst MARCA_RAIZ = \"»\";\n\n/**\n * Directorio cuya repetición más caracteres ahorra si se saca a una cabecera.\n *\n * Se parte del prefijo común de las rutas de FICHERO (`lee`/`esc`/`ed`, que son\n * homogéneas) y se prueban también sus directorios padre, quedándose con el que\n * más ahorra contando las apariciones en TODAS las líneas. Los padres importan:\n * en la sesión real de `before-compaction.jsonl` las rutas de fichero comparten\n * `…/pi-mono/packages/coding-agent/`, pero los 59 comandos empiezan por\n * `cd …/pi-mono && `, y solo el padre corto sirve para los dos.\n *\n * Primer intento: sacar el prefijo común de TODAS las rutas absolutas del lote.\n * Salía \"\" siempre — basta un `/dev/null` o un `/tmp/x` sueltos para que el\n * prefijo común se quede en \"/\" — y la abreviatura quedó de adorno, sin que\n * ninguna prueba lo notara. Lo cazó romper la función a propósito y ver que la\n * salida no cambiaba ni un byte.\n *\n * Devuelve \"\" cuando no compensa.\n */\nfunction raizComun(hechos: Hecho[]): string {\n\t// Si UN solo hecho lleva ya la marca, no hay abreviatura posible para NINGUNO:\n\t// `absorberRegistro` expande todas las marcas de la línea, así que una `»`\n\t// que venía en el texto literal se convertiría en la raíz. Con la petición\n\t// «lee el fichero \"main.ts\" y dime »qué hace» el hecho volvía de la cascada\n\t// como «... y dime /Users/x/proy/qué hace»: texto FABRICADO, y encima marcado\n\t// como heredado, que es justo lo que `verificarProcedencia` no comprueba.\n\t// La guardia por línea que había en `abreviar` no bastaba: protegía la línea\n\t// al escribir y la expansión al leer no la respetaba.\n\tif (hechos.some((h) => h.texto.includes(MARCA_RAIZ))) return \"\";\n\n\tconst rutas = hechos.filter((h) => h.clase === \"lee\" || h.clase === \"esc\" || h.clase === \"ed\").map((h) => h.texto);\n\tif (rutas.length < 3) return \"\";\n\n\tlet prefijo = rutas[0];\n\tfor (const ruta of rutas) {\n\t\tlet i = 0;\n\t\twhile (i < prefijo.length && i < ruta.length && prefijo[i] === ruta[i]) i++;\n\t\tprefijo = prefijo.slice(0, i);\n\t\tif (prefijo.length === 0) return \"\";\n\t}\n\n\tconst candidatos: string[] = [];\n\tfor (let corte = prefijo.lastIndexOf(\"/\"); corte > 0; corte = prefijo.lastIndexOf(\"/\", corte - 1)) {\n\t\tconst candidato = prefijo.slice(0, corte + 1);\n\t\tif (candidato.length >= 8) candidatos.push(candidato);\n\t}\n\n\tlet mejor = \"\";\n\tlet mejorAhorro = 0;\n\tfor (const candidato of candidatos) {\n\t\tlet apariciones = 0;\n\t\tfor (const hecho of hechos) apariciones += hecho.texto.split(candidato).length - 1;\n\t\t// Cada aparición se sustituye por un carácter, y la cabecera se paga una vez.\n\t\tconst ahorro = apariciones * (candidato.length - MARCA_RAIZ.length) - (candidato.length + 7);\n\t\tif (ahorro > mejorAhorro) {\n\t\t\tmejorAhorro = ahorro;\n\t\t\tmejor = candidato;\n\t\t}\n\t}\n\treturn mejor;\n}\n\n/**\n * Sustituye la raíz por su marca. `raizComun` ya ha garantizado que ningún\n * hecho del lote contiene la marca, así que la expansión de vuelta no puede ser\n * ambigua. La guardia por línea que había aquí daba esa garantía por línea y no\n * por bloque, que es donde se rompía (ver `raizComun`).\n */\nfunction abreviar(texto: string, raiz: string): string {\n\tif (!raiz) return texto;\n\treturn texto.split(raiz).join(MARCA_RAIZ);\n}\n\nfunction lineaDe(hecho: Hecho, raiz: string): string {\n\treturn `T${hecho.turno}${hecho.heredado ? \"*\" : \"\"} ${hecho.clase} ${abreviar(hecho.texto, raiz)}`;\n}\n\n/**\n * Quita duplicados exactos (misma clase y mismo texto).\n *\n * Ante un empate se conserva el que SÍ se puede verificar. En la cascada los\n * heredados van delante (`reescribirADenso` los antepone), así que \"conservar el\n * primero\" degradaba un hecho comprobable en uno que nadie puede comprobar: con\n * `resumenAnterior` conteniendo `T0 pet sigue` y un turno nuevo que vuelve a\n * decir «sigue» —cosa que pasa a diario— el registro se quedaba con la línea\n * heredada, y `verificarProcedencia` la devolvía por `heredados`, no por\n * `validos`. La puerta de procedencia se iba vaciando sola a cada compactación.\n */\nfunction deduplicar(hechos: Hecho[]): Hecho[] {\n\tconst posicion = new Map<string, number>();\n\tconst salida: Hecho[] = [];\n\tfor (const hecho of hechos) {\n\t\tconst clave = `${hecho.clase} ${hecho.texto}`;\n\t\tconst previa = posicion.get(clave);\n\t\tif (previa === undefined) {\n\t\t\tposicion.set(clave, salida.length);\n\t\t\tsalida.push(hecho);\n\t\t\tcontinue;\n\t\t}\n\t\t// Mismo texto: si el que guardamos es heredado y este no, se cambia por él.\n\t\t// Solo cambia el turno (y el `*`), nunca el texto, así que ninguna línea\n\t\t// aparece ni desaparece del registro por esto.\n\t\tif (salida[previa].heredado && !hecho.heredado) salida[previa] = hecho;\n\t}\n\treturn salida;\n}\n\nexport interface RegistroFormateado {\n\ttexto: string;\n\tincluidos: Hecho[];\n\tomitidos: Hecho[];\n}\n\n/**\n * Formatea los hechos como bloque de registro, respetando un presupuesto de\n * tokens.\n *\n * Cuando no caben todos se caen primero los de menor peso (lecturas, prosa del\n * asistente) y NUNCA en silencio: la última línea dice cuántos se han quitado y\n * de qué clase. Un registro recortado que no lo dijera se leería como \"esto es\n * todo lo que pasó\", que es exactamente el fallo que se lee como éxito.\n *\n * `omitidosPrevios` es la cuenta que YA declaraba el registro anterior de la\n * cascada, y se suma al total. Sin ese arrastre el aviso duraba una sola vuelta:\n * medido, la 1ª compactación decía \"[omitidos 49 hechos]\" y la 2ª —con\n * presupuesto de sobra, sin nada nuevo que quitar— salía sin aviso ninguno. El\n * registro volvía a leerse como \"esto es todo lo que pasó\" con 49 hechos ya\n * perdidos, que es justo lo que este aviso existe para impedir.\n */\nexport function formatearRegistro(hechos: Hecho[], presupuestoTokens: number, omitidosPrevios = 0): RegistroFormateado {\n\tconst unicos = deduplicar(hechos);\n\tconst raiz = raizComun(unicos);\n\tconst cabecera = raiz ? `#raiz ${raiz}\\n` : \"\";\n\n\t// Orden de sacrificio: peso ascendente y, a igualdad, los más antiguos primero.\n\tconst porSacrificar = [...unicos].sort((a, b) => PESO[a.clase] - PESO[b.clase] || a.turno - b.turno);\n\n\tconst fijos = tokensDeTexto(`${MARCA_ABRE}\\n${cabecera}${MARCA_CIERRA}\\n`);\n\tconst fuera = new Set<Hecho>();\n\n\t// El aviso de recorte se cuenta con su TEXTO REAL, no con un hueco de tamaño\n\t// fijo: con muchas clases omitidas mide 80 caracteres y no 45, y esa\n\t// diferencia se comió el presupuesto por un token en la primera versión.\n\tconst avisoDe = (omitidos: Hecho[]): string => {\n\t\tconst total = omitidos.length + omitidosPrevios;\n\t\tif (total === 0) return \"\";\n\t\tconst porClase = new Map<ClaseHecho, number>();\n\t\tfor (const h of omitidos) porClase.set(h.clase, (porClase.get(h.clase) ?? 0) + 1);\n\t\tconst detalle = [...porClase.entries()].sort((a, b) => b[1] - a[1]).map(([clase, n]) => `${clase} x${n}`);\n\t\t// El arrastre va como una entrada más del detalle, no como una frase\n\t\t// aparte: así el total de cabecera lo vuelve a leer `omitidosDeRegistro`\n\t\t// en la vuelta siguiente sin sumar dos veces lo mismo.\n\t\tif (omitidosPrevios > 0) detalle.push(`${omitidosPrevios} en compactaciones anteriores`);\n\t\treturn `[omitidos ${total} hechos por presupuesto: ${detalle.join(\", \")}]`;\n\t};\n\n\tlet incluidos = unicos;\n\tlet omitidos: Hecho[] = [];\n\tlet costeLineas = 0;\n\tfor (const h of unicos) costeLineas += tokensDeTexto(`${lineaDe(h, raiz)}\\n`);\n\n\tconst coste = () =>\n\t\tfijos + costeLineas + (omitidos.length + omitidosPrevios > 0 ? tokensDeTexto(`${avisoDe(omitidos)}\\n`) : 0);\n\n\tlet indice = 0;\n\twhile (coste() > presupuestoTokens && indice < porSacrificar.length) {\n\t\tconst victima = porSacrificar[indice];\n\t\tindice++;\n\t\tfuera.add(victima);\n\t\tcosteLineas -= tokensDeTexto(`${lineaDe(victima, raiz)}\\n`);\n\t\tomitidos = unicos.filter((h) => fuera.has(h));\n\t}\n\tincluidos = unicos.filter((h) => !fuera.has(h));\n\n\tconst lineas = incluidos.map((h) => lineaDe(h, raiz));\n\tif (raiz) lineas.unshift(`#raiz ${raiz}`);\n\tconst aviso = avisoDe(omitidos);\n\tif (aviso) lineas.push(aviso);\n\n\treturn {\n\t\ttexto: `${MARCA_ABRE}\\n${lineas.join(\"\\n\")}\\n${MARCA_CIERRA}`,\n\t\tincluidos,\n\t\tomitidos,\n\t};\n}\n\n// ============================================================================\n// Absorción (cascada)\n// ============================================================================\n\nconst RE_LINEA = /^T(\\d+)(\\*?) ([a-z]{2,4}) (.*)$/;\n\n/**\n * Límites `[abre, cierra]` del bloque de registro dentro de un texto, o `null`\n * si no hay bloque.\n *\n * Las marcas se buscan como LÍNEA COMPLETA, y la de apertura es la ÚLTIMA.\n * Buscarlas como subcadena (y la primera) leía el bloque equivocado en dos casos\n * reales:\n *\n * (a) El resumen persistido es «prosa + registro», y en la SIGUIENTE\n *     compactación upstream se lo pasa entero al modelo dentro de\n *     <previous-summary> pidiéndole un resumen actualizado. Si el modelo copia el\n *     bloque en su prosa, esa copia va ANTES del registro de verdad y ganaba: se\n *     heredaban hechos escritos por el modelo, que es exactamente lo que este\n *     módulo existe para impedir — y como salen por `heredados`,\n *     `verificarProcedencia` no los mira.\n * (b) Un hecho cuyo texto contiene \"</registro-denso>\" (basta con que el usuario\n *     lo pegue) cerraba el bloque en mitad de la lista y las líneas siguientes se\n *     perdían EN SILENCIO. Con 3 hechos se absorbía 1.\n *\n * Una línea de hecho siempre empieza por \"T<n> <clase> \", así que nunca es igual\n * a una marca entera: la comparación por línea las distingue sin heurística.\n */\nfunction localizarBloque(lineas: string[]): [number, number] | null {\n\tlet abre = -1;\n\tfor (let i = lineas.length - 1; i >= 0; i--) {\n\t\tif (lineas[i].trim() === MARCA_ABRE) {\n\t\t\tabre = i;\n\t\t\tbreak;\n\t\t}\n\t}\n\tif (abre < 0) return null;\n\tfor (let i = abre + 1; i < lineas.length; i++) {\n\t\tif (lineas[i].trim() === MARCA_CIERRA) return [abre, i];\n\t}\n\treturn null;\n}\n\n/**\n * Cuántos hechos declara haber perdido un registro YA ESCRITO. Devuelve 0 si el\n * texto no es un registro o si el registro no declara ninguna pérdida.\n *\n * Existe porque `absorberRegistro` solo recupera las líneas de hecho: el aviso\n * de recorte no es un hecho y se quedaba fuera, así que la cuenta de lo perdido\n * moría en la vuelta siguiente de la cascada. Ver `formatearRegistro`.\n */\nexport function omitidosDeRegistro(texto: string): number {\n\tconst lineas = texto.split(\"\\n\");\n\tconst limites = localizarBloque(lineas);\n\tif (!limites) return 0;\n\tfor (const linea of lineas.slice(limites[0] + 1, limites[1])) {\n\t\tconst m = linea.trim().match(RE_OMITIDOS);\n\t\tif (m) return Number.parseInt(m[1], 10);\n\t}\n\treturn 0;\n}\n\n/**\n * Lee un bloque de registro denso de un texto.\n *\n * Tres estados, no dos:\n * - `null`  → NO ES un registro denso (prosa, o texto sin el bloque). \"No lo he\n *             mirado\" no aplica aquí, pero \"esto no es lo mío\" sí, y no se puede\n *             confundir con \"el registro estaba vacío\".\n * - `[]`    → es un registro denso y NO TIENE hechos.\n * - `[...]` → los hechos, marcados como heredados.\n */\nexport function absorberRegistro(texto: string): Hecho[] | null {\n\tconst lineas = texto.split(\"\\n\");\n\tconst limites = localizarBloque(lineas);\n\tif (!limites) return null;\n\tconst [abre, cierra] = limites;\n\n\tconst hechos: Hecho[] = [];\n\tlet raiz = \"\";\n\tfor (const linea of lineas.slice(abre + 1, cierra)) {\n\t\tconst recortada = linea.trim();\n\t\tif (recortada.startsWith(\"#raiz \")) {\n\t\t\traiz = recortada.slice(\"#raiz \".length);\n\t\t\tcontinue;\n\t\t}\n\t\tconst m = recortada.match(RE_LINEA);\n\t\tif (!m) continue;\n\t\t// Se deshace la abreviatura AQUÍ: en memoria `texto` vuelve a ser literal,\n\t\t// que es lo que hace verificable un hecho heredado el día que alguien lo\n\t\t// compare contra su sesión de origen.\n\t\tconst bruto = m[4];\n\t\thechos.push({\n\t\t\tturno: Number.parseInt(m[1], 10),\n\t\t\tclase: m[3] as ClaseHecho,\n\t\t\ttexto: raiz ? bruto.split(MARCA_RAIZ).join(raiz) : bruto,\n\t\t\theredado: true,\n\t\t});\n\t}\n\treturn hechos;\n}\n\n// ============================================================================\n// Procedencia\n// ============================================================================\n\nexport interface Procedencia {\n\t/** Hechos cuyo texto aparece literalmente en su turno de origen. */\n\tvalidos: Hecho[];\n\t/** Hechos que NO aparecen en su turno, o cuyo turno no existe. Inventados. */\n\tinvalidos: Hecho[];\n\t/**\n\t * Hechos heredados de un registro anterior. NO son inválidos: su origen está\n\t * en un lote que ya no tenemos delante. Se cuentan aparte a propósito, para\n\t * no leer \"no lo puedo comprobar aquí\" como \"es válido\".\n\t */\n\theredados: Hecho[];\n}\n\n/**\n * Comprueba que cada hecho se puede rastrear a su turno.\n *\n * Esta es la puerta que impide que el registro invente: un hecho cuyo texto no\n * esté, carácter a carácter, en el mensaje que dice ser su origen, sale por\n * `invalidos`.\n */\nexport function verificarProcedencia(hechos: Hecho[], mensajes: AgentMessage[]): Procedencia {\n\tconst cache = new Map<number, string>();\n\tconst validos: Hecho[] = [];\n\tconst invalidos: Hecho[] = [];\n\tconst heredados: Hecho[] = [];\n\n\tfor (const hecho of hechos) {\n\t\tif (hecho.heredado) {\n\t\t\theredados.push(hecho);\n\t\t\tcontinue;\n\t\t}\n\t\tif (hecho.turno < 0 || hecho.turno >= mensajes.length) {\n\t\t\tinvalidos.push(hecho);\n\t\t\tcontinue;\n\t\t}\n\t\tlet canonico = cache.get(hecho.turno);\n\t\tif (canonico === undefined) {\n\t\t\tcanonico = serializarTurno(mensajes[hecho.turno]);\n\t\t\tcache.set(hecho.turno, canonico);\n\t\t}\n\t\tconst buscado = nucleo(hecho.texto);\n\t\t// Los hechos \"her\" llevan \"<nombre de herramienta> <primer argumento>\", y\n\t\t// esos dos trozos están en el turno pero no pegados. Se parte por el PRIMER\n\t\t// espacio y SOLO por él: partir por todos convertía la puerta en \"cada\n\t\t// palabra aparece en algún sitio del turno\", que es lo contrario de\n\t\t// verificar. Con la versión anterior, el hecho inventado\n\t\t// \"her borra secreto produccion\" pasaba como VÁLIDO contra un turno que\n\t\t// decía \"busca deploy en produccion y borra el fichero secreto\".\n\t\tconst corte = hecho.clase === \"her\" ? buscado.indexOf(\" \") : -1;\n\t\tconst ok =\n\t\t\tcanonico.includes(buscado) ||\n\t\t\t(corte > 0 && canonico.includes(buscado.slice(0, corte)) && canonico.includes(buscado.slice(corte + 1)));\n\t\t(ok ? validos : invalidos).push(hecho);\n\t}\n\n\treturn { validos, invalidos, heredados };\n}\n\n// ============================================================================\n// Reescritura completa\n// ============================================================================\n\n/**\n * Construye el registro denso de un lote, absorbiendo el registro anterior si\n * lo hay.\n *\n * `resumenAnterior` es el resumen de la compactación previa. Si ya era un\n * registro denso, sus líneas se conservan TAL CUAL (no se re-resumen): esa es\n * la diferencia entre encadenar compactaciones y degradarlas en cascada.\n */\nexport function reescribirADenso(\n\tmensajes: AgentMessage[],\n\tpresupuestoTokens: number,\n\tresumenAnterior?: string,\n): RegistroFormateado {\n\tconst previos = resumenAnterior ? (absorberRegistro(resumenAnterior) ?? []) : [];\n\tconst nuevos = extraerHechos(mensajes);\n\t// Lo que el registro anterior YA declaraba perdido se arrastra: esos hechos no\n\t// están en `previos` (nadie los escribió) y sin la cuenta nadie sabría que\n\t// faltan. Ver `formatearRegistro`.\n\tconst omitidosPrevios = resumenAnterior ? omitidosDeRegistro(resumenAnterior) : 0;\n\treturn formatearRegistro([...previos, ...nuevos], presupuestoTokens, omitidosPrevios);\n}\n"]}