@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/edicion/hueco.js

@@ -0,0 +1,162 @@
+/**
+ * Casar una edición cuando el modelo ELIDE el medio con `...`.
+ *
+ * EL CASO. El modelo quiere reescribir una función de treinta líneas y cambia
+ * dos. Retipear las otras veintiocho es caro y, sobre todo, es donde se
+ * equivoca: cada línea retecleada es una oportunidad de meter un espacio de
+ * más. Así que hace lo natural y nombra los extremos:
+ *
+ *     function total(items: Item[]) {
+ *     ...
+ *     }
+ *
+ * Hasta ahora eso era un rechazo seguro —«el texto no coincide exactamente»— y
+ * costaba un turno entero releyendo el fichero para volver a escribir a ciegas
+ * lo que ya estaba bien.
+ *
+ * POR QUÉ ESTO ES MÁS PELIGROSO QUE LOS DEMÁS CAMINOS, y por qué las anclas se
+ * comparan con IGUALDAD EXACTA de línea. Este camino se traga líneas que el
+ * modelo NO ha nombrado: todo lo que hay entre las dos anclas desaparece. Un
+ * fallo aquí no deja un espacio mal, borra código. Con esa apuesta encima de la
+ * mesa, la comparación laxa no se paga: `casarIgnorandoSangria` puede permitirse
+ * recortar la sangría porque el bloque que sustituye está enteramente escrito
+ * por el modelo; aquí no.
+ *
+ * Y hay una razón medida, no estética. Sobre el fichero de siete líneas del
+ * banco, el ancla de cierre es `}` y aparece DOS veces si se comparan las líneas
+ * recortadas: la del `for` interior (`    }`) y la de la función (`}`). Con
+ * igualdad exacta hay una sola, y es la correcta. La comparación laxa habría
+ * convertido este caso en una moneda al aire — o en un rechazo, si se es
+ * honesto con la ambigüedad.
+ *
+ * ALCANCE MEDIDO, para que nadie se lleve una sorpresa. Con la regla de ancla
+ * única, sobre las 1173 funciones de nivel superior de `src/core/` y el patrón
+ * `cabecera` + `...` + `}`, casan 164 (14%): en la práctica solo la ÚLTIMA
+ * función de cada fichero, porque el `}` de la columna cero de cualquier función
+ * posterior vuelve ambigua el ancla de cierre. Es el lado seguro de la moneda
+ * —rechazar cuesta un turno y tragarse líneas que nadie nombró cuesta código—,
+ * pero conviene no confundir «recuperado» con «recuperado siempre»: el resto
+ * sigue costando el turno. La carga `hueco-cierre-no-unico` lo mide, para que
+ * quien lo cambie tenga que cambiar una cifra y no una intuición.
+ *
+ * TRES INVARIANTES:
+ *
+ * 1. **Anclas a los dos lados.** Un `...` al principio deja el hueco sin fondo:
+ *    el reemplazo se comería el fichero desde su inicio. Cae por el invariante 2
+ *    y no por una guarda propia — la guarda propia estaba escrita y no se podía
+ *    poner roja, así que se quitó; el detalle está en el cuerpo.
+ * 2. **Cada ancla en un solo sitio.** La primera, única en todo el fichero; las
+ *    siguientes, únicas en lo que queda por detrás de la anterior. Dos
+ *    posiciones es una moneda al aire y se rechaza.
+ * 3. **El `newText` no puede llevar elisión.** Si el modelo elide también en el
+ *    reemplazo, escribirlo dejaría un `...` literal dentro del código. Ese es el
+ *    fallo que se lee como éxito: la edición «entra» y el fichero no compila.
+ */
+import { reSangrarComoElBloque, unidadDe } from "./sangria.js";
+/**
+ * Una línea que es SOLO una elisión, con el comentario que los modelos le
+ * cuelgan delante (`// ...`, `# ...`, `-- ...`, o abierto y cerrado de bloque) o
+ * sin él.
+ *
+ * Tiene que ser la línea entera. `...props,` es código real y no casa, que es
+ * justo lo que se quiere: la elisión es un gesto deliberado del modelo y ocupa
+ * su propia línea.
+ */
+const ELISION = /^\s*(?:\/\/|#|--|\/\*)?\s*(?:\.{3}|…)\s*(?:\*\/)?\s*$/;
+function esLineaDeElision(linea) {
+    return ELISION.test(linea);
+}
+/**
+ * Casa `oldText` contra `contenido` cuando el patrón elide el medio con `...`.
+ *
+ * Devuelve `null` cuando no hay elisión, cuando alguna ancla falta, cuando
+ * alguna casa en más de un sitio, o cuando el reemplazo también elide. `null`
+ * significa «no puedo», nunca «no hay»: quien llama sigue con su propio error.
+ */
+export function casarHuecoElidido(contenido, oldText, newText) {
+    const patron = oldText.split("\n");
+    // Líneas vacías de los extremos: ruido de copiado, igual que en la sangría.
+    while (patron.length > 0 && patron[0].trim() === "")
+        patron.shift();
+    while (patron.length > 0 && patron[patron.length - 1].trim() === "")
+        patron.pop();
+    if (!patron.some(esLineaDeElision))
+        return null;
+    // Invariante 3: si el reemplazo elide, no hay nada que escribir sin inventar.
+    if (newText.split("\n").some(esLineaDeElision))
+        return null;
+    // El patrón partido por sus elisiones. Un trozo vacío significa una elisión
+    // pegada a un extremo o a otra elisión — el hueco sin fondo del invariante 1.
+    //
+    // Aquí había una guarda explícita contra los trozos vacíos y la QUITÉ, porque
+    // no se podía poner roja: la rompí a propósito y la puerta siguió en verde.
+    // La razón es que el invariante 2 ya la cubre, y se demuestra: un ancla vacía
+    // casa en TODAS las posiciones desde `desde`, o sea `lineas.length - desde + 1`
+    // de ellas. Para una elisión delantera `desde` es 0 y eso son al menos dos
+    // posiciones en cualquier fichero, luego «una sola posición» la rechaza
+    // siempre. Una guarda que no se puede poner roja es una invariante declarada y
+    // no comprobada, que es peor que no declararla.
+    const anclas = [[]];
+    for (const linea of patron) {
+        if (esLineaDeElision(linea))
+            anclas.push([]);
+        else
+            anclas[anclas.length - 1].push(linea);
+    }
+    const lineas = contenido.split("\n");
+    // Invariante 2: cada ancla en un solo sitio, y por detrás de la anterior.
+    let desde = 0;
+    let primeraLinea = -1;
+    let ultimaLinea = -1;
+    for (const ancla of anclas) {
+        const posiciones = [];
+        for (let i = desde; i + ancla.length <= lineas.length; i++) {
+            let casa = true;
+            for (let j = 0; j < ancla.length; j++) {
+                if (lineas[i + j] !== ancla[j]) {
+                    casa = false;
+                    break;
+                }
+            }
+            if (casa)
+                posiciones.push(i);
+        }
+        if (posiciones.length !== 1)
+            return null;
+        if (primeraLinea === -1)
+            primeraLinea = posiciones[0];
+        ultimaLinea = posiciones[0] + ancla.length - 1;
+        desde = ultimaLinea + 1;
+    }
+    // Desplazamientos en el contenido original: hay que contar los saltos.
+    let indice = 0;
+    for (let i = 0; i < primeraLinea; i++)
+        indice += lineas[i].length + 1;
+    let longitud = 0;
+    for (let i = primeraLinea; i <= ultimaLinea; i++)
+        longitud += lineas[i].length + 1;
+    longitud -= 1;
+    // El CARÁCTER de sangría sale del fichero, igual que en `casarIgnorandoSangria`.
+    //
+    // Aquí se escribía el `newText` tal cual, y eso rompía en este camino el
+    // invariante 2 del módulo de al lado. Medido con la carga `hueco-elidido`: el
+    // fichero se sangra con cuatro espacios, el modelo elide y manda
+    // `\treturn 0;`, y entraba un TABULADOR en un fichero de espacios. Es una de
+    // las dos formas exactas en las que corrompe oh-my-pi —«aplica y deja la
+    // sangría mal»—, y el banco la daba por correcta. En TypeScript es cosmético;
+    // en Python es un error de sintaxis, o peor, una línea que se sale del bloque
+    // `if` sin romper nada.
+    //
+    // Se re-sangra SOLO si el carácter no coincide, y por qué: cuando el modelo ya
+    // usa el del fichero, reescribir la sangría de todas sus líneas tocaría bytes
+    // que nadie ha pedido tocar — el interior de una plantilla multilínea es
+    // contenido, no estructura. Con el carácter equivocado no hay elección: esas
+    // líneas ya están mal.
+    const bloque = lineas.slice(primeraLinea, ultimaLinea + 1);
+    const nuevas = newText.split("\n");
+    const textoNuevo = unidadDe(bloque).caracter === unidadDe(nuevas).caracter
+        ? newText
+        : reSangrarComoElBloque(nuevas, bloque).join("\n");
+    return { indice, longitud, textoNuevo };
+}
+//# sourceMappingURL=hueco.js.map

package/dist/core/edicion/hueco.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hueco.js","sourceRoot":"","sources":["../../../src/core/edicion/hueco.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Casar una edición cuando el modelo ELIDE el medio con `...`.\n *\n * EL CASO. El modelo quiere reescribir una función de treinta líneas y cambia\n * dos. Retipear las otras veintiocho es caro y, sobre todo, es donde se\n * equivoca: cada línea retecleada es una oportunidad de meter un espacio de\n * más. Así que hace lo natural y nombra los extremos:\n *\n *     function total(items: Item[]) {\n *     ...\n *     }\n *\n * Hasta ahora eso era un rechazo seguro —«el texto no coincide exactamente»— y\n * costaba un turno entero releyendo el fichero para volver a escribir a ciegas\n * lo que ya estaba bien.\n *\n * POR QUÉ ESTO ES MÁS PELIGROSO QUE LOS DEMÁS CAMINOS, y por qué las anclas se\n * comparan con IGUALDAD EXACTA de línea. Este camino se traga líneas que el\n * modelo NO ha nombrado: todo lo que hay entre las dos anclas desaparece. Un\n * fallo aquí no deja un espacio mal, borra código. Con esa apuesta encima de la\n * mesa, la comparación laxa no se paga: `casarIgnorandoSangria` puede permitirse\n * recortar la sangría porque el bloque que sustituye está enteramente escrito\n * por el modelo; aquí no.\n *\n * Y hay una razón medida, no estética. Sobre el fichero de siete líneas del\n * banco, el ancla de cierre es `}` y aparece DOS veces si se comparan las líneas\n * recortadas: la del `for` interior (`    }`) y la de la función (`}`). Con\n * igualdad exacta hay una sola, y es la correcta. La comparación laxa habría\n * convertido este caso en una moneda al aire — o en un rechazo, si se es\n * honesto con la ambigüedad.\n *\n * ALCANCE MEDIDO, para que nadie se lleve una sorpresa. Con la regla de ancla\n * única, sobre las 1173 funciones de nivel superior de `src/core/` y el patrón\n * `cabecera` + `...` + `}`, casan 164 (14%): en la práctica solo la ÚLTIMA\n * función de cada fichero, porque el `}` de la columna cero de cualquier función\n * posterior vuelve ambigua el ancla de cierre. Es el lado seguro de la moneda\n * —rechazar cuesta un turno y tragarse líneas que nadie nombró cuesta código—,\n * pero conviene no confundir «recuperado» con «recuperado siempre»: el resto\n * sigue costando el turno. La carga `hueco-cierre-no-unico` lo mide, para que\n * quien lo cambie tenga que cambiar una cifra y no una intuición.\n *\n * TRES INVARIANTES:\n *\n * 1. **Anclas a los dos lados.** Un `...` al principio deja el hueco sin fondo:\n *    el reemplazo se comería el fichero desde su inicio. Cae por el invariante 2\n *    y no por una guarda propia — la guarda propia estaba escrita y no se podía\n *    poner roja, así que se quitó; el detalle está en el cuerpo.\n * 2. **Cada ancla en un solo sitio.** La primera, única en todo el fichero; las\n *    siguientes, únicas en lo que queda por detrás de la anterior. Dos\n *    posiciones es una moneda al aire y se rechaza.\n * 3. **El `newText` no puede llevar elisión.** Si el modelo elide también en el\n *    reemplazo, escribirlo dejaría un `...` literal dentro del código. Ese es el\n *    fallo que se lee como éxito: la edición «entra» y el fichero no compila.\n */\n\nimport { type CasadoPorSangria, reSangrarComoElBloque, unidadDe } from \"./sangria.ts\";\n\n/**\n * Una línea que es SOLO una elisión, con el comentario que los modelos le\n * cuelgan delante (`// ...`, `# ...`, `-- ...`, o abierto y cerrado de bloque) o\n * sin él.\n *\n * Tiene que ser la línea entera. `...props,` es código real y no casa, que es\n * justo lo que se quiere: la elisión es un gesto deliberado del modelo y ocupa\n * su propia línea.\n */\nconst ELISION = /^\\s*(?:\\/\\/|#|--|\\/\\*)?\\s*(?:\\.{3}|…)\\s*(?:\\*\\/)?\\s*$/;\n\nfunction esLineaDeElision(linea: string): boolean {\n\treturn ELISION.test(linea);\n}\n\n/**\n * Casa `oldText` contra `contenido` cuando el patrón elide el medio con `...`.\n *\n * Devuelve `null` cuando no hay elisión, cuando alguna ancla falta, cuando\n * alguna casa en más de un sitio, o cuando el reemplazo también elide. `null`\n * significa «no puedo», nunca «no hay»: quien llama sigue con su propio error.\n */\nexport function casarHuecoElidido(contenido: string, oldText: string, newText: string): CasadoPorSangria | null {\n\tconst patron = oldText.split(\"\\n\");\n\t// Líneas vacías de los extremos: ruido de copiado, igual que en la sangría.\n\twhile (patron.length > 0 && patron[0].trim() === \"\") patron.shift();\n\twhile (patron.length > 0 && patron[patron.length - 1].trim() === \"\") patron.pop();\n\tif (!patron.some(esLineaDeElision)) return null;\n\n\t// Invariante 3: si el reemplazo elide, no hay nada que escribir sin inventar.\n\tif (newText.split(\"\\n\").some(esLineaDeElision)) return null;\n\n\t// El patrón partido por sus elisiones. Un trozo vacío significa una elisión\n\t// pegada a un extremo o a otra elisión — el hueco sin fondo del invariante 1.\n\t//\n\t// Aquí había una guarda explícita contra los trozos vacíos y la QUITÉ, porque\n\t// no se podía poner roja: la rompí a propósito y la puerta siguió en verde.\n\t// La razón es que el invariante 2 ya la cubre, y se demuestra: un ancla vacía\n\t// casa en TODAS las posiciones desde `desde`, o sea `lineas.length - desde + 1`\n\t// de ellas. Para una elisión delantera `desde` es 0 y eso son al menos dos\n\t// posiciones en cualquier fichero, luego «una sola posición» la rechaza\n\t// siempre. Una guarda que no se puede poner roja es una invariante declarada y\n\t// no comprobada, que es peor que no declararla.\n\tconst anclas: string[][] = [[]];\n\tfor (const linea of patron) {\n\t\tif (esLineaDeElision(linea)) anclas.push([]);\n\t\telse anclas[anclas.length - 1].push(linea);\n\t}\n\n\tconst lineas = contenido.split(\"\\n\");\n\n\t// Invariante 2: cada ancla en un solo sitio, y por detrás de la anterior.\n\tlet desde = 0;\n\tlet primeraLinea = -1;\n\tlet ultimaLinea = -1;\n\tfor (const ancla of anclas) {\n\t\tconst posiciones: number[] = [];\n\t\tfor (let i = desde; i + ancla.length <= lineas.length; i++) {\n\t\t\tlet casa = true;\n\t\t\tfor (let j = 0; j < ancla.length; j++) {\n\t\t\t\tif (lineas[i + j] !== ancla[j]) {\n\t\t\t\t\tcasa = false;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (casa) posiciones.push(i);\n\t\t}\n\t\tif (posiciones.length !== 1) return null;\n\t\tif (primeraLinea === -1) primeraLinea = posiciones[0];\n\t\tultimaLinea = posiciones[0] + ancla.length - 1;\n\t\tdesde = ultimaLinea + 1;\n\t}\n\n\t// Desplazamientos en el contenido original: hay que contar los saltos.\n\tlet indice = 0;\n\tfor (let i = 0; i < primeraLinea; i++) indice += lineas[i].length + 1;\n\tlet longitud = 0;\n\tfor (let i = primeraLinea; i <= ultimaLinea; i++) longitud += lineas[i].length + 1;\n\tlongitud -= 1;\n\n\t// El CARÁCTER de sangría sale del fichero, igual que en `casarIgnorandoSangria`.\n\t//\n\t// Aquí se escribía el `newText` tal cual, y eso rompía en este camino el\n\t// invariante 2 del módulo de al lado. Medido con la carga `hueco-elidido`: el\n\t// fichero se sangra con cuatro espacios, el modelo elide y manda\n\t// `\\treturn 0;`, y entraba un TABULADOR en un fichero de espacios. Es una de\n\t// las dos formas exactas en las que corrompe oh-my-pi —«aplica y deja la\n\t// sangría mal»—, y el banco la daba por correcta. En TypeScript es cosmético;\n\t// en Python es un error de sintaxis, o peor, una línea que se sale del bloque\n\t// `if` sin romper nada.\n\t//\n\t// Se re-sangra SOLO si el carácter no coincide, y por qué: cuando el modelo ya\n\t// usa el del fichero, reescribir la sangría de todas sus líneas tocaría bytes\n\t// que nadie ha pedido tocar — el interior de una plantilla multilínea es\n\t// contenido, no estructura. Con el carácter equivocado no hay elección: esas\n\t// líneas ya están mal.\n\tconst bloque = lineas.slice(primeraLinea, ultimaLinea + 1);\n\tconst nuevas = newText.split(\"\\n\");\n\tconst textoNuevo =\n\t\tunidadDe(bloque).caracter === unidadDe(nuevas).caracter\n\t\t\t? newText\n\t\t\t: reSangrarComoElBloque(nuevas, bloque).join(\"\\n\");\n\treturn { indice, longitud, textoNuevo };\n}\n"]}

package/dist/core/edicion/limpiar-carga.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Quitarle a un `oldText` el ruido que no es código.
+ *
+ * EL CASO MÁS VERGONZOSO ES EL NUESTRO. Nuestro propio `read` añade al final de
+ * lo que devuelve una línea como:
+ *
+ *     [Showing lines 1-5 of 5. Use offset=6 to continue.]
+ *
+ * El modelo lee un fichero, copia el bloque que quiere cambiar —cabecera
+ * incluida, porque venía pegada— y nosotros rechazamos la edición porque «el
+ * texto no coincide exactamente». Generamos la contaminación y luego la
+ * castigamos.
+ *
+ * Los otros tres son ruido que los modelos añaden solos y que ninguna de las
+ * dos partes discute que sea ruido: vallas de markdown, sentinelas de sobre de
+ * parche, y los números de línea de un `grep`.
+ *
+ * LA REGLA QUE EVITA HACER DAÑO: solo se quita lo que es INEQUÍVOCO. Un `3:` al
+ * principio de una línea podría ser una etiqueta de código real, así que solo se
+ * trata como número de línea cuando TODAS las líneas lo llevan y además los
+ * números van en orden. Preferimos dejar ruido que borrar código: quitar de más
+ * cambia el patrón y lo casa en el sitio equivocado, y eso es corrupción
+ * silenciosa — la clase de fallo que más cara nos ha salido.
+ */
+/** Lo que se quitó, para poder explicarlo en un error. */
+export interface CargaLimpia {
+    texto: string;
+    /** Qué se retiró, en orden. Vacío = no había ruido. */
+    quitado: readonly string[];
+}
+/**
+ * Limpia `oldText`. Devuelve el texto y qué se quitó.
+ *
+ * Si no había nada que quitar, `quitado` viene vacío y `texto` es idéntico al
+ * de entrada — quien llama puede así distinguir «lo he limpiado» de «no había
+ * nada», sin comparar cadenas.
+ */
+export declare function limpiarCarga(oldText: string): CargaLimpia;
+//# sourceMappingURL=limpiar-carga.d.ts.map

package/dist/core/edicion/limpiar-carga.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limpiar-carga.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/limpiar-carga.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,2DAA0D;AAC1D,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,2DAAuD;IACvD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AAgFD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAUzD","sourcesContent":["/**\n * Quitarle a un `oldText` el ruido que no es código.\n *\n * EL CASO MÁS VERGONZOSO ES EL NUESTRO. Nuestro propio `read` añade al final de\n * lo que devuelve una línea como:\n *\n *     [Showing lines 1-5 of 5. Use offset=6 to continue.]\n *\n * El modelo lee un fichero, copia el bloque que quiere cambiar —cabecera\n * incluida, porque venía pegada— y nosotros rechazamos la edición porque «el\n * texto no coincide exactamente». Generamos la contaminación y luego la\n * castigamos.\n *\n * Los otros tres son ruido que los modelos añaden solos y que ninguna de las\n * dos partes discute que sea ruido: vallas de markdown, sentinelas de sobre de\n * parche, y los números de línea de un `grep`.\n *\n * LA REGLA QUE EVITA HACER DAÑO: solo se quita lo que es INEQUÍVOCO. Un `3:` al\n * principio de una línea podría ser una etiqueta de código real, así que solo se\n * trata como número de línea cuando TODAS las líneas lo llevan y además los\n * números van en orden. Preferimos dejar ruido que borrar código: quitar de más\n * cambia el patrón y lo casa en el sitio equivocado, y eso es corrupción\n * silenciosa — la clase de fallo que más cara nos ha salido.\n */\n\n/** Lo que se quitó, para poder explicarlo en un error. */\nexport interface CargaLimpia {\n\ttexto: string;\n\t/** Qué se retiró, en orden. Vacío = no había ruido. */\n\tquitado: readonly string[];\n}\n\n/** ```ts … ``` envolviendo el bloque entero. */\nfunction quitarValla(lineas: string[]): string | undefined {\n\tif (lineas.length < 2) return undefined;\n\tconst primera = lineas[0].trim();\n\tconst ultima = lineas[lineas.length - 1].trim();\n\tif (!primera.startsWith(\"```\") || ultima !== \"```\") return undefined;\n\t// La apertura puede llevar el lenguaje (```ts); el cierre nunca lleva nada.\n\tlineas.splice(lineas.length - 1, 1);\n\tlineas.splice(0, 1);\n\treturn \"valla de markdown\";\n}\n\n/** `*** Begin Patch` / `*** End Patch` y sus variantes. */\nconst SOBRE = /^\\*{3}\\s*(begin|end)\\b|^(begin|end)(\\s+of)?\\s+(patch|edits?|file)\\b/i;\n\nfunction quitarSobre(lineas: string[]): string | undefined {\n\tlet quitadas = 0;\n\twhile (lineas.length > 0 && SOBRE.test(lineas[0].trim())) {\n\t\tlineas.shift();\n\t\tquitadas++;\n\t}\n\twhile (lineas.length > 0 && SOBRE.test(lineas[lineas.length - 1].trim())) {\n\t\tlineas.pop();\n\t\tquitadas++;\n\t}\n\treturn quitadas > 0 ? \"sentinelas de sobre de parche\" : undefined;\n}\n\n/**\n * La cabecera que añade NUESTRO `read`.\n *\n * Se reconoce por su forma exacta y solo al principio o al final, nunca en\n * medio: en medio sería contenido del fichero.\n */\nconst CABECERA_READ = /^\\[Showing lines \\d+-\\d+ of \\d+\\.( Use offset=\\d+ to continue\\.)?\\]$/;\n/** Y la de un fichero truncado, del mismo sitio. */\nconst CABECERA_TRUNCADO = /^\\[(File truncated|Truncated|Showing first) .*\\]$/i;\n\nfunction quitarCabeceraPropia(lineas: string[]): string | undefined {\n\tconst es = (l: string) => CABECERA_READ.test(l.trim()) || CABECERA_TRUNCADO.test(l.trim());\n\tlet quitadas = 0;\n\twhile (lineas.length > 0 && es(lineas[0])) {\n\t\tlineas.shift();\n\t\tquitadas++;\n\t}\n\twhile (lineas.length > 0 && es(lineas[lineas.length - 1])) {\n\t\tlineas.pop();\n\t\tquitadas++;\n\t}\n\treturn quitadas > 0 ? \"la cabecera que añade nuestro propio read\" : undefined;\n}\n\n/**\n * Números de línea de un `grep` o un `read` numerado: `12:` o `12-`.\n *\n * Solo si TODAS las líneas no vacías lo llevan Y los números son consecutivos.\n * Con una sola de las dos condiciones se dejaría de tocar código real: un\n * `case 3:` o un fragmento de YAML con `80:` cumplirían la primera.\n */\nfunction quitarNumerosDeLinea(lineas: string[]): string | undefined {\n\tconst noVacias = lineas.filter((l) => l.trim() !== \"\");\n\tif (noVacias.length === 0) return undefined;\n\tconst numeros: number[] = [];\n\tfor (const linea of noVacias) {\n\t\tconst m = linea.match(/^\\s*(\\d+)[:\\-\\t]/);\n\t\tif (!m) return undefined;\n\t\tnumeros.push(Number(m[1]));\n\t}\n\t// Consecutivos, y por tanto números de línea y no datos.\n\tfor (let i = 1; i < numeros.length; i++) {\n\t\tif (numeros[i] !== numeros[i - 1] + 1) return undefined;\n\t}\n\tfor (let i = 0; i < lineas.length; i++) {\n\t\tlineas[i] = lineas[i].replace(/^\\s*\\d+[:\\-\\t]/, \"\");\n\t}\n\treturn \"números de línea\";\n}\n\n/**\n * Limpia `oldText`. Devuelve el texto y qué se quitó.\n *\n * Si no había nada que quitar, `quitado` viene vacío y `texto` es idéntico al\n * de entrada — quien llama puede así distinguir «lo he limpiado» de «no había\n * nada», sin comparar cadenas.\n */\nexport function limpiarCarga(oldText: string): CargaLimpia {\n\tconst lineas = oldText.split(\"\\n\");\n\tconst quitado: string[] = [];\n\t// Orden: primero los envoltorios de fuera adentro, y los números al final\n\t// porque una valla o un sobre romperían la comprobación de consecutivos.\n\tfor (const paso of [quitarValla, quitarSobre, quitarCabeceraPropia, quitarNumerosDeLinea]) {\n\t\tconst que = paso(lineas);\n\t\tif (que) quitado.push(que);\n\t}\n\treturn { texto: lineas.join(\"\\n\"), quitado };\n}\n"]}

package/dist/core/edicion/limpiar-carga.js

@@ -0,0 +1,121 @@
+/**
+ * Quitarle a un `oldText` el ruido que no es código.
+ *
+ * EL CASO MÁS VERGONZOSO ES EL NUESTRO. Nuestro propio `read` añade al final de
+ * lo que devuelve una línea como:
+ *
+ *     [Showing lines 1-5 of 5. Use offset=6 to continue.]
+ *
+ * El modelo lee un fichero, copia el bloque que quiere cambiar —cabecera
+ * incluida, porque venía pegada— y nosotros rechazamos la edición porque «el
+ * texto no coincide exactamente». Generamos la contaminación y luego la
+ * castigamos.
+ *
+ * Los otros tres son ruido que los modelos añaden solos y que ninguna de las
+ * dos partes discute que sea ruido: vallas de markdown, sentinelas de sobre de
+ * parche, y los números de línea de un `grep`.
+ *
+ * LA REGLA QUE EVITA HACER DAÑO: solo se quita lo que es INEQUÍVOCO. Un `3:` al
+ * principio de una línea podría ser una etiqueta de código real, así que solo se
+ * trata como número de línea cuando TODAS las líneas lo llevan y además los
+ * números van en orden. Preferimos dejar ruido que borrar código: quitar de más
+ * cambia el patrón y lo casa en el sitio equivocado, y eso es corrupción
+ * silenciosa — la clase de fallo que más cara nos ha salido.
+ */
+/** ```ts … ``` envolviendo el bloque entero. */
+function quitarValla(lineas) {
+    if (lineas.length < 2)
+        return undefined;
+    const primera = lineas[0].trim();
+    const ultima = lineas[lineas.length - 1].trim();
+    if (!primera.startsWith("```") || ultima !== "```")
+        return undefined;
+    // La apertura puede llevar el lenguaje (```ts); el cierre nunca lleva nada.
+    lineas.splice(lineas.length - 1, 1);
+    lineas.splice(0, 1);
+    return "valla de markdown";
+}
+/** `*** Begin Patch` / `*** End Patch` y sus variantes. */
+const SOBRE = /^\*{3}\s*(begin|end)\b|^(begin|end)(\s+of)?\s+(patch|edits?|file)\b/i;
+function quitarSobre(lineas) {
+    let quitadas = 0;
+    while (lineas.length > 0 && SOBRE.test(lineas[0].trim())) {
+        lineas.shift();
+        quitadas++;
+    }
+    while (lineas.length > 0 && SOBRE.test(lineas[lineas.length - 1].trim())) {
+        lineas.pop();
+        quitadas++;
+    }
+    return quitadas > 0 ? "sentinelas de sobre de parche" : undefined;
+}
+/**
+ * La cabecera que añade NUESTRO `read`.
+ *
+ * Se reconoce por su forma exacta y solo al principio o al final, nunca en
+ * medio: en medio sería contenido del fichero.
+ */
+const CABECERA_READ = /^\[Showing lines \d+-\d+ of \d+\.( Use offset=\d+ to continue\.)?\]$/;
+/** Y la de un fichero truncado, del mismo sitio. */
+const CABECERA_TRUNCADO = /^\[(File truncated|Truncated|Showing first) .*\]$/i;
+function quitarCabeceraPropia(lineas) {
+    const es = (l) => CABECERA_READ.test(l.trim()) || CABECERA_TRUNCADO.test(l.trim());
+    let quitadas = 0;
+    while (lineas.length > 0 && es(lineas[0])) {
+        lineas.shift();
+        quitadas++;
+    }
+    while (lineas.length > 0 && es(lineas[lineas.length - 1])) {
+        lineas.pop();
+        quitadas++;
+    }
+    return quitadas > 0 ? "la cabecera que añade nuestro propio read" : undefined;
+}
+/**
+ * Números de línea de un `grep` o un `read` numerado: `12:` o `12-`.
+ *
+ * Solo si TODAS las líneas no vacías lo llevan Y los números son consecutivos.
+ * Con una sola de las dos condiciones se dejaría de tocar código real: un
+ * `case 3:` o un fragmento de YAML con `80:` cumplirían la primera.
+ */
+function quitarNumerosDeLinea(lineas) {
+    const noVacias = lineas.filter((l) => l.trim() !== "");
+    if (noVacias.length === 0)
+        return undefined;
+    const numeros = [];
+    for (const linea of noVacias) {
+        const m = linea.match(/^\s*(\d+)[:\-\t]/);
+        if (!m)
+            return undefined;
+        numeros.push(Number(m[1]));
+    }
+    // Consecutivos, y por tanto números de línea y no datos.
+    for (let i = 1; i < numeros.length; i++) {
+        if (numeros[i] !== numeros[i - 1] + 1)
+            return undefined;
+    }
+    for (let i = 0; i < lineas.length; i++) {
+        lineas[i] = lineas[i].replace(/^\s*\d+[:\-\t]/, "");
+    }
+    return "números de línea";
+}
+/**
+ * Limpia `oldText`. Devuelve el texto y qué se quitó.
+ *
+ * Si no había nada que quitar, `quitado` viene vacío y `texto` es idéntico al
+ * de entrada — quien llama puede así distinguir «lo he limpiado» de «no había
+ * nada», sin comparar cadenas.
+ */
+export function limpiarCarga(oldText) {
+    const lineas = oldText.split("\n");
+    const quitado = [];
+    // Orden: primero los envoltorios de fuera adentro, y los números al final
+    // porque una valla o un sobre romperían la comprobación de consecutivos.
+    for (const paso of [quitarValla, quitarSobre, quitarCabeceraPropia, quitarNumerosDeLinea]) {
+        const que = paso(lineas);
+        if (que)
+            quitado.push(que);
+    }
+    return { texto: lineas.join("\n"), quitado };
+}
+//# sourceMappingURL=limpiar-carga.js.map

package/dist/core/edicion/limpiar-carga.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limpiar-carga.js","sourceRoot":"","sources":["../../../src/core/edicion/limpiar-carga.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Quitarle a un `oldText` el ruido que no es código.\n *\n * EL CASO MÁS VERGONZOSO ES EL NUESTRO. Nuestro propio `read` añade al final de\n * lo que devuelve una línea como:\n *\n *     [Showing lines 1-5 of 5. Use offset=6 to continue.]\n *\n * El modelo lee un fichero, copia el bloque que quiere cambiar —cabecera\n * incluida, porque venía pegada— y nosotros rechazamos la edición porque «el\n * texto no coincide exactamente». Generamos la contaminación y luego la\n * castigamos.\n *\n * Los otros tres son ruido que los modelos añaden solos y que ninguna de las\n * dos partes discute que sea ruido: vallas de markdown, sentinelas de sobre de\n * parche, y los números de línea de un `grep`.\n *\n * LA REGLA QUE EVITA HACER DAÑO: solo se quita lo que es INEQUÍVOCO. Un `3:` al\n * principio de una línea podría ser una etiqueta de código real, así que solo se\n * trata como número de línea cuando TODAS las líneas lo llevan y además los\n * números van en orden. Preferimos dejar ruido que borrar código: quitar de más\n * cambia el patrón y lo casa en el sitio equivocado, y eso es corrupción\n * silenciosa — la clase de fallo que más cara nos ha salido.\n */\n\n/** Lo que se quitó, para poder explicarlo en un error. */\nexport interface CargaLimpia {\n\ttexto: string;\n\t/** Qué se retiró, en orden. Vacío = no había ruido. */\n\tquitado: readonly string[];\n}\n\n/** ```ts … ``` envolviendo el bloque entero. */\nfunction quitarValla(lineas: string[]): string | undefined {\n\tif (lineas.length < 2) return undefined;\n\tconst primera = lineas[0].trim();\n\tconst ultima = lineas[lineas.length - 1].trim();\n\tif (!primera.startsWith(\"```\") || ultima !== \"```\") return undefined;\n\t// La apertura puede llevar el lenguaje (```ts); el cierre nunca lleva nada.\n\tlineas.splice(lineas.length - 1, 1);\n\tlineas.splice(0, 1);\n\treturn \"valla de markdown\";\n}\n\n/** `*** Begin Patch` / `*** End Patch` y sus variantes. */\nconst SOBRE = /^\\*{3}\\s*(begin|end)\\b|^(begin|end)(\\s+of)?\\s+(patch|edits?|file)\\b/i;\n\nfunction quitarSobre(lineas: string[]): string | undefined {\n\tlet quitadas = 0;\n\twhile (lineas.length > 0 && SOBRE.test(lineas[0].trim())) {\n\t\tlineas.shift();\n\t\tquitadas++;\n\t}\n\twhile (lineas.length > 0 && SOBRE.test(lineas[lineas.length - 1].trim())) {\n\t\tlineas.pop();\n\t\tquitadas++;\n\t}\n\treturn quitadas > 0 ? \"sentinelas de sobre de parche\" : undefined;\n}\n\n/**\n * La cabecera que añade NUESTRO `read`.\n *\n * Se reconoce por su forma exacta y solo al principio o al final, nunca en\n * medio: en medio sería contenido del fichero.\n */\nconst CABECERA_READ = /^\\[Showing lines \\d+-\\d+ of \\d+\\.( Use offset=\\d+ to continue\\.)?\\]$/;\n/** Y la de un fichero truncado, del mismo sitio. */\nconst CABECERA_TRUNCADO = /^\\[(File truncated|Truncated|Showing first) .*\\]$/i;\n\nfunction quitarCabeceraPropia(lineas: string[]): string | undefined {\n\tconst es = (l: string) => CABECERA_READ.test(l.trim()) || CABECERA_TRUNCADO.test(l.trim());\n\tlet quitadas = 0;\n\twhile (lineas.length > 0 && es(lineas[0])) {\n\t\tlineas.shift();\n\t\tquitadas++;\n\t}\n\twhile (lineas.length > 0 && es(lineas[lineas.length - 1])) {\n\t\tlineas.pop();\n\t\tquitadas++;\n\t}\n\treturn quitadas > 0 ? \"la cabecera que añade nuestro propio read\" : undefined;\n}\n\n/**\n * Números de línea de un `grep` o un `read` numerado: `12:` o `12-`.\n *\n * Solo si TODAS las líneas no vacías lo llevan Y los números son consecutivos.\n * Con una sola de las dos condiciones se dejaría de tocar código real: un\n * `case 3:` o un fragmento de YAML con `80:` cumplirían la primera.\n */\nfunction quitarNumerosDeLinea(lineas: string[]): string | undefined {\n\tconst noVacias = lineas.filter((l) => l.trim() !== \"\");\n\tif (noVacias.length === 0) return undefined;\n\tconst numeros: number[] = [];\n\tfor (const linea of noVacias) {\n\t\tconst m = linea.match(/^\\s*(\\d+)[:\\-\\t]/);\n\t\tif (!m) return undefined;\n\t\tnumeros.push(Number(m[1]));\n\t}\n\t// Consecutivos, y por tanto números de línea y no datos.\n\tfor (let i = 1; i < numeros.length; i++) {\n\t\tif (numeros[i] !== numeros[i - 1] + 1) return undefined;\n\t}\n\tfor (let i = 0; i < lineas.length; i++) {\n\t\tlineas[i] = lineas[i].replace(/^\\s*\\d+[:\\-\\t]/, \"\");\n\t}\n\treturn \"números de línea\";\n}\n\n/**\n * Limpia `oldText`. Devuelve el texto y qué se quitó.\n *\n * Si no había nada que quitar, `quitado` viene vacío y `texto` es idéntico al\n * de entrada — quien llama puede así distinguir «lo he limpiado» de «no había\n * nada», sin comparar cadenas.\n */\nexport function limpiarCarga(oldText: string): CargaLimpia {\n\tconst lineas = oldText.split(\"\\n\");\n\tconst quitado: string[] = [];\n\t// Orden: primero los envoltorios de fuera adentro, y los números al final\n\t// porque una valla o un sobre romperían la comprobación de consecutivos.\n\tfor (const paso of [quitarValla, quitarSobre, quitarCabeceraPropia, quitarNumerosDeLinea]) {\n\t\tconst que = paso(lineas);\n\t\tif (que) quitado.push(que);\n\t}\n\treturn { texto: lineas.join(\"\\n\"), quitado };\n}\n"]}

package/dist/core/edicion/observador.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Observa cada edición: avisa si ha dejado el fichero roto, intenta
+ * repararlo solo cuando puede, y deja constancia de las tres cosas en el
+ * diario.
+ *
+ * Se engancha en los dos manejadores que ya existen: `beforeToolCall` guarda la
+ * preimagen y `afterToolCall` compara. Vive en su propio módulo, y no dentro de
+ * `agent-session.ts`, porque ese fichero es de upstream y el presupuesto de
+ * fork está en el tope: cuanto menos código nuestro viva ahí, menos cuesta
+ * seguir siendo un fork.
+ *
+ * Lee el fichero dos veces por edición. Es a propósito: la alternativa es
+ * tocar las tools `edit` y `write`, que también son de upstream, y una lectura
+ * de más en una operación que ya escribe a disco no se nota. Si algún día pesa,
+ * la respuesta es un `EditToolOptions` aguas arriba, no cachear aquí.
+ */
+/**
+ * Lo que el libro de sesión necesita saber de una edición.
+ *
+ * Sale de aquí y no de `agent-session.ts` porque este observador YA lee el
+ * fichero antes y después: pedirlo en otro sitio obligaría a leerlo una tercera
+ * vez, y sobre todo dejaría fuera el caso reparado, donde el contenido final no
+ * es el que dejó la tool.
+ */
+export interface CambioDeFichero {
+    ruta: string;
+    /** Contenido previo, o `null` si el fichero no existía. Lo hashea el libro. */
+    antes: string | null;
+    /** Contenido final, ya con la reparación aplicada si hubo. `null` = borrado. */
+    despues: string | null;
+}
+export declare class ObservadorDeEdiciones {
+    /** Preimagen por id de llamada. La borra quien la consume. */
+    private readonly previas;
+    /**
+     * Cambio observado por id de llamada, a la espera de que el libro lo anote.
+     *
+     * Es un hueco de estado y no un valor de retorno porque `despuesDe` ya
+     * devuelve el aviso para el modelo y tiene dieciocho llamadas en pruebas:
+     * cambiarle la firma para colar un segundo dato habría costado dieciocho
+     * ediciones sin comprar nada.
+     *
+     * Va por id y no en una sola ranura, y esto lo enseñó la prueba de la ruta
+     * real: el modelo puede pedir dos `write` en el mismo turno y el bucle del
+     * agente los ejecuta entrelazados, así que con una ranura única el segundo
+     * pisaba al primero antes de que nadie lo leyera. El libro registraba UN
+     * fichero de los dos — un fallo silencioso que se lee como éxito, porque el
+     * informe salía con una tabla poblada y creíble a la que le faltaba una fila.
+     */
+    private readonly cambios;
+    /**
+     * El cambio de fichero de esa llamada, o `null` si no editó nada. Lo consume:
+     * dos lecturas seguidas devuelven `null` la segunda, así que una llamada no
+     * puede heredar el cambio de otra y anotarlo dos veces en el libro.
+     */
+    ultimoCambio(idLlamada: string): CambioDeFichero | null;
+    private readonly cwd;
+    private readonly agentDir;
+    /** `undefined` cuando no hay modelo disponible (p. ej. en pruebas): la reparación queda "no-aplicable", nunca "rechazada". */
+    private readonly completar?;
+    /**
+     * Se crea una vez por sesión y mantiene vivo el programa de TypeScript entre
+     * ediciones: es lo que hace que la primera comprobación cueste 2,5 s y las
+     * siguientes 124 ms.
+     */
+    private readonly tipos;
+    constructor(cwd: () => string, agentDir: () => string, completar?: (prompt: string) => Promise<string | null>);
+    /** Antes de editar: guarda cómo estaba el fichero. */
+    antesDe(idLlamada: string, tool: string, args: unknown): Promise<void>;
+    /**
+     * Después de editar: devuelve el aviso (roto, o reparado — hay algo que
+     * decir en los dos casos), o `null` si no hay nada que decir. Deja
+     * constancia en el diario pase lo que pase.
+     *
+     * `null` en la inmensa mayoría de ediciones es lo correcto y lo que hace que
+     * el aviso signifique algo cuando aparece.
+     */
+    despuesDe(idLlamada: string, huboError: boolean): Promise<string | null>;
+}
+//# sourceMappingURL=observador.d.ts.map

package/dist/core/edicion/observador.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observador.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/observador.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAYH;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,gFAA+E;IAC/E,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,iFAAgF;IAChF,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAkBD,qBAAa,qBAAqB;IACjC,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6D;IAErF;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;IAE9D;;;;OAIG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAItD;IAED,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC,+HAA8H;IAC9H,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAA6C;IACxE;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4B;IAIlD,YAAY,GAAG,EAAE,MAAM,MAAM,EAAE,QAAQ,EAAE,MAAM,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,EAI5G;IAED,uDAAsD;IAChD,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAO3E;IAED;;;;;;;OAOG;IACG,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiF7E;CACD","sourcesContent":["/**\n * Observa cada edición: avisa si ha dejado el fichero roto, intenta\n * repararlo solo cuando puede, y deja constancia de las tres cosas en el\n * diario.\n *\n * Se engancha en los dos manejadores que ya existen: `beforeToolCall` guarda la\n * preimagen y `afterToolCall` compara. Vive en su propio módulo, y no dentro de\n * `agent-session.ts`, porque ese fichero es de upstream y el presupuesto de\n * fork está en el tope: cuanto menos código nuestro viva ahí, menos cuesta\n * seguir siendo un fork.\n *\n * Lee el fichero dos veces por edición. Es a propósito: la alternativa es\n * tocar las tools `edit` y `write`, que también son de upstream, y una lectura\n * de más en una operación que ya escribe a disco no se nota. Si algún día pesa,\n * la respuesta es un `EditToolOptions` aguas arriba, no cachear aquí.\n */\n\nimport { readFile, writeFile } from \"node:fs/promises\";\nimport { resolveToCwd } from \"../tools/path-utils.ts\";\nimport { anotarEnDiario } from \"./diario.ts\";\nimport { avisoDeParseoRoto, primerErrorDe, rompioElParseo } from \"./parseo.ts\";\nimport { intentarReparar, type ResultadoReparacion } from \"./reparacion.ts\";\nimport { avisoDeTipos, ComprobadorDeTipos } from \"./tipos.ts\";\n\n/** Tools cuya salida es un fichero con contenido nuevo. */\nconst TOOLS_DE_EDICION = new Set([\"edit\", \"write\"]);\n\n/**\n * Lo que el libro de sesión necesita saber de una edición.\n *\n * Sale de aquí y no de `agent-session.ts` porque este observador YA lee el\n * fichero antes y después: pedirlo en otro sitio obligaría a leerlo una tercera\n * vez, y sobre todo dejaría fuera el caso reparado, donde el contenido final no\n * es el que dejó la tool.\n */\nexport interface CambioDeFichero {\n\truta: string;\n\t/** Contenido previo, o `null` si el fichero no existía. Lo hashea el libro. */\n\tantes: string | null;\n\t/** Contenido final, ya con la reparación aplicada si hubo. `null` = borrado. */\n\tdespues: string | null;\n}\n\n/** Lee el fichero, o `null` si no existe o no se puede leer. */\nasync function contenido(ruta: string): Promise<string | null> {\n\ttry {\n\t\treturn await readFile(ruta, \"utf-8\");\n\t} catch {\n\t\treturn null;\n\t}\n}\n\n/** La ruta que la tool va a tocar, ya resuelta contra el cwd. */\nfunction rutaDe(args: unknown, cwd: string): string | null {\n\tconst a = args as { path?: unknown; file_path?: unknown } | undefined;\n\tconst cruda = typeof a?.file_path === \"string\" ? a.file_path : typeof a?.path === \"string\" ? a.path : null;\n\treturn cruda === null ? null : resolveToCwd(cruda, cwd);\n}\n\nexport class ObservadorDeEdiciones {\n\t/** Preimagen por id de llamada. La borra quien la consume. */\n\tprivate readonly previas = new Map<string, { ruta: string; antes: string | null }>();\n\n\t/**\n\t * Cambio observado por id de llamada, a la espera de que el libro lo anote.\n\t *\n\t * Es un hueco de estado y no un valor de retorno porque `despuesDe` ya\n\t * devuelve el aviso para el modelo y tiene dieciocho llamadas en pruebas:\n\t * cambiarle la firma para colar un segundo dato habría costado dieciocho\n\t * ediciones sin comprar nada.\n\t *\n\t * Va por id y no en una sola ranura, y esto lo enseñó la prueba de la ruta\n\t * real: el modelo puede pedir dos `write` en el mismo turno y el bucle del\n\t * agente los ejecuta entrelazados, así que con una ranura única el segundo\n\t * pisaba al primero antes de que nadie lo leyera. El libro registraba UN\n\t * fichero de los dos — un fallo silencioso que se lee como éxito, porque el\n\t * informe salía con una tabla poblada y creíble a la que le faltaba una fila.\n\t */\n\tprivate readonly cambios = new Map<string, CambioDeFichero>();\n\n\t/**\n\t * El cambio de fichero de esa llamada, o `null` si no editó nada. Lo consume:\n\t * dos lecturas seguidas devuelven `null` la segunda, así que una llamada no\n\t * puede heredar el cambio de otra y anotarlo dos veces en el libro.\n\t */\n\tultimoCambio(idLlamada: string): CambioDeFichero | null {\n\t\tconst cambio = this.cambios.get(idLlamada) ?? null;\n\t\tthis.cambios.delete(idLlamada);\n\t\treturn cambio;\n\t}\n\n\tprivate readonly cwd: () => string;\n\tprivate readonly agentDir: () => string;\n\t/** `undefined` cuando no hay modelo disponible (p. ej. en pruebas): la reparación queda \"no-aplicable\", nunca \"rechazada\". */\n\tprivate readonly completar?: (prompt: string) => Promise<string | null>;\n\t/**\n\t * Se crea una vez por sesión y mantiene vivo el programa de TypeScript entre\n\t * ediciones: es lo que hace que la primera comprobación cueste 2,5 s y las\n\t * siguientes 124 ms.\n\t */\n\tprivate readonly tipos = new ComprobadorDeTipos();\n\n\t// Campos explícitos y no propiedades de parámetro: el proyecto compila con\n\t// `erasableSyntaxOnly`, que prohíbe la forma corta por no ser borrable.\n\tconstructor(cwd: () => string, agentDir: () => string, completar?: (prompt: string) => Promise<string | null>) {\n\t\tthis.cwd = cwd;\n\t\tthis.agentDir = agentDir;\n\t\tthis.completar = completar;\n\t}\n\n\t/** Antes de editar: guarda cómo estaba el fichero. */\n\tasync antesDe(idLlamada: string, tool: string, args: unknown): Promise<void> {\n\t\tif (!TOOLS_DE_EDICION.has(tool)) return;\n\t\tconst ruta = rutaDe(args, this.cwd());\n\t\tif (ruta === null) return;\n\t\t// Tope de seguridad por si alguna llamada muere antes de consumirse.\n\t\tif (this.previas.size > 256) this.previas.clear();\n\t\tthis.previas.set(idLlamada, { ruta, antes: await contenido(ruta) });\n\t}\n\n\t/**\n\t * Después de editar: devuelve el aviso (roto, o reparado — hay algo que\n\t * decir en los dos casos), o `null` si no hay nada que decir. Deja\n\t * constancia en el diario pase lo que pase.\n\t *\n\t * `null` en la inmensa mayoría de ediciones es lo correcto y lo que hace que\n\t * el aviso signifique algo cuando aparece.\n\t */\n\tasync despuesDe(idLlamada: string, huboError: boolean): Promise<string | null> {\n\t\tconst previa = this.previas.get(idLlamada);\n\t\tthis.previas.delete(idLlamada);\n\t\tif (!previa || huboError) return null;\n\n\t\tconst despues = await contenido(previa.ruta);\n\t\t// Para el libro de sesión: el fichero se tocó, pase lo que pase con el\n\t\t// parseo. Una edición que deja el fichero roto es MÁS auditable, no menos,\n\t\t// así que esto va antes de cualquier rama y no dentro de la de éxito.\n\t\t// Tope de seguridad, igual que en `previas`: si alguna llamada muriera sin\n\t\t// que nadie consumiera su cambio, el mapa no puede crecer sin fin.\n\t\tif (this.cambios.size > 256) this.cambios.clear();\n\t\tthis.cambios.set(idLlamada, { ruta: previa.ruta, antes: previa.antes, despues });\n\t\t// El orden es: sintaxis → reparación → tipos. No es arbitrario.\n\t\t//\n\t\t// Si el fichero no parsea, los errores de tipos son CONSECUENCIA de eso:\n\t\t// enseñarlos mandaría al modelo a perseguir síntomas en vez de la causa.\n\t\t// Y si la reparación funciona, los tipos hay que mirarlos sobre el\n\t\t// fichero YA REPARADO, no sobre el roto — mirarlos antes daría una lista\n\t\t// de errores que dejan de existir un instante después.\n\t\tif (!rompioElParseo({ ruta: previa.ruta, antes: previa.antes, despues })) {\n\t\t\tawait anotarEnDiario(this.agentDir(), { ruta: previa.ruta, antes: previa.antes, despues, resultado: \"ok\" });\n\t\t\tif (despues === null) return null;\n\t\t\t// Los tipos, que es lo que un comprobador de sintaxis nunca puede ver:\n\t\t\t// cambiar una firma y romper a quien la llama en OTRO fichero.\n\t\t\treturn avisoDeTipos(previa.ruta, this.tipos.introducidos(previa.ruta, previa.antes, despues));\n\t\t}\n\n\t\t// `rompioElParseo` solo devuelve `true` cuando `antes` y `despues` no son\n\t\t// `null` (así lo garantiza su propio contrato en parseo.ts) — el cast de\n\t\t// abajo es ese contrato leído, no una suposición nueva.\n\t\t//\n\t\t// Todo este bloque va protegido: un fallo aquí (disco lleno, permisos, el\n\t\t// fichero borrado por debajo entre la edición y este punto) no puede\n\t\t// tumbar el turno entero solo por intentar mejorar el aviso — se degrada\n\t\t// al aviso normal de parseo roto, igual que si la reparación se hubiera\n\t\t// rechazado.\n\t\tlet reparacion: ResultadoReparacion;\n\t\ttry {\n\t\t\treparacion = await intentarReparar(\n\t\t\t\t{ ruta: previa.ruta, antes: previa.antes as string, despues: despues as string },\n\t\t\t\tthis.completar,\n\t\t\t);\n\t\t\tif (reparacion.estado === \"reparado\") {\n\t\t\t\tawait writeFile(previa.ruta, reparacion.contenido, \"utf-8\");\n\t\t\t}\n\t\t} catch {\n\t\t\treparacion = { estado: \"rechazada\" };\n\t\t}\n\n\t\tif (reparacion.estado === \"reparado\") {\n\t\t\t// El libro tiene que llevar el hash de lo que QUEDÓ en disco, no el del\n\t\t\t// intermedio roto que la reparación acaba de sobrescribir: si no, el hash\n\t\t\t// del registro no coincidiría con el fichero y la auditoría acusaría una\n\t\t\t// manipulación donde solo hubo una reparación.\n\t\t\tthis.cambios.set(idLlamada, { ruta: previa.ruta, antes: previa.antes, despues: reparacion.contenido });\n\t\t\tawait anotarEnDiario(this.agentDir(), {\n\t\t\t\truta: previa.ruta,\n\t\t\t\tantes: previa.antes,\n\t\t\t\tdespues,\n\t\t\t\tresultado: \"reparada\",\n\t\t\t});\n\t\t\tconst intentos = reparacion.intentos > 1 ? ` (hicieron falta ${reparacion.intentos} intentos)` : \"\";\n\t\t\t// Sobre el fichero YA reparado: reparar la sintaxis no garantiza que\n\t\t\t// los tipos cuadren, y callarlo aquí convertiría un \"✓ reparado\" en una\n\t\t\t// media verdad.\n\t\t\tconst tipos = avisoDeTipos(\n\t\t\t\tprevia.ruta,\n\t\t\t\tthis.tipos.introducidos(previa.ruta, previa.antes, reparacion.contenido),\n\t\t\t);\n\t\t\tconst nota = `✓ Esta edición dejó \\`${previa.ruta}\\` sintácticamente roto, pero se ha reparado sola conservando el cambio pretendido${intentos}.`;\n\t\t\treturn tipos ? `${nota}\\n${tipos}` : nota;\n\t\t}\n\n\t\tvoid anotarEnDiario(this.agentDir(), {\n\t\t\truta: previa.ruta,\n\t\t\tantes: previa.antes,\n\t\t\tdespues,\n\t\t\tresultado: reparacion.estado === \"rechazada\" ? \"reparacion-rechazada\" : \"rota\",\n\t\t});\n\t\treturn avisoDeParseoRoto(previa.ruta, primerErrorDe(despues ?? \"\", previa.ruta));\n\t}\n}\n"]}