xonecode 0.38.44 → 0.39.2

package/dist/core/descargas.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Los dos prefijos virtuales, con barra final: `CompositeBackend` la exige para no
+ * reconstruir `//nombre` fuera de la raíz montada — la misma trampa medida con `/skills/`.
+ *
+ * Los nombres son los de la librería y no una elección nuestra: cambiarlos aquí no cambiaría
+ * dónde escribe ella, solo dejaría el montaje sin usar.
+ */
+export declare const RUTA_RESULTADOS_GRANDES = "/large_tool_results/";
+export declare const RUTA_HISTORIAL_DE_MENSAJES = "/conversation_history/";
+/** Las dos, para montarlas de una vez. */
+export declare const RUTAS_DE_DESCARGA: readonly ["/large_tool_results/", "/conversation_history/"];
+/**
+ * Dónde cae en DISCO una de esas carpetas: al LADO de la de artefactos de la sesión.
+ *
+ * Se deriva de la carpeta de artefactos en vez de recibir su propio parámetro, y no es
+ * pereza: esa carpeta ya lleva dentro la única decisión que hace falta —¿hay una sesión con
+ * IDENTIDAD?—, que `turnoReal.ts` resuelve pasando `.xonecode/sesiones/<id>/artefactos` en
+ * la web y cayendo a `.xonecode/artefactos` en el terminal, donde el hilo es un uuid nuevo
+ * en cada arranque y no habría nada que reabrir. Dos parámetros serían dos sitios donde
+ * contestar la misma pregunta, y el segundo es justo el que se cae en un cableado de ocho
+ * saltos — el patrón de fallo que este repo ya ha medido seis veces.
+ *
+ * Y de vivir AHÍ cuelga gratis lo que si no habría que escribir: `borrarSesion` ya borra la
+ * carpeta `<id>` entera (`rmSync(dirname(carpetaDeArtefactosDeSesion(...)))`), así que
+ * borrar una conversación se lleva también sus descargas — que es lo correcto, por el mismo
+ * motivo que se lleva su checkpoint: ahí dentro está la salida entera de tools que se
+ * ejecutaron en ella.
+ *
+ * En el terminal la carpeta es del PROYECTO y no de un hilo, y eso hay que decirlo: esos
+ * ficheros se acumulan entre arranques y nada los poda. Es la misma deuda declarada del
+ * checkpointer — en este repo no hay barrido de nada todavía.
+ */
+export declare function carpetaDeDescargas(carpetaDeArtefactos: string, ruta: string): string;
+/**
+ * ¿Es esta ruta una descarga del agente escrita en el PROYECTO? Y si lo es, dónde iba.
+ *
+ * Existe para que la regla no dependa del montaje. Con las dos raíces montadas esto no
+ * salta nunca —`CompositeBackend.getBackendAndKey` enruta por PREFIJO de texto y sin mirar
+ * si la carpeta destino existe (leído en deepagents 1.13.2), así que el backend del proyecto
+ * no llega a ver esas rutas—, y ahí está el sentido: el día que el montaje falte (una
+ * consola construida sin carpeta de artefactos, un cableado que se cae en silencio) la
+ * escritura falla CERRADO en vez de aterrizar en la app del cliente. Es la misma lección
+ * que la fila incondicional de `/adjuntos/` en `permisosDe`, y por el mismo camino: medido,
+ * sin ella la ruta se convertía en un fichero del proyecto.
+ *
+ * **Se mira el PRIMER segmento y nada más**, igual que `artefactoFueraDeSitio`, y con el
+ * mismo precio dicho: un proyecto que de verdad tuviera una carpeta `large_tool_results/`
+ * en su raíz no podría escribir ahí con el agente. Se acepta — ninguna convención de XOne
+ * usa esos nombres, y el otro lado del error es la salida cruda de una tool subida a la app
+ * del cliente. Sin distinguir mayúsculas, que es la lección de APFS.
+ */
+export declare function descargaFueraDeSitio(ruta: string): string | undefined;
+/**
+ * El motivo con el que se rechaza. Dice QUÉ es y por qué no va ahí, como `porQueNoAhi`: un
+ * error seco haría que el modelo probara otra ruta o diera el trabajo por hecho.
+ *
+ * Aquí quien lee el mensaje casi nunca es el modelo —estas escrituras las hace la librería,
+ * y su hueco en el contexto es un «no se pudo guardar»— así que el destinatario de verdad
+ * es quien esté leyendo un log. Por eso nombra la causa probable.
+ */
+export declare const porQueNoEsDelProyecto: (ruta: string, destino: string) => string;

package/dist/core/descripcionDePantalla.d.ts

@@ -0,0 +1,121 @@
+/**
+ * El DESCRIPTOR DE PANTALLA: lo que el modelo ve en UNA imagen —la maqueta o la captura, cada una SOLA— con el
+ * MISMO esquema y el MISMO vocabulario cerrado, para que la comparación la haga el CÓDIGO. Puro.
+ *
+ * Existe por la calculadora de MyAllXOne. El crítico comparaba las dos imágenes a la vez y contestaba en prosa
+ * libre: vio el visor roto, pero en la misma lista dijo que el «0» de la maqueta era una píldora ancha y que la
+ * «=» era más grande que las demás, las dos cosas falsas, y no había forma de separar lo cierto de lo inventado.
+ * La maqueta ya se describía con un esquema; la captura, no. Ahora hablan el mismo idioma.
+ *
+ * Cuatro reglas:
+ *
+ * - **Cada imagen se describe SOLA.** Con las dos delante el modelo compara de memoria y lo que ve en una se
+ *   contagia a la otra.
+ * - **En la captura, la ESTRUCTURA la pone el árbol de controles** (`filasDelAparato`): se le dice qué controles
+ *   existen y en qué fila, y solo describe cómo se ve cada uno. Así no puede inventarse una fila ni un botón.
+ * - **Vocabulario CERRADO** (formas, tamaños de letra, alineación, colores en `#RRGGBB`): lo que no está en la
+ *   lista se tira, no se interpreta.
+ * - **La comparación es de CÓDIGO** (`compararDescripciones`), control a control y siempre con la misma frase,
+ *   agrupada por diferencia: «forma píldora → círculo en «7», «8»…». Un texto RECORTADO se dice siempre.
+ *
+ * Las filas descritas de una maqueta sin `code.html` se comparan además contra el árbol medido
+ * (`compararConMaqueta` en modo `aproximada`, vía `maquetaDeLaDescripcion`).
+ */
+import { type ControlDelAparato, type GeometriaDelAparato, type MaquetaMedida } from "./geometriaDePantalla.js";
+export declare const FORMAS: readonly ["pildora", "redondeada", "recta", "circulo"];
+export declare const LETRAS: readonly ["pequena", "normal", "grande", "enorme"];
+export declare const ALINEACIONES: readonly ["izquierda", "centro", "derecha"];
+export type Forma = (typeof FORMAS)[number];
+export type Letra = (typeof LETRAS)[number];
+export type Alineacion = (typeof ALINEACIONES)[number];
+export interface ControlVisto {
+    /** El texto VISIBLE; un icono sin texto va entre corchetes: `[borrar]`. */
+    texto: string;
+    /** Su ancho respecto al más estrecho de su fila (1, 2…). Ausente: no se compara su ancho. */
+    unidades?: number;
+    forma?: Forma;
+    fondo?: string;
+    colorTexto?: string;
+    letra?: Letra;
+    /** Lleva un CONTORNO visible. */
+    borde?: boolean;
+    /** Su texto se ve CORTADO por algún borde. */
+    recortado?: boolean;
+    alineacion?: Alineacion;
+    /** Radio de las esquinas del fondo entre el lado corto (0 recto … 0,5 extremo redondo). */
+    radio?: number;
+    /** Ancho entre alto de su fondo. */
+    proporcion?: number;
+    /** Altura de la tinta en fracción del ANCHO de la pantalla. */
+    alturaDeLetra?: number;
+    /** Su centro en fracción de la pantalla: con él se empareja, en vez de con la fila y la columna. */
+    centro?: {
+        x: number;
+        y: number;
+    };
+}
+export interface FilaVista {
+    /** Dónde está: `cabecera`, `visor`, `teclado`… (texto libre, corto). */
+    zona?: string;
+    controles: ControlVisto[];
+}
+export interface PantallaDescrita {
+    /** De arriba abajo; cada fila de izquierda a derecha. */
+    filas: FilaVista[];
+    /** Lo visible que NO es un control: una caja vacía con borde, una línea, un marco. */
+    extras: string[];
+}
+/**
+ * El prompt, el MISMO para la maqueta y para la captura. `controlesQueExisten` (de la captura, del árbol): las
+ * filas con sus textos, que el modelo tiene que usar tal cual.
+ */
+export declare function promptDescribirPantalla(controlesQueExisten?: readonly string[]): string;
+/** La fila de la captura como se le da al modelo: los textos, y un control sin texto por su nombre entre corchetes. */
+export declare function filasParaElDescriptor(filas: readonly (readonly ControlDelAparato[])[]): string[];
+/** La descripción que devolvió el modelo, o `undefined` si no trae al menos una fila. Lo que no encaja se tira. */
+export declare function interpretarDescripcion(objeto: Record<string, unknown> | undefined): PantallaDescrita | undefined;
+/**
+ * La descripción como cajas de una REJILLA: cada fila a su altura, cada control a lo ancho de sus unidades. Solo
+ * sirven para decir fila, orden y ancho relativo (`compararConMaqueta` en modo `aproximada`); un control sin
+ * unidades —o todos, con `conAnchos: false`— va marcado `sinAncho`.
+ */
+export declare function maquetaDeLaDescripcion(d: PantallaDescrita, conAnchos?: boolean): MaquetaMedida;
+/** La maqueta MEDIDA (las cajas del `code.html`) vista como si fuera un aparato, para compararla con la descrita. */
+export declare function htmlComoAparato(m: MaquetaMedida): GeometriaDelAparato;
+export interface ComparacionDeDescripciones {
+    /** «forma píldora → círculo en «7», «8»…»: una línea por diferencia, con los controles que la tienen. */
+    diferencias: string[];
+    /**
+     * Diferencias MENORES: se enseñan, pero no ponen el rojo. Una forma de una categoría VECINA con casi la misma
+     * proporción (una píldora de 2,9:1 que sale «recta» de 2,8:1) es un radio unos píxeles distinto en el límite entre dos
+     * nombres. Medido en la calculadora: sin esta separación el crítico medido no daba verde nunca y el bucle no acababa.
+     */
+    menores?: string[];
+    /** Lo de la maqueta que no está en la captura. */
+    faltan: string[];
+    /**
+     * Lo que se DICE y no pone el rojo: un texto que en la captura dice otra cosa en el mismo sitio (traducido, u otro
+     * estado: un DEG que está en RAD). Antes era una diferencia, y una maqueta en inglés no daba verde nunca.
+     */
+    notas?: string[];
+    /** Texto RECORTADO en la captura: se dice siempre, haya maqueta o no. */
+    recortes: string[];
+    /**
+     * Lo que se ve y no es un control (cajas vacías, rectángulos con borde…), de cada lado. Texto libre: se ENSEÑA
+     * para que lo mire quien arregla, pero no cuenta para el veredicto —no se puede comparar por código—.
+     */
+    extras: {
+        maqueta: string[];
+        captura: string[];
+    };
+}
+/**
+ * La comparación, control a control y con la misma frase siempre. Se empareja por TEXTO en orden de lectura
+ * (el segundo «±» de la maqueta con el segundo de la captura). Las diferencias iguales se AGRUPAN: dieciséis
+ * teclas que pasan de píldora a círculo son una línea, no dieciséis.
+ */
+export declare function compararDescripciones(maqueta: PantallaDescrita, captura: PantallaDescrita): ComparacionDeDescripciones;
+/** El bloque que ve el agente. `medida`: las dos salen de los píxeles de cada control, no de un modelo. */
+export declare function informeDeComparacion(c: ComparacionDeDescripciones, como?: "medida" | "descrita"): string[];
+/** Hay algo que arreglar según la comparación. */
+export declare const hayQueArreglar: (c: ComparacionDeDescripciones) => boolean;

package/dist/core/descriptoresDeApp.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Los descriptores de una app XOne: `app.xml` (qué conexiones declara) y `app.ini` (cómo se
+ * llama). Datos puros, sin tocar el disco y sin una sola dependencia.
+ *
+ * **Por qué un escáner y no un regex.** Un regex sobre el texto entero no puede distinguir una
+ * etiqueta dentro de un comentario de una de verdad —`<!-- <connection .../> -->` le da
+ * exactamente lo mismo—, y aquí el error peligroso es el **falso negativo**: decir «este
+ * proyecto no declara conexión» cuando sí la declara deja pasar justo el caso que esta
+ * comprobación existe para parar, que es el fichero que falta, el `{"result":true}` del
+ * lanzamiento y el diálogo «Database not found» detrás. Un falso positivo, en cambio, solo
+ * bloquea y dice por qué: es recuperable. El escáner puede ser correcto en las dos
+ * direcciones; un regex, no. Y **no se añade una dependencia de XML**: esto lee dos atributos
+ * de un fichero que ya conocemos y que sabemos emitir, no un documento arbitrario.
+ *
+ * Medido el 2026-09-16 sobre proyectos reales: de cuatro proyectos, dos declaran sus conexiones
+ * con `Provider=…` (Replanteos_2026, MyAllXOne), uno declara además la local
+ * `connstring="bd/gestion.db"` (MinitsMT) y el esqueleto de `core/esqueleto.ts` declara solo
+ * esa ruta. O sea que las dos formas conviven, y por eso hay un predicado que las separa.
+ *
+ * **Y de ahí sale una consecuencia que NO es la obvia: la declaración es la forma RARA.** De
+ * esos cuatro, tres no declaran su base y **los cuatro tienen su `bd/gestion.db`** — porque
+ * XOne usa esa ruta **por defecto**, se declare o no—. Así que `esRutaDeFichero` sirve para
+ * separar una ruta de una cadena de proveedor dentro de lo declarado, y **no** para decidir qué
+ * bases hay que comprobar: eso lo decide la convención, en `puedeLanzarse.ts`. Una regla que
+ * dependiera de este escáner para saber si hay base dejaría sin mirar el caso más común —el
+ * medido, el diálogo «Database not found»— en tres de cada cuatro proyectos.
+ *
+ * Y sobre `app.ini`: **el `app.ini` real escribe `name=` en MINÚSCULA** y el esqueleto de
+ * `core/esqueleto.ts` escribe `Name=` en mayúscula. Un lector sensible a mayúsculas devolvería
+ * `undefined` en todos los proyectos reales y funcionaría solo en el esqueleto — el patrón de
+ * fallo de esta casa, escrito en `CLAUDE.md`.
+ */
+/**
+ * Hasta dónde se mira. `app.xml` de verdad son 2-4 KB (el mayor medido, MinitsMT, 3.9 KB), así
+ * que este tope solo existe para que un fichero que no es un `app.xml` —un binario, un minified
+ * gigante— no se recorra entero. Por encima se devuelve **lo encontrado**: no es un error, es
+ * el final del texto que sabemos leer.
+ */
+export declare const TOPE_DE_XML = 400000;
+export interface ConexionDeclarada {
+    /** El `name` del atributo. Vacío si la etiqueta no lo traía. */
+    nombre: string;
+    /** El `connstring` tal cual, sin normalizar. */
+    connstring: string;
+}
+/**
+ * Las conexiones que declara `app.xml`, **en orden de aparición**.
+ *
+ * Bucle sobre índices y sin recursión: cada `<` se decide una vez y se avanza, así que un
+ * documento mal formado no puede hacer otra cosa que terminar antes.
+ *
+ * No se mira `<connection>` **dentro de un comentario, de un CDATA, del prólogo `<?xml ?>` ni
+ * de un `<!DOCTYPE>`**, que es exactamente lo que un regex no sabe hacer. Medido: el `app.xml`
+ * de MinitsMT tiene cuatro bloques de comentario —uno de ellos de cinco líneas y otro que
+ * contiene atributos comentados— y el de Replanteos tiene un `<include>` comentado.
+ *
+ * Un `<connection` sin `>` que lo cierre **sí** se devuelve, con lo que se haya podido leer. Es
+ * el lado conservador y la misma doctrina del falso negativo: una etiqueta truncada es una
+ * conexión declarada cuyo valor no se pudo leer, y decir «no declara ninguna» sería afirmar de
+ * más.
+ */
+export declare function conexionesDeApp(xml: string): ConexionDeclarada[];
+/**
+ * El `name=`/`Name=` de `app.ini`, recortado. `undefined` si no está o si está vacío.
+ *
+ * **Sin distinguir mayúsculas, y no es prudencia: es el censo.** Los tres `app.ini` reales que
+ * existen —Replanteos_2026, MyAllXOne y AppDemo; MinitsMT no tiene— escriben `name=` en
+ * minúscula, y el esqueleto de xonecode escribe `Name=`. Comparar con `=== "name"` funcionaría
+ * en todos los proyectos de verdad y fallaría en el único que escribimos nosotros, que es el
+ * peor reparto posible.
+ *
+ * Se salta las líneas sin `=`: el `app.ini` de AppDemo tiene una. Y la PRIMERA clave que case
+ * decide: no se sigue buscando otra por si acaso, porque dos `name=` en el mismo fichero no son
+ * una ambigüedad que resolver, son un fichero que alguien tocó.
+ */
+export declare function nombreDeApp(ini: string): string | undefined;
+/** El icono de la app (`icon=`/`Icon=` de `app.ini`), con las mismas reglas que `nombreDeApp`. */
+export declare function iconoDeApp(ini: string): string | undefined;
+/**
+ * Dónde puede estar el icono, en orden y como rutas RELATIVAS a la raíz del proyecto.
+ *
+ * **Dos sitios, porque el censo y la documentación no coinciden.** Los proyectos reales
+ * (ProyectoDieta, ProyectoPruebasXOneCode, mRED_Web) escriben `icon=icon.png` y dejan el fichero
+ * en la RAÍZ, junto a `splash.png`; la documentación y nuestro esqueleto dicen `Icon=app_icon.png`
+ * dentro de `IconFolder` (`icons/` por omisión). Se prueba primero lo que hacen los reales.
+ *
+ * Aquí no se decide nada de seguridad: un `icon=../.env` sale tal cual y lo para quien LEE
+ * (`leerFicheroDeProyecto`, texto y `realpath`), que es la misma barrera de Ficheros.
+ */
+export declare function candidatosDeIcono(ini: string): string[];
+/**
+ * ¿Este `connstring` es una RUTA del proyecto, o una cadena de proveedor?
+ *
+ * Medido el 2026-09-16: `bd/gestion.db` es una ruta; `Provider=Xone Remote Provider;ProgID=…`
+ * no lo es, y esos proyectos (Replanteos_2026, MyAllXOne) arrancan perfectamente. Confundirlos
+ * bloquearía un lanzamiento que funciona. Los tres descartes son la forma de una cadena de
+ * proveedor y no una lista de proveedores conocidos, para que uno nuevo no se cuele como ruta:
+ * `;` separa campos, `=` asigna, y `://` es un origen remoto.
+ *
+ * **La comprobación de existencia que esto habilita es conservadora a propósito, y su falso
+ * positivo está acotado.** Mira el PROYECTO, no el dispositivo: un proyecto que nunca se
+ * arrancó en local puede no tener `bd/gestion.db` aquí y tenerlo en el aparato, y entonces esto
+ * bloquea un lanzamiento que habría funcionado. Se acepta porque el error contrario —el
+ * medido— es un `{"result":true}` seguido de un diálogo de error, sin síntoma en ningún sitio;
+ * y porque la frase que lo acompaña dice exactamente qué falta. Preguntarle al DISPOSITIVO si
+ * tiene el fichero es la mejora obvia y queda fuera de esta pasada.
+ */
+export declare function esRutaDeFichero(connstring: string): boolean;

package/dist/core/diagnosticoDeNode.d.ts

@@ -0,0 +1,51 @@
+/**
+ * El diagnóstico de Node de Ajustes → General: lo que hace falta en ESTA máquina para que el agente pueda probar en el
+ * aparato y verificar el proyecto. Existe por un paquete de soporte de un usuario en Windows: el desarrollador en Claude
+ * Code no tenía ningún script (Windows no da bit de ejecución) y cada turno cerraba con «xone-simulator no está
+ * instalado (ENOENT)» aunque venía dentro del paquete. Las dos cosas se ven aquí en un clic.
+ *
+ * Una FOTO con hora, pedida a mano (el patrón de Dispositivos y Motores locales). **Ninguna ruta de la máquina viaja**:
+ * cada línea dice si funciona, una versión y, si falla, un motivo corto sin rutas (el `code` de Node o una frase fija).
+ */
+/** Una comprobación: si funciona, lo que se midió (una versión, una cuenta) y, si no, por qué. */
+export interface LineaDeDiagnostico {
+    ok: boolean;
+    /** Lo medido: una versión («v22.11.0», «2.1.301»), o lo que se comprobó. */
+    valor?: string;
+    /** Solo si `ok` es falso: por qué, sin rutas. */
+    motivo?: string;
+}
+export interface DiagnosticoDeNode {
+    /** ISO de cuando se midió. */
+    cuando: string;
+    /** El Node que corre xonecode: siempre funciona (si no, no habría servidor). */
+    servidor: {
+        version: string;
+        plataforma: string;
+        arquitectura: string;
+    };
+    /** Si el comando `node` responde desde una shell, que es como lanzan los scripts en Windows. */
+    nodeEnPath: LineaDeDiagnostico;
+    /** Cuántos scripts de las skills se detectan y si uno arranca con la MISMA llamada que haría el agente. */
+    scripts: LineaDeDiagnostico & {
+        cuantos: number;
+    };
+    /** `xone-simulator` (de `xone-linter`), el verificador del proyecto. */
+    simulador: LineaDeDiagnostico;
+    /** El Claude Code que trae el SDK: su versión y si su binario arranca. */
+    claudeCode: LineaDeDiagnostico;
+    /**
+     * El navegador con que el crítico MIDE la maqueta (y se imprime a PDF): Chrome, Edge… Medido en Windows: sin él, el
+     * crítico comparaba contra una descripción. Ausente en una foto vieja.
+     */
+    navegador?: LineaDeDiagnostico;
+}
+/** Los sistemas con su nombre de persona; lo que no se reconoce va tal cual. */
+export declare function nombreDeSistema(plataforma: string): string;
+/**
+ * El motivo de un fallo al lanzar un proceso, SIN rutas: el `code` de Node (ENOENT, EACCES…), el tope, o el código de
+ * salida. El mensaje de Node no se usa nunca: lleva la ruta absoluta del programa.
+ */
+export declare function motivoDeFallo(error: unknown): string;
+/** Si TODO lo que el agente necesita funciona. */
+export declare function todoBien(d: DiagnosticoDeNode): boolean;

package/dist/core/diff.d.ts

@@ -0,0 +1,26 @@
+/**
+ * El diff de líneas para la aprobación: el ANTES contra el DESPUÉS de una escritura
+ * pendiente, como datos — quien pinta decide colores y presupuesto de líneas.
+ *
+ * Es PURO a propósito: quién aprueba y de dónde sale el antes y el después no son
+ * cosa de este módulo. El algoritmo es el LCS clásico por programación dinámica,
+ * con un GUARDIÁN de tamaño: dos ficheros de mil líneas serían un millón de celdas
+ * por el precio de un diff bonito, y el fallback (entero reescrito: todo quitado y
+ * todo añadido) sigue contando la verdad, solo que sin deduplicar lo que se mantiene.
+ */
+export type LineaDeDiff = {
+    tipo: "igual" | "anadido" | "quitado";
+    texto: string;
+};
+export declare function diffDeLineas(antes: string, despues: string): LineaDeDiff[];
+/**
+ * Solo las líneas que importan para decidir: los cambios y `contexto` líneas alrededor
+ * de cada uno. Las rachas largas de «igual» se recortan por VENTANAS solapadas (dos
+ * cambios cercanos comparten el contexto), no por trozos fijos.
+ */
+export declare function conContexto(d: LineaDeDiff[], contexto: number): LineaDeDiff[];
+/** El techo de líneas del bloque de diff, con la cuenta honesta de lo que no cabe. */
+export declare function recortar(d: LineaDeDiff[], tope: number): {
+    lineas: LineaDeDiff[];
+    recortadas: number;
+};

package/dist/core/diffDeColecciones.d.ts

@@ -0,0 +1,54 @@
+/**
+ * El diff SEMÁNTICO de las colecciones de un fichero: qué campos, referencias, eventos, nodos y
+ * conexiones entran, salen o cambian entre el «antes» de Revisión y ahora.
+ *
+ * **Puro, y sobre el MISMO modelo que el índice** (`ColeccionDeNavegacion`): quien lee el disco
+ * —el de ahora y el del «antes», sacado de git— es `agent/`, con el cargador de siempre. Así no
+ * hay un segundo sitio que decida qué es un campo o una referencia.
+ *
+ * **Límite declarado**: el modelo sabe el TIPO de un campo y nada más de sus atributos —ni el
+ * tamaño, ni `visible`, ni `class`—, así que un `S(20) → S(50)` o un cambio de estilo NO salen
+ * aquí: los enseña el diff de texto de debajo, que es la medida entera. Esto es el resumen de lo
+ * que el modelo entiende, no un sustituto del diff.
+ *
+ * Los nombres se casan SIN distinguir mayúsculas, la misma regla que el índice: en XOne `NOMBRE`
+ * y `Nombre` son la misma intención, y contarlo como «uno sale, otro entra» sería inventar un
+ * cambio. Se enseña el nombre de AHORA.
+ */
+import type { ColeccionDeNavegacion } from "./navegacion.js";
+export interface CambioDeCampo {
+    cambio: "nuevo" | "borrado" | "tipo";
+    nombre: string;
+    /** El tipo de antes (en `borrado` y `tipo`) y el de ahora (en `nuevo` y `tipo`). Ausente = el `.xne` no lo dice. */
+    antes?: string;
+    ahora?: string;
+}
+/** Una referencia que entra o sale: `desde` con qué atributo `hacia` dónde. */
+export interface CambioDeReferencia {
+    cambio: "nuevo" | "borrado";
+    desde: string;
+    por: string;
+    hacia: string;
+}
+/** Un nombre suelto (evento, nodo o conexión) que entra o sale. */
+export interface CambioDeNombre {
+    cambio: "nuevo" | "borrado";
+    nombre: string;
+}
+export interface CambiosDeUnaColeccion {
+    nombre: string;
+    /** La colección entera: nueva en este fichero, borrada de él, o modificada dentro. */
+    estado: "nueva" | "borrada" | "modificada";
+    campos: CambioDeCampo[];
+    referencias: CambioDeReferencia[];
+    eventos: CambioDeNombre[];
+    nodos: CambioDeNombre[];
+    conexiones: CambioDeNombre[];
+}
+/**
+ * Las colecciones que cambiaron entre `antes` y `ahora`, que son las declaradas en UN fichero en
+ * cada extremo. Una colección sin ningún cambio que el modelo vea no sale: el fichero cambió en
+ * algo que el modelo no entiende, y eso lo dice quien pinta («sin cambios en el modelo»), no una
+ * fila vacía.
+ */
+export declare function diffDeColecciones(antes: readonly ColeccionDeNavegacion[], ahora: readonly ColeccionDeNavegacion[]): CambiosDeUnaColeccion[];

package/dist/core/disenoVinculado.d.ts

@@ -0,0 +1,17 @@
+/**
+ * El diseño VINCULADO a un proyecto XOne, en un módulo SIN imports: `config.ts` lo valida y `stitch.ts` lo usa, y
+ * importarlo desde `stitch.ts` cerraba el ciclo config → stitch → artefactos → settings → config (`ciclos.test.ts`).
+ */
+/**
+ * El proyecto de Stitch VINCULADO a un proyecto XOne (`config.json#disenoVinculado`): de ahí salen las pantallas que se
+ * eligen para una tarea. Decisión suya: el diseño se ELIGE con su miniatura, no se busca por el nombre que escribe la
+ * persona — medido en Maset, «Menu Listado Entregas» no era el título de ninguna y la tarea construyó con otra maqueta.
+ */
+export interface DisenoVinculado {
+    /** `projects/<id>` de Stitch. */
+    proyecto: string;
+    /** Su título, para enseñarlo sin volver a preguntar a Stitch. */
+    nombre: string;
+}
+/** Por qué ese `projects/<id>` no vale, o `undefined`. */
+export declare function motivoDeProyectoDeStitchInaceptable(proyecto: unknown): string | undefined;

package/dist/core/dispositivoDeSesion.d.ts

@@ -0,0 +1,22 @@
+import { type DispositivoDeLaSesion } from "./dispositivoElegido.js";
+/** La variable que nombra el fichero con el dispositivo de la sesión. */
+export declare const VARIABLE_DE_DISPOSITIVO = "XONECODE_DISPOSITIVO";
+/** Lo que se guarda en el fichero: lo mismo que la pastilla, sin el estado en vivo. Vive en un
+ *  módulo aparte porque `settings.ts` también lo lee, y desde aquí sería un ciclo. */
+export type { DispositivoDeLaSesion } from "./dispositivoElegido.js";
+/** El fichero, al lado de la carpeta de artefactos de la sesión y no dentro: lo de dentro se
+ *  ANUNCIA como artefacto, y esto no es una salida para nadie. */
+export declare function ficheroDeDispositivo(carpetaDeArtefactos: string): string;
+export declare function ficheroDeDispositivoDeSesion(raiz: string, id: string): string;
+/**
+ * El contenido del fichero, validado como lo valida `skills/xone-hotswap/lib/dispositivo.mjs`
+ * (`dispositivoDeLaSesion`): las dos lecturas tienen que coincidir, o la shell y los scripts
+ * creerían en aparatos distintos. Roto o incompleto = no hay elección.
+ */
+export declare function dispositivoDeTexto(texto: string): DispositivoDeLaSesion | undefined;
+/**
+ * La línea que se le DICE al agente al mandar cada turno. La garantía la ponen los scripts, que
+ * leen el fichero; esto es para que el orquestador lo nombre al delegar y el `device-controller`
+ * sepa con cuál trabaja en vez de descubrirlo, y no se pelee con él pasando otro `--serie`.
+ */
+export declare function lineaDelDispositivo(d: DispositivoDeLaSesion | undefined): string;

package/dist/core/dispositivoElegido.d.ts

@@ -0,0 +1,17 @@
+/**
+ * La FOTO de un aparato elegido —el de una sesión, o el de por defecto de las sesiones nuevas
+ * (IXCODE-51)— y la regla que la valida. Puro, y sin importar nada: lo leen `dispositivoDeSesion.ts`
+ * y `settings.ts`, y desde cualquiera de los dos sería un ciclo.
+ */
+export interface DispositivoDeLaSesion {
+    id: string;
+    nombre: string;
+    plataforma: "android" | "ios";
+    clase: "emulador" | "simulador" | "fisico";
+}
+/**
+ * Validada como la valida `skills/xone-hotswap/lib/dispositivo.mjs` (`dispositivoDeLaSesion`): las
+ * dos lecturas tienen que coincidir, o la shell y los scripts creerían en aparatos distintos.
+ * Rota o incompleta = no hay elección.
+ */
+export declare function dispositivoDeValor(valor: unknown): DispositivoDeLaSesion | undefined;