xonecode 0.38.41 → 0.39.2

package/dist/web/servidor/transporte.d.ts

@@ -0,0 +1,2751 @@
+/**
+ * SSE del servidor al cliente, `POST /accion` del cliente al servidor.
+ *
+ * No es WebSocket a propósito: aquí hay UN stream, no un mux de streams lógicos con
+ * decenas de clientes hablando a la vez. Con SSE la reconexión es trivial porque el
+ * servidor guarda la lista de actos y la reemite entera; con WS habría que reimplementar
+ * generaciones y reanudación para no ganar nada.
+ *
+ * La regla que gobierna este fichero: **el contenido de fichero y el diff viajan en UN
+ * solo mensaje**, `aprobacion`, que es el paso donde el humano DECIDE sobre ellos. Ni los
+ * actos ni la traza de emisión los tocan, y por eso `emitir` no registra ese mensaje: lo
+ * guarda quien lo tiene en vuelo, que lo suelta en cuanto hay decisión.
+ */
+import type { PlanEnDisco } from "../../agent/planesEnDisco.js";
+import type { EsquemaDelProyecto, MapeoDeEstados, TareaDelGestor, TransicionDelGestor, Vinculo } from "../../core/gestorDeTareas.js";
+import type { CambiosDeUnaColeccion } from "../../core/diffDeColecciones.js";
+import type { FotoDeColecciones } from "../../core/fotoDeColecciones.js";
+import type { InformeDeDispositivos, NombreDeHerramienta } from "../../core/dispositivos.js";
+import type { AjustesDeDispositivos } from "../../core/settings.js";
+import type { Acto, ConsumoDeTurno, ConsumoPorModelo } from "../../core/actos.js";
+import type { Tarea } from "../../core/tareas.js";
+import type { PendienteDeAprobacion } from "../../core/events.js";
+import type { LineaDeDiff } from "../../core/diff.js";
+import type { SelectorDeConsola } from "../../cli/consola.js";
+import type { DecisionDeConsola } from "../../cli/aprobar.js";
+import type { OpcionDeEntorno, PasoDelVestibulo } from "./vestibulo.js";
+import type { DispositivoElegido } from "./sesiones.js";
+import type { Esfuerzo } from "../../core/esfuerzo.js";
+import type { ConectorDelCable, DefinicionDeConector, FilaDeCatalogo } from "../../core/conectores.js";
+import type { EstadoDeMotorLocal } from "../../core/motoresLocales.js";
+import type { DiagnosticoDeNode } from "../../core/diagnosticoDeNode.js";
+/** El vínculo del proyecto con su gestor, tal como cruza el cable: el del `config.json` más el
+ *  nombre del sitio si esta ejecución ya lo sabe (lo dijo `sitios()`), y el del PROYECTO si ya
+ *  lo nombró el gestor (IXCODE-15: en Notion `proyecto` es un `collection://…` que no se lee).
+ *  Ausente = no consta. */
+/** El vínculo tal como cruza: con su mapeo de estados y el interruptor del disparo (la puerta 2), que se editan en el panel. */
+export type VinculoDelCable = Vinculo & {
+    nombreDelSitio?: string;
+    nombreDelProyecto?: string;
+    estados?: MapeoDeEstados;
+    automatico?: boolean;
+    revisarEncargo?: boolean;
+};
+/**
+ * El informe de `core/dispositivos.ts`. **La `ruta` de cada herramienta solo cruza para
+ * `adb`/`emulator`** —la excepción declarada, igual que el workspace— y se quita en el
+ * código (`arranque.ts#sinRutas`) para `xcrun`/`devicectl`, que se quedan en el host: este
+ * cable puede ir por un túnel (`--anfitrion`) y esas dos nunca tuvieron un motivo para
+ * cruzarlo.
+ */
+export type InformeDeDispositivosDelCable = InformeDeDispositivos;
+/**
+ * Una sesión tal como viaja dentro del alta de un proyecto. **Sin la raíz**: la fila de la
+ * barra no la pinta, y una ruta de la máquina no cruza este cable (`sinRutas`).
+ * Redeclarada en `apps/web/src/tipos.ts`, como `TareaDelCable`.
+ *
+ * Tiene nombre propio, y no es cosmético: `tipos.test.ts` comprueba que los campos de los dos
+ * lados son los MISMOS, y una fila escrita dentro de otra interfaz no se puede comparar —
+ * el test la ve como parte del alta y no como un tipo. Nombrarla es lo que hace posible que
+ * un campo que se añada en el host y no en el cliente salga rojo en vez de quedarse mudo.
+ */
+export interface SesionDelCable {
+    id: string;
+    titulo: string;
+    /**
+     * Cuándo se tocó por última vez, en ISO. Es lo que ordena la lista y lo que la barra pinta
+     * a la derecha de cada fila. Ausente = el índice no lo dice (una entrada corrupta): la fila
+     * se pinta sin sello y se ordena la última.
+     */
+    ultimoTurno?: string;
+    /**
+     * Esta conversación la abrió una TAREA de fondo, no una persona (`EntradaIndice.tarea`).
+     * Viaja un booleano y no el id: la fila lleva una marca y no el nombre de la tarea, así que
+     * el id se queda en el host.
+     *
+     * **Ausente es «no consta», no «es un chat»**: no la lleva ninguna sesión anterior a esta
+     * marca. Se pinta liso porque liso es lo conservador, no porque conste que sea de una
+     * persona — igual que `compartido` en un proyecto.
+     */
+    deTarea?: true;
+    /**
+     * Esa conversación tiene un turno EN MARCHA ahora mismo, sea o no la que se está mirando.
+     * Es lo que hace visible que cambiar de sesión ya no interrumpe nada: el agente sigue
+     * trabajando en la de antes y la barra lo dice.
+     *
+     * Va en el ALTA y no en un mensaje propio porque el alta se reemite en los dos flancos de
+     * cada turno —de cualquiera de las consolas vivas—, que es exactamente cuando esto cambia.
+     *
+     * **Ausente es «no consta que esté trabajando»**, y eso incluye dos casos que no se pueden
+     * distinguir desde aquí: la sesión no tiene consola viva, o la tiene y está ociosa. Para lo
+     * que la barra pinta da igual; afirmar lo contrario, no.
+     */
+    trabajando?: true;
+    /**
+     * Lo que ha gastado la sesión ENTERA: los deltas de sus turnos, sumados. Es un ACUMULADO,
+     * así que solo crece, y no lleva `ventana` —«cuánto ocupa el historial ahora» es una
+     * pregunta de la sesión ABIERTA, y congelada en una cerrada sería un «ahora» de hace días
+     * (lo quita `core/actos.ts#acumularTotales`)—.
+     *
+     * **Ausente es «no consta», nunca cero**: no lo trae ninguna sesión anterior a esto que la
+     * siembra no haya alcanzado. Un `{0,0}` afirmaría que la sesión salió gratis, y con él la
+     * barra pintaría un `↑0 ↓0` que nadie ha medido.
+     */
+    consumo?: ConsumoDeTurno;
+    /**
+     * La CLAVE del ticket de Jira al que quedó ligada esta sesión (`"IXCODE-12"`), si tiene
+     * uno (`EntradaIndice.ticket`, IXCODE-11). Solo la clave, y no el objeto entero: es lo
+     * único que la fila de la barra tiene que pintar; el conector y el sitio se quedan en el
+     * host hasta que algo necesite componer la URL pública.
+     */
+    ticket?: string;
+    /**
+     * IXCODE-15: el CONECTOR de ese ticket (`"jira"`, `"notion"`), solo con `ticket`. Es con quien
+     * se cierra la tarea —no con el gestor vinculado ahora—, y de él sale el rótulo «Cerrar en …».
+     */
+    ticketConector?: string;
+}
+/**
+ * Las seis fases de un lanzamiento, EN ORDEN, y los cinco estados en que puede estar.
+ *
+ * **Se declaran aquí, en el cable, y no se importan de `agent/dispositivos/lanzamientoEnMaquina.ts`**, que es
+ * quien las recorre. El motivo es el de siempre en este fichero: el cable tiene su vocabulario
+ * CERRADO, y quien lo cierra es esta constante — la lista blanca del store del cliente y la
+ * validación del servidor se escriben contra ESTA lista, así que un valor que no esté aquí no
+ * llega a la pantalla. Importarlas ataría el contrato del cable al módulo que hoy lo cumple, y
+ * el día que ese módulo añada una fase el cable la aceptaría sin que nadie hubiera decidido si
+ * el cliente sabe pintarla.
+ *
+ * **Y por eso mismo hay un test que las ata** (`arranque.test.ts`: «las fases del cable son las
+ * que corre la máquina»): la lista de aquí no puede quedarse corta respecto de la de allí, o el
+ * recorrido se quedaría sin emitir justo la fase que alguien acaba de añadir.
+ *
+ * **`corriendo` no está en `EstadoDeLanzamiento` de la máquina, y aquí sí.** Allí el estado es un
+ * DESENLACE —cuatro formas de acabar—, porque `lanzarEnDispositivo` devuelve un resultado; aquí
+ * hay además un RECORRIDO EN VIVO, que es lo que permite que la pestaña enseñe en qué fase va
+ * en vez de un botón apagado sin explicación.
+ */
+export declare const FASES_DEL_LANZAMIENTO: readonly ["comprobando", "empaquetando", "subiendo", "reiniciando", "lanzando", "comprobando-arranque"];
+export type FaseDelLanzamiento = (typeof FASES_DEL_LANZAMIENTO)[number];
+export declare const ESTADOS_DEL_LANZAMIENTO: readonly ["corriendo", "ok", "fallo", "cancelada", "colgada"];
+export type EstadoDelLanzamiento = (typeof ESTADOS_DEL_LANZAMIENTO)[number];
+export type MensajeAlCliente = {
+    clase: "acto";
+    acto: Acto;
+}
+/**
+ * SUSTITUYE el último acto del cliente. Existe porque `pielWeb.alActo` avisa también
+ * de ACTUALIZACIONES: el cierre de una racha de tools reemplaza a su apertura dentro
+ * del mismo acto `herramientas` (`core/actos.ts#conLineaDeTool`). Un cliente que
+ * anexara a ciegas enseñaría las dos líneas para siempre.
+ *
+ * Solo se emite cuando el acto que cambia ES el último; si algo se escribió después,
+ * el transporte manda una `reemision` entera — sustituir «el último» tocaría otro acto.
+ */
+ | {
+    clase: "sustitucion";
+    acto: Acto;
+}
+/** El transcript completo: lo que recibe quien (re)conecta, y el arreglo de cualquier desajuste. */
+ | {
+    clase: "reemision";
+    actos: Acto[];
+}
+/**
+ * La sesión remota: el interruptor (`habilitado`, de `settings.remoto` o `XONECODE_REMOTO=1`, que
+ * es `porEntorno` y no se apaga desde Ajustes) y el estado del puente. La `url` lleva
+ * el SECRETO en el fragmento: es el TERCER secreto del cable, tras `leerSecreto` y el `codigo` de `motorLocal`, y por eso
+ * `remoto` no está en la lista de salida del puente (`core/remoto.ts`).
+ */
+ | {
+    clase: "remoto";
+    estado: "apagada" | "abriendo" | "activa" | "reconectando" | "error";
+    habilitado?: boolean;
+    porEntorno?: true;
+    url?: string;
+    moviles?: number;
+    motivo?: string;
+    /** Por dónde sale: el servidor manda siempre la vía en vigor; un cliente que no la reciba (servidor antiguo) la lee como ngrok. */
+    via?: "servidor" | "ngrok";
+    /**
+     * Lo medido de ngrok, solo si el diálogo lo necesita. `cuenta` = hay authtoken en SU
+     * configuración (nunca el token ni la ruta, que no cruzan). `instalado` = el SDK de ngrok, que viene con
+     * xonecode, CARGA: no hay receta para instalarlo aparte.
+     * `motivo` = por qué falló la última acción de ngrok (authtoken o dominio): SOLO un texto
+     * fijo nuestro (`MOTIVOS_DEL_TUNEL` o el rechazo del dominio), nunca lo tecleado ni lo que
+     * contestó ngrok. Lo quita la siguiente acción que sale bien.
+     */
+    ngrok?: {
+        instalado: boolean;
+        cuenta: boolean;
+        dominio?: string;
+        motivo?: string;
+    };
+}
+/**
+ * El saludo, SUELTO del `alta`. `agent/config/persona.ts#nombreDePersona` no depende de
+ * ninguna cuenta ni de ningún login —es `git config`/`os.userInfo()`, local y ya
+ * resuelto al construir el vestíbulo—, pero el `alta` solo se manda DESPUÉS de que
+ * `conducirCuenta()` termina (`arranque.ts#anunciarAlta`), que puede tardar lo que
+ * tarde un humano en elegir modelo y teclear una clave. Sin este mensaje, medido: la
+ * pantalla decía «Hola» a secas durante TODO el paso de cuenta, con el nombre ya
+ * resuelto y sin ningún sitio por el que viajar hasta que la cuenta se resolviera —
+ * un saludo que se sabe y no se dice. Se manda una vez, al conectar, antes de
+ * `conducirCuenta()`. `alta.nombre` (más abajo) sigue llevando el MISMO dato — no
+ * porque quede alguna conexión sin ver este mensaje (el SSE arranca de cero en cada
+ * conexión y siempre lo manda primero), sino porque quitarlo de `alta` cambiaría ese
+ * contrato y su test, y eso no es parte de este arreglo.
+ */
+ | {
+    clase: "bienvenida";
+    nombre?: string;
+}
+/**
+ * Una pregunta a la que hay que contestar.
+ *
+ * **`decision` es la FORMA, y ausente significa texto libre**, que es lo que ha sido
+ * siempre: el cliente pinta un campo y lo que se teclea vuelve como `respuesta`. Con
+ * `decision` puesta la respuesta es sí o no y no se teclea nada — la tarjeta enseña
+ * `lineas` (el plan de la subida, las mismas líneas que ya fueron por `acto` de sistema)
+ * y dos botones, y contesta por la MISMA puerta de siempre: `"s"` autoriza y el resto
+ * rechaza (`interpretAnswer`).
+ *
+ * No se deduce del enunciado: el `[s/N]` es sintaxis, y una piel rica que lo leyera para
+ * decidir si pone botones se rompería el día que alguien reescriba el prompt — con un
+ * editor donde hacía falta un botón, o con dos botones sobre una pregunta abierta, y sin
+ * ningún error que lo delate.
+ */
+ | {
+    clase: "pregunta";
+    texto: string;
+    decision?: DecisionDeConsola;
+} | {
+    clase: "selector";
+    selector: SelectorDeConsola;
+}
+/**
+ * Los modelos: cuál está en vigor, cuál queda por defecto, y qué se puede elegir.
+ *
+ * **Son DOS preguntas y por eso son dos campos.** `actual` es lo que resuelve el papel
+ * `trabajo` con las fuentes de la sesión ABIERTA, no lo que diga un fichero: `/modelo`
+ * cambia el modelo en caliente sin escribir nada, así que releer la configuración
+ * contaría lo de antes. Ausente = no hay sesión de proyecto y por tanto no hay modelo en
+ * vigor que afirmar — el cliente enseña «Elige modelo» en vez de inventarse una fila, que
+ * es la regla del harness de DeepSeek: «no stale row is synthesized».
+ *
+ * `porDefecto` es otra cosa: el que usarán las sesiones NUEVAS, resuelto contra el
+ * `config.json` global. Existe porque el compositor y Ajustes no preguntan lo mismo —una
+ * sesión puede llevar encima un `/modelo` en caliente y el defecto seguir siendo otro—, y
+ * meterlos en un campo solo enseñaría una de las dos como si fuera la otra. Y se manda
+ * TAMBIÉN sin sesión abierta, que es justo donde se configura: sin él, Ajustes diría «sin
+ * elegir» sobre una máquina que sí tiene un defecto escrito.
+ *
+ * `modelos` de un proveedor viaja SOLO cuando alguien lo ha pedido (`clase: "catalogo"`):
+ * el catálogo es una llamada de red por proveedor y consultarlos todos al conectar sería
+ * gastar cinco peticiones para pintar un menú que quizá nadie abra. `error` es el fallo
+ * de ESE proveedor y no tumba a los demás — se lista inservible y el resto sigue
+ * elegible.
+ */
+ | {
+    clase: "modelos";
+    actual?: string;
+    porDefecto?: string;
+    proveedores: ProveedorDeModelos[];
+    /**
+     * Qué esfuerzo admite el modelo EN VIGOR y cuál está puesto en la sesión.
+     *
+     * Viaja con los modelos y no en un mensaje propio porque cambia en los mismos
+     * instantes: los niveles dependen del modelo, así que un `/modelo` que no lo trajera
+     * dejaría la pastilla ofreciendo los del modelo de antes. Mismo motivo por el que la
+     * ventana de contexto viaja dentro de `consumo`.
+     *
+     * Ausente = no hay nada que afirmar (sin sesión, o el modelo no lo admite), y
+     * entonces la pastilla no se pinta.
+     */
+    esfuerzo?: {
+        niveles: Esfuerzo[];
+        actual?: Esfuerzo;
+        nota?: string;
+    };
+}
+/**
+ * Los proyectos de UN entorno registrado, en respuesta a la acción «proyectos» de un
+ * mensaje de entorno. Lleva el `entorno` dentro porque el cliente los guarda por
+ * entorno: son las casillas de una pestaña concreta de Ajustes, y una lista sin dueño se
+ * acabaría pintando bajo el nombre de otro servidor.
+ *
+ * **`proyectos` ausente y `error` puesto no es una lista vacía**: «no se pudo preguntar»
+ * no es «este entorno no tiene proyectos», y la pestaña tiene que poder decir lo primero
+ * en vez de afirmar lo segundo. El fallo es de ESE entorno y no tumba a los demás —la
+ * regla del catálogo de modelos: un desvío, no un callejón—, así que tampoco se pinta un
+ * aviso global ni se toca el entorno activo.
+ *
+ * No va en el `alta` a propósito, aunque `registrados` viaje ahí: el alta se reemite en
+ * los dos flancos de cada turno, y meter estas listas dentro obligaría a cachearlas en el
+ * proceso. Sin caché hay UNA sola fuente, así que la pestaña no puede contradecir a la
+ * barra cuando alguien cree un proyecto en Studio.
+ */
+ | {
+    clase: "proyectosDeEntorno";
+    entorno: string;
+    proyectos?: ProyectoDeEntorno[];
+    error?: string;
+}
+/**
+ * Cómo fue el último alta o baja de proveedor personalizado.
+ *
+ * El motivo viaja EN un mensaje propio y no por `informar`, por lo mismo que el aviso
+ * del selector durante el alta: la ventana de ajustes no pinta el transcript, así que un
+ * fallo contado como acto de sistema sería mudo justo donde hay que leerlo. `hecho` es
+ * lo que deja al formulario cerrarse solo cuando la cosa salió bien.
+ */
+ | {
+    clase: "proveedor";
+    hecho: boolean;
+    motivo?: string;
+}
+/**
+ * Hay un turno EN VUELO, o dejó de haberlo.
+ *
+ * El cliente lo necesita para dos cosas que no puede deducir sin mentir: apagar el
+ * compositor mientras el agente trabaja —mandar una segunda petición encima solo la
+ * encola sin decirlo— y convertir la flecha de enviar en un botón de parar. Deducirlo de
+ * los actos (¿llegó un `fin` después del último `usuario`?) fallaría justo cuando importa:
+ * un turno que revienta no siempre deja `fin`.
+ */
+/** `detenible`: el turno en marcha admite DETENER y replanificar. Ausente = no. */
+ | {
+    clase: "turno";
+    activo: boolean;
+    detenible?: true;
+}
+/**
+ * Lo que lleva consumido la sesión, en sus DOS cuentas.
+ *
+ * Separadas y no sumadas: los del grafo van contra la clave de API del usuario y los del
+ * agente externo contra su suscripción del producto. Sumar tokens es defendible; sumar su
+ * coste sería la cifra que miente, así que aquí solo viajan tokens y viajan aparte.
+ *
+ * Se emite en cada cambio y también al conectar, porque una pestaña que llega a mitad de
+ * sesión no vio los anteriores. Ausente = no consta (no hay sesión, o es el de pega) y
+ * entonces el cliente NO pinta un cero.
+ */
+ | {
+    clase: "consumo";
+    modelo: {
+        entrada: number;
+        salida: number;
+        cache: number;
+    };
+    externo: {
+        entrada: number;
+        salida: number;
+        cache: number;
+    };
+    /**
+     * Cuánto ocupa la VENTANA ahora, y su tope si se sabe. Otra pregunta que los
+     * acumulados: aquéllos dicen lo que la sesión ha costado y esto cuánto margen queda.
+     *
+     * `tope` ausente es «no se sabe», y entonces no se pinta denominador ni porcentaje —
+     * con Ollama no hay tope A PROPÓSITO (cada modelo local trae el suyo), y un
+     * porcentaje sobre un número inventado es una mentira con forma de cifra.
+     */
+    ventana: {
+        usado: number;
+        tope?: number;
+    };
+    /**
+     * Lo mismo, POR MODELO: un especialista puede correr en otro modelo que el raíz. Ausente =
+     * no consta (una sesión de antes, o un motor que no lo mide); lo gastado antes de medirlo
+     * llega bajo `SIN_DESGLOSE`, así que las filas suman el total.
+     */
+    porModelo?: ConsumoPorModelo;
+}
+/**
+ * Se está ABRIENDO algo: una sesión, o un proyecto que además hay que descargar.
+ *
+ * Lo dice el SERVIDOR y no lo deduce el cliente, por el mismo motivo que `turno`: solo
+ * este lado sabe cuándo empieza y cuándo acaba, y aquí el rango va de «unos cientos de
+ * milisegundos» (abrir una copia local: foto de git, checkpointer, sesiones) a «minutos»
+ * (descargar el proyecto entero). Deducirlo de que llegue un `alta` nuevo fallaría justo
+ * cuando importa: un fallo al abrir también anuncia alta, y una apertura sobre el
+ * proyecto que YA estaba activo no cambia nada en él.
+ *
+ * `activo: false` es el otro flanco y va en un `finally`, así que salir por un error
+ * también lo apaga — un indicador de actividad que se queda encendido para siempre es
+ * peor que no tenerlo.
+ */
+ | {
+    clase: "abriendo";
+    activo: boolean;
+    /** Qué se está abriendo, para poder señalarlo en su fila. Solo con `activo`. */
+    proyecto?: string;
+    sesion?: string;
+    /**
+     * El entorno que se está MUDANDO, cuando lo que viaja no es una apertura sino un
+     * cambio de entorno activo.
+     *
+     * Va aparte de `proyecto` y no en su lugar porque el cambio de entorno no abre nada
+     * del árbol: vacía la lista entera y la vuelve a traer del otro servidor. Y es un
+     * campo y no un `activo: true` pelado porque el cliente tiene que poder ENSEÑAR el
+     * que se ha pedido: sin eso el `<select>`, que va controlado por el `alta` —y el
+     * `alta` solo llega al final—, se queda clavado en el valor viejo durante toda la
+     * espera, y la elección se lee como que no ha entrado. Medido: 1,5 s.
+     */
+    entorno?: string;
+    /** Además hay que BAJARLO: es la espera larga, y la que hay que decir con palabras. */
+    descargando?: true;
+}
+/**
+ * Los subagentes dados de alta, para la ventana de ajustes.
+ *
+ * Se manda entero cada vez que cambia —son pocos y pequeños— en vez de mandar deltas:
+ * una lista de cinco elementos no justifica un protocolo de diferencias, y un delta
+ * perdido dejaría la ventana enseñando un agente que ya no existe.
+ *
+ * `problemas` son los `.md` que no se pudieron leer, con su motivo. Van por el cable y no
+ * solo al log del servidor porque quien los tiene que arreglar está mirando ESTA ventana:
+ * un agente que no aparece y nadie dice por qué se lee como que la aplicación lo perdió.
+ */
+ | {
+    clase: "agentes";
+    agentes: AgenteDelCable[];
+    problemas: string[];
+}
+/**
+ * Las skills en vigor, para la ventana de ajustes y para el editor de un subagente.
+ *
+ * Se manda entera cada vez que cambia —son pocas y el cuerpo solo viaja de las del
+ * usuario— en vez de mandar deltas, por lo mismo que `agentes`: un delta perdido dejaría
+ * la ventana enseñando una skill que ya no existe, y un subagente marcando una casilla que
+ * no tiene detrás ningún fichero.
+ *
+ * `problemas` son las carpetas que no se pudieron leer, con su motivo, y significa SOLO
+ * eso: que una del usuario tape a una de serie no es un problema, es la forma de afinarla
+ * sin editar donde el `npm install` la pisaría.
+ */
+ | {
+    clase: "skills";
+    skills: SkillDelCable[];
+    problemas: string[];
+}
+/**
+ * El cuerpo de UNA skill, pedido a mano (`clase: "cuerpoDeSkill"` del cliente).
+ *
+ * Va aparte y no dentro del `skills` por lo que ese tipo explica: las de serie son
+ * ficheros grandes y mandarlas todas en la ráfaga de bienvenida cuesta cientos de
+ * kilobytes para un formulario que nadie puede guardar. Aquí se paga solo la que se abre.
+ *
+ * `cuerpo` ausente = no se pudo leer, y entonces se DICE: una ficha que se abre en blanco
+ * se lee como que la skill está vacía.
+ */
+ | {
+    clase: "cuerpoDeSkill";
+    nombre: string;
+    cuerpo?: string;
+    error?: string;
+}
+/**
+ * La cola de tareas entera. Va a TODOS los clientes, como la foto de la máquina y por lo
+ * mismo: la cola es de la máquina. `corriendoAqui` es falso en el segundo proceso, y es lo
+ * que deja decir que este kanban no avanza.
+ *
+ * **Y `ejecutaOtroProceso` es la otra mitad, porque «no soy yo» y «no hay nadie»
+ * significan lo contrario**: el primero manda a esperar —una tarea creada aquí arrancará
+ * cuando ese proceso mire la cola— y el segundo dice que no va a pasar nada hasta que
+ * alguna consola tome el relevo. Con un solo booleano, el aviso mandaba a esperar a un
+ * proceso que puede no existir. **Ausente = no se sabe** (el cerrojo ni se pudo mirar, o
+ * esta ejecución no tiene corredor), y entonces no se afirma ninguna de las dos.
+ * **El pid no viaja**: es un dato de la máquina y no le dice nada a quien lo lee.
+ */
+ | {
+    clase: "tareas";
+    lista: TareaDelCable[];
+    concurrencia: number;
+    corriendoAqui: boolean;
+    ejecutaOtroProceso?: boolean;
+}
+/**
+ * Dónde se bajan las copias locales: la ruta ENTERA.
+ *
+ * **Es la excepción NOMBRADA a `sinRutas`**, y la única del cable. No se puede esquivar:
+ * el campo de Ajustes tiene que enseñar la carpeta que hay puesta, y una ruta que no se
+ * enseña no se puede comprobar ni elegir. Se probó a mandarla abreviada con `~` para que el
+ * caso normal no llevara el nombre de la cuenta del sistema, y no se sostiene: la cabecera
+ * de esta misma consola ya saluda por el nombre del usuario (`clase: "bienvenida"`), así que
+ * el `~` no tapaba nada que no estuviera ya y a cambio dejaba en pantalla una ruta que no se
+ * puede leer de un vistazo.
+ *
+ * Va en la ráfaga de bienvenida por lo mismo que los modelos y las skills: Ajustes se
+ * puede abrir en cuanto conecta, y un campo vacío se lee como «no hay nada puesto».
+ */
+ | {
+    clase: "workspace";
+    ruta: string;
+    puedeElegir?: boolean;
+}
+/**
+ * La carpeta que la persona eligió en el diálogo del sistema, para PONERLA EN EL CAMPO —
+ * no para guardarla. `ruta` AUSENTE = no eligió ninguna (canceló, o no se pudo abrir el
+ * diálogo), y entonces el campo se queda como estaba.
+ *
+ * **Elegir y guardar son dos actos, y por eso son dos mensajes.** Guardar desde el propio
+ * diálogo dejaría el ajuste escrito antes de que nadie hubiera leído la ruta entera, y en
+ * un campo cuyo único trabajo es que la ruta se pueda leer eso sería quitarle el trabajo.
+ */
+ | {
+    clase: "carpetaElegida";
+    ruta?: string;
+}
+/**
+ * Cómo va la MUDANZA de las copias al cambiar el workspace, y cómo acabó. `progreso` mientras
+ * dura (fase, y el proyecto por NOMBRE y entorno: ninguna ruta de la máquina), `resultado`
+ * una vez al final. Los dos ausentes no viajan nunca.
+ */
+ | {
+    clase: "mudanzaDeWorkspace";
+    progreso?: {
+        fase: "comprobar" | "copiar" | "verificar" | "borrar";
+        proyecto?: string;
+        entorno?: string;
+        indice?: number;
+        total?: number;
+    };
+    resultado?: {
+        estado: "hecho";
+        mudadas: number;
+        restos: string[];
+        avisos: string[];
+    } | {
+        estado: "rechazado";
+        motivo: string;
+    };
+}
+/**
+ * La casilla «Depurar» de Ajustes > General: si las dos trazas opt-in van encendidas sin
+ * variable de entorno. Va en la ráfaga de bienvenida por lo mismo que el workspace.
+ *
+ * `activa` es el valor YA RESUELTO (`core/settings.ts#depuracionActiva`): ausente en
+ * `settings.json` llega como `true`, la omisión de esta etapa de pruebas.
+ */
+ | {
+    clase: "depuracion";
+    activa: boolean;
+}
+/**
+ * El modo con que NACEN las sesiones nuevas en cualquier proyecto (IXCODE-31, Ajustes >
+ * General). Va en la ráfaga de bienvenida por lo mismo que «Depurar». Ya RESUELTO: ausente en
+ * `settings.json` llega como `supervisado`. El de cada proyecto, que gana sobre éste, viaja en
+ * la foto del resumen (`FotoDelResumen.modoDeEscritura`).
+ */
+ | {
+    clase: "modoPorDefecto";
+    modo: "supervisado" | "autonomo";
+}
+/**
+ * El aparato con que NACEN las sesiones nuevas, de una persona y de una tarea (IXCODE-51,
+ * Ajustes > General). Va en la ráfaga por lo mismo que el modo. Sin `dispositivo` = ninguno
+ * elegido, que no es lo mismo que no recibir el mensaje (entonces el control no se pinta).
+ */
+ | {
+    clase: "dispositivoPorDefecto";
+    dispositivo?: DispositivoElegido;
+}
+/**
+ * El catálogo de conectores MCP y los que esta consola tiene AÑADIDOS, para la sección de
+ * Ajustes. Va en la ráfaga de bienvenida por lo mismo que el workspace: Ajustes se puede
+ * abrir en cuanto conecta, y solo si la opción `conectores` está puesta — «un control sin
+ * dato detrás no se pinta».
+ *
+ * `catalogo` viaja SIN la `url` de cada servidor: no hace falta en pantalla, y así no hay
+ * una ruta remota que discutir por este cable.
+ *
+ * `ilegible`/`error` son los mismos campos que da `ServicioDeConectores.lista()`. Un fallo
+ * NO va por `informar`, que no llega al navegador desde el vestíbulo, y Ajustes se abre sin
+ * proyecto.
+ */
+ | {
+    clase: "conectores";
+    catalogo: FilaDeCatalogo[];
+    conectores: ConectorDelCable[];
+    desconocidos: string[];
+    ilegible?: true;
+    error?: string;
+}
+/**
+ * Cómo fue la última augmentación pedida (`{clase:"tarea", accion:"augmentar"}`): el
+ * encargo que propone el modelo, o por qué no se pudo. Nunca los dos a la vez.
+ */
+ | {
+    clase: "tarea";
+    accion: "augmentado";
+    encargo: string;
+} | {
+    clase: "tarea";
+    accion: "augmentado";
+    error: string;
+}
+/**
+ * Un trozo del transcript de la sesión de una TAREA que alguien está mirando en vivo.
+ *
+ * **No es un segundo registro** (decisión 3 del diseño): son los MISMOS actos que se
+ * guardan en el `.jsonl` de esa sesión, los mismos que se leen al abrirla después. La
+ * lista sale de los actos y nunca del disco, igual que la de artefactos.
+ *
+ * Va SOLO al cliente que lo pidió y no a todos: el transcript de una tarea no puede
+ * aparecer en el chat de quien está trabajando en otra cosa. Y lleva el `tarea` delante
+ * porque por el mismo cable puede llegar el transcript de la sesión propia: sin la
+ * etiqueta, los actos de una tarea de fondo se mezclarían con la conversación.
+ *
+ * Los tres `via` son los tres mensajes del transcript de siempre, con otro nombre:
+ * `todos` es la reemisión entera (al empezar a mirar y cuando el servidor reemite),
+ * `alta` un acto nuevo al final, y `sustitucion` el último que cambió (el cierre de una
+ * racha de tools sustituye a su apertura). `actos` es SIEMPRE una lista: con `alta` y
+ * `sustitucion`, de un solo elemento — un campo opcional por cada forma habría sido un
+ * «ausente no es vacío» de más en la lista blanca del store.
+ */
+ | {
+    clase: "mirada";
+    tarea: string;
+    via: "todos" | "alta" | "sustitucion";
+    actos: Acto[];
+}
+/**
+ * Qué hay en la MÁQUINA para probar la app: el sistema, las herramientas de Android e
+ * iOS (adb, emulator, xcrun/simctl, devicectl) con su estado, y a qué dispositivos y
+ * simuladores se llega (`core/dispositivos.ts`).
+ *
+ * Es una FOTO con su hora (`medido`), no un estado en vivo: se toma al conectar el primer
+ * cliente y cuando alguien pide actualizarla (el mensaje «dispositivos» del cliente). No se
+ * sondea en bucle porque `adb devices` arranca el demonio de adb y `xcrun` puede tardar
+ * segundos — un panel que se refresca solo cada pocos segundos lanzaría procesos en la
+ * máquina del usuario sin que nadie lo pidiera.
+ */
+ | {
+    clase: "dispositivos";
+    informe: InformeDeDispositivosDelCable;
+    /**
+     * Cómo acabó el último «Arrancar» de un emulador, si hubo uno.
+     *
+     * Viaja CON la foto nueva a propósito: el resultado de arrancar no es el código de
+     * salida de `emulator` —que vuelve enseguida— sino que el aparato APAREZCA, y eso es lo
+     * que dice la foto. Así las dos cosas llegan juntas y no se pueden leer desfasadas.
+     *
+     * **Ausente = no se ha pedido ninguno**, que no es «salió bien». Y un `ok: false` trae
+     * su línea: un botón que no hace nada y no lo dice es lo que esto viene a evitar.
+     */
+    arranque?: {
+        avd: string;
+        ok: boolean;
+        detalle: string;
+    };
+    /**
+     * Qué dispositivo tiene elegido CADA consola abierta, y de qué proyecto es: con dos
+     * proyectos sobre dos emuladores, la pastilla del chat avisa «lo usa Tienda» en el aparato ajeno.
+     * `proyecto` es el nombre de su carpeta —el que enseña la barra—, nunca una ruta. Una
+     * consola sin dispositivo elegido no aparece.
+     */
+    enUso?: {
+        id: string;
+        proyecto: string;
+    }[];
+    /**
+     * Qué destinos se miran (`core/settings.ts#AjustesDeDispositivos`). Viaja CON la
+     * foto porque las dos cosas se leen juntas: una herramienta «desactivada» solo se
+     * entiende sabiendo qué interruptor la apagó. **Ausente = nadie ha elegido**, y
+     * entonces se miran todos; un `false` es una elección.
+     */
+    ajustes: AjustesDeDispositivos;
+}
+/**
+ * Los ficheros que ESTA sesión ha tocado, y el parche de uno.
+ *
+ * `via` no es decoración, y son TRES cosas distintas: «git» es «comparado, y esto es lo
+ * que hay»; «sin-empezar» es que la sesión todavía no ha volcado ningún acto, así que no
+ * ha tocado nada y se sabe; «sin-marca» es que NO se sabe —la sesión se abrió sin git
+ * usable, o antes de que esto existiera—. Fundir las tres en una lista vacía haría que
+ * «todavía no has hecho nada» y «no se puede saber» se leyeran igual, y la segunda haría
+ * creer que un turno no escribió cuando lo que pasa es que no hay con qué comparar.
+ */
+/**
+ * Lo que ha tocado la sesión. `via` dice CÓMO se ha medido, y desde el 10-09-2026 son
+ * cuatro y no tres: `git` es atribución por COMMIT (lo que hizo esta sesión) y
+ * `desde-apertura` es la medida vieja —todo lo que ha cambiado en la copia desde que se
+ * abrió, de quien sea—, que es lo único posible en una sesión sin sello. Colapsarlas
+ * dejaría la pestaña rotulada «Sesión» sobre el trabajo de una tarea de fondo, que es el
+ * fallo que se vio en pantalla.
+ */
+ | {
+    clase: "revision";
+    via: "git" | "desde-apertura" | "sin-marca" | "sin-empezar";
+    ficheros: FicheroTocado[];
+    /** Commits de OTRAS sesiones entre los de esta: la lista es exacta, un parche puede
+     *  traer hunks ajenos. Ausente = ninguno, o no se pudo medir. */
+    mezclados?: number;
+} | {
+    clase: "parche";
+    ruta: string;
+    texto: string;
+    recortado: boolean;
+}
+/**
+ * TODO lo pendiente de subir a CloudStudio del proyecto abierto (la pestaña Sincronización del
+ * panel), o por qué no se pudo medir. Lo que git aún no sigue va marcado `sinCommitear`.
+ */
+ | {
+    clase: "pendientesDeSubida";
+    ficheros?: FicheroTocado[];
+    error?: string;
+}
+/**
+ * El diff de UN fichero pendiente contra CloudStudio. `negado` = la ruta no se enseña (la
+ * regla del lector), y entonces no viaja texto.
+ */
+ | {
+    clase: "parcheDeSubida";
+    ruta: string;
+    texto: string;
+    recortado: boolean;
+    negado?: string;
+}
+/**
+ * Lo que cambió en el MODELO de un `.xne` de Revisión (`core/diffDeColecciones.ts`), entre el
+ * mismo «antes» que su parche y ahora. Sin `cambios` y con `error` si no se pudo
+ * reconstruir; `cambios` vacío es «ningún cambio que el modelo vea».
+ */
+ | {
+    clase: "modeloDelCambio";
+    ruta: string;
+    cambios?: CambiosDeUnaColeccion[];
+    error?: string;
+}
+/**
+ * El árbol del proyecto abierto (pestaña Ficheros): rutas relativas, ordenadas y ya
+ * filtradas por la misma regla que ve el agente (`agent/grafo/arbolDeProyecto.ts`). `error`
+ * solo si no se pudo listar, y entonces `rutas` va vacía. Y el contenido de UN fichero,
+ * de solo lectura: sin `texto` si es binario o si la ruta se rechazó, con el motivo.
+ */
+ | {
+    clase: "arbol";
+    rutas: string[];
+    recortado: boolean;
+    error?: string;
+}
+/**
+ * El modelo XOne del proyecto abierto (pestaña Colecciones), del MISMO índice que
+ * `xone_navegacion`: rutas virtuales y nombres, nunca rutas de la máquina. Sin `foto` y con
+ * `error` si no se pudo leer.
+ */
+ | {
+    clase: "colecciones";
+    foto?: FotoDeColecciones;
+    error?: string;
+}
+/**
+ * Los planes del proyecto abierto (`.xonecode/planes/`, pestaña Planes): sus ficheros, las
+ * tareas leídas de su `TASKS.md` y el texto de su `PLAN.md`. Es lo que el plan DICE —estado y
+ * casillas las marca el modelo—. Sin `planes` y con `error` si no se pudo leer.
+ */
+ | {
+    clase: "planes";
+    planes?: PlanEnDisco[];
+    error?: string;
+}
+/**
+ * El gestor de tareas del proyecto abierto (IXCODE-11, panel del proyecto): UN mensaje con
+ * campos opcionales, como `planes`, y cada acción del cliente rellena el suyo. `error` dice
+ * QUÉ acción falló, porque el panel espera la respuesta de una en concreto. Nunca viaja un
+ * correo, un token ni una ruta de la máquina: del asignado, solo el nombre visible.
+ */
+ | {
+    clase: "gestor";
+    /** `admiteMias` (IXCODE-15): si el gestor VINCULADO sabe filtrar «asignadas a mí». Se
+     *  decidió AL VINCULAR y se lee del `config.json`, sin red. Viaja SIEMPRE con vínculo y
+     *  nunca sin él. */
+    estado?: {
+        conectores: string[];
+        vinculo?: VinculoDelCable;
+        admiteMias?: boolean;
+    };
+    sitios?: {
+        conector: string;
+        lista: {
+            id: string;
+            nombre: string;
+        }[];
+    };
+    proyectos?: {
+        sitio: string;
+        lista: {
+            clave: string;
+            nombre: string;
+        }[];
+    };
+    /** IXCODE-15: la respuesta de `buscarProyectos`, con el `texto` que se buscó (para no
+     *  pintar una respuesta vieja). En Notion `proyecto` es el id de la BASE: se manda a
+     *  `describir`, NO a `vincular`. */
+    busqueda?: {
+        conector: string;
+        texto: string;
+        lista: {
+            proyecto: string;
+            nombre: string;
+            ruta?: string;
+        }[];
+    };
+    /** IXCODE-15: la respuesta de `describir`. `pedido` es lo que se mandó; con `esquema`, lo
+     *  que hay que mandar a `vincular` es `esquema.proyecto` (el data source ya resuelto). Con
+     *  `motivo`, esa base no vale como gestor —la acción salió bien; no es un `error`—. */
+    descripcion?: {
+        conector: string;
+        pedido: string;
+    } & ({
+        esquema: EsquemaDelProyecto;
+    } | {
+        motivo: string;
+    });
+    /** `cuando`: la hora del SERVIDOR a la que se preguntó, para decir «hace N min».
+     *  `mias` viaja SOLO cuando la lista es la de «asignadas a mí»: el cliente pinta lo que
+     *  el servidor contestó, no lo que pidió. */
+    pendientes?: {
+        cuando: number;
+        texto?: string;
+        mias?: true;
+        lista: TareaDelGestor[];
+    };
+    /** La descripción de UNA tarea, para desplegarla en su fila antes de empezar. De solo
+     *  LECTURA: solo la clave y el texto, nada más de la ficha. */
+    ficha?: {
+        clave: string;
+        descripcion: string;
+    };
+    /** El texto que el compositor PROPONE: lo envía la persona, no sale solo. */
+    borrador?: {
+        clave: string;
+        texto: string;
+    };
+    /**
+     * Las transiciones disponibles de una tarea (Task 10, IXCODE-11), para «empezar» —con
+     * `transicion`— y para «cerrar». `propuesta` es el id que `transicionPropuesta` sugiere
+     * (la persona puede elegir otra o ninguna); ausente si ninguna encaja.
+     */
+    transiciones?: {
+        clave: string;
+        para: "empezar" | "cerrar";
+        lista: TransicionDelGestor[];
+        propuesta?: string;
+    };
+    /**
+     * El comentario de cierre PROPUESTO para la tarea de la sesión ABIERTA: lo compone
+     * `comentarioDeCierre` desde lo que el harness sabe de la sesión (`datosDeCierre`). La
+     * persona lo EDITA antes de mandar `cerrar`; nada se escribe todavía.
+     */
+    cierre?: {
+        clave: string;
+        comentario: string;
+    };
+    /**
+     * El resultado de `cerrar`: se llega aquí solo si `comentar` no falló —si falla, sale
+     * `error` en su lugar, así que `comento` es siempre `true`—, y `transicion` viaja SOLO
+     * si además se aplicó una. Si la transición pedida FALLÓ, su motivo va en
+     * `falloDeTransicion` (y `transicion` no viaja): el comentario ya está escrito, y un
+     * `error` a secas invitaría a repetir el cierre y comentar dos veces.
+     */
+    cerrado?: {
+        clave: string;
+        comento: boolean;
+        transicion?: string;
+        falloDeTransicion?: string;
+    };
+    /** `clave` solo en el de `ficha`: dice de QUÉ tarea es la descripción que no se pudo leer.
+     *  IXCODE-15: `texto` solo en el de `buscarProyectos` (QUÉ búsqueda falló) y `pedido` solo en
+     *  el de `describir` (QUÉ base): el cliente no pinta el fallo de una búsqueda o base que ya
+     *  no tiene delante. */
+    error?: {
+        accion: string;
+        motivo: string;
+        clave?: string;
+        texto?: string;
+        pedido?: string;
+    };
+} | ({
+    clase: "fichero";
+} & FicheroDelProyecto)
+/**
+ * La respuesta a guardar un fichero desde el editor de la pestaña Ficheros: con `huella` se
+ * escribió y esa es la nueva; con `error`, no se tocó nada. Va a TODOS los clientes: otra pestaña
+ * con el mismo fichero abierto se entera de que el disco cambió.
+ */
+ | {
+    clase: "ficheroGuardado";
+    ruta: string;
+    id: string;
+    huella?: string;
+    error?: string;
+}
+/**
+ * Lo que pasó al llevar un fichero guardado al aparato de la sesión (recarga en caliente). Va
+ * SIEMPRE después de su `ficheroGuardado` y aparte: el guardado no depende del aparato. `texto`
+ * es la frase hecha (`core/recargaEnCaliente.ts#textoDeRecarga`); `tipo`, cómo se aplicó.
+ */
+ | {
+    clase: "recargaEnAparato";
+    ruta: string;
+    estado: "aplicada" | "relanzar" | "relanzada" | "sin-app" | "desplegando" | "desplegada" | "ocupado" | "no-aplica" | "fallo";
+    tipo?: "coleccion" | "js" | "css" | "relanzar" | "no-aplica";
+    texto: string;
+}
+/** La base de comparación de un fichero, para las marcas del margen del editor. */
+ | ({
+    clase: "baseDeFichero";
+} & BaseDelFichero)
+/**
+ * El estado de sincronización del proyecto abierto (pestaña CloudStudio). Los campos van en
+ * `EstadoDeSync`, aquí arriba, para poder compararlos con los del cliente.
+ */
+ | ({
+    clase: "sync";
+} & EstadoDeSync)
+/**
+ * El contenido de un ARTEFACTO de la sesión, con la MISMA forma que un fichero del
+ * proyecto — a propósito: así los visores del cliente son los de la pestaña Ficheros y no
+ * una segunda familia de componentes para lo mismo. La `ruta` que trae es la VIRTUAL
+ * (`/artefactos/<nombre>`), que es la que el cliente ya conoce por el acto.
+ *
+ * El HTML no viaja por aquí para VERSE —eso lo pinta un iframe contra `GET /artefacto`,
+ * que es la única forma de darle un documento—, sino para leer su fuente cuando se pide.
+ */
+ | ({
+    clase: "artefacto";
+} & FicheroDelProyecto)
+/**
+ * Cómo va el paso de receta que se está EJECUTANDO, o cómo acabó.
+ *
+ * Va a TODOS los clientes, como la foto de la máquina y por lo mismo: la máquina es la
+ * misma para todos, y un `sdkmanager` corriendo lo está para las dos pestañas. `lineas` es
+ * la COLA del log —lo último, no todo—: un `sdkmanager` verboso son miles de líneas y el
+ * cable no es un sitio donde guardarlas.
+ */
+ | {
+    clase: "instalacion";
+    receta: string;
+    paso: number;
+    titulo: string;
+    estado: "corriendo" | "ok" | "fallo" | "cancelada" | "colgada";
+    lineas: string[];
+    ms: number;
+    motivo?: string;
+}
+/**
+ * El veredicto de «¿se puede lanzar la app del proyecto abierto, en su dispositivo?».
+ *
+ * **Va a la consola que lo PIDIÓ, no a todos los clientes** — la regla contraria a
+ * `dispositivos` e `instalacion`, y no por descuido: la máquina es la misma para todos, pero
+ * el PROYECTO no. Es el reparto de `revision` y `arbol`: se pide, se contesta, y NO entra en
+ * la ráfaga de bienvenida, porque una pestaña que acaba de abrirse no tiene por qué recibir
+ * el veredicto de un proyecto que a lo mejor ya no es el suyo.
+ *
+ * **`faltas` son FRASES ya escritas** (`core/puedeLanzarse.ts#motivoDeBloqueo`), no las causas
+ * crudas: el cliente no es fuente sobre qué se puede lanzar, y componer aquí «falta el
+ * framework en tal dispositivo» sería una segunda redacción de la misma regla, que es donde
+ * las dos divergen. `listo` es `faltas.length === 0` y viaja igualmente porque es lo que
+ * decide si el botón se pinta.
+ */
+ | {
+    clase: "lanzable";
+    /** El nombre del proyecto abierto. Un SEGMENTO, no una ruta: `sinRutas`. */
+    proyecto: string;
+    listo: boolean;
+    /** Vacío cuando `listo`. Una LISTA y no la primera: se arregla lo que falta una a una. */
+    faltas: string[];
+    /**
+     * El nombre de la app, el que dice el `name=` de `app.ini`. Ausente = no consta, y sin
+     * él no hay a qué lanzar: `launchApplication` la pide por nombre.
+     */
+    app?: string;
+    /**
+     * El dispositivo de la sesión tal y como salió de la última MEDIDA —id, nombre,
+     * plataforma y clase, y nada más—, que es la foto que ya viaja en `alta.dispositivoActivo`
+     * y en `sesiones[].dispositivo`. Ausente = ninguno elegido, o uno que ya no está.
+     */
+    dispositivo?: DispositivoElegido;
+    /**
+     * CUÁNDO se midió esto. Un veredicto sin fecha es una promesa sin fecha: el framework se
+     * mide al conectar y al pulsar «volver a mirar», así que un «todo listo» de hace media
+     * hora sobre un aparato que se acaba de desenchufar es exactamente el botón muerto que
+     * esta pestaña existe para no pintar.
+     */
+    medido: string;
+}
+/**
+ * Cómo va el lanzamiento de la app, o cómo acabó. Va a la consola que lo pidió, por lo mismo
+ * que `lanzable`.
+ *
+ * **`lineas` es la COLA del recorrido y no todo**: lo que suelta `adb` al subir un ZIP son
+ * miles de líneas, y este cable no es un sitio donde guardarlas. `ms` son los milisegundos
+ * desde que arrancó, y viaja porque un recorrido sin tiempo se lee como un cuelgue.
+ *
+ * `motivo` solo cuando lo hay: en `ok` no hay nada que decir, y un `motivo: ""` invitaría a
+ * pintar una línea vacía al lado del visto bueno.
+ */
+ | {
+    clase: "lanzamiento";
+    /** El nombre del proyecto, si se sabe CUÁL. Ausente = no había ninguno que nombrar. */
+    proyecto?: string;
+    dispositivo?: DispositivoElegido;
+    fase: FaseDelLanzamiento;
+    estado: EstadoDelLanzamiento;
+    lineas: string[];
+    ms: number;
+    motivo?: string;
+}
+/** Lo que ofrece un motor externo. `error` en vez de una lista vacía muda: un desplegable
+ *  vacío sin motivo se lee como que la ventana está rota. */
+ | {
+    clase: "modelosDeMotor";
+    motor: string;
+    modelos: {
+        id: string;
+        nombre: string;
+    }[];
+    error?: string;
+}
+/** El diagnóstico de Node de Ajustes → General (`core/diagnosticoDeNode.ts`): una foto, sin rutas de la máquina. */
+ | {
+    clase: "diagnosticoNode";
+    diagnostico: DiagnosticoDeNode;
+}
+/**
+ * El diseño vinculado de un proyecto: `vinculo` (null = sin vínculo), los `proyectos` de Stitch para elegir, las
+ * `pantallas` con miniatura, o un `error`. Cada mensaje trae solo lo que se pidió. `proyecto` = de qué proyecto XOne.
+ */
+ | {
+    clase: "diseno";
+    proyecto?: string;
+    vinculo?: {
+        proyecto: string;
+        nombre: string;
+    } | null;
+    proyectos?: {
+        name: string;
+        title: string;
+    }[];
+    pantallas?: {
+        name: string;
+        title: string;
+        miniatura?: string;
+    }[];
+    error?: string;
+}
+/**
+ * La foto de los motores locales (Claude Code, Codex, OpenCode) para Ajustes → Motores locales:
+ * si están, con qué sesión, la última prueba y el login en curso. Entera en cada cambio, como
+ * `dispositivos`. Ni rutas, ni el correo de la cuenta, ni el enlace de autorización.
+ */
+ | {
+    clase: "motoresLocales";
+    motores: EstadoDeMotorLocal[];
+} | {
+    clase: "secreto";
+    pregunta: string;
+}
+/**
+ * El alta que FALTA, para el wizard del navegador. `pasos` sale de
+ * `vestibulo.ts#pasosPendientes`, que los calcula preguntándole al sistema y nunca a una
+ * marca de «primer arranque»; vacío significa que no hay alta que hacer y el cliente no
+ * pinta el wizard — pero puede seguir sin haber proyecto abierto, ver `proyectoAbierto`
+ * más abajo. Cambio de rumbo del usuario: «proyecto» ya NO puede aparecer en `pasos`
+ * (sigue siendo un `paso` válido del lado del `MensajeDelCliente`, para abrir uno desde
+ * la barra lateral, pero no bloquea la entrada al dashboard).
+ *
+ * `proyectos` y `ramas` llegan vacíos hasta que hay entorno (y proyecto) elegidos: son
+ * dos consultas a CloudStudio y no se pueden inventar. Lista vacía es «todavía no lo
+ * sé», que es la verdad, y no un dato de relleno.
+ *
+ * **La clave de API NO viaja aquí.** El paso de cuenta lo conduce
+ * `vestibulo.pasoDeCuenta()` sobre `seleccionar` y `leerSecreto`, así que la clave sigue
+ * entrando por el mensaje de clase «secreto» y por ninguno más — el mismo trato que
+ * documentan `consolaWeb.ts#leerSecreto` y la cabecera de `Wizard.tsx`.
+ */
+ | {
+    clase: "alta";
+    pasos: PasoDelVestibulo[];
+    /**
+     * **Qué está preparando el arranque AHORA. Ausente = ya está listo.**
+     *
+     * Existe porque `proyectos: []` no distingue «todavía no lo he preguntado» de «no hay
+     * ninguno», y de esa ambigüedad salía un Escritorio que entraba vacío y se rellenaba
+     * delante del usuario. Con este campo el cliente se queda en el lienzo hasta que el
+     * arranque termina, y mientras puede DECIR qué hace en vez de estar un segundo y medio
+     * en silencio.
+     *
+     * Es la FASE y no un booleano por lo mismo que `Fase` en el turno: un «espera» sin
+     * decir a qué se parece a estar colgado. Y va como texto ya redactado por el servidor,
+     * que es quien sabe el nombre del entorno al que está llamando.
+     *
+     * Lo que acota la espera es un PLAZO (`MS_DE_PREPARACION`), no la confianza en que el
+     * MCP conteste: si no contesta, se entra igual y el `aviso` dice por qué. Medido: con
+     * un MCP que descarta paquetes, sin plazo el lienzo se queda para siempre.
+     */
+    preparando?: string;
+    proveedores: {
+        id: string;
+        nombre: string;
+    }[];
+    entornos: OpcionDeEntorno[];
+    /**
+     * Los entornos REGISTRADOS de verdad (`settings.json`), que no son los OFRECIDOS de
+     * `entornos` —esa es la lista fija de los dos oficiales más «otro», y sirve para
+     * prerrellenar la URL del alta—. Hacía falta desde que el registro deduce la
+     * identidad del host: un on-premise registrado no aparece en la ofrecida por ningún
+     * lado, y la barra lateral llevaba enseñando la ofrecida como si fuera ésta.
+     */
+    registrados: EntornoRegistrado[];
+    /**
+     * El id del proyecto ABIERTO ahora mismo, y el de su sesión.
+     *
+     * `proyectoAbierto` (booleano, más abajo) dice SI hay uno; estos dicen CUÁL, que es
+     * otra pregunta y la que necesita la barra para marcar la fila. Se resuelven
+     * comparando la raíz de la consola abierta con la que le tocaría a cada proyecto
+     * (`raizDeProyecto`), no guardando un id aparte: dos fuentes para lo mismo divergen
+     * en cuanto una se olvide de actualizarse.
+     *
+     * `sesionActiva` puede faltar con un proyecto abierto, y no es un fallo: el id de
+     * sesión no existe hasta que se vuelca el primer acto (`ConsolaDeProyecto.sesion`),
+     * así que una sesión recién empezada todavía no tiene nada que marcar — igual que
+     * tampoco aparece en la lista de sesiones guardadas.
+     */
+    proyectoActivo?: string;
+    sesionActiva?: string;
+    /**
+     * Con qué dispositivo trabaja la sesión abierta. Ausente = ninguno elegido.
+     *
+     * Viaja la FOTO y no solo el id porque los ids no son estables —`emulator-5554` es un
+     * puerto, y un teléfono se desenchufa—: al reabrir una sesión, el selector puede decir
+     * «iPhone 16 · no está ahora» en vez de un serial crudo o nada. Si está a mano AHORA
+     * no se manda: eso lo resuelve el cliente contra la última medida, que es la única que
+     * lo sabe en este instante.
+     */
+    dispositivoActivo?: {
+        id: string;
+        nombre: string;
+        plataforma: "android" | "ios";
+        clase: "emulador" | "simulador" | "fisico";
+    };
+    /**
+     * La sesión abierta es una RELECTURA: se reabrió y del hilo no queda memoria
+     * (`ConsolaDeProyecto.historica`, que lo PREGUNTA al checkpointer del proyecto en vez
+     * de darlo por hecho — una sesión con checkpoint continúa y no lleva esta marca; la
+     * llevan las de antes de que hubiera checkpointer y aquellas cuyo primer turno nunca
+     * llegó a correr). Deja de serlo en el primer turno nuevo,
+     * y el alta se reanuncia en ese flanco. Solo viaja cuando es cierto: ausente es «no».
+     * Sin esto el cliente pintaba una conversación y un compositor activo como si se
+     * pudiera seguir hablando, que es lo que el propio `CLAUDE.md` dice que no pasa.
+     */
+    historica?: boolean;
+    /**
+     * El modo de escritura de la SESIÓN abierta: `supervisado` (cada escritura con su
+     * diff) o `autonomo` (se aplican solas). Ver `core/modoDeEscritura.ts`.
+     *
+     * **Ausente = no hay sesión abierta**, y por eso la pastilla no se pinta: un control
+     * sin dato detrás no se pinta. Nunca significa «supervisado» — una sesión abierta
+     * siempre trae el suyo, porque el servidor resuelve la omisión antes de emitir.
+     *
+     * Viaja en el alta y no solo en el aviso del turno porque quien se sienta hoy tiene
+     * que saber en qué modo está ANTES de pedir nada, no después con los ficheros ya
+     * cambiados. Y viaja el MODO y no un booleano porque es lo que la pastilla pinta.
+     */
+    modoDeEscritura?: "supervisado" | "autonomo";
+    /**
+     * Lo que YA estaba sin commitear en el proyecto cuando se abrió esta consola
+     * (`agent/sesiones/gitSync.ts#trabajoSinCommitear`, medido en el instante de abrir).
+     *
+     * Ausente = no hay nada que decir, y son las tres respuestas que se callan a
+     * propósito: el árbol estaba limpio, no hay git con qué mirar (todo proyecto
+     * OFFLINE), o la medida falló. Ninguna de las tres es un aviso.
+     *
+     * Va la lista y no un número: quien lo lee tiene que poder reconocer si eso es suyo,
+     * de otra sesión o de una tarea, y un contador a secas es el aviso que enseña a
+     * ignorar los avisos. `ficheros` viene ACOTADA —el alta se reemite en los dos flancos
+     * de cada turno y la frase no puede llevar trescientos nombres— y `total` es la cifra
+     * entera, que es lo que impide leer los que caben como si fueran todos.
+     *
+     * La medida es del instante de ABRIR y no cambia con los reanuncios, a propósito: así
+     * no puede contar como «de otro» lo que esta misma sesión —o esta tarea— acabe de
+     * escribir.
+     */
+    trabajoAlAbrir?: {
+        ficheros: string[];
+        total: number;
+    };
+    /**
+     * De qué entorno son los `proyectos` de este mensaje. Ausente = todavía de ninguno
+     * (nadie ha elegido y no había ninguno registrado que poblar). El cliente lo NECESITA
+     * para no tener que asumir «el primero de la lista», que es lo que hacía y era una
+     * suposición que se rompía en cuanto había dos.
+     */
+    entornoActivo?: string;
+    /**
+     * Los proyectos del entorno, con las SESIONES que ya tiene su copia local (vacío si
+     * no se ha bajado nunca). Van en el mismo mensaje porque la barra los pinta juntos:
+     * un proyecto sin sus sesiones es una fila que no se puede abrir por donde se dejó.
+     */
+    proyectos: {
+        id: string;
+        nombre: string;
+        /**
+         * Compartido CONTIGO por otra persona (`shared` de `studio_list_projects`).
+         * **Ausente no es «es tuyo»**: es que el servidor no lo dijo, y entonces no se
+         * pinta etiqueta ninguna — afirmar que todos son propios porque un endpoint viejo
+         * calló sería la clase de dato inventado que esta consola no consiente.
+         *
+         * Es un booleano y NO el correo del propietario, que viaja en la misma respuesta
+         * (`suser`): para distinguir lo propio de lo compartido basta con esto, y quién lo
+         * compartió es un dato de una persona que esta pantalla no necesita.
+         */
+        compartido?: boolean;
+        /** Fecha ISO del último acceso (`last` de `studio_list_projects`). Ausente = no
+         *  consta — no todos los proyectos lo traen. */
+        ultimoAcceso?: string;
+        sesiones?: SesionDelCable[];
+        /** La copia local YA existe: se puede abrir sin bajar nada ni preguntar rama. */
+        local?: boolean;
+        /** La rama de la que se bajó la copia local. Ausente = sin copia, o no consta. */
+        rama?: string;
+        /**
+         * La copia local tiene un icono de app que se puede enseñar (`app.ini`), servido por
+         * `RUTA_ICONO_DEL_PROYECTO`. Un booleano y no la ruta: ninguna ruta sale del host.
+         * Ausente = sin copia, sin icono, o no consta; la barra pinta entonces la carpeta.
+         */
+        icono?: true;
+        /**
+         * Alguna sesión de este proyecto tiene un turno EN MARCHA ahora mismo.
+         *
+         * No se DERIVA de `sesiones[].trabajando`, y ahí está el motivo de que exista: una
+         * sesión nueva no tiene fila en el índice hasta que vuelca su primer acto —o sea al
+         * final del turno—, así que el caso más común (abrir, pedir algo, irse a otro
+         * proyecto) no habría marcado ni la fila ni el proyecto, y en la barra no se vería
+         * nada en ninguna parte.
+         *
+         * De aquí cuelga además que las OTRAS sesiones de ese proyecto no se puedan abrir
+         * mientras dure: una copia de trabajo no aguanta dos conversaciones, y el servidor
+         * lo declina (`motivoDeProyectoTrabajando`). Decirlo antes del clic es lo que evita
+         * el botón muerto.
+         */
+        trabajando?: true;
+    }[];
+    ramas: string[];
+    /** El id del proyecto del que son las `ramas`. Ausente = no hay ramas, o no consta. */
+    ramasDe?: string;
+    /**
+     * Qué falló en el paso anterior. Ausente = no falló nada.
+     *
+     * Viaja EN el alta y no solo como acto porque el fallo pertenece al paso que lo
+     * produjo. Medido en el navegador: el acto de sistema aterriza en la Trayectoria —la
+     * pestaña que el usuario no está mirando— mientras el wizard repinta el mismo paso
+     * sin una palabra, que es exactamente el fallo mudo que se quería quitar.
+     */
+    aviso?: string;
+    /**
+     * El saludo (`agent/config/persona.ts#nombreDePersona`). Viaja SUELTO en este mensaje, no
+     * dentro de ningún acto: `Bienvenida.tsx` lo pinta y nada más, así que no entra en
+     * el `.jsonl` de una sesión ni en el transcript. Ausente = sin nombre que saludar.
+     */
+    nombre?: string;
+    /**
+     * Si hay un proyecto abierto AHORA MISMO en esta conexión. Hace falta desde que el
+     * paso de proyecto salió del alta: antes, `pasos: []` solo pasaba con un proyecto
+     * ya abierto, y esa implicación bastaba para que el cliente supiera si pintar la
+     * maqueta completa o el alta. Ahora `pasos: []` pasa en cuanto cuenta y entorno
+     * están resueltos, CON o SIN proyecto abierto —el proyecto se elige en la barra—,
+     * así que hace falta decirlo aparte para que el centro sepa si esperar una elección
+     * o pintar la sesión de verdad.
+     */
+    proyectoAbierto: boolean;
+    /**
+     * El `modo` del `.xonecode/config.json` del proyecto abierto, para la pastilla de
+     * la cabecera. **Ausente cuando no se sabe**, y eso incluye tres casos que no se
+     * distinguen desde aquí: no hay proyecto abierto, el fichero no se pudo leer, o
+     * lleva un valor que no es ninguno de los dos. Ausente NO significa «offline»:
+     * pintar «offline» sobre un fichero que no se pudo leer sería afirmar lo que no se
+     * sabe, que es la misma clase de mentira que un alias de color inventado. Es lo
+     * único que se le extrae al config: ni la URL del entorno, ni el proyecto, ni la
+     * rama, que son datos del despliegue y no tienen por qué acabar en el transcript.
+     */
+    modo?: "offline" | "cloud";
+}
+/** El ÚNICO mensaje que lleva contenido de fichero: es el paso donde se DECIDE sobre él. */
+ | {
+    clase: "aprobacion";
+    pendientes: PendienteDeAprobacion[];
+    ficheros: Record<string, string>;
+    diffs: Record<string, LineaDeDiff[]>;
+};
+/**
+ * Un proveedor, tal y como lo ve el selector de modelos.
+ *
+ * `credencial` es literal y tiene TRES valores porque hay tres cosas distintas que decir:
+ * «puesta» solo si la credencial está confirmada, «falta» solo si se sabe que no está, y
+ * «nativa» para quien no necesita ninguna (Ollama local). Pintarle un punto rojo a Ollama
+ * sería inventarse un problema, y uno verde, un permiso.
+ */
+/**
+ * Un entorno ya registrado, con la elección de qué proyectos suyos se enseñan.
+ *
+ * `proyectos` AUSENTE no es «ninguno»: es que nadie lo ha dicho, y entonces la barra aplica
+ * su omisión (los primeros `PROYECTOS_POR_OMISION`). Una lista vacía sí es una elección.
+ */
+export interface EntornoRegistrado extends OpcionDeEntorno {
+    proyectos?: string[];
+    /** Los fijados arriba de la barra (`Entorno.fijados`). Ausente = ninguno. */
+    fijados?: string[];
+    /** Cuántas carpetas de proyecto tiene en el workspace. Ausente = no se pudo mirar, que no
+     *  es cero: con cero la casilla de borrarlas no se ofrece. */
+    copias?: number;
+}
+/**
+ * Un proyecto de un entorno, para elegir si se enseña. Es menos de lo que lleva un proyecto
+ * del `alta`: sin `sesiones`, porque una sesión es de la COPIA LOCAL y aquí solo se decide
+ * qué aparece en la barra. Lo que no hace falta, no viaja.
+ */
+export interface ProyectoDeEntorno {
+    id: string;
+    nombre: string;
+    /** Compartido contigo por otra persona. Ausente no es «es tuyo»: es que no se dijo. */
+    compartido?: boolean;
+    /** Fecha ISO del último acceso (`last` de `studio_list_projects`). Ausente = no consta. */
+    ultimoAcceso?: string;
+}
+/** Un fichero de la sesión. `mas`/`menos` faltan en un binario: git no cuenta líneas ahí, y
+ *  poner cero diría que no cambió nada. */
+export interface FicheroTocado {
+    ruta: string;
+    clase: "nuevo" | "modificado" | "borrado";
+    mas?: number;
+    menos?: number;
+    /** Hay cambios en este fichero que nadie ha commiteado, así que no se pueden atribuir a
+     *  esta sesión ni a otra (`agent/sesiones/sesionGit.ts#FicheroDeSesion`). Viaja para poder DECIRLO
+     *  en la fila: el turno en vuelo commitea al terminar, y esta es la única marca que
+     *  distingue «lo escribió esta sesión» de «esto está aquí y no consta de quién es». */
+    sinCommitear?: true;
+    /**
+     * ¿Sigue pendiente de subir a CloudStudio? Lo decide el SERVIDOR en la misma foto que la
+     * lista (`arranque.ts#marcarPendientes`), no el cliente cruzando dos mensajes que llegan en
+     * momentos distintos. AUSENTE = no se pudo medir (proyecto sin CloudStudio, o la medida
+     * falló), y entonces Revisión enseña todo en vez de esconder sobre una pregunta sin contestar.
+     */
+    pendiente?: boolean;
+}
+/** Un fichero del proyecto tal como viaja. Redeclarado en `apps/web/src/tipos.ts`. */
+export interface FicheroDelProyecto {
+    /** La ruta tal como se pidió, nunca la resuelta en disco. */
+    ruta: string;
+    texto?: string;
+    recortado: boolean;
+    binario: boolean;
+    bytes: number;
+    codificacion?: "utf-8" | "latin1";
+    /**
+     * El MIME, solo si la ruta es una imagen que el visor sabe pintar. Viaja aunque los bytes
+     * NO vengan: es lo que distingue «una imagen demasiado grande» de «un binario cualquiera».
+     */
+    mime?: string;
+    /** La imagen entera, si cupo en el tope. Nunca recortada: media imagen no se abre. */
+    base64?: string;
+    /**
+     * Solo en un markdown que enlaza imágenes del proyecto: el texto con esos enlaces apuntando a la
+     * ruta que las sirve, para la VISTA (`arbolDeProyecto.ts#vistaDeMarkdown`). `texto` es la fuente.
+     */
+    vista?: string;
+    /**
+     * El sha256 de los bytes en disco, solo con el texto ENTERO en UTF-8
+     * (`arbolDeProyecto.ts#huellaDeContenido`). Vuelve al guardar: si el disco ya no coincide, no se
+     * escribe nada.
+     */
+    huella?: string;
+    error?: string;
+}
+/**
+ * La versión de un fichero contra la que el editor pinta sus marcas (`agent/sesiones/baseDeFichero.ts`).
+ * `texto` = había una versión; `vacio` = en esa base no existía; `sinBase` = no hay con qué comparar,
+ * y por qué. Redeclarado en `apps/web/src/tipos.ts`.
+ */
+export interface BaseDelFichero {
+    ruta: string;
+    base: "sesion" | "commit";
+    texto?: string;
+    vacio?: true;
+    sinBase?: string;
+}
+/**
+ * El estado de sincronización del proyecto abierto (pestaña CloudStudio): de qué rama es y
+ * cuántos ficheros quedan por subir. Redeclarado en `apps/web/src/tipos.ts`.
+ *
+ * **`proyecto` y `rama` ausentes no son «cero pendientes»**: son «este proyecto no está dado
+ * de alta en CloudStudio» —o le falta la rama del alta—, que es un estado y no un contador a
+ * cero. Son las dos preguntas que la pestaña tiene que poder contestar por separado, y por
+ * eso no se rellenan con cadenas vacías.
+ *
+ * `pendientes` se mide contra la ref de seguimiento que dejó la última descarga
+ * (`refs/remotes/cloudstudio/<rama>`), que es LA MISMA cuenta que da `/sync estado` —
+ * `agent/sesiones/gitSync.ts#cambiosPendientes`, el mismo que decide qué sube el plan—. `error` solo
+ * cuando no se pudo medir, y entonces `pendientes` no viene: un cero que nadie ha contado es
+ * la cifra inventada de siempre.
+ *
+ * Es interfaz con nombre y no campos sueltos dentro de la unión por lo de siempre: los
+ * campos de un mensaje EMBEBIDO en otro no se pueden comparar con `camposDeInterfaz`, y ese
+ * es el test que vigila que el cliente no se quede con la mitad del contrato.
+ */
+/**
+ * La foto del resumen de un proyecto, tal como vuelve en la respuesta de `accion: "resumen"`.
+ *
+ * `tareas` son los IDS de las tareas de la cola cuya raíz es la de este proyecto: la tarea no
+ * lleva su entorno, así que filtrarla por id en el cliente dejaría pasar la de otro entorno.
+ * `sync` es la MISMA medida que la banda de CloudStudio (`lecturaDeSync`), y AUSENTE cuando no
+ * hay copia bajada — que no es lo mismo que «nada por subir».
+ */
+export interface FotoDelResumen {
+    tareas: string[];
+    sync?: EstadoDeSync;
+    /**
+     * El modo con que nacen las sesiones nuevas de ESTE proyecto (IXCODE-31). Presente solo con
+     * copia bajada —sin ella no hay `config.json` que lo guarde—; `proyecto` ausente dentro es
+     * «como el global», que no es lo mismo que no saberlo.
+     */
+    modoDeEscritura?: {
+        proyecto?: "supervisado" | "autonomo";
+    };
+}
+export interface EstadoDeSync {
+    proyecto?: string;
+    rama?: string;
+    pendientes?: number;
+    /**
+     * De los `pendientes`, cuántos tocó ESTA sesión.
+     *
+     * Existe porque `pendientes` se mide contra la rama y la lista de Revisión contra la
+     * sesión: son dos referencias distintas, así que las dos cifras pueden no tocarse. Medido
+     * en el AppDemo del usuario el 16-09-2026, mirando la pantalla: la banda decía «3 ficheros
+     * por subir» y la sesión de delante había hecho UN cambio —borrar un fichero que otra
+     * había creado, así que el alta y el borrado se anulaban— que no entraba en el plan NI
+     * PODÍA ENTRAR. Los dos números no discrepaban: eran de dos trabajos sin nada en común.
+     *
+     * **Ausente no es cero, y la diferencia es la de siempre.** Ausente = no se puede atribuir
+     * (sin sesión abierta, o una sesión sin sello, que es la que solo se puede medir «desde que
+     * abriste» y ahí dentro está el trabajo de cualquiera). Cero = se atribuyó y NINGUNO de los
+     * pendientes es suyo, que es un hecho medido y justo el que hace falta para entender la
+     * pantalla. Rellenar lo ausente con un cero diría «esta sesión no ha hecho nada» sobre una
+     * sesión de la que no se sabe qué hizo.
+     */
+    deLaSesion?: number;
+    error?: string;
+}
+/**
+ * Una tarea tal como viaja. **Sin la raíz del proyecto**: viajan su id y su nombre, que es
+ * lo que la interfaz necesita — la ruta se queda en el host, igual que `Herramienta.ruta` de
+ * `xcrun`/`devicectl` (`adb`/`emulator` sí cruzan, ver `InformeDeDispositivosDelCable`).
+ * Redeclarada en `apps/web/src/tipos.ts`.
+ */
+export interface TareaDelCable {
+    id: string;
+    proyecto: string;
+    proyectoNombre: string;
+    titulo: string;
+    peticion: string;
+    encargo: string;
+    adjuntos: {
+        nombre: string;
+        bytes: number;
+        mime?: string;
+    }[];
+    estado: "nuevo" | "en-proceso" | "requiere-atencion" | "terminada";
+    motivo?: string;
+    sesion?: string;
+    /** El id de la tarea ANTERIOR de su cadena (`Tarea.tras`): esta no arranca hasta que aquella termine. */
+    tras?: string;
+    creada: string;
+    empezada?: string;
+    acabada?: string;
+    /**
+     * Lo que la tarea AUTORIZÓ escribir sin que nadie lo aprobara, con ruta relativa al
+     * proyecto (`core/tareas.ts#Tarea.autorizadas`). **No es lo mismo que lo que cambió en el
+     * disco** —una ruta que las guardas de sitio rechazan sale aquí sin haberse escrito—: la
+     * verdad sobre el disco la tiene la pestaña Revisión, con la ref de esta `sesion`. Ausente
+     * = no consta (la tarea no llegó a correr un turno); `[]` = corrió y no autorizó ninguna.
+     */
+    autorizadas?: string[];
+    /**
+     * El historial de lo que el desarrollador contestó mientras la tarea esperaba feedback
+     * (`core/tareas.ts#Tarea.feedback`). Ausente = nunca se le pidió nada. `consumido` dice
+     * si ya se le mandó al agente en un turno.
+     */
+    feedback?: {
+        texto: string;
+        creado: string;
+        consumido: boolean;
+    }[];
+    /**
+     * El veredicto del juez de QA (`core/entrega.ts#VeredictoDeTarea`), y con él la
+     * SALVEDAD: con qué condición de menos se entregó.
+     *
+     * **Sin esto, «Terminada» no distingue tres cosas distintas** —F1 de la revisión final—:
+     * que el juez la aprobó con el verificador en verde, que se entregó SIN NADA que
+     * verificar (una tarea de solo lectura: la salvedad), y —con `terminadaAMano`— que la dio
+     * por buena una persona. El campo se guardaba en el índice de tareas desde que existe la
+     * puerta de entrega y se quedaba en el host: la mitad del contrato en `core/` y en disco,
+     * y la mitad que una persona lee sin cablear.
+     *
+     * **Y viaja completo porque no puede llevar nada más que texto para leer.** Medido en
+     * `agent/tareas/juezDeTarea.ts#promptDelJuez`: el juez recibe el encargo, las rutas RELATIVAS de
+     * lo autorizado y los hallazgos del verificador (código, fichero relativo, línea,
+     * mensaje) — no hay un solo `readFile` en ese módulo, así que su prosa no puede citar el
+     * contenido de un fichero ni una ruta de la máquina. El `resumen` ya cruzaba el cable de
+     * todos modos: para un veredicto rojo va dentro del `motivo`.
+     */
+    veredicto?: {
+        veredicto: "verde" | "rojo" | "indeterminado";
+        resumen: string;
+        hallazgos?: string[];
+        salvedad?: string;
+    };
+    /**
+     * La dio por buena una PERSONA («Dar por bueno»), no la puerta de entrega
+     * (`core/tareas.ts#Tarea.terminadaAMano`). Ausente = no consta.
+     */
+    terminadaAMano?: boolean;
+    /**
+     * Con qué se CERRÓ (`core/entrega.ts#cierreDeLaEntrega`): lo crítico y las observaciones, lo que dice el comentario
+     * de cierre del ticket. Ausente = se entregó sin nada que decir (o se cerró antes de que existiera).
+     */
+    cierre?: {
+        criticos: string[];
+        observaciones: string[];
+    };
+    /**
+     * El ticket del gestor de tareas en el que vive (`core/tareas.ts#TicketDeTarea`). Cruzan la CLAVE, el conector (de él
+     * sale el nombre que se enseña: «Jira»), el enlace y el aviso de lo último que no se pudo escribir; el `sitio` y el
+     * `proyecto` del gestor se quedan en el host, como los de una sesión ligada a un ticket.
+     */
+    ticket?: {
+        clave: string;
+        conector: string;
+        url?: string;
+        aviso?: string;
+    };
+    /** La pantalla de Stitch elegida para la tarea: su `name` y su título (no es una ruta de la máquina). */
+    pantallaDeStitch?: {
+        name: string;
+        titulo: string;
+        proyecto?: string;
+    };
+}
+/**
+ * Una `Tarea` del índice traducida a lo que viaja. **La raíz del proyecto se queda aquí.**
+ *
+ * **Vive en este fichero, exportada, y eso es el arreglo de F1.** Era una copia de campos a
+ * mano enterrada en el cierre de `montarRutas` (`arranque.ts`), a mil líneas del tipo que
+ * traduce y dentro de algo que todos sus tests doblan — o sea el patrón de fallo que
+ * `CLAUDE.md` documenta cinco veces en esta misma tanda: «si una regla de producción se
+ * compone dentro de algo que los tests simulan, esa regla no está probada: está escrita».
+ * `veredicto` se cayó aquí y en el store del cliente sin que nada se pusiera rojo. Ahora
+ * `transporte.test.ts` recorre los campos de `Tarea` y exige decisión explícita por cada
+ * uno.
+ *
+ * Campo a campo, y también DENTRO del veredicto: un `...tarea.veredicto` dejaría pasar sin
+ * nombrar el campo que alguien le añada mañana a `VeredictoDeTarea`.
+ */
+export declare function filaDeTarea(t: Tarea): TareaDelCable;
+export interface ProveedorDeModelos {
+    id: string;
+    /**
+     * Cómo se ESCRIBE, que no es el id. Lo pone el servidor (`core/modelos.ts#nombreDeProveedor`)
+     * y no el cliente: capitalizar un id en el navegador daría «Xai» y «Ollama-cloud».
+     */
+    nombre: string;
+    credencial: "puesta" | "falta" | "nativa";
+    /**
+     * La credencial está en `auth.json` — o sea, es NUESTRA y se puede borrar desde la
+     * interfaz. Una que solo viene del entorno no lleva esta marca: desexportar la shell de
+     * nadie no está a nuestro alcance, y ofrecer un botón que no puede cumplir sería peor
+     * que no ofrecerlo. Misma disciplina que el harness de DeepSeek, que solo retira la
+     * credencial cuya referencia puede demostrar suya.
+     */
+    enFichero?: boolean;
+    /** Lo declaró el usuario (`custom:<slug>`), no viene de serie. */
+    personalizado?: boolean;
+    /** Su URL base, SOLO en los personalizados: es lo que tecleó el usuario y lo que hay que
+     *  ver al lado de su clave para saber a dónde va. Los de serie la tienen en el repo. */
+    baseUrl?: string;
+    /** Ausente = todavía no se ha consultado su catálogo. Vacío = lo dijo y no ofrece nada. */
+    /**
+     * Los modelos que sirve, con los niveles de ESFUERZO que admite cada uno.
+     *
+     * `esfuerzos` lo calcula el SERVIDOR con la tabla de `core/esfuerzo.ts`: la frontera
+     * prohíbe que el cliente importe de `src/`, y una copia declarada de una tabla que crece
+     * cada vez que se mide un modelo nuevo es un sitio donde quedarse viejo en silencio.
+     * Ausente = ese modelo no admite ninguno, y entonces no se pinta el control.
+     */
+    modelos?: {
+        id: string;
+        nombre?: string;
+        esfuerzos?: Esfuerzo[];
+    }[];
+    /** El catálogo de ESTE proveedor falló. Nunca lleva la clave ni el cuerpo remoto. */
+    error?: string;
+}
+export type MensajeDelCliente = 
+/**
+ * `detener`: el botón DETENER y replanificar — `texto` puede ir vacío.
+ * `adjuntos` (IXCODE-7): los NOMBRES que ya se subieron con `POST /adjunto?para=sesion` antes
+ * de mandar este mensaje — nunca bytes por el cable, el molde de siempre.
+ */
+{
+    clase: "prosa";
+    texto: string;
+    detener?: true;
+    adjuntos?: string[];
+}
+/**
+ * «Ponme este modelo», dicho por un control de la interfaz: `proveedor/modelo` y nada
+ * más.
+ *
+ * El cliente NO manda comandos. Podría mandar la prosa `/modelo <id>` —es el mismo
+ * efecto— y estuvo escrito así un rato, pero eso son dos mentiras pequeñas: el transcript
+ * se apunta un acto de USUARIO que nadie tecleó (y de ahí sale el título de la sesión), y
+ * la interfaz queda hablando en la sintaxis de otra piel. Lo que viaja es la intención;
+ * CÓMO se aplica es cosa del servidor, y hoy es reusando el manejador de `COMANDOS` que
+ * ya comparten el terminal y la TUI — la función se comparte, la sintaxis no se exporta.
+ */
+ | {
+    clase: "modelo";
+    id: string;
+}
+/**
+ * Cuánto razona el modelo de esta sesión. `nivel` ausente = quitarlo.
+ *
+ * La INTENCIÓN y no la sintaxis, como el modelo: el servidor la aplica encolando el
+ * manejador de `/esfuerzo` que ya comparten el terminal y la TUI. Mandar la prosa
+ * apuntaría en el transcript un acto de usuario que nadie tecleó.
+ *
+ * El nivel NO se comprueba aquí contra el modelo en vigor: se guarda en la sesión y
+ * `construirModelo` lo omite mientras no aplique. Así, cambiar de modelo a uno que sí lo
+ * admite lo recupera solo, en vez de obligar a volver a elegirlo.
+ */
+ | {
+    clase: "esfuerzo";
+    nivel?: Esfuerzo;
+}
+/**
+ * El MODO DE ESCRITURA de la sesión abierta: supervisado o autónomo.
+ *
+ * La INTENCIÓN y no la sintaxis, como el modelo y el esfuerzo: el servidor la aplica
+ * encolando el manejador de `/aprobacion` que ya comparten el terminal y la TUI. Un
+ * segundo camino para lo mismo es donde el hueco de política podría reabrirse.
+ *
+ * Lo que el modo gobierna son las escrituras LOCALES: la subida a CloudStudio conserva
+ * su plan y su aprobación en los dos modos, y las guardas de RUTA no se tocan.
+ */
+ | {
+    clase: "modoDeEscritura";
+    modo: "supervisado" | "autonomo";
+}
+/**
+ * Abrir una sesión de un proyecto: la que se nombra, o una NUEVA si no se nombra ninguna.
+ *
+ * Es la acción de la barra lateral, y no pasa por el alta: si la copia local ya existe no
+ * hay nada que dar de alta ni rama que preguntar — se abre y ya. Si no existe, el
+ * servidor contesta con las ramas por el camino del alta, que es el que sabe bajarla.
+ */
+ | {
+    clase: "sesion";
+    proyecto: string;
+    sesion?: string;
+}
+/**
+ * Lo que se hace con una sesión GUARDADA desde el menú de su fila: borrarla o ponerle
+ * nombre. Va aparte de abrir (arriba) y no como un campo opcional de aquel, porque son
+ * verbos distintos con consecuencias distintas: uno abre y los otros dos escriben en el
+ * índice del proyecto — y borrar, además, puede cerrar la consola si es la sesión abierta.
+ *
+ * `titulo` solo lo lleva «renombrar», y vacío se rechaza en el servidor: dejar el título en
+ * blanco devolvería la sesión al régimen automático y el siguiente turno la rebautizaría
+ * con la primera frase, borrando en silencio el nombre que puso una persona.
+ */
+ | {
+    clase: "sesionAccion";
+    accion: "borrar";
+    proyecto: string;
+    sesion: string;
+} | {
+    clase: "sesionAccion";
+    accion: "renombrar";
+    proyecto: string;
+    sesion: string;
+    titulo: string;
+}
+/** Qué proyectos de un entorno se enseñan en la barra. Lista vacía = ninguno, que es una
+ *  elección; para volver a la omisión no hay mensaje, porque no hay «deshacer» que pedir. */
+ | {
+    clase: "entorno";
+    accion: "visibles";
+    entorno: string;
+    proyectos: string[];
+}
+/** Qué proyectos de un entorno van FIJADOS arriba de la barra, en su grupo. La lista
+ *  ENTERA, no un «fija este»: el cliente la compone y el servidor la guarda tal cual, el
+ *  mismo trato que `visibles`. Vacía = ninguno fijado. */
+ | {
+    clase: "entorno";
+    accion: "fijados";
+    entorno: string;
+    proyectos: string[];
+}
+/**
+ * Borrar la COPIA LOCAL de un proyecto del entorno activo: vuelve a «sin descargar», y con
+ * ella se van sus sesiones, su historial, sus artefactos y lo que no se haya subido.
+ *
+ * `proyecto` es el ID del listado, no una ruta: la carpeta la compone el servidor a partir
+ * del nombre que ÉL tiene para ese id. Contesta **409 con `{ motivo }`** si no se puede
+ * ahora (un turno en vuelo, una tarea de fondo sin terminar), igual que `olvidar`.
+ */
+ | {
+    clase: "copiaLocal";
+    accion: "borrar";
+    proyecto: string;
+}
+/** Abrir la carpeta de la copia local en el explorador de ficheros de la máquina del
+ *  servidor. Mismo trato que `borrar`: el ID, nunca una ruta; 409 con `{ motivo }` si no. */
+ | {
+    clase: "copiaLocal";
+    accion: "abrirCarpeta";
+    proyecto: string;
+}
+/** Pedir la FOTO del resumen del proyecto. Contesta 200 con un `FotoDelResumen` en la propia
+ *  respuesta, o 409 con `{ motivo }`. Mismo trato que `borrar`: el ID, nunca una ruta. */
+ | {
+    clase: "copiaLocal";
+    accion: "resumen";
+    proyecto: string;
+}
+/** Fijar —o quitar, sin `modo`— el modo con que nacen las sesiones nuevas de este proyecto
+ *  (IXCODE-31). 200 con `{ proyecto? }`, 409 con `{ motivo }` sin copia o con un id ajeno, y
+ *  400 con un modo que no existe. Mismo trato que `resumen`: el ID, nunca una ruta. */
+ | {
+    clase: "copiaLocal";
+    accion: "modoDeEscritura";
+    proyecto: string;
+    modo?: "supervisado" | "autonomo";
+}
+/** Fijar el modo con que nacen las sesiones nuevas en cualquier proyecto (Ajustes > General). */
+ | {
+    clase: "modoPorDefecto";
+    modo: "supervisado" | "autonomo";
+}
+/** Fijar —o quitar, sin `id`— el aparato de las sesiones nuevas (IXCODE-51). Solo el ID: el resto
+ *  sale de la última MEDIDA, como en la pastilla. */
+ | {
+    clase: "dispositivoPorDefecto";
+    id?: string;
+}
+/** LEER una conversación sin abrirle consola (IXCODE-36): 200 con `{actos}`, o 409 con `{motivo}`. */
+ | {
+    clase: "leerSesion";
+    proyecto: string;
+    sesion: string;
+}
+/** La pestaña Soporte: chats y tareas del proyecto con su análisis previo (`soporte.ts`). */
+ | {
+    clase: "soporte";
+    accion: "listar";
+    proyecto: string;
+}
+/**
+ * Quitar un entorno registrado. El servidor contesta **409 con `{ motivo }`** si no se puede
+ * ahora (un proyecto suyo abierto, una tarea sin terminar): la negativa vive allí, y así el
+ * cliente la enseña sin llevar una copia de la regla. Sus copias locales se quedan.
+ */
+ | {
+    clase: "entorno";
+    accion: "olvidar";
+    entorno: string;
+    /** Borrar además `<workspace>/<entorno>/` entera. Solo con la casilla marcada y el
+     *  nombre escrito; ausente = las copias se quedan. */
+    borrarCopias?: boolean;
+}
+/**
+ * Ponerle NOMBRE a un entorno registrado: el alias con el que se lee en la barra y en su
+ * pestaña de Ajustes. Se escribe a mano porque hasta ahora el nombre lo deducía el
+ * servidor al conectarse, y el «Otro» de un on-premise se quedaba con su host por nombre
+ * para siempre.
+ *
+ * **El `id` NO viaja**: es lo que identifica al entorno —segmento de su carpeta en el
+ * workspace, hueco de sus credenciales— y renombrar no lo toca, así que el cable no puede
+ * ni sugerir que cambie.
+ *
+ * El servidor contesta **409 con `{ motivo }`** si el nombre no vale, igual que `olvidar`.
+ * La regla es SUYA (`core/settings.ts#motivoDeNombreDeEntornoInaceptable`) y la vuelve a
+ * aplicar aunque el cliente ya la tenga —la frontera prohíbe compartir el módulo, así que
+ * `Ajustes.tsx` lleva su copia DECLARADA, para poder avisar mientras se teclea—: la copia
+ * es comodidad, y la negativa que manda es esta, con su motivo en la mano. Dos entornos con
+ * el mismo nombre SÍ se admiten; que se repitan se advierte en la pantalla, que es donde se
+ * ven los dos.
+ */
+ | {
+    clase: "entorno";
+    accion: "renombrar";
+    entorno: string;
+    nombre: string;
+}
+/** Cambiar de entorno ACTIVO: el de cuyos proyectos se habla. Trae su listado consigo. */
+ | {
+    clase: "entorno";
+    accion: "activo";
+    entorno: string;
+}
+/**
+ * «Dime qué proyectos tiene ESTE entorno», sin hacerlo activo. Es lo que necesita la
+ * pestaña de un entorno en Ajustes para poder marcar sus casillas, y la diferencia con
+ * `activo` es justo lo que la hace usable: abrir Ajustes a elegir proyectos es MIRAR, y
+ * mudar el entorno activo le cambiaría la barra lateral —y los proyectos de los que se
+ * habla— a quien esté trabajando en otro servidor.
+ *
+ * Se pide al abrir esa pestaña y no antes, por lo mismo que el catálogo de un proveedor
+ * (`clase: "catalogo"`): cada uno es una conexión con CloudStudio (OAuth + `initialize` +
+ * `studio_list_projects`), y consultarlos todos al conectar sería gastar una petición por
+ * entorno para pintar unas casillas que quizá nadie abra. La respuesta es
+ * `proyectosDeEntorno`, con su lista o con su `error`.
+ */
+ | {
+    clase: "entorno";
+    accion: "proyectos";
+    entorno: string;
+}
+/**
+ * La respuesta a una `pregunta`. `seleccion` solo la manda el diálogo de una decisión
+ * `seleccionable` (la subida a CloudStudio): las rutas que la persona dejó marcadas.
+ * Ausente = el plan entero, o una pregunta que no deja elegir.
+ */
+ | {
+    clase: "respuesta";
+    texto: string;
+    seleccion?: string[];
+}
+/**
+ * La respuesta a `seleccionar`. **Sin `id` (o con `id: null`) es CANCELAR**, que es
+ * exactamente lo que `seleccionar` ya devuelve al desconectarse y al vencer su plazo — en
+ * el terminal cancelar es una salida de primera clase («número, Enter cancela»), así que
+ * la web no puede tener menos. Se aprovecha esta clase en vez de añadir otra: el contrato
+ * del cable no crece y la traducción a `undefined` vive en un solo sitio
+ * (`consolaWeb.ts#recibir`). `undefined` viaja como la AUSENCIA del campo, porque
+ * `JSON.stringify` descarta las claves con ese valor; `null` se admite porque es lo que
+ * escribiría un cliente que lo serialice explícitamente, y dice lo mismo.
+ *
+ * Un `id` vacío o desconocido NO es cancelar: es un id que no existe, y así se lo pasa a
+ * quien llamó. Traducirlo aquí a cancelación convertiría el bug de un cliente en un
+ * usuario que se echó atrás.
+ */
+ | {
+    clase: "eleccion";
+    id?: string | null;
+} | {
+    clase: "secreto";
+    valor: string;
+}
+/**
+ * Un paso del alta, resuelto por el wizard. Es UNA clase y no tres porque los tres son
+ * el mismo trámite —el alta— y quien la atiende es un solo sitio (`web/servidor/arranque.ts`);
+ * tres clases obligarían a mantener tres ramas del cable de acuerdo entre sí sin ganar
+ * nada.
+ *
+ * Con `paso` «proyecto» y SIN `rama` no se abre nada: significa «he elegido proyecto,
+ * dime sus ramas», y el servidor contesta con otro mensaje de alta con `ramas` llenas.
+ * Es lo que evita inventarse las ramas del primer proyecto de la lista antes de que
+ * nadie haya elegido — el mismo «lista vacía, no dato inventado» del otro extremo.
+ *
+ * Aquí NO hay campo para la clave de API: el paso de cuenta va por «secreto».
+ */
+ | {
+    clase: "alta";
+    paso: PasoDelVestibulo;
+    entorno?: {
+        id: string;
+        nombre: string;
+        url: string;
+    };
+    proyecto?: string;
+    rama?: string;
+}
+/**
+ * El valor es el `Decision["type"]` que el pendiente declara en `decisionesPermitidas`,
+ * no una respuesta tecleada: el cliente son botones. `consolaWeb` lo traduce a la
+ * respuesta que `interpretAnswer` entiende, en vez de comparar cadenas por su cuenta.
+ */
+/**
+ * «Dime qué modelos sirve este proveedor.» Se pide al abrir el menú de ese proveedor y no
+ * antes: cada uno es una llamada de red. La respuesta es otro mensaje `modelos` con ese
+ * proveedor ya relleno — o con su `error` puesto, que también es una respuesta.
+ */
+ | {
+    clase: "catalogo";
+    proveedor: string;
+}
+/**
+ * Vuelve a mirar qué dispositivos y simuladores hay. La respuesta viaja por el SSE como
+ * `dispositivos`, a todos los clientes: la máquina es la misma para todos.
+ */
+ | {
+    clase: "dispositivos";
+    /**
+     * Con `ajustes` se GUARDAN antes de volver a medir; sin ellos solo se vuelve a medir.
+     * Es el mismo mensaje para las dos cosas porque configurar sin remedir dejaría la
+     * pantalla enseñando la foto de la configuración anterior.
+     */
+    ajustes?: AjustesDeDispositivos;
+    /**
+     * Instala una herramienta que falta, y después se vuelve a medir. El comando NO viaja
+     * del cliente: viaja el NOMBRE de la herramienta y el servidor decide qué lanzar
+     * (`INSTALADORES`, tabla cerrada) — un comando que llegue por el cable es una shell
+     * abierta en la máquina del usuario.
+     */
+    instalar?: NombreDeHerramienta;
+    /**
+     * Abre la carpeta que contiene el binario de esta herramienta en el explorador del
+     * SISTEMA donde corre la consola — el mismo límite que el selector de carpeta del
+     * workspace: con la consola por un túnel, el botón no sirve. Solo `adb`/`emulator`
+     * tienen una ruta que abrir; no vuelve a medir ni cambia ningún estado.
+     */
+    abrirRuta?: NombreDeHerramienta;
+}
+/**
+ * Con qué dispositivo trabaja la sesión abierta. Viaja el ID y nada más: el servidor lo
+ * resuelve contra la última medida y guarda la foto — un nombre que llegue del cliente no
+ * es una fuente sobre la máquina. Sin `id`, se quita la elección.
+ */
+ | {
+    clase: "dispositivo";
+    id?: string;
+}
+/**
+ * «Arranca este AVD.» El nombre y nada más: el servidor comprueba que esté en SU última
+ * medida antes de ejecutar nada, así que por aquí no entra un nombre a ciegas.
+ *
+ * La respuesta es el `dispositivos` de siempre, con la foto nueva y el `arranque` dentro:
+ * arrancar acaba en una medida, no en un acuse.
+ */
+ | {
+    clase: "arrancarEmulador";
+    avd: string;
+}
+/**
+ * «Crea un AVD con este nombre.» El servidor valida el nombre (forma, y que no exista en SU
+ * última medida) antes de lanzar `avdmanager`, y lo cuenta como un paso de receta
+ * (`instalacion` con `receta: "crear-avd"`): comparten el cerrojo, uno a la vez.
+ */
+ | {
+    clase: "crearEmulador";
+    nombre: string;
+    base?: string;
+    conDatos?: boolean;
+}
+/** Elimina un AVD por su nombre: el servidor lo comprueba contra SU medida (existe, no es el único, está apagado). */
+ | {
+    clase: "eliminarEmulador";
+    avd: string;
+}
+/**
+ * Lo de UN AVD: el puerto local del túnel de hotswap y si arranca sin ventana. El AVD tiene
+ * que estar en la última medida y el puerto no puede ser de otro; la respuesta es el
+ * `dispositivos` de siempre, con los `ajustes` nuevos.
+ */
+ | {
+    clase: "ajusteDeAvd";
+    avd: string;
+    puerto?: number;
+    sinVentana?: boolean;
+}
+/** «Para este emulador.» El ID de la medida, y solo si es un emulador; después se remide. */
+ | {
+    clase: "pararEmulador";
+    id: string;
+}
+/**
+ * VERIFICAR la conexión con un dispositivo: hablarle y esperar respuesta.
+ *
+ * Viaja el ID y nada más, la misma regla que `dispositivo`: el servidor lo resuelve contra
+ * la última MEDIDA y de ahí saca la plataforma y la clase, que son las que deciden qué
+ * comando se lanza. Un id que no esté en la medida se ignora — es una foto vieja del
+ * cliente, no un error.
+ *
+ * **Es un mensaje propio y no un campo de `dispositivos`**, aunque las dos cosas acaben
+ * emitiendo el informe: `dispositivos` significa «vuelve a MEDIR», y una medida nueva se
+ * lleva por construcción todas las verificaciones —viven con la foto—. O sea que meterlo
+ * ahí habría borrado la verificación que se acaba de hacer.
+ */
+ | {
+    clase: "conexion";
+    id: string;
+}
+/**
+ * La credencial de un proveedor, desde la ventana de ajustes.
+ *
+ * «pedir» hace que el servidor PREGUNTE por ella (`leerSecreto`), así que la clave sigue
+ * viajando por el ÚNICO mensaje del cable que la lleva («secreto») y este mensaje no la
+ * toca. «borrar» la quita de `auth.json`.
+ *
+ * Podría haber viajado como la prosa `/provider <id>`, que es el mismo diálogo, pero esa
+ * ruta necesita el lazo de `correrConsola` — y el lazo solo existe con un proyecto
+ * abierto. La ventana de ajustes se abre antes, así que tiene su propio mensaje.
+ */
+ | {
+    clase: "credencial";
+    accion: "pedir" | "borrar";
+    proveedor: string;
+}
+/**
+ * Dar de alta o retirar un proveedor de modelos PERSONALIZADO: un endpoint compatible
+ * con OpenAI que declara el usuario.
+ *
+ * La clave NO viaja aquí. El alta escribe nombre y URL en el `config.json` global, y la
+ * credencial se pone después con el mismo `{clase:"credencial", accion:"pedir"}` que los
+ * de serie — o sea, por el único mensaje del cable que la lleva. Que sean dos pasos y no
+ * un formulario de tres campos es deliberado: un tercer campo con la clave dentro sería
+ * un segundo camino para lo mismo, y el que menos garantías da.
+ *
+ * El identificador no se teclea: lo deriva el servidor del nombre
+ * (`core/modelos.ts#slugDesdeNombre`). La baja va por ese identificador, que es lo que
+ * la fila conoce.
+ */
+ | {
+    clase: "proveedor";
+    accion: "alta";
+    nombre: string;
+    baseUrl: string;
+} | {
+    clase: "proveedor";
+    accion: "baja";
+    slug: string;
+}
+/**
+ * Dar de alta, cambiar o borrar un subagente.
+ *
+ * `ambito` decide en qué carpeta se escribe, y viaja explícito en vez de deducirse de si
+ * hay proyecto abierto: con uno abierto valen las dos, y adivinar cuál quiere el usuario
+ * es cómo un «revisor» que quería para todos los proyectos acaba escondido en uno.
+ */
+ | {
+    clase: "agente";
+    /**
+     * `restaurar` devuelve un agente de serie a como lo entregamos, y ocupa el sitio del
+     * `borrar` en esos: borrarlo no lo resiembra —la marca recuerda que se entregó—, así
+     * que era perderlo para siempre. El servidor RECHAZA un `borrar` de uno de serie:
+     * esconderle el icono al cliente es presentación, no una guarda.
+     */
+    accion: "guardar" | "borrar" | "restaurar";
+    ambito: "global" | "proyecto";
+    agente: AgenteDelCable;
+    /**
+     * El nombre de ANTES, solo en un renombrado. Ausente = el nombre no cambia, que es lo
+     * que manda un alta y una edición normal.
+     *
+     * Va en el `guardar` y no en una cuarta acción porque renombrar ES guardar: el
+     * formulario permite cambiar el nombre y la descripción en la misma pulsación, y dos
+     * mensajes serían dos escrituras que pueden quedarse a medias. Lo decide el servidor
+     * comparándolo con `agente.nombre`: si son iguales, no hay renombrado.
+     */
+    renombrandoDe?: string;
+}
+/**
+ * Dar de alta, cambiar o borrar una skill del USUARIO.
+ *
+ * El mismo molde que `agente`, y las dos diferencias no son de forma:
+ *
+ * - **No hay `restaurar`.** Una skill de serie vive dentro del paquete instalado y nunca
+ *   se copia a la casa del usuario, así que no hay marca que recordar ni nada que
+ *   reponer: lo que la consola ofrece sobre una de serie es COPIARLA, que es un `guardar`
+ *   normal con otro nombre.
+ * - **El servidor RECHAZA guardar o borrar con el nombre de una de serie.** Esconderle el
+ *   botón al cliente es presentación, no una guarda; la barrera está aquí.
+ */
+ | {
+    clase: "skill";
+    accion: "guardar" | "borrar";
+    ambito: "global" | "proyecto";
+    skill: SkillDelCable;
+    /** El nombre de ANTES, solo en un renombrado. Ausente = no cambia. Como en `agente`. */
+    renombrandoDe?: string;
+}
+/** El cuerpo de una skill, bajo demanda: al abrir su ficha o al copiar una de serie. */
+ | {
+    clase: "cuerpoDeSkill";
+    nombre: string;
+}
+/** Parar el turno en vuelo. Aborta el `stream` del grafo (`SesionReal.cancelar`) y deja
+ *  la sesión viva: es parar ESTO, no cerrar la conversación. */
+ | {
+    clase: "cancelar";
+}
+/** La sesión remota: encenderla, revocar su enlace (apagar y volver a encender) o apagarla. */
+ | {
+    clase: "remoto";
+    accion: "encender" | "revocar" | "apagar";
+}
+/** El interruptor de Ajustes: escribe `remoto.habilitado`; desactivar apaga antes lo encendido. */
+ | {
+    clase: "remoto";
+    accion: "habilitar";
+    valor: boolean;
+}
+/** Elegir la vía (solo apagada o en error), pedir el authtoken de ngrok (llega por `leerSecreto`) o fijar su dominio. */
+ | {
+    clase: "remoto";
+    accion: "via";
+    via: "servidor" | "ngrok";
+}
+/** Con `authtoken`, el tecleado en Ajustes; sin él, se pide por `leerSecreto`. Es un SECRETO del cable:
+ *  no se apunta, no se devuelve y no sale más que hacia `guardarAuthtoken`. */
+ | {
+    clase: "remoto";
+    accion: "authtoken";
+    authtoken?: string;
+} | {
+    clase: "remoto";
+    accion: "dominio";
+    dominio: string;
+}
+/** Pide lo que la sesión abierta ha tocado, o el parche de un fichero concreto. */
+ | {
+    clase: "revision";
+    ruta?: string;
+}
+/** Lo pendiente de subir (sin `ruta`) o el diff de uno (con `ruta`). */
+ | {
+    clase: "pendientesDeSubida";
+    ruta?: string;
+}
+/** Pide el diff SEMÁNTICO de un `.xne` de Revisión. */
+ | {
+    clase: "modeloDelCambio";
+    ruta: string;
+}
+/** Pide el árbol del proyecto abierto, o el contenido de una ruta relativa a su raíz. */
+ | {
+    clase: "arbol";
+}
+/** Pide la foto del modelo XOne del proyecto abierto (pestaña Colecciones). */
+ | {
+    clase: "colecciones";
+}
+/** Pide los planes del proyecto abierto (pestaña Planes). */
+ | {
+    clase: "planes";
+}
+/**
+ * El gestor de tareas del proyecto abierto (IXCODE-11). Leer (`estado`, `sitios`,
+ * `proyectos`, `pendientes`), vincular y desvincular el proyecto del gestor, marcar qué
+ * conectores usa, y `empezar`: abre una sesión NUEVA ligada a esa tarea y contesta con el
+ * borrador para el compositor. Nada de esto escribe en el gestor todavía.
+ */
+ | {
+    clase: "gestor";
+    accion: "estado";
+} | {
+    clase: "gestor";
+    accion: "sitios";
+    conector: string;
+} | {
+    clase: "gestor";
+    accion: "proyectos";
+    conector: string;
+    sitio: string;
+}
+/** IXCODE-15, de solo LECTURA: buscar proyectos por texto (Notion: sus bases). */
+ | {
+    clase: "gestor";
+    accion: "buscarProyectos";
+    conector: string;
+    texto: string;
+}
+/** IXCODE-15, de solo LECTURA: lo que se entiende del esquema de un proyecto antes de vincularlo. */
+ | {
+    clase: "gestor";
+    accion: "describir";
+    conector: string;
+    proyecto: string;
+} | {
+    clase: "gestor";
+    accion: "vincular";
+    conector: string;
+    sitio: string;
+    proyecto: string;
+} | {
+    clase: "gestor";
+    accion: "desvincular";
+}
+/** Los estados del flujo del proyecto vinculado y el mapeo propuesto, contestados en la respuesta (la puerta 2). */
+ | {
+    clase: "gestor";
+    accion: "estadosDelFlujo";
+}
+/** Guardar el mapeo de estados y el interruptor del disparo del vínculo (la puerta 2). */
+ | {
+    clase: "gestor";
+    accion: "ajustarVinculo";
+    estados: MapeoDeEstados;
+    automatico: boolean;
+    revisarEncargo?: boolean;
+} | {
+    clase: "gestor";
+    accion: "usarConector";
+    conector: string;
+    usar: boolean;
+} | {
+    clase: "gestor";
+    accion: "pendientes";
+    texto?: string;
+    mias?: boolean;
+}
+/** La descripción de una tarea (la fila desplegada del panel). De solo LECTURA. */
+ | {
+    clase: "gestor";
+    accion: "ficha";
+    clave: string;
+}
+/**
+ * Task 10 (IXCODE-11): las ÚNICAS cuatro acciones que ESCRIBEN en Jira, siempre por un
+ * mensaje EXPLÍCITO del cliente —la persona aprobó una tarjeta—, nunca solas. `transiciones`
+ * es de solo LECTURA (pide la lista); `empezar` con `transicion` transiciona ANTES de abrir
+ * la sesión; `borradorDeCierre` también es de solo lectura (compone el texto, no lo manda);
+ * `cerrar` comenta y, si hay `transicion`, transiciona.
+ */
+ | {
+    clase: "gestor";
+    accion: "transiciones";
+    clave: string;
+    para: "empezar" | "cerrar";
+} | {
+    clase: "gestor";
+    accion: "empezar";
+    clave: string;
+    transicion?: string;
+} | {
+    clase: "gestor";
+    accion: "borradorDeCierre";
+} | {
+    clase: "gestor";
+    accion: "cerrar";
+    comentario: string;
+    transicion?: string;
+} | {
+    clase: "fichero";
+    ruta: string;
+}
+/**
+ * Guardar lo que la persona editó. La única escritura del cliente en un fichero del proyecto:
+ * sin tarjeta de aprobación porque lo teclea ella, con las guardas de ruta de leer y negada con
+ * un turno o una tarea en marcha en esa raíz. `huella` es la del fichero que se cargó, y
+ * `proyecto` el `proyectoActivo` con que se ABRIÓ la edición: si el foco ya es otro, se niega.
+ */
+ | {
+    clase: "guardarFichero";
+    ruta: string;
+    texto: string;
+    huella: string;
+    id: string;
+    proyecto: string;
+    /** Tras guardar, llevarlo al aparato de la sesión. Nunca hace fallar el guardado. */
+    recargar?: true;
+}
+/** Pedir la base de comparación de un fichero: la foto del inicio de la sesión o el último commit. */
+ | {
+    clase: "baseDeFichero";
+    ruta: string;
+    base: "sesion" | "commit";
+}
+/**
+ * La sincronización con CloudStudio del proyecto abierto (pestaña CloudStudio).
+ * `estado` pide la medida; `subir` y `bajar` son las dos acciones de `/sync`.
+ *
+ * Viaja la INTENCIÓN, no la sintaxis: el servidor las aplica encolando `/sync <accion>`
+ * en el lazo (`arranque.ts#atenderSync`), así que el plan, la guarda de árbol sucio y la
+ * aprobación salen por donde ya salían — la aprobación es la pregunta de siempre, que es
+ * la que autoriza la escritura. Un `git push` desde el cliente no existiría ni aunque
+ * quisiéramos: la copia la mueve `agent/cloudstudio/subida.ts` llamando a las tools MCP.
+ */
+ | {
+    clase: "sync";
+    accion: "estado" | "subir" | "bajar";
+}
+/**
+ * El contenido de un artefacto de la sesión abierta. Se pide por NOMBRE y no por ruta: la
+ * carpeta la compone el servidor con el id del hilo, y aceptar una ruta del cliente sería
+ * abrir a negociación justo la parte que es una barrera.
+ */
+/** Con `proyecto` y `sesion`: el de esa conversación, que se LEE sin consola, contestado en la propia respuesta. */
+ | {
+    clase: "artefacto";
+    nombre: string;
+    proyecto?: string;
+    sesion?: string;
+}
+/**
+ * Ejecuta —o cancela— un paso de una receta de instalación.
+ *
+ * Viajan el NOMBRE de la receta y el NÚMERO del paso, nunca un comando ni un binario: un
+ * comando que llegue del cliente es una shell abierta en la máquina del usuario. Qué se
+ * lanza lo decide una tabla cerrada del host (`agent/dispositivos/instalacionEnMaquina.ts`).
+ */
+ | {
+    clase: "receta";
+    id: string;
+    paso: number;
+    accion: "ejecutar" | "cancelar";
+}
+/** Los modelos que ofrece un MOTOR externo, para el desplegable de un subagente. Se pide
+ *  bajo demanda: el de Codex se le pregunta a él, y eso arranca un proceso. */
+ | {
+    clase: "modelosDeMotor";
+    motor: string;
+}
+/** Medir el diagnóstico de Node (Ajustes → General, «Comprobar»). */
+ | {
+    clase: "diagnosticoNode";
+}
+/** El diseño vinculado (Stitch): leer, listar proyectos, vincular, desvincular o listar sus pantallas. */
+ | {
+    clase: "diseno";
+    accion: "estado" | "proyectos" | "desvincular" | "pantallas";
+    proyecto?: string;
+} | {
+    clase: "diseno";
+    accion: "vincular";
+    proyecto?: string;
+    vinculo: {
+        proyecto: string;
+        nombre: string;
+    };
+}
+/**
+ * Una acción sobre un motor local. La INTENCIÓN, no el comando: qué binario y con qué
+ * argumentos lo decide el servidor (`agent/motores/motoresLocales.ts`). `codigo` es el que la
+ * web de Claude enseña al terminar cuando el navegador no pudo volver solo: va al `stdin` del
+ * `auth login` en curso y a ningún otro sitio.
+ */
+ | {
+    clase: "motorLocal";
+    accion: "medir" | "probar" | "login" | "codigo" | "cancelar" | "navegador" | "consola" | "modelo";
+    motor?: string;
+    modo?: "claudeai" | "console";
+    codigo?: string;
+    /** Con `accion: "modelo"`: el elegido (`proveedor/modelo`); ausente o vacío lo quita. */
+    modelo?: string;
+}
+/**
+ * Las acciones sobre una tarea. Viaja el ID del proyecto y su nombre, NUNCA su raíz: es
+ * una ruta de la máquina, y el cable puede ir por un túnel.
+ */
+/**
+ * `borrador` es el identificador bajo el que ya se subieron los adjuntos por
+ * `POST /adjunto` — los bytes tienen que estar en disco ANTES de crear la tarea, porque
+ * crear la encola y el corredor puede arrancarla en el acto. El servidor lo ADOPTA como
+ * id de la tarea si es un segmento llano y no es ya una tarea; los adjuntos los lee del
+ * disco, nunca de lo que diga el cliente.
+ */
+ | {
+    clase: "tarea";
+    accion: "crear";
+    proyecto: string;
+    peticion: string; /** Vacío o ausente = lo prepara el servidor al encolar. */
+    encargo?: string;
+    borrador?: string;
+    pantallaDeStitch?: {
+        name: string;
+        titulo: string;
+    };
+} | {
+    clase: "tarea";
+    accion: "augmentar";
+    proyecto: string;
+    peticion: string;
+    borrador?: string;
+    pantallaDeStitch?: {
+        name: string;
+        titulo: string;
+    };
+}
+/**
+ * Una PROPUESTA de tareas encadenadas (el acto `propuesta-de-tareas`): encolarla en orden o
+ * descartarla. Viaja el id de la propuesta y, al encolar, los encargos que la persona revisó (la
+ * petición del orquestador, que no se vuelve a redactar), UNO por tarea y en orden; títulos, peticiones y adjuntos los saca el servidor del
+ * acto, nunca del cliente. Encolar contesta en la propia respuesta: `{encoladas, faltan?}` o 409
+ * con `{motivo}`.
+ */
+/** `enChat`: se descarta para hacerlo en ESTA conversación; el cliente manda luego la prosa que lo pide. */
+ | {
+    clase: "tarea";
+    accion: "descartarPropuesta";
+    proyecto: string;
+    propuesta: string;
+    enChat?: true;
+} | {
+    clase: "tarea";
+    accion: "crearEncadenadas";
+    proyecto: string;
+    propuesta: string;
+    encargos: string[];
+}
+/**
+ * «Se edita la tarea y se agrega el feedback del usuario» (§0 del diseño): la respuesta a
+ * una tarea «esperando feedback», que la devuelve al lazo en su MISMO hilo. Es su propia
+ * variante y no un tercer campo opcional en `reintentar` porque lleva `texto` y las otras
+ * tres no llevan nada — un campo que solo tiene sentido en una de cuatro acciones es la
+ * misma mentira por omisión que una lista vacía rellenada.
+ */
+ | {
+    clase: "tarea";
+    accion: "feedback";
+    id: string;
+    texto: string;
+}
+/**
+ * «Continuar» una tarea aparcada sin escribir nada (entra en su hilo `TEXTO_DE_CONTINUAR`), y «Arrancar ahora» una
+ * `nuevo` que no espera a ninguna anterior: la persona CEDE el proyecto —se cierra su consola de ahí si no está
+ * trabajando— y la tarea arranca. Las dos contestan 409 con `{motivo}` si no se puede.
+ */
+ | {
+    clase: "tarea";
+    accion: "continuar";
+    id: string;
+} | {
+    clase: "tarea";
+    accion: "arrancarAhora";
+    id: string;
+}
+/** Editar el encargo de una tarea que todavía no ha arrancado (IXCODE-52). 204, o 409 con `{motivo}`. */
+ | {
+    clase: "tarea";
+    accion: "encargo";
+    id: string;
+    encargo: string;
+    peticion?: string;
+    pantallaDeStitch?: {
+        name: string;
+        titulo: string;
+    } | null;
+}
+/** Volver a preparar el encargo desde la petición editada, SIN guardarlo (IXCODE-53). 200 con `{encargo}`, o 409 con `{motivo}`. */
+ | {
+    clase: "tarea";
+    accion: "regenerarEncargo";
+    id: string;
+    peticion: string;
+}
+/** Con qué gestor vivirá una tarea nueva de ese proyecto: contestado en la propia respuesta, `{gestor?: {conector, proyecto}}`. */
+ | {
+    clase: "tarea";
+    accion: "destino";
+    proyecto: string;
+}
+/** «Mirar ahora»: una pasada del sondeo del gestor (la puerta 2), contestada con lo que hizo. */
+ | {
+    clase: "tarea";
+    accion: "mirarGestor";
+}
+/** PARAR una tarea en marcha sin borrarla (IXCODE-50): queda aparcada con su conversación. 204, o 409 con `{motivo}`. */
+ | {
+    clase: "tarea";
+    accion: "parar";
+    id: string;
+} | {
+    clase: "tarea";
+    accion: "reintentar" | "descartar" | "terminar";
+    id: string;
+}
+/** Cambia el tope de concurrencia de la cola de tareas. */
+ | {
+    clase: "tareas";
+    concurrencia: number;
+}
+/**
+ * Elige dónde se bajan las copias locales. Acepta `~/…` y absolutas; la regla de qué vale
+ * es `core/settings.ts#motivoDeWorkspaceInaceptable`, y se aplica en el SERVIDOR además de
+ * en la pantalla — el cliente lleva su copia DECLARADA, como la de la URL de un entorno y
+ * la del slug de un subagente, porque la frontera prohíbe compartir módulo.
+ *
+ * **MUDA lo que ya está bajado** (`vestibulo.mudarWorkspace`), en dos actos: `planear`
+ * contesta en la PROPIA respuesta qué se movería o por qué no se puede, sin tocar nada; sin
+ * `accion` (o con `aplicar`) se cambia de verdad, y el recorrido llega por
+ * `mudanzaDeWorkspace`.
+ */
+ | {
+    clase: "workspace";
+    ruta: string;
+    accion?: "planear" | "aplicar";
+}
+/** Cambia la casilla «Depurar» de Ajustes > General. */
+ | {
+    clase: "depuracion";
+    activa: boolean;
+}
+/** Abre el selector de carpeta NATIVO **de la máquina donde corre la consola** — ver
+ *  `core/selectorDeCarpeta.ts` para por qué no lo puede poner el navegador. */
+ | {
+    clase: "elegirCarpeta";
+}
+/**
+ * Empezar (`ver: true`) o dejar de mirar en vivo lo que hace una tarea.
+ *
+ * **`cliente` es lo que hace que esto sea por CLIENTE y no una emisión a todos.** El SSE
+ * y el `POST /accion` son dos peticiones distintas, así que el único sitio con un sumidero
+ * en la mano es la ruta del SSE: sin un identificador, el servidor no podría saber a qué
+ * pestaña engancharle la mirada, y tendría que mandarle el transcript de la tarea a todo
+ * el mundo. Lo elige el cliente —una vez por conexión— igual que elige el id de una tarea
+ * al subirle un adjunto por `POST /adjunto`, y se valida como un segmento llano; uno que
+ * no conste es un fallo de lookup y no un error que contar.
+ *
+ * `ver` es explícito y no «ausente = dejar de mirar»: son dos intenciones opuestas y
+ * confundirlas dejaría un sumidero enganchado a un turno que nadie mira.
+ */
+ | {
+    clase: "mirar";
+    tarea: string;
+    ver: boolean;
+    cliente: string;
+}
+/**
+ * Vuelve a MEDIR si se puede lanzar la app del proyecto abierto, y contesta con un `lanzable`.
+ *
+ * Sin datos, y no es una comodidad: el veredicto se compone de la elección de dispositivo de
+ * la SESIÓN, de la última medida de la máquina y de los descriptores del PROYECTO abierto —
+ * tres cosas que el navegador no tiene y sobre las que no es fuente. Que el cliente pudiera
+ * mandar «lanza el proyecto X en el aparato Y» sería abrir a negociación justo lo que decide
+ * si se lanza o no.
+ */
+ | {
+    clase: "revisarLanzamiento";
+}
+/**
+ * Lanza la app del proyecto abierto en el dispositivo de la sesión.
+ *
+ * **Sin datos tampoco, y aquí es la regla entera**: ni el dispositivo, ni el nombre de la app,
+ * ni una ruta, ni siquiera el proyecto — los tres primeros son datos sobre la máquina y sobre
+ * el proyecto, y el cuarto lo resuelve el servidor de la consola que atiende. Y el servidor
+ * **revalida antes de empezar**: entre el veredicto y este clic pueden pasar minutos, y un
+ * `lanzarApp` sobre un proyecto que ya no cumple se contesta con un `lanzamiento` en `fallo`,
+ * no lanzando a ciegas.
+ */
+ | {
+    clase: "lanzarApp";
+}
+/**
+ * Para el lanzamiento en curso. Es parar ESTO, no cerrar nada — la misma distinción que
+ * `cancelar` con un turno: el recorrido queda en `cancelada` con lo que ya se había contado.
+ *
+ * Un lanzamiento a la vez por consola, así que no lleva id: no hay dos entre los que elegir.
+ */
+ | {
+    clase: "cancelarLanzamiento";
+}
+/**
+ * Llevar un fichero ya guardado al aparato de la sesión. `probar`: si la app no corre, desplegar
+ * el proyecto entero (lo de Ejecutar). `relanzar`: relanzar la app (lo que pide un CSS).
+ */
+ | {
+    clase: "recargarEnAparato";
+    ruta: string;
+    probar?: true;
+    relanzar?: true;
+}
+/**
+ * Una acción sobre UN conector: añadirlo, quitarlo, probarlo, autorizarlo, desconectarlo o
+ * darlo de alta a mano. Una `accion` que no sea una de esas seis se rechaza con 400 y no hace
+ * nada.
+ *
+ * **Son DOS formas y no una con campos opcionales**, porque `crear` no lleva `id`: el id lo
+ * DERIVA el servidor del nombre (y por eso tampoco se puede elegir desde fuera, que sería
+ * dejar que el cliente nombre una clave de fichero). Su `definicion` viaja sin comprobar por
+ * tipo —un cliente puede mentir sobre lo que el tipo promete— y quien la mira de verdad es
+ * `definicionDelCable` en el servidor.
+ *
+ * El resultado NO viaja en la respuesta: `probar` y `autorizar` corren en segundo plano
+ * (red, o esperar al navegador) y lo que cambien llega por el `conectores` que sigue, vía
+ * `alCambiar` del servicio — el mismo molde que `dispositivo`/`conexion`.
+ */
+ | {
+    clase: "conector";
+    accion: "crear";
+    definicion: DefinicionDeConector;
+} | {
+    clase: "conector";
+    accion: "anadir" | "quitar" | "probar" | "autorizar" | "desconectar";
+    id: string;
+} | {
+    clase: "decision";
+    decisiones: Record<string, string>;
+};
+/**
+ * Un subagente tal y como viaja: los campos del `.md` y de dónde salió.
+ *
+ * `origen` es de solo lectura —lo pone el servidor al leer— y sirve para que la ventana
+ * pueda decir si un agente viene del global o del proyecto, que es lo que explica por qué
+ * editarlo aquí no afecta a los demás proyectos.
+ */
+export interface AgenteDelCable {
+    nombre: string;
+    descripcion: string;
+    motor: string;
+    modelo?: string;
+    soloLectura: boolean;
+    /**
+     * Si puede EJECUTAR comandos en la máquina. **Ausente es que no**: es una capacidad, y una
+     * capacidad que se concede por omisión es la que nadie decidió conceder.
+     *
+     * Solo tiene efecto con `motor: "modelo"`; en los tres externos la shell está cerrada a
+     * propósito y esto no la abre, así que la ventana lo dice en vez de pintar una casilla
+     * marcada que no hace nada.
+     */
+    ejecucion?: boolean;
+    /**
+     * Cuánto razona su modelo antes de contestar. Ausente = no se manda el parámetro.
+     *
+     * Solo tiene efecto con `motor: "modelo"`: en los tres externos el modelo lo construye el
+     * hijo en su proceso y un campo nuestro no llega hasta allí. Qué niveles admite depende
+     * del modelo elegido (`core/esfuerzo.ts`), y por eso la ventana lo pinta pegado a él.
+     */
+    esfuerzo?: Esfuerzo;
+    skills: string[];
+    instrucciones: string;
+    origen?: string;
+    /**
+     * De quién es el fichero, que NO es lo mismo que `origen` —esa es la carpeta— y decide qué
+     * botón lleva la tarjeta: ausente, la papelera; `modificada`, «Restaurar el de serie».
+     * Los tres estados y su porqué, en `core/agentes.ts#AgenteCargado`.
+     */
+    semilla?: "intacta" | "modificada";
+}
+/**
+ * Una skill tal como viaja: nunca su carpeta, que es una ruta de la máquina (`sinRutas`).
+ *
+ * **`cuerpo` solo lo llevan las del usuario, y su ausencia significa «esta no se edita».**
+ * Las de serie son nueve ficheros que pueden pasar de veinte mil caracteres cada uno: si
+ * viajaran todas en la ráfaga de bienvenida, abrir la consola costaría cientos de kilobytes
+ * para rellenar un formulario que nadie puede guardar. Se piden una a una cuando alguien
+ * quiere verlas o copiarlas (`clase: "cuerpoDeSkill"`), que es cuando el coste se justifica.
+ *
+ * `origen` dice de DÓNDE sale y es de solo lectura: separa las dos pestañas y explica por
+ * qué editar la del proyecto no toca a los demás proyectos. `ficheros` son los anexos por
+ * NOMBRE y sin contenido — una skill puede ser una carpeta entera, y una ventana que solo
+ * enseña el `SKILL.md` haría creer que editarlo es editarla toda.
+ */
+export interface SkillDelCable {
+    nombre: string;
+    descripcion: string;
+    origen: "serie" | "global" | "proyecto";
+    tokens: number;
+    ficheros: string[];
+    /**
+     * El frontmatter del `SKILL.md` tal cual, sin los `---`.
+     *
+     * Viaja SIEMPRE —también en las de serie— y no con el cuerpo, porque son cuatro líneas y
+     * es lo que contesta «qué declara este fichero»: `description` no es lo único que puede
+     * haber ahí (`archify` lleva `license` y un bloque `metadata`), y enseñar solo la
+     * descripción haría creer que eso es todo. Al guardar vuelve, y `escribirSkill` conserva
+     * las claves que no entendemos en vez de borrárselas al usuario en silencio.
+     */
+    frontmatter?: string;
+    /** Ausente en las de serie, y en la que se está creando. Ver arriba. */
+    cuerpo?: string;
+}
+/** A dónde escribe el SSE. Ausente = no hay nadie al otro lado. */
+export type Sumidero = (mensaje: MensajeAlCliente) => void;
+export interface Transporte {
+    /**
+     * Un cliente abre el SSE. Devuelve los actos que hay que reemitirLE: quien registra la
+     * ruta los manda como una `reemision` con su propia escritura —solo a ese sumidero—, así
+     * que esto NO los emite; hacerlo se los mandaría también a los demás clientes, que ya
+     * tienen el transcript.
+     *
+     * **Se admite más de uno.** Antes había UNA ranura y el último en conectar desplazaba al
+     * anterior en silencio: la pestaña vieja se quedaba con el SSE abierto y sin recibir
+     * nada, así que su interfaz se congelaba en el último estado que le llegó —medido con
+     * una pestaña local y otra por un túnel: el menú de modelos se quedaba en «consultando…»
+     * para siempre porque la respuesta se la llevaba la otra—. Un servidor que acepta la
+     * conexión tiene que hablarle.
+     */
+    conectar(enviar?: Sumidero): readonly Acto[];
+    /**
+     * Un SSE se cae, o se cierra una pestaña. Con el sumidero se dice CUÁL se va; sin él se
+     * van todos (es lo que hace `cerrar`).
+     *
+     * Fail-closed sigue significando lo mismo, pero sobre el conjunto: quien espera respuesta
+     * deja de esperar cuando se va el ÚLTIMO cliente, no el primero. Cortar a la primera baja
+     * rechazaría la aprobación que otra pestaña abierta todavía tiene delante.
+     */
+    desconectar(enviar?: Sumidero): void;
+    /**
+     * El cable se MUDA a otra consola: se sueltan los sumideros y NADA más.
+     *
+     * La diferencia con `desconectar` es toda la razón de que exista, y es de significado, no
+     * de implementación: `desconectar` afirma «se ha ido el humano» —despierta con la cadena
+     * vacía a todo el que esperaba respuesta y da por rechazada la aprobación que hubiera
+     * delante—, y eso es cierto cuando el SSE se cae y FALSO cuando alguien cambia de sesión
+     * en la barra teniendo esta con un turno corriendo: la persona sigue ahí, mirando otra
+     * cosa. Con `soltar`, `conectado()` sigue diciendo que hay alguien —así que su aprobación
+     * espera su plazo en vez de rechazarse sola— y lo que se emita mientras tanto no llega a
+     * ningún socket, que es exactamente lo que se quiere: los actos de un turno de segundo
+     * plano no pueden aparecer en la conversación que se está mirando.
+     *
+     * Los MIRONES no se sueltan: los quita `dejarDeMirar`, y aquí la consola no se cierra
+     * —su socket sigue vivo—, al contrario que en `desconectar()` sin sumidero.
+     */
+    soltar(enviar?: Sumidero): void;
+    /** ¿Queda alguien al otro lado? Es lo que `consolaWeb.eof()` usa para saber si hay humano. */
+    conectado(): boolean;
+    /**
+     * Alguien MIRA lo que esta consola pinta, sin ser su cliente. Devuelve el transcript de
+     * ese instante, igual que `conectar` y por lo mismo: emitirlo aquí se lo mandaría también
+     * a los demás, que ya lo tienen.
+     *
+     * Es un conjunto APARTE del de los clientes, y las dos diferencias son el motivo de que
+     * exista en vez de reusar `conectar`:
+     *  - **No cuenta como cliente**, así que `conectado()` —y con él `consolaWeb.eof()`— sigue
+     *    diciendo la verdad. Medido antes de escribir esto: con un `conectar` de más, el
+     *    `eof()` de la consola de una tarea de fondo pasaba de `true` a `false`, o sea «hay un
+     *    humano al que preguntar». Y no lo hay: esta vista es de SOLO lectura, no tiene
+     *    compositor y nadie puede contestar una pregunta ni aprobar una escritura desde ahí.
+     *    Irse el último mirón tampoco dispara `alDesconectar`: no ha dejado a nadie sin
+     *    contestar.
+     *  - **Recibe SOLO el transcript** (`acto`, `sustitucion`, `reemision`). Por el transporte
+     *    de una consola de tarea viaja además el mensaje `turno` de los flancos —lo emite el
+     *    envoltorio del ejecutor sin mirar `alCable`, medido—, y ese mensaje apagaría el
+     *    compositor de quien mira por un turno que no es suyo. La lista es BLANCA a propósito:
+     *    una clase nueva no llega a un mirón hasta que alguien la nombre aquí.
+     */
+    mirar(enviar: Sumidero): readonly Acto[];
+    /** Se va UN mirón. Los demás siguen: dos personas pueden mirar la misma tarea. */
+    dejarDeMirar(enviar: Sumidero): void;
+    /**
+     * Produce un mensaje: lo anota en la traza y, si hay cliente, lo escribe. Anota aunque
+     * no haya nadie porque la traza cuenta lo que el servidor PRODUJO — que es lo que los
+     * tests de «esto no viaja» tienen que poder mirar.
+     */
+    emitir(mensaje: MensajeAlCliente): void;
+    /**
+     * La traza de todo lo producido MENOS la aprobación. No es una lista arbitraria: es la
+     * frontera del invariante — el contenido de fichero está en el mensaje de aprobación y
+     * en ninguna otra clase de mensaje, y así un test lo puede afirmar sobre todo el resto.
+     */
+    emitidos(): readonly MensajeAlCliente[];
+    /** Se llama al desconectar: por aquí se despierta a todo el que esperaba respuesta. */
+    alDesconectar(escucha: () => void): void;
+}
+export declare function crearTransporte(actos: () => readonly Acto[]): Transporte;