xonecode 0.2.0 → 0.5.0

package/dist/cli/main.js

@@ -14,17 +14,34 @@ import { cmdDoctor } from "./doctor.js";
 import { cmdVerify } from "./verify.js";
 import { ModeloMalEscrito, parsear, resolver } from "../core/modelos.js";
 import { topeResuelto } from "../core/contextos.js";
-import { cargar } from "../agent/configEnDisco.js";
-import { COMANDOS, correrConsola, crearCompleter, } from "./consola.js";
-import { crearLeerSecreto, crearPreguntar, crearPielStdio, escribirEnStdout } from "./stdio.js";
-import { crearTema } from "./tema.js";
+import { aplicarAuth, cargar, cloudstudioDelProyecto, aplicarCredencialAlProceso, guardarCloudStudioDeProyecto, guardarEntornoDeProyecto, guardarModeloGlobal, guardarModelosDeProyecto, proveedoresPersonalizados, guardarModoDeProyecto, guardarProyectoCloudStudioDeProyecto, guardarRamaDeProyecto, guardarTemaDeProyecto, } from "../agent/configEnDisco.js";
+import { crearCheckpointerDeProyecto } from "../agent/checkpointer.js";
+import { crearTareasEnDisco } from "../agent/tareasEnDisco.js";
+import { carpetaDeArtefactosDeSesion } from "../core/artefactos.js";
+import { seAplicaSinAprobacion } from "../core/settings.js";
+import { conectarCloudStudio, sesionCloudStudio, PUERTO_CALLBACK } from "../agent/cloudstudioMcp.js";
+import { clienteCloudStudio } from "../agent/cloudstudioClient.js";
+import { cargarSettings } from "../agent/settingsEnDisco.js";
+import { descargarProyecto } from "../agent/descarga.js";
+import { arbolLimpio, cambiosPendientes, prepararRepo, sinCommitear } from "../agent/gitSync.js";
+import { subir } from "../agent/subida.js";
+import { guardarCredencial } from "../agent/authEnDisco.js";
+import { asistenteDeModelo } from "./wizardInicial.js";
+import { COMANDOS, configurarModoInicial, correrConsola, crearCompleter, hayCredencial, hayEstadoDeProyecto, MENSAJE_BIENVENIDA, MENSAJE_REANUDANDO, PETICION_REANUDAR_PROYECTO, } from "./consola.js";
+import { crearDetectorDeEof, crearLeerSecreto, crearPreguntar, crearPielStdio, escribirEnStdout } from "./stdio.js";
+import { crearTema, esTema, seleccionarTema } from "./tema.js";
 import { pedirDecisiones } from "./aprobar.js";
+import { modeloDeAcuse } from "./acuseDeModelo.js";
 import { inspeccionar } from "../agent/entorno.js";
+import { versionEnMarcha } from "../agent/versionEnDisco.js";
 import { SkillsEnDisco } from "../agent/skills.js";
 import { Modelos } from "../agent/modelos.js";
+import { CatalogoModelos } from "../agent/catalogoModelos.js";
 import { abrirSesionReal, ficherosDelProyecto } from "../agent/turnoReal.js";
+import { SimuladorVerifier } from "../agent/verificador.js";
 import { crearProyecto } from "../agent/crearProyecto.js";
 import { createTokenTracker } from "../vendor/tokenTracking.js";
+import { compacto, formatearTokens, formatearTope } from "./tokens.js";
 /**
  * Estilo, y solo con TTY detrás.
  *
@@ -40,6 +57,10 @@ const BOLD = tema.negrita;
 const RESET = tema.reset;
 /** El prompt. Se ve dónde acaba la respuesta y empieza lo que uno escribe. */
 const PROMPT = CON_COLOR ? `${tema.prompt}❯${tema.reset} ` : "> ";
+/** El arranque automático falla como un turno normal: informa y deja la consola viva. */
+function describirError(e) {
+    return e instanceof Error ? `${e.constructor.name}: ${e.message}` : String(e);
+}
 /**
  * Envuelve las líneas de `readline` para pintar la barra y el prompt ANTES de cada una.
  *
@@ -68,6 +89,12 @@ async function* conPrompt(rl, escribir, barra) {
 }
 const AYUDA = `xonecode — harness de XOne
 
+  xonecode                       abre la consola WEB en el navegador (por defecto)
+  xonecode --no-abrir            la web, pero sin abrir el navegador (imprime la URL)
+  xonecode --puerto <n>          la web en otro puerto (por omisión 4173)
+  xonecode --anfitrion <host>    acepta ese Host además del loopback, para un túnel
+  xonecode --cli                 la consola de terminal (TUI)
+  xonecode --cli --no-tui        consola clásica (stdio)
   xonecode run "<peticion>"      un turno, de un disparo (pipeable)
   xonecode run --real "<peticion>"   el agente real sobre el proyecto del cwd
   xonecode describe              qué hay montado y qué es de pega (sin red)
@@ -76,6 +103,11 @@ const AYUDA = `xonecode — harness de XOne
   xonecode doctor                ¿hay un proyecto aquí? ¿responde el simulador?
   xonecode verify [ruta]         valida el proyecto con xone-simulator (por omisión, aquí)
   xonecode --guion               la consola con el agente de pega, sin gastar
+  xonecode --guion --web         lo mismo, y si el cwd es un proyecto offline lo abre
+                                  solo: la maqueta completa sin alta ni CloudStudio
+  xonecode --web                 fuerza la web aunque no haya terminal interactivo
+  xonecode --cli --tui           fuerza la interfaz de terminal (TUI)
+  xonecode --cli --sin-raton     TUI sin capturar el ratón (la rueda vuelve al terminal)
   xonecode --help                esto
 
 Modelo:
@@ -131,20 +163,6 @@ export function extraerBanderasDeModelo(argv) {
         resto,
     };
 }
-/**
- * Token compacto para la línea de estado: `0 tokens` hasta 999, `12.8K tokens` a partir
- * de 1000. Un decimal basta para un indicador de cabecera; la cifra exacta la da quien
- * la necesita (printTokenUsage al final de los experimentos).
- */
-function formatearTokens(total) {
-    return total < 1000 ? `${total} tokens` : `${(total / 1000).toFixed(1)}K tokens`;
-}
-/** El tope de contexto, compacto: `131K`, `200K`, `1M`. Sin decimales de cortesía. */
-function formatearTope(tope) {
-    if (tope >= 1_000_000)
-        return `${tope / 1_000_000}M`;
-    return `${Math.round(tope / 1000)}K`;
-}
 /**
  * La barra de estado como función PURA: la compone quien tiene los valores y
  * la pinta quien tiene el color. Así la barra se puede probar sin TTY — y es
@@ -156,13 +174,151 @@ function formatearTope(tope) {
  */
 export function formatearBarra(p) {
     const ctx = p.contexto > 0
-        ? ` · ctx ${formatearTokens(p.contexto).replace(" tokens", "")}` +
+        ? ` · ctx ${compacto(p.contexto)}` +
             (p.tope !== undefined
                 ? `/${formatearTope(p.tope)} (${Math.round((p.contexto / p.tope) * 100)}%)`
                 : "")
         : "";
     return `─ ${p.proyecto} (${p.colecciones} colls) · ${p.modelo} · ${formatearTokens(p.tokens)}${ctx} · /ayuda`;
 }
+/**
+ * El tope de la ventana del modelo ACTUAL: tabla de `core/contextos.ts` + lo que el
+ * usuario haya fijado en `config.json` (lo de proyecto gana a lo global, como los
+ * modelos). Fábrica PORQUE la barra lo lee en cada llamada y no en el arranque:
+ * /modelo cambia el modelo en caliente, y un tope del modelo equivocado es un
+ * porcentaje que miente. Si el id no parsea —no debería, viene de `resolver`—, no hay
+ * tope y no pasa nada.
+ *
+ * Exportada para que la TUI calcule su `ctx` con LA MISMA función que usa la barra de
+ * stdio y la que /config declara: dos pieles no pueden divergir en el tope.
+ */
+export function crearTopeDelModelo(raiz) {
+    return (id) => {
+        try {
+            const { proveedor, modelo } = parsear(id);
+            const { config } = cargar(raiz);
+            // Misma resolución que /config (`topeResuelto`): proyecto gana a global, y la
+            // tabla es el último recurso. El origen aquí no se mira, pero así no puede
+            // divergir entre lo que la barra calcula y lo que /config declara.
+            return topeResuelto(proveedor, modelo, {
+                proyecto: config.proyecto?.contextos,
+                global: config.global?.contextos,
+            })?.tope;
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
+/**
+ * ¿TUI o stdio? `--no-tui` gana siempre (el usuario pidió explícitamente la consola
+ * clásica); después `--tui` fuerza la TUI aunque no haya TTY (quien la pide, la tiene:
+ * sin TTY el raw mode no funciona y el resultado es suyo); por omisión, AMBOS lados
+ * TTY → TUI (solo mirar stdout monta la TUI con stdin de tubería — «echo /salir |
+ * xonecode» en un terminal real — y los bytes del pipe se consumen como teclas mientras
+ * el EOF del pipe no termina el lazo) y cualquier tubería → stdio, que es lo que
+ * mantiene el e2e de pipe byte-idéntico.
+ */
+/**
+ * ¿Captura la TUI el ratón? Con él, la rueda mueve el transcript y no el scrollback del
+ * terminal, a cambio de que seleccionar texto sea Alt/Shift + arrastre. `--sin-raton` lo
+ * apaga. Pura, para probarla.
+ */
+export function quiereRaton(argv = []) {
+    return !argv.includes("--sin-raton");
+}
+export function decidirTui(argv = []) {
+    if (argv.includes("--no-tui"))
+        return false;
+    if (argv.includes("--tui"))
+        return true;
+    return process.stdout.isTTY === true && process.stdin.isTTY === true;
+}
+/**
+ * Error de USO: una bandera imposible de obedecer, nunca un fallo del harness. Mismo
+ * tratamiento que `ModeloMalEscrito` en el `catch` de `main` — mensaje a stderr, sin
+ * traza, código 64 — pero con su propia clase: reusar `ModeloMalEscrito` aquí mentiría
+ * sobre la causa, y el contrato de códigos de salida lo lee CI.
+ */
+export class ErrorDeUso extends Error {
+}
+const PUERTO_WEB_POR_OMISION = 4173;
+/**
+ * Qué piel arranca. Hermana pura de `decidirTui`, y por la misma razón: la decisión se
+ * prueba sin TTY, y la rama que la usa solo la obedece.
+ *
+ * La omisión ya es la web. `--cli` gana siempre —es la puerta a la consola de terminal
+ * entera, TUI incluida— y `--web` fuerza la web incluso sin terminal, que es lo que hace
+ * falta en una máquina remota sin TTY.
+ *
+ * El TTY entra por parámetro y no se lee aquí dentro para poder probar los dos lados sin
+ * terminal; la omisión sigue siendo el `process.stdin.isTTY` de verdad.
+ */
+/**
+ * Las banderas que solo tienen sentido en la consola de TERMINAL. Pedir cualquiera de ellas
+ * es pedir la terminal, así que implican `--cli`.
+ *
+ * Medido con un pty: sin esto, `xonecode --tui` imprimía «consola web en …» y abría el
+ * navegador — o sea, la bandera documentada como «fuerza la interfaz de terminal» hacía
+ * exactamente lo contrario y sin decir nada; `--no-tui`, que ERA la vía a la stdio, se
+ * ignoraba igual. Una bandera que se obedece al revés en silencio es el bug mudo que este
+ * repo persigue en todas partes.
+ */
+const BANDERAS_DE_TERMINAL = ["--tui", "--no-tui", "--sin-raton"];
+export function decidirPiel(argv = [], entorno = {}) {
+    // `--cli` gana SIEMPRE, también frente a la combinación imposible de abajo: es la orden
+    // más explícita que hay y no puede quedar en un error.
+    if (argv.includes("--cli"))
+        return "consola";
+    const deTerminal = BANDERAS_DE_TERMINAL.filter((b) => argv.includes(b));
+    if (argv.includes("--web")) {
+        // Obedecer una y callar la otra es lo que no se puede hacer: la bandera perdedora se
+        // habría ignorado en silencio. Error de USO (64), como `--tui` sin terminal.
+        if (deTerminal.length > 0) {
+            throw new ErrorDeUso(`«${deTerminal.join("», «")}» son de la consola de terminal y --web pide la web: elige una`);
+        }
+        return "web";
+    }
+    if (deTerminal.length > 0)
+        return "consola";
+    // Sin stdin TTY la omisión NO es la web: `echo "…" | xonecode` intentaría abrir un
+    // navegador y se llevaría por delante el e2e de tubería byte-idéntica, que es lo que
+    // sostiene que `npm test` no necesite terminal.
+    const tty = entorno.stdinTTY ?? process.stdin.isTTY === true;
+    return tty ? "web" : "consola";
+}
+/**
+ * El anfitrión de un túnel: un nombre de máquina, y nada más.
+ *
+ * Se valida aquí y no en el servidor porque es un error de USO (64) y no de ejecución. Sin
+ * comodines, sin esquema, sin ruta y sin puerto: lo que llega en la cabecera `Host` de un
+ * túnel HTTPS es el nombre pelado, y aceptar `https://x/` o `*.ngrok-free.app` sería aceptar
+ * algo que nunca va a casar —o, peor, casar de más—.
+ */
+function anfitrionDeTunel(bruto) {
+    const valor = (bruto ?? "").trim();
+    if (!/^[a-zA-Z0-9.-]+$/.test(valor) || valor.includes("*")) {
+        throw new ErrorDeUso(`--anfitrion espera un nombre de máquina (por ejemplo «algo.ngrok-free.app»), y recibió «${bruto ?? ""}»`);
+    }
+    return valor;
+}
+export function parsearOpcionesWeb(argv) {
+    const abrir = !argv.includes("--no-abrir");
+    const j = argv.indexOf("--anfitrion");
+    const anfitrion = j === -1 ? {} : { anfitrion: anfitrionDeTunel(argv[j + 1]) };
+    const i = argv.indexOf("--puerto");
+    if (i === -1)
+        return { puerto: PUERTO_WEB_POR_OMISION, abrir, ...anfitrion };
+    const bruto = argv[i + 1];
+    const puerto = Number(bruto);
+    if (!Number.isInteger(puerto) || puerto < 1 || puerto > 65535) {
+        throw new ErrorDeUso(`--puerto espera un número entre 1 y 65535, y recibió «${bruto ?? ""}»`);
+    }
+    if (puerto === PUERTO_CALLBACK) {
+        throw new ErrorDeUso(`el puerto ${PUERTO_CALLBACK} está reservado al callback de OAuth de CloudStudio: elige otro`);
+    }
+    return { puerto, abrir, ...anfitrion };
+}
 /**
  * El ejecutor de turno REAL de la consola: cada línea de prosa corre sobre una `SesionReal`
  * que sobrevive entre turnos (mismo agente, mismo hilo).
@@ -179,8 +335,31 @@ export function formatearBarra(p) {
  * `alAbrirSesion` se llama UNA vez, justo tras `abrirSesionReal`, y es la costura por la
  * que `entrarEnConsola` apunta la barra de estado al tracker de la sesión (que alimenta
  * el agente; el de `createTokenTracker()` de cabecera se descarta al reasignarse).
+ *
+ * Exportada porque la consola web la monta tal cual: es exactamente lo que espera la
+ * opción `crearEjecutor` del vestíbulo (`web/servidor/vestibulo.ts`), que usa esa misma
+ * costura para poder CERRAR la sesión al cambiar de proyecto. Una segunda fábrica para la
+ * web habría sido un segundo sitio donde arreglar cada bug del ejecutor real.
+ */
+/**
+ * `checkpointerDeProyecto` entra por parámetro y no se importa aquí, y no es purismo: la
+ * consola de TERMINAL no lo pasa. Su hilo es un uuid nuevo en cada arranque y no hay índice
+ * de sesiones donde reanudarlo, así que persistirlo solo dejaría hilos que nadie puede
+ * volver a abrir engordando el fichero del proyecto. Persistir es de quien tiene identidad
+ * que reanudar — hoy, la consola web.
  */
-function crearEjecutorReal(alAbrirSesion) {
+export function crearEjecutorReal(alAbrirSesion, checkpointerDeProyecto, carpetaDeArtefactos, 
+/**
+ * La carpeta de los ADJUNTOS de una tarea — `/adjuntos/` para el agente, de solo lectura.
+ *
+ * Es un valor y no una función de `(raiz, hilo)` como las dos de arriba, y esa diferencia
+ * es el dato: los artefactos se derivan de la sesión, pero los adjuntos son de la TAREA, y
+ * la tarea solo la conoce quien abrió esta consola (el corredor). Por eso llega a la
+ * FÁBRICA: es una propiedad de la consola, igual que su checkpointer.
+ *
+ * Ausente en toda consola de persona y en toda tarea sin adjuntos.
+ */
+carpetaDeAdjuntos) {
     let sesion;
     let fuentesVistas;
     let hiloVisto;
@@ -194,18 +373,81 @@ function crearEjecutorReal(alAbrirSesion) {
                 consolaReal.escribir("✗ falta algo imprescindible: xonecode no puede trabajar aquí.\n");
                 return;
             }
+            const persistente = checkpointerDeProyecto?.(estado.raiz);
+            // Y si había fábrica pero no dio nada, el fichero no se pudo abrir: se DICE. Sin esto
+            // la sesión funcionaba igual y en silencio dejaba de recordar entre arranques, que es
+            // justo la clase de degradación muda que este repo evita. El motivo no viaja —puede
+            // llevar la ruta absoluta del home—, así que se dice QUÉ pasa, no dónde.
+            if (checkpointerDeProyecto !== undefined && persistente === undefined) {
+                consolaReal.escribir("aviso: no se pudo abrir la memoria del proyecto (.xonecode/checkpoint.sqlite); " +
+                    "esta conversación no se recordará al reabrirla.\n");
+            }
             sesion = await abrirSesionReal({
                 raiz: estado.raiz,
-                modelos: new Modelos(estado.fuentes),
+                modelos: new Modelos(estado.fuentes, proveedoresPersonalizados),
                 skills: new SkillsEnDisco(),
                 entorno,
+                // El hilo de la CONSOLA, no uno propio. Había dos ids para lo mismo —el que
+                // `/hilo` enseña y el que se generaba dentro— y solo coincidían tras un `/nuevo`.
+                // Y en la web ese hilo es el id de la sesión, que es lo que la hace reanudable.
+                hilo: estado.hilo,
+                // La memoria del agente entre arranques. Ausente —porque nadie pasó fábrica, o
+                // porque abrir el fichero falló— y `abrirSesionReal` cae en el `MemorySaver` de
+                // siempre: se pierde la memoria entre arranques, que es lo que ya pasaba.
+                ...(persistente === undefined ? {} : { checkpointer: persistente }),
+                // Dónde caen los diagramas y demás salidas del agente. Con sesión (la web) van a la
+                // carpeta de ESA sesión; sin ella, `abrirSesionReal` cae a `.xonecode/artefactos`
+                // del proyecto — el hilo del terminal es un uuid nuevo por arranque, y una carpeta
+                // por hilo dejaría basura que nadie puede volver a abrir.
+                ...(carpetaDeArtefactos === undefined
+                    ? {}
+                    : { artefactos: carpetaDeArtefactos(estado.raiz, estado.hilo) }),
+                // Los adjuntos de la tarea, si esta consola es de una tarea con alguno. Ausente es
+                // «no hay», y el campo NO se pone: una cadena vacía montaría el cwd del proceso.
+                ...(carpetaDeAdjuntos === undefined ? {} : { adjuntos: carpetaDeAdjuntos }),
+                // Si las escrituras de ESTE proyecto se aplican sin preguntar. Se pregunta en cada
+                // ronda —de ahí la función— porque `/aprobacion` lo cambia sin cerrar la sesión, y
+                // porque `interactivo` es de la consola que esté delante. Los settings se releen
+                // cada vez por lo mismo: la alternativa es que el cambio no surta efecto hasta
+                // reabrir, y la mitad de las veces eso sería en la dirección peligrosa.
+                // Cuántas rondas de aprobación admite un turno de ESTA consola. La pone quien la
+                // monta porque es quien sabe quién está detrás (ver `Consola.topeDeAprobaciones`);
+                // ausente y `abrirSesionReal` usa el `MAX_APPROVAL_ROUNDS` de siempre.
+                ...(consolaReal.topeDeAprobaciones === undefined
+                    ? {}
+                    : { topeDeRondas: consolaReal.topeDeAprobaciones }),
+                sinAprobacion: () => seAplicaSinAprobacion({
+                    raiz: estado.raiz,
+                    sinAprobacion: cargarSettings().settings.sinAprobacion,
+                    // Del DISCO y por la raíz, no de `estado.fuentes.proyecto`: en la web ese
+                    // campo no se rellena nunca, y la guarda habría dado «offline» para todos.
+                    cloudstudio: cloudstudioDelProyecto(estado.raiz),
+                    // `interactivo` SOLO no basta, y esto no es celo: `consolaWeb.ts` lo declara
+                    // `true` a fuego, así que una pestaña que se cierra a mitad de turno seguiría
+                    // auto-aprobando. «Hay alguien delante» ya está definido en este repo —
+                    // `pedirDecisiones` lo calcula como `interactive && !eof()` (`cli/aprobar.ts`)—
+                    // y esa es la misma cuenta. Con ella, al caerse el cable la escritura vuelve al
+                    // camino de aprobación, donde el eof la rechaza.
+                    interactivo: consolaReal.interactivo && !(consolaReal.eof?.() ?? false),
+                }),
+                // El simulador de verdad. Su ausencia en la máquina no se descubre aquí sino al
+                // verificar, y entonces se dice en el turno — sin tumbar nada.
+                verifier: new SimuladorVerifier(),
                 // Las aprobaciones entran por el `preguntar` de la propia consola: el turno para
                 // y pregunta DENTRO de la sesión, sin salir de ella ni montar otro lector de stdin.
-                pedirAprobacion: (lista, ficheros, diffs) => pedirDecisiones(lista, consolaReal.preguntar, consolaReal.escribir, {
-                    interactive: consolaReal.interactivo,
-                    fichero: (id) => ficheros.get(id),
-                    diff: (id) => diffs.get(id),
-                }),
+                // Si la consola aporta su propio puerto (`aprobacionesTui`, el modal de la TUI),
+                // manda: mismo contrato que este `pedirDecisiones` por readline.
+                pedirAprobacion: async (lista, ficheros, diffs) => consolaReal.aprobacionesTui !== undefined
+                    ? consolaReal.aprobacionesTui(lista, ficheros, diffs)
+                    : pedirDecisiones(lista, consolaReal.preguntar, consolaReal.escribir, {
+                        interactive: consolaReal.interactivo,
+                        // Sin esto, el Ctrl-D de un TTY llega como cadena vacía y `interactive:
+                        // true` la aprueba: un EOF haciéndose pasar por el Enter que aprueba
+                        // escrituras. `eof` lo distingue (`cli/aprobar.ts` lo explica entero).
+                        eof: consolaReal.eof,
+                        fichero: (id) => ficheros.get(id),
+                        diff: (id) => diffs.get(id),
+                    }),
             });
             alAbrirSesion(sesion);
             // Recién construida: no hay cambio que detectar en esta primera vuelta.
@@ -216,7 +458,7 @@ function crearEjecutorReal(alAbrirSesion) {
             // `/modelo` solo actualizó `estado.fuentes`; aquí es donde deja de ser un cambio
             // cosmético: el agente se reconstruye con el modelo nuevo y el hilo SE CONSERVA.
             if (JSON.stringify(estado.fuentes) !== JSON.stringify(fuentesVistas)) {
-                await sesion.cambiarModelos(new Modelos(estado.fuentes));
+                await sesion.cambiarModelos(new Modelos(estado.fuentes, proveedoresPersonalizados));
                 consolaReal.escribir("  (agente reconstruido con el modelo nuevo — el hilo se conserva)\n");
                 fuentesVistas = estado.fuentes;
             }
@@ -231,7 +473,59 @@ function crearEjecutorReal(alAbrirSesion) {
                 hiloVisto = estado.hilo;
             }
         }
-        await sesion.turno(peticion, crearPielStdio(consolaReal.escribir));
+        // La piel del turno: la de la consola si la aporta (la TUI), y el render stdio de
+        // siempre si no — mismo reparto que `ejecutarTurnoGuionizado`.
+        const resultado = await sesion.turno(peticion, consolaReal.piel?.() ?? crearPielStdio(consolaReal.escribir));
+        /**
+         * **Y se DEVUELVE lo que el turno sabe de sí mismo**, que antes se tiraba aquí.
+         *
+         * Era una deuda medida: `EjecutorDeTurno` devolvía `void`, así que el `cortadoPorTope`
+         * —y con él el hecho de que quedaron escrituras sin aplicar y el veredicto del
+         * verificador— morían en esta línea. Con las tareas de fondo aplicando escrituras
+         * solas, eso se veía en el kanban: cuatro ficheros escritos, una escritura abandonada,
+         * el verificador sin correr ni una vez, y la tarea diciendo «terminada». Quien decide
+         * si eso es entregable es `core/entrega.ts`; aquí solo se abre el canal.
+         *
+         * Se reenvían los campos de `ResultadoDeTurno` y NO el objeto entero: la bitácora y
+         * los `Cambio` son piezas de `agent/` que no tienen por qué cruzar hasta el corredor
+         * de tareas, y `cambios` lleva rutas del proyecto que nadie de ahí necesita.
+         */
+        return {
+            verificador: resultado.verificador,
+            pendientes: resultado.pendientes,
+            ...(resultado.hallazgos === undefined ? {} : { hallazgos: resultado.hallazgos }),
+            ...(resultado.motivoSinVerificar === undefined
+                ? {}
+                : { motivoSinVerificar: resultado.motivoSinVerificar }),
+        };
+    };
+}
+/**
+ * Los adaptadores de disco y de red que dependen SOLO de la raíz del proyecto.
+ *
+ * Existe porque estaban escritos dos veces —una en la rama TUI y otra en la stdio— y eso
+ * ya divergió, medido: el arreglo del `entorno` caducado de `/connect-studio` entró en la
+ * rama TUI y no en la de stdio, así que por la consola de terminal seguía guardándose una
+ * `url` nueva encima de un `entorno` que nombraba el juego de credenciales de OTRO
+ * servidor. Es el mismo principio que ya rige aquí para los comandos («la consola y la
+ * shell no divergen porque comparten función»), aplicado a los adaptadores: con una sola
+ * definición, «las dos ramas hacen lo mismo» deja de ser algo que haya que recordar.
+ */
+export function adaptadoresDeProyecto(raiz, 
+/** Misma costura que `guardarEndpointYEntorno`: los tests no pueden leer el
+ *  `~/.xonecode/settings.json` de quien corre la suite. */
+leerSettings = cargarSettings) {
+    return {
+        guardarTemaDeProyecto: (tema) => guardarTemaDeProyecto(raiz, tema),
+        // `guardarEndpointYEntorno` y NUNCA `guardarCloudStudioDeProyecto` a pelo: el endpoint
+        // y el entorno tienen que escribirse juntos o la referencia se queda caducada.
+        guardarCloudStudioDeProyecto: (url, scopes) => guardarEndpointYEntorno(raiz, url, scopes, leerSettings),
+        guardarModoDeProyecto: (modo) => guardarModoDeProyecto(raiz, modo),
+        guardarProyectoCloudStudioDeProyecto: (proyecto) => guardarProyectoCloudStudioDeProyecto(raiz, proyecto),
+        ramasDeCloudStudio: crearListaDeRamas(raiz),
+        guardarRamaDeProyecto: (rama) => guardarRamaDeProyecto(raiz, rama),
+        guardarModelosDeProyecto: (papel, id) => guardarModelosDeProyecto(raiz, papel, id),
+        sincronizar: crearSincronizador(),
     };
 }
 /**
@@ -309,6 +603,188 @@ async function preguntarDatos(consola) {
 export function crearCompleterDelProyecto(raiz, escribir = escribirEnStdout) {
     return crearCompleter(escribir, () => ficherosDelProyecto(raiz));
 }
+const PIEZAS_DE_SINCRONIZACION_REALES = {
+    leerConfig: cargar,
+    leerSettings: cargarSettings,
+    sesion: sesionCloudStudio,
+    cliente: clienteCloudStudio,
+    descargar: descargarProyecto,
+    preparar: prepararRepo,
+    pendientes: cambiosPendientes,
+    limpio: arbolLimpio,
+    sinCommitear,
+    subirProyecto: subir,
+};
+/**
+ * Qué entorno de `settings.json` sirve esta URL.
+ *
+ * Existe porque el `entorno` del `config.json` puede FALTAR o quedarse viejo, y las dos
+ * cosas mandaban el token al hueco equivocado:
+ *
+ *  - Falta en todo proyecto dado de alta desde la terminal, que no elige entorno. Esos
+ *    proyectos viven en `legado` hasta que alguien registra el oficial en el vestíbulo, y
+ *    entonces `adoptarLegadoSiProcede` MUEVE ese juego a `webstudio` y los deja sin tokens:
+ *    reautenticaban en silencio. Casando la URL leen el hueco adoptado y no se enteran.
+ *  - Se queda viejo cuando `/connect-studio` reescribe la `url` del proyecto: sin volver a
+ *    resolver, el `entorno` anterior seguiría nombrando el juego de OTRO servidor.
+ *
+ * La comparación normaliza con `URL` y cae a la comparación literal si alguna cadena no
+ * parsea. Qué absorbe esa normalización, MEDIDO y no supuesto: el case del host y el puerto
+ * por omisión explícito (`:443`) sí casan; una barra final de más, un `?` vacío, otro puerto,
+ * `http` frente a `https` y otro case en la RUTA no casan. Que no casen es benigno y no
+ * accidental: el fallo devuelve `undefined` —y cae en `legado`, donde ese proyecto ya
+ * estaba— en vez de resolver al id de otro entorno. Ninguna variante cruza a un id ajeno, y
+ * ESA es la propiedad de la que depende no mandarle a un servidor el token de otro.
+ */
+export function entornoDeUrl(url, entornos) {
+    const canonica = (valor) => {
+        try {
+            return new URL(valor).toString();
+        }
+        catch {
+            return valor;
+        }
+    };
+    const buscada = canonica(url);
+    return entornos.find((entorno) => canonica(entorno.url) === buscada)?.id;
+}
+/**
+ * El adaptador de `/connect-studio`: guarda el endpoint Y vuelve a resolver el `entorno`.
+ *
+ * Las dos escrituras van juntas a propósito. Separarlas es lo que dejaba el `entorno`
+ * caducado apuntando al juego de credenciales de otro servidor — el fallo peor de todo
+ * este arreglo, porque manda un token válido a un endpoint que no lo emitió.
+ */
+export function guardarEndpointYEntorno(raiz, url, scopes, leerSettings = cargarSettings) {
+    const guardado = guardarCloudStudioDeProyecto(raiz, url, scopes);
+    // Sin entorno registrado para esa URL se BORRA la clave: el OAuth de esa URL cae en
+    // `legado`, y decir «webstudio» sería nombrar un juego que no es el suyo.
+    guardarEntornoDeProyecto(raiz, entornoDeUrl(guardado.url, leerSettings().settings.entornos));
+    return guardado;
+}
+/**
+ * El endpoint de CloudStudio del proyecto YA guardado, o `undefined` si `/sync` no puede
+ * seguir: ni «no hay `cloudstudio`» ni «falta el proyecto o la rama» (un `/connect-studio`
+ * sin completar el alta) se distinguen hoy — las dos caen en el mismo texto genérico de
+ * `crearSincronizador`. Si algún día hace falta un mensaje más fino, es aquí donde separar
+ * los dos casos, sin tocar a quien llama.
+ */
+function cloudStudioDeProyecto(leerConfig, leerSettings, raiz) {
+    const proyectoConfig = leerConfig(raiz).config.proyecto;
+    const cloudstudio = proyectoConfig?.cloudstudio;
+    if (cloudstudio === undefined)
+        return undefined;
+    if (cloudstudio.proyecto === undefined || cloudstudio.rama === undefined)
+        return undefined;
+    // `entorno` viaja junto a la URL porque decide de QUÉ juego de credenciales se lee
+    // (`porEntorno[id]`, `agent/cloudstudioMcp.ts`). Si al `config.json` le falta —todo
+    // proyecto dado de alta desde la terminal— se resuelve casando la URL contra los
+    // entornos registrados: ver `entornoDeUrl`. Si tampoco así aparece, `undefined` cae en
+    // `legado`, que es donde ese proyecto tiene sus tokens.
+    return {
+        url: cloudstudio.url,
+        scopes: cloudstudio.scopes,
+        proyecto: cloudstudio.proyecto,
+        rama: cloudstudio.rama,
+        entorno: proyectoConfig?.entorno ?? entornoDeUrl(cloudstudio.url, leerSettings().settings.entornos),
+    };
+}
+/**
+ * El adaptador real de `consola.sincronizar`: abre una sesión MCP VIVA con
+ * `sesionCloudStudio` —`conectarCloudStudio` cierra su transporte al terminar y sirve
+ * para el alta, pero no para operar— y la cierra siempre en un `finally`, tanto si la
+ * operación termina bien como si revienta.
+ *
+ * El orden dentro de «bajar» es crítico: `descargarProyecto` (que ya retira las vistas
+ * aplanadas) y DESPUÉS `prepararRepo`. Al revés, git vería esos `.xml` como borrados y la
+ * primera subida los borraría en Studio.
+ *
+ * Las dos direcciones se niegan con el árbol sucio ANTES de abrir sesión ni tocar
+ * CloudStudio: «subir» porque se sube el estado de un commit y no un borrador (para que
+ * mover la ref signifique algo), y «bajar» porque la descarga SOBRESCRIBE el disco y el
+ * baseline se construye después — sin un commit debajo, el trabajo local no se recupera.
+ */
+export function crearSincronizador(piezas = PIEZAS_DE_SINCRONIZACION_REALES) {
+    return async (accion, raiz, politicaDeAprobacion, informar = () => { }) => {
+        const config = cloudStudioDeProyecto(piezas.leerConfig, piezas.leerSettings, raiz);
+        if (config === undefined) {
+            return { tipo: "texto", texto: "este proyecto no es cloud (o le falta el proyecto/rama del alta)\n" };
+        }
+        // Las DOS direcciones exigen árbol limpio, y «bajar» no menos que «subir»: la
+        // descarga SOBRESCRIBE el disco (`extraerZipBase64` escribe encima, no fusiona) y el
+        // baseline se construye DESPUÉS, así que sin un commit debajo el trabajo local no se
+        // recupera de ninguna forma. Es alcanzable sin escribir `/sync`: el alta llama a
+        // `sincronizar("bajar", …)`, así que quien arranca xonecode en una carpeta con
+        // trabajo y elige modo cloud lo perdería. La guarda va ANTES de abrir sesión MCP.
+        if (accion !== "estado" && !(await piezas.limpio(raiz))) {
+            // `sinCommitear` y no `pendientes`: la pregunta aquí es «qué falta por COMMITEAR»,
+            // y además `pendientes` compara contra la ref de seguimiento, que en el alta de una
+            // carpeta que todavía no es repo no existe siquiera.
+            return { tipo: "arbol-sucio", accion, pendientes: await piezas.sinCommitear(raiz) };
+        }
+        const sesion = await piezas.sesion(config.url, { scopes: config.scopes, entornoId: config.entorno });
+        try {
+            const puerto = piezas.cliente(sesion.invocar, config.proyecto.nombre);
+            if (accion === "bajar") {
+                // `ramaOrigen` fija explícitamente de qué rama se baja (`descargarProyecto` la
+                // deja posicionada y la restaura al terminar): sin esto se traería lo que
+                // estuviera ACTIVO en la sesión de Studio, y una subida posterior firmaría ese
+                // contenido como si fuera de `config.rama`, en silencio.
+                const bajada = await piezas.descargar({ puerto, raiz, proyecto: config.proyecto, ramaOrigen: config.rama, informar });
+                await piezas.preparar(raiz, bajada.rama, informar);
+                return { tipo: "texto", texto: `bajados ${bajada.descargados.length} ficheros (${bajada.via})\n` };
+            }
+            if (accion === "subir") {
+                const informe = await piezas.subirProyecto({
+                    puerto,
+                    raiz,
+                    // La MISMA rama de la que se bajó: lo que se pide es aplicar cambios y subirlos a
+                    // la rama del proyecto, no a una rama de trabajo aparte que nadie mira en Studio.
+                    ramaOrigen: config.rama,
+                    proyecto: config.proyecto,
+                    // Fail-closed si alguien llamara a `sincronizar("subir", ...)` sin política (el
+                    // comando `/sync` siempre construye una): sin ella, no autoriza NADA en vez de
+                    // asumir que sí. El hueco lo documenta `core/cloudstudio.ts#PoliticaDeAprobacion`.
+                    politicaDeAprobacion: politicaDeAprobacion ?? (async () => false),
+                    informar,
+                });
+                return { tipo: "texto", texto: `subidos ${informe.ok.length}, fallaron ${informe.fallos.length}\n` };
+            }
+            const pendientes = await piezas.pendientes(raiz, config.rama);
+            return { tipo: "texto", texto: `rama ${config.rama}: ${pendientes.length} ficheros por subir\n` };
+        }
+        finally {
+            await sesion.cerrar();
+        }
+    };
+}
+/**
+ * El adaptador real de `consola.ramasDeCloudStudio`: mismo patrón de sesión VIVA +
+ * `finally`. Se usa durante el alta, con `proyecto` y `url` ya guardados pero la rama
+ * todavía sin elegir — por eso lee el config en cada llamada en vez de recibirlo cerrado.
+ */
+export function crearListaDeRamas(raiz, piezas = PIEZAS_DE_SINCRONIZACION_REALES) {
+    return async (proyectoNombre) => {
+        const proyectoConfig = piezas.leerConfig(raiz).config.proyecto;
+        const cloudstudio = proyectoConfig?.cloudstudio;
+        if (cloudstudio?.url === undefined)
+            return [];
+        // Mismo motivo, y misma resolución por URL, que en `cloudStudioDeProyecto`: sin el id
+        // del entorno un proyecto ya migrado a `webstudio` volvería a autenticar bajo `legado`.
+        const sesion = await piezas.sesion(cloudstudio.url, {
+            scopes: cloudstudio.scopes,
+            entornoId: proyectoConfig?.entorno ?? entornoDeUrl(cloudstudio.url, piezas.leerSettings().settings.entornos),
+        });
+        try {
+            const puerto = piezas.cliente(sesion.invocar, proyectoNombre);
+            await puerto.abrir(proyectoNombre);
+            return await puerto.ramas();
+        }
+        finally {
+            await sesion.cerrar();
+        }
+    };
+}
 export async function entrarEnConsola(fuentes, raiz = process.cwd(), escribir = escribirEnStdout, inspeccionarProyecto = inspeccionar, crearRl = () => readline.createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -320,7 +796,70 @@ export async function entrarEnConsola(fuentes, raiz = process.cwd(), escribir =
     prompt: PROMPT,
 }), guion = false, 
 /** Costura de test del «¿hay alguien al otro lado?»: sin TTY no se pregunta nada. */
-interactivo = process.stdin.isTTY === true) {
+interactivo = process.stdin.isTTY === true, 
+/**
+ * ¿Arranca la TUI? Costura de test: los tests corren sin TTY y pasan `false` (o no
+ * la pasan, y `decidirTui` sin banderas cae en el `isTTY` del proceso). En la rama
+ * TUI este parámetro de `interactivo` no se usa: la TUI es interactiva por diseño.
+ */
+usarTui = decidirTui(), 
+/** ¿Ratón en la TUI? Solo la rama TUI lo mira. */
+raton = true, 
+/** Adaptadores compartidos por stdio y TUI; `main` construye una sola instancia real. */
+dependencias = {
+    catalogoModelos: new CatalogoModelos(undefined, undefined, proveedoresPersonalizados),
+    guardarModeloGlobal,
+    conectarCloudStudio: (url, scopes, informar) => 
+    // El entorno se resuelve por URL, no se omite: sin esto, un `/connect-studio` sobre
+    // un proyecto del vestíbulo abría OAuth en `legado` —un hueco que `/sync` no lee— y
+    // dejaba al proyecto reautenticando en cada sincronización.
+    conectarCloudStudio(url, { informar, scopes, entornoId: entornoDeUrl(url, cargarSettings().settings.entornos) }),
+}) {
+    // La elección de modelo y las credenciales se hidratan ANTES de decidir la piel:
+    // stdio y TUI reciben exactamente las mismas fuentes y el catálogo leerá la clave
+    // ya aplicada solo cuando `/modelos` provoque su primera consulta.
+    const cargado = cargar(raiz);
+    aplicarAuth(cargado.auth);
+    // El tema es una preferencia del proyecto: un config global no puede cambiar cómo se
+    // presenta otro repositorio. Un valor manual desconocido conserva XOne por omisión.
+    seleccionarTema("xone");
+    const temaDeProyecto = cargado.config.proyecto?.tema;
+    if (temaDeProyecto !== undefined && esTema(temaDeProyecto))
+        seleccionarTema(temaDeProyecto);
+    // `let`: el asistente de cuenta y el alta de proyecto (más abajo, ambos solo con TTY)
+    // pueden escribir modelo global o de proyecto, y la cabecera no puede quedarse leyendo
+    // las fuentes de ANTES de esa escritura.
+    let fuentesHidratadas = {
+        ...fuentes,
+        proyecto: cargado.config.proyecto,
+        global: cargado.config.global,
+    };
+    if (usarTui) {
+        // La TUI es la MISMA consola: `entrarEnConsola` no la duplica, le entrega las
+        // piezas que son de esta capa (la inspección, el asistente de creación, el
+        // ejecutor real, el tope compartido) y el montaje vive en `tui/correrTui.ts`,
+        // que no puede importar de aquí porque sería un ciclo.
+        //
+        // Import DINÁMICO: `correrTui.ts` arrastra ink y react, y un import estático los
+        // cargaría también en `run`, `describe`, `config` y en cada pipe — que no los
+        // necesitan ni los van a pintar. Solo la rama TUI paga el módulo.
+        const { correrConsolaTui } = await import("./tui/correrTui.js");
+        return correrConsolaTui({
+            fuentes: fuentesHidratadas,
+            raiz,
+            guion,
+            ...dependencias,
+            ...adaptadoresDeProyecto(raiz),
+            inspeccionarProyecto,
+            ofrecer: ofrecerCrearProyecto,
+            crearEjecutor: guion ? undefined : crearEjecutorReal,
+            topeDe: crearTopeDelModelo(raiz),
+            raton,
+            // Una TUI ya implica interacción real. No se vuelve a consultar isTTY dentro de
+            // Ink: algunos emuladores integrados lo exponen falso tras capturar stdin.
+            asistenteInicial: true,
+        });
+    }
     // `let` porque el asistente de creación puede cambiarlo TODO: si el usuario acepta,
     // la carpeta pasa de «0 colls, sin app.xml» a proyecto de verdad, y la cabecera se
     // re-inspecciona para no mentir en la primera línea que se ve.
@@ -330,7 +869,7 @@ interactivo = process.stdin.isTTY === true) {
     // con /describe. `let` porque /modelo <p>/<m> la cambia EN CALIENTE dentro de la sesión.
     let modeloTrabajo;
     {
-        const { proveedor, modelo } = resolver(fuentes).trabajo;
+        const { proveedor, modelo } = resolver(fuentesHidratadas).trabajo;
         modeloTrabajo = `${proveedor}/${modelo}`;
     }
     /**
@@ -347,28 +886,11 @@ interactivo = process.stdin.isTTY === true) {
     // al arrancar y tras cada /nuevo o /modelo. La lista de comandos se GENERA recorriendo
     // el registro — una lista escrita a mano se queda vieja en cuanto alguien añade uno.
     /**
-     * El tope de la ventana del modelo ACTUAL: tabla de `core/contextos.ts` + lo que el
-     * usuario haya fijado en `config.json` (lo de proyecto gana a lo global, como los
-     * modelos). Se lee en cada barra y no en el arranque porque `modeloTrabajo` cambia
-     * en caliente con /modelo, y un tope del modelo equivocado es un porcentaje que miente.
-     * Si el id no parsea —no debería, viene de `resolver`—, no hay tope y no pasa nada.
+     * El tope de la ventana del modelo ACTUAL. La lógica vive en `crearTopeDelModelo`
+     * (módulo, y compartida con la TUI): la barra la llama en cada emisión porque
+     * /modelo cambia el modelo en caliente.
      */
-    const topeDelModelo = (id) => {
-        try {
-            const { proveedor, modelo } = parsear(id);
-            const { config } = cargar(raiz);
-            // Misma resolución que /config (`topeResuelto`): proyecto gana a global, y la
-            // tabla es el último recurso. El origen aquí no se mira, pero así no puede
-            // divergir entre lo que la barra calcula y lo que /config declara.
-            return topeResuelto(proveedor, modelo, {
-                proyecto: config.proyecto?.contextos,
-                global: config.global?.contextos,
-            })?.tope;
-        }
-        catch {
-            return undefined;
-        }
-    };
+    const topeDelModelo = crearTopeDelModelo(raiz);
     /**
      * La barra de estado, al estilo de la de opencode: lo que uno necesita tener delante sin
      * pedirlo. En stdio no se puede clavar al fondo de la pantalla —eso pide control de
@@ -408,15 +930,11 @@ interactivo = process.stdin.isTTY === true) {
         lineas: conPrompt(rl, escribir, barraDeEstado),
         escribir: (t) => {
             escribir(t);
-            // La línea de estado se reimprime tras /nuevo y /modelo (los DOS, no
-            // /modelo-rapido/-trabajo/-afilado: así lo pide la tarea). Ambos manejadores
-            // escriben su resultado en UNA sola llamada a escribir, así que basta con anclar
-            // al principio de esa cadena exacta:
-            //   "modelo (los tres papeles): <p>/<m>\n"   → /modelo
-            //   "hilo nuevo: <id>\n"                     → /nuevo
-            const comoModelo = /^modelo \(los tres papeles\): (.+)\n$/.exec(t);
-            if (comoModelo) {
-                modeloTrabajo = comoModelo[1];
+            // La TUI usa el mismo parser: un acuse de los tres papeles, o el del papel
+            // `trabajo` individual de `/modelos`, actualiza la cabecera sin duplicar regex.
+            const acuse = modeloDeAcuse(t);
+            if (acuse !== undefined && (acuse.papel === undefined || acuse.papel === "trabajo")) {
+                modeloTrabajo = acuse.modelo;
                 escribir(lineaDeEstado());
             }
             else if (/^hilo nuevo: /.test(t)) {
@@ -425,8 +943,39 @@ interactivo = process.stdin.isTTY === true) {
         },
         preguntar: crearPreguntar(rl),
         interactivo,
+        eof: crearDetectorDeEof(rl),
         leerSecreto: crearLeerSecreto(rl),
+        catalogoModelos: dependencias.catalogoModelos,
+        guardarModeloGlobal: dependencias.guardarModeloGlobal,
+        conectarCloudStudio: dependencias.conectarCloudStudio,
+        ...adaptadoresDeProyecto(raiz),
     };
+    // Los dobles de readline de tests (y una tubería) pueden declararse interactivos para
+    // probar otro diálogo, pero no son un terminal en el que abrir OAuth. El asistente de
+    // arranque es exclusivamente de una sesión TTY real.
+    if (process.stdin.isTTY === true) {
+        // 1. Cuenta: proveedor y modelo, SOLO si nadie eligió nunca (mira `origen`, no un
+        // flag de «primer arranque» aparte). Antes que el proyecto: es configuración de la
+        // persona, no de la carpeta.
+        await asistenteDeModelo(consola, {
+            origenDeTrabajo: resolver(fuentesHidratadas).trabajo.origen,
+            hayCredencial: (proveedor) => hayCredencial(proveedor, raiz),
+            guardarCredencial: (proveedor, clave) => guardarCredencial(proveedor, clave),
+            // La clave se PRUEBA antes de escribirse: esto la pone en el proceso (que es de
+            // donde la lee `CatalogoModelos`) sin tocar `auth.json`.
+            aplicarCredencial: aplicarCredencialAlProceso,
+        });
+        // 2-3-4. Modo, proyecto de CloudStudio + rama + descarga, y modelo propio opcional.
+        await configurarModoInicial(raiz, consola);
+        // El asistente y el alta pueden haber escrito modelo global o de proyecto (y, con
+        // cloud, ficheros nuevos): se relee TODO antes de fijar la cabecera, o mentiría sobre
+        // lo que se acaba de elegir.
+        const recargado = cargar(raiz);
+        fuentesHidratadas = { ...fuentesHidratadas, proyecto: recargado.config.proyecto, global: recargado.config.global };
+        entorno = await inspeccionarProyecto(raiz);
+        const elegidoTrasAlta = resolver(fuentesHidratadas).trabajo;
+        modeloTrabajo = `${elegidoTrasAlta.proveedor}/${elegidoTrasAlta.modelo}`;
+    }
     // El asistente de creación: la única escritura fuera de un turno del agente, y
     // por eso la única que pregunta ANTES de escribir. Si se crea, la carpeta ya ES
     // un proyecto XOne y `entorno` se re-inspecciona; si no, la consola sigue viva
@@ -440,7 +989,11 @@ interactivo = process.stdin.isTTY === true) {
     }
     escribir(cabecera());
     // Mismo patrón de prefijo que run.ts y el manejador /nuevo de consola.ts.
-    const estado = { hilo: `xonecode-${randomUUID()}`, raiz, fuentes };
+    const estado = {
+        hilo: `xonecode-${randomUUID()}`,
+        raiz,
+        fuentes: fuentesHidratadas,
+    };
     // `--guion` conserva el agente de pega (el valor por omisión de `correrConsola`): es lo
     // que permite ver la consola correr sin gastar. Sin ella, el ejecutor real corre cada
     // línea de prosa sobre una sesión que se abre en el PRIMER turno y sobrevive a los demás.
@@ -449,6 +1002,21 @@ interactivo = process.stdin.isTTY === true) {
         : crearEjecutorReal((sesion) => {
             tracker = sesion.tracker;
         });
+    // Una memoria .xonecode pertenece al PROYECTO y significa que hay trabajo que
+    // retomar. El saludo de primera visita no debe ocultar ese contexto. `--guion` no
+    // simula esta lectura: no hay modelo real que pueda analizarlo.
+    if (hayEstadoDeProyecto(raiz) && !guion) {
+        consola.escribir(MENSAJE_REANUDANDO);
+        try {
+            await ejecutar(PETICION_REANUDAR_PROYECTO, estado, consola);
+        }
+        catch (e) {
+            consola.escribir(`${describirError(e)}\n`);
+        }
+    }
+    else {
+        consola.escribir(MENSAJE_BIENVENIDA);
+    }
     const codigo = await correrConsola(consola, estado, ejecutar);
     // Siempre, tanto si se sale por /salir como por EOF: sin rl.close() el proceso queda
     // escuchando stdin y `xonecode` no vuelve nunca a la shell.
@@ -457,26 +1025,117 @@ interactivo = process.stdin.isTTY === true) {
 }
 export async function main(argv) {
     const [comando, ...resto] = argv;
-    // Las banderas de la consola (`--guion` y las de modelo) no son subcomandos:
-    // `xonecode --guion` entra en la consola igual que `xonecode` a secas, pero con el
-    // agente de pega. `--help`/`-h` NO entran aquí: son el subcomando de ayuda de abajo.
-    // El resto de banderas (`--real`, `--json`, …) pertenecen a otros subcomandos y siguen
-    // cayendo en «no conozco el comando».
-    // `--guion` se quita del argv ANTES de extraerBanderasDeModelo: no es una bandera de
-    // modelo y no debe llegar como `resto` a ninguna parte.
-    if (!comando || comando === "--guion" || comando.startsWith("--modelo")) {
-        const guion = argv.includes("--guion");
-        // extraerBanderasDeModelo también con argv vacío, para que fuentes.entorno
-        // .XONECODE_MODELO se rellene igual que en todos los demás subcomandos: la consola
-        // no puede ser la única vía que ignora esa variable.
-        const { fuentes } = extraerBanderasDeModelo(argv.filter((a) => a !== "--guion"));
-        return entrarEnConsola(fuentes, undefined, undefined, undefined, undefined, guion);
-    }
-    if (comando === "--help" || comando === "-h") {
-        process.stdout.write(AYUDA);
-        return 0;
-    }
     try {
+        // Las banderas de la consola (`--guion` y las de modelo) no son subcomandos:
+        // `xonecode --guion` entra en la consola igual que `xonecode` a secas, pero con el
+        // agente de pega. `--help`/`-h` NO entran aquí: son el subcomando de ayuda de abajo.
+        // El resto de banderas (`--real`, `--json`, …) pertenecen a otros subcomandos y siguen
+        // cayendo en «no conozco el comando».
+        // `--guion` se quita del argv ANTES de extraerBanderasDeModelo: no es una bandera de
+        // modelo y no debe llegar como `resto` a ninguna parte.
+        if (!comando ||
+            comando === "--guion" ||
+            comando === "--tui" ||
+            comando === "--no-tui" ||
+            comando === "--sin-raton" ||
+            // Las cuatro de la consola web. Sin ellas, `xonecode --web` cae en «no conozco el
+            // comando» y sale 64 antes de que `decidirPiel` llegue a decidir nada — medido.
+            comando === "--web" ||
+            comando === "--cli" ||
+            comando === "--no-abrir" ||
+            comando === "--puerto" ||
+            comando.startsWith("--modelo")) {
+            // La bifurcación va ANTES del alta de cuatro pasos de `entrarEnConsola`: si no,
+            // `xonecode` con TTY preguntaría el proveedor en el terminal y DESPUÉS abriría un
+            // navegador para volver a preguntarlo.
+            if (decidirPiel(argv) === "web") {
+                const { puerto, abrir, anfitrion } = parsearOpcionesWeb(argv);
+                // Import DINÁMICO, por el mismo motivo que el de la TUI: esta rama arrastra el
+                // vestíbulo entero (grafo del agente, MCP, sesiones) y `run`, `describe` y
+                // cualquier tubería no lo necesitan ni lo van a levantar.
+                const { arrancarConsolaWeb } = await import("../web/servidor/arranque.js");
+                return await arrancarConsolaWeb({
+                    puerto,
+                    ...(anfitrion === undefined ? {} : { anfitrion }),
+                    abrir,
+                    cwd: process.cwd(),
+                    guion: argv.includes("--guion"),
+                    // Las dos piezas de ESTA capa que el vestíbulo necesita, pasadas y no importadas
+                    // desde allí: `arranque.ts` importando `main.ts` sería un ciclo entre el
+                    // despachador y la piel que monta. Y no son opcionales de verdad — sin
+                    // `crearEjecutor` el vestíbulo cae en el turno GUIONIZADO, y sin
+                    // `dependenciasDeProyecto` no hay `/sync`, o sea que la descarga del alta no
+                    // bajaría nada. Las dos cosas serían mudas.
+                    // Con checkpointer PERSISTENTE, al revés que la consola de terminal: aquí cada
+                    // conversación tiene id en el índice, así que su hilo se puede reanudar — y esa
+                    // es la diferencia entre reabrir y releer.
+                    // Y la carpeta de ADJUNTOS cuando la apertura es de una tarea con alguno: el
+                    // vestíbulo la reenvía desde `abrirParaTarea`, que es quien la recibe del
+                    // corredor — el único que sabe de qué tarea se trata.
+                    crearEjecutor: (alAbrir, opcionesDeConsola) => crearEjecutorReal(alAbrir, crearCheckpointerDeProyecto, carpetaDeArtefactosDeSesion, opcionesDeConsola?.adjuntos),
+                    // El tope de la ventana para el contador de contexto de la web, con LA MISMA
+                    // función que la barra de stdio y la de la TUI. Dos resoluciones del tope serían
+                    // dos porcentajes distintos para el mismo modelo, y esa función ya respeta la
+                    // precedencia que `/config` declara (proyecto > global > tabla).
+                    topeDeContexto: (raiz, modelo) => crearTopeDelModelo(raiz)(modelo),
+                    // Con qué código corre este proceso. Se lee aquí y no allí porque toca disco y
+                    // lanza `git`, y los tests de `arranque.ts` llaman a esa función entera.
+                    version: versionEnMarcha,
+                    // La cola de tareas de la MÁQUINA, y con ella el corredor. Se pasa desde aquí y
+                    // no se construye allí por la misma razón que las dos de arriba, más una: la
+                    // omisión de `arrancarConsolaWeb` tiene que ser NO ejecutar tareas, porque sus
+                    // propios tests lo llaman entero y tomarían el cerrojo de quien los corre.
+                    tareas: (informar) => crearTareasEnDisco({ informar }),
+                    dependenciasDeProyecto: (raiz) => ({
+                        ...adaptadoresDeProyecto(raiz),
+                        catalogoModelos: new CatalogoModelos(undefined, undefined, proveedoresPersonalizados),
+                        guardarModeloGlobal,
+                        conectarCloudStudio: (url, scopes, informar) => conectarCloudStudio(url, {
+                            informar,
+                            scopes,
+                            entornoId: entornoDeUrl(url, cargarSettings().settings.entornos),
+                        }),
+                    }),
+                });
+            }
+            const guion = argv.includes("--guion");
+            const pedirTui = argv.includes("--tui");
+            // Por defecto, TUI siempre. `--no-tui` fuerza stdio; sin banderas, TUI.
+            const usarTui = !argv.includes("--no-tui");
+            // `--tui` fuerza la TUI, pero no puede fabricar un terminal: sin stdin interactivo
+            // no hay teclado que leer, y sin stdout TTY ink pintaría códigos de escape en la
+            // tubería. Error de USO (64), no un crash — la bandera fue imposible, no el entorno.
+            if (pedirTui && usarTui && (process.stdin.isTTY !== true || process.stdout.isTTY !== true)) {
+                process.stderr.write("la TUI necesita un terminal interactivo: usa --no-tui o corre sin tubería\n");
+                return 64;
+            }
+            // extraerBanderasDeModelo también con argv vacío, para que fuentes.entorno
+            // .XONECODE_MODELO se rellene igual que en todos los demás subcomandos: la consola
+            // no puede ser la única vía que ignora esa variable.
+            // `--puerto` se quita CON su valor: un `4300` suelto no es una bandera de modelo,
+            // pero tampoco tiene por qué llegar a `resto` como si fuera un argumento del usuario.
+            const sinBanderasDeConsola = argv.filter((a, i) => {
+                if (["--guion", "--sin-raton", "--web", "--cli", "--no-abrir", "--puerto"].includes(a))
+                    return false;
+                return argv[i - 1] !== "--puerto";
+            });
+            const { fuentes } = extraerBanderasDeModelo(sinBanderasDeConsola);
+            const catalogoModelos = new CatalogoModelos(undefined, undefined, proveedoresPersonalizados);
+            // Por defecto, TUI siempre. `--no-tui` fuerza stdio.
+            return await entrarEnConsola(fuentes, undefined, undefined, undefined, undefined, guion, undefined, !argv.includes("--no-tui"), quiereRaton(argv), {
+                catalogoModelos,
+                guardarModeloGlobal,
+                conectarCloudStudio: (url, scopes, informar) => 
+                // El entorno se resuelve por URL, no se omite: sin esto, un `/connect-studio` sobre
+                // un proyecto del vestíbulo abría OAuth en `legado` —un hueco que `/sync` no lee— y
+                // dejaba al proyecto reautenticando en cada sincronización.
+                conectarCloudStudio(url, { informar, scopes, entornoId: entornoDeUrl(url, cargarSettings().settings.entornos) }),
+            });
+        }
+        if (comando === "--help" || comando === "-h") {
+            process.stdout.write(AYUDA);
+            return 0;
+        }
         if (comando === "run") {
             const { fuentes, resto: sinModelo } = extraerBanderasDeModelo(resto);
             const peticion = sinModelo.filter((a) => !a.startsWith("--")).join(" ");
@@ -508,7 +1167,7 @@ export async function main(argv) {
     catch (e) {
         // Un modelo mal escrito es un error del USUARIO, no del harness: su mensaje, sin
         // traza, y código de uso (64). No se propaga como un fallo de software.
-        if (e instanceof ModeloMalEscrito) {
+        if (e instanceof ModeloMalEscrito || e instanceof ErrorDeUso) {
             process.stderr.write(`${e.message}\n`);
             return 64; // EX_USAGE
         }