xonecode 0.2.0 → 0.5.0

package/dist/web/servidor/vestibulo.js

@@ -0,0 +1,1276 @@
+/**
+ * El vestíbulo: lo que hay ANTES de que exista ninguna raíz.
+ *
+ * `correrConsola` es un lazo sobre UNA `raiz`, y la jerarquía entorno → proyecto → sesión
+ * necesita un sitio donde vivir mientras no hay proyecto abierto. De ahí las dos clases de
+ * consola: el vestíbulo (sin raíz) y la consola de proyecto (con la suya).
+ *
+ * Los pasos son los mismos del alta de terminal, y cada uno solo aparece si falta lo que
+ * decide. El de cuenta se detecta como siempre: si el papel `trabajo` resuelve por
+ * `omision`, nadie eligió nunca. **No hay marca de «primer arranque»**: sería una segunda
+ * fuente de verdad sobre algo que el sistema ya sabe.
+ *
+ * Este fichero NO toca disco ni red por su cuenta. Todo lo que escribe o conecta entra por
+ * la opción correspondiente, y las que escriben (`guardarCredencial`, `guardarEntorno`,
+ * `guardarConfigDeProyecto`, `descargar`) son OBLIGATORIAS: un valor por omisión que
+ * escribiera en el `~/.xonecode` de verdad convertiría cualquier test en una escritura en
+ * la casa del usuario, y uno que no escribiera sería el no-op silencioso que este repo
+ * evita en todas partes.
+ *
+ * La única LECTURA de disco con valor por omisión es `esProyecto` («¿hay copia local
+ * aquí?»), y sigue la misma regla que `sesiones ?? SESIONES_EN_DISCO`: entra por opción
+ * para que un test pueda contestarla sin carpetas, y su omisión es la de verdad porque
+ * mentir en esa pregunta abre un proyecto que no existe.
+ */
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { consumoDeLosActos, sumarConsumo } from "../../core/actos.js";
+import { consumoDeLaSesion, consumoPersistible, esDoble } from "../../core/ports.js";
+import { rutaDeWorkspace } from "../../core/settings.js";
+import { URL_CLOUDSTUDIO_POR_OMISION, SCOPES_CLOUDSTUDIO_AGENTE, AVISO_DE_URL_DE_MCP, adoptarLegadoSiProcede, conectarCloudStudio, rutaAuthPorDefecto, sesionCloudStudio, urlDeMcpAceptable, } from "../../agent/cloudstudioMcp.js";
+import { clienteCloudStudio } from "../../agent/cloudstudioClient.js";
+import { guardarCloudStudioDeProyecto, guardarEntornoDeProyecto, guardarModeloGlobal as guardarModeloGlobalEnDisco, guardarModoDeProyecto, guardarProyectoCloudStudioDeProyecto, guardarRamaDeProyecto, } from "../../agent/configEnDisco.js";
+import { correrConsola, ejecutarTurnoGuionizado, } from "../../cli/consola.js";
+import { asistenteDeModelo } from "../../cli/wizardInicial.js";
+import { crearConsolaWeb } from "./consolaWeb.js";
+import { anotarActo, borrarSesion, crearSesion, elegirDispositivo, listarSesiones, reabrirSesion, renombrarSesion, } from "./sesiones.js";
+/**
+ * Los dos CloudStudio oficiales, pre-rellenados.
+ *
+ * La URL de WebStudio no se repite aquí: se importa de `agent/cloudstudioMcp.ts`, que es
+ * donde vive desde que `adoptarLegadoSiProcede` la necesitó (`cli/consola.ts` la reexporta
+ * por compatibilidad). Dos literales de la misma dirección es cómo divergen el día que una
+ * se corrige y la otra no — el mismo motivo por el que `segmentoSeguro` no se copió.
+ */
+export const ENTORNOS_OFICIALES = [
+    { id: "webstudio", nombre: "XOne WebStudio", url: URL_CLOUDSTUDIO_POR_OMISION },
+    { id: "manager", nombre: "XOne Manager", url: "https://mcp.xonemanager.com/mcp" },
+];
+/**
+ * El tercero de la lista, y no un botón aparte de la interfaz: un on-premise es un entorno
+ * como los otros dos, y presentarlo al mismo nivel es lo que evita que la web tenga dos
+ * caminos distintos para registrar lo mismo.
+ */
+export const ENTORNO_OTRO = { id: "otro", nombre: "Otro (on-premise)", url: "" };
+/** La base del workspace por omisión: `~/.xonecode`. La disposición de dentro la fija
+ *  `rutaDeWorkspace` y no es configurable. */
+export function baseDeWorkspacePorOmision() {
+    return join(homedir(), ".xonecode");
+}
+const SESIONES_EN_DISCO = {
+    crear: crearSesion,
+    listar: listarSesiones,
+    anotar: anotarActo,
+    reabrir: reabrirSesion,
+    borrar: borrarSesion,
+    renombrar: renombrarSesion,
+    elegirDispositivo,
+};
+/**
+ * ¿Hay una copia local de proyecto en esa raíz? Es el MISMO criterio con el que el alta
+ * decide `proyectos[].local` (`arranque.ts#hayCopiaLocal`, que tira de aquí): existe su
+ * `.xonecode/config.json`. Dos copias del predicado es cómo divergen el día que una se
+ * afine — el mismo motivo por el que la regla de URL de MCP vive en un solo sitio.
+ *
+ * Se lo traga todo y devuelve `false`: una raíz que no se puede ni mirar (permisos, un
+ * enlace roto) no es un proyecto sobre el que abrir nada, y esta puerta falla CERRADO.
+ */
+export function esProyectoEnDisco(raiz) {
+    // Sin `try`: `existsSync` no lanza nunca —traga cualquier error del sistema y devuelve
+    // false—, así que envolverlo sugeriría un peligro que no existe.
+    return existsSync(join(raiz, ".xonecode", "config.json"));
+}
+/**
+ * Lo que se contesta a quien intenta abrir —o borrar— la conversación de una tarea que sigue
+ * corriendo. Vive en una constante porque lo leen las dos guardas y su test, y porque es lo
+ * ÚNICO que el usuario ve de esta regla.
+ *
+ * **Dice qué SÍ se puede hacer**, y no es cortesía: la vista en vivo existe justo al lado, así
+ * que un «no puedes» a secas es lo que hace que alguien insista o dé el botón por roto. Y no
+ * lleva ninguna ruta de la máquina: sale por el cable, que puede ir por un túnel.
+ */
+export function motivoDeProyectoTrabajando() {
+    return ("ese proyecto tiene una sesión con un turno en marcha: dos conversaciones sobre la misma " +
+        "copia de trabajo se pisarían los ficheros. Vuelve a ella para verla, o párala, y abre la " +
+        "otra cuando termine.");
+}
+export const MOTIVO_SESION_DE_TAREA_EN_CURSO = "esa conversación es la de una tarea en curso: el agente está escribiendo en ella ahora " +
+    "mismo. Pulsa «Ver lo que hace» en su tarjeta para mirarla, y ábrela cuando termine.";
+/**
+ * El `config.json` del proyecto, escrito con los escritores que ya existen.
+ *
+ * El orden importa y `modo` va el ÚLTIMO a propósito: si algo revienta a mitad, lo que
+ * queda en disco es un `cloudstudio` sin `modo`, que es exactamente el caso que
+ * `crearSincronizador` ya sabe contar («este proyecto no es cloud…»). Al revés dejaría un
+ * proyecto declarado cloud sin saber contra qué sincronizar.
+ *
+ * `entorno` se escribe ADEMÁS de `cloudstudio.url`, nunca en su lugar: conservar la URL es
+ * lo que hace literalmente cierto que la sincronización no se toca — `crearSincronizador`
+ * y todo lo que cuelga de él la leen igual que hoy.
+ */
+export function escribirProyectoEnDisco(raiz, datos) {
+    guardarCloudStudioDeProyecto(raiz, datos.url, datos.scopes);
+    guardarProyectoCloudStudioDeProyecto(raiz, datos.proyecto);
+    guardarRamaDeProyecto(raiz, datos.rama);
+    guardarEntornoDeProyecto(raiz, datos.entorno);
+    return { ruta: guardarModoDeProyecto(raiz, "cloud").ruta };
+}
+/**
+ * Los dos cables de CloudStudio del vestíbulo, con el id del entorno y la vuelta a la web
+ * ya enhebrados.
+ *
+ * Las dos cosas son deudas que se pagan aquí: sin `entornoId`, un proyecto ya migrado a
+ * `webstudio` reautenticaría en un segundo hueco `legado`; y sin `redirigirA`, la página
+ * del callback termina diciendo «vuelve a la terminal», que en un navegador es falso.
+ */
+export function conexionDeVestibulo(urlDeLaWeb) {
+    const comunes = (entorno) => ({
+        scopes: entorno.scopes ?? SCOPES_CLOUDSTUDIO_AGENTE,
+        entornoId: entorno.id,
+        ...(urlDeLaWeb === undefined ? {} : { redirigirA: urlDeLaWeb }),
+    });
+    return {
+        proyectosDeEntorno: async (entorno) => {
+            const conexion = await conectarCloudStudio(entorno.url, comunes(entorno));
+            return {
+                proyectos: conexion.proyectos,
+                ...(conexion.servidor === undefined ? {} : { servidor: { nombre: conexion.servidor.nombre } }),
+            };
+        },
+        ramasDeProyecto: async (entorno, proyecto) => {
+            const sesion = await sesionCloudStudio(entorno.url, comunes(entorno));
+            try {
+                const puerto = clienteCloudStudio(sesion.invocar, proyecto);
+                await puerto.abrir(proyecto);
+                return await puerto.ramas();
+            }
+            finally {
+                await sesion.cerrar();
+            }
+        },
+    };
+}
+/**
+ * La regla de URL de entorno es la MISMA que la de quien conecta de verdad
+ * (`agent/cloudstudioMcp.ts#urlDeMcpAceptable`), importada y no copiada: cuando eran dos
+ * criterios, el wizard aceptaba un loopback que este fichero rechazaba, con dos mensajes
+ * claros que se contradecían. Ver allí por qué se resolvió por el lado permisivo.
+ */
+const urlDeEntornoValida = urlDeMcpAceptable;
+/**
+ * El host de una URL, o la URL entera si no parsea. No debería hacer falta ese segundo caso
+ * —`urlDeEntornoValida` corre antes y ya rechaza lo que no parsea—, pero si algún día
+ * alguien invierte ese orden, mejor un id feo que una excepción.
+ */
+function hostDeUrl(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return url;
+    }
+}
+/** Misma URL, dicha de dos formas (`https://x/mcp` y `https://x/mcp/`), es el mismo sitio. */
+function mismaUrl(a, b) {
+    const normal = (u) => u.trim().replace(/\/+$/, "").toLowerCase();
+    return normal(a) === normal(b);
+}
+/**
+ * La identidad del entorno, DEDUCIDA de la URL cuando no la trae puesta.
+ *
+ * El formulario del navegador pide solo la URL: un nombre tecleado a mano es un dato que
+ * el usuario se inventa y que después hay que creerse en la barra lateral y en la ruta del
+ * workspace. Las dos reglas:
+ *
+ * - Si la URL es la de un entorno OFICIAL, se usa su identidad (aunque se haya escrito a
+ *   mano en el hueco de «otro»): dos entradas para el mismo servidor son dos carpetas de
+ *   workspace y dos huecos de OAuth para la misma cuenta.
+ * - Si no, el id y el nombre salen del HOST. El id pasa por `segmentoSeguro`
+ *   (`core/settings.ts`) porque acaba siendo una carpeta (`rutaDeWorkspace`), así que se
+ *   quita todo lo que no sea letra, cifra, punto o guion — los dos puntos del puerto
+ *   incluidos, que en Windows parten la ruta. El nombre conserva el host tal cual, que es
+ *   para leerlo.
+ *
+ * Lo que NO se deduce aquí es nada que venga del servidor: eso exige haber hecho OAuth, y
+ * el registro pasa antes. Un nombre inventado a partir de la URL es verdad comprobable;
+ * uno «bonito» sacado de la nada no lo sería.
+ */
+export function identidadDeEntorno(entorno) {
+    const oficial = ENTORNOS_OFICIALES.find((o) => mismaUrl(o.url, entorno.url));
+    if (oficial !== undefined)
+        return { ...entorno, id: oficial.id, nombre: oficial.nombre };
+    // Un id y un nombre puestos por quien llama se respetan: el paso de entorno del wizard
+    // manda «otro» (o vacío) justo para pedir esta deducción, pero otra piel puede traerlos.
+    if (entorno.id !== "" && entorno.id !== ENTORNO_OTRO.id && entorno.nombre !== "")
+        return entorno;
+    const host = hostDeUrl(entorno.url);
+    const id = host.replace(/[^a-zA-Z0-9.-]+/g, "-").replace(/^-+|-+$/g, "");
+    return {
+        ...entorno,
+        id: id === "" ? "on-premise" : id,
+        nombre: entorno.nombre === "" ? host : entorno.nombre,
+    };
+}
+export function crearVestibulo(opciones) {
+    const sesiones = opciones.sesiones ?? SESIONES_EN_DISCO;
+    const crearConsola = opciones.crearConsola ?? crearConsolaWeb;
+    const correr = opciones.correr ?? correrConsola;
+    const base = opciones.baseDeWorkspace ?? baseDeWorkspacePorOmision();
+    const adoptarLegado = opciones.adoptarLegado ??
+        // `rutaAuthPorDefecto` y no un `join` propio: el mismo literal en dos ficheros es lo
+        // que esta cabecera condena, y `cloudstudioMcp.ts` la exporta justo para esto.
+        ((entorno) => adoptarLegadoSiProcede(rutaAuthPorDefecto(), entorno));
+    const guardarModeloGlobal = opciones.guardarModeloGlobal ?? guardarModeloGlobalEnDisco;
+    const esProyecto = opciones.esProyecto ?? esProyectoEnDisco;
+    const consolaDelVestibulo = crearConsola({
+        catalogoModelos: opciones.catalogoModelos,
+        guardarModeloGlobal,
+        ...(opciones.msDeEspera === undefined ? {} : { msDeEspera: opciones.msDeEspera }),
+    });
+    const informar = opciones.informar ?? ((texto) => consolaDelVestibulo.consola.escribir(`${texto}\n`));
+    /** Los registrados al arrancar MÁS los que este vestíbulo acaba de dar de alta: el paso 3
+     *  llega justo después del 2 y `settings.json` no se vuelve a leer entre medias. */
+    const registrados = [...(opciones.entornos ?? [])];
+    /** Lo ya escrito, para que `cancelar()` pueda decirlo en vez de fingir que no pasó nada. */
+    let credencialEscrita;
+    let proyectoEscrito;
+    /**
+     * Las consolas de PERSONA vivas, por raíz. Antes era una sola variable, y cambiar de
+     * sesión mataba el turno que estuviera corriendo.
+     *
+     * **La clave es la raíz, y eso es la mitad del diseño**: nunca hay dos consolas sobre la
+     * misma copia de trabajo, así que dos conversaciones no pueden escribir el mismo fichero
+     * ni pisarse el hilo del checkpointer. Lo que se gana es lo otro: dos proyectos distintos
+     * pueden estar trabajando a la vez, y mirar uno no interrumpe al otro.
+     *
+     * No crece sin freno: una consola de segundo plano se cierra ella sola en cuanto su turno
+     * acaba (`cerrarSiSobra`). El hilo no se pierde —el checkpointer lo reanuda al reabrir la
+     * sesión—, así que cerrarla no cuesta nada y dejarla viva costaría un `correrConsola` por
+     * proyecto visitado.
+     */
+    const abiertas = new Map();
+    /** La raíz de la consola que el cable está pintando. `undefined` = el vestíbulo. */
+    let enFoco;
+    const consolaEnFoco = () => enFoco === undefined ? undefined : abiertas.get(enFoco);
+    /** Quien quiera enterarse de que el modelo en vigor cambió. UNA sola: el cable es uno. */
+    let escuchaDeEstado;
+    /** Y de que hay (o deja de haber) un turno corriendo. */
+    let escuchaDeTurno;
+    /** Y de que la sesión en foco ha consumido más tokens. */
+    let escuchaDeConsumo;
+    /**
+     * Avisa de que algo cambió en las consolas de persona: un turno empieza o acaba —en
+     * CUALQUIERA de ellas— o una de segundo plano se cierra.
+     *
+     * El booleano sigue siendo el de siempre: «¿hay turno en vuelo en la que se está
+     * mirando?». Lo que se ensanchó es el DISPARADOR, y hacía falta: sin eso, un turno de
+     * segundo plano que arranca o termina no repintaría la barra, que es donde se ve qué
+     * sesión está trabajando.
+     *
+     * `deLaDeAhora` existe por una trampa de orden: el primer flanco de un turno puede
+     * ocurrir ANTES de que la consola esté en el mapa —`construirConsolaDeProyecto` arranca
+     * su lazo dentro, y un `correr` que ejecute un turno en el acto (los tests, y cualquier
+     * ejecutor que no espere una línea) lo dispara desde ahí—. Preguntándole al mapa se
+     * habría contestado «no hay turno» justo en el flanco que lo anuncia. Quien llama sí sabe
+     * de qué consola habla, así que lo dice.
+     */
+    const avisarDeLasAbiertas = (deLaDeAhora) => {
+        const enfocada = deLaDeAhora !== undefined && deLaDeAhora.raiz === enFoco
+            ? deLaDeAhora.turnoEnVuelo
+            : consolaEnFoco()?.turnoEnVuelo === true;
+        escuchaDeTurno?.(enfocada);
+    };
+    const entornoPorId = (id) => {
+        const encontrado = registrados.find((e) => e.id === id);
+        if (encontrado === undefined) {
+            throw new Error(`el entorno «${id}» no está registrado en settings.json`);
+        }
+        return encontrado;
+    };
+    /** Escribe la credencial y la RECUERDA, sin decir nada: quien llama decide si lo dice,
+     *  porque `asistenteDeModelo` ya lo dice por su cuenta y decirlo dos veces es ruido. */
+    const registrarCredencial = (proveedor, clave) => {
+        const guardada = opciones.guardarCredencial(proveedor, clave);
+        credencialEscrita = { proveedor, ruta: guardada.ruta };
+        return guardada;
+    };
+    /**
+     * El nombre BUENO del entorno, el que dice el propio servidor, cuando por fin se ha
+     * hablado con él.
+     *
+     * Del alta solo sale la URL, así que hasta aquí el nombre era el host — verdad
+     * comprobable, pero fea («mcp.casa.local»). El `serverInfo` del initialize llega en la
+     * primera conexión de verdad, que es `proyectosDe`, y solo entonces se puede sustituir.
+     *
+     * Dos guardas, y las dos importan:
+     * - Solo se pisa un nombre DEDUCIDO (el que sigue siendo igual al host). Un nombre que
+     *   puso una persona —o el de un entorno oficial, «XOne WebStudio»— no lo cambia un
+     *   servidor remoto por su cuenta.
+     * - El id NO se toca nunca. Es un segmento de ruta (`rutaDeWorkspace`) y ya hay una copia
+     *   local colgando de él: cambiarlo aquí sería mudar la carpeta del proyecto de sitio
+     *   porque el servidor decidió llamarse de otra forma.
+     */
+    const renombrarConElServidor = (entorno, nombreDelServidor) => {
+        if (nombreDelServidor === undefined || nombreDelServidor === "")
+            return;
+        if (entorno.nombre !== hostDeUrl(entorno.url))
+            return;
+        if (nombreDelServidor === entorno.nombre)
+            return;
+        const renombrado = { ...entorno, nombre: nombreDelServidor };
+        opciones.guardarEntorno(renombrado);
+        const donde = registrados.findIndex((e) => e.id === entorno.id);
+        if (donde >= 0)
+            registrados.splice(donde, 1, renombrado);
+        informar(`entorno «${entorno.id}»: el servidor dice llamarse «${nombreDelServidor}»`);
+    };
+    /**
+     * Cierra la consola de ESA raíz, si hay alguna.
+     *
+     * Se ESPERA a que el lazo retorne. Dos `correrConsola` vivos sobre la misma copia de
+     * trabajo comparten el ejecutor real y se pisarían el hilo — que es exactamente lo que la
+     * clave por raíz del mapa impide, y esto es la otra mitad: se saca del mapa DESPUÉS de
+     * que su lazo haya terminado, así que entre medias nadie la puede reclamar como libre.
+     */
+    const cerrarConsolaDeProyecto = async (raiz) => {
+        const consola = abiertas.get(raiz);
+        if (consola === undefined)
+            return;
+        await consola.cerrar();
+        abiertas.delete(raiz);
+        if (enFoco === raiz)
+            enFoco = undefined;
+    };
+    /** Todas: lo que hacen `cancelar()` y `cerrar()`. Un fallo al cerrar una no puede dejar a
+     *  las demás vivas — es la misma regla que `cerrarLasDeTareas`. */
+    const cerrarLasDeProyecto = async () => {
+        for (const raiz of [...abiertas.keys()]) {
+            await cerrarConsolaDeProyecto(raiz).catch(() => abiertas.delete(raiz));
+        }
+        enFoco = undefined;
+    };
+    /**
+     * Cierra las consolas de segundo plano que NO están trabajando, menos la de esa raíz.
+     *
+     * Es la otra mitad del acotado, y va ANTES de construir la nueva: lo que se queda vivo en
+     * segundo plano es solo lo que tiene un turno en marcha. Sin esto, visitar diez proyectos
+     * dejaría diez `correrConsola` corriendo para siempre — y de paso se conserva el orden
+     * que ya estaba probado: el lazo anterior TERMINA antes de que arranque el siguiente, que
+     * es lo normal porque lo normal es cambiar de sesión sin nada en vuelo.
+     */
+    const cerrarLasOciosasSalvo = async (raizQueSigue) => {
+        for (const [raiz, consola] of [...abiertas]) {
+            if (raiz === raizQueSigue)
+                continue;
+            if (consola.turnoEnVuelo && !consola.cerrada)
+                continue;
+            await cerrarConsolaDeProyecto(raiz).catch(() => abiertas.delete(raiz));
+        }
+    };
+    /**
+     * Una consola de segundo plano que acaba de terminar su turno ya no hace falta: se cierra.
+     *
+     * Es lo que hace que «varias consolas vivas» sea acotado en vez de una fuga: sin esto,
+     * cada proyecto que alguien visitara dejaría un `correrConsola` corriendo para siempre.
+     * Y no se pierde nada al cerrarla — el hilo del agente lo reanuda el checkpointer cuando
+     * esa sesión se vuelva a abrir; lo único que se paga es el arranque.
+     *
+     * Va POR LA COLA y no en el acto: quien llama es el `finally` del propio turno, y
+     * `cerrar()` aguarda `terminada`, o sea el lazo que todavía está dentro de ese turno.
+     * Encolarlo lo deja para cuando la pasada haya devuelto. Las tres condiciones se vuelven a
+     * mirar ahí dentro, porque entre medias el foco puede haber vuelto a este proyecto o
+     * puede haber empezado otro turno.
+     */
+    const cerrarSiSobra = (raiz) => {
+        void enCola(async () => {
+            if (enFoco === raiz)
+                return;
+            const consola = abiertas.get(raiz);
+            if (consola === undefined || consola.turnoEnVuelo)
+                return;
+            if (!consola.cerrada)
+                await cerrarConsolaDeProyecto(raiz);
+            else
+                abiertas.delete(raiz);
+            // Se vuelve a avisar: esta raíz acaba de quedar LIBRE, y de eso cuelgan la barra y la
+            // cola de tareas («gana la persona» deja de aplicar aquí). Avisar solo en el flanco
+            // del turno habría contado la raíz como ocupada, porque este cierre viene después.
+            avisarDeLasAbiertas();
+        }).catch(() => undefined);
+    };
+    /**
+     * La cola de las operaciones que tocan `abiertas`.
+     *
+     * «Una consola por raíz» no se sostiene sin serializar: dos `POST` que lleguen a la vez se
+     * entrelazan en el `await` del cierre, los dos ven la raíz libre, los dos arrancan un
+     * `correrConsola` y el primero se queda vivo y sin nadie que lo pueda cerrar nunca. La
+     * cola se traga los rechazos —si no, un fallo
+     * dejaría la cadena rota para todo lo que venga detrás— y el rechazo de verdad se
+     * devuelve sin tragar a quien llamó.
+     */
+    let cola = Promise.resolve();
+    const enCola = (operacion) => {
+        const resultado = cola.then(operacion);
+        cola = resultado.catch(() => undefined);
+        return resultado;
+    };
+    /**
+     * Construye una consola de proyecto — y NADA de la contabilidad del cable.
+     *
+     * Se extrajo de `abrirDeVerdad` cuando apareció la segunda puerta (`abrirParaTarea`), y
+     * la línea del corte es exactamente esa: aquí dentro está TODO lo que decide con qué
+     * barreras corre el agente —el ejecutor real por `crearEjecutor`, de donde cuelga el
+     * backend con las vistas aplanadas retiradas y la guarda de artefactos; las dependencias
+     * de la raíz; la foto del antes; el volcado— y fuera se queda solo quién está enganchado
+     * al cable (`abierto`, y el cierre de lo anterior).
+     *
+     * Que sea UNA función no es comodidad: si las dos puertas divergieran, una tarea correría
+     * con menos barreras que una persona, y eso no se ve — se descubre cuando el agente ya
+     * escribió. Lo único que `alCable` apaga son los dos AVISOS al navegador; ni una regla.
+     */
+    const construirConsolaDeProyecto = async ({ raiz, sesion, adjuntos, tarea, enElCable, alFlancoDeTurno, }) => {
+        const reabierta = sesion === undefined ? undefined : sesiones.reabrir(raiz, sesion);
+        /**
+         * Lo que costó esta conversación ANTES de este proceso, leído de los `fin` que el
+         * `.jsonl` ya tenía.
+         *
+         * **Se lee UNA vez, aquí, y no se vuelve a mirar.** El fichero CRECE por debajo mientras
+         * este proceso vive —`volcar()` anota cada turno—, así que releerlo a mitad de sesión
+         * contaría dos veces los turnos que ya están en el tracker vivo. Esa es la regla que se
+         * puede romper en silencio dentro de un año, y por eso la base solo se fija en este
+         * punto: a partir de aquí, lo que crezca lo aporta la sesión viva.
+         *
+         * `undefined` cuando ningún `fin` lo trae, que es una sesión escrita antes de que esto
+         * existiera. No se rellena con ceros: un cero que nadie ha medido es la cifra inventada
+         * de siempre, y aquí se distinguen «anterior» y «gastó cero».
+         */
+        const consumoHistorico = reabierta === undefined ? undefined : consumoDeLosActos(reabierta.actos);
+        /**
+         * La sesión real, que nace DENTRO del primer turno —`crearEjecutorReal` avisa después de
+         * `inspeccionar` y de `abrirSesionReal`—. Se declara aquí arriba, antes de construir la
+         * consola, porque quien pregunta por el consumo se construye ANTES que ella.
+         */
+        let sesionReal;
+        /**
+         * Lo consumido por la sesión VIVA, sin la base histórica.
+         *
+         * **Es la fuente de la piel, y no la de la pantalla.** Son dos lecturas distintas a
+         * propósito: la piel resta este valor contra el que estampó en el `fin` anterior para
+         * sacar el gasto del turno, y si aquí entrara la base histórica el PRIMER `fin` de una
+         * sesión reabierta estamparía la base entera como si se hubiera gastado otra vez — y
+         * reabrir tres veces triplicaría el total. Lo que se pinta es la suma, y esa se compone
+         * abajo.
+         */
+        const consumoVivo = () => {
+            const vivo = sesionReal?.consumo?.();
+            return vivo === undefined ? undefined : consumoPersistible(vivo);
+        };
+        const consolaWeb = crearConsola({
+            catalogoModelos: opciones.catalogoModelos,
+            guardarModeloGlobal,
+            ...(opciones.msDeEspera === undefined ? {} : { msDeEspera: opciones.msDeEspera }),
+            consumoAcumulado: consumoVivo,
+        });
+        // `Partial<Consola>` sobre el objeto recién creado: lo que depende de la raíz (`/sync`,
+        // los escritores del proyecto) no lo puede saber `consolaWeb`, que no conoce ninguna.
+        Object.assign(consolaWeb.consola, opciones.dependenciasDeProyecto?.(raiz) ?? {});
+        // La foto del ANTES se toma AQUÍ, al abrir, no en el primer volcado: para entonces el
+        // agente ya habría escrito y el «antes» incluiría su trabajo. Se nombra más abajo,
+        // cuando el id existe. Se lanza sin esperar —abrir no puede quedarse esperando a git— y
+        // el rechazo se traga: sin marca, la vista lo dice.
+        const foto = opciones.marcarSesion?.(raiz).catch(() => undefined);
+        // La misma regla que la foto de arriba, en el mismo instante y por el mismo motivo:
+        // medido después, el «ya había trabajo de alguien» incluiría el de esta sesión. Se
+        // lanza sin esperar y el rechazo se traga: es un dato accesorio y abrir un proyecto no
+        // puede depender de que git conteste.
+        const trabajoAlAbrir = Promise.resolve(opciones.sinCommitear?.(raiz)).catch(() => undefined);
+        /**
+         * La ref ya APUNTADA, para poder esperarla al cerrar.
+         *
+         * `volcar()` la lanza y no la aguarda —es síncrono y corre en el `finally` de cada
+         * turno—, y eso está bien para quien mira: la pestaña Revisión pregunta cuando alguien
+         * la abre, mucho después. Lo que no vale es para quien MIDE: el corredor de tareas
+         * comprueba que lo escrito se pueda revisar justo después de cerrar la consola, y
+         * medido con git de verdad la ref todavía no estaba —`cambiosDeSesion` devolvía
+         * `sin-marca`— así que TODA tarea se habría aparcado diciendo que nadie puede revisarla
+         * en un proyecto donde sí se puede. Guardarla aquí y esperarla en `cerrar()` es lo que
+         * lo cierra sin que abrir un proyecto tenga que aguardar a git.
+         */
+        let marcado;
+        /**
+         * El id de la sesión, decidido al ABRIR y no en el primer volcado.
+         *
+         * Es el `thread_id` del grafo, y sin esa igualdad no hay nada que reanudar: al reabrir
+         * hay que preguntarle al checkpointer por la misma cadena con la que se escribió. Antes
+         * nacía en `volcar()` y el hilo era otro uuid, así que reabrir una sesión abría un hilo
+         * que no existía en ninguna parte.
+         *
+         * Lo que sigue siendo PEREZOSO es la entrada del índice (`anotada`): un uuid en memoria
+         * no ensucia nada, pero una entrada escrita al abrir dejaría una sesión vacía en la
+         * barra cada vez que alguien mira un proyecto y se va sin decir nada. Y un hilo sin
+         * turnos tampoco deja checkpoint: LangGraph solo escribe cuando el grafo corre.
+         */
+        const idSesion = sesion ?? randomUUID();
+        /** ¿Tiene ya entrada en el índice? Reabrir implica que sí. */
+        let anotada = sesion !== undefined;
+        /**
+         * Reabrir ya no implica releer: si el checkpointer guarda ese hilo, la conversación
+         * CONTINÚA de verdad y el aviso no sale. Solo se pregunta al reabrir —una sesión nueva
+         * no puede tener memoria— y una respuesta negativa deja el aviso puesto, que es el lado
+         * conservador: enseñarlo de más es preferible a prometer una memoria que no está.
+         */
+        let historica = reabierta?.historica ?? false;
+        if (historica && (await opciones.hayMemoriaDeHilo?.(raiz, sesion)) === true)
+            historica = false;
+        let dispositivo = reabierta?.dispositivo;
+        let cerrada = false;
+        /** Ver `ConsolaDeProyecto.turnoEnVuelo`: lo pone y lo quita el envoltorio de abajo, que
+         *  es el único sitio que ve los dos flancos. */
+        let turnoEnVuelo = false;
+        let volcados = 0;
+        /**
+         * Marcado desde que empieza el cierre. Hace falta porque `crearEjecutorReal` avisa de
+         * la sesión DESPUÉS de `inspeccionar` y `abrirSesionReal` —segundos en el primer
+         * turno—, así que un cierre en esa ventana encontraba `sesionReal` sin definir, no
+         * abortaba nada, y el turno seguía corriendo entero sobre un proyecto que el usuario
+         * ya había dejado. La sesión que llega tarde se cierra en cuanto se anuncia.
+         */
+        let cerrando = false;
+        const base = opciones.crearEjecutor?.((s) => {
+            sesionReal = s;
+            if (cerrando)
+                s.cerrar();
+            /**
+             * La cuenta de tokens se escucha AQUÍ y no al construir la consola porque la sesión
+             * se anuncia tarde: `crearEjecutorReal` avisa después de `inspeccionar` y
+             * `abrirSesionReal`, o sea segundos dentro del primer turno. Suscribirse antes sería
+             * suscribirse a algo que no existe.
+             *
+             * Solo se avisa si esta consola es la que el cable está pintando: los tokens de un
+             * turno de segundo plano no pueden cambiar el contador que alguien está mirando en
+             * otra sesión — la misma regla que hace que sus actos no se cuelen en ese chat.
+             */
+            s.alCambiarConsumo?.(() => {
+                if (enFoco === raiz)
+                    escuchaDeConsumo?.();
+            });
+        }, 
+        // Solo si la hay: `undefined` es lo que reciben las aperturas de persona, y de ahí
+        // sale que su agente no tenga `/adjuntos/` montada.
+        adjuntos === undefined ? undefined : { adjuntos });
+        // El ejecutor que de verdad va a correr los turnos de ESTA consola de proyecto — se
+        // fija UNA vez, aquí, para que `volcar` y `ejecutarTurno` miren siempre el mismo valor.
+        const ejecutorEfectivo = base ?? ejecutarTurnoGuionizado;
+        /**
+         * Vuelca al `.jsonl` los actos nuevos.
+         *
+         * Se llama en las FRONTERAS de turno y al cerrar, nunca a mitad: durante un turno el
+         * último acto de la piel todavía muta (el cierre de una racha de tools SUSTITUYE a su
+         * apertura dentro del mismo acto, `core/actos.ts#conLineaDeTool`), y un `.jsonl` que
+         * solo sabe anexar guardaría las dos líneas. El coste, medido y asumido: un cierre
+         * abrupto a mitad de turno pierde ese turno, no la sesión.
+         *
+         * La sesión se crea PEREZOSAMENTE, en el primer volcado: un proyecto que se abre y se
+         * cierra sin decir nada no deja una sesión vacía en el índice.
+         *
+         * Un ejecutor de PEGA (`--guion`, sin `crearEjecutor`) no vuelca NADA: el `.jsonl` de
+         * una sesión es historia del proyecto, y un transcript de pega indistinguible de uno
+         * real la ensuciaría — mañana alguien la reabre, lee la respuesta guionizada y no
+         * puede saber si fue el agente de pega o un fallo del de verdad. La decisión la toma
+         * la marca `ES_DOBLE` sobre `ejecutarTurnoGuionizado` (`cli/consola.ts`), nunca un
+         * booleano de este cierre ni la bandera `--guion` del argv: la misma razón por la que
+         * el resto del repo marca los dobles con un Symbol y no con un campo que alguien puede
+         * olvidar o poner mal. La guarda vive AQUÍ, en el único sitio que escribe a disco, y no
+         * repartida en cada llamador — `ejecutarTurno` de abajo y el `cerrar()` de más abajo
+         * comparten la misma `volcar`, así que ninguno de los dos puede colarse sin ella.
+         */
+        const volcar = () => {
+            if (esDoble(ejecutorEfectivo))
+                return;
+            const todos = consolaWeb.actos();
+            if (todos.length <= volcados)
+                return;
+            if (!anotada) {
+                sesiones.crear(raiz, idSesion, tarea);
+                anotada = true;
+                // Ahora sí hay una sesión en el índice a la que apuntar la foto de la apertura.
+                // Se guarda la promesa en vez de tirarla: `cerrar()` la espera. Ver `marcado`.
+                marcado = foto?.then((apuntar) => apuntar?.(idSesion));
+            }
+            for (const acto of todos.slice(volcados))
+                sesiones.anotar(raiz, idSesion, acto);
+            volcados = todos.length;
+            // El dispositivo elegido ANTES de que la sesión estuviera en el índice se anota
+            // ahora, que es la primera vez que hay una entrada a la que apuntarlo. Sin esto,
+            // elegir dispositivo y hablar después perdía la elección al reabrir.
+            if (dispositivo !== undefined)
+                sesiones.elegirDispositivo?.(raiz, idSesion, dispositivo);
+        };
+        /**
+         * El mensaje del commit del turno.
+         *
+         * Lleva el TÍTULO de la sesión, que es el asidero con el que una persona la reconoce en
+         * la barra, y el id de la tarea cuando la escribió una: es lo que permite leer el
+         * historial y saber qué salió de algo que corría solo.
+         *
+         * Lo que NO dice es «lo escribió el agente». El commit barre todo lo que haya cambiado,
+         * incluido lo que tocara una persona a mano en esa carpeta durante el turno — la misma
+         * honestidad que separa `Tarea.autorizadas` de «aplicados».
+         */
+        const mensajeDeCommit = () => {
+            const titulo = sesiones.listar(raiz).find((e) => e.id === idSesion)?.titulo;
+            return `xonecode: ${titulo === undefined || titulo === "" ? "sesión sin título" : titulo}${tarea === undefined ? "" : ` [tarea ${tarea}]`}`;
+        };
+        const ejecutarTurno = async (peticion, estado, consola) => {
+            /**
+             * La raíz del estado tiene que ser la de ESTA consola, y aquí se comprueba.
+             *
+             * Desde que `ejecutarTurno` se expone (`ConsolaDeProyecto.ejecutarTurno`, para las
+             * tareas), el estado lo puede construir quien llama — y de `estado.raiz` sale el
+             * backend del agente (`crearEjecutorReal` → `abrirSesionReal` → `backendDeAgente`).
+             * Una raíz equivocada no da error: hace que el agente lea y ESCRIBA en otro proyecto,
+             * con la aprobación de ese otro y sin un solo síntoma. Falla cerrado, como todo lo
+             * que decide sobre escrituras.
+             *
+             * Por la puerta de las personas esto no puede saltar nunca: el estado lo lleva
+             * `correrConsola` y ningún comando cambia `raiz` (medido en `cli/consola.ts`: solo
+             * `fuentes`, `seleccionesDeCatalogo` y `hilo`). Por eso la guarda va en el envoltorio
+             * COMPARTIDO y no solo en la puerta nueva — una guarda que solo vigila una puerta es
+             * la divergencia que esto viene a evitar.
+             */
+            if (estado.raiz !== raiz) {
+                throw new Error("ese turno trae la raíz de otro proyecto: esta consola solo corre turnos sobre la suya");
+            }
+            // El primer turno NUEVO es lo que deja de ser histórica una sesión reabierta.
+            // `sesiones.ts` no puede hacerlo —`reabrirSesion` es una lectura pura sin estado
+            // entre llamadas—, así que lo hace quien es dueño de la sesión viva, que es esto.
+            historica = false;
+            // Este envoltorio es el ÚNICO sitio que sabe cuándo empieza y cuándo acaba un turno:
+            // `correrConsola` solo lo espera y la piel solo ve eventos. De aquí sale lo que apaga
+            // el compositor, saca el botón de parar y enciende el borde vivo.
+            turnoEnVuelo = true;
+            consolaWeb.turno(true);
+            alFlancoDeTurno?.(true);
+            try {
+                // Se DEVUELVE lo que el turno informe. Sin este `return`, el canal que
+                // `crearEjecutorReal` acaba de abrir moría en este envoltorio: el corredor de
+                // tareas no tendría con qué medir si lo hecho es entregable, y ninguna piel se
+                // enteraría — que es exactamente cómo el `terminada` falso pasó desapercibido.
+                return await ejecutorEfectivo(peticion, estado, consola);
+            }
+            finally {
+                // En el `finally`: un turno que revienta o que se cancela también TERMINA, y dejar
+                // el compositor apagado para siempre sería peor que no haberlo apagado nunca.
+                turnoEnVuelo = false;
+                consolaWeb.turno(false);
+                alFlancoDeTurno?.(false);
+                volcar();
+                // Y el commit, DESPUÉS de volcar: así la entrada del índice ya existe y su título
+                // —que es lo que da nombre al commit— es el de verdad.
+                //
+                // Se ESPERA, al contrario que la ref de la foto: medido sobre una copia del
+                // proyecto real del usuario (165 MB, 41 colecciones), `add -A` + `commit` tardan
+                // 74 ms, y quien llama acaba de esperar un turno entero. Y hace falta esperarlo: la
+                // puerta de entrega del corredor corre en cuanto el turno devuelve y le pregunta a
+                // git, así que un commit suelto correría contra ella.
+                //
+                // Envuelto entero: esto va en el `finally` del turno, y una excepción aquí se
+                // llevaría por delante el cierre —el compositor apagado para siempre—. Un fallo se
+                // DICE, que es lo contrario de dejar el árbol sucio en silencio hasta que
+                // `/sync subir` se niegue.
+                try {
+                    // El id de sesión va APARTE del mensaje: de él sale el sello con el que después
+                    // se atribuye el cambio (`agent/sesionGit.ts`), y el título que va en el asunto no
+                    // identifica nada — dos sesiones se pueden llamar igual, y renombrar una lo cambia.
+                    const aviso = await opciones.commitearTurno?.(raiz, mensajeDeCommit(), idSesion);
+                    if (aviso !== undefined)
+                        informar(aviso);
+                }
+                catch (error) {
+                    informar(`no se pudo commitear el turno: ${error.message}`);
+                }
+            }
+        };
+        // El estado con el que arranca el lazo, guardado ANTES de arrancarlo: es lo que
+        // `estadoDeSesion` devuelve mientras nadie haya cambiado nada, y sin él quien pinte el
+        // modelo en vigor no tendría qué enseñar hasta el primer `/modelo` — que es justo lo
+        // que se quiere evitar (enseñar «no se sabe» cuando sí se sabe).
+        let estadoDeSesion = {
+            // El hilo ES el id de la sesión: es lo que permite que reabrirla continúe la
+            // conversación en vez de releerla. `/nuevo` sigue pudiendo cambiarlo — abre otro hilo
+            // dentro de la misma sesión, y eso es exactamente lo que dice que hace.
+            hilo: idSesion,
+            raiz,
+            // Se LEE aquí, una vez por consola y no una por proceso: es lo que hace que una
+            // sesión nueva vea el `config.json` de ahora. Ver `OpcionesDelVestibulo.fuentes`.
+            fuentes: opciones.fuentes?.() ?? {},
+        };
+        // `/modelo` y `/modelos` cambian el modelo EN CALIENTE y no tocan disco, así que esta
+        // es la única forma de enterarse. Ver `Consola.alEstado`.
+        consolaWeb.consola.alEstado = (nuevo) => {
+            estadoDeSesion = nuevo;
+            // Al cable solo por la puerta de las personas: la escucha reemite el estado de
+            // modelos a los navegadores conectados, y el modelo de una tarea no es el que está
+            // en vigor para quien mira. El estado LOCAL se actualiza igual — `/modelo` dentro de
+            // la tarea tiene que surtir efecto en la tarea.
+            if (enElCable())
+                escuchaDeEstado?.(nuevo);
+        };
+        const terminada = correr(consolaWeb.consola, estadoDeSesion, ejecutarTurno).finally(() => {
+            cerrada = true;
+        });
+        // Un lazo que revienta sin que nadie espere `terminada` sería un rechazo sin manejar
+        // que tumba el proceso. Se cuenta y se sigue: la consola del vestíbulo sigue viva.
+        terminada.catch((error) => {
+            informar(`la consola del proyecto terminó con un error: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        const consolaDeProyecto = {
+            raiz,
+            /**
+             * Lo que lleva consumido su sesión, contando lo de ANTES de este proceso.
+             *
+             * **Se PREGUNTA a la sesión, no se cachea**: el acumulador vive en el cierre de
+             * `abrirSesionReal` y es la única fuente; una copia aquí se quedaría vieja entre
+             * avisos. Y se le SUMA la base histórica leída al abrir, que es lo que hace que
+             * reabrir una conversación no ponga el contador a cero: sin esto, una sesión volvía
+             * sin ninguna cifra hasta su primer turno nuevo.
+             *
+             * `sesionReal` llega TARDE —`crearEjecutorReal` la anuncia dentro del primer turno—,
+             * así que antes de eso solo hay base, y si tampoco la hay se contesta `undefined`, que
+             * es «no consta» y hace que no se pinte nada.
+             */
+            consumo: () => {
+                const vivo = consumoVivo();
+                if (vivo === undefined) {
+                    return consumoHistorico === undefined ? undefined : consumoDeLaSesion(consumoHistorico);
+                }
+                if (consumoHistorico === undefined)
+                    return consumoDeLaSesion(vivo);
+                return consumoDeLaSesion(sumarConsumo(consumoHistorico, vivo));
+            },
+            get estadoDeSesion() {
+                return estadoDeSesion;
+            },
+            // Ver `ConsolaDeProyecto.idDeHilo`: este es el id crudo, sin esperar al índice.
+            idDeHilo: idSesion,
+            get sesion() {
+                // Solo cuando está en el ÍNDICE. El id existe desde que se abre —es el hilo—, pero
+                // hacia fuera «hay sesión» significa «hay una entrada que la barra puede marcar»:
+                // devolver un uuid que no está en ninguna lista haría que la barra buscara una fila
+                // que no existe, y que Revisión dijera que la sesión ya empezó sin haber empezado.
+                return anotada ? idSesion : undefined;
+            },
+            get historica() {
+                return historica;
+            },
+            trabajoAlAbrir,
+            get dispositivo() {
+                return dispositivo;
+            },
+            elegirDispositivo: (elegido) => {
+                dispositivo = elegido;
+                // Si todavía no está en el índice, se queda en memoria: `volcar()` lo anotará en
+                // cuanto cree la entrada. Escribir aquí una entrada nueva la enseñaría en la barra
+                // como una sesión vacía que nadie ha empezado.
+                if (anotada)
+                    sesiones.elegirDispositivo?.(raiz, idSesion, elegido);
+            },
+            get cerrada() {
+                return cerrada;
+            },
+            get turnoEnVuelo() {
+                return turnoEnVuelo;
+            },
+            consola: consolaWeb,
+            cancelarTurno: () => {
+                if (sesionReal?.cancelar === undefined)
+                    return false;
+                sesionReal.cancelar();
+                return true;
+            },
+            recibir: (mensaje) => {
+                consolaWeb.recibir(mensaje);
+                /**
+                 * Una PROSA del usuario da de alta la sesión en el índice AHORA, no al acabar el
+                 * turno.
+                 *
+                 * `volcar()` era lo único que creaba la entrada, y corre en la frontera del turno:
+                 * así que la conversación no aparecía en la barra hasta que el asistente terminaba
+                 * de contestar —minutos— y hasta entonces no había fila que marcar, ni que enseñar
+                 * trabajando, ni que volver a abrir. Lo dijo el usuario mirando la pantalla.
+                 *
+                 * No contradice la pereza que la entrada tenía: esa existía para que «alguien mira
+                 * un proyecto y se va sin decir nada» no dejara una sesión vacía en la barra, y
+                 * mandar un mensaje es exactamente decir algo. Lo que sigue siendo perezoso es lo
+                 * mismo de antes: abrir no escribe nada.
+                 *
+                 * **Solo con el turno parado**, y eso es la otra mitad. `volcar` no puede correr a
+                 * mitad de turno: el último acto de la piel todavía muta —el cierre de una racha de
+                 * tools SUSTITUYE a su apertura dentro del mismo acto— y el `.jsonl` solo sabe
+                 * anexar, así que guardaría las dos líneas. Con el turno en vuelo no hace falta:
+                 * la entrada ya la creó la prosa que lo arrancó. Y el acto de usuario en sí no muta
+                 * nunca, que es lo que hace seguro volcarlo suelto.
+                 */
+                if (mensaje.clase === "prosa" && !turnoEnVuelo)
+                    volcar();
+            },
+            // El transcript del cliente lleva PRIMERO lo releído y después lo de esta ejecución.
+            // Lo releído no vuelve a pasar por `volcar`: ya está en el `.jsonl`.
+            conectar: (enviar) => [...(reabierta?.actos ?? []), ...consolaWeb.conectar(enviar)],
+            desconectar: (enviar) => consolaWeb.desconectar(enviar),
+            soltar: (enviar) => consolaWeb.soltar(enviar),
+            mensajesDeAprobacion: () => consolaWeb.mensajesDeAprobacion(),
+            actos: () => [...(reabierta?.actos ?? []), ...consolaWeb.actos()],
+            cerrar: async () => {
+                // El orden es el que evita que cerrar cuelgue: `consolaWeb.cerrar()` pone el EOF,
+                // pero `correrConsola` no lo mira hasta que el turno en vuelo devuelve, y un turno
+                // en vuelo puede tardar minutos. Abortar la sesión real primero es lo que lo
+                // desbloquea — y es para lo que existe `SesionReal.cerrar()`.
+                cerrando = true;
+                sesionReal?.cerrar();
+                consolaWeb.cerrar();
+                await terminada.catch(() => 0);
+                volcar();
+            },
+            /**
+             * Espera a que la ref de la sesión esté ESCRITA, para quien vaya a mirarla.
+             *
+             * Estuvo un rato dentro de `cerrar()` y era una regresión para quien está sentado
+             * delante: cerrar un proyecto pasaba a aguardar un `git add -A` + `write-tree` sobre
+             * el árbol entero, o sea una pausa visible en un proyecto grande — y por un camino
+             * que no la necesita. Quien la necesita es el CORREDOR de tareas, que mide la
+             * condición de «revisable» justo después de cerrar; así que la espera la hace él y no
+             * se le cobra a nadie más. Ver `marcado`.
+             */
+            esperarMarca: async () => void (await marcado?.catch(() => undefined)),
+            // El MISMO objeto que se le acaba de pasar a `correr`, no un segundo envoltorio: dos
+            // versiones del turno divergen en la primera corrección que solo toque a una.
+            ejecutarTurno,
+            terminada,
+        };
+        return consolaDeProyecto;
+    };
+    const abrirDeVerdad = async (apertura) => {
+        /**
+         * ANTES de cerrar nada: si esa conversación es la de una tarea en curso, no se abre.
+         *
+         * Es la MISMA guarda que `borrarSesion`, con el mismo motivo de fondo —el hilo lo está
+         * escribiendo alguien— y sobre la misma fuente (`deTareas`, que es quien sabe qué
+         * consolas están vivas). Lo que pasaba sin ella: el `thread_id` del checkpointer ES el id
+         * de la sesión, así que abrirla aquí ponía DOS consolas escribiendo el mismo hilo, con el
+         * agente a mitad de turno en una de ellas. El botón existía desde siempre (el título de
+         * la tarjeta del kanban), y con «Ver lo que hace» a su lado un botón correcto pegado a uno
+         * peligroso enseña que los dos son igual de seguros.
+         *
+         * **El orden es la mitad del arreglo**: abajo se cierra la consola que ocupe esa raíz,
+         * así que una guarda puesta después habría cerrado la sesión de la persona para después
+         * negarse a abrir la otra — dos daños en vez de ninguno.
+         *
+         * Se compara con `sesion` Y con `idDeHilo` porque son dos momentos de la misma
+         * conversación: `sesion` no existe hasta que se vuelca el primer acto, y `idDeHilo` desde
+         * el primer instante. El que viaja en la tarjeta es el primero; el que cubre la ventana
+         * anterior al volcado es el segundo.
+         */
+        if (apertura.sesion !== undefined && esDeUnaTareaEnCurso(apertura.raiz, apertura.sesion)) {
+            throw new Error(MOTIVO_SESION_DE_TAREA_EN_CURSO);
+        }
+        // Poda: una consola cuyo lazo ya terminó por su cuenta (un `/salir`, un fallo del lazo)
+        // no puede seguir ocupando su raíz. Es la misma poda perezosa que `deTareas`, y aquí es
+        // lo que impide que un proyecto quede inabrible para siempre.
+        for (const [raiz, vieja] of [...abiertas])
+            if (vieja.cerrada)
+                abiertas.delete(raiz);
+        const yaAbierta = abiertas.get(apertura.raiz);
+        if (yaAbierta !== undefined) {
+            /**
+             * La MISMA sesión de un proyecto que ya está abierto: solo se muda el foco.
+             *
+             * Es el caso corriente de volver a ella desde la barra, y cerrarla para reabrirla
+             * sería tirar el turno que quizá está corriendo — justo lo que este cambio existe para
+             * evitar. Se compara con `sesion` Y con `idDeHilo` por lo mismo que la guarda de las
+             * tareas: son dos momentos de la misma conversación, y el segundo cubre la ventana
+             * anterior al primer volcado.
+             */
+            const laMisma = apertura.sesion !== undefined &&
+                (yaAbierta.sesion === apertura.sesion || yaAbierta.idDeHilo === apertura.sesion);
+            /**
+             * Abrir el PROYECTO —sin nombrar sesión— que está trabajando es VOLVER a lo que está
+             * pasando, no pedir una conversación nueva.
+             *
+             * Y es la única forma de llegar: el id de una sesión nace al volcar su primer acto, o
+             * sea al final del turno, así que la conversación que acabas de arrancar no tiene fila
+             * en la barra todavía. Medido en la pantalla del usuario: arrancó una sesión, se fue,
+             * pulsó el nombre del proyecto para ver qué hacía y se llevó el rechazo cinco veces —
+             * el botón muerto de siempre, y sin ninguna otra puerta detrás.
+             *
+             * La distinción con «nueva sesión» no la hace esto, la hace el cliente: el «+» se
+             * apaga mientras el proyecto trabaja, porque una segunda conversación sobre la misma
+             * copia de trabajo sigue siendo imposible. Lo que queda aquí es que el gesto de
+             * «llévame a este proyecto» lleve a alguna parte.
+             */
+            const volverALoQueTrabaja = apertura.sesion === undefined && yaAbierta.turnoEnVuelo;
+            if (laMisma || volverALoQueTrabaja) {
+                enFoco = apertura.raiz;
+                await cerrarLasOciosasSalvo(apertura.raiz);
+                return yaAbierta;
+            }
+            /**
+             * OTRA sesión del MISMO proyecto, con la que hay trabajando: se DECLINA.
+             *
+             * Una consola por raíz no es una limitación de este mapa: es la copia de trabajo. Dos
+             * conversaciones escribiendo los mismos ficheros no tienen aislamiento de ninguna
+             * clase —es el mismo motivo por el que una tarea no arranca donde hay una persona— y
+             * cerrar la que trabaja para abrir la otra sería la interrupción que se acaba de
+             * quitar. Si está OCIOSA sí se cierra y se abre la nueva, que es lo de siempre.
+             */
+            if (yaAbierta.turnoEnVuelo)
+                throw new Error(motivoDeProyectoTrabajando());
+            await cerrarConsolaDeProyecto(apertura.raiz);
+        }
+        const raiz = apertura.raiz;
+        await cerrarLasOciosasSalvo(raiz);
+        /**
+         * El foco se muda ANTES de construir, y no después.
+         *
+         * No es orden por gusto: el lazo arranca DENTRO de `construirConsolaDeProyecto`, así que
+         * su primer flanco de turno puede salir de ahí —lo hace con cualquier `correr` que no
+         * espere una línea—, y con el foco puesto después ese flanco habría hablado de la
+         * consola anterior. Que quede apuntando a una raíz sin consola si la construcción
+         * revienta es inocuo: `consolaEnFoco()` pregunta al mapa, y ahí no habrá nada.
+         */
+        enFoco = raiz;
+        const consolaDeProyecto = await construirConsolaDeProyecto({
+            ...apertura,
+            enElCable: () => enFoco === raiz,
+            alFlancoDeTurno: (activo) => {
+                // La barra se repinta en los DOS flancos y esté o no en foco: de aquí sale que una
+                // sesión de segundo plano está trabajando.
+                avisarDeLasAbiertas({ raiz, turnoEnVuelo: activo });
+                // Y al terminar, si ya no la mira nadie, se cierra. Ver `cerrarSiSobra`.
+                if (!activo)
+                    cerrarSiSobra(raiz);
+            },
+        });
+        abiertas.set(raiz, consolaDeProyecto);
+        return consolaDeProyecto;
+    };
+    /**
+     * Las consolas abiertas para tareas. No son `abierto` —nadie las mira— pero cada una
+     * tiene su `correrConsola` vivo, así que `cerrar()` tiene que llevárselas: un lazo que
+     * nadie cierra deja el proceso sin terminar, y «cierra el propio vestíbulo» sería falso.
+     *
+     * El objeto se guarda TAL CUAL, sin envolver su `cerrar`: `ConsolaDeProyecto` expone
+     * captadores (`sesion`, `historica`, `cerrada`) y una copia con `...` los congelaría en
+     * el valor que tuvieran al abrir — `sesion` se quedaría en `undefined` para siempre. Las
+     * ya cerradas se PODAN al abrir la siguiente, que es cuando puede empezar a crecer.
+     */
+    const deTareas = new Set();
+    /**
+     * ¿Esa conversación la está escribiendo una tarea de fondo AHORA?
+     *
+     * La fuente es `deTareas` y no el índice de tareas a propósito: lo que hace daño es que
+     * haya dos consolas de ESTE proceso sobre el mismo hilo, y eso solo lo sabe este conjunto.
+     * Una tarea `en-proceso` en el OTRO proceso no aparece aquí, y esa limitación es la misma
+     * que ya declara `borrarSesion` — el límite lo pone el sistema operativo, no esta función.
+     */
+    const esDeUnaTareaEnCurso = (raiz, sesion) => [...deTareas].some((consola) => consola.raiz === raiz && !consola.cerrada && (consola.sesion === sesion || consola.idDeHilo === sesion));
+    const abrirParaTarea = async (raiz, sesion, adjuntos, tarea) => {
+        // ANTES de construir nada: sin esto, una raíz equivocada dejaba un `correrConsola`
+        // vivo, una foto de git lanzada y un id de hilo gastado. Y el motivo no lleva la ruta
+        // —puede ser la del home— porque de aquí el error sube al registro de la tarea.
+        if (!esProyecto(raiz)) {
+            throw new Error("esa raíz no es un proyecto de xonecode: falta su .xonecode/config.json");
+        }
+        for (const vieja of deTareas)
+            if (vieja.cerrada)
+                deTareas.delete(vieja);
+        // `sesion` reenviada tal cual: es lo que hace que `construirConsolaDeProyecto` REABRA
+        // ese hilo —`idSesion = sesion ?? randomUUID()`— en vez de abrir uno nuevo. `undefined`
+        // en la primera ejecución de la tarea sigue dando una sesión nueva, como siempre.
+        // `adjuntos` reenviada igual que `sesion`, y por el mismo motivo: quien la conoce es el
+        // corredor, que es el único que sabe de qué tarea es esta apertura.
+        // `tarea` viaja por lo mismo que las otras dos: quien sabe de qué tarea es esta
+        // apertura es el corredor. Es lo que marca su fila en el índice como sesión de tarea.
+        const consolaDeProyecto = await construirConsolaDeProyecto({
+            raiz,
+            sesion,
+            adjuntos,
+            tarea,
+            // Nunca. Una consola de tarea no está en el cable ni puede llegar a estarlo: el foco
+            // es de las de persona, y su raíz podría coincidir con una de ellas.
+            enElCable: () => false,
+        });
+        deTareas.add(consolaDeProyecto);
+        return consolaDeProyecto;
+    };
+    /** Cierra las consolas de tarea que queden vivas. Ver `deTareas`. */
+    const cerrarLasDeTareas = async () => {
+        for (const consola of [...deTareas]) {
+            deTareas.delete(consola);
+            // Una que ya cerró el corredor no se vuelve a cerrar, y un fallo al cerrar una no
+            // puede dejar a las demás vivas: el cierre es lo último que corre.
+            if (!consola.cerrada)
+                await consola.cerrar().catch(() => undefined);
+        }
+    };
+    return {
+        consola: consolaDelVestibulo,
+        nombre: opciones.nombre,
+        async pasosPendientes() {
+            const pasos = [];
+            // La MISMA condición que usa `asistenteDeModelo`: si `trabajo` no resolvió por
+            // `omision`, alguien eligió (proveedor, modelo, clave si el proveedor la pide,
+            // global o bandera) y no se pregunta.
+            if (opciones.origenDeTrabajo === "omision")
+                pasos.push("cuenta");
+            if (registrados.length === 0)
+                pasos.push("entorno");
+            // El proyecto YA NO es un paso del alta — cambio de rumbo del usuario: con cuenta
+            // y entorno resueltos se entra directo al dashboard, y el proyecto se elige en la
+            // barra lateral (entorno → proyectos → sesiones), no aquí. `abierto` sigue
+            // existiendo como estado (`proyectoAbierto()`, más abajo) pero no bloquea nada.
+            return pasos;
+        },
+        alCambiarEstadoDeSesion(escucha) {
+            escuchaDeEstado = escucha;
+        },
+        alCambiarTurno(escucha) {
+            escuchaDeTurno = escucha;
+        },
+        alCambiarConsumo(escucha) {
+            escuchaDeConsumo = escucha;
+        },
+        // La del FOCO, igual que `proyectoAbierto()`: es la sesión que se está mirando.
+        consumoDeSesion: () => consolaEnFoco()?.consumo?.(),
+        opcionesDeEntorno: () => [...ENTORNOS_OFICIALES, ENTORNO_OTRO],
+        entornosRegistrados: () => [...registrados],
+        async pasoDeCuenta() {
+            // Sigue siendo `asistenteDeModelo` con la consola web detrás y nada más. Lo único que
+            // esta piel añade es `exigirEleccion`: aquí el paso de cuenta es la PUERTA del
+            // dashboard, así que cancelar vuelve a preguntar en vez de dejar entrar con el modelo
+            // por omisión. El asistente decide cuándo parar mirando `eof()` — sin cliente, no hay
+            // a quién insistirle.
+            return asistenteDeModelo(consolaDelVestibulo.consola, {
+                origenDeTrabajo: opciones.origenDeTrabajo,
+                hayCredencial: opciones.hayCredencial ?? (() => false),
+                guardarCredencial: registrarCredencial,
+                // La clave se prueba contra el catálogo ANTES de escribirse; esto es lo que la
+                // pone en el proceso mientras tanto. Entra por opción como todo lo que toca el
+                // sistema: un test no puede escribir en el `process.env` del que corre los tests
+                // sin decirlo.
+                ...(opciones.aplicarCredencial === undefined ? {} : { aplicarCredencial: opciones.aplicarCredencial }),
+                exigirEleccion: true,
+            });
+        },
+        async guardarCredencialDe(proveedor, clave) {
+            const guardada = registrarCredencial(proveedor, clave);
+            // Se dice AQUÍ, en el momento: si el usuario cancela el paso siguiente, un
+            // «cancelado» a secas daría a entender que no se tocó nada, y la clave ya está en
+            // disco. Es la misma frase que escribe `/provider` y el asistente de terminal.
+            informar(`credencial de ${proveedor} guardada en ${guardada.ruta}`);
+            return guardada;
+        },
+        async registrarEntorno(entorno) {
+            if (!urlDeEntornoValida(entorno.url)) {
+                throw new Error(AVISO_DE_URL_DE_MCP);
+            }
+            // Lo ÚNICO que el formulario pide es la URL; la identidad se deduce de ella.
+            const identificado = identidadDeEntorno(entorno);
+            const guardado = opciones.guardarEntorno(identificado);
+            // Justo después de registrar, y no antes: `adoptarLegadoSiProcede` solo actúa si la
+            // URL es la oficial por omisión, que es la única que el fichero plano pudo usar.
+            adoptarLegado(identificado);
+            // SUSTITUYE por id, como hace `settingsEnDisco.guardarEntorno` en el fichero. Con un
+            // `push` a secas, registrar dos veces el mismo entorno —cosa que la web hace cada vez
+            // que alguien lo elige— dejaba dos entradas para un id, y `entornoPorId` resolvía a la
+            // primera: la vieja. Registrar es idempotente aquí igual que en disco.
+            const yaEstaba = registrados.findIndex((e) => e.id === identificado.id);
+            if (yaEstaba >= 0)
+                registrados.splice(yaEstaba, 1, identificado);
+            else
+                registrados.push(identificado);
+            informar(`entorno «${identificado.id}» registrado en ${guardado.ruta}`);
+            // El entorno YA identificado vuelve con la ruta: quien registró un «otro» no sabe con
+            // qué id quedó, y `arranque.ts` necesita ese id exacto para pedirle los proyectos —
+            // con el «otro» de la lista, `entornoPorId` no encontraría nada.
+            return { ...guardado, entorno: identificado };
+        },
+        async guardarProyectosVisibles(entorno, proyectos) {
+            const registrado = entornoPorId(entorno);
+            const conProyectos = { ...registrado, proyectos: [...proyectos] };
+            const guardado = opciones.guardarEntorno(conProyectos);
+            const donde = registrados.findIndex((e) => e.id === registrado.id);
+            if (donde >= 0)
+                registrados.splice(donde, 1, conProyectos);
+            informar(`proyectos visibles de «${registrado.id}»: ${proyectos.length === 0 ? "ninguno" : proyectos.join(", ")}`);
+            return guardado;
+        },
+        async proyectosDe(entorno) {
+            const registrado = entornoPorId(entorno);
+            if (opciones.proyectosDeEntorno === undefined) {
+                throw new Error("esta ejecución no tiene conexión con CloudStudio");
+            }
+            const { proyectos, servidor } = await opciones.proyectosDeEntorno(registrado);
+            renombrarConElServidor(registrado, servidor?.nombre);
+            return proyectos;
+        },
+        async ramasDe(entorno, proyecto) {
+            // El NOMBRE, siempre: es lo único que el servidor sabe abrir.
+            const nombre = typeof proyecto === "string" ? proyecto : proyecto.nombre;
+            const registrado = entornoPorId(entorno);
+            if (opciones.ramasDeProyecto === undefined) {
+                throw new Error("esta ejecución no tiene conexión con CloudStudio");
+            }
+            return opciones.ramasDeProyecto(registrado, nombre);
+        },
+        raizDeProyecto(entorno, proyecto) {
+            return rutaDeWorkspace(base, entornoPorId(entorno).id, proyecto);
+        },
+        sesionesDe(raiz) {
+            // Una carpeta que no existe no es un fallo: es un proyecto que nunca se abrió. El
+            // puerto se lo traga y devuelve vacío, que es la verdad.
+            try {
+                // Campo a campo y no la entrada entera: del índice cuelgan además `creada` y el
+                // `dispositivo`, que la barra no pinta. Los tres que sí salen son los que distinguen
+                // una fila de otra: CUÁNDO se tocó, de QUIÉN es y CUÁNTO costó.
+                return sesiones.listar(raiz).map((s) => ({
+                    id: s.id,
+                    titulo: s.titulo,
+                    ...(s.ultimoTurno === undefined ? {} : { ultimoTurno: s.ultimoTurno }),
+                    ...(s.tarea === undefined ? {} : { tarea: s.tarea }),
+                    ...(s.consumo === undefined ? {} : { consumo: s.consumo }),
+                }));
+            }
+            catch {
+                return [];
+            }
+        },
+        async borrarSesion(raiz, id) {
+            // Antes de tocar NADA: si esa conversación es la de una tarea en curso, no se borra.
+            // `olvidarMarcaDeSesion` y `olvidarMemoriaDeHilo` no son condicionales, así que
+            // borrar aquí se habría llevado la ref de git y el checkpoint de un hilo que el
+            // agente sigue escribiendo — y su siguiente `volcar()` habría devuelto la fila a la
+            // barra, dejando al usuario con un botón que parece no funcionar. Ver `deTareas`.
+            // El MISMO predicado que la guarda de `abrirDeVerdad`: dos copias de «¿la está
+            // escribiendo una tarea?» acabarían discrepando, y la que se quedara vieja sería la
+            // que deja pasar el daño.
+            if (esDeUnaTareaEnCurso(raiz, id)) {
+                return {
+                    borrada: false,
+                    cerroLaAbierta: false,
+                    motivo: "esa conversación es la de una tarea en curso: se podrá borrar cuando termine",
+                };
+            }
+            // Cerrar ANTES de borrar: ver el comentario del contrato. Y solo si es ESA sesión —
+            // cerrar el proyecto entero porque se borró una conversación vieja de la lista sería
+            // llevarse por delante el trabajo en curso.
+            // La consola de ESA sesión, si hay alguna abierta: puede no ser la que está en foco
+            // desde que cambiar de sesión no mata la anterior. `cerroLaAbierta` sigue queriendo
+            // decir «la que estabas mirando», que es lo que el cliente usa para volver al
+            // escritorio: cerrar una de segundo plano no le cambia la vista a nadie.
+            const suya = abiertas.get(raiz);
+            const laDeEsaSesion = suya !== undefined && suya.sesion === id;
+            const cerroLaAbierta = laDeEsaSesion && enFoco === raiz;
+            if (laDeEsaSesion)
+                await cerrarConsolaDeProyecto(raiz);
+            const borrada = sesiones.borrar?.(raiz, id) ?? false;
+            // La ref de git de la sesión se va con ella: apunta a un árbol que solo esa vista
+            // usaba, y dejarla mantendría ese árbol vivo para siempre (`agent/sesionGit.ts`).
+            // No es condicional al `borrada`: una entrada de índice ya perdida no es motivo para
+            // dejar la ref colgada.
+            await opciones.olvidarMarcaDeSesion?.(raiz, id);
+            // Y su memoria: el `thread_id` es el id de la sesión, así que el checkpoint queda
+            // huérfano y con el contenido de todo lo que se escribió en ella. Tampoco condicional
+            // al `borrada`, por lo mismo que la ref.
+            await opciones.olvidarMemoriaDeHilo?.(raiz, id);
+            return { borrada, cerroLaAbierta };
+        },
+        renombrarSesion(raiz, id, titulo) {
+            return sesiones.renombrar?.(raiz, id, titulo) ?? false;
+        },
+        async completarProyecto({ entorno, proyecto, rama }) {
+            const registrado = entornoPorId(entorno);
+            // El listado remoto trae `{id, nombre}`; un nombre suelto vale porque en CloudStudio
+            // el proyecto se abre POR NOMBRE (`studio_open_project`) y el id solo identifica.
+            //
+            // Se DESESTRUCTURA, y no es estilo: lo que entre aquí acaba en el `config.json` del
+            // proyecto (`guardarProyectoCloudStudioDeProyecto`, abajo), y quien llama le pasa una
+            // fila del listado remoto — que hoy trae además `compartido` y mañana podría traer
+            // otra cosa. TypeScript no avisa: la comprobación de propiedades de más solo salta
+            // con un literal, no con un objeto que llega por variable. Copiar los dos campos que
+            // SON la identidad es lo que impide que el disco se llene de datos del servidor.
+            const identidad = typeof proyecto === "string"
+                ? { id: proyecto, nombre: proyecto }
+                : { id: proyecto.id, nombre: proyecto.nombre };
+            const raiz = rutaDeWorkspace(base, registrado.id, identidad.nombre);
+            const datos = {
+                entorno: registrado.id,
+                url: registrado.url,
+                scopes: registrado.scopes ?? SCOPES_CLOUDSTUDIO_AGENTE,
+                proyecto: identidad,
+                rama,
+            };
+            // El alta se escribe ENTERA antes de bajar, y no después. No es un descuido: la
+            // frase que se dice cuando la descarga falla es «reintenta con /sync bajar», y
+            // `/sync` lee del disco el proyecto y la rama — sin el alta escrita, ese consejo
+            // sería mentira. «No a medias» significa completa o nada, no «nada».
+            const { ruta } = opciones.guardarConfigDeProyecto(raiz, datos);
+            proyectoEscrito = { raiz, ruta };
+            informar(`proyecto dado de alta en ${ruta}`);
+            try {
+                await opciones.descargar({ ...datos, raiz });
+            }
+            catch (error) {
+                const detalle = error instanceof Error ? error.message : String(error);
+                informar(`no se pudo descargar el proyecto: ${detalle}`);
+                informar(`el alta quedó completa en ${ruta}; reintenta la descarga con «/sync bajar»`);
+                // Se propaga: quien llama decide si vuelve al paso de proyecto o abre igualmente
+                // la copia vacía. Tragárselo aquí dejaría creer que el proyecto está bajado.
+                throw error;
+            }
+            return { raiz, ruta };
+        },
+        abrirProyecto: (apertura) => enCola(() => abrirDeVerdad(apertura)),
+        /**
+         * Abrir un proyecto para una TAREA: la misma construcción, sin registrarlo como el
+         * proyecto abierto ni mudar el sumidero del cable.
+         *
+         * Existe porque el vestíbulo sirve UN proyecto a la vez (`proyectoAbierto()` devuelve
+         * uno) y el cable se muda a esa consola (`arranque.ts#adjuntar`): si el corredor
+         * reusara `abrirProyecto`, cada tarea que arrancase cerraría la consola de quien esté
+         * trabajando y le movería la vista.
+         *
+         * Va por la misma COLA que la otra puerta aunque no toque `abierto`: la cola es lo que
+         * sostiene «una consola de proyecto a la vez», y colarse por delante de un
+         * un cierre a medias sería empezar a construir mientras el lazo anterior
+         * todavía vive. El precio, dicho: una tarea que llega mientras se cierra un turno
+         * humano de minutos espera a que acabe. Para trabajo de fondo es el lado correcto.
+         */
+        abrirParaTarea: (raiz, sesion, adjuntos, tarea) => enCola(() => abrirParaTarea(raiz, sesion, adjuntos, tarea)),
+        proyectoAbierto: () => consolaEnFoco(),
+        // La del foco INCLUIDA, y las cerradas fuera: una consola cuyo lazo ya terminó no ocupa
+        // su raíz, y de esta lista cuelga la guarda de «gana la persona».
+        proyectosAbiertos: () => [...abiertas.values()].filter((c) => !c.cerrada),
+        cancelar: () => enCola(async () => {
+            await cerrarLasDeProyecto();
+            informar("alta cancelada");
+            // Negar lo que ya está en disco sería mentir. Cancelar no BORRA nada: dice qué quedó.
+            if (credencialEscrita !== undefined) {
+                informar(`la credencial de ${credencialEscrita.proveedor} sigue escrita en ${credencialEscrita.ruta}`);
+            }
+            if (proyectoEscrito !== undefined) {
+                informar(`el alta del proyecto sigue escrita en ${proyectoEscrito.ruta}`);
+            }
+        }),
+        cerrar: () => enCola(async () => {
+            await cerrarLasDeProyecto();
+            // Y las de las tareas: cada una tiene su `correrConsola` vivo, y dejarlo corriendo
+            // deja el proceso sin terminar. Ver `deTareas`.
+            await cerrarLasDeTareas();
+            consolaDelVestibulo.cerrar();
+        }),
+    };
+}
+//# sourceMappingURL=vestibulo.js.map