xonecode 0.35.0 → 0.37.0

package/dist/web/servidor/arranque.js

@@ -52,7 +52,8 @@ import { detectarDispositivos, frameworkEnDispositivo } from "../../agent/dispos
  */
 import { lanzarEnDispositivo, } from "../../agent/dispositivos/lanzamientoEnMaquina.js";
 import { motivoDeBloqueo, puedeLanzarse, } from "../../core/puedeLanzarse.js";
-import { PLATAFORMAS_DE_DISPOSITIVO } from "../../core/settings.js";
+import { PLATAFORMAS_DE_DISPOSITIVO, remotoEnVigor } from "../../core/settings.js";
+import { motivoDeDominioInaceptable } from "../../core/tunel.js";
 import { instalarHerramientaDeDispositivos, verificarDispositivo } from "../../agent/dispositivos/dispositivosEnMaquina.js";
 import { arrancarEmulador, pararEmulador } from "../../agent/dispositivos/arranqueDeEmulador.js";
 import { borrarAvd, clonarAvd, correrPasoDeReceta, crearAvd } from "../../agent/dispositivos/instalacionEnMaquina.js";
@@ -72,7 +73,7 @@ import { borrarCredencial, guardarCredencial } from "../../agent/config/authEnDi
 import { borrarProveedorPersonalizado, guardarProveedorPersonalizado, proveedoresPersonalizados, } from "../../agent/config/configEnDisco.js";
 import { crearCheckpointerDeProyecto, mantenimientoDelCheckpointer, } from "../../agent/sesiones/checkpointer.js";
 import { resumenDePoda } from "../../core/podaDeCheckpoint.js";
-import { cargarSettings, guardarConcurrenciaDeTareas, guardarDepurar, guardarModoPorDefecto, guardarWorkspace as guardarWorkspaceEnDisco, guardarDispositivos, guardarAjusteDeAvd, quitarAjustesDeAvd, guardarPuertosAsignados, guardarEntorno as guardarEntornoEnDisco, olvidarEntornoDeSettings, copiasDeEntorno, borrarCopiasDeEntorno, } from "../../agent/config/settingsEnDisco.js";
+import { cargarSettings, guardarConcurrenciaDeTareas, guardarDepurar, guardarModoPorDefecto, guardarAjustesDeRemoto as guardarAjustesDeRemotoEnDisco, guardarWorkspace as guardarWorkspaceEnDisco, guardarDispositivos, guardarAjusteDeAvd, quitarAjustesDeAvd, guardarPuertosAsignados, guardarEntorno as guardarEntornoEnDisco, olvidarEntornoDeSettings, copiasDeEntorno, borrarCopiasDeEntorno, } from "../../agent/config/settingsEnDisco.js";
 import { dentroDelWorkspace, depuracionActiva, expandirConCasa, mismaRuta, motivoParaNoOlvidarEntorno, motivoDeNombreDeEntornoInaceptable, motivoDeWorkspaceInaceptable, } from "../../core/settings.js";
 import { esModoDeEscritura, MODO_POR_OMISION, } from "../../core/modoDeEscritura.js";
 import { megasDeLasMudanzas, mudarWorkspaceLegado } from "../../agent/config/mudanzaEnDisco.js";
@@ -115,6 +116,8 @@ import { baseDeWorkspaceLegada, baseDeWorkspacePorOmision, conexionDeVestibulo,
 // documentado cinco veces: una composición de producción dentro de algo que los tests
 // doblan.
 import { filaDeTarea } from "./transporte.js";
+import { crearSesionRemota, motivoFijoDelTunel } from "./puenteRemoto.js";
+import { componerPanorama, INTERVALO_DE_PANORAMA_MS } from "../../core/panorama.js";
 import { esEsfuerzo, nivelesDeEsfuerzo } from "../../core/esfuerzo.js";
 import { CATALOGO_DE_CONECTORES, conectoresParaElAgente, definicionDelCable, RUTA_CALLBACK_MCP } from "../../core/conectores.js";
 import { servicioDeConectoresCableado } from "../../agent/conectores/servicioDeConectores.js";
@@ -351,6 +354,43 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      * Emitir es escribirle a todos; el transporte hace lo mismo por su lado.
      */
     const clientes = new Set();
+    /**
+     * La sesión remota, si esta ejecución la monta. Se ASIGNA más abajo, en cuanto existen
+     * `engancharCliente`/`soltarCliente`/`cancelarTurno`/`recibirEnLaConsola`, que son su puerta y
+     * su despacho; se declara aquí porque la ráfaga (`adjuntar`) también la lee.
+     */
+    let sesionRemota;
+    const remotoHabilitado = () => opciones.remoto?.ajustes().habilitado === true;
+    /** La última foto de ngrok (`OpcionesDeMontaje.remoto.medirNgrok`); `undefined` = aún no medida. */
+    let fotoDeNgrok;
+    /** Por qué falló la última acción de ngrok: SOLO un texto fijo nuestro. Viaja en la foto. */
+    let motivoDeNgrok;
+    const mensajeDeRemoto = (e) => {
+        const ajustes = opciones.remoto?.ajustes();
+        return {
+            clase: "remoto",
+            estado: e.estado,
+            // El interruptor, para Ajustes: la sección se pinta siempre y el botón del chat solo encendido.
+            habilitado: remotoHabilitado(),
+            ...(ajustes?.porEntorno === true ? { porEntorno: true } : {}),
+            ...("url" in e ? { url: e.url } : {}),
+            ...("moviles" in e ? { moviles: e.moviles } : {}),
+            ...("motivo" in e ? { motivo: e.motivo } : {}),
+            // La vía EN VIGOR, siempre (`remotoEnVigor` ya resolvió la omisión): el cliente toma una
+            // ausente por ngrok, así que callarla con «servidor» lo pintaría como ngrok.
+            ...(ajustes?.via !== undefined ? { via: ajustes.via } : {}),
+            ...(fotoDeNgrok === undefined
+                ? {}
+                : {
+                    ngrok: {
+                        instalado: fotoDeNgrok.instalado,
+                        cuenta: fotoDeNgrok.cuenta,
+                        ...(ajustes?.dominio === undefined ? {} : { dominio: ajustes.dominio }),
+                        ...(motivoDeNgrok === undefined ? {} : { motivo: motivoDeNgrok }),
+                    },
+                }),
+        };
+    };
     /**
      * Los clientes por su IDENTIFICADOR, y qué tareas está mirando cada uno.
      *
@@ -439,6 +479,101 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         for (const cliente of clientes)
             cliente(mensaje);
     };
+    /**
+     * El PANEL de la sesión remota (`core/panorama.ts`): las consolas de persona abiertas y la cola
+     * de tareas, compuesto AQUÍ y mandado SOLO a los móviles (`SesionRemota.difundir`), nunca a las
+     * pestañas. Cada consola cruza con un id OPACO por encendido de la sesión remota —raíz → id, que
+     * se olvida al apagar—: la raíz es una ruta de la máquina (`sinRutas`) y el proyecto viaja como
+     * su `basename`. **Límite declarado**: el mismo nombre de proyecto en dos entornos se confunde.
+     */
+    const idsDeConsola = new Map();
+    const idDeConsola = (raiz) => {
+        let id = idsDeConsola.get(raiz);
+        if (id === undefined) {
+            id = randomUUID();
+            idsDeConsola.set(raiz, id);
+        }
+        return id;
+    };
+    /** La consola de persona ABIERTA con ese id, o nada: un id de otro encendido, o de una consola
+     *  que ya se cerró, no resuelve a ninguna. */
+    const consolaDelPanel = (id) => {
+        for (const [raiz, suyo] of idsDeConsola) {
+            if (suyo === id)
+                return vestibulo.proyectosAbiertos().find((c) => c.raiz === raiz);
+        }
+        return undefined;
+    };
+    const aprobacionEnVueloDe = (c) => {
+        for (const m of c.mensajesDeAprobacion())
+            if (m.clase === "aprobacion")
+                return m;
+        return undefined;
+    };
+    const panoramaAhora = () => {
+        const foco = vestibulo.proyectoAbierto();
+        const consolas = vestibulo.proyectosAbiertos().map((c) => {
+            const fila = c.sesion === undefined ? undefined : vestibulo.sesionesDe(c.raiz).find((s) => s.id === c.sesion);
+            const aprobacion = aprobacionEnVueloDe(c);
+            return {
+                id: idDeConsola(c.raiz),
+                proyecto: basename(c.raiz),
+                ...(fila === undefined || fila.titulo === "" ? {} : { sesion: fila.titulo }),
+                foco: c === foco,
+                turnoEnVuelo: c.turnoEnVuelo,
+                ...(aprobacion === undefined
+                    ? {}
+                    : { aprobacion: { pendientes: aprobacion.pendientes, ficheros: aprobacion.ficheros, diffs: aprobacion.diffs } }),
+                preguntaPendiente: c.preguntaPendiente,
+                ...(fila?.ultimoTurno === undefined ? {} : { ultimaActividad: fila.ultimoTurno }),
+            };
+        });
+        const tareas = (opciones.colaDeTareas?.listar() ?? []).map((t) => ({
+            id: t.id,
+            titulo: t.titulo,
+            // El NOMBRE, como en `filaDeTarea`: la raíz de la tarea no viaja.
+            proyecto: t.proyecto.nombre,
+            estado: t.estado,
+            creada: t.creada,
+            ...(t.tras === undefined ? {} : { tras: t.tras }),
+            ...(t.motivo === undefined ? {} : { motivo: t.motivo }),
+            ...(t.acabada === undefined ? {} : { acabada: t.acabada }),
+        }));
+        return componerPanorama({ consolas, tareas });
+    };
+    /**
+     * Un panorama nuevo a todos los móviles, como mucho uno por `INTERVALO_DE_PANORAMA_MS` y
+     * siempre DESPUÉS del último cambio. Los gatillos (`alCambiarEsperas`, `emitirTareas`) saltan a
+     * menudo y desde dentro de una resolución (una aprobación que se contesta): aquí solo se
+     * PROGRAMA, y se compone al vencer el reloj, con el estado de ese instante.
+     */
+    let relojDePanorama;
+    let ultimoPanorama = Number.NEGATIVE_INFINITY;
+    const programarPanorama = () => {
+        if (relojDePanorama !== undefined || sesionRemota === undefined || !sesionRemota.hayMoviles())
+            return;
+        const espera = Math.max(0, ultimoPanorama + INTERVALO_DE_PANORAMA_MS - Date.now());
+        relojDePanorama = setTimeout(() => {
+            relojDePanorama = undefined;
+            if (sesionRemota === undefined || !sesionRemota.hayMoviles())
+                return;
+            ultimoPanorama = Date.now();
+            try {
+                sesionRemota.difundir(panoramaAhora());
+            }
+            catch (error) {
+                contar(error);
+            }
+        }, espera);
+        relojDePanorama.unref?.();
+    };
+    const olvidarPanorama = () => {
+        if (relojDePanorama !== undefined)
+            clearTimeout(relojDePanorama);
+        relojDePanorama = undefined;
+        idsDeConsola.clear();
+    };
+    vestibulo.alCambiarEsperas(programarPanorama);
     /**
      * Lo que valga esa promesa, o nada si tarda demasiado. **No la cancela**: sigue viva y su
      * valor se usará en el siguiente anuncio — lo que se acota es la ESPERA, no el trabajo.
@@ -507,7 +642,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      * hace que se elija TAMBIÉN el modelo. El wizard sigue sabiendo pintarlo por si otra
      * piel se lo manda; esta no.
      */
-    const anunciarAlta = async () => {
+    const componerAlta = async () => {
         const abierto = vestibulo.proyectoAbierto();
         const proyectoAbierto = abierto !== undefined;
         // Se lee del disco EN CADA anuncio y no se cachea al abrir: `configurarModoInicial`
@@ -570,7 +705,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                     conIcono.add(p.id);
             }));
         }
-        emitir({
+        return {
             clase: "alta",
             pasos,
             proveedores: PROVEEDORES.map((p) => ({ id: p, nombre: nombreDeProveedor(p) })),
@@ -680,7 +815,12 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             // en cada anuncio en vez de pasarse por parámetro: los anuncios de los flancos del
             // turno no preparan nada y tienen que decir lo que hay, no lo que había.
             ...(preparando === undefined ? {} : { preparando }),
-        });
+        };
+    };
+    /** El alta a TODOS los clientes vivos. Compuesto aparte (`componerAlta`) para poder dárselo a
+     *  UNO solo: el móvil que entra por la sesión remota (ver `engancharMovil`). */
+    const anunciarAlta = async () => {
+        emitir(await componerAlta());
     };
     /**
      * Los catálogos ya consultados en ESTE proceso, por proveedor. Se guardan porque cada
@@ -1169,6 +1309,16 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 cliente(depuracion);
             if (modoPorDefecto !== undefined)
                 cliente(modoPorDefecto);
+            // La sesión remota, SIEMPRE que esta ejecución la monta: con `habilitado`, que es lo que
+            // pinta el interruptor de Ajustes (y, apagado, no hay botón en el chat). Un puente abierto
+            // con el interruptor quitado a mano en `settings.json` sale igual, para poder apagarlo.
+            // A un móvil no le llega: `remoto` no pasa `filtrarSalida` (lleva el secreto en la `url`).
+            if (sesionRemota !== undefined)
+                cliente(mensajeDeRemoto(sesionRemota.estado()));
+            // La foto de ngrok, la PRIMERA vez que alguien mira: lanza `ngrok version`, que no se hace
+            // con el interruptor apagado ni en sondeo.
+            if (sesionRemota !== undefined && fotoDeNgrok === undefined && midiendoNgrok === undefined && remotoHabilitado())
+                void medirNgrokYAnunciar().catch(contar);
             if (conectores !== undefined)
                 cliente(conectores);
             if (consumoDeLaSesion !== undefined) {
@@ -1436,6 +1586,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         const m = mensajeDeTareas();
         if (m !== undefined)
             emitir(m);
+        programarPanorama();
     };
     /**
      * Un id de proyecto a su tripleta completa, o nada si no se puede resolver.
@@ -1799,6 +1950,24 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             informar(`no se pudo añadir el feedback: ${resultado.motivo ?? "motivo desconocido"}`);
         }
     };
+    /**
+     * El feedback y «Continuar» de una tarea aparcada: los MISMOS para los botones del escritorio
+     * (`POST /accion`) y para el panel del móvil, que no es un segundo camino con su propia regla.
+     */
+    const tareaEsperandoFeedback = (id) => opciones.colaDeTareas?.listar().find((t) => t.id === id)?.estado === "requiere-atencion";
+    const darFeedbackATarea = (id, texto) => {
+        atenderFeedbackDeTarea(id, texto);
+        opciones.revisarTareas?.();
+        emitirTareas();
+    };
+    /** Lo mismo que un feedback, con el texto de «sigue» del núcleo: entra en SU hilo, no repite el
+     *  encargo. Devuelve por qué no, o nada si se hizo. */
+    const continuarTarea = (id) => {
+        if (!tareaEsperandoFeedback(id))
+            return "esa tarea ya no está esperando feedback";
+        darFeedbackATarea(id, TEXTO_DE_CONTINUAR);
+        return undefined;
+    };
     /** Los ajustes de destino, o `{}` —que es «se miran todos»— si esta ejecución no los lee. */
     const ajustesDeDispositivos = () => opciones.ajustesDeDispositivos?.() ?? {};
     /**
@@ -4646,6 +4815,53 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             .then(() => anunciarAlta())
             .catch(contar);
     });
+    /**
+     * Engancha un cliente del cable: una pestaña SSE o un MÓVIL de la sesión remota
+     * (`puenteRemoto.ts`). Es la misma puerta para los dos a propósito: así el móvil recibe la
+     * misma ráfaga, se muda con el foco y cuenta como «hay alguien delante» igual que una pestaña.
+     */
+    const engancharCliente = (sumidero) => {
+        clientes.add(sumidero);
+        adjuntar(sumidero);
+        // ANTES de `conducirCuenta()`, no después: el nombre ya está resuelto (es local, no
+        // depende de ninguna cuenta) y el paso de cuenta puede tardar lo que tarde un humano
+        // en elegir modelo y teclear una clave. Mandarlo solo dentro de `alta` —al final de
+        // TODO esto— dejaba el saludo en «Hola» a secas mientras tanto (`transporte.ts`
+        // documenta la medida).
+        // Solo al recién llegado: los demás ya recibieron su saludo al conectar.
+        sumidero({ clase: "bienvenida", ...(vestibulo.nombre === undefined ? {} : { nombre: vestibulo.nombre }) });
+    };
+    /**
+     * Lo contrario, con la regla de «el ÚLTIMO en irse deja la consola sola» (ver el `close` de la
+     * ruta SSE).
+     *
+     * Se va ESTE cliente, no «el cliente». La guarda de antes (`enviar !== sumidero`)
+     * existía porque el `close` de una pestaña recargada puede llegar DESPUÉS de que el
+     * SSE nuevo se enganche, y con una sola ranura eso desconectaba al recién llegado;
+     * con un conjunto, quitar el suyo es exacto y esa carrera desaparece.
+     */
+    const soltarCliente = (sumidero) => {
+        clientes.delete(sumidero);
+        // La consola solo se da por sola cuando se va el ÚLTIMO: el transporte lo decide
+        // mirando sus sumideros. Cortar a la primera baja rechazaría la aprobación que otra
+        // pestaña todavía tiene delante.
+        adjunto?.desconectar(sumidero);
+        if (clientes.size === 0) {
+            /**
+             * Y las de SEGUNDO PLANO también, que es lo que `soltar` deja pendiente a
+             * propósito: mudarse de consola no da por ido al humano, pero cerrarse el último
+             * SSE sí. Sin esto, una consola que se quedó detrás con un turno en marcha seguiría
+             * creyendo que hay alguien a quien preguntar y su aprobación esperaría el plazo
+             * entero antes de rechazarse. Se les dice a todas menos a la que ya se acaba de
+             * cortar arriba.
+             */
+            for (const consola of vestibulo.proyectosAbiertos()) {
+                if (consola !== adjunto)
+                    consola.desconectar();
+            }
+            adjunto = undefined;
+        }
+    };
     servidor.registrarRuta("GET", RUTA_EVENTOS, (peticion, respuesta) => {
         respuesta.writeHead(200, {
             "Content-Type": "text/event-stream; charset=utf-8",
@@ -4664,7 +4880,6 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 /* el cliente se fue; el `close` de abajo ya desconecta */
             }
         };
-        clientes.add(sumidero);
         /**
          * El identificador que el navegador eligió para ESTA conexión, si lo mandó. Es lo que
          * después le permite decir «engánchame a la tarea t1» por `POST /accion`, que es otra
@@ -4700,14 +4915,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         // Un comentario SSE abre el stream de verdad: sin nada escrito, algunos navegadores no
         // disparan `onopen` hasta el primer dato.
         respuesta.write(": xonecode\n\n");
-        adjuntar(sumidero);
-        // ANTES de `conducirCuenta()`, no después: el nombre ya está resuelto (es local, no
-        // depende de ninguna cuenta) y el paso de cuenta puede tardar lo que tarde un humano
-        // en elegir modelo y teclear una clave. Mandarlo solo dentro de `alta` —al final de
-        // TODO esto— dejaba el saludo en «Hola» a secas mientras tanto (`transporte.ts`
-        // documenta la medida).
-        // Solo al recién llegado: los demás ya recibieron su saludo al conectar.
-        sumidero({ clase: "bienvenida", ...(vestibulo.nombre === undefined ? {} : { nombre: vestibulo.nombre }) });
+        engancharCliente(sumidero);
         /**
          * **Dos anuncios, y el primero va ANTES de preguntar a CloudStudio.**
          *
@@ -4751,11 +4959,6 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             void anunciarAlta().catch(contar);
         });
         peticion.on("close", () => {
-            // Se va ESTE cliente, no «el cliente». La guarda de antes (`enviar !== sumidero`)
-            // existía porque el `close` de una pestaña recargada puede llegar DESPUÉS de que el
-            // SSE nuevo se enganche, y con una sola ranura eso desconectaba al recién llegado;
-            // con un conjunto, quitar el suyo es exacto y esa carrera desaparece.
-            clientes.delete(sumidero);
             /**
              * Y se desenganchan sus MIRADAS. Sin esto, el envoltorio de una pestaña cerrada se
              * queda enganchado al turno de la tarea para siempre, escribiendo en un socket que ya
@@ -4773,25 +4976,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                     porIdDeCliente.delete(idDeCliente);
                 }
             }
-            // Y la consola solo se da por sola cuando se va el ÚLTIMO: el transporte lo decide
-            // mirando sus sumideros. Cortar a la primera baja rechazaría la aprobación que otra
-            // pestaña todavía tiene delante.
-            adjunto?.desconectar(sumidero);
-            if (clientes.size === 0) {
-                /**
-                 * Y las de SEGUNDO PLANO también, que es lo que `soltar` deja pendiente a
-                 * propósito: mudarse de consola no da por ido al humano, pero cerrarse el último
-                 * SSE sí. Sin esto, una consola que se quedó detrás con un turno en marcha seguiría
-                 * creyendo que hay alguien a quien preguntar y su aprobación esperaría el plazo
-                 * entero antes de rechazarse. Se les dice a todas menos a la que ya se acaba de
-                 * cortar arriba.
-                 */
-                for (const consola of vestibulo.proyectosAbiertos()) {
-                    if (consola !== adjunto)
-                        consola.desconectar();
-                }
-                adjunto = undefined;
-            }
+            soltarCliente(sumidero);
         });
     });
     /**
@@ -5315,6 +5500,306 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         respuesta.writeHead(204);
         respuesta.end();
     });
+    /**
+     * Parar ESTE turno, no cerrar la conversación. Sin proyecto abierto no hay turno que
+     * parar y se dice: un botón que no puede cumplir no puede callar. Lo usan `POST /accion`
+     * y el móvil.
+     */
+    const cancelarTurno = () => {
+        const abierto = vestibulo.proyectoAbierto();
+        if (abierto === undefined || !abierto.cancelarTurno()) {
+            informar("no hay ningún turno en vuelo que parar");
+        }
+    };
+    /**
+     * Lo que va a la consola en foco: prosa, respuestas, decisiones… Lo usan `POST /accion` y
+     * el móvil.
+     *
+     * Y si fue una PROSA, se reanuncia el alta: la sesión acaba de darse de alta en el
+     * índice (`ConsolaDeProyecto.recibir`), así que hay una fila nueva que la barra tiene
+     * que enseñar YA — con su título y marcada como la activa.
+     *
+     * Diferido por lo mismo que el reanuncio de los flancos: el lazo coge la línea en una
+     * microtarea, y anunciar en el acto contaría el turno como no empezado. No sustituye a
+     * los flancos —de ellos sale la marca de «trabajando»—, cubre el caso en que no hay
+     * flanco ninguno: un `/comando`, que no corre turno.
+     */
+    const recibirEnLaConsola = (mensaje) => {
+        destinoActual().recibir(mensaje);
+        if (mensaje.clase === "prosa") {
+            void Promise.resolve()
+                .then(() => anunciarAlta())
+                .catch(contar);
+        }
+    };
+    /**
+     * La puerta de un MÓVIL: la de una pestaña y, detrás, el `alta` SOLO para él. Una pestaña lo
+     * recibe porque la ruta SSE anuncia después de enganchar (`conducirCuenta().then(anunciarAlta)`);
+     * un móvil no pasa por esa ruta, y sin esto su cabecera decía «sin sesión» hasta el siguiente
+     * `alta` difundido. No va en `adjuntar` porque las pestañas recibirían uno de más, ni se difunde
+     * a todos por lo mismo. Sale por su sumidero, así que cruza transformado por `filtrarSalida`
+     * (`remoto.estado`: proyecto y título de la sesión). Se compone asíncrono: si el móvil se fue
+     * entre medias, no se le escribe.
+     */
+    const engancharMovil = (sumidero) => {
+        engancharCliente(sumidero);
+        void componerAlta()
+            .then((alta) => {
+            if (clientes.has(sumidero))
+                sumidero(alta);
+        })
+            .catch(contar);
+    };
+    /**
+     * Una decisión del PANEL del móvil: va a la consola de ESE id y nunca a la del foco. Si el id no
+     * resuelve, o esa consola no tiene aprobación en vuelo, o la decisión nombra ids que no son los
+     * de la aprobación que hay AHORA (el panel pudo quedarse viejo), se descarta y se dice: en
+     * `consolaWeb#recibir` una decisión con ids que no casan RECHAZA lo pendiente, y aquí no se
+     * rechaza nada que nadie haya visto.
+     */
+    const decidirDesdeElPanel = (id, decisiones) => {
+        const consola = consolaDelPanel(id);
+        const enVuelo = consola === undefined ? undefined : aprobacionEnVueloDe(consola);
+        const ids = Object.keys(decisiones);
+        if (consola === undefined ||
+            enVuelo === undefined ||
+            ids.length === 0 ||
+            !ids.every((nombrado) => enVuelo.pendientes.some((p) => p.id === nombrado))) {
+            informar("sesión remota: una decisión del panel no tenía aprobación a la que contestar");
+            return;
+        }
+        consola.recibir({ clase: "decision", decisiones });
+    };
+    /**
+     * El móvil entra por la MISMA puerta que una pestaña (`engancharCliente`) y lo que manda va a
+     * la consola por el MISMO despacho que `POST /accion` (`cancelarTurno`/`recibirEnLaConsola`):
+     * un segundo camino sería una segunda regla de qué se puede hacer desde fuera.
+     */
+    sesionRemota =
+        opciones.remoto === undefined
+            ? undefined
+            : crearSesionRemota({
+                puerto: opciones.remoto.puerto,
+                servidor: () => opciones.remoto.ajustes().servidor,
+                // La vía se lee en CADA encendido (vive en `settings.json`), y el dominio con ella.
+                tunel: () => {
+                    const { via, dominio } = opciones.remoto.ajustes();
+                    if (via !== "ngrok")
+                        return undefined;
+                    const tunel = opciones.remoto.tunel;
+                    return {
+                        abrir: () => tunel === undefined
+                            ? Promise.reject(new Error("esta ejecución no tiene túnel"))
+                            : tunel.abrir(dominio === undefined ? {} : { dominio }),
+                    };
+                },
+                engancharCliente: engancharMovil,
+                soltarCliente,
+                // La `respuesta` es la excepción, y por SEGURIDAD: por `recibir` contestaría también la
+                // subida con casillas o «¿Vaciar la copia…?» del escritorio, que el móvil nunca ve.
+                despachar: (m) => {
+                    if (m.clase === "cancelar")
+                        cancelarTurno();
+                    else if (m.clase === "respuesta") {
+                        if (!destinoActual().responderDesdeElMovil(m.texto))
+                            informar("sesión remota: una respuesta del móvil no tenía pregunta a la que contestar");
+                    }
+                    else if (m.clase === "decision" && m.consola !== undefined)
+                        decidirDesdeElPanel(m.consola, m.decisiones);
+                    else if (m.clase === "feedback" || m.clase === "continuar") {
+                        // Solo a una tarea que ESPERA feedback: el panel la enseñó así, pero pudo cambiar entre medias.
+                        if (!tareaEsperandoFeedback(m.tarea))
+                            informar("sesión remota: el panel mandó algo a una tarea que ya no espera feedback");
+                        else if (m.clase === "continuar")
+                            void continuarTarea(m.tarea);
+                        else
+                            darFeedbackATarea(m.tarea, m.texto);
+                    }
+                    else
+                        recibirEnLaConsola(m);
+                },
+                alEntrarMovil: (enviar) => {
+                    try {
+                        enviar(panoramaAhora());
+                    }
+                    catch (error) {
+                        contar(error);
+                    }
+                },
+                informar,
+                // A las pestañas: el diálogo de la consola. `clientes` contiene también los sumideros
+                // de los móviles, y no pasa nada: su filtro descarta `remoto`.
+                alCambiar: (e) => {
+                    // Los ids del panel son de UN encendido (revocar incluido): al abrir, apagar o caer se olvidan.
+                    if (e.estado === "apagada" || e.estado === "error" || e.estado === "abriendo")
+                        olvidarPanorama();
+                    for (const cliente of clientes)
+                        cliente(mensajeDeRemoto(e));
+                },
+            });
+    /**
+     * Apagar solo si hay algo ENCENDIDO. `apagar()` anuncia `{estado:"apagada"}` a todas las
+     * pestañas, y `arrancarConsolaWeb` monta la opción SIEMPRE: con el interruptor apagado, un
+     * apagado a ciegas en el cierre emitiría un mensaje `remoto` que no debe existir. Y no mira el
+     * interruptor: si alguien lo apaga en `settings.json` con el puente abierto, cerrarlo sigue
+     * siendo posible (y es lo único seguro).
+     */
+    const apagarRemoto = () => {
+        if (sesionRemota !== undefined && sesionRemota.estado().estado !== "apagada")
+            return sesionRemota.apagar();
+        return Promise.resolve();
+    };
+    /** El estado de la sesión remota, otra vez, a cada pestaña: tras cambiar algo que el mensaje lleva. */
+    const anunciarRemoto = () => {
+        if (sesionRemota === undefined)
+            return;
+        const mensaje = mensajeDeRemoto(sesionRemota.estado());
+        for (const cliente of clientes)
+            cliente(mensaje);
+    };
+    /**
+     * Una medida a la vez, y la pedida con otra en vuelo se ENCADENA detrás (una sola, compartida
+     * por quien la pida mientras espera): la que está en vuelo pudo empezar ANTES de guardar el
+     * authtoken o de acabar la receta, y reutilizarla dejaría una foto vieja.
+     */
+    let midiendoNgrok;
+    let siguienteMedidaDeNgrok;
+    const medirNgrokAhora = (medir) => {
+        const esta = medir()
+            .then((foto) => {
+            fotoDeNgrok = { instalado: foto.instalado, cuenta: foto.cuenta };
+            anunciarRemoto();
+        })
+            .finally(() => {
+            if (midiendoNgrok === esta)
+                midiendoNgrok = undefined;
+        });
+        midiendoNgrok = esta;
+        return esta;
+    };
+    const medirNgrokYAnunciar = () => {
+        const medir = opciones.remoto?.medirNgrok;
+        if (medir === undefined || !remotoHabilitado())
+            return Promise.resolve();
+        const enVuelo = midiendoNgrok;
+        if (enVuelo === undefined)
+            return medirNgrokAhora(medir);
+        siguienteMedidaDeNgrok ??= enVuelo
+            .catch(() => { })
+            .then(() => {
+            siguienteMedidaDeNgrok = undefined;
+            return medirNgrokAhora(medir);
+        });
+        return siguienteMedidaDeNgrok;
+    };
+    /**
+     * Las acciones de la vía ngrok. Lo que se dice de vuelta es SIEMPRE texto nuestro: ni lo que
+     * llegó por el cable, ni lo que contestó ngrok, ni —sobre todo— el authtoken.
+     */
+    const atenderViaRemota = (via) => {
+        if (via !== "servidor" && via !== "ngrok")
+            return;
+        const estado = sesionRemota?.estado().estado;
+        // La vía se lee al encender: cambiarla encendida no haría nada hasta apagar, y un revocar
+        // la aplicaría a medias. El diálogo solo la ofrece apagada o en error.
+        if (estado !== "apagada" && estado !== "error") {
+            informar("sesión remota: la vía se cambia con la sesión apagada");
+            return;
+        }
+        if (!guardarAjustesDeRemoto({ via }))
+            return;
+        motivoDeNgrok = undefined;
+        anunciarRemoto();
+        void medirNgrokYAnunciar().catch(contar);
+    };
+    const atenderDominioRemoto = (bruto) => {
+        if (typeof bruto !== "string")
+            return;
+        const dominio = bruto.trim();
+        if (dominio !== "") {
+            const motivo = motivoDeDominioInaceptable(dominio);
+            if (motivo !== undefined) {
+                // El texto del rechazo es fijo (`core/tunel.ts`): no repite lo tecleado.
+                informar(`sesión remota: ${motivo}`);
+                motivoDeNgrok = motivo;
+                anunciarRemoto();
+                if (fotoDeNgrok === undefined)
+                    void medirNgrokYAnunciar().catch(contar);
+                return;
+            }
+        }
+        // Vacío QUITA el dominio: sin esto, uno puesto no se podría borrar desde el diálogo.
+        if (!guardarAjustesDeRemoto({ dominio: dominio === "" ? null : dominio }))
+            return;
+        motivoDeNgrok = undefined;
+        anunciarRemoto();
+        void medirNgrokYAnunciar().catch(contar);
+    };
+    /** `true` si quedó escrito. El error de disco lleva la ruta de `settings.json`: solo su `code`. */
+    const guardarAjustesDeRemoto = (cambio) => {
+        const guardar = opciones.remoto?.guardarAjustes;
+        if (guardar === undefined) {
+            informar("sesión remota: esta ejecución no puede guardar sus ajustes");
+            return false;
+        }
+        try {
+            guardar(cambio);
+            return true;
+        }
+        catch (error) {
+            informar(`sesión remota: no se pudo guardar en settings.json (${codigoDe(error)})`);
+            return false;
+        }
+    };
+    /**
+     * El interruptor de Ajustes → Sesión remota. Desactivar APAGA antes lo que haya encendido: un
+     * puente abierto con el interruptor quitado seguiría dando la consola a quien tenga la URL.
+     * Activar no enciende nada: solo hace aparecer el botón del chat y mide ngrok.
+     */
+    const atenderHabilitarRemoto = async (valor) => {
+        if (typeof valor !== "boolean")
+            return;
+        if (!valor)
+            await apagarRemoto();
+        if (!guardarAjustesDeRemoto({ habilitado: valor }))
+            return;
+        if (!valor && opciones.remoto?.ajustes().porEntorno === true) {
+            informar("sesión remota: XONECODE_REMOTO=1 la mantiene activa en este arranque");
+        }
+        anunciarRemoto();
+        if (valor)
+            await medirNgrokYAnunciar();
+    };
+    /**
+     * El authtoken entra por `leerSecreto` —la MISMA puerta que una clave de API— y sale solo hacia
+     * `ngrok config add-authtoken`. Vacío es cancelar: no se llama a nadie ni se dice nada.
+     */
+    const pedirAuthtoken = async () => {
+        const guardar = opciones.remoto?.guardarAuthtoken;
+        if (guardar === undefined) {
+            informar("sesión remota: esta ejecución no puede guardar el authtoken de ngrok");
+            return;
+        }
+        const consola = vestibulo.proyectoAbierto()?.consola.consola ?? vestibulo.consola.consola;
+        const token = (await consola.leerSecreto("authtoken de ngrok: ")).trim();
+        if (token === "")
+            return;
+        let resultado;
+        try {
+            resultado = await guardar(token);
+        }
+        catch {
+            resultado = { ok: false, motivo: "" };
+        }
+        if (resultado.ok)
+            motivoDeNgrok = undefined;
+        else {
+            motivoDeNgrok = motivoFijoDelTunel(resultado.motivo);
+            informar(`sesión remota: ${motivoDeNgrok}`);
+        }
+        // La medida dice si quedó con cuenta, no lo que contestó el comando.
+        await medirNgrokYAnunciar();
+    };
     servidor.registrarRuta("POST", RUTA_ACCION, async (peticion, respuesta) => {
         let mensaje;
         try {
@@ -5795,16 +6280,12 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 return;
             }
             if (mensaje.accion === "continuar" && opciones.colaDeTareas !== undefined) {
-                // Lo mismo que un feedback, con el texto de «sigue» del núcleo: entra en SU hilo, no repite el encargo.
-                const actual = opciones.colaDeTareas.listar().find((t) => t.id === mensaje.id);
-                if (actual === undefined || actual.estado !== "requiere-atencion") {
+                const motivo = continuarTarea(mensaje.id);
+                if (motivo !== undefined) {
                     respuesta.writeHead(409, { "content-type": "application/json" });
-                    respuesta.end(JSON.stringify({ motivo: "esa tarea ya no está esperando feedback" }));
+                    respuesta.end(JSON.stringify({ motivo }));
                     return;
                 }
-                atenderFeedbackDeTarea(mensaje.id, TEXTO_DE_CONTINUAR);
-                opciones.revisarTareas?.();
-                emitirTareas();
                 respuesta.writeHead(204);
                 respuesta.end();
                 return;
@@ -5874,9 +6355,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 void atenderAugmentar(opciones.augmentar, mensaje.proyecto, mensaje.peticion, mensaje.borrador);
             }
             else if (mensaje.accion === "feedback" && opciones.colaDeTareas !== undefined) {
-                atenderFeedbackDeTarea(mensaje.id, mensaje.texto);
-                opciones.revisarTareas?.();
-                emitirTareas();
+                darFeedbackATarea(mensaje.id, mensaje.texto);
             }
             else if (mensaje.accion !== "crear" &&
                 mensaje.accion !== "augmentar" &&
@@ -6137,17 +6616,35 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
-        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "cancelar") {
-            // Parar ESTE turno, no cerrar la conversación. Sin proyecto abierto no hay turno que
-            // parar y se dice: un botón que no puede cumplir no puede callar.
-            const abierto = vestibulo.proyectoAbierto();
-            if (abierto === undefined || !abierto.cancelarTurno()) {
-                informar("no hay ningún turno en vuelo que parar");
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "remoto") {
+            // Con el interruptor apagado se contesta igual y no se ENCIENDE nada: ni se carga el
+            // paquete. Apagar sí se atiende siempre, pero solo actúa si hay algo encendido.
+            if (mensaje.accion === "apagar")
+                void apagarRemoto().catch(contar);
+            else if (mensaje.accion === "habilitar")
+                void atenderHabilitarRemoto(mensaje.valor).catch(contar);
+            else if (sesionRemota !== undefined && remotoHabilitado()) {
+                if (mensaje.accion === "encender")
+                    void sesionRemota.encender().catch(contar);
+                else if (mensaje.accion === "revocar")
+                    void sesionRemota.revocar().catch(contar);
+                else if (mensaje.accion === "via")
+                    atenderViaRemota(mensaje.via);
+                else if (mensaje.accion === "dominio")
+                    atenderDominioRemoto(mensaje.dominio);
+                else if (mensaje.accion === "authtoken")
+                    void pedirAuthtoken().catch(contar);
             }
             respuesta.writeHead(204);
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "cancelar") {
+            cancelarTurno();
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "sesion") {
             // Suelto: abrir un proyecto arranca una consola entera y el `POST` no se queda
             // esperando. Lo que pase se cuenta por el cable.
@@ -6387,27 +6884,12 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             void atenderAlta(mensaje);
         }
         else {
-            destinoActual().recibir(mensaje);
-            /**
-             * Y si fue una PROSA, se reanuncia el alta: la sesión acaba de darse de alta en el
-             * índice (`ConsolaDeProyecto.recibir`), así que hay una fila nueva que la barra tiene
-             * que enseñar YA — con su título y marcada como la activa.
-             *
-             * Diferido por lo mismo que el reanuncio de los flancos: el lazo coge la línea en una
-             * microtarea, y anunciar en el acto contaría el turno como no empezado. No sustituye a
-             * los flancos —de ellos sale la marca de «trabajando»—, cubre el caso en que no hay
-             * flanco ninguno: un `/comando`, que no corre turno.
-             */
-            if (mensaje.clase === "prosa") {
-                void Promise.resolve()
-                    .then(() => anunciarAlta())
-                    .catch(contar);
-            }
+            recibirEnLaConsola(mensaje);
         }
         respuesta.writeHead(204);
         respuesta.end();
     });
-    return { emitirTareas };
+    return { emitirTareas, cerrarRemoto: apagarRemoto };
 }
 /**
  * Construye el corredor de tareas y la costura que lo conecta al cable.
@@ -7341,6 +7823,35 @@ export async function arrancarConsolaWeb(opciones) {
     }
     const cable = montarRutas(servidor, vestibulo, {
         informar,
+        // El interruptor se lee de `settings.json` (o `XONECODE_REMOTO=1`) en cada uso. Sin el
+        // paquete del puente instalado, encender dice que no está disponible.
+        remoto: {
+            ajustes: () => remotoEnVigor(cargarSettings().settings.remoto, process.env),
+            puerto: opciones.puertoRemoto ??
+                (async () => {
+                    // `import()` dinámico también aquí: con el interruptor apagado ni se carga el adaptador.
+                    const { cargarModuloRemoto, crearPuenteWebSocket } = await import("../../agent/remoto/puenteWebSocket.js");
+                    const modulo = await cargarModuloRemoto();
+                    return modulo === undefined ? undefined : crearPuenteWebSocket(modulo);
+                }),
+            // La vía ngrok, también por `import()` dinámico: ni el túnel ni la medida se cargan hasta
+            // que alguien los usa, y los dos solo se usan con el interruptor encendido.
+            tunel: opciones.tunelRemoto ?? {
+                abrir: async (o) => {
+                    const { crearTunelNgrok } = await import("../../agent/remoto/tunelNgrok.js");
+                    return crearTunelNgrok().abrir(o);
+                },
+            },
+            medirNgrok: opciones.medirNgrok ??
+                (async () => {
+                    // ngrok viene con xonecode (el SDK): no hay receta de instalación que medir.
+                    const ngrok = await import("../../agent/remoto/ngrokEnMaquina.js");
+                    return ngrok.medirNgrok();
+                }),
+            guardarAuthtoken: opciones.guardarAuthtoken ??
+                (async (token) => (await import("../../agent/remoto/ngrokEnMaquina.js")).guardarAuthtoken(token)),
+            guardarAjustes: (cambio) => void guardarAjustesDeRemotoEnDisco(undefined, cambio),
+        },
         // El tope de ventana, tal cual llega: es la misma función que la barra del terminal, y
         // dos resoluciones serían dos porcentajes distintos para el mismo modelo.
         ...(opciones.topeDeContexto === undefined ? {} : { topeDeContexto: opciones.topeDeContexto }),
@@ -7559,6 +8070,11 @@ export async function arrancarConsolaWeb(opciones) {
      * señal repetida no puede matar el cierre que sigue: ver `interrupcion.ts`.
      */
     await (opciones.esperarCierre ?? (() => esperarInterrupcion({ avisar: escribir })))();
+    // La sesión remota antes que nada: un móvil no puede seguir mandando prosa a una consola que
+    // se está cerrando, y el socket del puente no puede quedarse abierto tras el proceso.
+    // Se ESPERA: con la vía ngrok, cerrar mata ngrok y el puente local, y sin esperar el proceso
+    // saldría antes y dejaría a ngrok huérfano del `SIGKILL` de rescate.
+    await cable.cerrarRemoto().catch(() => { });
     /**
      * El corredor PRIMERO, y el orden es load-bearing: `parar()` corta los turnos en vuelo y
      * los deja aparcados diciendo que la consola se cerró a mitad. Al revés, el