@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/dificultad/clasificador.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clasificador.js","sourceRoot":"","sources":["../../../src/core/dificultad/clasificador.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Presupuesto de razonamiento según la dificultad del turno.\n *\n * El nivel de pensamiento estaba fijo para toda la sesión: quien lo dejaba en\n * `high` pagaba razonamiento extendido para preguntar «¿qué hace este\n * fichero?», y quien lo dejaba en `low` pedía una refactorización completa con\n * el presupuesto de una consulta. Las dos mitades cuestan dinero, una en\n * tokens y la otra en calidad.\n *\n * Este clasificador decide el nivel a partir del texto del turno, SIN llamar\n * al modelo: una llamada extra para decidir cuánto gastar se come el ahorro.\n * Solo mira señales del propio texto (longitud, verbos de acción, ficheros\n * mencionados, trazas de error).\n *\n * Tres estados, no dos, en las dos capas:\n *   - `clasificar` devuelve `indeterminada` cuando NO PUEDE clasificar (texto\n *     vacío, un comando de barra, o un turno de dos palabras sin ninguna\n *     señal como «sigue»). No es «fácil»: es «no lo sé», y quien llama no\n *     debe tocar nada.\n *   - `decidirPresupuesto` devuelve una acción explícita (`inactivo`,\n *     `cedido`, `sin-señal`, `sin-cambio`, `aplicar`) en vez de un nivel\n *     opcional, para que «no toco nada porque el usuario mandó» no se lea\n *     igual que «no toco nada porque ya está bien».\n */\n\nimport type { ThinkingLevel } from \"@earendil-works/pi-agent-core\";\n\n/** Orden canónico de menor a mayor gasto (el mismo de `EXTENDED_THINKING_LEVELS`). */\nconst ORDEN: string[] = [\"off\", \"minimal\", \"low\", \"medium\", \"high\", \"xhigh\", \"max\"];\n\nexport type NivelDificultad = \"indeterminada\" | \"trivial\" | \"media\" | \"alta\";\n\nexport interface Dificultad {\n\tnivel: NivelDificultad;\n\t/** Puntuación acumulada; negativa o cero es trivial. Útil para depurar el corpus. */\n\tpuntos: number;\n\t/** Señales encontradas, en el orden en que se sumaron. Se enseñan al usuario. */\n\tseñales: string[];\n}\n\n/**\n * Verbos que implican cambiar el mundo (imperativo e infinitivo, y sus\n * equivalentes en inglés porque medio equipo escribe los prompts en inglés).\n * Se comparan sobre el texto normalizado sin acentos.\n *\n * Los troncos van sin la vocal final del tema («arregl», no «arregla») porque\n * la primera persona es una forma corriente en un turno y la que decide el\n * descuento por consulta directa de más abajo. Con «arregla\\w*» el ejemplo que\n * el propio comentario de ese descuento ponía —«cómo arreglo X»— no encontraba\n * ningún verbo, se llevaba el descuento entero y salía trivial: el comentario\n * decía una cosa y el código hacía la contraria.\n *\n * Los verbos corrientes del día a día («crea», «escribe», «haz», «mueve»,\n * «cambia», «quita», «revisa») faltaban por completo, y su ausencia NO era\n * neutra: sin ninguna señal el turno sumaba 0 puntos y 0 se leía como\n * «trivial», así que «crea un endpoint para facturas» bajaba el presupuesto a\n * `low`. El corpus de la primera versión no lo vio porque sus seis turnos\n * duros usaban justo los verbos de esta lista. Se arregla por los dos lados:\n * aquí, añadiéndolos, y abajo, no leyendo la ausencia de señal como facilidad.\n *\n * Estos van en formas ENUMERADAS, no en troncos, porque el tronco corto choca\n * con palabras que aparecen en consultas puras: «hac\\w*» se come el «hace» de\n * «¿qué hace este fichero?», «escrib\\w*» el «escribio» de «quién escribió\n * esto», y «cre\\w*» el «creo que» de cualquier frase dubitativa. Un falso\n * verbo ahí no solo sube el nivel: además anula el descuento por consulta\n * directa, que exige cero verbos.\n *\n * Techo conocido: sigue siendo una lista de troncos y formas a mano. Las\n * irregulares que no están aquí («rehago», «deshaz») se escapan. Si el corpus\n * de tráfico real lo pide, esto se cambia por un lematizador, no por más\n * troncos.\n */\nconst VERBOS_DE_ACCION =\n\t/\\b(refactoriz\\w*|reescrib\\w+|reimplement\\w+|implement\\w+|migra\\w*|arregl\\w*|corrig\\w+|corrij\\w+|correg\\w+|repar[aeo]\\w*|depur[aeo]\\w*|optimiz\\w*|integr[aeo]\\w*|disen\\w*|anade|anadir|agreg\\w*|elimin\\w*|borr[aeo]\\w*|renombr\\w*|actualiz\\w*|extra[ei]\\w*|divid\\w*|unific\\w*|automatiz\\w*|crea|crear|creame|escribe|escribir|escribeme|haz|hazme|hacer|genera|generar|construye|construir|soluciona|solucionar|resuelve|mueve|mover|traslada|trasladar|cambia|cambiar|convierte|convertir|separa|separar|quita|quitar|revisa|revisar|mejora|mejorar|simplifica|simplificar|documenta|documentar|valida|validar|reemplaza|reemplazar|sustituye|sustituir|refactor|rewrite|reimplement|implement|migrate|fix|debug|optimi[sz]e|integrate|redesign|refactoring|create|write|generate|solve|move|convert|split|replace|simplify|validate|review)\\b/g;\n\n/** Arranques de consulta pura: preguntan por algo que ya existe, no piden cambiarlo. */\nconst ARRANQUE_DE_CONSULTA =\n\t/^(que|cual|cuales|donde|como|quien|cuando|cuanto|para que|por que|what|which|where|how|who|when|why)\\b/;\n\n/** Trazas y mensajes de error pegados: casi siempre implican investigar. */\nconst SEÑAL_DE_ERROR =\n\t/(\\btraceback\\b|\\b\\w*error\\b\\s*:|\\bexception\\b|\\bpanic\\b|\\bsegfault\\b|\\bstack trace\\b|^\\s+at\\s+\\S+|\\bexit code\\s*[:=]?\\s*\\d+|\\bENOENT\\b|\\bECONNREFUSED\\b|\\bfailed to\\b|\\bassertionerror\\b)/im;\n\n/** Rutas y nombres de fichero con extensión conocida. */\nconst FICHERO =\n\t/\\b[\\w.@/-]+\\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|rb|php|c|h|cpp|json|yaml|yml|toml|md|sh|sql|css|html)\\b/g;\n\n/** Quita acentos y baja a minúsculas para que las expresiones no lleven cada variante. */\nfunction normalizar(texto: string): string {\n\treturn texto\n\t\t.normalize(\"NFD\")\n\t\t.replace(/[\\u0300-\\u036f]/g, \"\")\n\t\t.toLowerCase();\n}\n\n/**\n * Clasifica la dificultad de un turno. Función pura: mismo texto, misma salida.\n *\n * Devuelve `indeterminada` cuando no hay nada que clasificar. Un turno vacío,\n * un comando de barra o un «sigue» de dos palabras no son «triviales»: no\n * traen ninguna señal, y bajar el presupuesto por ellos sería decidir con una\n * señal que no existe.\n */\nexport function clasificarDificultad(texto: string): Dificultad {\n\tconst crudo = texto.trim();\n\tif (crudo.length === 0 || crudo.startsWith(\"/\")) {\n\t\treturn { nivel: \"indeterminada\", puntos: 0, señales: [] };\n\t}\n\n\tconst t = normalizar(crudo);\n\tconst señales: string[] = [];\n\tlet puntos = 0;\n\n\tconst verbos = t.match(VERBOS_DE_ACCION) ?? [];\n\tif (verbos.length > 0) {\n\t\tconst suma = Math.min(verbos.length * 2, 4);\n\t\tpuntos += suma;\n\t\tseñales.push(verbos.length === 1 ? \"1 verbo de accion\" : `${verbos.length} verbos de accion`);\n\t}\n\n\tconst ficheros = new Set(crudo.match(FICHERO) ?? []);\n\tif (ficheros.size > 0) {\n\t\tpuntos += Math.min(ficheros.size, 3);\n\t\tseñales.push(ficheros.size === 1 ? \"1 fichero\" : `${ficheros.size} ficheros`);\n\t}\n\n\tif (SEÑAL_DE_ERROR.test(crudo)) {\n\t\tpuntos += 3;\n\t\tseñales.push(\"traza de error\");\n\t}\n\n\tif (crudo.length > 400) {\n\t\tpuntos += 2;\n\t\tseñales.push(\"turno largo\");\n\t} else if (crudo.length > 160) {\n\t\tpuntos += 1;\n\t\tseñales.push(\"turno medio\");\n\t}\n\n\t// Una lista de puntos o varias líneas es casi siempre varias tareas.\n\tconst lineas = crudo.split(\"\\n\").filter((l) => l.trim().length > 0);\n\tif (lineas.length >= 3 || /^\\s*(?:[-*]|\\d+[.)])\\s+/m.test(crudo)) {\n\t\tpuntos += 1;\n\t\tseñales.push(\"varias tareas\");\n\t}\n\n\t// Una consulta pura sin ningún verbo de acción se abarata a propósito.\n\t// Con verbo de acción no se descuenta: «cómo arreglo X» es trabajo, y por\n\t// eso los troncos de arriba tienen que cubrir la primera persona. Este\n\t// comentario decía ya esto mientras «cómo arreglo X» salía trivial.\n\tif (ARRANQUE_DE_CONSULTA.test(t.replace(/^[¿¡\\s]+/, \"\")) && verbos.length === 0) {\n\t\tpuntos -= 2;\n\t\tseñales.push(\"consulta directa\");\n\t}\n\n\t// CERO señales no es «fácil»: es «no lo sé». Sin esta puerta, `trivial` era\n\t// el valor por defecto de todo lo que la lista de verbos no reconocía, y la\n\t// lista nunca va a reconocerlo todo. Medido: de catorce turnos de trabajo\n\t// reales escritos con verbos corrientes («crea un endpoint», «mueve la\n\t// lógica de auth a su propio paquete», «revisa la seguridad del endpoint de\n\t// pagos»), los catorce salían `trivial` y se llevaban el presupuesto más\n\t// barato — exactamente el daño que este módulo dice venir a evitar. Lo\n\t// mismo con «sigue» detrás de una refactorización: el agente continuaba la\n\t// tarea dura con el presupuesto de una consulta.\n\t//\n\t// `trivial` pasa a exigir evidencia POSITIVA de que el turno es una\n\t// consulta (el descuento de arriba, o cualquier otra señal que deje los\n\t// puntos por debajo de cero). Sin ninguna señal no tocamos el presupuesto:\n\t// quedarse en el nivel de la sesión es el error barato; bajar a `low` una\n\t// tarea de refactorización es el caro.\n\tif (señales.length === 0) {\n\t\treturn { nivel: \"indeterminada\", puntos, señales };\n\t}\n\n\tconst nivel: NivelDificultad = puntos >= 4 ? \"alta\" : puntos >= 1 ? \"media\" : \"trivial\";\n\treturn { nivel, puntos, señales };\n}\n\n/** Nivel canónico que pediríamos para cada dificultad si el modelo los tuviera todos. */\nconst NIVEL_IDEAL: Record<Exclude<NivelDificultad, \"indeterminada\">, ThinkingLevel> = {\n\ttrivial: \"low\",\n\tmedia: \"medium\",\n\talta: \"high\",\n};\n\n/**\n * Traduce la dificultad al nivel más cercano de los que el modelo soporta.\n *\n * No todos los modelos tienen los siete niveles; en caso de empate se elige el\n * más barato, porque equivocarse hacia abajo cuesta menos que hacia arriba.\n *\n * El empate se resuelve mirando el ÍNDICE, no el orden de llegada. Quedarse\n * con el primero solo da el más barato si `disponibles` viene ordenado de\n * menor a mayor gasto — cierto hoy porque `getSupportedThinkingLevels` filtra\n * `EXTENDED_THINKING_LEVELS` en ese orden, pero eso es una propiedad del\n * llamante de hoy, no del contrato de esta función. Con `[\"high\", \"low\"]` y\n * dificultad media (ambos a distancia 1) devolvía `high`: lo caro, justo lo\n * que el comentario prometía no hacer.\n */\nexport function nivelParaDificultad(\n\tdificultad: Exclude<NivelDificultad, \"indeterminada\">,\n\tdisponibles: readonly ThinkingLevel[],\n): ThinkingLevel | null {\n\tif (disponibles.length === 0) return null;\n\tconst objetivo = ORDEN.indexOf(NIVEL_IDEAL[dificultad]);\n\tlet mejor: ThinkingLevel | null = null;\n\tlet mejorDistancia = Number.POSITIVE_INFINITY;\n\tlet mejorIndice = Number.POSITIVE_INFINITY;\n\tfor (const candidato of disponibles) {\n\t\tconst i = ORDEN.indexOf(candidato);\n\t\tif (i < 0) continue;\n\t\tconst distancia = Math.abs(i - objetivo);\n\t\tif (distancia < mejorDistancia || (distancia === mejorDistancia && i < mejorIndice)) {\n\t\t\tmejor = candidato;\n\t\t\tmejorDistancia = distancia;\n\t\t\tmejorIndice = i;\n\t\t}\n\t}\n\treturn mejor;\n}\n\n/** Estado que sobrevive entre turnos de una misma sesión. */\nexport interface EstadoPresupuesto {\n\t/** Nivel efectivo que dejamos puesto la última vez. `null` = aún no hemos tocado nada. */\n\tnivelPuestoPorNosotros: ThinkingLevel | null;\n\t/** El usuario mandó a mano; no volvemos a decidir en esta sesión. */\n\tcedido: boolean;\n}\n\nexport function estadoInicial(): EstadoPresupuesto {\n\treturn { nivelPuestoPorNosotros: null, cedido: false };\n}\n\nexport interface EntradaDecision {\n\ttexto: string;\n\tnivelActual: ThinkingLevel;\n\tdisponibles: readonly ThinkingLevel[];\n\testado: EstadoPresupuesto;\n\tactivo: boolean;\n}\n\nexport type DecisionDePresupuesto =\n\t| { accion: \"inactivo\" }\n\t| { accion: \"cedido\"; motivo: \"el usuario eligio el nivel a mano\" }\n\t| { accion: \"sin-señal\"; dificultad: Dificultad }\n\t| { accion: \"sin-cambio\"; dificultad: Dificultad; nivel: ThinkingLevel }\n\t| { accion: \"aplicar\"; dificultad: Dificultad; nivel: ThinkingLevel; anterior: ThinkingLevel };\n\n/**\n * Decide qué hacer con el presupuesto de este turno.\n *\n * NO es pura: al detectar la cesión marca `entrada.estado.cedido`. La marca es\n * necesaria — si solo dedujéramos la cesión comparando niveles, el usuario que\n * cicla con shift+tab y vuelve a caer en el nivel que dejamos puesto haría que\n * volviésemos a decidir por él. Aquí decía «sin efectos secundarios» y era\n * falso; se corrige el comentario, no el código.\n *\n * La cesión es la puerta del usuario: en cuanto el nivel actual no es el que\n * nosotros dejamos puesto, alguien lo cambió a mano entre turnos y dejamos de\n * decidir para el resto de la sesión. Se detecta comparando nuestro propio\n * estado, sin pedirle a upstream que nos avise de nada.\n *\n * El primer turno lo decidimos siempre. El nivel con el que arranca la sesión\n * es una CONFIGURACIÓN (el default de settings, o el del modelo), no la\n * intención de este turno — y es justo lo que este clasificador viene a\n * sustituir. Lo que respetamos es el cambio explícito, que va acompañado del\n * aviso visible que explica cómo desactivarnos.\n */\nexport function decidirPresupuesto(entrada: EntradaDecision): DecisionDePresupuesto {\n\tif (!entrada.activo) return { accion: \"inactivo\" };\n\n\tconst puesto = entrada.estado.nivelPuestoPorNosotros;\n\tif (entrada.estado.cedido || (puesto !== null && entrada.nivelActual !== puesto)) {\n\t\tentrada.estado.cedido = true;\n\t\treturn { accion: \"cedido\", motivo: \"el usuario eligio el nivel a mano\" };\n\t}\n\n\tconst dificultad = clasificarDificultad(entrada.texto);\n\tif (dificultad.nivel === \"indeterminada\") {\n\t\treturn { accion: \"sin-señal\", dificultad };\n\t}\n\n\tconst nivel = nivelParaDificultad(dificultad.nivel, entrada.disponibles);\n\tif (nivel === null || nivel === entrada.nivelActual) {\n\t\treturn { accion: \"sin-cambio\", dificultad, nivel: nivel ?? entrada.nivelActual };\n\t}\n\treturn { accion: \"aplicar\", dificultad, nivel, anterior: entrada.nivelActual };\n}\n\n/** Texto que ve el usuario. El ajuste NO puede ser silencioso: cambia lo que paga. */\nexport function mensajeDeDecision(decision: Extract<DecisionDePresupuesto, { accion: \"aplicar\" }>): string {\n\tconst señales = decision.dificultad.señales.length > 0 ? decision.dificultad.señales.join(\", \") : \"sin señales\";\n\treturn `Razonamiento automatico: ${decision.anterior} -> ${decision.nivel} (dificultad ${decision.dificultad.nivel}: ${señales}). Cambialo a mano para desactivarlo en esta sesion.`;\n}\n\n/** Puerto mínimo con la sesión. Lo justo para no importar `AgentSession` aquí. */\nexport interface SesionAjustable {\n\tnivelActual: ThinkingLevel;\n\tdisponibles: readonly ThinkingLevel[];\n\t/** Aplica el nivel y devuelve el EFECTIVO (upstream lo recorta al modelo). */\n\tfijar(nivel: ThinkingLevel): ThinkingLevel;\n\tavisar(mensaje: string): void;\n}\n\n/**\n * El estado vive aquí, indexado por la sesión, y no como campo de\n * `AgentSession`: declarar un campo privado en esa clase sería un hunk más\n * contra el presupuesto de fork, que está agotado (116/116). La sesión es la\n * clave; cuando se recolecta, su estado se va con ella.\n */\nconst estados = new WeakMap<object, EstadoPresupuesto>();\n\n/** El interruptor de escape, sin tocar `settings-manager.ts` (otro hunk de upstream). */\nfunction estaActivo(env: NodeJS.ProcessEnv): boolean {\n\tconst v = env.ADA_DIFICULTAD_AUTO;\n\treturn v !== \"0\" && v !== \"false\" && v !== \"no\";\n}\n\n/**\n * Punto de entrada desde `agent-session.prompt()`. Decide, aplica y avisa.\n *\n * Devuelve la decisión para que se pueda comprobar desde fuera: una función\n * que solo tiene efectos secundarios es una función que nadie verifica.\n */\nexport function ajustarPresupuestoDeRazonamiento(\n\tclave: object,\n\ttexto: string,\n\tsesion: SesionAjustable,\n\tenv: NodeJS.ProcessEnv = process.env,\n): DecisionDePresupuesto {\n\tlet estado = estados.get(clave);\n\tif (!estado) {\n\t\testado = estadoInicial();\n\t\testados.set(clave, estado);\n\t}\n\n\tconst decision = decidirPresupuesto({\n\t\ttexto,\n\t\tnivelActual: sesion.nivelActual,\n\t\tdisponibles: sesion.disponibles,\n\t\testado,\n\t\tactivo: estaActivo(env),\n\t});\n\n\tif (decision.accion === \"aplicar\") {\n\t\t// Guardamos el nivel EFECTIVO, no el pedido: upstream lo recorta a las\n\t\t// capacidades del modelo y, si guardáramos el pedido, el turno siguiente\n\t\t// vería una diferencia y cedería creyendo que fue el usuario.\n\t\testado.nivelPuestoPorNosotros = sesion.fijar(decision.nivel);\n\t\tsesion.avisar(mensajeDeDecision(decision));\n\t} else if (decision.accion === \"sin-cambio\" || decision.accion === \"sin-señal\") {\n\t\t// Un turno en el que NO cambiamos nada también hay que anotarlo: lo que\n\t\t// queda puesto es el nivel actual, y es contra ese valor contra el que\n\t\t// se detecta al usuario. Anotando solo al cambiar,\n\t\t// `nivelPuestoPorNosotros` se quedaba en null mientras el objetivo\n\t\t// coincidiera con el nivel de arranque, y la puerta de cesión no se\n\t\t// armaba nunca: sesión en `medium`, turno «arregla esto» (media ->\n\t\t// medium, sin-cambio), el usuario sube a `high` a mano y el turno\n\t\t// siguiente se lo bajaba a `low` sin ceder ni avisar de nada.\n\t\testado.nivelPuestoPorNosotros = sesion.nivelActual;\n\t}\n\treturn decision;\n}\n\n/** Solo para pruebas: olvida el estado de una sesión. */\nexport function olvidarEstado(clave: object): void {\n\testados.delete(clave);\n}\n"]}

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

@@ -0,0 +1,37 @@
+/**
+ * Diario de ediciones — un JSONL con `{ruta, antes, despues, resultado}` de
+ * cada edición que toca el observador.
+ *
+ * Es distinto del libro de sesión (`audit/libro.ts`): ese minimiza a hashes
+ * por diseño de cumplimiento — "nunca guardar el texto". Este diario existe
+ * justo para lo contrario: es la materia prima para medir si el auto-arreglo
+ * de `reparacion.ts` mejora las cosas de verdad, y para eso hace falta poder
+ * comparar antes/después de contenido, no solo saber que cambió. Por eso
+ * pasa cada lado por `taparAntesDeEscribir` antes de tocar disco — sin eso,
+ * cualquier secreto que el usuario tuviera en el fichero editado quedaría
+ * duplicado aquí en claro. Se cambió de `redactSensitive` a esa función porque
+ * `redactSensitive` no cubre las categorías especiales del art. 9 del RGPD:
+ * medido, una frase que las contenía salía de esa función idéntica, sin tapar
+ * un solo carácter. Un dato de esa clase aquí, y este diario es harina de otro costal que el
+ * libro de sesión: nadie audita su cadena, así que un secreto aquí no tiene
+ * ni la protección de "hace falta acceso al fichero de auditoría".
+ */
+export type ResultadoEdicion = "ok" | "rota" | "reparada" | "reparacion-rechazada";
+export interface EntradaDiario {
+    ruta: string;
+    /** `null` = el fichero no existía antes de la edición. */
+    antes: string | null;
+    /** `null` = la edición borró el fichero. */
+    despues: string | null;
+    resultado: ResultadoEdicion;
+}
+/** Ruta del fichero del día, dentro de `<agentDir>/edicion/`. Un fichero por día, no uno gigante. */
+export declare function ficheroDelDiario(agentDir: string, fecha: string): string;
+/** La línea tal cual se escribe, con el texto ya redactado. Separado de `anotarEnDiario` para poder probarlo sin tocar disco. */
+export declare function formatearEntrada(entrada: EntradaDiario, ts?: string): string;
+/**
+ * Anota una edición en el diario del día. Nunca lanza: igual que el libro de
+ * sesión, un fallo de este diario no puede tumbar la edición que registra.
+ */
+export declare function anotarEnDiario(agentDir: string, entrada: EntradaDiario): Promise<void>;
+//# sourceMappingURL=diario.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diario.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/diario.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG,MAAM,GAAG,UAAU,GAAG,sBAAsB,CAAC;AAEnF,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,4DAA0D;IAC1D,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,8CAA4C;IAC5C,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,gBAAgB,CAAC;CAC5B;AAED,uGAAqG;AACrG,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAExE;AAED,kIAAiI;AACjI,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,EAAE,EAAE,SAA2B,GAAG,MAAM,CAQ9F;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAS5F","sourcesContent":["/**\n * Diario de ediciones — un JSONL con `{ruta, antes, despues, resultado}` de\n * cada edición que toca el observador.\n *\n * Es distinto del libro de sesión (`audit/libro.ts`): ese minimiza a hashes\n * por diseño de cumplimiento — \"nunca guardar el texto\". Este diario existe\n * justo para lo contrario: es la materia prima para medir si el auto-arreglo\n * de `reparacion.ts` mejora las cosas de verdad, y para eso hace falta poder\n * comparar antes/después de contenido, no solo saber que cambió. Por eso\n * pasa cada lado por `taparAntesDeEscribir` antes de tocar disco — sin eso,\n * cualquier secreto que el usuario tuviera en el fichero editado quedaría\n * duplicado aquí en claro. Se cambió de `redactSensitive` a esa función porque\n * `redactSensitive` no cubre las categorías especiales del art. 9 del RGPD:\n * medido, una frase que las contenía salía de esa función idéntica, sin tapar\n * un solo carácter. Un dato de esa clase aquí, y este diario es harina de otro costal que el\n * libro de sesión: nadie audita su cadena, así que un secreto aquí no tiene\n * ni la protección de \"hace falta acceso al fichero de auditoría\".\n */\n\nimport { appendFile, mkdir } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { taparAntesDeEscribir } from \"../privacidad/tapar.ts\";\n\nexport type ResultadoEdicion = \"ok\" | \"rota\" | \"reparada\" | \"reparacion-rechazada\";\n\nexport interface EntradaDiario {\n\truta: string;\n\t/** `null` = el fichero no existía antes de la edición. */\n\tantes: string | null;\n\t/** `null` = la edición borró el fichero. */\n\tdespues: string | null;\n\tresultado: ResultadoEdicion;\n}\n\n/** Ruta del fichero del día, dentro de `<agentDir>/edicion/`. Un fichero por día, no uno gigante. */\nexport function ficheroDelDiario(agentDir: string, fecha: string): string {\n\treturn join(agentDir, \"edicion\", `diario-${fecha}.jsonl`);\n}\n\n/** La línea tal cual se escribe, con el texto ya redactado. Separado de `anotarEnDiario` para poder probarlo sin tocar disco. */\nexport function formatearEntrada(entrada: EntradaDiario, ts = new Date().toISOString()): string {\n\treturn JSON.stringify({\n\t\tts,\n\t\truta: entrada.ruta,\n\t\tantes: entrada.antes === null ? null : taparAntesDeEscribir(entrada.antes),\n\t\tdespues: entrada.despues === null ? null : taparAntesDeEscribir(entrada.despues),\n\t\tresultado: entrada.resultado,\n\t});\n}\n\n/**\n * Anota una edición en el diario del día. Nunca lanza: igual que el libro de\n * sesión, un fallo de este diario no puede tumbar la edición que registra.\n */\nexport async function anotarEnDiario(agentDir: string, entrada: EntradaDiario): Promise<void> {\n\ttry {\n\t\tconst ts = new Date().toISOString();\n\t\tconst dir = join(agentDir, \"edicion\");\n\t\tawait mkdir(dir, { recursive: true });\n\t\tawait appendFile(ficheroDelDiario(agentDir, ts.slice(0, 10)), `${formatearEntrada(entrada, ts)}\\n`, \"utf-8\");\n\t} catch {\n\t\t// El diario nunca rompe la edición que registra.\n\t}\n}\n"]}

package/dist/core/edicion/diario.js

@@ -0,0 +1,51 @@
+/**
+ * Diario de ediciones — un JSONL con `{ruta, antes, despues, resultado}` de
+ * cada edición que toca el observador.
+ *
+ * Es distinto del libro de sesión (`audit/libro.ts`): ese minimiza a hashes
+ * por diseño de cumplimiento — "nunca guardar el texto". Este diario existe
+ * justo para lo contrario: es la materia prima para medir si el auto-arreglo
+ * de `reparacion.ts` mejora las cosas de verdad, y para eso hace falta poder
+ * comparar antes/después de contenido, no solo saber que cambió. Por eso
+ * pasa cada lado por `taparAntesDeEscribir` antes de tocar disco — sin eso,
+ * cualquier secreto que el usuario tuviera en el fichero editado quedaría
+ * duplicado aquí en claro. Se cambió de `redactSensitive` a esa función porque
+ * `redactSensitive` no cubre las categorías especiales del art. 9 del RGPD:
+ * medido, una frase que las contenía salía de esa función idéntica, sin tapar
+ * un solo carácter. Un dato de esa clase aquí, y este diario es harina de otro costal que el
+ * libro de sesión: nadie audita su cadena, así que un secreto aquí no tiene
+ * ni la protección de "hace falta acceso al fichero de auditoría".
+ */
+import { appendFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { taparAntesDeEscribir } from "../privacidad/tapar.js";
+/** Ruta del fichero del día, dentro de `<agentDir>/edicion/`. Un fichero por día, no uno gigante. */
+export function ficheroDelDiario(agentDir, fecha) {
+    return join(agentDir, "edicion", `diario-${fecha}.jsonl`);
+}
+/** La línea tal cual se escribe, con el texto ya redactado. Separado de `anotarEnDiario` para poder probarlo sin tocar disco. */
+export function formatearEntrada(entrada, ts = new Date().toISOString()) {
+    return JSON.stringify({
+        ts,
+        ruta: entrada.ruta,
+        antes: entrada.antes === null ? null : taparAntesDeEscribir(entrada.antes),
+        despues: entrada.despues === null ? null : taparAntesDeEscribir(entrada.despues),
+        resultado: entrada.resultado,
+    });
+}
+/**
+ * Anota una edición en el diario del día. Nunca lanza: igual que el libro de
+ * sesión, un fallo de este diario no puede tumbar la edición que registra.
+ */
+export async function anotarEnDiario(agentDir, entrada) {
+    try {
+        const ts = new Date().toISOString();
+        const dir = join(agentDir, "edicion");
+        await mkdir(dir, { recursive: true });
+        await appendFile(ficheroDelDiario(agentDir, ts.slice(0, 10)), `${formatearEntrada(entrada, ts)}\n`, "utf-8");
+    }
+    catch {
+        // El diario nunca rompe la edición que registra.
+    }
+}
+//# sourceMappingURL=diario.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diario.js","sourceRoot":"","sources":["../../../src/core/edicion/diario.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAa9D,uGAAqG;AACrG,MAAM,UAAU,gBAAgB,CAAC,QAAgB,EAAE,KAAa,EAAU;IACzE,OAAO,IAAI,CAAC,QAAQ,EAAE,SAAS,EAAE,UAAU,KAAK,QAAQ,CAAC,CAAC;AAAA,CAC1D;AAED,kIAAiI;AACjI,MAAM,UAAU,gBAAgB,CAAC,OAAsB,EAAE,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAU;IAC/F,OAAO,IAAI,CAAC,SAAS,CAAC;QACrB,EAAE;QACF,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,KAAK,EAAE,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,oBAAoB,CAAC,OAAO,CAAC,KAAK,CAAC;QAC1E,OAAO,EAAE,OAAO,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,oBAAoB,CAAC,OAAO,CAAC,OAAO,CAAC;QAChF,SAAS,EAAE,OAAO,CAAC,SAAS;KAC5B,CAAC,CAAC;AAAA,CACH;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,QAAgB,EAAE,OAAsB,EAAiB;IAC7F,IAAI,CAAC;QACJ,MAAM,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QACpC,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;QACtC,MAAM,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACtC,MAAM,UAAU,CAAC,gBAAgB,CAAC,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,gBAAgB,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC9G,CAAC;IAAC,MAAM,CAAC;QACR,kDAAiD;IAClD,CAAC;AAAA,CACD","sourcesContent":["/**\n * Diario de ediciones — un JSONL con `{ruta, antes, despues, resultado}` de\n * cada edición que toca el observador.\n *\n * Es distinto del libro de sesión (`audit/libro.ts`): ese minimiza a hashes\n * por diseño de cumplimiento — \"nunca guardar el texto\". Este diario existe\n * justo para lo contrario: es la materia prima para medir si el auto-arreglo\n * de `reparacion.ts` mejora las cosas de verdad, y para eso hace falta poder\n * comparar antes/después de contenido, no solo saber que cambió. Por eso\n * pasa cada lado por `taparAntesDeEscribir` antes de tocar disco — sin eso,\n * cualquier secreto que el usuario tuviera en el fichero editado quedaría\n * duplicado aquí en claro. Se cambió de `redactSensitive` a esa función porque\n * `redactSensitive` no cubre las categorías especiales del art. 9 del RGPD:\n * medido, una frase que las contenía salía de esa función idéntica, sin tapar\n * un solo carácter. Un dato de esa clase aquí, y este diario es harina de otro costal que el\n * libro de sesión: nadie audita su cadena, así que un secreto aquí no tiene\n * ni la protección de \"hace falta acceso al fichero de auditoría\".\n */\n\nimport { appendFile, mkdir } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { taparAntesDeEscribir } from \"../privacidad/tapar.ts\";\n\nexport type ResultadoEdicion = \"ok\" | \"rota\" | \"reparada\" | \"reparacion-rechazada\";\n\nexport interface EntradaDiario {\n\truta: string;\n\t/** `null` = el fichero no existía antes de la edición. */\n\tantes: string | null;\n\t/** `null` = la edición borró el fichero. */\n\tdespues: string | null;\n\tresultado: ResultadoEdicion;\n}\n\n/** Ruta del fichero del día, dentro de `<agentDir>/edicion/`. Un fichero por día, no uno gigante. */\nexport function ficheroDelDiario(agentDir: string, fecha: string): string {\n\treturn join(agentDir, \"edicion\", `diario-${fecha}.jsonl`);\n}\n\n/** La línea tal cual se escribe, con el texto ya redactado. Separado de `anotarEnDiario` para poder probarlo sin tocar disco. */\nexport function formatearEntrada(entrada: EntradaDiario, ts = new Date().toISOString()): string {\n\treturn JSON.stringify({\n\t\tts,\n\t\truta: entrada.ruta,\n\t\tantes: entrada.antes === null ? null : taparAntesDeEscribir(entrada.antes),\n\t\tdespues: entrada.despues === null ? null : taparAntesDeEscribir(entrada.despues),\n\t\tresultado: entrada.resultado,\n\t});\n}\n\n/**\n * Anota una edición en el diario del día. Nunca lanza: igual que el libro de\n * sesión, un fallo de este diario no puede tumbar la edición que registra.\n */\nexport async function anotarEnDiario(agentDir: string, entrada: EntradaDiario): Promise<void> {\n\ttry {\n\t\tconst ts = new Date().toISOString();\n\t\tconst dir = join(agentDir, \"edicion\");\n\t\tawait mkdir(dir, { recursive: true });\n\t\tawait appendFile(ficheroDelDiario(agentDir, ts.slice(0, 10)), `${formatearEntrada(entrada, ts)}\\n`, \"utf-8\");\n\t} catch {\n\t\t// El diario nunca rompe la edición que registra.\n\t}\n}\n"]}

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

@@ -0,0 +1,71 @@
+/**
+ * Hashline — formato de edición anclado por hash de línea.
+ *
+ * Nuestro único formato de edición hoy (`edit`, en `core/tools/edit.ts`) casa
+ * `oldText` contra el contenido actual del fichero: si el texto no está
+ * literal, la edición falla con un error de "no encontrado". No hay forma de
+ * decir "quiero cambiar las líneas 10-12 tal como las vi", así que un hunk
+ * calculado sobre una versión del fichero que ya cambió por debajo (otro
+ * proceso, otra pestaña del agente, el usuario a mano) se puede colar sobre
+ * líneas que ya no son las que el hunk cree que son, con la única defensa de
+ * que `oldText` deje de encontrarse — y si el nuevo contenido de esas líneas
+ * es distinto pero de la misma LONGITUD y forma que el viejo `oldText`
+ * (variable renombrada, número cambiado), ni eso lo detiene.
+ *
+ * Hashline cierra ese hueco por construcción: el hunk lleva un hash del
+ * contenido exacto del rango que dice tocar, calculado sobre lo que el
+ * llamante VIO. `aplicarHashline` recalcula ese mismo hash sobre el fichero
+ * tal como está AHORA y rechaza el hunk si no coincide — sin tocar el
+ * fichero — en vez de intentar adivinar dónde se movió el texto. La idea es
+ * la de `@oh-my-pi/hashline` (paquete de referencia en
+ * `/Users/31017423z/auditoria-omp/oh-my-pi/packages/hashline`): anclar cada
+ * hunk a un hash de contenido y rechazar el que ya no cuadra. Lo que cambia
+ * aquí es el alcance: ellos anclan el FICHERO ENTERO con una gramática de
+ * varias operaciones (PUT/CUT/MV…) pensada para sustituir su tool de edición
+ * completa; esto ancla cada RANGO de líneas por separado, como una quinta
+ * opción de formato de edición, no un reemplazo del `edit` que ya existe.
+ */
+/** Etiqueta de 8 hex del contenido exacto de las líneas `desde..hasta` (1-indexado, inclusive). */
+export declare function etiquetaDeRango(lineas: readonly string[], desde: number, hasta: number): string;
+/** Construye la cabecera `[ruta#tag]` para el rango `desde..hasta` del contenido actual. */
+export declare function construirCabecera(ruta: string, contenido: string, desde: number, hasta: number): string;
+export interface HunkHashline {
+    ruta: string;
+    tag: string;
+    /** 1-indexado, inclusive. */
+    desde: number;
+    hasta: number;
+    /** Líneas de sustitución, ya sin el `+` de cabecera. */
+    cuerpo: string[];
+}
+/** `{hunk}` si parseó, `{error}` si no — dos formas distintas, nunca un `null` que mezcle los dos motivos. */
+export type ResultadoParseo = {
+    hunk: HunkHashline;
+} | {
+    error: string;
+};
+/**
+ * Parsea un hunk hashline de tres partes: cabecera `[ruta#tag]`, línea de
+ * rango `A` o `A-B`, y cuerpo con cada línea de sustitución prefijada por
+ * `+` (una línea `+` sola es una línea en blanco).
+ */
+export declare function parsearHunk(texto: string): ResultadoParseo;
+export type ResultadoAplicar = {
+    ok: true;
+    contenido: string;
+}
+/** El hunk parseó pero su tag no corresponde a las líneas actuales, o el rango cae fuera del fichero: nada se toca. */
+ | {
+    ok: false;
+    motivo: string;
+};
+/**
+ * Aplica un hunk ya parseado sobre `contenidoActual`. Rechaza sin tocar nada
+ * si el tag no coincide con lo que hay AHORA en ese rango — esa es toda la
+ * garantía del formato: un hunk calculado sobre una versión vieja del
+ * fichero nunca se aplica en silencio sobre líneas que ya cambiaron.
+ */
+export declare function aplicarHunk(contenidoActual: string, hunk: HunkHashline): ResultadoAplicar;
+/** Atajo: parsea y aplica en un paso, contra el contenido actual del fichero que nombra el hunk. */
+export declare function aplicarHashline(contenidoActual: string, textoHunk: string): ResultadoAplicar;
+//# sourceMappingURL=hashline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hashline.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/hashline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,oGAAmG;AACnG,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG/F;AAED,4FAA4F;AAC5F,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvG;AAED,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,0DAAwD;IACxD,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,iHAA8G;AAC9G,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAKzE;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAgC1D;AAED,MAAM,MAAM,gBAAgB,GACzB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;AACjC,yHAAuH;GACrH;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjC;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,gBAAgB,CAqBzF;AAED,oGAAoG;AACpG,wBAAgB,eAAe,CAAC,eAAe,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAI5F","sourcesContent":["/**\n * Hashline — formato de edición anclado por hash de línea.\n *\n * Nuestro único formato de edición hoy (`edit`, en `core/tools/edit.ts`) casa\n * `oldText` contra el contenido actual del fichero: si el texto no está\n * literal, la edición falla con un error de \"no encontrado\". No hay forma de\n * decir \"quiero cambiar las líneas 10-12 tal como las vi\", así que un hunk\n * calculado sobre una versión del fichero que ya cambió por debajo (otro\n * proceso, otra pestaña del agente, el usuario a mano) se puede colar sobre\n * líneas que ya no son las que el hunk cree que son, con la única defensa de\n * que `oldText` deje de encontrarse — y si el nuevo contenido de esas líneas\n * es distinto pero de la misma LONGITUD y forma que el viejo `oldText`\n * (variable renombrada, número cambiado), ni eso lo detiene.\n *\n * Hashline cierra ese hueco por construcción: el hunk lleva un hash del\n * contenido exacto del rango que dice tocar, calculado sobre lo que el\n * llamante VIO. `aplicarHashline` recalcula ese mismo hash sobre el fichero\n * tal como está AHORA y rechaza el hunk si no coincide — sin tocar el\n * fichero — en vez de intentar adivinar dónde se movió el texto. La idea es\n * la de `@oh-my-pi/hashline` (paquete de referencia en\n * `/Users/31017423z/auditoria-omp/oh-my-pi/packages/hashline`): anclar cada\n * hunk a un hash de contenido y rechazar el que ya no cuadra. Lo que cambia\n * aquí es el alcance: ellos anclan el FICHERO ENTERO con una gramática de\n * varias operaciones (PUT/CUT/MV…) pensada para sustituir su tool de edición\n * completa; esto ancla cada RANGO de líneas por separado, como una quinta\n * opción de formato de edición, no un reemplazo del `edit` que ya existe.\n */\n\nimport { createHash } from \"node:crypto\";\n\n/** Etiqueta de 8 hex del contenido exacto de las líneas `desde..hasta` (1-indexado, inclusive). */\nexport function etiquetaDeRango(lineas: readonly string[], desde: number, hasta: number): string {\n\tconst texto = lineas.slice(desde - 1, hasta).join(\"\\n\");\n\treturn createHash(\"sha256\").update(texto).digest(\"hex\").slice(0, 8);\n}\n\n/** Construye la cabecera `[ruta#tag]` para el rango `desde..hasta` del contenido actual. */\nexport function construirCabecera(ruta: string, contenido: string, desde: number, hasta: number): string {\n\treturn `[${ruta}#${etiquetaDeRango(contenido.split(\"\\n\"), desde, hasta)}]`;\n}\n\nexport interface HunkHashline {\n\truta: string;\n\ttag: string;\n\t/** 1-indexado, inclusive. */\n\tdesde: number;\n\thasta: number;\n\t/** Líneas de sustitución, ya sin el `+` de cabecera. */\n\tcuerpo: string[];\n}\n\n/** `{hunk}` si parseó, `{error}` si no — dos formas distintas, nunca un `null` que mezcle los dos motivos. */\nexport type ResultadoParseo = { hunk: HunkHashline } | { error: string };\n\nconst RE_CABECERA = /^\\[(.+)#([0-9a-f]{8})\\]\\s*$/;\nconst RE_RANGO = /^(\\d+)(?:-(\\d+))?\\s*$/;\n\n/**\n * Parsea un hunk hashline de tres partes: cabecera `[ruta#tag]`, línea de\n * rango `A` o `A-B`, y cuerpo con cada línea de sustitución prefijada por\n * `+` (una línea `+` sola es una línea en blanco).\n */\nexport function parsearHunk(texto: string): ResultadoParseo {\n\tconst lineas = texto.replace(/\\r\\n/g, \"\\n\").split(\"\\n\");\n\t// Ignora líneas en blanco iniciales/finales: son ruido de quien compone el\n\t// hunk a mano, no parte del formato.\n\twhile (lineas.length > 0 && lineas[0].trim() === \"\") lineas.shift();\n\twhile (lineas.length > 0 && lineas.at(-1)?.trim() === \"\") lineas.pop();\n\n\tif (lineas.length < 2) return { error: \"hunk vacío: hace falta cabecera y línea de rango\" };\n\n\tconst cabecera = lineas[0].match(RE_CABECERA);\n\tif (!cabecera) return { error: `cabecera inválida: \"${lineas[0]}\" (se esperaba \"[ruta#8hex]\")` };\n\n\tconst rango = lineas[1].match(RE_RANGO);\n\tif (!rango) return { error: `rango inválido: \"${lineas[1]}\" (se esperaba \"A\" o \"A-B\")` };\n\tconst desde = Number(rango[1]);\n\tconst hasta = rango[2] !== undefined ? Number(rango[2]) : desde;\n\tif (desde < 1 || hasta < desde) return { error: `rango sin sentido: ${desde}-${hasta}` };\n\n\tconst cuerpo: string[] = [];\n\tfor (let i = 2; i < lineas.length; i++) {\n\t\tconst linea = lineas[i];\n\t\tif (linea === \"+\") {\n\t\t\tcuerpo.push(\"\");\n\t\t\tcontinue;\n\t\t}\n\t\tif (!linea.startsWith(\"+\")) {\n\t\t\treturn { error: `línea de cuerpo sin \"+\": \"${linea}\"` };\n\t\t}\n\t\tcuerpo.push(linea.slice(1));\n\t}\n\n\treturn { hunk: { ruta: cabecera[1], tag: cabecera[2], desde, hasta, cuerpo } };\n}\n\nexport type ResultadoAplicar =\n\t| { ok: true; contenido: string }\n\t/** El hunk parseó pero su tag no corresponde a las líneas actuales, o el rango cae fuera del fichero: nada se toca. */\n\t| { ok: false; motivo: string };\n\n/**\n * Aplica un hunk ya parseado sobre `contenidoActual`. Rechaza sin tocar nada\n * si el tag no coincide con lo que hay AHORA en ese rango — esa es toda la\n * garantía del formato: un hunk calculado sobre una versión vieja del\n * fichero nunca se aplica en silencio sobre líneas que ya cambiaron.\n */\nexport function aplicarHunk(contenidoActual: string, hunk: HunkHashline): ResultadoAplicar {\n\tconst lineas = contenidoActual.split(\"\\n\");\n\tif (hunk.hasta > lineas.length) {\n\t\treturn {\n\t\t\tok: false,\n\t\t\tmotivo: `el rango ${hunk.desde}-${hunk.hasta} cae fuera del fichero (tiene ${lineas.length} líneas)`,\n\t\t};\n\t}\n\n\tconst tagActual = etiquetaDeRango(lineas, hunk.desde, hunk.hasta);\n\tif (tagActual !== hunk.tag) {\n\t\treturn {\n\t\t\tok: false,\n\t\t\tmotivo:\n\t\t\t\t`tag obsoleto: el hunk trae #${hunk.tag} para las líneas ${hunk.desde}-${hunk.hasta} pero ahora mismo ` +\n\t\t\t\t`esas líneas etiquetan #${tagActual} — el fichero cambió por debajo desde que se calculó este hunk`,\n\t\t};\n\t}\n\n\tconst resultado = [...lineas.slice(0, hunk.desde - 1), ...hunk.cuerpo, ...lineas.slice(hunk.hasta)].join(\"\\n\");\n\treturn { ok: true, contenido: resultado };\n}\n\n/** Atajo: parsea y aplica en un paso, contra el contenido actual del fichero que nombra el hunk. */\nexport function aplicarHashline(contenidoActual: string, textoHunk: string): ResultadoAplicar {\n\tconst parseado = parsearHunk(textoHunk);\n\tif (\"error\" in parseado) return { ok: false, motivo: parseado.error };\n\treturn aplicarHunk(contenidoActual, parseado.hunk);\n}\n"]}

package/dist/core/edicion/hashline.js

@@ -0,0 +1,111 @@
+/**
+ * Hashline — formato de edición anclado por hash de línea.
+ *
+ * Nuestro único formato de edición hoy (`edit`, en `core/tools/edit.ts`) casa
+ * `oldText` contra el contenido actual del fichero: si el texto no está
+ * literal, la edición falla con un error de "no encontrado". No hay forma de
+ * decir "quiero cambiar las líneas 10-12 tal como las vi", así que un hunk
+ * calculado sobre una versión del fichero que ya cambió por debajo (otro
+ * proceso, otra pestaña del agente, el usuario a mano) se puede colar sobre
+ * líneas que ya no son las que el hunk cree que son, con la única defensa de
+ * que `oldText` deje de encontrarse — y si el nuevo contenido de esas líneas
+ * es distinto pero de la misma LONGITUD y forma que el viejo `oldText`
+ * (variable renombrada, número cambiado), ni eso lo detiene.
+ *
+ * Hashline cierra ese hueco por construcción: el hunk lleva un hash del
+ * contenido exacto del rango que dice tocar, calculado sobre lo que el
+ * llamante VIO. `aplicarHashline` recalcula ese mismo hash sobre el fichero
+ * tal como está AHORA y rechaza el hunk si no coincide — sin tocar el
+ * fichero — en vez de intentar adivinar dónde se movió el texto. La idea es
+ * la de `@oh-my-pi/hashline` (paquete de referencia en
+ * `/Users/31017423z/auditoria-omp/oh-my-pi/packages/hashline`): anclar cada
+ * hunk a un hash de contenido y rechazar el que ya no cuadra. Lo que cambia
+ * aquí es el alcance: ellos anclan el FICHERO ENTERO con una gramática de
+ * varias operaciones (PUT/CUT/MV…) pensada para sustituir su tool de edición
+ * completa; esto ancla cada RANGO de líneas por separado, como una quinta
+ * opción de formato de edición, no un reemplazo del `edit` que ya existe.
+ */
+import { createHash } from "node:crypto";
+/** Etiqueta de 8 hex del contenido exacto de las líneas `desde..hasta` (1-indexado, inclusive). */
+export function etiquetaDeRango(lineas, desde, hasta) {
+    const texto = lineas.slice(desde - 1, hasta).join("\n");
+    return createHash("sha256").update(texto).digest("hex").slice(0, 8);
+}
+/** Construye la cabecera `[ruta#tag]` para el rango `desde..hasta` del contenido actual. */
+export function construirCabecera(ruta, contenido, desde, hasta) {
+    return `[${ruta}#${etiquetaDeRango(contenido.split("\n"), desde, hasta)}]`;
+}
+const RE_CABECERA = /^\[(.+)#([0-9a-f]{8})\]\s*$/;
+const RE_RANGO = /^(\d+)(?:-(\d+))?\s*$/;
+/**
+ * Parsea un hunk hashline de tres partes: cabecera `[ruta#tag]`, línea de
+ * rango `A` o `A-B`, y cuerpo con cada línea de sustitución prefijada por
+ * `+` (una línea `+` sola es una línea en blanco).
+ */
+export function parsearHunk(texto) {
+    const lineas = texto.replace(/\r\n/g, "\n").split("\n");
+    // Ignora líneas en blanco iniciales/finales: son ruido de quien compone el
+    // hunk a mano, no parte del formato.
+    while (lineas.length > 0 && lineas[0].trim() === "")
+        lineas.shift();
+    while (lineas.length > 0 && lineas.at(-1)?.trim() === "")
+        lineas.pop();
+    if (lineas.length < 2)
+        return { error: "hunk vacío: hace falta cabecera y línea de rango" };
+    const cabecera = lineas[0].match(RE_CABECERA);
+    if (!cabecera)
+        return { error: `cabecera inválida: "${lineas[0]}" (se esperaba "[ruta#8hex]")` };
+    const rango = lineas[1].match(RE_RANGO);
+    if (!rango)
+        return { error: `rango inválido: "${lineas[1]}" (se esperaba "A" o "A-B")` };
+    const desde = Number(rango[1]);
+    const hasta = rango[2] !== undefined ? Number(rango[2]) : desde;
+    if (desde < 1 || hasta < desde)
+        return { error: `rango sin sentido: ${desde}-${hasta}` };
+    const cuerpo = [];
+    for (let i = 2; i < lineas.length; i++) {
+        const linea = lineas[i];
+        if (linea === "+") {
+            cuerpo.push("");
+            continue;
+        }
+        if (!linea.startsWith("+")) {
+            return { error: `línea de cuerpo sin "+": "${linea}"` };
+        }
+        cuerpo.push(linea.slice(1));
+    }
+    return { hunk: { ruta: cabecera[1], tag: cabecera[2], desde, hasta, cuerpo } };
+}
+/**
+ * Aplica un hunk ya parseado sobre `contenidoActual`. Rechaza sin tocar nada
+ * si el tag no coincide con lo que hay AHORA en ese rango — esa es toda la
+ * garantía del formato: un hunk calculado sobre una versión vieja del
+ * fichero nunca se aplica en silencio sobre líneas que ya cambiaron.
+ */
+export function aplicarHunk(contenidoActual, hunk) {
+    const lineas = contenidoActual.split("\n");
+    if (hunk.hasta > lineas.length) {
+        return {
+            ok: false,
+            motivo: `el rango ${hunk.desde}-${hunk.hasta} cae fuera del fichero (tiene ${lineas.length} líneas)`,
+        };
+    }
+    const tagActual = etiquetaDeRango(lineas, hunk.desde, hunk.hasta);
+    if (tagActual !== hunk.tag) {
+        return {
+            ok: false,
+            motivo: `tag obsoleto: el hunk trae #${hunk.tag} para las líneas ${hunk.desde}-${hunk.hasta} pero ahora mismo ` +
+                `esas líneas etiquetan #${tagActual} — el fichero cambió por debajo desde que se calculó este hunk`,
+        };
+    }
+    const resultado = [...lineas.slice(0, hunk.desde - 1), ...hunk.cuerpo, ...lineas.slice(hunk.hasta)].join("\n");
+    return { ok: true, contenido: resultado };
+}
+/** Atajo: parsea y aplica en un paso, contra el contenido actual del fichero que nombra el hunk. */
+export function aplicarHashline(contenidoActual, textoHunk) {
+    const parseado = parsearHunk(textoHunk);
+    if ("error" in parseado)
+        return { ok: false, motivo: parseado.error };
+    return aplicarHunk(contenidoActual, parseado.hunk);
+}
+//# sourceMappingURL=hashline.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hashline.js","sourceRoot":"","sources":["../../../src/core/edicion/hashline.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Hashline — formato de edición anclado por hash de línea.\n *\n * Nuestro único formato de edición hoy (`edit`, en `core/tools/edit.ts`) casa\n * `oldText` contra el contenido actual del fichero: si el texto no está\n * literal, la edición falla con un error de \"no encontrado\". No hay forma de\n * decir \"quiero cambiar las líneas 10-12 tal como las vi\", así que un hunk\n * calculado sobre una versión del fichero que ya cambió por debajo (otro\n * proceso, otra pestaña del agente, el usuario a mano) se puede colar sobre\n * líneas que ya no son las que el hunk cree que son, con la única defensa de\n * que `oldText` deje de encontrarse — y si el nuevo contenido de esas líneas\n * es distinto pero de la misma LONGITUD y forma que el viejo `oldText`\n * (variable renombrada, número cambiado), ni eso lo detiene.\n *\n * Hashline cierra ese hueco por construcción: el hunk lleva un hash del\n * contenido exacto del rango que dice tocar, calculado sobre lo que el\n * llamante VIO. `aplicarHashline` recalcula ese mismo hash sobre el fichero\n * tal como está AHORA y rechaza el hunk si no coincide — sin tocar el\n * fichero — en vez de intentar adivinar dónde se movió el texto. La idea es\n * la de `@oh-my-pi/hashline` (paquete de referencia en\n * `/Users/31017423z/auditoria-omp/oh-my-pi/packages/hashline`): anclar cada\n * hunk a un hash de contenido y rechazar el que ya no cuadra. Lo que cambia\n * aquí es el alcance: ellos anclan el FICHERO ENTERO con una gramática de\n * varias operaciones (PUT/CUT/MV…) pensada para sustituir su tool de edición\n * completa; esto ancla cada RANGO de líneas por separado, como una quinta\n * opción de formato de edición, no un reemplazo del `edit` que ya existe.\n */\n\nimport { createHash } from \"node:crypto\";\n\n/** Etiqueta de 8 hex del contenido exacto de las líneas `desde..hasta` (1-indexado, inclusive). */\nexport function etiquetaDeRango(lineas: readonly string[], desde: number, hasta: number): string {\n\tconst texto = lineas.slice(desde - 1, hasta).join(\"\\n\");\n\treturn createHash(\"sha256\").update(texto).digest(\"hex\").slice(0, 8);\n}\n\n/** Construye la cabecera `[ruta#tag]` para el rango `desde..hasta` del contenido actual. */\nexport function construirCabecera(ruta: string, contenido: string, desde: number, hasta: number): string {\n\treturn `[${ruta}#${etiquetaDeRango(contenido.split(\"\\n\"), desde, hasta)}]`;\n}\n\nexport interface HunkHashline {\n\truta: string;\n\ttag: string;\n\t/** 1-indexado, inclusive. */\n\tdesde: number;\n\thasta: number;\n\t/** Líneas de sustitución, ya sin el `+` de cabecera. */\n\tcuerpo: string[];\n}\n\n/** `{hunk}` si parseó, `{error}` si no — dos formas distintas, nunca un `null` que mezcle los dos motivos. */\nexport type ResultadoParseo = { hunk: HunkHashline } | { error: string };\n\nconst RE_CABECERA = /^\\[(.+)#([0-9a-f]{8})\\]\\s*$/;\nconst RE_RANGO = /^(\\d+)(?:-(\\d+))?\\s*$/;\n\n/**\n * Parsea un hunk hashline de tres partes: cabecera `[ruta#tag]`, línea de\n * rango `A` o `A-B`, y cuerpo con cada línea de sustitución prefijada por\n * `+` (una línea `+` sola es una línea en blanco).\n */\nexport function parsearHunk(texto: string): ResultadoParseo {\n\tconst lineas = texto.replace(/\\r\\n/g, \"\\n\").split(\"\\n\");\n\t// Ignora líneas en blanco iniciales/finales: son ruido de quien compone el\n\t// hunk a mano, no parte del formato.\n\twhile (lineas.length > 0 && lineas[0].trim() === \"\") lineas.shift();\n\twhile (lineas.length > 0 && lineas.at(-1)?.trim() === \"\") lineas.pop();\n\n\tif (lineas.length < 2) return { error: \"hunk vacío: hace falta cabecera y línea de rango\" };\n\n\tconst cabecera = lineas[0].match(RE_CABECERA);\n\tif (!cabecera) return { error: `cabecera inválida: \"${lineas[0]}\" (se esperaba \"[ruta#8hex]\")` };\n\n\tconst rango = lineas[1].match(RE_RANGO);\n\tif (!rango) return { error: `rango inválido: \"${lineas[1]}\" (se esperaba \"A\" o \"A-B\")` };\n\tconst desde = Number(rango[1]);\n\tconst hasta = rango[2] !== undefined ? Number(rango[2]) : desde;\n\tif (desde < 1 || hasta < desde) return { error: `rango sin sentido: ${desde}-${hasta}` };\n\n\tconst cuerpo: string[] = [];\n\tfor (let i = 2; i < lineas.length; i++) {\n\t\tconst linea = lineas[i];\n\t\tif (linea === \"+\") {\n\t\t\tcuerpo.push(\"\");\n\t\t\tcontinue;\n\t\t}\n\t\tif (!linea.startsWith(\"+\")) {\n\t\t\treturn { error: `línea de cuerpo sin \"+\": \"${linea}\"` };\n\t\t}\n\t\tcuerpo.push(linea.slice(1));\n\t}\n\n\treturn { hunk: { ruta: cabecera[1], tag: cabecera[2], desde, hasta, cuerpo } };\n}\n\nexport type ResultadoAplicar =\n\t| { ok: true; contenido: string }\n\t/** El hunk parseó pero su tag no corresponde a las líneas actuales, o el rango cae fuera del fichero: nada se toca. */\n\t| { ok: false; motivo: string };\n\n/**\n * Aplica un hunk ya parseado sobre `contenidoActual`. Rechaza sin tocar nada\n * si el tag no coincide con lo que hay AHORA en ese rango — esa es toda la\n * garantía del formato: un hunk calculado sobre una versión vieja del\n * fichero nunca se aplica en silencio sobre líneas que ya cambiaron.\n */\nexport function aplicarHunk(contenidoActual: string, hunk: HunkHashline): ResultadoAplicar {\n\tconst lineas = contenidoActual.split(\"\\n\");\n\tif (hunk.hasta > lineas.length) {\n\t\treturn {\n\t\t\tok: false,\n\t\t\tmotivo: `el rango ${hunk.desde}-${hunk.hasta} cae fuera del fichero (tiene ${lineas.length} líneas)`,\n\t\t};\n\t}\n\n\tconst tagActual = etiquetaDeRango(lineas, hunk.desde, hunk.hasta);\n\tif (tagActual !== hunk.tag) {\n\t\treturn {\n\t\t\tok: false,\n\t\t\tmotivo:\n\t\t\t\t`tag obsoleto: el hunk trae #${hunk.tag} para las líneas ${hunk.desde}-${hunk.hasta} pero ahora mismo ` +\n\t\t\t\t`esas líneas etiquetan #${tagActual} — el fichero cambió por debajo desde que se calculó este hunk`,\n\t\t};\n\t}\n\n\tconst resultado = [...lineas.slice(0, hunk.desde - 1), ...hunk.cuerpo, ...lineas.slice(hunk.hasta)].join(\"\\n\");\n\treturn { ok: true, contenido: resultado };\n}\n\n/** Atajo: parsea y aplica en un paso, contra el contenido actual del fichero que nombra el hunk. */\nexport function aplicarHashline(contenidoActual: string, textoHunk: string): ResultadoAplicar {\n\tconst parseado = parsearHunk(textoHunk);\n\tif (\"error\" in parseado) return { ok: false, motivo: parseado.error };\n\treturn aplicarHunk(contenidoActual, parseado.hunk);\n}\n"]}

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

@@ -0,0 +1,64 @@
+/**
+ * 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 { type CasadoPorSangria } from "./sangria.ts";
+/**
+ * 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 declare function casarHuecoElidido(contenido: string, oldText: string, newText: string): CasadoPorSangria | null;
+//# sourceMappingURL=hueco.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hueco.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/hueco.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,OAAO,EAAE,KAAK,gBAAgB,EAAmC,MAAM,cAAc,CAAC;AAiBtF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAiF9G","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"]}