xonecode 0.38.44 → 0.39.2

package/dist/agent/config/modelosDeMotor.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Los alias de Claude Code, tal como los documenta su SDK instalado:
+ * «Model alias (e.g. 'fable', 'opus', 'sonnet', 'haiku') or full model ID».
+ *
+ * Alias y no ids pinchados: es lo que el producto ofrece justamente para que sobrevivan a
+ * sus versiones. Un `claude-opus-4-8` escrito aquí hoy se queda viejo solo, y el campo sigue
+ * aceptando un id entero para quien quiera fijar uno.
+ */
+export declare const ALIAS_DE_CLAUDE_CODE: readonly ["opus", "sonnet", "haiku", "fable"];
+/** Cómo se lee un modelo por el cable: lo justo para elegirlo. */
+export interface ModeloDeMotor {
+    id: string;
+    /** Para leer. Sin él se usa el id: un nombre inventado sería peor que ninguno. */
+    nombre: string;
+}
+/** Cuánto se espera a que Codex conteste su lista antes de darlo por no disponible. */
+export declare const TOPE_DE_MODELOS_MS = 15000;
+export interface DependenciasDeModelos {
+    /** Se le pregunta a Codex. Entra por parámetro: `npm test` no lanza procesos. */
+    preguntarACodex?: () => Promise<ModeloDeMotor[]>;
+    /** Y a OpenCode, por lo mismo. */
+    preguntarAOpencode?: () => Promise<ModeloDeMotor[]>;
+}
+export declare function modelosDeMotor(motor: string, deps?: DependenciasDeModelos): Promise<{
+    modelos: ModeloDeMotor[];
+    error?: string;
+}>;
+/**
+ * Lo que se guarda de la respuesta de `model/list`, y solo eso.
+ *
+ * Trae además esfuerzos de razonamiento, modalidades de entrada, tramos de servicio y avisos
+ * de crédito de la cuenta. Nada de eso hace falta para elegir un modelo, y arrastrarlo por
+ * el cable sería llevar datos de la cuenta de alguien sin ningún motivo — la misma regla con
+ * la que `proyectosDeResultado` se queda con dos campos y deja fuera el correo del
+ * propietario.
+ *
+ * Los que el propio Codex marca como `hidden` no se ofrecen: es él quien dice que no son
+ * para elegir.
+ */
+export declare function modelosDeRespuestaDeCodex(respuesta: unknown): ModeloDeMotor[];
+/**
+ * Los modelos de OpenCode: se los pregunta a él con `opencode models`.
+ *
+ * Una línea por modelo, con la forma `proveedor/id` — que es exactamente lo que su campo
+ * `model` de configuración espera, así que no hay que componer nada. Se le pregunta en vez de
+ * escribir una tabla por el mismo motivo que a Codex: su catálogo cambia con cada versión y
+ * con las credenciales que el usuario tenga, y una lista a mano produciría un modelo que el
+ * usuario elige y el hijo rechaza.
+ *
+ * No hace falta ni servidor ni sesión: es un comando que imprime y termina.
+ */
+export declare function modelosDeSalidaDeOpencode(salida: string): ModeloDeMotor[];

package/dist/agent/config/mudanzaEnDisco.d.ts

@@ -0,0 +1,99 @@
+/**
+ * La mudanza de una vez de las copias locales que siguen en el reparto VIEJO
+ * (`<base>/<entorno>/workspace/<proyecto>`) al de ahora (`<workspace>/<entorno>/<proyecto>`).
+ *
+ * **No es cosmética, y por eso se hace sola.** `dentroDelWorkspace` es lo que decide si el
+ * harness puede commitear al cerrar cada turno, y compara la raíz contra el workspace: con
+ * el reparto nuevo, una copia que se quedara en el sitio viejo dejaría de estar dentro y los
+ * commits por turno se pararían EN SILENCIO — que es exactamente el fallo mudo que este repo
+ * persigue en todas partes. Dejarlas donde están no era una opción; dejarlas y avisar,
+ * tampoco, porque el aviso saldría en cada arranque para siempre.
+ *
+ * La decisión de QUÉ se muda es pura y vive en `core/mudanzaDeWorkspace.ts`. Aquí solo está
+ * lo que toca disco: mover, reescribir los dos almacenes con raíces absolutas y CONTARLO.
+ */
+import { planDeCambioDeBase, type Mudanza } from "../../core/mudanzaDeWorkspace.js";
+export interface ResultadoDeMudanza {
+    mudadas: number;
+    chocadas: number;
+}
+export declare function mudarWorkspaceLegado(opciones: {
+    /** La casa donde viven `settings.json` y `tareas/indice.json`. Inyectable por los tests. */
+    casa?: string;
+    /** La base con el reparto viejo: `settings.workspace` si estaba puesto, o `~/.xonecode`. */
+    legado: string;
+    /** El workspace de ahora. */
+    workspace: string;
+    entornos: readonly string[];
+    /** Al TERMINAL y no al cable: por ahí viajan rutas de la máquina (`sinRutas`). */
+    escribir: (texto: string) => void;
+    /** Cómo se mueve una copia. Por omisión `renameSync`; entra por parámetro porque el fallo
+     *  que importa —EXDEV, un workspace en otro volumen— no se puede provocar en un temporal. */
+    mover?: (desde: string, hacia: string) => void;
+}): ResultadoDeMudanza;
+/** Las carpetas que cuelgan de una ruta: la foto de disco que pide `planDeCambioDeBase`. */
+export declare function planDeCambioDeBaseEnDisco(opciones: {
+    desde: string;
+    hacia: string;
+    casaXonecode: string;
+}): ReturnType<typeof planDeCambioDeBase>;
+/** En qué va una mudanza de base. Sin rutas: viaja por el cable tal cual. */
+export interface ProgresoDeMudanza {
+    fase: "comprobar" | "copiar" | "verificar" | "borrar";
+    proyecto?: string;
+    entorno?: string;
+    indice?: number;
+    total?: number;
+}
+export type ResultadoDeCambioDeBase = {
+    estado: "hecho";
+    mudadas: number;
+    restos: string[];
+    avisos: string[];
+} | {
+    estado: "rechazado";
+    motivo: string;
+};
+/** Lo que ocupa lo que se va a mudar, en megas redondeados hacia arriba: para el aviso. */
+export declare function megasDeLasMudanzas(mudanzas: readonly Mudanza[]): Promise<number>;
+/**
+ * CAMBIAR EL WORKSPACE MUDANDO lo que hay dentro: copiar, VERIFICAR y solo entonces borrar el
+ * origen. La decisión de QUÉ se muda es pura (`core/mudanzaDeWorkspace.ts#planDeCambioDeBase`);
+ * aquí está lo que toca disco, en un orden que no deja nada a medias:
+ *
+ * 1. **comprobar**: el destino se puede escribir y cabe lo que se copia, con margen;
+ * 2. **copiar** cada proyecto a una carpeta OCULTA hermana de su destino
+ *    (`.<proyecto>.llegando-<uuid>`). Se COPIA siempre, también en el mismo disco: un
+ *    `rename` entre volúmenes da EXDEV, y así el origen sigue intacto hasta el final;
+ * 3. **verificar** cada copia contra su original, fichero a fichero con SHA-256 — la igualdad
+ *    byte a byte es más fuerte que cualquier comprobación de git, y `git fsck` abortaría por
+ *    defectos que ya traía el origen. Una sola diferencia descarta TODAS las copias;
+ * 4. con todo verificado, las ocultas pasan a su nombre, y SOLO ENTONCES se guarda el
+ *    workspace nuevo y se reescribe `proyecto.raiz` del índice de tareas;
+ * 5. **borrar** el origen por lápida (renombrar y luego borrar, el molde de
+ *    `borrarCopiaDeProyecto`). Si algo lo bloquea, el cambio YA está hecho y se dice como
+ *    `restos`: deshacerlo con la base nueva escrita sería peor.
+ *
+ * Hasta el paso 4 la base vieja es la válida y en el destino solo hay carpetas ocultas, que se
+ * limpian. Quien llama garantiza que nada escribe en la base mientras tanto
+ * (`vestibulo.mudarWorkspace`).
+ */
+export declare function mudarBaseDeWorkspace(opciones: {
+    desde: string;
+    hacia: string;
+    mudanzas: readonly Mudanza[];
+    /** `~/.xonecode`: donde vive el índice de tareas. */
+    casaXonecode: string;
+    guardarWorkspace: (ruta: string) => void;
+    progreso?: (p: ProgresoDeMudanza) => void;
+    /** Cómo se copia un proyecto. Inyectable: una copia que sale MAL no se provoca a mano. */
+    copiar?: (desde: string, hacia: string) => Promise<void>;
+    /** Bytes libres en el destino, o ausente si no se sabe. Inyectable por los tests. */
+    espacioLibre?: (ruta: string) => Promise<number | undefined>;
+    /** Cómo se renombra el origen a su lápida. Inyectable: un fichero bloqueado por otro
+     *  programa no se provoca en un temporal. */
+    enterrar?: (desde: string, lapida: string) => Promise<void>;
+    /** Cómo se retira una copia ya puesta en el destino al deshacer el paso 4. Inyectable por lo
+     *  mismo que `enterrar`: una carpeta que no se deja borrar no se provoca en un temporal. */
+    retirar?: (copia: string) => Promise<void>;
+}): Promise<ResultadoDeCambioDeBase>;

package/dist/agent/config/persona.d.ts

@@ -0,0 +1 @@
+export declare function nombreDePersona(cwd: string): string | undefined;

package/dist/agent/config/selectorEnMaquina.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Abrir el selector de carpeta NATIVO de esta máquina. La regla de QUÉ comando y cómo se lee
+ * su respuesta es pura y vive en `core/selectorDeCarpeta.ts`; aquí solo está lanzarlo.
+ */
+import { type ComandoDeSelector } from "../../core/selectorDeCarpeta.js";
+/** ¿Hay selector en este sistema? Es lo que decide si se OFRECE el botón: un botón que no
+ *  hace nada es peor que no tenerlo, y el campo de texto ya resuelve el caso. */
+export declare function haySelectorDeCarpeta(plataforma?: string): boolean;
+/**
+ * La carpeta que la persona elija, o AUSENTE.
+ *
+ * **Ausente lo cubre todo lo que no es una elección**: cancelar, que el comando no esté, que
+ * falle, o que se agote el tope. No se distinguen a propósito — `osascript` sale con código 1
+ * tanto si cierras el diálogo como si revienta, así que afirmar cuál de las dos fue sería
+ * inventarlo. Lo que la pantalla necesita saber es si hay carpeta nueva, y eso sí se sabe.
+ *
+ * **Nunca LANZA.** Esto cuelga de un mensaje del cable, y una excepción aquí subiría por el
+ * manejador de la petición.
+ */
+export declare function elegirCarpetaEnMaquina(opciones?: {
+    desde?: string;
+    plataforma?: string;
+    lanzar?: (comando: ComandoDeSelector) => Promise<string>;
+}): Promise<string | undefined>;
+/**
+ * Abre, en el explorador de ficheros de ESTA máquina, la carpeta que contiene `ruta`.
+ *
+ * Accesorio, como `abrirEnSistema` al arrancar la web: nunca lanza, no espera respuesta ni
+ * mira el código de salida —`explorer.exe` sale con uno no-cero también cuando funciona—, y
+ * `detached`+`unref` para no dejar el proceso padre esperando a una ventana del sistema.
+ */
+export declare function abrirCarpetaDelSistema(ruta: string, plataforma?: string): void;
+/** Abre ESA carpeta (no la que la contiene) en el explorador de ficheros. El mismo trato
+ *  accesorio que `abrirCarpetaDelSistema`: nunca lanza ni espera. */
+export declare function abrirDirectorioDelSistema(carpeta: string, plataforma?: string): void;

package/dist/agent/config/settingsEnDisco.d.ts

@@ -0,0 +1,206 @@
+/**
+ * El ESCRITOR de `~/.xonecode/settings.json` (el lector puro está en `core/settings.ts`).
+ *
+ * Misma disciplina que `authEnDisco.ts`: una escritura nunca destruye lo que ya había,
+ * así que la base de la fusión es el objeto CRUDO tal cual (no el resultado de
+ * `validarSettings`, que descarta en silencio entradas raras) y ante un JSON roto se
+ * PARA sin escribir, en vez de recuperar el fichero por su cuenta. La mecánica de
+ * escritura —temporal + `renameSync`— es la de `agent/cloudstudio/cloudstudioMcp.ts#guardarEstado`:
+ * un `writeFileSync` a medias dejaría un `settings.json` truncado si el proceso muere a
+ * mitad de escritura, y el rename es atómico.
+ */
+import type { Aviso } from "../../core/config.js";
+import { type ModoDeEscritura } from "../../core/modoDeEscritura.js";
+import type { DispositivoDeLaSesion } from "../../core/dispositivoElegido.js";
+import { AjustesDeDispositivos, Entorno, Settings, type ViaRemota } from "../../core/settings.js";
+/** Un `settings.json` existente que no se puede fusionar: no se escribe nada encima. */
+export declare class SettingsRotosEnDisco extends Error {
+}
+/**
+ * `casa` es inyectable (por omisión `homedir()`) porque los tests no pueden tocar el
+ * `~/.xonecode` real — se resuelve en cada llamada, nunca se cachea, por la misma razón
+ * que `configEnDisco.ts#rutaConfigGlobal`: un test que cambia la home después del import
+ * vería si no la ruta vieja.
+ */
+export declare function rutaSettings(casa?: string): string;
+/**
+ * Sin fichero, settings vacíos y sin avisos: no hay nada que crear solo por leer.
+ *
+ * Igual que `cargar()` en `configEnDisco.ts`, devuelve `{ settings, avisos }` — el JSON
+ * roto y la credencial colada NO lanzan, se cuentan como aviso: un fallo del área de
+ * CloudStudio no puede tumbar el arranque de la consola (invariante de `CLAUDE.md`), y
+ * `validarSettings` ya no lanza para una credencial, solo para JSON-que-no-parsea, que
+ * aquí se atrapa igual que en `configEnDisco.ts`.
+ */
+export declare function cargarSettings(casa?: string): {
+    settings: Settings;
+    avisos: Aviso[];
+};
+/** Registra o sustituye un entorno por `id`, sin tocar los demás ni el resto del fichero. */
+export declare function guardarEntorno(casa: string | undefined, entorno: Entorno): {
+    ruta: string;
+};
+/**
+ * Guarda qué destinos se miran, sin tocar nada más del fichero.
+ *
+ * Se escribe el objeto ENTERO y no una fusión campo a campo: son cuatro interruptores (y las
+ * dos rutas) que la ventana manda juntos, y fusionar dejaría vivo un `ios: false` de una versión anterior
+ * que la persona acaba de apagar en la interfaz sin saber que seguía ahí. Un objeto sin
+ * ningún campo se guarda como ausencia —`{}` y «no lo he dicho» significan lo mismo: mirar
+ * todo— para no dejar basura en el fichero.
+ */
+export declare function guardarDispositivos(casa: string | undefined, ajustes: AjustesDeDispositivos): {
+    ruta: string;
+};
+/**
+ * Cambia UN AVD. `sinVentana: false` y `clon: false` borran su clave; un AVD sin nada desaparece.
+ * `copiaDe`/`clon` son la procedencia: se guardan al crear desde «Copia de» y no se piden por el cable.
+ */
+export declare function guardarAjusteDeAvd(casa: string | undefined, avd: string, cambio: {
+    puerto?: number;
+    sinVentana?: boolean;
+    copiaDe?: string;
+    clon?: boolean;
+}): {
+    ruta: string;
+};
+/**
+ * Quita TODO lo que se recordaba de un AVD (puerto, sin ventana, procedencia): al eliminarlo, su
+ * puerto tiene que quedar libre para el siguiente. Uno que no consta no toca el fichero; lo que
+ * queda vacío (`avds`, `dispositivos`) desaparece, como en `guardarAjusteDeAvd`.
+ */
+export declare function quitarAjustesDeAvd(casa: string | undefined, avd: string): {
+    ruta: string;
+};
+/** La siembra de puertos: solo AÑADE, un puerto que ya esté en disco no se mueve. */
+export declare function guardarPuertosAsignados(casa: string | undefined, asignados: Record<string, number>): {
+    ruta: string;
+};
+/**
+ * La siembra de puertos de los móviles físicos (IXCODE-32, `core/puertosDeAvd.ts`): solo AÑADE,
+ * el de una serie que ya tiene uno no se mueve.
+ */
+export declare function guardarPuertosDeFisicos(casa: string | undefined, asignados: Record<string, number>): {
+    ruta: string;
+};
+/**
+ * Guarda el tope de concurrencia de la cola de tareas, sin tocar nada más del fichero.
+ *
+ * Se acota a `0..TOPE_DE_CONCURRENCIA_DE_TAREAS` aquí y no solo en el cliente: el selector
+ * de Ajustes ya lo acota antes de mandarlo, pero `settings.json` no se fía de quien
+ * escribe — es el mismo criterio que `validarConcurrenciaDeTareas` aplica al LEER, aplicado
+ * ahora al escribir. Trunca en vez de rechazar: un decimal o un valor fuera de rango es un
+ * fallo de quien llama y no una razón para dejar el fichero como estaba: aquí solo hay un
+ * valor, así que truncarlo no puede aplastar la decisión de nadie más.
+ */
+export declare function guardarConcurrenciaDeTareas(casa: string | undefined, concurrencia: number): {
+    ruta: string;
+};
+/**
+ * Guarda el interruptor de depuración, sin tocar nada más del fichero.
+ *
+ * `true` BORRA la clave en vez de escribirla: ausente y encendida significan lo mismo
+ * mientras dure esta etapa de pruebas (`core/settings.ts#Settings.depurar`), y guardar un
+ * `true` explícito solo ensuciaría el fichero de quien nunca tocó nada.
+ */
+export declare function guardarDepurar(casa: string | undefined, depurar: boolean): {
+    ruta: string;
+};
+/**
+ * Guarda el modo con que nacen las sesiones nuevas (IXCODE-31), sin tocar nada más del fichero.
+ * `supervisado` BORRA la clave: es la omisión, y escribirla solo ensuciaría el fichero.
+ */
+export declare function guardarModoPorDefecto(casa: string | undefined, modo: ModoDeEscritura): {
+    ruta: string;
+};
+/**
+ * Guarda el interruptor de la sesión remota, su vía y el dominio de ngrok, fundidos en el `remoto`
+ * que ya hay (lo que no se nombra, intacto). `dominio: null` lo QUITA. La forma la comprueba quien
+ * llama (`motivoDeDominioInaceptable`) y la vuelve a comprobar `validarSettings` al leer.
+ * `habilitado` solo se escribe si se PIDE (el interruptor de Ajustes): guardar la vía o el dominio
+ * no lo inventa, porque el interruptor puede venir de `XONECODE_REMOTO=1`.
+ */
+export declare function guardarAjustesDeRemoto(casa: string | undefined, cambio: {
+    habilitado?: boolean;
+    via?: ViaRemota;
+    dominio?: string | null;
+}): {
+    ruta: string;
+};
+/**
+ * Guarda el modelo de OpenCode de Ajustes → Motores locales, sin tocar nada más del fichero.
+ * `undefined` BORRA la clave («sin modelo elegido»). La forma la comprueba quien llama
+ * (`motivoDeModeloDeMotorInaceptable`), y la vuelve a comprobar `validarSettings` al leer.
+ */
+export declare function guardarModeloDeOpencode(casa: string | undefined, modelo: string | undefined): {
+    ruta: string;
+};
+/**
+ * El modelo de OpenCode guardado, leído en CADA uso (se cambia desde Ajustes con la consola en
+ * marcha). Un `settings.json` roto no tumba un encargo: es «no hay modelo elegido».
+ */
+export declare function modeloDeOpencodeGuardado(casa?: string): string | undefined;
+/**
+ * Guarda el aparato con que nacen las sesiones nuevas (IXCODE-51), sin tocar nada más del fichero.
+ * `undefined` BORRA la clave: «ninguno» es la omisión.
+ */
+export declare function guardarDispositivoPorDefecto(casa: string | undefined, dispositivo: DispositivoDeLaSesion | undefined): {
+    ruta: string;
+};
+/** Guarda solo la base del workspace, sin tocar la lista de entornos. */
+export declare function guardarWorkspace(casa: string | undefined, base: string): {
+    ruta: string;
+};
+/**
+ * Dónde caen las copias cuando nadie ha configurado `settings.workspace`. Vive aquí y no en el
+ * vestíbulo desde que también la necesita `cli/` (la bajada que vacía la copia solo lo hace
+ * dentro del workspace), y `cli/` no importa de `web/`. El vestíbulo la reexporta, con el
+ * porqué de la carpeta propia.
+ */
+export declare function baseDeWorkspacePorOmision(): string;
+/** La base del workspace EN VIGOR: la de Ajustes si la hay, y si no la de omisión. Se lee en
+ *  cada uso, nunca se captura: se cambia desde Ajustes con la consola en marcha. */
+export declare function baseDeWorkspace(): string;
+/**
+ * Quita un entorno por `id`, sin tocar los demás ni el resto del fichero: el mismo molde que
+ * `guardarEntorno` (leer crudo, filtrar, escritura atómica). Las copias bajadas NO se tocan.
+ */
+export declare function olvidarEntornoDeSettings(casa: string | undefined, id: string): {
+    ruta: string;
+};
+/** Las carpetas de proyecto bajo `<workspace>/<entorno>/`, o `undefined` si no se pueden mirar
+ *  (ausente es «no consta», que no es cero). Sin la basura del sistema. */
+export declare function copiasDeEntorno(base: string, entorno: string): number | undefined;
+/**
+ * Borra `<workspace>/<entorno>/` ENTERA: las copias de todos sus proyectos, con su trabajo sin
+ * subir, sus sesiones y su git. Solo lo pide quitar un entorno con la casilla marcada y el
+ * nombre escrito, y quien llama ya ha comprobado que no hay nada abierto ni tareas vivas.
+ *
+ * La barrera es la de siempre y va AQUÍ, no solo en quien llama: el id pasa por
+ * `segmentoSeguro` (un id de un solo segmento, sin `..`), y la carpeta tiene que estar dentro
+ * del workspace por el TEXTO y por el camino REAL — un enlace que apuntara fuera pasaría la
+ * primera. Devuelve cuántas carpetas de proyecto había.
+ */
+export declare function borrarCopiasDeEntorno(base: string, entorno: string): number;
+/**
+ * Borra la copia local de UN proyecto, `<workspace>/<entorno>/<proyecto>/`, entera: su git, su
+ * `.xonecode/` (sesiones, `checkpoint.sqlite`, artefactos) y lo que no se haya subido. Lo de
+ * CloudStudio no se toca; el proyecto vuelve a estar «sin descargar».
+ *
+ * Las barreras son las de `borrarCopiasDeEntorno`, y van AQUÍ por lo mismo: la ruta se compone
+ * con `rutaDeWorkspace` (dos segmentos por `segmentoSeguro`, sin `..`) y se comprueba dentro
+ * del workspace por el TEXTO y por el camino REAL — un enlace que apuntara fuera pasaría la
+ * primera. Quien llama ya ha cerrado la consola de esa raíz y comprobado que nada escribe ahí.
+ *
+ * **Primero se RENOMBRA a una lápida y después se borra**, y es lo que hace que un fallo no
+ * deje una copia a medias. `rmSync` borra fichero a fichero: si algo tiene un fichero abierto
+ * dentro —otro proceso de xonecode con su checkpointer, un editor, el antivirus—, en Windows
+ * revienta a mitad, con los `.xne` y el git ya borrados y la carpeta todavía en su sitio, que
+ * se abriría como un proyecto roto. Renombrar una carpeta con un fichero abierto dentro falla
+ * ANTES de tocar nada, así que la negativa es verdad. La lápida empieza por punto: ni
+ * `copiasDeEntorno` ni la barra la cuentan como proyecto.
+ *
+ * Devuelve `"nada"` si no había copia, `"borrada"`, o `"restos"` si ya salió de su sitio pero
+ * quedó algo de la lápida por borrar — el proyecto está «sin descargar» igual.
+ */
+export declare function borrarCopiaDeProyecto(base: string, entorno: string, proyecto: string): "nada" | "borrada" | "restos";

package/dist/agent/config/versionEnDisco.d.ts

@@ -0,0 +1,17 @@
+/**
+ * De dónde sale lo que `core/version.ts` imprime: el `package.json` y, si esto es una copia
+ * de git, su commit y si hay cambios sin commitear.
+ *
+ * Vive en `agent/` y no en `core/` por la regla de siempre: aquí se toca el disco y se lanza
+ * un proceso. Lo que decide cómo se DICE es puro y está al otro lado.
+ */
+import type { VersionEnMarcha } from "../../core/version.js";
+/**
+ * Qué versión está corriendo. **Nunca lanza**: es una línea informativa, y un arranque que
+ * reventara por no poder leer su propio commit sería absurdo.
+ *
+ * El `git` se llama con `cwd` en la raíz del PAQUETE —no en la del usuario—, porque lo que
+ * se pregunta es con qué código corre xonecode y no qué hay en su proyecto. Con un tope
+ * corto: esto va en el camino del arranque, y un git colgado no puede retrasarlo.
+ */
+export declare function versionEnMarcha(raiz?: string): VersionEnMarcha;

package/dist/agent/dispositivos/arranqueDeEmulador.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Arrancar un emulador de Android desde xonecode.
+ *
+ * Hasta ahora la receta lo confesaba —«para arrancarlo: `emulator -avd pixel8`… arrancarlo
+ * desde esta ventana todavía no está cableado»— y la interfaz no prometía botón. Esto es ese
+ * botón, y tiene dos particularidades que lo separan de todo lo demás de esta pantalla.
+ *
+ * **1. Un emulador no TERMINA, así que no puede ocupar la ranura del único trabajo.** La
+ * receta de instalación corre con `crearEjecutor`, que vigila el silencio y espera el cierre
+ * del proceso (`TOPE_SIN_SALIDA_MS`); un emulador se queda vivo por definición, así que por
+ * ahí bloquearía la máquina para siempre. Se lanza DESPEGADO y no se espera su cierre: lo que
+ * se espera es que el aparato APAREZCA.
+ *
+ * **2. «Lanzado» y «arrancado» son dos cosas, y manda la MEDIDA.** Es la misma disciplina que
+ * ya aplica la receta —«la foto nueva dice si el paso quedó hecho, no el código de salida»— y
+ * aquí es más literal todavía: `emulator` devuelve el control enseguida y la ventana de Android
+ * tarda en aparecer. Así que se sondea `adb devices` hasta que el emulador contesta con SU
+ * nombre de AVD, que es el único dato que lo ata a lo que se pidió arrancar
+ * (`core/dispositivos.ts#nombreDeAvdDeConsola`). Sin esa comprobación, arrancar `pixel8`
+ * mientras otro emulador se levantaba diría «ya está» por el aparato equivocado.
+ */
+import { type DependenciasDeDeteccion } from "./dispositivosEnMaquina.js";
+import { type Lanzar } from "./procesosEnMaquina.js";
+/**
+ * Cuánto se espera a que el aparato aparezca.
+ *
+ * Un arranque en frío de un AVD con `google_apis` tarda decenas de segundos en esta máquina, y
+ * con la caché del sistema fría bastante más. Generoso a propósito: cortar pronto diría «no
+ * arrancó» de un emulador que estaba arrancando, que es la mentira que este sondeo existe para
+ * evitar. Y el proceso sigue vivo cuando el plazo vence — lo que se acota es la ESPERA, no el
+ * trabajo, igual que en el resto del repo.
+ */
+export declare const TOPE_DE_ARRANQUE_MS = 180000;
+/** Cada cuánto se pregunta. `adb devices` es barato una vez que el demonio está en marcha. */
+export declare const ESPERA_ENTRE_SONDEOS_MS = 2000;
+export interface ResultadoDeArranque {
+    ok: boolean;
+    /** Una línea, siempre: un fallo mudo aquí sería un botón que no hace nada. */
+    detalle: string;
+}
+export interface DependenciasDeArranque extends DependenciasDeDeteccion {
+    /** El `spawn` despegado. Por omisión el único del repo (`procesosEnMaquina.ts#lanzarReal`). */
+    lanzar?: Lanzar;
+    /** La espera entre sondeos, inyectable: los tests no pueden tardar tres minutos. */
+    esperar?: (ms: number) => Promise<void>;
+}
+/**
+ * Arranca el AVD `avd` y espera a que el aparato aparezca.
+ *
+ * **Nunca lanza**: un botón de esta ventana no puede tumbar el cable, así que todo sale por
+ * `ResultadoDeArranque` con su línea.
+ */
+export declare function arrancarEmulador(avd: string, deps?: DependenciasDeArranque, opciones?: {
+    sinVentana?: boolean;
+}): Promise<ResultadoDeArranque>;
+/**
+ * Para un emulador por su consola. Sin ventana no hay nada que cerrar: esto es lo que hace de
+ * botón. Nunca lanza; la serie se cierra por forma porque es un argumento de proceso.
+ */
+export declare function pararEmulador(serie: string, deps?: DependenciasDeDeteccion): Promise<ResultadoDeArranque>;

package/dist/agent/dispositivos/cajasDeMaqueta.d.ts

@@ -0,0 +1,61 @@
+import type { MaquetaMedida } from "../../core/geometriaDePantalla.js";
+/** Lo que tarda como mucho un render: con red lenta, Tailwind y las fuentes son unos segundos. */
+export declare const TOPE_DE_RENDER_MS = 45000;
+/**
+ * Qué se mide de la maqueta: los TEXTOS que se ven, cada uno con su caja. Se ejecuta DENTRO de la página (se
+ * inyecta con `toString()`), así que es JavaScript que el navegador entiende tal cual y no puede usar nada de fuera.
+ * Exportada para probarla con un DOM de pruebas.
+ *
+ * Antes se medían solo los `<button>`, cada uno con TODO su texto pegado. En la calculadora valía —cada tecla es un
+ * botón con un texto—, pero en una pantalla de tarjetas (Maset) cada tarjeta es un botón con título, badge,
+ * subtítulo y contador dentro: salía UN elemento «ENTREGAS PRIORIDAD Reparto de pedidos… 12 pend.» que no coincide
+ * con ningún control del aparato (BLOQUEANTE falso), y todo lo que no es botón —cabecera, banda, sección, pie— no se
+ * veía. Ahora:
+ * - un botón con UN texto (sin contar los iconos de Material) es un elemento, con la caja del BOTÓN: su forma es la
+ *   de la tecla, no la de las letras;
+ * - un botón con VARIOS textos se parte en ellos;
+ * - fuera de los botones, cada elemento con texto propio es uno.
+ * Cada uno dice si es un botón (`boton`): lo que no lo es y no tiene letras es un dato de ejemplo («12», «09:41»).
+ */
+export declare function medirElementos(doc: any): Array<{
+    texto: string;
+    caja: {
+        x: number;
+        y: number;
+        ancho: number;
+        alto: number;
+    };
+    boton?: true;
+    cajaDelTexto?: {
+        x: number;
+        y: number;
+        ancho: number;
+        alto: number;
+    };
+}>;
+/** La escala de una imagen de maqueta: una exportada a 2x o 3x se mide a su tamaño en puntos. Pura. */
+export declare function viewportDeMaqueta(anchoPng: number, altoPng: number): {
+    ancho: number;
+    alto: number;
+};
+/** El ancho y el alto de un PNG o un JPEG, de su cabecera. `undefined` si no se sabe. Pura. */
+export declare function medidasDeImagen(bytes: Buffer): {
+    ancho: number;
+    alto: number;
+} | undefined;
+/** Saca la medida del DOM que vuelca Chrome. Pura. */
+export declare function medidaDelDom(dom: string): (MaquetaMedida & {
+    tailwind: boolean;
+    pideTailwind: boolean;
+}) | undefined;
+export interface DependenciasDeRender {
+    navegador?: string;
+    /** Lanza el navegador y devuelve lo que imprime. Los tests no abren un Chrome. */
+    volcar?: (navegador: string, argumentos: readonly string[]) => Promise<string>;
+}
+/**
+ * Las cajas de `rutaDelHtml` renderizada a `ancho`×`alto`. Nunca lanza: lo que falla vuelve como motivo.
+ */
+export declare function cajasDeMaqueta(rutaDelHtml: string, ancho: number, alto: number, deps?: DependenciasDeRender): Promise<MaquetaMedida | {
+    motivo: string;
+}>;

package/dist/agent/dispositivos/decodificarImagen.d.ts

@@ -0,0 +1,21 @@
+import type { ImagenRgba } from "../../core/compararCapturas.js";
+/**
+ * De un PNG o un JPEG a píxeles RGBA, para `core/compararCapturas.ts` (que no importa librerías).
+ *
+ * **Se comprueban las dimensiones ANTES de descomprimir.** Un PNG de unos cientos de bytes puede
+ * declarar 60.000×60.000 y agotar la memoria al abrirlo (una bomba de descompresión, la misma
+ * clase que el `.zip` de una skill), así que se lee la cabecera —los primeros bytes— y se rechaza
+ * lo que pase de `MAX_LADO`/`MAX_PIXELES` sin decodificar nada. Una captura de móvil va de
+ * 1080×2400 a 1440×3200 (~4,6 millones), lejos del tope.
+ *
+ * **Lanza con un mensaje sin ruta ni contenido**: quien lo llama (la tool) lo devuelve como texto.
+ */
+export declare const MAX_LADO = 8192;
+export declare const MAX_PIXELES = 40000000;
+export declare const MAX_BYTES: number;
+/** Solo el tamaño, de la cabecera y sin decodificar nada (`convertir_a_p` necesita el ancho de la maqueta). */
+export declare function dimensionesDeImagen(bytes: Buffer): {
+    ancho: number;
+    alto: number;
+};
+export declare function decodificarImagen(bytes: Buffer): ImagenRgba;

package/dist/agent/dispositivos/descargaDeHerramientas.d.ts

@@ -0,0 +1,44 @@
+/** Lo que puede ocupar el `.zip` descargado. Las cmdline-tools de hoy pesan 156 MB, el JDK
+ *  ronda los 190 MB: deja margen sin abrir la puerta a un zip bomba servido por un host que
+ *  dejó de ser de confianza (una URL fijada a mano, ver `core/dispositivos.ts`). */
+export declare const TOPE_DE_LA_DESCARGA: number;
+/** Lo que puede ocupar DESCOMPRIMIDO. El de arriba no lo ve: un zip pequeño puede
+ *  descomprimirse en gigabytes. */
+export declare const TOPE_DESCOMPRIMIDO: number;
+/** Cuántas entradas puede traer. Las cmdline-tools traen unos pocos miles de ficheros. */
+export declare const TOPE_DE_ENTRADAS = 8000;
+export interface ResultadoDeDescarga {
+    estado: "ok" | "fallo" | "cancelada" | "colgada";
+    /** Una línea, nunca la salida entera. Ausente si fue bien. */
+    motivo?: string;
+    ms: number;
+}
+export interface Descarga {
+    cancelar: () => void;
+    terminado: Promise<ResultadoDeDescarga>;
+}
+export interface OpcionesDeDescarga {
+    /**
+     * Si el zip trae EXACTAMENTE una carpeta de primer nivel, se renombra a esta al escribir
+     * —sin un paso de renombrado aparte, se descomprime YA con el nombre fijo—. Se usa para el
+     * JDK (`jdk-17.0.20.1+1` → `jdk17`) y las cmdline-tools (`cmdline-tools` → `latest`), cuyo
+     * nombre de carpeta trae la versión o no es el que Google exige. `platform-tools` no la
+     * necesita: su zip ya trae `platform-tools/` con el nombre correcto.
+     */
+    renombrarCarpetaUnicaA?: string;
+}
+export interface DependenciasDeDescarga {
+    fetch?: typeof fetch;
+    crearCarpeta?: (ruta: string) => void;
+    escribir?: (ruta: string, datos: Uint8Array) => void;
+    ahora?: () => number;
+    /** Cada línea de progreso, en cuanto sale: es lo que hace usable una descarga de minutos. */
+    alSalirLinea?: (linea: string) => void;
+}
+/**
+ * Descarga `url` y la descomprime bajo `destino`. Nunca lanza: todo lo que puede ir mal
+ * —una URL caducada, un zip corrupto, una ruta de zip-slip, el tope de tamaño— vuelve como
+ * un `ResultadoDeDescarga` con su motivo de UNA línea, igual que
+ * `instalacionEnMaquina.ts#correrPasoDeReceta`.
+ */
+export declare function descargarYDescomprimir(url: string, destino: string, opciones?: OpcionesDeDescarga, deps?: DependenciasDeDescarga): Descarga;