xonecode 0.38.41 → 0.39.2

package/dist/agent/subagentes/actividadDeCodex.d.ts

@@ -0,0 +1,8 @@
+/** Lo que sale de un `item/completed` de Codex: las tools que hizo y lo que contó. */
+export declare function actividadDeItemDeCodex(item: unknown, cwd: string, real?: (ruta: string) => string): {
+    tools: {
+        nombre: string;
+        detalle?: string;
+    }[];
+    razonamiento?: string;
+};

package/dist/agent/subagentes/agentesEnDisco.d.ts

@@ -0,0 +1,198 @@
+/**
+ * Los subagentes en disco: `<base>/.xonecode/agentes/<nombre>.md`, uno por fichero.
+ *
+ * Ficheros y no una entrada en `config.json` por tres razones. El cuerpo son
+ * INSTRUCCIONES, o sea prosa larga, y la prosa dentro de un JSON se vuelve inmanejable en
+ * cuanto pasa de dos frases. Es la convención que ya conoce quien viene de Claude Code
+ * (`.claude/agents/*.md`), así que el fichero se lee sin explicar nada. Y se edita a mano y
+ * se diffea, que es lo que va a pasar de verdad con un prompt que se afina.
+ *
+ * `.xonecode/` hereda además dos protecciones que aquí importan: está denegada entera al
+ * agente (`permisosDe`) y **no sube nunca** a CloudStudio. Un subagente es configuración de
+ * la herramienta, no del proyecto XOne — no tiene por qué acabar en Studio.
+ *
+ * Dos sitios, con la misma precedencia que los modelos: el GLOBAL (`~/.xonecode/agentes/`)
+ * y el del PROYECTO, y el de proyecto gana. Un «revisor de XOne» se quiere en todos los
+ * proyectos; un «experto en esta app», solo en uno.
+ */
+import { type Agente, type AgenteCargado, type Carga, type Lectura } from "../../core/agentes.js";
+/** La carpeta de agentes de una raíz cualquiera. */
+export declare function rutaDeAgentes(base: string): string;
+/** La global. `homedir()` en el momento de la llamada, como el resto del repo: cachearla en
+ *  una constante de módulo la congelaría para los tests que la cambian. */
+export declare function rutaGlobalDeAgentes(): string;
+/**
+ * Lee una carpeta. Un fichero que no se puede leer o que no valida NO tumba la carga: se
+ * salta, se apunta el motivo y los demás siguen — es la misma postura que `reabrirSesion`
+ * con una línea corrupta del `.jsonl`, y la que evita que un `.md` a medio escribir deje la
+ * consola sin ningún subagente.
+ */
+export declare function leerCarpetaDeAgentes(carpeta: string, origen: Agente["origen"]): Lectura;
+/**
+ * Los agentes en vigor para un proyecto: los globales, pisados por los del proyecto.
+ *
+ * `raizDelProyecto` es opcional porque el vestíbulo existe ANTES de que haya proyecto
+ * abierto (`web/servidor/vestibulo.ts`) y la ventana de ajustes se abre desde ahí: sin
+ * raíz se contestan los globales, que es la verdad, en vez de una lista vacía.
+ */
+export declare function cargarAgentes(raizDelProyecto?: string): Carga;
+/** ¿Es uno de los que trae xonecode? La guarda del `borrar`, y la lista de la pantalla. */
+export declare function esDeSerie(nombre: string): boolean;
+/**
+ * De quién es cada `.md`: ausente si lo escribió el usuario, `intacta`/`modificada` si es
+ * uno de los nuestros. Ver `AgenteCargado` para los tres estados y qué se hace con cada uno.
+ *
+ * Pura y exportada a propósito, no compuesta dentro de `cargarAgentes`: es el patrón de
+ * fallo de esta arquitectura —una regla que vive en un cierre que todos los tests doblan—, y
+ * la trampa de abajo es justo la que se queda sin probar así.
+ *
+ * **La regla es «de serie Y del GLOBAL», y el segundo requisito no es decorativo.** La
+ * siembra solo toca el global, así que un `docs.md` en `.xonecode/agentes/` DEL PROYECTO lo
+ * escribió el usuario aunque se llame igual que uno nuestro. Con `nombre ∈ AGENTES_DE_SERIE`
+ * a secas se quedaría sin botón de borrar —un fichero suyo que no puede borrar— y con un
+ * «Restaurar el de serie» que le pisaría el suyo con el global.
+ */
+export declare function marcarSemilla<T extends Agente>(agentes: readonly T[], desactualizados: readonly string[]): (T & AgenteCargado)[];
+/**
+ * Escribe un agente.
+ *
+ * `segmentoSeguro` por lo mismo que en `sesiones.ts`: el nombre llega del cliente por HTTP,
+ * y un `../../.env` compondría una ruta fuera de la carpeta. Misma función que usa
+ * `rutaDeWorkspace`, no una copia — dos guardas es cómo una se corrige y la otra no. LANZA
+ * en vez de limpiar, y está bien: limpiar el nombre hasta hacerlo válido guardaría el
+ * agente con uno que nadie pidió, y quien lo mandó creería que se llama de otra forma.
+ *
+ * La validación va ANTES del `mkdirSync`, y no es cosmético: al revés, un nombre rechazado
+ * dejaba la carpeta creada de todas formas — y la carpeta es justo la marca de «ya se
+ * sembró» (`sembrarAgentes`), así que un intento fallido en el global habría impedido para
+ * siempre que se sembraran los cuatro de serie.
+ */
+export declare function guardarAgente(base: string, agente: Agente): void;
+/**
+ * Devuelve un agente de serie a como lo entregamos, pisando lo que el usuario tuviera.
+ *
+ * Es lo que ocupa el sitio del borrado en un agente sembrado, y existe porque el borrado
+ * NO hacía lo que la consola prometía: la marca recuerda que se entregó, así que
+ * `sembrarAgentes` no lo resiembra (ver «uno BORRADO no se resucita») — o sea que el
+ * «bórralo si quieres el nuevo» dejaba sin ninguno de los dos y para siempre.
+ *
+ * **No escribe la marca, y es deliberado.** La reanota la siembra siguiente, que corre ANTES
+ * de cualquier lectura —`cargarAgentes` la llama primero— y que ya sabe reconocer su propio
+ * hash. Escribirla aquí sería un segundo sitio donde decidir sobre la marca, y el único que
+ * podría resucitar un agente que el usuario borró a propósito: con una marca ilegible, este
+ * camino la reescribiría con una sola clave y las demás pasarían por «nunca entregadas».
+ *
+ * Devuelve si pudo, como `borrarAgente`: de algo que no es de serie no hay versión nuestra
+ * que poner, y la interfaz no puede decir «restaurado» de eso.
+ */
+export declare function restaurarAgente(base: string, nombre: string): boolean;
+/** Los tres desenlaces de un renombrado. Tres situaciones distintas, tres valores. */
+export type Renombrado = "hecho" | "sin-origen" | "destino-ocupado";
+/**
+ * Renombra un subagente, escribiendo a la vez lo que se haya cambiado de él.
+ *
+ * **`renameSync` y LUEGO escribir**, nunca escribir y luego borrar: un fallo entre los dos
+ * pasos deja UN fichero —el renombrado, con el contenido de antes—, nunca dos con el mismo
+ * prompt ni cero. Al revés, una excepción entre el `write` y el `rm` deja los DOS, que es
+ * justo lo que el campo deshabilitado del formulario evitaba: dos subagentes con la misma
+ * descripción y ninguna forma de saber a cuál delega el orquestador.
+ *
+ * Las dos cosas en el mismo paso porque el formulario permite cambiar el nombre Y el resto en
+ * la misma pulsación; guardar solo una dejaría la pantalla mintiendo.
+ *
+ * **El destino ocupado es un NO**, sea de serie o del usuario: sin esta guarda, renombrar
+ * `advisor` a `docs` se llevaba por delante el `docs.md` sembrado —o el otro subagente— sin
+ * decir nada. Un caso especial para los de serie diría un motivo menos cierto.
+ *
+ * **Pero «existe» no es «es otro fichero», y eso está MEDIDO en una máquina de verdad.** APFS
+ * es insensible a mayúsculas, así que con un `Documentador.md` en disco el `existsSync` de
+ * `documentador.md` contesta SÍ —es el mismo fichero— y esta guarda rechazaba justo el arreglo
+ * que el aviso del cargador propone, que es el renombrado más común de todos. Se compara por
+ * INODO (`dev` + `ino`): si el destino ES el origen, no hay nada ocupado. En un sistema
+ * sensible a mayúsculas son dos ficheros con dos inodos, así que la comparación sigue diciendo
+ * la verdad ahí — y si el otro existe de verdad, se sigue rechazando.
+ *
+ * Que un de serie NO se pueda renombrar no se decide aquí: esto mueve un fichero, y la regla
+ * del producto vive donde ya vive la de que no se borra (`arranque.ts#atenderAgente`). Dos
+ * sitios donde decidir lo mismo es cómo uno de los dos se queda sin la regla.
+ */
+export declare function renombrarAgente(base: string, viejo: string, agente: Agente): Renombrado;
+/** Borra uno. Devuelve si existía: la interfaz no puede decir «borrado» de algo que no estaba. */
+export declare function borrarAgente(base: string, nombre: string): boolean;
+/** El nombre de la marca. Empieza por punto y no acaba en `.md`: el cargador la ignora. */
+export declare const FICHERO_DE_SEMILLA = ".semilla.json";
+export interface Siembra {
+    /** Los que se han escrito ahora: nuevos, o actualizados porque nadie los había tocado. */
+    escritos: string[];
+    /**
+     * Los que se quedan atrás: existen, no coinciden con lo que sembramos, y la versión de
+     * serie ha cambiado. No se pisan —puede ser trabajo del usuario— pero se DICEN: callarlo
+     * es lo que dejaba a un `docs.md` sin la consulta acotada durante semanas.
+     */
+    desactualizados: string[];
+    /**
+     * Los que se RETIRARON por un renombrado. Es el quinto caso, y el único que no puede salir
+     * del bucle de serie: habla de una clave de la marca que ya no nombra a ningún agente.
+     */
+    retirados: Retirado[];
+}
+/**
+ * Un agente de serie que cambió de nombre.
+ *
+ * Los dos desenlaces no se cuentan igual, y por eso viaja cuál fue: al nuestro intacto se le
+ * retira el fichero —y hay que decirlo, o el especialista desaparece de la lista sin que nada
+ * lo explique—, mientras que al que el usuario afinó se le deja donde está.
+ */
+export interface Retirado {
+    /** El nombre que ya no es de serie. */
+    nombre: string;
+    /** El que tiene ahora. */
+    ahoraSeLlama: string;
+    /** Cierto si era nuestra semilla intacta y se ha borrado del disco. */
+    borrado: boolean;
+}
+/**
+ * Siembra los agentes de serie, y ACTUALIZA los que nadie ha tocado.
+ *
+ * La regla anterior era «la carpeta es la marca»: si existía, no se escribía nada nunca más.
+ * Respetaba el prompt afinado por el usuario —que es lo que había que respetar— pero eligió
+ * un cuerno del dilema y el otro acabó mordiendo: **ningún agente nuevo, y ninguna
+ * corrección a uno existente, alcanzaba a quien ya hubiera arrancado una vez**. Medido: el
+ * `docs.md` de un usuario llevaba semanas sin la consulta acotada, y el probador de
+ * dispositivos no le habría llegado jamás.
+ *
+ * Ahora la marca es un fichero, `.semilla.json`, con el HASH DE LO QUE ESCRIBIMOS NOSOTROS
+ * para cada agente. Con eso se distinguen los cuatro casos que antes eran uno solo:
+ *
+ * | en disco | en la marca | qué se hace |
+ * |---|---|---|
+ * | no está | no está | es un agente NUEVO: se escribe |
+ * | no está | está | lo BORRÓ el usuario: no se resucita |
+ * | está, y su hash es el nuestro | está | nadie lo tocó: se actualiza |
+ * | está, y su hash NO es el nuestro | cualquiera | es suyo: se deja, y se DICE |
+ *
+ * Y un quinto, que aparece el día que un agente se RENOMBRA y que no puede salir de ese bucle
+ * porque habla de una clave que ya no nombra a ninguno: ver `RENOMBRADOS` y `Retirado`.
+ *
+ * **Y una carpeta sin marca se ADOPTA, no se siembra.** Es la de quien ya venía de la regla
+ * vieja, y ahí no se puede saber qué borró a propósito: dar por nuevo lo que falta le
+ * resucitaría un agente que eliminó. Así que se anota lo que hay —como nuestro si coincide
+ * con la versión de serie de hoy, como `ajeno` si no— y no se escribe ningún `.md` esa vez.
+ * Desde la siguiente, todo lo de arriba funciona. El coste es una ronda de retraso para las
+ * instalaciones viejas; la alternativa es pisar o resucitar sin permiso.
+ *
+ * El fichero de marca empieza por punto y no acaba en `.md`, así que `leerCarpetaDeAgentes`
+ * ni lo mira — no hace falta excluirlo a mano en dos sitios.
+ */
+/** Dónde se guarda la copia de un agente de serie editado antes de actualizarlo: `.anteriores/<nombre>.<fecha>.md`. */
+export declare const CARPETA_DE_ANTERIORES = ".anteriores";
+export declare function sembrarAgentes(base?: string): Siembra;
+/**
+ * Los cinco. Nacieron como una mudanza de los textos que había en código; desde entonces
+ * `docs` lleva además la consulta acotada, y el que conduce aparatos llegó con la documentación
+ * del protocolo hotswap y pasó por dos nombres más antes de `device-controller` (ver
+ * `RENOMBRADOS`). Cada regla que
+ * se añade aquí se mide antes con los evals, porque un prompt más largo es coste en TODAS las
+ * llamadas.
+ */
+export declare const AGENTES_DE_SERIE: readonly Agente[];

package/dist/agent/subagentes/consumoExterno.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Qué ha consumido un agente EXTERNO, leído de lo que él mismo reporta.
+ *
+ * Los tres motores lo dicen, y las tres formas están MEDIDAS contra sus contratos reales y no
+ * deducidas:
+ * - **Claude Code**: el mensaje `result` trae `modelUsage`, un mapa por modelo. Su propia
+ *   documentación dice que es «the correct field for token/cost accounting», por encima de
+ *   `usage` — que es solo del bucle principal y se deja fuera los subagentes del hijo.
+ * - **Codex**: manda `thread/tokenUsage/updated` con `tokenUsage.total`. Estaba en la lista
+ *   de RUIDO de `subagenteCodex.ts`, o sea que el dato llevaba llegando desde el principio y
+ *   se tiraba.
+ *
+ * - **OpenCode**: el resultado de `session/prompt` de ACP trae `usage` con `inputTokens`,
+ *   `outputTokens`, `totalTokens` y `cachedReadTokens`. Llega UNA vez, al final del turno.
+ *
+ * **Los dos primeros son ACUMULADOS, así que se lee el último y no se suman.** Lo dicen los dos
+ * contratos con esas palabras («each result carries the running total so far, so read the
+ * latest result rather than summing») y es la diferencia entre contar bien y contar el doble.
+ * Entre ejecuciones distintas sí se suma: cada `correr` es otra sesión del producto.
+ */
+import type { ConsumoDeSesion, ConsumoExterno } from "../../core/ports.js";
+/**
+ * Lo que consumió un `query()` de Claude Code, sumando TODOS sus modelos.
+ *
+ * Se suma por modelo porque un hijo puede usar más de uno en la misma ejecución (su
+ * compactación y sus propios subagentes corren en otro), y aquí la pregunta es cuánto ha
+ * costado el especialista entero, no cada pieza.
+ *
+ * La CACHÉ va aparte de la entrada, igual que en `vendor/tokenTracking.ts`: son tokens que
+ * se leyeron pero no se pagaron igual, y meterlos en «entrada» inflaría la cifra que se
+ * enseña. Que existan los dos campos es lo que permite decir la verdad sin elegir cuál.
+ */
+export declare function consumoDeClaude(resultado: unknown): {
+    entrada: number;
+    salida: number;
+    cache: number;
+    /** El mismo gasto, por el id de modelo que Claude Code da como clave de `modelUsage`. */
+    porModelo: Record<string, {
+        entrada: number;
+        salida: number;
+        cache: number;
+    }>;
+};
+/**
+ * Lo que lleva consumido un hilo de Codex, de su `thread/tokenUsage/updated`.
+ *
+ * Se lee `total` y no `last`: `last` es el de la última llamada —lo que ocupa la ventana—, y
+ * aquí la pregunta es cuánto lleva el hilo. Son las dos preguntas que
+ * `vendor/tokenTracking.ts` ya separa con `contexto` y los acumulados.
+ *
+ * `reasoningOutputTokens` NO se suma a la salida: por el esquema del propio binario va
+ * dentro de `outputTokens`, así que sumarlo sería contarlo dos veces.
+ */
+export declare function consumoDeCodex(params: unknown): {
+    entrada: number;
+    salida: number;
+    cache: number;
+} | undefined;
+/** Suma de consumos, para acumular entre ejecuciones. */
+export declare function sumarConsumo(a: ConsumoDeSesion, b: {
+    entrada: number;
+    salida: number;
+    cache: number;
+}): ConsumoDeSesion;
+export declare const SIN_CONSUMO: ConsumoDeSesion;
+export type { ConsumoDeSesion, ConsumoExterno };
+/**
+ * Lo que consumió un turno de OpenCode, del `usage` que devuelve `session/prompt`.
+ *
+ * **La caché NO está dentro de la entrada, y eso se comprobó con la aritmética de una medida
+ * real**: `inputTokens: 8756`, `outputTokens: 141`, `cachedReadTokens: 1792` y
+ * `totalTokens: 10689` — y 8756 + 141 + 1792 = 10689. O sea que `inputTokens` excluye la
+ * caché, así que se copia tal cual en vez de restarla. Si estuvieran sumados, enseñar
+ * `inputTokens` como entrada inflaría la cifra.
+ *
+ * Ausente devuelve `undefined` y no un cero: un contador a cero que nadie ha medido es la
+ * cifra inventada de siempre, y quien llama ya sabe no pintar lo que no consta.
+ */
+export declare function consumoDeOpencode(uso: unknown): {
+    entrada: number;
+    salida: number;
+    cache: number;
+} | undefined;

package/dist/agent/subagentes/ejecutableEnWindows.d.ts

@@ -0,0 +1,53 @@
+/**
+ * El ejecutable de VERDAD de un motor externo en Windows.
+ *
+ * npm instala `opencode` y `codex` como un `.cmd`, y `spawn("opencode")` sin shell busca solo
+ * `opencode.exe` en el PATH: `ENOENT`. La medida de Ajustes pasaba por la shell y daba «Listo»;
+ * lanzarlo fallaba. Medido sobre opencode 1.18.34 y sobre el `@openai/codex` de npm.
+ *
+ * No se arregla con `shell: true` ni con `cmd.exe /c`: Parar mata al hijo (`PeticionExterna.senal`),
+ * y el hijo sería `cmd.exe` —el motor nieto sobreviviría—. Se lee el shim y se lanza el NATIVO:
+ *
+ * - **OpenCode**: el shim apunta a un `.exe` (`"%dp0%\node_modules\opencode-ai\bin\opencode.exe"`),
+ *   y se lanza ese.
+ * - **Codex**: el shim apunta a un script de Node (`…\@openai\codex\bin\codex.js`) que a su vez
+ *   lanza el `codex.exe` de su paquete de plataforma. Tampoco se lanza `node codex.js`: en Windows
+ *   matar a `node` no le reenvía nada al nieto. Se busca el `codex.exe` con la MISMA regla que el
+ *   script (`@openai/codex-win32-<arch>/vendor/<triple>/bin/codex.exe`), igual que con el binario
+ *   del SDK de Claude. Lo único que el script añade al entorno son `CODEX_MANAGED_*`, que solo
+ *   deciden cómo sugiere actualizarse.
+ *
+ * Un shim de otro script de Node no se persigue: se devuelve `undefined` y quien llama se queda
+ * con el nombre a secas. Fuera del PATH × PATHEXT no se acepta nada: npm deja además un `opencode`
+ * SIN extensión, que es el shim de sh para Git Bash y no se puede lanzar.
+ */
+/** Lo que el resolvedor necesita de la máquina, para poder probarlo sin ella. */
+export interface MaquinaWindows {
+    readonly path: string | undefined;
+    readonly pathext: string | undefined;
+    readonly esFichero: (ruta: string) => boolean;
+    readonly leer: (ruta: string) => string;
+    /** `process.arch`: decide el paquete de plataforma de Codex. */
+    readonly arquitectura?: string;
+}
+/**
+ * Lo que lanza un shim `.cmd` de npm, RELATIVO a la carpeta del shim: un `.exe` o un `.js`. Es la
+ * ÚLTIMA ruta `"%dp0%\…"` del fichero: el de un script de Node nombra antes `"%dp0%\node.exe"`
+ * en el `IF EXIST` que busca un Node al lado, y ese no es el destino.
+ */
+export declare function destinoDeShimDeNpm(texto: string): string | undefined;
+/**
+ * El `codex.exe` que lanzaría `…\@openai\codex\bin\codex.js`. El script lo resuelve con
+ * `require.resolve("@openai/codex-win32-<arch>/package.json")` desde su paquete (anidado o
+ * subido al `node_modules` de al lado) y cae a `vendor/` dentro del propio paquete.
+ */
+export declare function nativoDeCodex(script: string, maquina: MaquinaWindows): string | undefined;
+/** La ruta del ejecutable que de verdad se lanza para `nombre`, o `undefined` si no hay uno. */
+export declare function resolverEnWindows(nombre: string, maquina: MaquinaWindows): string | undefined;
+/**
+ * El binario que se le pasa a `spawn`. Fuera de Windows, tal cual. En Windows, un nombre a secas o
+ * un `.cmd` se resuelven a su nativo; una ruta a un `.exe` (lo que alguien puso en `OPENCODE_BIN`
+ * o `CODEX_BIN`) se respeta. Lo que no se resuelve se devuelve como llegó: el `ENOENT` dirá lo que
+ * pasa.
+ */
+export declare function ejecutableParaLanzar(binario: string, maquina?: MaquinaWindows, plataforma?: NodeJS.Platform): string;

package/dist/agent/subagentes/escrituraDeCodex.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Qué puede escribir un agente externo con motor **codex**, y quién lo autoriza.
+ *
+ * Este fichero es el gemelo de `escrituraExterna.ts` para el otro motor, y existe por la
+ * misma razón: las rutas que Codex propone son **absolutas** y van al disco directas, así
+ * que ninguna de las cuatro capas que protegen al proyecto por el camino de LangGraph
+ * —`permisosDe`, el `virtualMode`, las vistas aplanadas y las guardas de artefactos y
+ * descargas— las ve. Lo que NO se hace aquí es volver a escribir esas guardas: se llama a
+ * `veredictoDeRuta`, la misma función, porque un segundo sitio donde decidir sobre una ruta
+ * sería un segundo sitio donde el fail-closed puede dejar de estarlo.
+ *
+ * Lo propio de Codex es solo la FORMA, y está medida contra el binario real (codex-cli
+ * 0.152.1, 11-09-2026, tres ejecuciones):
+ *
+ * - **La palanca es `approvalPolicy`, no `sandbox`.** Con `sandbox: "workspace-write"` las
+ *   escrituras dentro del cwd ocurren solas y no vuelven a xonecode — que es exactamente el
+ *   motivo por el que `core/agentes.ts` rechazaba un `.md` de codex que pidiera escribir.
+ *   Con `sandbox: "read-only"` + `approvalPolicy: "on-request"`, la denegación la sigue
+ *   poniendo la caja del sistema operativo y cada escritura llega como una PETICIÓN que
+ *   contestamos nosotros: el mismo papel que el `ask` del hook `PreToolUse` en Claude Code.
+ *   Medido: al contestar `accept` el fichero se escribe, y al contestar `decline` no queda
+ *   fichero, el item queda `declined` y el turno SIGUE (el agente lo cuenta en su respuesta).
+ *   Por eso el sandbox se queda en `read-only` SIEMPRE, también con la escritura concedida:
+ *   no existe ningún modo en el que Codex escriba sin pasar por aquí.
+ *
+ * - **La petición no dice sobre QUÉ se decide.** `item/fileChange/requestApproval` trae
+ *   `{threadId, turnId, itemId, startedAtMs, reason, grantRoot}` y nada más; los ficheros
+ *   vienen ANTES, en el `item/started` cuyo `item.id` es ese `itemId`. De ahí que el
+ *   adaptador lleve un registro de items: sin él no hay diff que enseñar, y sin diff no hay
+ *   decisión que tomar.
+ *
+ * - **`add` y `update` no traen lo mismo en `diff`**: en `add` es el CONTENIDO entero
+ *   (`"medido.\n"`), y en `update` un hunk unificado
+ *   (`"@@ -1,3 +1,3 @@\n uno\n-dos\n+DOS\n tres\n"`). Por eso `cambioDe()` no sirve aquí
+ *   —espera los argumentos de un `Write`/`Edit`— y hay una traducción propia a
+ *   `LineaDeDiff[]`, que es lo único que las tres pieles saben pintar.
+ */
+import type { LineaDeDiff } from "../../core/diff.js";
+import type { PoliticaDeEscrituraExterna } from "../../core/ports.js";
+import { type VeredictoDeEscrituras } from "./escrituraExterna.js";
+/** Un `FileUpdateChange` tal y como llega. Se tipa flojo a propósito: viene de fuera. */
+export interface CambioDeCodex {
+    path?: unknown;
+    kind?: {
+        type?: unknown;
+        move_path?: unknown;
+    } | undefined;
+    diff?: unknown;
+}
+/**
+ * El diff de un cambio, traducido a lo que pintan las pieles.
+ *
+ * Dos formas y no una, porque el binario manda dos (medido):
+ * - `add`: el contenido entero, sin cabeceras. Todo es línea AÑADIDA.
+ * - `update`: hunks unificados. Se tira la cabecera `@@ …@@` y la marca
+ *   ``, que no son contenido del fichero; el primer carácter de
+ *   lo demás dice el tipo.
+ *
+ * **Límite declarado**: con varios hunks, las líneas de uno y de otro salen seguidas, sin
+ * decir que en medio hay fichero que no cambia. Meter un separador exigiría inventar una
+ * línea que no está en el fichero, y `LineaDeDiff` no tiene forma de marcarla como tal.
+ */
+export declare function lineasDeCambioDeCodex(kind: string, diff: unknown): LineaDeDiff[];
+/**
+ * Los cambios de un item, traducidos a escrituras propuestas y comprobados contra las guardas.
+ *
+ * Lo propio de Codex es solo esto: reconocer el `kind` y componer las líneas. Las guardas de
+ * ruta y la política son `escrituraExterna.ts`, compartidas con el otro motor que escribe por
+ * petición.
+ *
+ * **`delete` y `move_path` se deniegan, y está declarado.** En Claude Code esa escritura no
+ * existe —no hay tool de borrar ni de renombrar, así que las listas ni la nombran—, `cambioDe`
+ * no sabe componer su diff, y un renombrado son DOS destinos que habría que guardar por
+ * separado. Es la paridad conservadora entre motores, y se afloja el día que se mida.
+ */
+export declare function veredictoDeCambiosDeCodex(opciones: {
+    cwd: string;
+    agente: string;
+    cambios: unknown;
+    ficheros: ReadonlySet<string>;
+    real?: (ruta: string) => string;
+}): VeredictoDeEscrituras;
+/** La decisión entera para Codex: traducir, y de ahí en adelante el camino compartido. */
+export declare function decisionDeEscrituraDeCodex(opciones: {
+    cwd: string;
+    agente: string;
+    cambios: unknown;
+    ficheros: ReadonlySet<string>;
+    real?: (ruta: string) => string;
+    aprobar?: PoliticaDeEscrituraExterna;
+}): Promise<{
+    concedida: boolean;
+    motivo?: string;
+}>;

package/dist/agent/subagentes/escrituraDeOpencode.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Qué puede escribir un agente externo con motor **opencode**, y quién lo autoriza.
+ *
+ * El tercer motor, y el que menos código propio necesita: su petición de permiso trae TODO en
+ * un solo mensaje. Medido contra el binario real (opencode 1.18.27, 11-09-2026):
+ *
+ *     session/request_permission {
+ *       toolCall: { toolCallId, title, kind: "edit", status, locations: [{path}],
+ *                   rawInput: {filepath, diff}, content: [{type:"diff", path, oldText, newText}] },
+ *       options: [ {optionId:"once"}, {optionId:"always"}, {optionId:"reject"} ] }
+ *
+ * De ahí salen las dos cosas que hacen falta y nada más: la RUTA (absoluta, como en los otros
+ * dos motores) y el ANTES y el DESPUÉS. **`oldText`/`newText` entran directos en
+ * `core/diff.ts#diffDeLineas`**, que es la misma función que compone el diff de una aprobación
+ * del grafo — así que aquí no hay ni registro de items (como en Codex, cuya petición solo trae
+ * un `itemId`) ni parser de hunks. Es la forma más sencilla de las tres.
+ *
+ * Las guardas de ruta y la política NO se reescriben: son `escrituraExterna.ts`, compartidas.
+ * Y se reaplican aunque la configuración de opencode ya deniegue por su cuenta: esa capa es
+ * NUESTRA configuración, pero quien la aplica es él. La guarda de xonecode es código.
+ */
+import type { PoliticaDeEscrituraExterna } from "../../core/ports.js";
+import { type EscrituraPropuesta, type VeredictoDeEscrituras } from "./escrituraExterna.js";
+/** El `toolCall` de una petición de permiso de ACP. Se tipa flojo: viene de fuera. */
+export interface ToolCallDeOpencode {
+    kind?: unknown;
+    locations?: unknown;
+    content?: unknown;
+}
+/**
+ * Las escrituras que propone un `toolCall`, o el motivo por el que no se puede decidir.
+ *
+ * **Solo `kind: "edit"`.** Lo que no sea una edición no tiene diff que componer, y decidir
+ * sobre una escritura sin poder enseñarla es justo lo que este camino existe para impedir —
+ * el mismo argumento por el que en Codex un `item/commandExecution/requestApproval` se deniega
+ * siempre. La configuración ya le quita `bash`, `webfetch` y `websearch`; esto es la segunda
+ * llave, por si esa capa fallara.
+ *
+ * Del `content` se leen los trozos `diff`, que es donde vienen el antes y el después. Si no
+ * hay ninguno se cae a `locations`, **y entonces se pregunta igual con el diff vacío**: decidir
+ * sin diff es peor que decidir con diff, pero escribir sin decisión es lo que esto evita.
+ */
+export declare function propuestasDeToolCall(toolCall: ToolCallDeOpencode | undefined): {
+    propuestas: EscrituraPropuesta[];
+} | {
+    motivo: string;
+};
+/** El veredicto de ruta de un `toolCall`, para poder probar la traducción aparte. */
+export declare function veredictoDeToolCall(opciones: {
+    cwd: string;
+    agente: string;
+    toolCall: ToolCallDeOpencode | undefined;
+    ficheros: ReadonlySet<string>;
+    real?: (ruta: string) => string;
+}): VeredictoDeEscrituras;
+/** La decisión entera: traducir, y de ahí en adelante el camino compartido con Codex. */
+export declare function decisionDeEscrituraDeOpencode(opciones: {
+    cwd: string;
+    agente: string;
+    toolCall: ToolCallDeOpencode | undefined;
+    ficheros: ReadonlySet<string>;
+    real?: (ruta: string) => string;
+    aprobar?: PoliticaDeEscrituraExterna;
+}): Promise<{
+    concedida: boolean;
+    motivo?: string;
+}>;