xonecode 0.38.44 → 0.39.2

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

@@ -0,0 +1,1372 @@
+/**
+ * El arranque de la consola web: las comprobaciones, el servidor, las RUTAS y el navegador.
+ *
+ * Vive aquí y no en `cli/main.ts` —que ya pasa de mil líneas— por lo mismo que
+ * `cli/tui/correrTui.ts`: el despachador decide QUÉ piel arranca, y la piel se monta en su
+ * propia casa. `main.ts` lo carga con un import dinámico, así que `run`, `describe` y
+ * cualquier tubería no pagan el vestíbulo entero.
+ *
+ * **Aquí es donde `registrarRuta` deja de ser código muerto.** `web/servidor/servidor.ts`
+ * la exportaba desde la Task 5 y hasta ahora no la llamaba nadie fuera de sus tests: los
+ * dos extremos del cable estaban escritos y sin conectar, de modo que la consola web no se
+ * podía abrir aunque `decidirPiel` devolviera «web». Las dos rutas son las que el cliente
+ * ya pedía (`apps/web/src/conexion.ts`): el SSE de `/eventos` y el `POST /accion`.
+ *
+ * **A qué consola habla el cable, y por qué se re-adjunta.** El vestíbulo tiene DOS
+ * consolas: la suya (sin raíz, la del alta) y la del proyecto abierto. `consolaWeb.eof()`
+ * es `!transporte.conectado()`, y sin cliente conectado toda aprobación sale rechazada y
+ * todo `preguntar` responde cadena vacía. Si el SSE se quedara enganchado a la consola del
+ * vestíbulo después de abrir un proyecto, el usuario vería su transcript y NADA de lo que
+ * decidiera llegaría: fail-closed mudo. Por eso al abrir proyecto se desconecta la anterior
+ * y se conecta la nueva, con reemisión entera del transcript.
+ *
+ * **La clave de API no pasa por el mensaje de alta.** El paso de cuenta lo conduce
+ * `vestibulo.pasoDeCuenta()` —o sea `cli/wizardInicial.ts#asistenteDeModelo` sin tocar—
+ * sobre `seleccionar` y `leerSecreto`, que el cliente ya pinta. Así la clave sigue viajando
+ * por el único mensaje del cable que la lleva y, de propina, el asistente elige TAMBIÉN el
+ * modelo y lo guarda: un paso de cuenta que solo guardara la credencial dejaría `trabajo`
+ * en la omisión (Ollama local) con una clave de Anthropic recién escrita al lado.
+ */
+import { type VersionEnMarcha } from "../../core/version.js";
+/**
+ * El veredicto de «¿se puede lanzar?» y el lanzamiento entero.
+ *
+ * `lanzarEnDispositivo` se pasa al cable como FUNCIÓN y no como dependencias: construye las
+ * suyas por dentro —el `https`, el ZIP en memoria, `frameworkEnDispositivo`, `process.kill(-pid)`
+ * y el WebSocket del hotswap—, así que repetir ese montaje en el cableado sería un segundo sitio
+ * donde puede dejar de estar montado, que es el patrón de fallo de esta casa. Lo único que este
+ * lado aporta es `alFase`, que es cómo se cuenta el recorrido.
+ */
+import { type DependenciasDeLanzamiento, type LanzamientoEnCurso, type PeticionDeLanzamiento } from "../../agent/dispositivos/lanzamientoEnMaquina.js";
+import { type FrameworkMedido } from "../../core/puedeLanzarse.js";
+import type { Dispositivo, InformeDeDispositivos } from "../../core/dispositivos.js";
+import { type AjustesDeDispositivos } from "../../core/settings.js";
+import type { NombreDeHerramienta } from "../../core/dispositivos.js";
+import type { ViaRemota } from "../../core/settings.js";
+import { arrancarEmulador } from "../../agent/dispositivos/arranqueDeEmulador.js";
+import { type DestinoDeRecarga } from "../../agent/dispositivos/recargaEnAparato.js";
+import { type ResultadoDeRecarga } from "../../core/recargaEnCaliente.js";
+import { type ServicioDeMotoresLocales } from "../../agent/motores/motoresLocales.js";
+import { traerPantalla } from "../../agent/motores/trueforge/traerDeStitch.js";
+import type { DiagnosticoDeNode } from "../../core/diagnosticoDeNode.js";
+import { type ProveedorDeclarado, type FuentesDeEleccion, type Proveedor } from "../../core/modelos.js";
+import { type Consola, type EjecutorDeTurno } from "../../cli/consola.js";
+import { crearCheckpointerDeProyecto, mantenimientoDelCheckpointer } from "../../agent/sesiones/checkpointer.js";
+import { type Settings } from "../../core/settings.js";
+import { type ModoDeEscritura } from "../../core/modoDeEscritura.js";
+import { mudarWorkspaceLegado, type ResultadoDeMudanza } from "../../agent/config/mudanzaEnDisco.js";
+import { type DispositivoElegido } from "./sesiones.js";
+import type { PantallaElegida } from "../../core/tareas.js";
+import { type FotoDeColecciones } from "../../core/fotoDeColecciones.js";
+import type { CambiosDeUnaColeccion } from "../../core/diffDeColecciones.js";
+import { type PlanEnDisco } from "../../agent/planesEnDisco.js";
+import { type LecturaCruda } from "../../agent/grafo/artefactosEnDisco.js";
+import type { AumentadorPort, ConectoresPort, JuezDeTareaPort, PuenteRemotoPort, TunelPort } from "../../core/ports.js";
+import { arrancarServidor, type ServidorWeb } from "./servidor.js";
+import { type Corredor, type RevisionDeSesion } from "./corredorDeTareas.js";
+import { type Tarea } from "../../core/tareas.js";
+import { type TareasEnDisco } from "../../agent/tareas/tareasEnDisco.js";
+import { type OpcionDeEntorno, type PasoDelVestibulo, type OpcionesDelVestibulo, type SesionCerrable, type Vestibulo } from "./vestibulo.js";
+import type { FicheroTocado, FicheroDelProyecto, MensajeAlCliente, InformeDeDispositivosDelCable, BaseDelFichero } from "./transporte.js";
+import { type ServicioDeConectores } from "../../agent/conectores/servicioDeConectores.js";
+import { type DatosDeCierre, type GestorDeTareasPort } from "../../core/gestorDeTareas.js";
+import { crearSondeoDelGestor, type CopiaConGestor, type ResultadoDelSondeo, type SondeoDelGestor } from "../../agent/tareas/sondeoDelGestor.js";
+/** Las dos rutas del cable. El cliente las tiene escritas en `apps/web/src/conexion.ts`. */
+/**
+ * Cuánto se espera al aviso de «lo que ya había sin commitear» antes de anunciar sin él.
+ *
+ * Dos segundos porque esto va en el camino de ABRIR una sesión y ahí lo que se nota es el
+ * indicador: un anuncio sin ese campo es «no consta» —lo que ya significaba ausente— y el
+ * siguiente flanco de turno lo trae. Bloquear la apertura por un `git status` lento es la
+ * definición de que el aviso frena, que es justo lo que su propia regla prohíbe.
+ */
+export declare const MS_DE_TRABAJO_AL_ABRIR = 2000;
+/**
+ * Cuánto se espera al arranque antes de entrar igual.
+ *
+ * Lo que se prepara es la sesión MCP y la lista de proyectos del primer entorno registrado,
+ * y el usuario pidió no entrar al Escritorio hasta tenerlo: entrar antes significa un
+ * Escritorio vacío que se rellena delante. Pero esperar SIN plazo es lo que convierte una
+ * espera en un cuelgue — medido con un MCP que descarta paquetes, el lienzo se quedaba para
+ * siempre, y eso es peor que lo que veníamos a arreglar.
+ *
+ * Generoso a propósito: una sesión MCP fría lleva descubrimiento OAuth y handshake, y
+ * cortarla pronto haría entrar en vacío justo a quien tiene la red lenta, que es a quien más
+ * le duele. Y como el lienzo DICE lo que está haciendo (`preparando`), la espera se lee como
+ * trabajo y no como una pantalla muerta.
+ *
+ * Igual que `MS_DE_TRABAJO_AL_ABRIR`, lo que se acota es la ESPERA y no el trabajo: la
+ * promesa sigue viva y lo que llegue tarde sale en el siguiente anuncio.
+ */
+export declare const MS_DE_PREPARACION = 10000;
+export declare const RUTA_EVENTOS = "/eventos";
+export declare const RUTA_ACCION = "/accion";
+/**
+ * El documento de un ARTEFACTO, para el iframe y para la descarga.
+ *
+ * Tiene que ser HTTP y no cable: un iframe pinta un DOCUMENTO, y por `/eventos` viajan
+ * mensajes. El nombre va en la query y no en la ruta porque `registrarRuta` casa por
+ * coincidencia EXACTA (`servidor.ts`), así que `/artefacto/<nombre>` no encontraría
+ * manejador. Consecuencia asumida: las URLs relativas de dentro del HTML no resuelven —
+ * el contrato de las skills que los escriben es «autocontenido».
+ */
+export declare const RUTA_ARTEFACTO = "/artefacto";
+/**
+ * `GET /soporte?tipo=<proyecto|chat|tarea>&proyecto=<id>[&id=<id>]` — el PAQUETE de soporte
+ * (`soporte.ts`), escrito en streaming. Del cable llegan IDs; la raíz y lo que existe los decide
+ * el servidor con su propio listado e índice.
+ */
+export declare const RUTA_SOPORTE = "/soporte";
+/**
+ * `POST /skill?nombre=<fichero.zip>&ambito=<global|proyecto>` — los BYTES de un `.zip`.
+ *
+ * Por HTTP y no por el cable, que lleva JSON: la misma razón y el mismo molde que
+ * `POST /adjunto`. Una ruta EXACTA, porque el servidor casa por ruta exacta.
+ */
+export declare const RUTA_SKILL = "/skill";
+/**
+ * `POST /adjunto?tarea=<id>&nombre=<fichero>` — los BYTES de un adjunto.
+ *
+ * Por HTTP y no por el cable: el SSE lleva JSON y esto son bytes. El nombre va en la QUERY
+ * y no en la ruta por lo mismo que el del artefacto: `registrarRuta` casa por coincidencia
+ * EXACTA, así que `/adjunto/<nombre>` no encontraría manejador.
+ */
+export declare const RUTA_ADJUNTO = "/adjunto";
+/** Cuántas líneas del log de una instalación viajan: la COLA, lo último. */
+export declare const LINEAS_DE_LOG = 12;
+/** Cada cuánto se emite el progreso. Ver `atenderReceta`: cada emisión manda la cola entera. */
+export declare const MS_ENTRE_PROGRESOS = 250;
+/** Lo que se sirve: el build del cliente. Tres niveles arriba tanto desde `src/web/servidor/`
+ *  como desde `dist/web/servidor/`, que es la disposición que se publica en npm. */
+export declare function raizDelClientePorOmision(): string;
+/**
+ * El visor de OpenUI del build del cliente, o `undefined` si no está. Se lee en cada petición, como
+ * el resto del cliente: reconstruirlo se ve recargando, sin reiniciar el servidor.
+ */
+export declare function leerVisorOpenui(raizDelCliente: string): {
+    js: string;
+    css: string;
+} | undefined;
+export declare const FALTA_EL_BUILD = "falta el build del cliente: ejecuta \u00ABnpm run build:web\u00BB";
+export interface OpcionesDeMontaje {
+    /** A dónde van los avisos que no caben en el transcript. Por omisión, a ningún sitio. */
+    informar?: (texto: string) => void;
+    /**
+     * La sesión remota (`puenteRemoto.ts`). Ausente o `ajustes().habilitado === false` = no
+     * existe: ni se anuncia, ni se atiende, ni se llama a `puerto` (que es lo que cargaría el
+     * paquete del puente). Con una excepción: un puente que sigue abierto al apagar el
+     * interruptor se sigue anunciando hasta que se apague. `ajustes` se lee en cada uso, no al montar: el
+     * interruptor vive en `settings.json` y leerlo una vez lo congelaría.
+     */
+    remoto?: {
+        ajustes: () => {
+            habilitado: boolean;
+            porEntorno?: true;
+            servidor: string;
+            via?: ViaRemota;
+            dominio?: string;
+        };
+        puerto: () => Promise<PuenteRemotoPort | undefined>;
+        /**
+         * La vía «ngrok» (`agent/remoto/tunelNgrok.ts`): se abre al encender solo si `ajustes().via`
+         * es `ngrok`. Ausente con esa vía = encender da error con texto fijo.
+         */
+        tunel?: TunelPort;
+        /**
+         * La FOTO de ngrok para el diálogo (`agent/remoto/ngrokEnMaquina.ts#medirNgrok`, más si hay
+         * `brew`, que decide si el paso de macOS de su receta tiene botón). Se mide al conectar la
+         * primera pestaña, tras cada acción suya y al acabar su receta; nunca en sondeo, y nunca con
+         * el interruptor apagado. Ausente = el mensaje no lleva `ngrok`.
+         */
+        medirNgrok?: () => Promise<{
+            instalado: boolean;
+            cuenta: boolean;
+        }>;
+        /** `ngrok config add-authtoken`. Un fallo es un texto de `MOTIVOS_DEL_TUNEL`. */
+        guardarAuthtoken?: (token: string) => Promise<{
+            ok: true;
+        } | {
+            ok: false;
+            motivo: string;
+        }>;
+        /** Escribe el interruptor, la vía o el dominio en `settings.json`; `dominio: null` lo quita. Puede lanzar. */
+        guardarAjustes?: (cambio: {
+            habilitado?: boolean;
+            via?: ViaRemota;
+            dominio?: string | null;
+        }) => void;
+    };
+    /**
+     * El tope de la ventana del modelo, para el contador de contexto. Ver la opción del mismo
+     * nombre en `OpcionesDeArranque`: es la MISMA función que la barra del terminal, y entra
+     * por parámetro para no importar `cli/` desde aquí.
+     */
+    topeDeContexto?: (raiz: string, modelo: string) => number | undefined;
+    /**
+     * Con qué código corre este proceso. Ver la opción del mismo nombre en
+     * `OpcionesDeArranque`: se llama UNA vez al montar las rutas —no cambia mientras el
+     * proceso vive— y su número (sin commit ni si el árbol está sucio: eso es lo que ya dice
+     * la línea de terminal) viaja en el `alta`, para el pie de la barra. Ausente = no se dice
+     * nada.
+     */
+    version?: () => VersionEnMarcha;
+    /**
+     * ¿Está confirmada la credencial de ese proveedor? Por omisión NADIE la tiene, que es la
+     * dirección honesta: decir «puesta» sin haberlo comprobado es pintar un punto verde que
+     * no significa nada. Los que no necesitan credencial (`SIN_CREDENCIAL`) no pasan por
+     * aquí.
+     */
+    hayCredencial?: (proveedor: Proveedor) => boolean;
+    /** ¿Está esa credencial en `auth.json`? Solo esas se pueden borrar desde la interfaz. */
+    credencialEnFichero?: (proveedor: Proveedor) => boolean;
+    /**
+     * Guarda un modelo como DEFECTO de un papel en el `config.json` global
+     * (`agent/config/configEnDisco.ts#guardarModeloGlobal`). Es el escritor de la elección que
+     * sobrevive al proceso.
+     *
+     * Entra por opción y no se importa dentro por la razón de siempre —un valor por omisión
+     * que escribiera de verdad convertiría cualquier test de este cable en una escritura en
+     * el `~/.xonecode` de quien los corre—, y además por una propia: **ausente NO significa
+     * que no se pueda cambiar de modelo**, significa que no se puede GUARDAR. El mensaje
+     * sigue aplicándose en caliente si hay sesión, y lo que falta se DICE.
+     *
+     * El tipo es el del método de la consola y no una firma escrita otra vez: es el MISMO
+     * escritor (`vestibulo.ts` lo declara igual), y una segunda copia de la firma es el sitio
+     * donde las dos divergen.
+     */
+    guardarModeloGlobal?: Consola["guardarModeloGlobal"];
+    /**
+     * El modelo que usarán las sesiones NUEVAS, ya resuelto («proveedor/modelo»).
+     *
+     * Es la respuesta a `porDefecto` del mensaje de modelos, y entra por opción por lo mismo
+     * que `ajustesDeDispositivos`: leerlo toca el `config.json` global, y un test del cable
+     * no puede estar leyendo el de quien lo corre. Ausente = no se afirma, que NO es lo mismo
+     * que decir que no hay ninguno.
+     */
+    modeloPorDefecto?: () => string | undefined;
+    /**
+     * Borra la credencial de `auth.json`. Ausente = esta ejecución no puede borrar, y la
+     * interfaz no ofrece el botón en vez de ofrecer uno que no hace nada.
+     */
+    borrarCredencial?: (proveedor: Proveedor) => {
+        ruta: string;
+        borrada: boolean;
+        quedaEnEntorno: boolean;
+    };
+    /**
+     * Escribe la credencial en `auth.json`. Entra por opción y no se importa aquí por lo
+     * mismo que todo lo que toca el disco en este repo: un valor por omisión que escribiera
+     * de verdad convertiría cualquier test de este cable en una escritura en el
+     * `~/.xonecode` de quien los corre.
+     */
+    guardarCredencial?: (proveedor: Proveedor, clave: string) => {
+        ruta: string;
+    };
+    /**
+     * Los proveedores personalizados dados de alta. Es una FUNCIÓN y no una lista porque se
+     * dan de alta en caliente desde esta misma ventana: una lista leída al montar las rutas
+     * se quedaría vieja hasta reiniciar.
+     */
+    proveedoresPersonalizados?: () => readonly ProveedorDeclarado[];
+    /**
+     * Da de alta o reescribe un proveedor personalizado. Ausente = esta ejecución no puede,
+     * y la ventana no ofrece el formulario en vez de ofrecer uno que no guarda nada.
+     */
+    guardarProveedor?: (declarado: ProveedorDeclarado) => {
+        ruta: string;
+    };
+    /** Retira uno. Su credencial la borra quien llama, con `borrarCredencial`. */
+    borrarProveedor?: (slug: string) => {
+        ruta: string;
+        borrado: boolean;
+    };
+    /**
+     * El catálogo VIVO de un proveedor. Ausente = esta ejecución no puede consultarlo, y el
+     * menú lo dice en vez de quedarse cargando para siempre.
+     */
+    catalogoDeModelos?: (proveedor: Proveedor) => Promise<{
+        id: string;
+        nombre?: string;
+    }[]>;
+    /**
+     * Lo que el servidor de un proveedor dice de UN modelo suyo. Hoy solo Ollama, que es el
+     * único cuyos modelos elige el usuario y no hay tabla que los describa.
+     *
+     * Entra por opción y no se importa aquí por la regla de siempre: toca la red, y sin ella
+     * `npm test` tendría que tener un Ollama levantado. Ausente = no se pregunta, y entonces
+     * un modelo de Ollama no ofrece esfuerzo — que es la dirección segura, porque pedírselo a
+     * uno que no piensa tumba el turno.
+     */
+    capacidadesDeModelo?: (proveedor: Proveedor, modelo: string) => Promise<{
+        piensa: boolean;
+    } | undefined>;
+    /** Qué ha tocado la sesión, y el parche de un fichero (`agent/sesiones/sesionGit.ts`). Ausentes =
+     *  esta ejecución no lo puede saber, y la pestaña lo dice. */
+    cambiosDeSesion?: (raiz: string, sesion: string) => Promise<{
+        via: "git" | "desde-apertura" | "sin-marca";
+        ficheros: FicheroTocado[];
+        mezclados?: number;
+    }>;
+    parcheDeSesion?: (raiz: string, sesion: string, ruta: string) => Promise<{
+        texto: string;
+        recortado: boolean;
+    } | undefined>;
+    /**
+     * El árbol del proyecto y el contenido de un fichero (`agent/grafo/arbolDeProyecto.ts`). Entran
+     * por opción porque tocan el disco del proyecto: un test del cable usa dobles.
+     */
+    arbolDelProyecto?: (raiz: string) => Promise<{
+        rutas: string[];
+        recortado: boolean;
+    }>;
+    /**
+     * La foto del modelo XOne (pestaña Colecciones, `core/fotoDeColecciones.ts`), sobre el mismo
+     * cargador que `xone_navegacion`. Por opción porque lee el proyecto con `xone-linter`.
+     */
+    coleccionesDelProyecto?: (raiz: string) => Promise<FotoDeColecciones>;
+    /**
+     * El visor de artefactos OpenUI ya construido (`apps/web/dist/openui/`), leído en CADA petición
+     * como el resto del cliente. `undefined` = no está construido, y entonces se DICE.
+     */
+    visorOpenui?: () => {
+        js: string;
+        css: string;
+    } | undefined;
+    /** Los planes del proyecto (`agent/planesEnDisco.ts`). Por opción porque lee su disco. */
+    planesDelProyecto?: (raiz: string) => PlanEnDisco[];
+    /**
+     * El diff SEMÁNTICO de un `.xne` de la sesión (`agent/sesiones/modeloDelCambio.ts`): toca git y
+     * el disco, así que entra por opción. `undefined` = no hay «antes» con el que comparar.
+     */
+    modeloDelCambio?: (raiz: string, sesion: string, ruta: string) => Promise<CambiosDeUnaColeccion[] | undefined>;
+    leerFichero?: (raiz: string, ruta: string) => Promise<FicheroDelProyecto>;
+    /**
+     * Guardar un fichero que la persona editó en la pestaña Ficheros
+     * (`agent/grafo/arbolDeProyecto.ts#escribirFicheroDeProyecto`). Por opción porque escribe en el
+     * disco del proyecto: un test del cable usa dobles.
+     */
+    escribirFichero?: (raiz: string, ruta: string, texto: string, huella: string) => Promise<{
+        ruta: string;
+        huella?: string;
+        error?: string;
+    }>;
+    /** La base de las marcas del editor (`agent/sesiones/baseDeFichero.ts`). Por opción porque toca git. */
+    baseDeFichero?: (raiz: string, sesion: string | undefined, ruta: string, base: "sesion" | "commit") => Promise<BaseDelFichero>;
+    /**
+     * La ruta relativa del icono de la app de una copia bajada (`agent/grafo/arbolDeProyecto.ts
+     * #iconoDelProyecto`), o `undefined` sin icono. Por opción porque lee el disco; ausente = ningún
+     * proyecto lleva icono y la barra pinta la carpeta de siempre.
+     */
+    iconoDelProyecto?: (raiz: string) => Promise<string | undefined>;
+    /**
+     * Los dos lectores de ARTEFACTOS (`agent/grafo/artefactosEnDisco.ts`), y son dos porque son dos
+     * transportes con necesidades opuestas: el del cable devuelve la forma de un fichero
+     * —texto al tope, imagen en base64— y el crudo devuelve los bytes tal cual, que es lo que
+     * el iframe necesita (un HTML recortado no abre) y lo que se descarga.
+     *
+     * Ausentes = esta ejecución no los tiene, y se dice: un visor que se queda «trayendo…»
+     * para siempre es peor que uno que explica que aquí no se puede.
+     */
+    leerArtefacto?: (raiz: string, sesion: string, nombre: string) => Promise<FicheroDelProyecto>;
+    leerArtefactoCrudo?: (raiz: string, sesion: string, nombre: string) => Promise<LecturaCruda>;
+    /**
+     * Qué hay en la máquina para probar la app (`agent/dispositivos/dispositivosEnMaquina.ts`). Ausente =
+     * esta ejecución no lo mira, y no se manda ningún `dispositivos`: el escritorio se queda
+     * en «consultando…» en vez de afirmar una máquina vacía. Entra por opción porque lanza
+     * procesos (adb, xcrun) y un test del cable no puede lanzarlos.
+     */
+    detectarDispositivos?: () => Promise<InformeDeDispositivos>;
+    /**
+     * Qué destinos se miran, leídos de `settings.json` en el momento de emitir. Se lee y no
+     * se cachea porque el fichero es del usuario y puede cambiar por fuera. Ausente = esta
+     * ejecución no los conoce y viaja `{}`, que significa «se miran todos».
+     */
+    ajustesDeDispositivos?: () => AjustesDeDispositivos;
+    /**
+     * Guarda esos ajustes. Ausente = la ventana no puede cambiarlos y el cable lo dirá
+     * quedándose como estaba: mejor que un interruptor que se mueve y no persiste.
+     */
+    guardarAjustesDeDispositivos?: (ajustes: AjustesDeDispositivos) => void;
+    /**
+     * Instala una herramienta que falta. Recibe el NOMBRE, nunca un comando: qué se lanza lo
+     * decide el host, porque un comando que llegue por el cable es una shell abierta en la
+     * máquina del usuario. Ausente = esta ejecución no instala nada.
+     */
+    instalarHerramienta?: (herramienta: NombreDeHerramienta) => Promise<void>;
+    /**
+     * Abre, en el sistema donde corre la consola, la carpeta que contiene el binario de una
+     * herramienta. Recibe la ruta ENTERA (host-only hasta aquí); nunca lanza y no tiene
+     * respuesta que esperar — un fallo aquí es accesorio, como abrir el navegador al arrancar.
+     * Ausente = esta ejecución no lo ofrece y el botón no se pinta.
+     */
+    abrirCarpetaDeHerramienta?: (ruta: string) => void;
+    /**
+     * Abre la carpeta de la copia local de un proyecto en el explorador de ficheros de ESTA
+     * máquina (el botón del resumen del proyecto). Recibe la raíz ENTERA, que no sale del host.
+     * Nunca lanza. Ausente = esta ejecución no lo ofrece, y el cable contesta 409 con el motivo.
+     * **Límite declarado**: por un túnel se abre en la máquina del servidor, no en la del navegador.
+     */
+    abrirCarpetaDeProyecto?: (raiz: string) => void;
+    /**
+     * VERIFICA la conexión con un dispositivo (`agent/dispositivos/dispositivosEnMaquina.ts`).
+     *
+     * Recibe el `Dispositivo` de la última medida y no un id del cliente: de él salen la
+     * plataforma y la clase, que son las que deciden qué comando se lanza — una cadena del
+     * navegador dentro de los argumentos de un proceso es la puerta que esto no abre. Ausente
+     * = esta ejecución no verifica nada y el botón no se pinta.
+     */
+    verificarDispositivo?: (dispositivo: Dispositivo) => Promise<{
+        ok: boolean;
+        detalle: string;
+    }>;
+    /**
+     * Arranca un AVD y espera a que el aparato aparezca
+     * (`agent/dispositivos/arranqueDeEmulador.ts`). **Ausente = esta ejecución no puede**, y
+     * entonces se dice en vez de pintar un botón muerto. Promete no lanzar.
+     */
+    arrancarEmulador?: (avd: string, opciones?: {
+        sinVentana?: boolean;
+    }) => Promise<{
+        ok: boolean;
+        detalle: string;
+    }>;
+    /**
+     * Crea un AVD con nombre (`agent/dispositivos/instalacionEnMaquina.ts#crearAvd`), con su salida en
+     * vivo. **Ausente = esta ejecución no crea**, y se dice. Comparte el cerrojo de las recetas:
+     * un `avdmanager` y un `sdkmanager` a la vez sobre el mismo SDK son la misma carrera.
+     */
+    crearAvd?: (nombre: string, alSalirLinea: (linea: string) => void, 
+    /** A partir de un AVD existente: `conDatos` clona la carpeta entera, si no solo su configuración. */
+    desde?: {
+        base: string;
+        conDatos: boolean;
+    }) => {
+        titulo: string;
+        cancelar: () => void;
+        terminado: Promise<{
+            estado: string;
+            motivo?: string;
+            ms: number;
+        }>;
+    };
+    /**
+     * Para un emulador por su consola (`arranqueDeEmulador.ts#pararEmulador`). Recibe la SERIE de
+     * la última medida, nunca una cadena del cliente sin comprobar. Promete no lanzar.
+     */
+    pararEmulador?: (serie: string) => Promise<{
+        ok: boolean;
+        detalle: string;
+    }>;
+    /**
+     * Elimina un AVD con su salida en vivo (`instalacionEnMaquina.ts#borrarAvd`). **Ausente = esta
+     * ejecución no elimina**, y se dice. Comparte el cerrojo con crear y las recetas. Promete no lanzar.
+     */
+    borrarAvd?: (nombre: string, alSalirLinea: (linea: string) => void) => {
+        titulo: string;
+        cancelar: () => void;
+        terminado: Promise<{
+            estado: string;
+            motivo?: string;
+            ms: number;
+        }>;
+    };
+    /** Guarda lo de UN AVD en `settings.json` (`settingsEnDisco.ts#guardarAjusteDeAvd`); `copiaDe`/`clon` son su procedencia. */
+    guardarAjusteDeAvd?: (avd: string, cambio: {
+        puerto?: number;
+        sinVentana?: boolean;
+        copiaDe?: string;
+        clon?: boolean;
+    }) => void;
+    /** Quita TODO lo guardado de un AVD al eliminarlo (`settingsEnDisco.ts#quitarAjustesDeAvd`): su puerto queda libre. */
+    quitarAjustesDeAvd?: (avd: string) => void;
+    /**
+     * La siembra de puertos al medir (`settingsEnDisco.ts#guardarPuertosAsignados`): solo AÑADE,
+     * un puerto ya guardado no se toca. Ausente = no se siembra y cada AVD sigue en el de fábrica.
+     */
+    guardarPuertosAsignados?: (asignados: Record<string, number>) => void;
+    /**
+     * Lo mismo para los móviles físicos Android, por su serie (IXCODE-32,
+     * `settingsEnDisco.ts#guardarPuertosDeFisicos`). Ausente = no se siembran, y cada físico usa el
+     * primero libre, que es el que la siembra le daría.
+     */
+    guardarPuertosDeFisicos?: (asignados: Record<string, number>) => void;
+    /**
+     * Qué se midió del framework de XOne en un dispositivo (`agent/dispositivos/dispositivosEnMaquina.ts`).
+     * Lanza adb, así que entra por opción.
+     *
+     * **Ausente = esta ejecución no lo mide, y el veredicto lo DICE**: la causa es
+     * `framework-no-medido` y su frase es «todavía no se ha mirado…», que es una frase y no un
+     * botón. Esa es la diferencia con no tener framework: las dos dan «no listo», pero una se
+     * arregla instalando y la otra mirando.
+     */
+    frameworkEnDispositivo?: (dispositivo: Dispositivo) => Promise<FrameworkMedido>;
+    /**
+     * ¿Existe esa ruta dentro del proyecto? Toca el disco, así que entra por opción.
+     *
+     * **Ausente = esta ejecución no lo comprueba, y entonces la comprobación de la conexión
+     * declarada se OMITE** — no se contesta «no está», que bloquearía un proyecto que funciona.
+     * Lo que no se puede comprobar no se afirma en ningún sentido, y el error caro aquí es el
+     * falso bloqueo: la frase que lo acompaña manda a buscar un fichero que sí está.
+     */
+    existeEnProyecto?: (raiz: string, rutaRelativa: string) => boolean;
+    /**
+     * Lanza la app en el dispositivo (`agent/dispositivos/lanzamientoEnMaquina.ts`). Ausente = esta ejecución
+     * no lanza nada, y el botón lo dice en vez de quedarse muerto.
+     *
+     * **Se pasa la función ENTERA y no sus dependencias.** `lanzarEnDispositivo` construye las
+     * suyas por dentro —el `https` de la subida, el ZIP en memoria, `frameworkEnDispositivo`, el
+     * `process.kill(-pid)` del grupo y el WebSocket del hotswap—, así que montarlas otra vez aquí
+     * sería un segundo sitio donde esa composición puede dejar de estar montada, con todo en
+     * verde. Lo único que este lado aporta es `alFase`: el recorrido, que es lo que viaja.
+     */
+    lanzarEnDispositivo?: (peticion: PeticionDeLanzamiento, deps: Pick<DependenciasDeLanzamiento, "alFase">) => LanzamientoEnCurso;
+    /**
+     * Llevar al aparato UN fichero recién guardado en el editor (`agent/dispositivos/recargaEnAparato.ts`).
+     * Ausente = esta ejecución no recarga, y el guardado sigue igual: la recarga es TRANSPARENTE.
+     */
+    recargarEnAparato?: (raiz: string, ruta: string, destino: DestinoDeRecarga) => Promise<ResultadoDeRecarga>;
+    /** Relanzar la app, a petición (lo que pide un CSS para verse). Ausente = no se ofrece. */
+    relanzarEnAparato?: (destino: DestinoDeRecarga) => Promise<ResultadoDeRecarga>;
+    /**
+     * Los modelos que ofrece un motor EXTERNO (`agent/config/modelosDeMotor.ts`). Ausente = esta
+     * ejecución no los sabe, y el desplegable lo dice en vez de quedarse vacío.
+     */
+    modelosDeMotor?: (motor: string) => Promise<{
+        modelos: {
+            id: string;
+            nombre: string;
+        }[];
+        error?: string;
+    }>;
+    /**
+     * Los motores locales de Ajustes (`agent/motores/motoresLocales.ts`): medir, probar e iniciar
+     * la sesión de Claude Code. Recibe con qué avisar de cada cambio. Ausente = esta ejecución no
+     * los toca, y la sección lo dice en vez de pintar botones muertos.
+     */
+    motoresLocales?: (alCambiar: () => void) => ServicioDeMotoresLocales;
+    /** El diagnóstico de Node de Ajustes → General. Ausente = esta ejecución no lo mide (tests, `run`). */
+    diagnosticoDeNode?: () => Promise<DiagnosticoDeNode>;
+    /**
+     * Ejecuta un paso de una receta (`agent/dispositivos/instalacionEnMaquina.ts`), con su salida en vivo.
+     * Ausente = esta ejecución no lanza nada y el botón no se ofrece: el paso se copia, que es
+     * lo que la receta hace de todas formas.
+     */
+    correrPasoDeReceta?: (receta: string, paso: number, alSalirLinea: (linea: string) => void) => {
+        titulo: string;
+        cancelar: () => void;
+        terminado: Promise<{
+            estado: string;
+            motivo?: string;
+            ms: number;
+        }>;
+    };
+    /**
+     * «Vuelve a mirar la cola de tareas» (`corredorDeTareas.ts#revisar`). Ausente = esta
+     * ejecución no ejecuta tareas.
+     *
+     * Hace falta AQUÍ porque abrir un proyecto es lo que BLOQUEA su raíz —gana la persona— y
+     * cerrarlo lo que la libera, y el corredor no tiene forma de enterarse: no hay
+     * temporizador, se revisa por evento. Sin esta llamada, una tarea que esperaba a que
+     * alguien cerrara un proyecto se quedaría esperando hasta el siguiente evento que no
+     * tiene nada que ver, y en la pantalla eso se lee como un cuelgue.
+     */
+    revisarTareas?: () => void;
+    /**
+     * La cola de tareas: el PUERTO de disco y el corredor, no operaciones sueltas.
+     *
+     * `crearTarea` no es una opción propia por lo mismo que `registrarEntorno` devuelve el
+     * entorno REGISTRADO en vez de que el llamante deduzca el id: **quien tiene el estado
+     * hace la resolución.** El cliente manda un id de proyecto y `Tarea.proyecto` necesita
+     * `{id, raiz, nombre}` — y esa raíz solo se puede calcular con `proyectos`,
+     * `entornoElegido` y `vestibulo.raizDeProyecto`, que son estado de este CIERRE (la misma
+     * resolución que ya hace `atenderSesion` para abrir por id). Un `crearTarea` recibido
+     * como función de fuera no tendría con qué resolverla — es justo el agujero que un
+     * primer intento de este cable dejó pasar. Por eso `montarRutas` construye los
+     * manejadores de crear/reintentar/descartar/terminar aquí dentro, con este `colaDeTareas`
+     * como único puerto de escritura. **No lo saques a una opción suelta**: quien lo intente
+     * se va a topar con la misma resolución que esto ya resuelve.
+     *
+     * Ausente = esta ejecución no ejecuta tareas, y no se manda ningún `tareas`: el kanban
+     * se queda diciendo que no ha llegado, en vez de afirmar que no hay tareas.
+     */
+    colaDeTareas?: Pick<TareasEnDisco, "listar" | "guardar" | "borrarTarea" | "guardarAdjunto" | "listarAdjuntos"> & Partial<Pick<TareasEnDisco, "carpetaDeAdjuntos">>;
+    /**
+     * Lo mínimo del corredor que este cable toca: `corriendoAqui` para LEER (el campo del
+     * mensaje `tareas`), y `cortar` para escribir — pero acotado a UNA tarea, nunca
+     * `arrancar`/`parar` el proceso entero. Task 14: `atenderAccionDeTarea` lo llama ANTES de
+     * `borrarTarea` para que descartar una `en-proceso` no deje su turno huérfano escribiendo
+     * en el proyecto sin que ninguna pantalla lo diga.
+     */
+    /**
+     * `ejecutaOtroProceso` va en un `Partial` a propósito: es la respuesta a «¿hay dueño?» y
+     * un corredor que no la sepa dar deja el campo AUSENTE en el cable, que es «no se sabe» —
+     * distinto de «nadie». Los dobles de test que no la implementan ejercitan justo ese caso.
+     */
+    corredorDeTareas?: Pick<Corredor, "corriendoAqui" | "cortar"> & Partial<Pick<Corredor, "ejecutaOtroProceso" | "mirar" | "dejarDeMirar">>;
+    /** El tope de concurrencia vigente, para el mensaje `tareas`. Ausente = `CONCURRENCIA_POR_OMISION`. */
+    concurrenciaDeTareas?: () => number;
+    /** Cambia el tope de concurrencia del corredor. Ausente = Ajustes no puede tocarlo. */
+    guardarConcurrencia?: (concurrencia: number) => void;
+    /**
+     * El workspace VIGENTE, ya en la forma del cable. Ausente = esta ejecución no lo dice, y
+     * entonces Ajustes no pinta el campo: un control sin dato detrás no se pinta.
+     */
+    workspace?: () => string;
+    /**
+     * Elige el workspace. Ausente = Ajustes lo enseña pero no deja cambiarlo — el mismo trato
+     * que `guardarConcurrencia`.
+     */
+    guardarWorkspace?: (ruta: string) => void;
+    /**
+     * Lo tecleado, EXPANDIDO contra la casa y validado con la regla del host: la ruta absoluta,
+     * o el motivo de que no valga. Ausente = no se puede MUDAR, y cambiar el workspace sigue
+     * siendo solo escribir el ajuste.
+     */
+    resolverWorkspace?: (ruta: string) => {
+        ruta: string;
+    } | {
+        motivo: string;
+    };
+    /** `~/.xonecode`: dónde vive el índice de tareas que la mudanza reescribe. */
+    casaXonecode?: string;
+    /**
+     * Abre el selector de carpeta NATIVO de esta máquina y devuelve la elegida, o AUSENTE si
+     * no se eligió ninguna. Ausente la OPCIÓN = este sistema no tiene selector (o esta
+     * ejecución no lo monta), y entonces el botón no se ofrece: un botón que no hace nada es
+     * peor que no tenerlo, y el campo de texto ya resuelve el caso.
+     */
+    elegirCarpeta?: (desde?: string) => Promise<string | undefined>;
+    /**
+     * La casilla «Depurar» de Ajustes > General, ya RESUELTA (`core/settings.ts#depuracionActiva`:
+     * ausente en disco es `true`, la omisión de esta etapa de pruebas). Ausente la OPCIÓN =
+     * Ajustes no pinta la casilla.
+     */
+    depuracionActiva?: () => boolean;
+    /** Cambia la casilla. Ausente = Ajustes la enseña pero no deja cambiarla. */
+    guardarDepuracion?: (activa: boolean) => void;
+    /**
+     * El modo con que NACEN las sesiones nuevas en cualquier proyecto (IXCODE-31), ya RESUELTO
+     * (ausente en disco = supervisado). Ausente la OPCIÓN = Ajustes no pinta el control.
+     */
+    modoPorDefectoGlobal?: () => ModoDeEscritura;
+    /** Cambia el global. Ausente = Ajustes lo enseña pero no deja cambiarlo. */
+    guardarModoPorDefectoGlobal?: (modo: ModoDeEscritura) => void;
+    /**
+     * El aparato con que NACEN las sesiones nuevas (IXCODE-51). Ausente la OPCIÓN = Ajustes no
+     * pinta el control; devolver `undefined` = ninguno elegido.
+     */
+    dispositivoPorDefecto?: () => DispositivoElegido | undefined;
+    /** Cambia —o quita— el aparato por defecto. Ausente = Ajustes lo enseña sin dejar cambiarlo. */
+    guardarDispositivoPorDefecto?: (dispositivo: DispositivoElegido | undefined) => void;
+    /** El modo de las sesiones nuevas de un proyecto, por su RAÍZ. Ausente = el panel no lo pinta. */
+    modoDelProyecto?: (raiz: string) => ModoDeEscritura | undefined;
+    /** Fija —o quita, con `undefined`— el de un proyecto. */
+    guardarModoDelProyecto?: (raiz: string, modo: ModoDeEscritura | undefined) => void;
+    /**
+     * Augmenta una petición en un encargo revisado (`agent/tareas/aumentador.ts`, Task 9). Ausente =
+     * el botón «Preparar el encargo» no está disponible.
+     */
+    augmentar?: (peticion: {
+        texto: string;
+        /**
+         * El proyecto RESUELTO, con su raíz. La resuelve este cierre —igual que al crear una
+         * tarea— porque el cliente solo manda el id: nunca ha visto una ruta de la máquina. Y la
+         * raíz hace falta para que el papel `trabajo` se resuelva con el `config.json` del
+         * proyecto, la misma trampa que `CasoDeJuez.raiz` documenta.
+         */
+        proyecto: {
+            id: string;
+            raiz: string;
+            nombre: string;
+        };
+        /** Nombres y tipos, nunca contenido: salen del DISCO, de la carpeta del borrador. */
+        adjuntos: readonly {
+            nombre: string;
+            mime?: string;
+        }[];
+        /** La pantalla de Stitch elegida, ya comprobada contra el vínculo del proyecto. */
+        pantallaDeStitch?: {
+            name: string;
+            titulo: string;
+            proyecto?: string;
+        };
+    }) => Promise<string>;
+    /**
+     * Los conectores MCP de esta consola: una FÁBRICA, y no el servicio ya construido. El
+     * arranque la llama UNA vez al montar, con su propio `emitirConectores` como `alCambiar` —
+     * así el servicio puede avisar de un cambio que ocurre en segundo plano (autorizar, probar)
+     * sin que `montarRutas` tenga que exponer su sumidero. Ausente = esta ejecución no ofrece
+     * conectores: ni el mensaje `conectores` se manda, ni la ruta del callback se registra —
+     * «un control sin dato detrás no se pinta».
+     */
+    conectores?: (alCambiar: () => void) => ServicioDeConectores;
+    /**
+     * El gestor de tareas de cada conector (IXCODE-11): `undefined` para un conector que no lo
+     * es. `montarRutas` lo MEMORIZA —una instancia por conector mientras vive el cable—, así que
+     * la fábrica puede construir en cada llamada. Ausente = esta ejecución no tiene gestor, y el
+     * mensaje `gestor` se contesta con ese error. En producción sale de `ajusteDeGestorCableado`.
+     */
+    /** «Mirar ahora» del sondeo de la puerta 2 (`agent/tareas/sondeoDelGestor.ts`). Ausente = esta ejecución no mira. */
+    mirarGestor?: () => Promise<ResultadoDelSondeo>;
+    gestorDeTareas?: (conector: string) => GestorDeTareasPort | undefined;
+}
+/**
+ * El texto con cada cosa con forma de CORREO cambiada por «[correo]». Para lo que cruza el cable
+ * desde el gestor de tareas: ni correos por el cable (IXCODE-11), y el texto de error de una tool
+ * de Jira es suyo, no nuestro. La forma es deliberadamente ANCHA —algo@algo.algo sin espacios—:
+ * tachar de más en un mensaje de error cuesta poco; dejar pasar un correo, no.
+ */
+export declare function sinCorreos(texto: string): string;
+/** Un error de un gestor de tareas como texto que puede cruzar el cable y quedarse en una tarea: de Node solo el
+ *  `code`, y del resto la primera línea con los correos TACHADOS y recortada (la regla de `motivoDelGestor`). */
+export declare function motivoDeGestorParaElCable(error: unknown): string;
+/**
+ * Lo que lleva el comentario de cierre de una tarea: lo mismo que el «Cerrar en …» de un chat sobre SU conversación
+ * (ficheros y commits de la sesión, el último veredicto del verificador, la última respuesta). Sin conversación, o si
+ * no se puede leer, un cierre sin datos —«no corrió», nunca un «verde» inventado—.
+ */
+/**
+ * Las copias locales con el DISPARO del gestor encendido (la puerta 2): `<workspace>/<entorno>/<proyecto>` con su
+ * `config.json`, de donde salen su identidad (`cloudstudio.proyecto`: el id con el que la pestaña Tareas filtra) y su
+ * vínculo. Se relee en cada pasada: el interruptor se cambia con todo en marcha. Lo que no se puede leer se salta.
+ */
+export declare function copiasConGestor(base: string): CopiaConGestor[];
+export declare function datosDeCierreDeTarea(tarea: Tarea): Promise<DatosDeCierre>;
+/**
+ * Monta `/eventos` y `/accion` sobre un servidor ya levantado.
+ *
+ * Separada de `arrancarConsolaWeb` para poder probar el cable entero —conexión, registro
+ * de comandos, alta, cambio de proyecto— sin puerto, sin disco y sin navegador: los
+ * manejadores se invocan con dobles de petición y respuesta.
+ *
+ * Devuelve `emitirTareas`: el corredor de tareas NACE antes que este cable (lo necesita
+ * `arrancarConsolaWeb` para pasarle `corredorDeTareas`), así que su `alCambiar` —un cambio
+ * de estado que nace DENTRO del lazo, no de una petición del cliente— no tiene manera de
+ * alcanzar el `emitir` de aquí salvo que se lo devuelva. Es la misma costura que
+ * `vestibulo.alCambiarEstadoDeSesion`, solo que el emisor nace después que quien lo
+ * necesita en vez de antes.
+ */
+export declare function montarRutas(servidor: Pick<ServidorWeb, "registrarRuta" | "registrarRutaPublica" | "puerto">, vestibulo: Vestibulo, opciones?: OpcionesDeMontaje): {
+    emitirTareas: () => void;
+    cerrarRemoto: () => Promise<void>;
+};
+/**
+ * El sondeo de la puerta 2 CABLEADO: extraído de `arrancarConsolaWeb` para poder probar la composición de verdad (el
+ * patrón de fallo de siempre: una regla de producción en un cierre que todos los tests doblan). Dos cosas que solo se
+ * ven aquí: lo que el sondeo guarda va por la cola ENVUELTA (así el reflejo en el gestor dispara), y tras guardar se
+ * EMITE la cola —el corredor solo emite en sus propias escrituras, y una tarea que no puede arrancar todavía (la
+ * persona tiene la consola de ese proyecto abierta) no salía en la pantalla—. Lo que falla en una pasada, también la
+ * primera, se dice.
+ */
+export declare function construirSondeoCableado(o: {
+    corredor: Pick<Omit<Corredor, "arrancar">, "revisar" | "corriendoAqui">;
+    cola: Pick<TareasEnDisco, "listar" | "guardar">;
+    copias: () => CopiaConGestor[];
+    gestorDe: (conector: string) => GestorDeTareasPort | undefined;
+    augmentar?: OpcionesDelSondeoCableado["augmentar"];
+    emitirTareas: () => void;
+    informar: (texto: string) => void;
+}): SondeoDelGestor;
+type OpcionesDelSondeoCableado = Parameters<typeof crearSondeoDelGestor>[0];
+export interface CorredorDeTareasCableado {
+    /** `undefined` si esta ejecución no tiene cola (`tareasFabrica` ausente): entonces no
+     *  hay nada que revisar. Sin `arrancar`: la única forma de arrancar el corredor devuelto
+     *  aquí fuera es `arrancarConectado`, que ata el orden puente-antes-que-arranque. Exponer
+     *  `arrancar` en este tipo dejaría `corredor?.arrancar()` compilando fuera de esa función
+     *  — el mismo fallo que esta extracción existe para hacer imposible. */
+    corredor: Omit<Corredor, "arrancar"> | undefined;
+    /** Lo que hay que fundir en las opciones de `montarRutas`. */
+    opcionesDeMontaje: Pick<OpcionesDeMontaje, "colaDeTareas" | "corredorDeTareas" | "concurrenciaDeTareas" | "guardarConcurrencia">;
+    /**
+     * Arranca el corredor YA conectado al cable. Es UNA función y no dos —«conecta el
+     * puente» y luego «arranca»— porque separarlas es exactamente el fallo que este
+     * cableado puede volver a cometer: un test que las llame en el orden que no toca no
+     * falla nunca si nada comprueba el orden, y en producción el corredor puede reconciliar
+     * y disparar `alCambiar` antes de que el puente esté puesto. Horneando el orden aquí
+     * dentro, quien llame no tiene manera de equivocarse.
+     */
+    arrancarConectado: (cable: {
+        emitirTareas: () => void;
+    }) => Promise<void>;
+}
+/**
+ * Construye el corredor de tareas y la costura que lo conecta al cable.
+ *
+ * Extraído de `arrancarConsolaWeb` a su propia función por la MISMA razón que
+ * `backendDeAgente` (`agent/grafo/proyecto.ts`): la composición vivía inline dentro de una
+ * función que todos sus tests DOBLAN —`vestibulo`, `crearServidor`, `crearEjecutor`—, así
+ * que esta costura concreta podía dejar de estar montada con el resto en verde. Aquí
+ * tiene su propio test que la compone de VERDAD: construye un corredor real
+ * (`crearCorredorDeTareas`) y comprueba que un cambio que el corredor mueve por su
+ * cuenta —nace DENTRO del lazo, no de una petición del cliente— llega a
+ * `emitirTareas`, y que si `emitirTareas` revienta el lazo de tareas no se entera.
+ */
+/**
+ * Las fuentes con que se resuelve el papel del JUEZ para una tarea, por la raíz de SU
+ * proyecto.
+ *
+ * Está extraída y exportada por el mismo motivo que `revisionConGit` y que `backendDeAgente`:
+ * vivía dentro del cierre de `arrancarConsolaWeb`, que todos sus tests doblan, así que
+ * quitarle la capa de proyecto no ponía ni un test en rojo — comprobado por mutación. Es la
+ * cuarta vez en esta tanda que una composición de producción escondida en un cierre deja una
+ * regla sin montar con todo en verde.
+ *
+ * Las dos capas salen de `cargar(raiz)`, que trae el `config.json` del proyecto y el global:
+ * en la consola web `FuentesDeEleccion.proyecto` no se rellena nunca —el vestíbulo sirve
+ * muchos proyectos y las fuentes se construyen una vez al arrancar—, así que sin preguntarle
+ * al disco por la raíz de la tarea, un proyecto que apuntara `afilado` a otro modelo se
+ * ignoraba en silencio. La misma trampa que `cloudstudioDelProyecto` ya resolvió así.
+ *
+ * `proyecto` se omite en vez de ponerse a `undefined`: ausente es «este proyecto no dice
+ * nada», y la precedencia de `core/modelos.ts` cuenta con eso.
+ */
+export declare function fuentesDelJuez(raiz: string): FuentesDeEleccion;
+/**
+ * Las fuentes del modelo con que arranca CADA consola de proyecto del vestíbulo.
+ *
+ * Es una función y no una constante por lo mismo que `fuentesDelJuez` está extraída: vivía
+ * dentro del cierre de `vestibuloReal` y se construía UNA vez, al arrancar. El global es del
+ * usuario —esta misma consola lo reescribe desde Ajustes—, así que la instantánea dejaba a
+ * las sesiones NUEVAS resolviendo contra el valor viejo mientras Ajustes enseñaba ya el
+ * elegido. El síntoma, medido: el proceso arrancó con `gemini` en el fichero, el fichero pasó
+ * a `ollama`, y una sesión nueva seguía diciendo `gemini`.
+ *
+ * La capa de PROYECTO no se rellena —el vestíbulo sirve muchos proyectos a la vez y aquí no
+ * hay uno del que hablar—, así que se llama a `cargar` por el cwd SOLO para llegar al fichero
+ * global, que es el único que este lector tiene que ver. Mismo camino que `modeloPorDefecto`.
+ */
+export declare function fuentesDeLaConsolaWeb(cwd: string): FuentesDeEleccion;
+/**
+ * Cuánta memoria de proyecto se le da al aumentador.
+ *
+ * Es CONTEXTO de una llamada, no un fichero que servir: `.xonecode/memoria.md` lo escribe el
+ * agente turno tras turno y puede crecer sin tope. Y el árbol del proyecto ya se descartó por
+ * lo mismo (§7 del diseño: «el árbol entero sería contexto por gastar»); dejar la memoria sin
+ * acotar reintroduciría el problema por la puerta de al lado.
+ */
+export declare const TOPE_DE_MEMORIA = 4000;
+/**
+ * Lo que se le añade a la petición del aumentador leyendo el DISCO por la raíz: la rama del
+ * proyecto y su memoria.
+ *
+ * **Por la raíz y no por las fuentes**, la trampa que `cloudstudioDelProyecto` ya resolvió:
+ * en la consola web `FuentesDeEleccion.proyecto` no se rellena nunca. Y lo que el disco no
+ * dice NO se pone —ausente es «no hay»—: un `rama: undefined` o un `memoria: ""` en el prompt
+ * harían que el modelo hablara de una rama sin nombre como si fuera un dato.
+ *
+ * Nada de esto lanza. Que no haya memoria, o que el `config.json` no se pueda leer, no puede
+ * impedir redactar un encargo.
+ */
+export declare function contextoDelProyecto(raiz: string): {
+    rama?: string;
+    memoria?: string;
+    conectores?: string[];
+};
+/**
+ * Cruza la elección GUARDADA de la sesión con la última MEDIDA del equipo.
+ *
+ * **Esto es la costura entera de `dispositivo-desconocido`, y sin ella esa causa no tiene
+ * emisor.** Las dos situaciones —«no has elegido ninguno» y «elegiste uno que ya no está»—
+ * llegan a `puedeLanzarse` con `dispositivo: undefined`, porque la diferencia no cabe en el
+ * dato del dispositivo: no hay ninguno. Lo único que las separa es el `elegido`, y quien lo
+ * sabe es la SESIÓN, que guarda la foto (`ConsolaDeProyecto.dispositivo`) mientras el informe
+ * la resuelve.
+ *
+ * **Se resuelve por lo que NO se encontró**: con un id guardado que no está en la medida, la
+ * causa es `dispositivo-desconocido`; sin id guardado no hay nada que buscar y ése es
+ * `sin-dispositivo-elegido`. Y cuando el id SÍ resuelve, `elegido` no se pone — manda
+ * `dispositivo`, que es el dato bueno.
+ *
+ * La rama `dispositivo` del cable (`POST /accion`) ya tolera en silencio un id que no esté en
+ * la medida —es una foto vieja del cliente, no un error que contar—; aquí ese mismo caso se
+ * CUENTA, porque es justo lo que decide la frase que se le enseña a quien va a pulsar.
+ *
+ * Extraída y exportada por la razón de siempre: es una regla de producción, y compuesta dentro
+ * de un cierre que los tests doblan no estaría probada — estaría escrita.
+ */
+export declare function dispositivoDeLaSesion(elegido: DispositivoElegido | undefined, informe: InformeDeDispositivosDelCable | undefined): {
+    dispositivo: Dispositivo | undefined;
+    elegido?: string;
+};
+/**
+ * Lo que la pestaña CloudStudio enseña: de qué rama es este proyecto y cuántos ficheros
+ * quedan por subir.
+ *
+ * **Extraída y exportada, no inline en el manejador del cable**, por la razón de siempre en
+ * esta casa: una regla de producción compuesta dentro de un cierre que los tests doblan no
+ * está probada, está escrita. Aquí lo que se caería sin síntoma es la MEDIDA —una lectura
+ * que devolviera cero pendientes siempre se vería como un proyecto al día, que es
+ * exactamente lo que nadie iría a comprobar—.
+ *
+ * Se mide contra la ref de seguimiento (`refs/remotes/cloudstudio/<rama>`), que es la MISMA
+ * cuenta que da `/sync estado` y la que decide qué sube el plan, y **sin abrir sesión MCP**:
+ * el número no está arriba, está en esa ref, y abrir OAuth para contar lo que ya se sabe en
+ * local sería pedir red y credenciales para pintar un contador. El comando del terminal sí
+ * la abre —es genérico y no se toca—; la diferencia se declara aquí.
+ *
+ * Un mensaje SIN `proyecto` ni `rama` no es un fallo: es que este proyecto no está dado de
+ * alta en CloudStudio, y quien lo pinta tiene que poder decir eso en vez de un cero.
+ *
+ * `sesion` entra para poder decir DE QUIÉN son los pendientes (`deLaSesion`), que es lo que
+ * evita que las dos cifras de la pestaña —la de la banda y la de la lista— parezcan
+ * contradecirse cuando en realidad se miden contra referencias distintas.
+ */
+export declare function lecturaDeSync(raiz: string, sesion?: string): Promise<Extract<MensajeAlCliente, {
+    clase: "sync";
+}>>;
+/**
+ * TODO lo pendiente de subir del proyecto, como mensaje del cable (la pestaña Sincronización del
+ * panel). Sin CloudStudio, o si la medida falla, lo DICE: «no se pudo medir» no es «nada».
+ */
+export declare function lecturaDePendientesDeSubida(raiz: string): Promise<Extract<MensajeAlCliente, {
+    clase: "pendientesDeSubida";
+}>>;
+/**
+ * El diff de UN fichero pendiente, con las DOS guardas antes de tocar git:
+ * - la ruta tiene que estar en la lista pendiente RECIÉN medida —una ruta inventada por el
+ *   cable no saca nada del disco—;
+ * - y tiene que poder ENSEÑARSE con la MISMA regla del lector que Ficheros y Revisión
+ *   (`motivoParaNoEnsenar`, texto y `realpath`): un `.env` pendiente sale en la lista, pero su
+ *   diff NO viaja nunca.
+ */
+export declare function lecturaDeParcheDeSubida(raiz: string, ruta: string): Promise<Extract<MensajeAlCliente, {
+    clase: "parcheDeSubida";
+}>>;
+/**
+ * Marca cada fichero de la sesión con si sigue PENDIENTE de subir a CloudStudio.
+ *
+ * Revisión enseña solo lo de la sesión que falta por subir: lo ya subido no es nada que
+ * revisar antes de subir. Se decide aquí y no en el cliente porque la lista (`revision`) y la
+ * medida (`sync`) son dos mensajes que llegan en momentos distintos, y cruzar uno nuevo con
+ * uno viejo escondería justo el fichero que el agente acaba de escribir —sin un solo error—.
+ *
+ * Misma medida que la banda (`cambiosPendientes` contra la ref de la bajada) y mismo cruce
+ * por ruta exacta que `cuantosDeLaSesion`, **más lo que git aún no sigue** (`sinSeguir`): un
+ * fichero recién creado a mitad de turno no sale en `git diff` y quedaría escondido justo
+ * cuando más falta hace verlo. La regla: lo que la ref no confirma como subido, se enseña. **Sin CloudStudio, o si la medida falla, los
+ * ficheros vuelven SIN la marca**: «no consta» no es «nada pendiente», y Revisión enseña
+ * entonces todo. No va dentro de `cambiosDeSesion`, que usan también el comentario de cierre,
+ * Soporte y `cuantosDeLaSesion`.
+ */
+export declare function marcarPendientes<F extends {
+    ruta: string;
+}>(raiz: string, ficheros: readonly F[]): Promise<Array<F & {
+    pendiente?: boolean;
+}>>;
+/**
+ * La costura entre el cable y el aumentador: convierte lo que `montarRutas` resuelve
+ * —proyecto y adjuntos— en la `PeticionDeTarea` del puerto, añadiéndole lo que solo se sabe
+ * mirando el disco.
+ *
+ * **Extraída y exportada, no inline en `arrancarConsolaWeb`**, por la misma razón que
+ * `revisionConGit` y `fuentesDelJuez`: en esta tanda cuatro veces una composición de
+ * producción vivía en un cierre que todos sus tests doblan, y una regla se quedó sin montar
+ * con todo en verde. Lo que aquí se caería sin dar ni un síntoma es la mitad del contexto: un
+ * encargo redactado sin la rama ni la memoria del proyecto se ve perfectamente normal.
+ *
+ * El error se PROPAGA: quien lo convierte en palabras para la ventana es `atenderAugmentar`,
+ * que aplica la regla del mensaje-o-código. Tragárselo aquí dejaría a la ventana con un
+ * encargo vacío y sin motivo.
+ */
+export declare function augmentacionCableada(opciones: {
+    aumentador: AumentadorPort;
+    /** Por parámetro para poder probar esta composición sin tocar disco. Por omisión,
+     *  `contextoDelProyecto`; ausente del todo = sin rama ni memoria. */
+    contexto?: (raiz: string) => {
+        rama?: string;
+        memoria?: string;
+        conectores?: string[];
+    };
+}): NonNullable<OpcionesDeMontaje["augmentar"]>;
+/**
+ * El commit de cada turno, cableado — y extraído por el motivo documentado en CLAUDE.md:
+ * esta composición vivía en un cierre de `arrancarConsolaWeb` que todos sus tests doblan, y
+ * es LA MISMA forma de fallo que ya se ha medido tres veces en `abrirParaTarea` (una lambda
+ * escrita a mano que se deja un argumento, con TypeScript callado porque una función que
+ * ignora parámetros es asignable). Aquí el argumento que se puede caer es el que sostiene la
+ * atribución entera: sin `sesion`, el commit sale sin sello y la pestaña Revisión se cae al
+ * respaldo para siempre, sin un solo síntoma.
+ *
+ * Dos decisiones que se quedan aquí y no en el vestíbulo:
+ * - **DÓNDE se commitea**: solo en la copia que creó xonecode. En la carpeta que abrió una
+ *   persona —offline, o `./bin/xonecode` dentro de su repo— un commit por turno sería
+ *   ensuciarle el historial cada vez que habla con el agente.
+ * - **Qué se DICE**: solo el fallo. Que no haya nada que commitear, que la carpeta no sea un
+ *   repo (todo proyecto offline) o que no sea del workspace no son avisos: son el caso
+ *   normal, y uno por turno enseñaría a ignorarlos.
+ */
+export declare function commitDeTurnoCableado(opciones: {
+    /** Una FUNCIÓN y no un valor: `settings.workspace` cambia con la consola en marcha, y una
+     *  base capturada al arrancar pararía los commits por turno EN SILENCIO en cuanto alguien
+     *  lo tocara — `dentroDelWorkspace` compararía contra la carpeta de antes. */
+    base: () => string;
+    commitear?: (raiz: string, mensaje: string, sesion?: string) => Promise<{
+        via: string;
+        motivo?: string;
+    }>;
+}): (raiz: string, mensaje: string, sesion: string) => Promise<string | undefined>;
+/**
+ * El mantenimiento de la memoria del agente, cableado — y EXTRAÍDO por el motivo de siempre:
+ * compuesto dentro del cierre de `arrancarConsolaWeb`, que todos sus tests doblan, esta regla
+ * estaría escrita y no probada. Es la novena vez que este repo tropieza con lo mismo.
+ *
+ * Lo que aquí se puede caer sin que TypeScript diga nada son las DOS mitades: pedir el
+ * checkpointer del proyecto que TOCA —`crearCheckpointerDeProyecto` devuelve la conexión
+ * compartida, y una segunda competiría con nosotros mismos por el lock exclusivo del
+ * `VACUUM`— y devolver el resumen en vez de tragárselo, que es lo único que hace visible que
+ * esto corrió.
+ *
+ * `podar` entra por parámetro para poder mirarlo desde fuera sin una base delante.
+ */
+export declare function mantenimientoDeMemoriaCableado(opciones?: {
+    podar?: typeof mantenimientoDelCheckpointer;
+    checkpointer?: typeof crearCheckpointerDeProyecto;
+}): (raiz: string) => string | undefined;
+/**
+ * La mudanza de una vez de las copias que siguen en el reparto viejo, cableada — y extraída
+ * por el motivo de siempre: compuesta dentro del cierre de `arrancarConsolaWeb`, que todos
+ * sus tests doblan, la regla estaría escrita y no probada.
+ *
+ * Lo que aquí se puede caer sin que TypeScript diga nada son las DOS bases, que no son la
+ * misma cuenta: la VIEJA es `settings.workspace` si estaba puesto —el reparto viejo metía su
+ * `workspace/` en medio fuera cual fuera la base— o `~/.xonecode` a secas; la de AHORA es ese
+ * mismo `settings.workspace` o `~/.xonecode/workspace`. Confundirlas en cualquiera de los dos
+ * sentidos da el mismo resultado: una mudanza que no encuentra nada y no dice nada.
+ *
+ * Y se ESCRIBE en el terminal, nunca por el cable: lo que se cuenta son rutas de la máquina
+ * y nombres de proyecto (`sinRutas`). Corre antes de que exista el vestíbulo, así que ni
+ * siquiera hay cable donde emitirlo.
+ */
+export declare function mudarWorkspaceLegadoCableado(opciones: {
+    settings: Pick<Settings, "entornos" | "workspace">;
+    escribir: (texto: string) => void;
+    mudar?: typeof mudarWorkspaceLegado;
+}): ResultadoDeMudanza;
+/**
+ * Las dos mitades del ajuste del workspace, cableadas — y extraídas por el motivo de
+ * siempre: dentro del cierre de `arrancarConsolaWeb`, que todos sus tests doblan, ni una ni
+ * otra estaría probada. Y aquí `guardarWorkspace` LLEVABA la marca: existía en
+ * `agent/config/settingsEnDisco.ts` con un test propio y CERO llamadores de producción, o
+ * sea el ajuste escrito que no hacía nada porque nadie lo había enchufado.
+ *
+ * Tres cosas que se deciden aquí y no en la pantalla:
+ * - **Qué se LEE**: el disco, en cada emisión, no un valor capturado al arrancar. Es la misma
+ *   regla que `baseDeWorkspace`, y aquí además cierra el lazo: lo que se acaba de guardar es
+ *   lo que se vuelve a emitir.
+ * - **Qué se ACEPTA**: `motivoDeWorkspaceInaceptable` sobre la ruta ya expandida, en el
+ *   servidor. El cliente lleva su copia declarada para explicar el no, pero una pantalla
+ *   solo esconde un botón.
+ * - **Qué se GUARDA y qué se ENSEÑA**: la ruta ENTERA, nunca un `~/…`. En el fichero porque
+ *   la casa cambia de una máquina a otra y un `~` dentro solo significa algo para quien lo
+ *   escribió; en la pantalla porque una ruta abreviada no se puede comprobar de un vistazo,
+ *   que es para lo que ese campo existe. Se probó a mandarla abreviada —para que el caso
+ *   normal no llevara el nombre de la cuenta— y no se sostiene: la cabecera de esa misma
+ *   consola ya saluda por el nombre del usuario. El `~` sigue ACEPTÁNDOSE al teclear, que es
+ *   comodidad de entrada y otra cosa.
+ */
+export declare function ajusteDeWorkspaceCableado(opciones: {
+    casa: string;
+    leer?: () => string | undefined;
+    guardar?: (ruta: string) => void;
+}): {
+    workspace: () => string;
+    guardarWorkspace: (ruta: string) => void;
+    resolverWorkspace: (ruta: string) => {
+        ruta: string;
+    } | {
+        motivo: string;
+    };
+    casaXonecode: string;
+};
+/**
+ * Los tres puertos de la pestaña Ficheros —leer, guardar y la base de las marcas—, cableados con las
+ * funciones de verdad y extraídos por el MISMO motivo que `emuladoresCableados`: dentro de
+ * `arrancarConsolaWeb` serían un literal que ningún test mira, y cada uno es un campo OPCIONAL de
+ * `montarRutas`, así que olvidarlo compila y pasa.
+ */
+export declare function ficherosCableados(): Required<Pick<OpcionesDeMontaje, "leerFichero" | "escribirFichero" | "baseDeFichero" | "iconoDelProyecto">>;
+/**
+ * Los motores locales de Ajustes, con el servicio de VERDAD: sin más que el aviso, todo lo demás
+ * —el binario del SDK, los procesos, la prueba por el mismo puerto que un subagente— son sus
+ * omisiones. Compuesto aquí y no en línea para que la composición de producción tenga test.
+ */
+/** El diagnóstico de Node REAL, compuesto fuera para que tenga test (el patrón de `motoresLocalesCableados`). */
+export declare function diagnosticoDeNodeCableado(): Required<Pick<OpcionesDeMontaje, "diagnosticoDeNode">>;
+export declare function motoresLocalesCableados(): Required<Pick<OpcionesDeMontaje, "motoresLocales">>;
+/**
+ * Los siete puertos de los emuladores, cableados con las funciones de verdad — extraídos por el
+ * MISMO motivo que `ajusteDeWorkspaceCableado`: dentro de `arrancarConsolaWeb` serían un literal
+ * que ningún test mira, y cada uno es un campo OPCIONAL de `montarRutas`, así que olvidarlo o
+ * perder un argumento por el camino compila y pasa.
+ *
+ * `casa` es la del `settings.json` donde se guardan los ajustes por AVD; ausente, la del usuario
+ * (`guardarAjusteDeAvd(undefined, …)`). `arrancar` entra solo para que un test vea qué recibe la
+ * de verdad sin lanzar un emulador.
+ */
+/**
+ * La recarga en caliente del editor, con las funciones de VERDAD y compuesta fuera del cableado
+ * por la trampa de siempre: un campo opcional olvidado en `arrancarConsolaWeb` deja la casilla
+ * pintada y sin hacer nada, con todo en verde. El `adb` y el canal reales los ponen ellas.
+ */
+export declare function recargaCableada(): Required<Pick<OpcionesDeMontaje, "recargarEnAparato" | "relanzarEnAparato">>;
+export declare function emuladoresCableados(opciones?: {
+    casa?: string;
+    arrancar?: typeof arrancarEmulador;
+}): Required<Pick<OpcionesDeMontaje, "arrancarEmulador" | "crearAvd" | "borrarAvd" | "pararEmulador" | "guardarAjusteDeAvd" | "quitarAjustesDeAvd" | "guardarPuertosAsignados" | "guardarPuertosDeFisicos">>;
+/**
+ * Las dos mitades de la casilla «Depurar», cableadas — extraídas por el MISMO motivo que
+ * `ajusteDeWorkspaceCableado`. `leer`/`guardar` entran por parámetro, y no como en el workspace
+ * porque una prueba no puede leer NI escribir el `settings.json` real de quien corre la suite
+ * (compartido por todo el worker vía `casaDePruebas.ts`): a diferencia del workspace, aquí no
+ * hay ninguna regla que aplicar sobre el valor (un booleano no se puede rechazar), así que la
+ * única razón de existir es esta — la MISMA costura de siempre, sin la mitad de validación.
+ */
+export declare function ajusteDeDepuracionCableado(opciones?: {
+    leer?: () => boolean | undefined;
+    guardar?: (activa: boolean) => void;
+}): {
+    depuracionActiva: () => boolean;
+    guardarDepuracion: (activa: boolean) => void;
+};
+/**
+ * El modo con que NACEN las sesiones nuevas (IXCODE-31), cableado: el global
+ * (`settings.json#modoDeEscritura`, Ajustes > General) y el de cada proyecto
+ * (`.xonecode/config.json#modoDeEscritura`, panel del proyecto). Extraída por el patrón de
+ * fallo de siempre, y con una trampa concreta que el test vigila: el del proyecto se lee por la
+ * RAÍZ, porque en la web `fuentes().proyecto` no se rellena nunca — leerlo de ahí daría el
+ * ajuste por guardado y no se aplicaría jamás.
+ */
+export declare function ajusteDeModoPorDefectoCableado(opciones?: {
+    leerGlobal?: () => ModoDeEscritura | undefined;
+    guardarGlobal?: (modo: ModoDeEscritura) => void;
+    leerProyecto?: (raiz: string) => ModoDeEscritura | undefined;
+    guardarProyecto?: (raiz: string, modo: ModoDeEscritura | undefined) => void;
+}): {
+    modoPorDefecto: (raiz: string) => {
+        proyecto?: ModoDeEscritura;
+        global?: ModoDeEscritura;
+    };
+    modoPorDefectoGlobal: () => ModoDeEscritura;
+    guardarModoPorDefectoGlobal: (modo: ModoDeEscritura) => void;
+    modoDelProyecto: (raiz: string) => ModoDeEscritura | undefined;
+    guardarModoDelProyecto: (raiz: string, modo: ModoDeEscritura | undefined) => void;
+};
+/**
+ * El aparato con que NACEN las sesiones nuevas (IXCODE-51), cableado contra `settings.json`.
+ * Extraída por el patrón de fallo de siempre: la lectura va al vestíbulo (cada apertura) y a
+ * Ajustes, y las dos tienen que leer el MISMO fichero que escribe el guardado.
+ */
+export declare function ajusteDeDispositivoPorDefectoCableado(opciones?: {
+    casa?: string;
+}): {
+    dispositivoPorDefecto: () => DispositivoElegido | undefined;
+    guardarDispositivoPorDefecto: (dispositivo: DispositivoElegido | undefined) => void;
+};
+/**
+ * La opción `conectores` de `montarRutas`, cableada — extraída por el MISMO motivo que
+ * `ajusteDeWorkspaceCableado`: un literal inline dentro de `arrancarConsolaWeb` no quedaría
+ * probado, y esa composición concreta —que la fábrica de verdad (`servicioDeConectoresCableado`)
+ * llega montada, y con la CASA correcta— es exactamente el patrón de fallo que este repo ya
+ * tiene documentado nueve veces.
+ *
+ * Es una función de una línea, pero la línea es la que puede caerse: sin este sitio propio,
+ * `arrancarConsolaWeb` seguiría compilando y pasando sus tests aunque alguien borrara la
+ * opción del objeto que le pasa a `montarRutas` — el mismo campo OPCIONAL que hace que
+ * `ConsolaDeProyecto.consumo` fuera la novena vez.
+ */
+export declare function ajusteDeConectoresCableado(opciones: {
+    casa: string;
+}): {
+    conectores: (alCambiar: () => void) => ServicioDeConectores;
+};
+/**
+ * Las opciones `conectores` y `gestorDeTareas` de `montarRutas`, cableadas JUNTAS (IXCODE-11).
+ *
+ * Juntas porque el gestor de Jira llama por el MISMO servicio de conectores que `montarRutas`
+ * construye con la fábrica `conectores` —el que lleva en memoria las autorizaciones
+ * pendientes: un segundo servicio no vería la de Ajustes y pisaría su verificador PKCE—. Así
+ * que aquí se ENVUELVE esa fábrica para quedarse con el servicio que devuelve, y el gestor le
+ * llama a ese. El gestor de `"jira"` es UNO (el adaptador guarda la url de cada sitio en la
+ * instancia), y el de `"notion"` también (guarda el esquema de cada base, IXCODE-15); cualquier
+ * otro conector no es un gestor. Extraída y probada por el patrón de
+ * fallo de siempre: un literal dentro de `arrancarConsolaWeb` no lo mira ningún test.
+ */
+export declare function ajusteDeGestorCableado(ajuste: {
+    conectores: (alCambiar: () => void) => ServicioDeConectores;
+}): {
+    conectores: (alCambiar: () => void) => ServicioDeConectores;
+    gestorDeTareas: (conector: string) => GestorDeTareasPort | undefined;
+    /**
+     * Los conectores para las SESIONES del agente, sobre ese MISMO servicio —el tercer usuario del
+     * servicio único, por la misma razón del PKCE—. Enlazado TARDE: el vestíbulo, que abre las
+     * sesiones, nace antes que `montarRutas`, que es quien construye el servicio.
+     */
+    conectoresDeSesion: ConectoresPort;
+};
+/**
+ * Trae la pantalla de Stitch ELEGIDA a la carpeta de artefactos de la sesión de la tarea, con la MISMA función que la tool
+ * (`traerDeStitch.ts#traerPantalla`), y compone la línea del encargo con la pantalla y el proyecto y sus ids. Nunca lanza.
+ */
+export declare function prepararDisenoDeTarea(conectores: ConectoresPort, traer?: typeof traerPantalla): (raiz: string, sesion: string, pantalla: PantallaElegida) => Promise<string>;
+export declare function construirCorredorDeTareasCableado(opciones: {
+    vestibulo: Pick<Vestibulo, "abrirParaTarea" | "proyectosAbiertos" | "sesionesDe">;
+    /** La fábrica de `OpcionesDeArranque.tareas`. Ausente = esta ejecución no ejecuta tareas. */
+    tareasFabrica?: (informar: (texto: string) => void) => TareasEnDisco;
+    informar: (texto: string) => void;
+    olvidarHiloDeSesion: (raiz: string, hilo: string) => Promise<void>;
+    /**
+     * Las DOS piezas de la puerta de la entrega, obligatorias porque el corredor las exige por
+     * TIPO (ver `crearCorredorDeTareas`): un juez que decida si el trabajo hace lo que se
+     * pedía, y con qué se comprueba que lo escrito se puede revisar. Suben hasta aquí para que
+     * el test de esta costura las componga de verdad, que es el motivo de que esta función
+     * exista.
+     */
+    juez: JuezDeTareaPort;
+    revisable: (raiz: string, sesion: string) => Promise<RevisionDeSesion>;
+    /**
+     * El gestor de tareas de un conector (la MISMA fábrica memoizada del panel, `ajusteDeGestorCableado`). Con él, una
+     * tarea con ticket se REFLEJA en su gestor al cambiar de estado (`agent/tareas/reflejoEnElGestor.ts`). Ausente = no
+     * se refleja nada (los tests que no lo piden, y una ejecución sin conectores).
+     */
+    gestorDeTareas?: (conector: string) => GestorDeTareasPort | undefined;
+    /** Lo que lleva el comentario de cierre de una tarea. Por omisión, `datosDeCierre` sobre su conversación. */
+    datosDeCierreDeTarea?: (tarea: Tarea) => Promise<DatosDeCierre>;
+    /**
+     * Los conectores de las sesiones (el MISMO servicio del panel): con ellos, la pantalla de Stitch ELEGIDA para una tarea
+     * se trae a su carpeta de artefactos antes del primer turno (`prepararDisenoDeTarea`). Ausente = no se trae.
+     */
+    conectores?: ConectoresPort;
+}): CorredorDeTareasCableado;
+export interface OpcionesDeArranque {
+    /** El puente de la sesión remota; por omisión el real. Los tests pasan el doble. */
+    puertoRemoto?: () => Promise<PuenteRemotoPort | undefined>;
+    /** El túnel de la vía ngrok; por omisión el real (`agent/remoto/tunelNgrok.ts`). Los tests pasan el doble. */
+    tunelRemoto?: TunelPort;
+    /** La foto de ngrok; por omisión la real (`agent/remoto/ngrokEnMaquina.ts`), que lanza `ngrok version`. */
+    medirNgrok?: () => Promise<{
+        instalado: boolean;
+        cuenta: boolean;
+    }>;
+    /** `ngrok config add-authtoken`; por omisión el real. */
+    guardarAuthtoken?: (token: string) => Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        motivo: string;
+    }>;
+    puerto: number;
+    abrir: boolean;
+    cwd: string;
+    /** `--guion`: el agente de pega también en la web, para verla correr sin gastar. */
+    guion?: boolean;
+    /**
+     * `--anfitrion <host>`: un nombre EXTRA que el servidor acepta en la cabecera `Host`,
+     * para servir a través de un túnel (ngrok, Tailscale) que apunte a este proceso.
+     *
+     * Sin esto, un túnel recibe 403 en todas las peticiones y hace bien: la comprobación de
+     * `Host` es la única defensa contra el DNS rebinding. Abrirla es una decisión, se pide a
+     * mano, y se DICE al arrancar — detrás de esta puerta hay un agente que escribe ficheros
+     * en el disco del usuario.
+     */
+    anfitrion?: string;
+    /**
+     * La fábrica del ejecutor real (`cli/main.ts#crearEjecutorReal`). Entra por parámetro y
+     * no se importa: `cli/main.ts` ya carga este módulo, e importarlo de vuelta sería un
+     * ciclo entre el despachador y la piel que monta.
+     */
+    crearEjecutor?: (alAbrirSesion: (sesion: SesionCerrable) => void, 
+    /** Lo que depende de la CONSOLA y no de su raíz: hoy la carpeta de adjuntos de una
+     *  tarea. La misma forma que `OpcionesDelVestibulo.crearEjecutor`, porque esto se le
+     *  pasa tal cual. */
+    opciones?: {
+        adjuntos?: string;
+        conectores?: ConectoresPort;
+    }) => EjecutorDeTurno;
+    /** Lo que la consola de proyecto necesita y depende de la raíz (`/sync`, los escritores). */
+    dependenciasDeProyecto?: (raiz: string) => Partial<Consola>;
+    /**
+     * Con qué código corre este proceso, para decirlo al arrancar. Entra por parámetro —y no
+     * se lee aquí— porque toca disco y lanza `git`: los tests de este fichero llaman a
+     * `arrancarConsolaWeb` entero, y no pueden depender de que exista un repo.
+     */
+    version?: () => VersionEnMarcha;
+    /**
+     * El tope de la ventana del modelo, para el contador de contexto.
+     *
+     * Entra por parámetro y no se importa por lo mismo que `crearEjecutor`: quien la tiene es
+     * `cli/main.ts#crearTopeDelModelo`, que ya carga este módulo. Y es la MISMA que usan la
+     * barra de stdio y la de la TUI a propósito — dos resoluciones del tope son dos
+     * porcentajes que divergen entre pieles. Ausente = no se pinta denominador, que es lo
+     * correcto para Ollama (sin tope a propósito) y para un modelo que la tabla no conoce.
+     */
+    topeDeContexto?: (raiz: string, modelo: string) => number | undefined;
+    /**
+     * La cola de TAREAS de fondo (`agent/tareas/tareasEnDisco.ts`), y con ella el corredor.
+     *
+     * **Ausente = esta ejecución no ejecuta tareas y no toma ningún cerrojo**, que es la
+     * omisión obligada y no una comodidad: el cerrojo y el índice viven en el
+     * `~/.xonecode/tareas` de la MÁQUINA, así que una omisión que construyera la cola de
+     * verdad haría que los tests de este fichero —que llaman a `arrancarConsolaWeb` entero—
+     * reconciliaran la cola real de quien los corre y le quitaran el cerrojo a su consola
+     * abierta. Es la misma razón por la que `detectarDispositivos` entra por opción.
+     *
+     * Es una FÁBRICA y no el puerto ya construido para poder darle el `informar` de aquí: el
+     * de un índice que no se puede leer tiene que llegar al navegador —es donde se está
+     * mirando el kanban—, y ese `informar` no existe hasta que existe el vestíbulo.
+     */
+    tareas?: (informar: (texto: string) => void) => TareasEnDisco;
+    /** Costuras de test: nada de esto toca disco, red ni navegador cuando se inyecta. */
+    raizDelCliente?: string;
+    escribir?: (texto: string) => void;
+    abrirNavegador?: (url: URL) => void;
+    crearServidor?: typeof arrancarServidor;
+    vestibulo?: Vestibulo;
+    /** Cuándo termina. Por omisión, con la primera señal de interrupción. */
+    esperarCierre?: () => Promise<void>;
+}
+/**
+ * Levanta la consola web y se queda. Devuelve el código de salida del proceso.
+ *
+ * El orden de las comprobaciones no es casual: primero lo que hace IMPOSIBLE arrancar
+ * (falta el build del cliente → 70, fallo del entorno y no del proyecto), y después lo que
+ * solo hay que DECIR (un proyecto offline en el cwd). Lo segundo informa y sigue, porque no
+ * es un error: quien abrió aquí un proyecto offline puede querer la web para otro.
+ *
+ * **`--guion` sobre un proyecto offline lo abre solo, sin pasar por el alta.** Es la única
+ * vía para ver la maqueta completa —barra con datos, transcript, compositor— sin
+ * credenciales de CloudStudio: el alta de la web solo sabe de entornos y proyectos
+ * REMOTOS (`vestibulo.ts`), así que un proyecto offline nunca llega a `proyectoAbierto()`
+ * por ese camino, con o sin `--guion`. `vestibulo.abrirProyecto` (`vestibulo.ts#abrirDeVerdad`)
+ * no toca red —es local, el mismo turno que corre `--cli`—, así que abrirlo aquí no es un
+ * doble de nada: es la operación real, disparada por una bandera que ya existe y ya
+ * significa «sin gastar ni conectar». Sin `--guion` esto NO se abre solo —sería magia, no
+ * un modo declarado—, y el aviso de abajo sigue mandando a `--cli`.
+ */
+/**
+ * Cuántos nombres de fichero se mandan en el aviso de trabajo sin commitear. El alta se
+ * reemite en los DOS flancos de cada turno, así que la lista viaja muchas veces; y la frase
+ * que la pinta no puede llevar trescientos nombres de todas formas. Lo que no cabe se
+ * cuenta: `total` va siempre entero.
+ */
+export declare const FICHEROS_DEL_AVISO = 20;
+export declare function arrancarConsolaWeb(opciones: OpcionesDeArranque): Promise<number>;
+/**
+ * El `modo` que declara el `.xonecode/config.json` de una raíz, o `undefined`.
+ *
+ * `undefined` es «no se sabe», no «offline»: cubre el fichero que no está, el JSON roto y
+ * el valor que no es ninguno de los dos. Quien pregunta decide qué hacer con no saber —
+ * `esProyectoOffline` lo trata como «no es offline» y la cabecera de la consola web no
+ * pinta pastilla—, y ninguno de los dos afirma sobre lo que no ha leído.
+ *
+ * Del config no sale nada más: ni la URL del entorno, ni el proyecto, ni la rama. Es lo
+ * mismo que ya hace `proyectosDeResultado` con la respuesta de CloudStudio (CLAUDE.md),
+ * quedarse SOLO con lo que hace falta enseñar.
+ */
+export declare function modoDeProyecto(raiz: string): "offline" | "cloud" | undefined;
+/**
+ * O el ejecutor real, o el de pega PEDIDO con `--guion`, o un error. Lo que no hay es una
+ * tercera opción muda.
+ */
+export declare function banderaDeEjecutor(opciones: OpcionesDeArranque, conectores?: ConectoresPort): Pick<OpcionesDelVestibulo, "crearEjecutor">;
+/** Los pasos, reexportados para quien monte otra piel sobre el mismo vestíbulo. */
+export type { OpcionDeEntorno, PasoDelVestibulo };