@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/compactar/registro-denso.js

@@ -0,0 +1,620 @@
+/**
+ * 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.
+ */
+/** Peso: más alto = se conserva más tiempo cuando falta presupuesto. */
+const PESO = {
+    err: 100,
+    pet: 95,
+    ed: 90,
+    esc: 90,
+    cmd: 80,
+    sal: 50,
+    her: 40,
+    lee: 30,
+    dijo: 20,
+};
+/** Marca de truncado. Se quita antes de comparar con el origen (ver `nucleo`). */
+const ELIPSIS = "…";
+const MARCA_ABRE = "<registro-denso>";
+const MARCA_CIERRA = "</registro-denso>";
+/**
+ * Aviso de recorte de un registro YA ESCRITO. Solo se lee el total; el detalle
+ * por clases describe la vuelta en que se escribió y no se reconstruye.
+ */
+const RE_OMITIDOS = /^\[omitidos (\d+) hechos? por presupuesto:/;
+/** Texto de un hecho sin la marca de truncado: lo que debe estar en el origen. */
+export function nucleo(texto) {
+    return texto.endsWith(ELIPSIS) ? texto.slice(0, -ELIPSIS.length) : texto;
+}
+// ============================================================================
+// Normalización
+// ============================================================================
+/**
+ * Colapsa todos los espacios en blanco a un solo espacio y recorta.
+ *
+ * Es idempotente y distributiva sobre el salto de línea
+ * (`aplanar(a + "\n" + b) === aplanar(a) + " " + aplanar(b)` con a y b no
+ * vacíos), que es justo lo que hace que "primera línea aplanada" siga siendo
+ * un prefijo del turno aplanado entero. Sin esa propiedad la puerta de
+ * procedencia daría falsos negativos en cuanto un comando llevara un salto.
+ */
+function aplanar(texto) {
+    return texto.replace(/\s+/g, " ").trim();
+}
+function recortar(texto, maxChars) {
+    const plano = aplanar(texto);
+    if (plano.length <= maxChars)
+        return plano;
+    return plano.slice(0, maxChars) + ELIPSIS;
+}
+/** Texto de un contenido que puede ser cadena o bloques. */
+function textoDeContenido(contenido) {
+    if (typeof contenido === "string")
+        return contenido;
+    if (!Array.isArray(contenido))
+        return "";
+    const partes = [];
+    for (const bloque of contenido) {
+        if (bloque && typeof bloque === "object" && bloque.type === "text") {
+            const t = bloque.text;
+            if (typeof t === "string")
+                partes.push(t);
+        }
+    }
+    return partes.join("\n");
+}
+/**
+ * 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 function serializarTurno(mensaje) {
+    const partes = [];
+    const msg = mensaje;
+    switch (msg.role) {
+        case "user":
+        case "custom":
+            partes.push(textoDeContenido(msg.content));
+            break;
+        case "toolResult":
+            partes.push(textoDeContenido(msg.content));
+            partes.push(msg.toolName);
+            break;
+        case "assistant": {
+            for (const bloque of msg.content) {
+                if (bloque.type === "text")
+                    partes.push(bloque.text);
+                else if (bloque.type === "thinking")
+                    partes.push(bloque.thinking);
+                else if (bloque.type === "toolCall") {
+                    partes.push(bloque.name);
+                    const args = bloque.arguments;
+                    if (args) {
+                        partes.push(JSON.stringify(args));
+                        for (const valor of Object.values(args)) {
+                            if (typeof valor === "string")
+                                partes.push(valor);
+                        }
+                    }
+                }
+            }
+            break;
+        }
+        case "bashExecution":
+            partes.push(msg.command);
+            partes.push(msg.output);
+            break;
+        case "branchSummary":
+        case "compactionSummary":
+            partes.push(msg.summary);
+            break;
+    }
+    return aplanar(partes.join("\n"));
+}
+// ============================================================================
+// Extracción
+// ============================================================================
+// 160 y no 300: medido sobre la sesión real de `before-compaction.jsonl`, las
+// 12 peticiones del usuario a 300 caracteres se comían 900 de los 1073 tokens
+// del presupuesto y dejaban fuera 247 hechos. La petición recortada sigue
+// diciendo qué se pidió; las 140 caracteres de más solo decían cómo.
+const MAX_PET = 160;
+const MAX_CMD = 200;
+const MAX_SAL = 160;
+const MAX_DIJO = 140;
+/** Por encima de esto, la salida de una herramienta es contenido, no estado. */
+const MAX_ESTADO = 100;
+/** Primera línea no vacía de un texto. */
+function primeraLinea(texto) {
+    for (const linea of texto.split("\n")) {
+        if (linea.trim().length > 0)
+            return linea;
+    }
+    return "";
+}
+function anadir(hechos, turno, clase, crudo, maxChars) {
+    const texto = recortar(crudo, maxChars);
+    if (nucleo(texto).length === 0)
+        return;
+    hechos.push({ turno, clase, texto });
+}
+function hechosDeToolCall(hechos, turno, nombre, args) {
+    const ruta = typeof args.path === "string" ? args.path : undefined;
+    switch (nombre) {
+        case "read":
+            if (ruta)
+                anadir(hechos, turno, "lee", ruta, MAX_CMD);
+            return;
+        case "write":
+            if (ruta)
+                anadir(hechos, turno, "esc", ruta, MAX_CMD);
+            return;
+        case "edit":
+            if (ruta)
+                anadir(hechos, turno, "ed", ruta, MAX_CMD);
+            return;
+        case "bash":
+            if (typeof args.command === "string")
+                anadir(hechos, turno, "cmd", args.command, MAX_CMD);
+            return;
+        default: {
+            // Para el resto de herramientas guardamos el nombre y el primer
+            // argumento de cadena: suficiente para saber QUÉ se hizo sin pagar el
+            // JSON entero. El nombre solo no distingue dos búsquedas distintas.
+            const primerValor = Object.values(args).find((v) => typeof v === "string");
+            anadir(hechos, turno, "her", primerValor ? `${nombre} ${primerValor}` : nombre, MAX_CMD);
+        }
+    }
+}
+/**
+ * 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 function extraerHechos(mensajes) {
+    const hechos = [];
+    for (let turno = 0; turno < mensajes.length; turno++) {
+        const msg = mensajes[turno];
+        switch (msg.role) {
+            case "user":
+                anadir(hechos, turno, "pet", textoDeContenido(msg.content), MAX_PET);
+                break;
+            case "assistant": {
+                for (const bloque of msg.content) {
+                    if (bloque.type === "text") {
+                        anadir(hechos, turno, "dijo", primeraLinea(bloque.text), MAX_DIJO);
+                    }
+                    else if (bloque.type === "toolCall") {
+                        hechosDeToolCall(hechos, turno, bloque.name, bloque.arguments ?? {});
+                    }
+                    // El pensamiento no entra: no es un hecho, es deliberación.
+                }
+                break;
+            }
+            case "toolResult": {
+                const primera = primeraLinea(textoDeContenido(msg.content));
+                if (msg.isError === true) {
+                    anadir(hechos, turno, "err", primera, MAX_SAL);
+                }
+                else if (aplanar(primera).length <= MAX_ESTADO) {
+                    // Solo la salida CORTA es un hecho ("Switched to a new branch
+                    // 'refactor'", "(no output)"). La primera línea de un `read` es la
+                    // primera línea del fichero: en la sesión real eran 3.545 tokens de
+                    // `import { ... }` que no dicen nada de lo que pasó, y la llamada que
+                    // los produjo ya está registrada.
+                    anadir(hechos, turno, "sal", primera, MAX_SAL);
+                }
+                break;
+            }
+            case "bashExecution": {
+                anadir(hechos, turno, "cmd", msg.command, MAX_CMD);
+                const fallo = typeof msg.exitCode === "number" && msg.exitCode !== 0;
+                anadir(hechos, turno, fallo ? "err" : "sal", primeraLinea(msg.output), MAX_SAL);
+                break;
+            }
+            case "compactionSummary":
+            case "branchSummary": {
+                // Cascada: un resumen anterior que YA es un registro denso se
+                // absorbe línea a línea. Si es prosa (compactación anterior a este
+                // módulo, o de una extensión), se guarda su primera línea y nada
+                // más: no vamos a fingir que sabemos de dónde salió cada frase.
+                const previos = absorberRegistro(msg.summary);
+                if (previos) {
+                    hechos.push(...previos);
+                }
+                else {
+                    anadir(hechos, turno, "dijo", primeraLinea(msg.summary), MAX_DIJO);
+                }
+                break;
+            }
+            case "custom":
+                anadir(hechos, turno, "dijo", primeraLinea(textoDeContenido(msg.content)), MAX_DIJO);
+                break;
+        }
+    }
+    return hechos;
+}
+// ============================================================================
+// Formato y presupuesto
+// ============================================================================
+/** Estimación de tokens con la misma heurística que usa la compactación (chars/4). */
+export function tokensDeTexto(texto) {
+    return Math.ceil(texto.length / 4);
+}
+/**
+ * Marca de raíz abreviada. La abreviatura vive solo en el texto formateado y
+ * `absorberRegistro` la deshace, así que `Hecho.texto` sigue siendo literal en
+ * memoria.
+ *
+ * Que sea reversible NO es gratis: depende de que ninguna línea del bloque
+ * contenga este carácter por su cuenta, y `»` es comilla latina corriente en
+ * español. Lo garantiza la guardia de `raizComun`, no el carácter en sí.
+ */
+const MARCA_RAIZ = "»";
+/**
+ * Directorio cuya repetición más caracteres ahorra si se saca a una cabecera.
+ *
+ * Se parte del prefijo común de las rutas de FICHERO (`lee`/`esc`/`ed`, que son
+ * homogéneas) y se prueban también sus directorios padre, quedándose con el que
+ * más ahorra contando las apariciones en TODAS las líneas. Los padres importan:
+ * en la sesión real de `before-compaction.jsonl` las rutas de fichero comparten
+ * `…/pi-mono/packages/coding-agent/`, pero los 59 comandos empiezan por
+ * `cd …/pi-mono && `, y solo el padre corto sirve para los dos.
+ *
+ * Primer intento: sacar el prefijo común de TODAS las rutas absolutas del lote.
+ * Salía "" siempre — basta un `/dev/null` o un `/tmp/x` sueltos para que el
+ * prefijo común se quede en "/" — y la abreviatura quedó de adorno, sin que
+ * ninguna prueba lo notara. Lo cazó romper la función a propósito y ver que la
+ * salida no cambiaba ni un byte.
+ *
+ * Devuelve "" cuando no compensa.
+ */
+function raizComun(hechos) {
+    // Si UN solo hecho lleva ya la marca, no hay abreviatura posible para NINGUNO:
+    // `absorberRegistro` expande todas las marcas de la línea, así que una `»`
+    // que venía en el texto literal se convertiría en la raíz. Con la petición
+    // «lee el fichero "main.ts" y dime »qué hace» el hecho volvía de la cascada
+    // como «... y dime /Users/x/proy/qué hace»: texto FABRICADO, y encima marcado
+    // como heredado, que es justo lo que `verificarProcedencia` no comprueba.
+    // La guardia por línea que había en `abreviar` no bastaba: protegía la línea
+    // al escribir y la expansión al leer no la respetaba.
+    if (hechos.some((h) => h.texto.includes(MARCA_RAIZ)))
+        return "";
+    const rutas = hechos.filter((h) => h.clase === "lee" || h.clase === "esc" || h.clase === "ed").map((h) => h.texto);
+    if (rutas.length < 3)
+        return "";
+    let prefijo = rutas[0];
+    for (const ruta of rutas) {
+        let i = 0;
+        while (i < prefijo.length && i < ruta.length && prefijo[i] === ruta[i])
+            i++;
+        prefijo = prefijo.slice(0, i);
+        if (prefijo.length === 0)
+            return "";
+    }
+    const candidatos = [];
+    for (let corte = prefijo.lastIndexOf("/"); corte > 0; corte = prefijo.lastIndexOf("/", corte - 1)) {
+        const candidato = prefijo.slice(0, corte + 1);
+        if (candidato.length >= 8)
+            candidatos.push(candidato);
+    }
+    let mejor = "";
+    let mejorAhorro = 0;
+    for (const candidato of candidatos) {
+        let apariciones = 0;
+        for (const hecho of hechos)
+            apariciones += hecho.texto.split(candidato).length - 1;
+        // Cada aparición se sustituye por un carácter, y la cabecera se paga una vez.
+        const ahorro = apariciones * (candidato.length - MARCA_RAIZ.length) - (candidato.length + 7);
+        if (ahorro > mejorAhorro) {
+            mejorAhorro = ahorro;
+            mejor = candidato;
+        }
+    }
+    return mejor;
+}
+/**
+ * Sustituye la raíz por su marca. `raizComun` ya ha garantizado que ningún
+ * hecho del lote contiene la marca, así que la expansión de vuelta no puede ser
+ * ambigua. La guardia por línea que había aquí daba esa garantía por línea y no
+ * por bloque, que es donde se rompía (ver `raizComun`).
+ */
+function abreviar(texto, raiz) {
+    if (!raiz)
+        return texto;
+    return texto.split(raiz).join(MARCA_RAIZ);
+}
+function lineaDe(hecho, raiz) {
+    return `T${hecho.turno}${hecho.heredado ? "*" : ""} ${hecho.clase} ${abreviar(hecho.texto, raiz)}`;
+}
+/**
+ * Quita duplicados exactos (misma clase y mismo texto).
+ *
+ * Ante un empate se conserva el que SÍ se puede verificar. En la cascada los
+ * heredados van delante (`reescribirADenso` los antepone), así que "conservar el
+ * primero" degradaba un hecho comprobable en uno que nadie puede comprobar: con
+ * `resumenAnterior` conteniendo `T0 pet sigue` y un turno nuevo que vuelve a
+ * decir «sigue» —cosa que pasa a diario— el registro se quedaba con la línea
+ * heredada, y `verificarProcedencia` la devolvía por `heredados`, no por
+ * `validos`. La puerta de procedencia se iba vaciando sola a cada compactación.
+ */
+function deduplicar(hechos) {
+    const posicion = new Map();
+    const salida = [];
+    for (const hecho of hechos) {
+        const clave = `${hecho.clase} ${hecho.texto}`;
+        const previa = posicion.get(clave);
+        if (previa === undefined) {
+            posicion.set(clave, salida.length);
+            salida.push(hecho);
+            continue;
+        }
+        // Mismo texto: si el que guardamos es heredado y este no, se cambia por él.
+        // Solo cambia el turno (y el `*`), nunca el texto, así que ninguna línea
+        // aparece ni desaparece del registro por esto.
+        if (salida[previa].heredado && !hecho.heredado)
+            salida[previa] = hecho;
+    }
+    return salida;
+}
+/**
+ * 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 function formatearRegistro(hechos, presupuestoTokens, omitidosPrevios = 0) {
+    const unicos = deduplicar(hechos);
+    const raiz = raizComun(unicos);
+    const cabecera = raiz ? `#raiz ${raiz}\n` : "";
+    // Orden de sacrificio: peso ascendente y, a igualdad, los más antiguos primero.
+    const porSacrificar = [...unicos].sort((a, b) => PESO[a.clase] - PESO[b.clase] || a.turno - b.turno);
+    const fijos = tokensDeTexto(`${MARCA_ABRE}\n${cabecera}${MARCA_CIERRA}\n`);
+    const fuera = new Set();
+    // El aviso de recorte se cuenta con su TEXTO REAL, no con un hueco de tamaño
+    // fijo: con muchas clases omitidas mide 80 caracteres y no 45, y esa
+    // diferencia se comió el presupuesto por un token en la primera versión.
+    const avisoDe = (omitidos) => {
+        const total = omitidos.length + omitidosPrevios;
+        if (total === 0)
+            return "";
+        const porClase = new Map();
+        for (const h of omitidos)
+            porClase.set(h.clase, (porClase.get(h.clase) ?? 0) + 1);
+        const detalle = [...porClase.entries()].sort((a, b) => b[1] - a[1]).map(([clase, n]) => `${clase} x${n}`);
+        // El arrastre va como una entrada más del detalle, no como una frase
+        // aparte: así el total de cabecera lo vuelve a leer `omitidosDeRegistro`
+        // en la vuelta siguiente sin sumar dos veces lo mismo.
+        if (omitidosPrevios > 0)
+            detalle.push(`${omitidosPrevios} en compactaciones anteriores`);
+        return `[omitidos ${total} hechos por presupuesto: ${detalle.join(", ")}]`;
+    };
+    let incluidos = unicos;
+    let omitidos = [];
+    let costeLineas = 0;
+    for (const h of unicos)
+        costeLineas += tokensDeTexto(`${lineaDe(h, raiz)}\n`);
+    const coste = () => fijos + costeLineas + (omitidos.length + omitidosPrevios > 0 ? tokensDeTexto(`${avisoDe(omitidos)}\n`) : 0);
+    let indice = 0;
+    while (coste() > presupuestoTokens && indice < porSacrificar.length) {
+        const victima = porSacrificar[indice];
+        indice++;
+        fuera.add(victima);
+        costeLineas -= tokensDeTexto(`${lineaDe(victima, raiz)}\n`);
+        omitidos = unicos.filter((h) => fuera.has(h));
+    }
+    incluidos = unicos.filter((h) => !fuera.has(h));
+    const lineas = incluidos.map((h) => lineaDe(h, raiz));
+    if (raiz)
+        lineas.unshift(`#raiz ${raiz}`);
+    const aviso = avisoDe(omitidos);
+    if (aviso)
+        lineas.push(aviso);
+    return {
+        texto: `${MARCA_ABRE}\n${lineas.join("\n")}\n${MARCA_CIERRA}`,
+        incluidos,
+        omitidos,
+    };
+}
+// ============================================================================
+// Absorción (cascada)
+// ============================================================================
+const RE_LINEA = /^T(\d+)(\*?) ([a-z]{2,4}) (.*)$/;
+/**
+ * Límites `[abre, cierra]` del bloque de registro dentro de un texto, o `null`
+ * si no hay bloque.
+ *
+ * Las marcas se buscan como LÍNEA COMPLETA, y la de apertura es la ÚLTIMA.
+ * Buscarlas como subcadena (y la primera) leía el bloque equivocado en dos casos
+ * reales:
+ *
+ * (a) El resumen persistido es «prosa + registro», y en la SIGUIENTE
+ *     compactación upstream se lo pasa entero al modelo dentro de
+ *     <previous-summary> pidiéndole un resumen actualizado. Si el modelo copia el
+ *     bloque en su prosa, esa copia va ANTES del registro de verdad y ganaba: se
+ *     heredaban hechos escritos por el modelo, que es exactamente lo que este
+ *     módulo existe para impedir — y como salen por `heredados`,
+ *     `verificarProcedencia` no los mira.
+ * (b) Un hecho cuyo texto contiene "</registro-denso>" (basta con que el usuario
+ *     lo pegue) cerraba el bloque en mitad de la lista y las líneas siguientes se
+ *     perdían EN SILENCIO. Con 3 hechos se absorbía 1.
+ *
+ * Una línea de hecho siempre empieza por "T<n> <clase> ", así que nunca es igual
+ * a una marca entera: la comparación por línea las distingue sin heurística.
+ */
+function localizarBloque(lineas) {
+    let abre = -1;
+    for (let i = lineas.length - 1; i >= 0; i--) {
+        if (lineas[i].trim() === MARCA_ABRE) {
+            abre = i;
+            break;
+        }
+    }
+    if (abre < 0)
+        return null;
+    for (let i = abre + 1; i < lineas.length; i++) {
+        if (lineas[i].trim() === MARCA_CIERRA)
+            return [abre, i];
+    }
+    return null;
+}
+/**
+ * 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 function omitidosDeRegistro(texto) {
+    const lineas = texto.split("\n");
+    const limites = localizarBloque(lineas);
+    if (!limites)
+        return 0;
+    for (const linea of lineas.slice(limites[0] + 1, limites[1])) {
+        const m = linea.trim().match(RE_OMITIDOS);
+        if (m)
+            return Number.parseInt(m[1], 10);
+    }
+    return 0;
+}
+/**
+ * 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 function absorberRegistro(texto) {
+    const lineas = texto.split("\n");
+    const limites = localizarBloque(lineas);
+    if (!limites)
+        return null;
+    const [abre, cierra] = limites;
+    const hechos = [];
+    let raiz = "";
+    for (const linea of lineas.slice(abre + 1, cierra)) {
+        const recortada = linea.trim();
+        if (recortada.startsWith("#raiz ")) {
+            raiz = recortada.slice("#raiz ".length);
+            continue;
+        }
+        const m = recortada.match(RE_LINEA);
+        if (!m)
+            continue;
+        // Se deshace la abreviatura AQUÍ: en memoria `texto` vuelve a ser literal,
+        // que es lo que hace verificable un hecho heredado el día que alguien lo
+        // compare contra su sesión de origen.
+        const bruto = m[4];
+        hechos.push({
+            turno: Number.parseInt(m[1], 10),
+            clase: m[3],
+            texto: raiz ? bruto.split(MARCA_RAIZ).join(raiz) : bruto,
+            heredado: true,
+        });
+    }
+    return hechos;
+}
+/**
+ * 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 function verificarProcedencia(hechos, mensajes) {
+    const cache = new Map();
+    const validos = [];
+    const invalidos = [];
+    const heredados = [];
+    for (const hecho of hechos) {
+        if (hecho.heredado) {
+            heredados.push(hecho);
+            continue;
+        }
+        if (hecho.turno < 0 || hecho.turno >= mensajes.length) {
+            invalidos.push(hecho);
+            continue;
+        }
+        let canonico = cache.get(hecho.turno);
+        if (canonico === undefined) {
+            canonico = serializarTurno(mensajes[hecho.turno]);
+            cache.set(hecho.turno, canonico);
+        }
+        const buscado = nucleo(hecho.texto);
+        // Los hechos "her" llevan "<nombre de herramienta> <primer argumento>", y
+        // esos dos trozos están en el turno pero no pegados. Se parte por el PRIMER
+        // espacio y SOLO por él: partir por todos convertía la puerta en "cada
+        // palabra aparece en algún sitio del turno", que es lo contrario de
+        // verificar. Con la versión anterior, el hecho inventado
+        // "her borra secreto produccion" pasaba como VÁLIDO contra un turno que
+        // decía "busca deploy en produccion y borra el fichero secreto".
+        const corte = hecho.clase === "her" ? buscado.indexOf(" ") : -1;
+        const ok = canonico.includes(buscado) ||
+            (corte > 0 && canonico.includes(buscado.slice(0, corte)) && canonico.includes(buscado.slice(corte + 1)));
+        (ok ? validos : invalidos).push(hecho);
+    }
+    return { validos, invalidos, heredados };
+}
+// ============================================================================
+// Reescritura completa
+// ============================================================================
+/**
+ * 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 function reescribirADenso(mensajes, presupuestoTokens, resumenAnterior) {
+    const previos = resumenAnterior ? (absorberRegistro(resumenAnterior) ?? []) : [];
+    const nuevos = extraerHechos(mensajes);
+    // Lo que el registro anterior YA declaraba perdido se arrastra: esos hechos no
+    // están en `previos` (nadie los escribió) y sin la cuenta nadie sabría que
+    // faltan. Ver `formatearRegistro`.
+    const omitidosPrevios = resumenAnterior ? omitidosDeRegistro(resumenAnterior) : 0;
+    return formatearRegistro([...previos, ...nuevos], presupuestoTokens, omitidosPrevios);
+}
+//# sourceMappingURL=registro-denso.js.map