@hoilab/ada-cli 0.84.22 → 0.85.0

package/dist/core/banco/mutaciones.js

@@ -0,0 +1,215 @@
+/**
+ * Catálogo de mutaciones: bugs deterministas de una línea.
+ *
+ * ponytail: mutaciones por regex sobre texto, no por AST (a diferencia de
+ * oh-my-pi, que parsea con Babel). Para medir precisión de EDICIÓN basta con
+ * un bug sintácticamente trivial en un sitio adverso — la dificultad la pone
+ * la selección de fichero y línea, no la sutileza del bug. Sube a un
+ * mutador AST si algún día hace falta que el bug sea semánticamente sutil
+ * (p.ej. no reventar con `!isFoo` dentro de un string).
+ *
+ * Cada mutación busca TODAS las posiciones aplicables en el fichero y una
+ * `rng` elige una: mismo fichero, misma semilla, mismo caso siempre.
+ */
+/**
+ * Rangos [inicio, fin) de todo literal de cadena o de expresión regular en la
+ * línea. Tokenizador de una pasada, no un parser: basta para decidir si una
+ * posición cae DENTRO de un literal, que es todo lo que este módulo necesita.
+ *
+ * Encontrado auditando: la guarda anterior (`entreComillas`) solo miraba el
+ * carácter pegado al match, así que `"the value is true today"` mutaba a
+ * `"...is false today"` — el bug caía en medio de la cadena, no en su borde.
+ * Y no cubría literales de regex en absoluto: `/-----BEGIN...KEY-----/`
+ * (política de secretos en `core/computer/politica.ts`) se corrompía a
+ * `--++-` sin que ninguna guarda lo viera venir.
+ */
+function rangosDeLiterales(linea) {
+    const rangos = [];
+    let i = 0;
+    while (i < linea.length) {
+        const ch = linea[i];
+        if (ch === "'" || ch === '"' || ch === "`") {
+            const inicio = i;
+            i++;
+            while (i < linea.length && linea[i] !== ch) {
+                i += linea[i] === "\\" ? 2 : 1;
+            }
+            i++; // consume la comilla de cierre (o el final de línea si no cierra)
+            rangos.push([inicio, i]);
+            continue;
+        }
+        if (ch === "/" && linea[i + 1] !== "/" && linea[i + 1] !== "*") {
+            // Heurística estándar de tokenizador: `/` abre regex salvo que el
+            // carácter no-espacio anterior sugiera división (identificador,
+            // número, `)` o `]`).
+            const anterior = linea.slice(0, i).trimEnd();
+            const esDivision = /[A-Za-z0-9_$)\]]$/.test(anterior);
+            if (!esDivision) {
+                const inicio = i;
+                i++;
+                while (i < linea.length && linea[i] !== "/") {
+                    i += linea[i] === "\\" ? 2 : 1;
+                }
+                i++; // consume el `/` de cierre
+                while (i < linea.length && /[a-z]/i.test(linea[i]))
+                    i++; // flags
+                rangos.push([inicio, i]);
+                continue;
+            }
+        }
+        i++;
+    }
+    return rangos;
+}
+/** ¿El rango [inicio, fin) cae dentro de algún literal de cadena o regex de la línea? */
+function dentroDeLiteral(linea, inicio, fin) {
+    return rangosDeLiterales(linea).some(([a, b]) => inicio < b && fin > a);
+}
+/**
+ * Para cada línea, ¿es puramente comentario? Cubre `//` (ya cubierto antes)
+ * Y `/* ... *\/` de una o varias líneas — que NO estaba cubierto: una línea
+ * JSDoc de una sola línea como `/** If true, ... *\/` mutaba igual que
+ * código real. Simplificación deliberada, igual que el resto del módulo:
+ * trata la línea entera como comentario si EMPIEZA por `//` o `/*` tras
+ * recortar espacios; no separa código y comentario en la misma línea
+ * (`const x = 1; /* nota *\/`), caso raro en este corpus con biome.
+ */
+function lineasComentadas(lineas) {
+    const resultado = [];
+    let dentroDeBloque = false;
+    for (const linea of lineas) {
+        const t = linea.trimStart();
+        if (dentroDeBloque) {
+            resultado.push(true);
+            if (linea.includes("*/"))
+                dentroDeBloque = false;
+            continue;
+        }
+        if (t.startsWith("//")) {
+            resultado.push(true);
+            continue;
+        }
+        if (t.startsWith("/*")) {
+            resultado.push(true);
+            dentroDeBloque = !linea.includes("*/", linea.indexOf("/*") + 2);
+            continue;
+        }
+        resultado.push(false);
+    }
+    return resultado;
+}
+function candidatosPorPalabra(lineas, palabra, reemplazo) {
+    const re = new RegExp(`(?<![A-Za-z0-9_$])${palabra}(?![A-Za-z0-9_$])`, "g");
+    const comentadas = lineasComentadas(lineas);
+    const salida = [];
+    lineas.forEach((linea, i) => {
+        if (comentadas[i])
+            return;
+        for (const m of linea.matchAll(re)) {
+            if (m.index === undefined)
+                continue;
+            if (dentroDeLiteral(linea, m.index, m.index + m[0].length))
+                continue;
+            const mutada = linea.slice(0, m.index) + reemplazo + linea.slice(m.index + m[0].length);
+            salida.push({ numeroLinea: i + 1, lineaOriginal: linea, lineaMutada: mutada });
+        }
+    });
+    return salida;
+}
+function candidatosPorToken(lineas, token, reemplazo) {
+    const comentadas = lineasComentadas(lineas);
+    const salida = [];
+    lineas.forEach((linea, i) => {
+        if (comentadas[i])
+            return;
+        let desde = 0;
+        let idx = linea.indexOf(token, desde);
+        while (idx !== -1) {
+            if (!dentroDeLiteral(linea, idx, idx + token.length)) {
+                const mutada = linea.slice(0, idx) + reemplazo + linea.slice(idx + token.length);
+                salida.push({ numeroLinea: i + 1, lineaOriginal: linea, lineaMutada: mutada });
+            }
+            desde = idx + token.length;
+            idx = linea.indexOf(token, desde);
+        }
+    });
+    return salida;
+}
+const invertirBooleano = {
+    nombre: "invertir-booleano",
+    candidatos: (lineas) => [
+        ...candidatosPorPalabra(lineas, "true", "false"),
+        ...candidatosPorPalabra(lineas, "false", "true"),
+    ],
+};
+const intercambiarIgualdad = {
+    nombre: "intercambiar-igualdad",
+    candidatos: (lineas) => [...candidatosPorToken(lineas, "===", "!=="), ...candidatosPorToken(lineas, "!==", "===")],
+};
+const intercambiarLogico = {
+    nombre: "intercambiar-logico",
+    candidatos: (lineas) => [...candidatosPorToken(lineas, "&&", "||"), ...candidatosPorToken(lineas, "||", "&&")],
+};
+const intercambiarNullish = {
+    nombre: "intercambiar-nullish",
+    candidatos: (lineas) => candidatosPorToken(lineas, "??", "||"),
+};
+const intercambiarIncremento = {
+    nombre: "intercambiar-incremento",
+    candidatos: (lineas) => [...candidatosPorToken(lineas, "++", "--"), ...candidatosPorToken(lineas, "--", "++")],
+};
+/** `!identificador` -> `identificador`. Nunca toca `!=`/`!==` porque esos ya llevan un `=` detrás. */
+const quitarNegacion = {
+    nombre: "quitar-negacion",
+    candidatos: (lineas) => {
+        const re = /(?<![=!])!(?=[A-Za-z_$(])/g;
+        const comentadas = lineasComentadas(lineas);
+        const salida = [];
+        lineas.forEach((linea, i) => {
+            if (comentadas[i])
+                return;
+            for (const m of linea.matchAll(re)) {
+                if (m.index === undefined)
+                    continue;
+                if (dentroDeLiteral(linea, m.index, m.index + 1))
+                    continue;
+                const mutada = linea.slice(0, m.index) + linea.slice(m.index + 1);
+                salida.push({ numeroLinea: i + 1, lineaOriginal: linea, lineaMutada: mutada });
+            }
+        });
+        return salida;
+    },
+};
+/** Literal entero aislado (ni parte de un identificador ni de un decimal) +1. */
+const offByOne = {
+    nombre: "off-by-one",
+    candidatos: (lineas) => {
+        const re = /(?<![\w.])(\d+)(?![\w.])/g;
+        const comentadas = lineasComentadas(lineas);
+        const salida = [];
+        lineas.forEach((linea, i) => {
+            if (comentadas[i])
+                return;
+            for (const m of linea.matchAll(re)) {
+                if (m.index === undefined)
+                    continue;
+                if (dentroDeLiteral(linea, m.index, m.index + m[0].length))
+                    continue;
+                const valor = Number(m[1]);
+                const mutada = `${linea.slice(0, m.index)}${valor + 1}${linea.slice(m.index + m[0].length)}`;
+                salida.push({ numeroLinea: i + 1, lineaOriginal: linea, lineaMutada: mutada });
+            }
+        });
+        return salida;
+    },
+};
+export const TODAS_LAS_MUTACIONES = [
+    invertirBooleano,
+    intercambiarIgualdad,
+    intercambiarLogico,
+    intercambiarNullish,
+    intercambiarIncremento,
+    quitarNegacion,
+    offByOne,
+];
+//# sourceMappingURL=mutaciones.js.map

package/dist/core/banco/mutaciones.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutaciones.js","sourceRoot":"","sources":["../../../src/core/banco/mutaciones.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Catálogo de mutaciones: bugs deterministas de una línea.\n *\n * ponytail: mutaciones por regex sobre texto, no por AST (a diferencia de\n * oh-my-pi, que parsea con Babel). Para medir precisión de EDICIÓN basta con\n * un bug sintácticamente trivial en un sitio adverso — la dificultad la pone\n * la selección de fichero y línea, no la sutileza del bug. Sube a un\n * mutador AST si algún día hace falta que el bug sea semánticamente sutil\n * (p.ej. no reventar con `!isFoo` dentro de un string).\n *\n * Cada mutación busca TODAS las posiciones aplicables en el fichero y una\n * `rng` elige una: mismo fichero, misma semilla, mismo caso siempre.\n */\n\nexport interface CandidatoMutacion {\n\tnumeroLinea: number; // 1-based\n\tlineaOriginal: string;\n\tlineaMutada: string;\n}\n\nexport interface Mutacion {\n\tnombre: string;\n\t/** Candidatos aplicables en el fichero (línea original -> línea con el bug). */\n\tcandidatos(lineas: string[]): CandidatoMutacion[];\n}\n\n/**\n * Rangos [inicio, fin) de todo literal de cadena o de expresión regular en la\n * línea. Tokenizador de una pasada, no un parser: basta para decidir si una\n * posición cae DENTRO de un literal, que es todo lo que este módulo necesita.\n *\n * Encontrado auditando: la guarda anterior (`entreComillas`) solo miraba el\n * carácter pegado al match, así que `\"the value is true today\"` mutaba a\n * `\"...is false today\"` — el bug caía en medio de la cadena, no en su borde.\n * Y no cubría literales de regex en absoluto: `/-----BEGIN...KEY-----/`\n * (política de secretos en `core/computer/politica.ts`) se corrompía a\n * `--++-` sin que ninguna guarda lo viera venir.\n */\nfunction rangosDeLiterales(linea: string): Array<[number, number]> {\n\tconst rangos: Array<[number, number]> = [];\n\tlet i = 0;\n\twhile (i < linea.length) {\n\t\tconst ch = linea[i];\n\t\tif (ch === \"'\" || ch === '\"' || ch === \"`\") {\n\t\t\tconst inicio = i;\n\t\t\ti++;\n\t\t\twhile (i < linea.length && linea[i] !== ch) {\n\t\t\t\ti += linea[i] === \"\\\\\" ? 2 : 1;\n\t\t\t}\n\t\t\ti++; // consume la comilla de cierre (o el final de línea si no cierra)\n\t\t\trangos.push([inicio, i]);\n\t\t\tcontinue;\n\t\t}\n\t\tif (ch === \"/\" && linea[i + 1] !== \"/\" && linea[i + 1] !== \"*\") {\n\t\t\t// Heurística estándar de tokenizador: `/` abre regex salvo que el\n\t\t\t// carácter no-espacio anterior sugiera división (identificador,\n\t\t\t// número, `)` o `]`).\n\t\t\tconst anterior = linea.slice(0, i).trimEnd();\n\t\t\tconst esDivision = /[A-Za-z0-9_$)\\]]$/.test(anterior);\n\t\t\tif (!esDivision) {\n\t\t\t\tconst inicio = i;\n\t\t\t\ti++;\n\t\t\t\twhile (i < linea.length && linea[i] !== \"/\") {\n\t\t\t\t\ti += linea[i] === \"\\\\\" ? 2 : 1;\n\t\t\t\t}\n\t\t\t\ti++; // consume el `/` de cierre\n\t\t\t\twhile (i < linea.length && /[a-z]/i.test(linea[i])) i++; // flags\n\t\t\t\trangos.push([inicio, i]);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t}\n\t\ti++;\n\t}\n\treturn rangos;\n}\n\n/** ¿El rango [inicio, fin) cae dentro de algún literal de cadena o regex de la línea? */\nfunction dentroDeLiteral(linea: string, inicio: number, fin: number): boolean {\n\treturn rangosDeLiterales(linea).some(([a, b]) => inicio < b && fin > a);\n}\n\n/**\n * Para cada línea, ¿es puramente comentario? Cubre `//` (ya cubierto antes)\n * Y `/* ... *\\/` de una o varias líneas — que NO estaba cubierto: una línea\n * JSDoc de una sola línea como `/** If true, ... *\\/` mutaba igual que\n * código real. Simplificación deliberada, igual que el resto del módulo:\n * trata la línea entera como comentario si EMPIEZA por `//` o `/*` tras\n * recortar espacios; no separa código y comentario en la misma línea\n * (`const x = 1; /* nota *\\/`), caso raro en este corpus con biome.\n */\nfunction lineasComentadas(lineas: string[]): boolean[] {\n\tconst resultado: boolean[] = [];\n\tlet dentroDeBloque = false;\n\tfor (const linea of lineas) {\n\t\tconst t = linea.trimStart();\n\t\tif (dentroDeBloque) {\n\t\t\tresultado.push(true);\n\t\t\tif (linea.includes(\"*/\")) dentroDeBloque = false;\n\t\t\tcontinue;\n\t\t}\n\t\tif (t.startsWith(\"//\")) {\n\t\t\tresultado.push(true);\n\t\t\tcontinue;\n\t\t}\n\t\tif (t.startsWith(\"/*\")) {\n\t\t\tresultado.push(true);\n\t\t\tdentroDeBloque = !linea.includes(\"*/\", linea.indexOf(\"/*\") + 2);\n\t\t\tcontinue;\n\t\t}\n\t\tresultado.push(false);\n\t}\n\treturn resultado;\n}\n\nfunction candidatosPorPalabra(lineas: string[], palabra: string, reemplazo: string): CandidatoMutacion[] {\n\tconst re = new RegExp(`(?<![A-Za-z0-9_$])${palabra}(?![A-Za-z0-9_$])`, \"g\");\n\tconst comentadas = lineasComentadas(lineas);\n\tconst salida: CandidatoMutacion[] = [];\n\tlineas.forEach((linea, i) => {\n\t\tif (comentadas[i]) return;\n\t\tfor (const m of linea.matchAll(re)) {\n\t\t\tif (m.index === undefined) continue;\n\t\t\tif (dentroDeLiteral(linea, m.index, m.index + m[0].length)) continue;\n\t\t\tconst mutada = linea.slice(0, m.index) + reemplazo + linea.slice(m.index + m[0].length);\n\t\t\tsalida.push({ numeroLinea: i + 1, lineaOriginal: linea, lineaMutada: mutada });\n\t\t}\n\t});\n\treturn salida;\n}\n\nfunction candidatosPorToken(lineas: string[], token: string, reemplazo: string): CandidatoMutacion[] {\n\tconst comentadas = lineasComentadas(lineas);\n\tconst salida: CandidatoMutacion[] = [];\n\tlineas.forEach((linea, i) => {\n\t\tif (comentadas[i]) return;\n\t\tlet desde = 0;\n\t\tlet idx = linea.indexOf(token, desde);\n\t\twhile (idx !== -1) {\n\t\t\tif (!dentroDeLiteral(linea, idx, idx + token.length)) {\n\t\t\t\tconst mutada = linea.slice(0, idx) + reemplazo + linea.slice(idx + token.length);\n\t\t\t\tsalida.push({ numeroLinea: i + 1, lineaOriginal: linea, lineaMutada: mutada });\n\t\t\t}\n\t\t\tdesde = idx + token.length;\n\t\t\tidx = linea.indexOf(token, desde);\n\t\t}\n\t});\n\treturn salida;\n}\n\nconst invertirBooleano: Mutacion = {\n\tnombre: \"invertir-booleano\",\n\tcandidatos: (lineas) => [\n\t\t...candidatosPorPalabra(lineas, \"true\", \"false\"),\n\t\t...candidatosPorPalabra(lineas, \"false\", \"true\"),\n\t],\n};\n\nconst intercambiarIgualdad: Mutacion = {\n\tnombre: \"intercambiar-igualdad\",\n\tcandidatos: (lineas) => [...candidatosPorToken(lineas, \"===\", \"!==\"), ...candidatosPorToken(lineas, \"!==\", \"===\")],\n};\n\nconst intercambiarLogico: Mutacion = {\n\tnombre: \"intercambiar-logico\",\n\tcandidatos: (lineas) => [...candidatosPorToken(lineas, \"&&\", \"||\"), ...candidatosPorToken(lineas, \"||\", \"&&\")],\n};\n\nconst intercambiarNullish: Mutacion = {\n\tnombre: \"intercambiar-nullish\",\n\tcandidatos: (lineas) => candidatosPorToken(lineas, \"??\", \"||\"),\n};\n\nconst intercambiarIncremento: Mutacion = {\n\tnombre: \"intercambiar-incremento\",\n\tcandidatos: (lineas) => [...candidatosPorToken(lineas, \"++\", \"--\"), ...candidatosPorToken(lineas, \"--\", \"++\")],\n};\n\n/** `!identificador` -> `identificador`. Nunca toca `!=`/`!==` porque esos ya llevan un `=` detrás. */\nconst quitarNegacion: Mutacion = {\n\tnombre: \"quitar-negacion\",\n\tcandidatos: (lineas) => {\n\t\tconst re = /(?<![=!])!(?=[A-Za-z_$(])/g;\n\t\tconst comentadas = lineasComentadas(lineas);\n\t\tconst salida: CandidatoMutacion[] = [];\n\t\tlineas.forEach((linea, i) => {\n\t\t\tif (comentadas[i]) return;\n\t\t\tfor (const m of linea.matchAll(re)) {\n\t\t\t\tif (m.index === undefined) continue;\n\t\t\t\tif (dentroDeLiteral(linea, m.index, m.index + 1)) continue;\n\t\t\t\tconst mutada = linea.slice(0, m.index) + linea.slice(m.index + 1);\n\t\t\t\tsalida.push({ numeroLinea: i + 1, lineaOriginal: linea, lineaMutada: mutada });\n\t\t\t}\n\t\t});\n\t\treturn salida;\n\t},\n};\n\n/** Literal entero aislado (ni parte de un identificador ni de un decimal) +1. */\nconst offByOne: Mutacion = {\n\tnombre: \"off-by-one\",\n\tcandidatos: (lineas) => {\n\t\tconst re = /(?<![\\w.])(\\d+)(?![\\w.])/g;\n\t\tconst comentadas = lineasComentadas(lineas);\n\t\tconst salida: CandidatoMutacion[] = [];\n\t\tlineas.forEach((linea, i) => {\n\t\t\tif (comentadas[i]) return;\n\t\t\tfor (const m of linea.matchAll(re)) {\n\t\t\t\tif (m.index === undefined) continue;\n\t\t\t\tif (dentroDeLiteral(linea, m.index, m.index + m[0].length)) continue;\n\t\t\t\tconst valor = Number(m[1]);\n\t\t\t\tconst mutada = `${linea.slice(0, m.index)}${valor + 1}${linea.slice(m.index + m[0].length)}`;\n\t\t\t\tsalida.push({ numeroLinea: i + 1, lineaOriginal: linea, lineaMutada: mutada });\n\t\t\t}\n\t\t});\n\t\treturn salida;\n\t},\n};\n\nexport const TODAS_LAS_MUTACIONES: Mutacion[] = [\n\tinvertirBooleano,\n\tintercambiarIgualdad,\n\tintercambiarLogico,\n\tintercambiarNullish,\n\tintercambiarIncremento,\n\tquitarNegacion,\n\toffByOne,\n];\n"]}

package/dist/core/banco/tipos.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Tipos compartidos del banco de fiabilidad de edición.
+ *
+ * El hueco que esto llena: no había forma de MEDIR si un cambio en las tools
+ * de edición mejora o empeora la precisión del modelo aplicando parches. Sin
+ * número, cualquier afirmación sobre "esto edita mejor" es opinión.
+ *
+ * Diseño copiado a propósito de oh-my-pi/typescript-edit-benchmark (ver
+ * cabecera de `generar.ts`): cuatro niveles de dificultad que varían a la vez
+ * la selección de fichero y el detalle del prompt, condiciones adversas
+ * explícitas, validación por resolución antes de admitir un caso, y métricas
+ * de tarea/edición/fantasma/timeout SEPARADAS — la lección de deepseek
+ * (100% edición, 55% tarea, 9 fantasmas) es que una sola métrica miente.
+ */
+export type Dificultad = "facil" | "medio" | "dificil" | "pesadilla";
+/** Un caso de banco: un fichero con un bug determinista y su arreglo exacto. */
+export interface CasoBanco {
+    id: string;
+    dificultad: Dificultad;
+    mutacion: string;
+    /** Ruta relativa al corpus de origen (informativa, no se usa para ejecutar). */
+    ficheroRelativo: string;
+    /** Contenido completo del fichero CON el bug: lo que ve el modelo. */
+    contenidoEntrada: string;
+    /** Contenido completo del fichero arreglado: lo que se compara al final. */
+    contenidoEsperado: string;
+    /** Número de línea (1-based, en el fichero de entrada) donde está el bug. */
+    numeroLinea: number;
+    /** Prompt completo que se le manda al modelo. */
+    prompt: string;
+    /** Puntuación de dificultad (mayor = más adversa), solo informativa. */
+    puntuacion: number;
+    contexto: {
+        lineasFichero: number;
+        esLineaRepetida: boolean;
+        vecesRepetida: number;
+        bloquesSimilares: number;
+        densidad: number;
+    };
+}
+export interface ConjuntoCasos {
+    version: 1;
+    generadoEn: string;
+    semilla: number;
+    corpus: string;
+    casos: CasoBanco[];
+    descartadosPorAmbiguos: number;
+    descartadosPorNoAplicable: number;
+    intentos: number;
+}
+/** Resultado de ejecutar UN caso contra un modelo. */
+export interface ResultadoCaso {
+    casoId: string;
+    dificultad: Dificultad;
+    mutacion: string;
+    /**
+     * Tarea: el fichero final es BYTE A BYTE el esperado. Es la métrica dura.
+     */
+    tareaOk: boolean;
+    /**
+     * Edición: alguna llamada a `edit`/`write` sobre el fichero objetivo
+     * TERMINÓ SIN ERROR. Puede ser true con tareaOk false: el modelo editó
+     * algo, pero editó lo que no era.
+     */
+    edicionOk: boolean;
+    /**
+     * Fantasma: el turno TERMINÓ (sin error, sin timeout) y el modelo no
+     * tocó el fichero objetivo ni una vez. Ni acertó ni erró: no lo intentó.
+     * Contarlo junto al éxito de edición (como hace un editor que "casi no
+     * edita pero puntúa 100%") es el defecto exacto que este banco existe
+     * para exponer.
+     *
+     * Un fantasma es "no hay nada que editar" — el modelo decidió no tocar
+     * el fichero. Eso NO es lo mismo que "no pude saberlo" (`error` no
+     * vacío, p.ej. sin API key): confundirlos hace que un fallo de
+     * autenticación se lea como "el modelo no editó", que es la mentira
+     * exacta que la regla de `null` vs `[]` prohíbe.
+     *
+     * Tampoco es lo mismo que `vacio`: ahí el modelo NO CONTESTÓ. Un turno
+     * vacío contado como fantasma dice «este modelo decide no editar» sobre un
+     * proveedor que no devolvió nada. Pasó con `x-preview-f-free`.
+     */
+    fantasma: boolean;
+    /**
+     * Vacío: el turno terminó y el modelo devolvió al menos una respuesta SIN
+     * texto, sin razonamiento y sin llamadas a herramienta. No es un dato
+     * sobre si el modelo sabe editar: es que no hubo respuesta que medir.
+     */
+    vacio: boolean;
+    /** Se agotó el presupuesto de tiempo antes de que el turno terminara. */
+    timeout: boolean;
+    duracionMs: number;
+    /** El turno no llegó a terminar por un motivo que NO es timeout (auth, red, proveedor caído). */
+    error?: string;
+}
+export interface ResultadosEjecucion {
+    version: 1;
+    ejecutadoEn: string;
+    proveedor: string;
+    modelo: string;
+    casosArchivo: string;
+    resultados: ResultadoCaso[];
+    resumen: ResumenMetricas;
+}
+export interface ResumenMetricas {
+    total: number;
+    tareaOkPct: number;
+    edicionOkPct: number;
+    fantasmaPct: number;
+    /** Casos donde el modelo devolvió un turno vacío: NO se cuentan como fantasma. */
+    vacioPct: number;
+    timeoutPct: number;
+    /** Turnos que no terminaron por un error (no timeout): NO se cuentan como fantasma. */
+    errorPct: number;
+    porDificultad: Record<string, {
+        total: number;
+        tareaOkPct: number;
+        edicionOkPct: number;
+    }>;
+}
+//# sourceMappingURL=tipos.d.ts.map

package/dist/core/banco/tipos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tipos.d.ts","sourceRoot":"","sources":["../../../src/core/banco/tipos.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,WAAW,CAAC;AAErE,gFAAgF;AAChF,MAAM,WAAW,SAAS;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,UAAU,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,gFAAgF;IAChF,eAAe,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,gBAAgB,EAAE,MAAM,CAAC;IACzB,4EAA4E;IAC5E,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gFAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,0EAAwE;IACxE,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE;QACT,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,EAAE,OAAO,CAAC;QACzB,aAAa,EAAE,MAAM,CAAC;QACtB,gBAAgB,EAAE,MAAM,CAAC;QACzB,QAAQ,EAAE,MAAM,CAAC;KACjB,CAAC;CACF;AAED,MAAM,WAAW,aAAa;IAC7B,OAAO,EAAE,CAAC,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,yBAAyB,EAAE,MAAM,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,sDAAsD;AACtD,MAAM,WAAW,aAAa;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,UAAU,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,KAAK,EAAE,OAAO,CAAC;IACf,0EAAyE;IACzE,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,mGAAiG;IACjG,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,CAAC,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,OAAO,EAAE,eAAe,CAAC;CACzB;AAED,MAAM,WAAW,eAAe;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,oFAAkF;IAClF,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,uFAAuF;IACvF,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC3F","sourcesContent":["/**\n * Tipos compartidos del banco de fiabilidad de edición.\n *\n * El hueco que esto llena: no había forma de MEDIR si un cambio en las tools\n * de edición mejora o empeora la precisión del modelo aplicando parches. Sin\n * número, cualquier afirmación sobre \"esto edita mejor\" es opinión.\n *\n * Diseño copiado a propósito de oh-my-pi/typescript-edit-benchmark (ver\n * cabecera de `generar.ts`): cuatro niveles de dificultad que varían a la vez\n * la selección de fichero y el detalle del prompt, condiciones adversas\n * explícitas, validación por resolución antes de admitir un caso, y métricas\n * de tarea/edición/fantasma/timeout SEPARADAS — la lección de deepseek\n * (100% edición, 55% tarea, 9 fantasmas) es que una sola métrica miente.\n */\n\nexport type Dificultad = \"facil\" | \"medio\" | \"dificil\" | \"pesadilla\";\n\n/** Un caso de banco: un fichero con un bug determinista y su arreglo exacto. */\nexport interface CasoBanco {\n\tid: string;\n\tdificultad: Dificultad;\n\tmutacion: string;\n\t/** Ruta relativa al corpus de origen (informativa, no se usa para ejecutar). */\n\tficheroRelativo: string;\n\t/** Contenido completo del fichero CON el bug: lo que ve el modelo. */\n\tcontenidoEntrada: string;\n\t/** Contenido completo del fichero arreglado: lo que se compara al final. */\n\tcontenidoEsperado: string;\n\t/** Número de línea (1-based, en el fichero de entrada) donde está el bug. */\n\tnumeroLinea: number;\n\t/** Prompt completo que se le manda al modelo. */\n\tprompt: string;\n\t/** Puntuación de dificultad (mayor = más adversa), solo informativa. */\n\tpuntuacion: number;\n\tcontexto: {\n\t\tlineasFichero: number;\n\t\tesLineaRepetida: boolean;\n\t\tvecesRepetida: number;\n\t\tbloquesSimilares: number;\n\t\tdensidad: number;\n\t};\n}\n\nexport interface ConjuntoCasos {\n\tversion: 1;\n\tgeneradoEn: string;\n\tsemilla: number;\n\tcorpus: string;\n\tcasos: CasoBanco[];\n\tdescartadosPorAmbiguos: number;\n\tdescartadosPorNoAplicable: number;\n\tintentos: number;\n}\n\n/** Resultado de ejecutar UN caso contra un modelo. */\nexport interface ResultadoCaso {\n\tcasoId: string;\n\tdificultad: Dificultad;\n\tmutacion: string;\n\t/**\n\t * Tarea: el fichero final es BYTE A BYTE el esperado. Es la métrica dura.\n\t */\n\ttareaOk: boolean;\n\t/**\n\t * Edición: alguna llamada a `edit`/`write` sobre el fichero objetivo\n\t * TERMINÓ SIN ERROR. Puede ser true con tareaOk false: el modelo editó\n\t * algo, pero editó lo que no era.\n\t */\n\tedicionOk: boolean;\n\t/**\n\t * Fantasma: el turno TERMINÓ (sin error, sin timeout) y el modelo no\n\t * tocó el fichero objetivo ni una vez. Ni acertó ni erró: no lo intentó.\n\t * Contarlo junto al éxito de edición (como hace un editor que \"casi no\n\t * edita pero puntúa 100%\") es el defecto exacto que este banco existe\n\t * para exponer.\n\t *\n\t * Un fantasma es \"no hay nada que editar\" — el modelo decidió no tocar\n\t * el fichero. Eso NO es lo mismo que \"no pude saberlo\" (`error` no\n\t * vacío, p.ej. sin API key): confundirlos hace que un fallo de\n\t * autenticación se lea como \"el modelo no editó\", que es la mentira\n\t * exacta que la regla de `null` vs `[]` prohíbe.\n\t *\n\t * Tampoco es lo mismo que `vacio`: ahí el modelo NO CONTESTÓ. Un turno\n\t * vacío contado como fantasma dice «este modelo decide no editar» sobre un\n\t * proveedor que no devolvió nada. Pasó con `x-preview-f-free`.\n\t */\n\tfantasma: boolean;\n\t/**\n\t * Vacío: el turno terminó y el modelo devolvió al menos una respuesta SIN\n\t * texto, sin razonamiento y sin llamadas a herramienta. No es un dato\n\t * sobre si el modelo sabe editar: es que no hubo respuesta que medir.\n\t */\n\tvacio: boolean;\n\t/** Se agotó el presupuesto de tiempo antes de que el turno terminara. */\n\ttimeout: boolean;\n\tduracionMs: number;\n\t/** El turno no llegó a terminar por un motivo que NO es timeout (auth, red, proveedor caído). */\n\terror?: string;\n}\n\nexport interface ResultadosEjecucion {\n\tversion: 1;\n\tejecutadoEn: string;\n\tproveedor: string;\n\tmodelo: string;\n\tcasosArchivo: string;\n\tresultados: ResultadoCaso[];\n\tresumen: ResumenMetricas;\n}\n\nexport interface ResumenMetricas {\n\ttotal: number;\n\ttareaOkPct: number;\n\tedicionOkPct: number;\n\tfantasmaPct: number;\n\t/** Casos donde el modelo devolvió un turno vacío: NO se cuentan como fantasma. */\n\tvacioPct: number;\n\ttimeoutPct: number;\n\t/** Turnos que no terminaron por un error (no timeout): NO se cuentan como fantasma. */\n\terrorPct: number;\n\tporDificultad: Record<string, { total: number; tareaOkPct: number; edicionOkPct: number }>;\n}\n"]}

package/dist/core/banco/tipos.js

@@ -0,0 +1,16 @@
+/**
+ * Tipos compartidos del banco de fiabilidad de edición.
+ *
+ * El hueco que esto llena: no había forma de MEDIR si un cambio en las tools
+ * de edición mejora o empeora la precisión del modelo aplicando parches. Sin
+ * número, cualquier afirmación sobre "esto edita mejor" es opinión.
+ *
+ * Diseño copiado a propósito de oh-my-pi/typescript-edit-benchmark (ver
+ * cabecera de `generar.ts`): cuatro niveles de dificultad que varían a la vez
+ * la selección de fichero y el detalle del prompt, condiciones adversas
+ * explícitas, validación por resolución antes de admitir un caso, y métricas
+ * de tarea/edición/fantasma/timeout SEPARADAS — la lección de deepseek
+ * (100% edición, 55% tarea, 9 fantasmas) es que una sola métrica miente.
+ */
+export {};
+//# sourceMappingURL=tipos.js.map

package/dist/core/banco/tipos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tipos.js","sourceRoot":"","sources":["../../../src/core/banco/tipos.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG","sourcesContent":["/**\n * Tipos compartidos del banco de fiabilidad de edición.\n *\n * El hueco que esto llena: no había forma de MEDIR si un cambio en las tools\n * de edición mejora o empeora la precisión del modelo aplicando parches. Sin\n * número, cualquier afirmación sobre \"esto edita mejor\" es opinión.\n *\n * Diseño copiado a propósito de oh-my-pi/typescript-edit-benchmark (ver\n * cabecera de `generar.ts`): cuatro niveles de dificultad que varían a la vez\n * la selección de fichero y el detalle del prompt, condiciones adversas\n * explícitas, validación por resolución antes de admitir un caso, y métricas\n * de tarea/edición/fantasma/timeout SEPARADAS — la lección de deepseek\n * (100% edición, 55% tarea, 9 fantasmas) es que una sola métrica miente.\n */\n\nexport type Dificultad = \"facil\" | \"medio\" | \"dificil\" | \"pesadilla\";\n\n/** Un caso de banco: un fichero con un bug determinista y su arreglo exacto. */\nexport interface CasoBanco {\n\tid: string;\n\tdificultad: Dificultad;\n\tmutacion: string;\n\t/** Ruta relativa al corpus de origen (informativa, no se usa para ejecutar). */\n\tficheroRelativo: string;\n\t/** Contenido completo del fichero CON el bug: lo que ve el modelo. */\n\tcontenidoEntrada: string;\n\t/** Contenido completo del fichero arreglado: lo que se compara al final. */\n\tcontenidoEsperado: string;\n\t/** Número de línea (1-based, en el fichero de entrada) donde está el bug. */\n\tnumeroLinea: number;\n\t/** Prompt completo que se le manda al modelo. */\n\tprompt: string;\n\t/** Puntuación de dificultad (mayor = más adversa), solo informativa. */\n\tpuntuacion: number;\n\tcontexto: {\n\t\tlineasFichero: number;\n\t\tesLineaRepetida: boolean;\n\t\tvecesRepetida: number;\n\t\tbloquesSimilares: number;\n\t\tdensidad: number;\n\t};\n}\n\nexport interface ConjuntoCasos {\n\tversion: 1;\n\tgeneradoEn: string;\n\tsemilla: number;\n\tcorpus: string;\n\tcasos: CasoBanco[];\n\tdescartadosPorAmbiguos: number;\n\tdescartadosPorNoAplicable: number;\n\tintentos: number;\n}\n\n/** Resultado de ejecutar UN caso contra un modelo. */\nexport interface ResultadoCaso {\n\tcasoId: string;\n\tdificultad: Dificultad;\n\tmutacion: string;\n\t/**\n\t * Tarea: el fichero final es BYTE A BYTE el esperado. Es la métrica dura.\n\t */\n\ttareaOk: boolean;\n\t/**\n\t * Edición: alguna llamada a `edit`/`write` sobre el fichero objetivo\n\t * TERMINÓ SIN ERROR. Puede ser true con tareaOk false: el modelo editó\n\t * algo, pero editó lo que no era.\n\t */\n\tedicionOk: boolean;\n\t/**\n\t * Fantasma: el turno TERMINÓ (sin error, sin timeout) y el modelo no\n\t * tocó el fichero objetivo ni una vez. Ni acertó ni erró: no lo intentó.\n\t * Contarlo junto al éxito de edición (como hace un editor que \"casi no\n\t * edita pero puntúa 100%\") es el defecto exacto que este banco existe\n\t * para exponer.\n\t *\n\t * Un fantasma es \"no hay nada que editar\" — el modelo decidió no tocar\n\t * el fichero. Eso NO es lo mismo que \"no pude saberlo\" (`error` no\n\t * vacío, p.ej. sin API key): confundirlos hace que un fallo de\n\t * autenticación se lea como \"el modelo no editó\", que es la mentira\n\t * exacta que la regla de `null` vs `[]` prohíbe.\n\t *\n\t * Tampoco es lo mismo que `vacio`: ahí el modelo NO CONTESTÓ. Un turno\n\t * vacío contado como fantasma dice «este modelo decide no editar» sobre un\n\t * proveedor que no devolvió nada. Pasó con `x-preview-f-free`.\n\t */\n\tfantasma: boolean;\n\t/**\n\t * Vacío: el turno terminó y el modelo devolvió al menos una respuesta SIN\n\t * texto, sin razonamiento y sin llamadas a herramienta. No es un dato\n\t * sobre si el modelo sabe editar: es que no hubo respuesta que medir.\n\t */\n\tvacio: boolean;\n\t/** Se agotó el presupuesto de tiempo antes de que el turno terminara. */\n\ttimeout: boolean;\n\tduracionMs: number;\n\t/** El turno no llegó a terminar por un motivo que NO es timeout (auth, red, proveedor caído). */\n\terror?: string;\n}\n\nexport interface ResultadosEjecucion {\n\tversion: 1;\n\tejecutadoEn: string;\n\tproveedor: string;\n\tmodelo: string;\n\tcasosArchivo: string;\n\tresultados: ResultadoCaso[];\n\tresumen: ResumenMetricas;\n}\n\nexport interface ResumenMetricas {\n\ttotal: number;\n\ttareaOkPct: number;\n\tedicionOkPct: number;\n\tfantasmaPct: number;\n\t/** Casos donde el modelo devolvió un turno vacío: NO se cuentan como fantasma. */\n\tvacioPct: number;\n\ttimeoutPct: number;\n\t/** Turnos que no terminaron por un error (no timeout): NO se cuentan como fantasma. */\n\terrorPct: number;\n\tporDificultad: Record<string, { total: number; tareaOkPct: number; edicionOkPct: number }>;\n}\n"]}

package/dist/core/blobs/almacen.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Caché en disco de los identificadores que devuelve la API de ficheros del
+ * proveedor, indexada por (proveedor, hash del contenido).
+ *
+ * Por qué en disco y no en memoria: el ahorro grande no es entre turnos de una
+ * sesión —eso lo daría un Map— sino entre SESIONES. La captura de pantalla que
+ * pegaste ayer y vuelves a pegar hoy es el mismo fichero para el proveedor, y
+ * volver a subir 1,4 MB es tiempo y cuota tirados.
+ *
+ * Por qué se relee el fichero antes de escribir: hay más de un proceso de Ada
+ * a la vez (CLI + escritorio + subagentes) y todos apuntan al mismo agentDir.
+ * Escribir el mapa entero desde memoria haría que el último en cerrar borrase
+ * lo que subieron los demás; ya nos pasó con un fichero compartido y varios
+ * escritores. Aquí se funde por entrada, quedándose con la de uso más reciente.
+ */
+export interface EntradaDeBlob {
+    /** Identificador que devolvió el proveedor (`file_...` / `file-...`). */
+    id: string;
+    /** Tamaño en bytes del contenido original, para el informe de `/blobs`. */
+    bytes: number;
+    mime: string;
+    /** Milisegundos epoch de la subida. */
+    subidoEn: number;
+    /** Milisegundos epoch del último uso; manda en la purga y en la fusión. */
+    usadoEn: number;
+}
+export interface OpcionesDePurga {
+    /** Edad máxima desde el último uso. Por defecto 30 días. */
+    maxEdadMs?: number;
+    /** Número máximo de entradas que se conservan. Por defecto 500. */
+    maxEntradas?: number;
+    /** Reloj inyectable; los tests no pueden esperar 30 días. */
+    ahora?: number;
+}
+/**
+ * Clave del mapa. El separador es `|` y no un byte NUL a propósito: un NUL en
+ * el fichero lo vuelve binario para `grep` y para `git diff`, y este fichero se
+ * mira a mano cuando algo va mal.
+ */
+export declare function claveDeBlob(proveedor: string, hash: string): string;
+export declare class AlmacenDeBlobs {
+    private readonly ruta;
+    private entradas;
+    private sucio;
+    /**
+     * Claves quitadas A PROPÓSITO (id muerto, purga por edad, purga a mano). La
+     * fusión de `volcar()` las tiene que borrar también de la copia en disco: si
+     * no, la entrada que este proceso acaba de tirar vuelve desde el fichero que
+     * dejó otro proceso y la purga no llega nunca al disco.
+     *
+     * Vive aquí y no en quien llama porque el llamador se olvida: la purga
+     * automática del arranque lo hacía y la de `/blobs purgar` no, así que el
+     * fichero crecía sin límite y las entradas de más de 30 días resucitaban en
+     * cada volcado. Comprobado ejecutándolo: purgar + volcar dejaba la clave
+     * `anthropic|aaa` intacta en disco.
+     */
+    private readonly olvidadas;
+    constructor(agentDir: string, nombreFichero?: string);
+    get rutaFichero(): string;
+    cargar(): Promise<void>;
+    /** Devuelve la entrada y marca el uso. `undefined` = no la tenemos. */
+    leer(proveedor: string, hash: string, ahora?: number): EntradaDeBlob | undefined;
+    guardar(proveedor: string, hash: string, entrada: EntradaDeBlob): void;
+    /**
+     * Borra una entrada. Se llama cuando el proveedor rechaza el id: mejor
+     * resubir 1 MB que dejar la conversación atada a un id muerto.
+     */
+    olvidar(proveedor: string, hash: string): boolean;
+    olvidarPorId(id: string): string[];
+    tamano(): number;
+    /** Devuelve las claves purgadas. Por edad primero, por número después. */
+    purgar(opciones?: OpcionesDePurga): string[];
+    /**
+     * Escribe fundiendo con lo que haya en disco. Las claves que este proceso ha
+     * borrado a propósito se quitan de la fusión: sin eso, la fusión las
+     * resucitaría desde la copia en disco de otro proceso y volveríamos a mandar
+     * un id que ya sabemos muerto, o a guardar para siempre lo que purgamos.
+     */
+    volcar(olvidadas?: Iterable<string>): Promise<void>;
+}
+//# sourceMappingURL=almacen.d.ts.map

package/dist/core/blobs/almacen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"almacen.d.ts","sourceRoot":"","sources":["../../../src/core/blobs/almacen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,MAAM,WAAW,aAAa;IAC7B,0EAAyE;IACzE,EAAE,EAAE,MAAM,CAAC;IACX,4EAA2E;IAC3E,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,6EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC/B,+DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAKD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnE;AAsCD,qBAAa,cAAc;IAC1B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAoC;IACpD,OAAO,CAAC,KAAK,CAAS;IACtB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;IAE/C,YAAY,QAAQ,EAAE,MAAM,EAAE,aAAa,SAAe,EAEzD;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAEK,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAO5B;IAED,uEAAuE;IACvE,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,SAAa,GAAG,aAAa,GAAG,SAAS,CAMnF;IAED,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CAOrE;IAED;;;OAGG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAMhD;IAED,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAUjC;IAED,MAAM,IAAI,MAAM,CAEf;IAMD,4EAA0E;IAC1E,MAAM,CAAC,QAAQ,GAAE,eAAoB,GAAG,MAAM,EAAE,CAyB/C;IAED;;;;;OAKG;IACG,MAAM,CAAC,SAAS,GAAE,QAAQ,CAAC,MAAM,CAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAqB5D;CACD","sourcesContent":["/**\n * Caché en disco de los identificadores que devuelve la API de ficheros del\n * proveedor, indexada por (proveedor, hash del contenido).\n *\n * Por qué en disco y no en memoria: el ahorro grande no es entre turnos de una\n * sesión —eso lo daría un Map— sino entre SESIONES. La captura de pantalla que\n * pegaste ayer y vuelves a pegar hoy es el mismo fichero para el proveedor, y\n * volver a subir 1,4 MB es tiempo y cuota tirados.\n *\n * Por qué se relee el fichero antes de escribir: hay más de un proceso de Ada\n * a la vez (CLI + escritorio + subagentes) y todos apuntan al mismo agentDir.\n * Escribir el mapa entero desde memoria haría que el último en cerrar borrase\n * lo que subieron los demás; ya nos pasó con un fichero compartido y varios\n * escritores. Aquí se funde por entrada, quedándose con la de uso más reciente.\n */\n\nimport { mkdir, readFile, rename, writeFile } from \"node:fs/promises\";\nimport { dirname, join } from \"node:path\";\n\nexport interface EntradaDeBlob {\n\t/** Identificador que devolvió el proveedor (`file_...` / `file-...`). */\n\tid: string;\n\t/** Tamaño en bytes del contenido original, para el informe de `/blobs`. */\n\tbytes: number;\n\tmime: string;\n\t/** Milisegundos epoch de la subida. */\n\tsubidoEn: number;\n\t/** Milisegundos epoch del último uso; manda en la purga y en la fusión. */\n\tusadoEn: number;\n}\n\nexport interface OpcionesDePurga {\n\t/** Edad máxima desde el último uso. Por defecto 30 días. */\n\tmaxEdadMs?: number;\n\t/** Número máximo de entradas que se conservan. Por defecto 500. */\n\tmaxEntradas?: number;\n\t/** Reloj inyectable; los tests no pueden esperar 30 días. */\n\tahora?: number;\n}\n\nconst MAX_EDAD_POR_DEFECTO_MS = 30 * 24 * 60 * 60 * 1000;\nconst MAX_ENTRADAS_POR_DEFECTO = 500;\n\n/**\n * Clave del mapa. El separador es `|` y no un byte NUL a propósito: un NUL en\n * el fichero lo vuelve binario para `grep` y para `git diff`, y este fichero se\n * mira a mano cuando algo va mal.\n */\nexport function claveDeBlob(proveedor: string, hash: string): string {\n\treturn `${proveedor}|${hash}`;\n}\n\ninterface FicheroDeBlobs {\n\tversion: number;\n\tentradas: Record<string, EntradaDeBlob>;\n}\n\nfunction esEntrada(valor: unknown): valor is EntradaDeBlob {\n\tif (!valor || typeof valor !== \"object\") return false;\n\tconst e = valor as Record<string, unknown>;\n\treturn (\n\t\ttypeof e.id === \"string\" &&\n\t\te.id.length > 0 &&\n\t\ttypeof e.bytes === \"number\" &&\n\t\ttypeof e.mime === \"string\" &&\n\t\ttypeof e.subidoEn === \"number\" &&\n\t\ttypeof e.usadoEn === \"number\"\n\t);\n}\n\nfunction leerFichero(texto: string): Map<string, EntradaDeBlob> {\n\tconst mapa = new Map<string, EntradaDeBlob>();\n\tlet crudo: unknown;\n\ttry {\n\t\tcrudo = JSON.parse(texto);\n\t} catch {\n\t\t// Un fichero corrupto se trata como vacío: como mucho se resube. Fallar\n\t\t// aquí dejaría al agente sin poder mandar adjuntos por un JSON roto.\n\t\treturn mapa;\n\t}\n\tconst doc = crudo as Partial<FicheroDeBlobs> | null;\n\tif (!doc || typeof doc !== \"object\" || !doc.entradas || typeof doc.entradas !== \"object\") return mapa;\n\tfor (const [clave, valor] of Object.entries(doc.entradas)) {\n\t\tif (esEntrada(valor)) mapa.set(clave, valor);\n\t}\n\treturn mapa;\n}\n\nexport class AlmacenDeBlobs {\n\tprivate readonly ruta: string;\n\tprivate entradas = new Map<string, EntradaDeBlob>();\n\tprivate sucio = false;\n\t/**\n\t * Claves quitadas A PROPÓSITO (id muerto, purga por edad, purga a mano). La\n\t * fusión de `volcar()` las tiene que borrar también de la copia en disco: si\n\t * no, la entrada que este proceso acaba de tirar vuelve desde el fichero que\n\t * dejó otro proceso y la purga no llega nunca al disco.\n\t *\n\t * Vive aquí y no en quien llama porque el llamador se olvida: la purga\n\t * automática del arranque lo hacía y la de `/blobs purgar` no, así que el\n\t * fichero crecía sin límite y las entradas de más de 30 días resucitaban en\n\t * cada volcado. Comprobado ejecutándolo: purgar + volcar dejaba la clave\n\t * `anthropic|aaa` intacta en disco.\n\t */\n\tprivate readonly olvidadas = new Set<string>();\n\n\tconstructor(agentDir: string, nombreFichero = \"blobs.json\") {\n\t\tthis.ruta = join(agentDir, nombreFichero);\n\t}\n\n\tget rutaFichero(): string {\n\t\treturn this.ruta;\n\t}\n\n\tasync cargar(): Promise<void> {\n\t\ttry {\n\t\t\tthis.entradas = leerFichero(await readFile(this.ruta, \"utf-8\"));\n\t\t} catch {\n\t\t\t// No existe todavía: primer arranque.\n\t\t\tthis.entradas = new Map();\n\t\t}\n\t}\n\n\t/** Devuelve la entrada y marca el uso. `undefined` = no la tenemos. */\n\tleer(proveedor: string, hash: string, ahora = Date.now()): EntradaDeBlob | undefined {\n\t\tconst entrada = this.entradas.get(claveDeBlob(proveedor, hash));\n\t\tif (!entrada) return undefined;\n\t\tentrada.usadoEn = ahora;\n\t\tthis.sucio = true;\n\t\treturn entrada;\n\t}\n\n\tguardar(proveedor: string, hash: string, entrada: EntradaDeBlob): void {\n\t\tconst clave = claveDeBlob(proveedor, hash);\n\t\tthis.entradas.set(clave, entrada);\n\t\t// Se ha vuelto a subir: deja de estar olvidada, o la fusión la borraría\n\t\t// justo después de haberla pagado.\n\t\tthis.olvidadas.delete(clave);\n\t\tthis.sucio = true;\n\t}\n\n\t/**\n\t * Borra una entrada. Se llama cuando el proveedor rechaza el id: mejor\n\t * resubir 1 MB que dejar la conversación atada a un id muerto.\n\t */\n\tolvidar(proveedor: string, hash: string): boolean {\n\t\tconst clave = claveDeBlob(proveedor, hash);\n\t\tconst borrada = this.entradas.delete(clave);\n\t\tthis.olvidadas.add(clave);\n\t\tif (borrada) this.sucio = true;\n\t\treturn borrada;\n\t}\n\n\tolvidarPorId(id: string): string[] {\n\t\tconst borradas: string[] = [];\n\t\tfor (const [clave, entrada] of this.entradas) {\n\t\t\tif (entrada.id !== id) continue;\n\t\t\tthis.entradas.delete(clave);\n\t\t\tthis.olvidadas.add(clave);\n\t\t\tborradas.push(clave);\n\t\t}\n\t\tif (borradas.length > 0) this.sucio = true;\n\t\treturn borradas;\n\t}\n\n\ttamano(): number {\n\t\treturn this.entradas.size;\n\t}\n\n\t// Aquí vivía `listar()`. Nadie lo llamaba: `/blobs` enseña el tamaño y la\n\t// ruta del fichero, que se mira a mano. Borrado por lo mismo que\n\t// `borrarFichero`.\n\n\t/** Devuelve las claves purgadas. Por edad primero, por número después. */\n\tpurgar(opciones: OpcionesDePurga = {}): string[] {\n\t\tconst ahora = opciones.ahora ?? Date.now();\n\t\tconst maxEdadMs = opciones.maxEdadMs ?? MAX_EDAD_POR_DEFECTO_MS;\n\t\tconst maxEntradas = opciones.maxEntradas ?? MAX_ENTRADAS_POR_DEFECTO;\n\t\tconst purgadas: string[] = [];\n\n\t\tfor (const [clave, entrada] of this.entradas) {\n\t\t\tif (ahora - entrada.usadoEn > maxEdadMs) {\n\t\t\t\tthis.entradas.delete(clave);\n\t\t\t\tpurgadas.push(clave);\n\t\t\t}\n\t\t}\n\n\t\tif (this.entradas.size > maxEntradas) {\n\t\t\tconst porAntiguedad = [...this.entradas].sort((a, b) => a[1].usadoEn - b[1].usadoEn);\n\t\t\tconst sobran = this.entradas.size - maxEntradas;\n\t\t\tfor (const [clave] of porAntiguedad.slice(0, sobran)) {\n\t\t\t\tthis.entradas.delete(clave);\n\t\t\t\tpurgadas.push(clave);\n\t\t\t}\n\t\t}\n\n\t\tif (purgadas.length > 0) this.sucio = true;\n\t\tfor (const clave of purgadas) this.olvidadas.add(clave);\n\t\treturn purgadas;\n\t}\n\n\t/**\n\t * Escribe fundiendo con lo que haya en disco. Las claves que este proceso ha\n\t * borrado a propósito se quitan de la fusión: sin eso, la fusión las\n\t * resucitaría desde la copia en disco de otro proceso y volveríamos a mandar\n\t * un id que ya sabemos muerto, o a guardar para siempre lo que purgamos.\n\t */\n\tasync volcar(olvidadas: Iterable<string> = []): Promise<void> {\n\t\tif (!this.sucio) return;\n\t\tlet enDisco = new Map<string, EntradaDeBlob>();\n\t\ttry {\n\t\t\tenDisco = leerFichero(await readFile(this.ruta, \"utf-8\"));\n\t\t} catch {\n\t\t\t// Sin fichero previo: la fusión es la identidad.\n\t\t}\n\t\tfor (const clave of this.olvidadas) enDisco.delete(clave);\n\t\tfor (const clave of olvidadas) enDisco.delete(clave);\n\t\tfor (const [clave, mia] of this.entradas) {\n\t\t\tconst suya = enDisco.get(clave);\n\t\t\tenDisco.set(clave, !suya || mia.usadoEn >= suya.usadoEn ? mia : suya);\n\t\t}\n\t\tconst doc: FicheroDeBlobs = { version: 1, entradas: Object.fromEntries(enDisco) };\n\t\tawait mkdir(dirname(this.ruta), { recursive: true });\n\t\tconst temporal = `${this.ruta}.${process.pid}.tmp`;\n\t\tawait writeFile(temporal, JSON.stringify(doc, null, \"\\t\"), \"utf-8\");\n\t\tawait rename(temporal, this.ruta);\n\t\tthis.entradas = enDisco;\n\t\tthis.sucio = false;\n\t}\n}\n"]}