xonecode 0.38.44 → 0.39.4

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

@@ -0,0 +1,952 @@
+/**
+ * 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 { baseDeWorkspacePorOmision } from "../../agent/config/settingsEnDisco.js";
+import type { Acto, ConsumoDeTurno } from "../../core/actos.js";
+import type { Eleccion, FuentesDeEleccion, Proveedor } from "../../core/modelos.js";
+import type { ConsumoDeSesionPorCuenta, CatalogoModelosPort, ConectoresPort } from "../../core/ports.js";
+import type { Entorno } from "../../core/settings.js";
+import { type Mudanza } from "../../core/mudanzaDeWorkspace.js";
+import { type ProgresoDeMudanza, type ResultadoDeCambioDeBase } from "../../agent/config/mudanzaEnDisco.js";
+import type { TrabajoSinCommitear } from "../../agent/sesiones/gitSync.js";
+import type { ProyectoRemoto } from "../../agent/cloudstudio/cloudstudioMcp.js";
+import { correrConsola, type Consola, type EjecutorDeTurno, type EstadoDeSesion } from "../../cli/consola.js";
+import { type ResultadoDelAsistente } from "../../cli/wizardInicial.js";
+import { type ConsolaWeb, type OpcionesDeConsolaWeb } from "./consolaWeb.js";
+import { type DispositivoElegido, type TicketDeSesion } from "./sesiones.js";
+import type { MensajeAlCliente, MensajeDelCliente, Sumidero } from "./transporte.js";
+import type { Esfuerzo } from "../../core/esfuerzo.js";
+import { type MotorDeAgente } from "../../core/motor.js";
+import { type ModoDeEscritura } from "../../core/modoDeEscritura.js";
+/**
+ * Un paso del alta — o, para «proyecto», una ACCIÓN que ya no es un paso del alta:
+ * `pasosPendientes()` nunca la devuelve (cambio de rumbo del usuario: el proyecto se
+ * elige en la barra lateral, no bloquea la entrada al dashboard), pero el mensaje
+ * `{clase:"alta", paso:"proyecto", …}` del cable (`transporte.ts`) sigue existiendo —es
+ * lo que `completarProyecto`/`abrirProyecto` siguen consumiendo—, así que el valor sigue
+ * siendo válido aquí para no partir ese tipo en dos. El orden de la lista de PENDIENTES
+ * («cuenta», «entorno») ES el orden en que se presentan.
+ */
+export type PasoDelVestibulo = "cuenta" | "entorno" | "proyecto";
+/** Un entorno ofrecido en el paso 2. `url` vacía = el usuario la teclea («otro»). */
+export interface OpcionDeEntorno {
+    id: string;
+    nombre: string;
+    url: string;
+}
+/**
+ * Los dos CloudStudio oficiales, pre-rellenados.
+ *
+ * La URL de WebStudio no se repite aquí: se importa de `agent/cloudstudio/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 declare const ENTORNOS_OFICIALES: readonly OpcionDeEntorno[];
+/**
+ * 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.
+ */
+/**
+ * Cada cuánto se vuelca el chat A MITAD de turno (`volcar` hasta `ConsolaWeb.estables`). Sin esto
+ * el `.jsonl` solo se escribía en la frontera del turno, y un proceso que murió en mitad de uno de
+ * 45 minutos dejó el mensaje de la persona y nada más. Lo que se pierde ahora es, como mucho, esto.
+ */
+export declare const INTERVALO_DE_VOLCADO_MS = 5000;
+export declare const ENTORNO_OTRO: OpcionDeEntorno;
+/**
+ * El workspace por omisión: `~/.xonecode/workspace`. La disposición de DENTRO
+ * (`<workspace>/<entorno>/<proyecto>`) la fija `rutaDeWorkspace` y no es configurable.
+ *
+ * **La carpeta propia es el punto.** Esto era `~/.xonecode` a secas, y entonces cada id de
+ * entorno se plantaba de hermano de `agentes/`, `skills/`, `tareas/`, `auth.json` y
+ * `settings.json`: la casa del harness y el trabajo del usuario en el mismo cajón. Con la
+ * carpeta puesta, lo de xonecode queda arriba y lo bajado queda junto, y
+ * `dentroDelWorkspace` —que es lo que decide si se commitea solo al cerrar cada turno—
+ * deja de dar por suya cualquier carpeta que cuelgue de `~/.xonecode`.
+ */
+export { baseDeWorkspacePorOmision };
+/**
+ * Dónde caían las copias con el reparto VIEJO, cuando nadie había configurado nada:
+ * `~/.xonecode` a secas, con los ids de los entornos colgando directamente de ahí.
+ *
+ * Existe solo para que la mudanza de una vez sepa dónde mirar
+ * (`agent/config/mudanzaEnDisco.ts`), y se va con ella el día que no quede nadie con el
+ * reparto viejo en disco. Está aquí y no en `mudanzaDeWorkspace.ts` porque depende de
+ * `homedir()`, que es lo que ese módulo no puede tocar para seguir siendo puro.
+ */
+export declare function baseDeWorkspaceLegada(): string;
+/** Lo que define a un proyecto ya elegido: entorno, endpoint, identidad remota y rama origen. */
+export interface DatosDeProyecto {
+    /** El id del entorno de `settings.json`. */
+    entorno: string;
+    url: string;
+    scopes: readonly string[];
+    proyecto: {
+        id: string;
+        nombre: string;
+    };
+    /** La rama ORIGEN: de la que se baja y contra la que se compara. */
+    rama: string;
+}
+/**
+ * La persistencia de sesiones, por puerto: los tests no pueden escribir en el proyecto de
+ * verdad y el vestíbulo no puede saber si el `raiz` que le dan existe.
+ */
+export interface PuertoDeSesiones {
+    /** El id lo decide quien abre: es también el `thread_id` del grafo. */
+    crear(raiz: string, id?: string): string;
+    /** El índice de sesiones de un proyecto ya bajado. Una carpeta que no existe es una
+     *  lista vacía, no un error: el proyecto todavía no se ha abierto nunca. `consumo` es el
+     *  acumulado de la sesión entera, y ausente es «no consta» — nunca cero. */
+    listar(raiz: string): {
+        id: string;
+        titulo: string;
+        ultimoTurno?: string;
+        tarea?: string;
+        consumo?: ConsumoDeTurno;
+        ticket?: TicketDeSesion;
+    }[];
+    /** Da de alta la entrada del índice. `tarea` es el id de la TAREA que abrió la sesión, y
+     *  solo lo trae la puerta de las tareas: ausente es «no consta». */
+    crear(raiz: string, id?: string, tarea?: string): string;
+    anotar(raiz: string, id: string, acto: Acto): void;
+    reabrir(raiz: string, id: string): {
+        id: string;
+        actos: Acto[];
+        historica: boolean;
+        dispositivo?: DispositivoElegido;
+        esfuerzo?: Esfuerzo;
+        motor?: MotorDeAgente;
+        modo?: ModoDeEscritura;
+        ticket?: TicketDeSesion;
+    };
+    /** Borra una sesión. Devuelve si había algo que borrar; un id desconocido no es un error
+     *  (dos pestañas, un doble clic). Opcional: un puerto de prueba puede no saber borrar. */
+    borrar?(raiz: string, id: string): boolean;
+    /** Le pone nombre. Devuelve si existía; un título vacío se rechaza. */
+    renombrar?(raiz: string, id: string, titulo: string): boolean;
+    /** Fija el dispositivo preferido. Devuelve si había entrada que tocar: la de una sesión
+     *  cuyo id todavía no existe (nace al volcar) no está, y quien llama lo guarda en memoria. */
+    elegirDispositivo?(raiz: string, id: string, dispositivo: DispositivoElegido | undefined): boolean;
+    /** Anota el esfuerzo de una sesión. Gemelo del anterior: otra elección DE la sesión. */
+    elegirEsfuerzo?(raiz: string, id: string, esfuerzo: Esfuerzo | undefined): boolean;
+    /** Anota con qué motor nace una sesión (`core/motor.ts`). */
+    anotarMotor?(raiz: string, id: string, motor: MotorDeAgente): boolean;
+    /** Anota el modo de escritura de una sesión. El tercero de la misma familia. */
+    elegirModo?(raiz: string, id: string, modo: ModoDeEscritura): boolean;
+    /** Liga una sesión a un ticket de Jira (IXCODE-11). El cuarto de la misma familia, sin
+     *  forma de quitarlo todavía —nadie la pidió. */
+    anotarTicket?(raiz: string, id: string, ticket: TicketDeSesion): boolean;
+}
+/**
+ * ¿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` **y el `sync.json` de una bajada que TERMINÓ**. 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.
+ *
+ * El `sync.json` es la mitad nueva, y cierra un fallo medido: el alta escribe el `config.json`
+ * ANTES de bajar —a propósito, para que «reintenta con /sync bajar» sea verdad—, así que con
+ * solo él una descarga que fallaba dejaba una carpeta vacía que la barra daba por bajada y que
+ * se abría como proyecto. `descargarProyecto` escribe el `sync.json` al acabar, también por la
+ * vía fichero a fichero; si no está, lo que hay que hacer es bajarlo, y eso es el alta.
+ *
+ * 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 declare function esProyectoEnDisco(raiz: string): boolean;
+/** Lo mínimo que el vestíbulo necesita de una `SesionReal` para cambiar de proyecto. */
+export interface SesionCerrable {
+    cerrar(): void;
+    /**
+     * Lo que lleva consumido la sesión, en sus dos cuentas, y el aviso de cuando cambia.
+     *
+     * OPCIONALES los dos, como `cancelar`: el ejecutor guionizado no consume nada y no tiene
+     * qué contar. Ausente significa «no se sabe», que es distinto de cero — y por eso el
+     * contador no se pinta en vez de enseñar un 0 inventado.
+     */
+    consumo?(): {
+        modelo: {
+            entrada: number;
+            salida: number;
+            cache: number;
+        };
+        externo: {
+            entrada: number;
+            salida: number;
+            cache: number;
+        };
+        contexto: number;
+    };
+    alCambiarConsumo?(oyente: () => void): () => void;
+    /** Aborta el `stream` del grafo y deja la sesión viva. Opcional: el ejecutor guionizado
+     *  no tiene nada que abortar. */
+    cancelar?(): void;
+    /** Añade una nota al turno EN MARCHA (IXCODE-4). Opcional: el ejecutor guionizado y
+     *  `deepagents` no lo tienen. */
+    agregarNota?(texto: string): void;
+    /** DETENER y replanificar el turno EN MARCHA (IXCODE-4). Opcional: solo TrueForge. */
+    detener?(texto: string): void;
+}
+export interface OpcionesDelVestibulo {
+    /**
+     * El `origen` con el que resolvió el papel `trabajo`. Es la ÚNICA señal de que nadie ha
+     * elegido nunca; no hay marca de primer arranque.
+     */
+    origenDeTrabajo: Eleccion["origen"];
+    catalogoModelos: CatalogoModelosPort;
+    /** Escribe en `~/.xonecode/auth.json` y devuelve dónde quedó, como `agent/config/authEnDisco.ts`. */
+    guardarCredencial: (proveedor: Proveedor, clave: string) => {
+        ruta: string;
+    };
+    /** Pone la clave en el proceso SIN escribirla, para poder probarla antes de guardarla
+     *  (`agent/config/configEnDisco.ts#aplicarCredencialAlProceso`). Ausente = no se prueba antes. */
+    aplicarCredencial?: (proveedor: Proveedor, clave: string) => void;
+    /** Registra el entorno en `~/.xonecode/settings.json`. */
+    guardarEntorno: (entorno: Entorno) => {
+        ruta: string;
+    };
+    /**
+     * Quita el entorno de `settings.json` y OLVIDA sus credenciales OAuth. OBLIGATORIA, y es a
+     * propósito: una opción opcional que nadie pasa es el patrón de fallo de este repo, y aquí
+     * el síntoma sería un «Eliminar» que no borra nada con todo en verde.
+     */
+    olvidarEntorno: (id: string, modo?: {
+        credenciales?: boolean;
+    }) => {
+        ruta: string;
+    };
+    /** Baja la copia local. Recibe la raíz ya calculada: la sincronización no se toca, solo
+     *  cambia QUIÉN calcula el `raiz` que siempre recibió por parámetro. */
+    descargar: (datos: DatosDeProyecto & {
+        raiz: string;
+    }) => Promise<void>;
+    /** Escribe el `config.json` del proyecto ENTERO. Ver `escribirProyectoEnDisco`. */
+    guardarConfigDeProyecto: (raiz: string, datos: DatosDeProyecto) => {
+        ruta: string;
+    };
+    /** A dónde van los avisos del vestíbulo. Por omisión, su propia consola. */
+    informar?: (texto: string) => void;
+    /**
+     * Apuntar un fallo de DESCARGA en el registro de fallos del proyecto. Por omisión el REAL
+     * (`registroDeFallos.ts`) y no un hueco: un opcional que nadie pasa es el patrón de fallo de
+     * este repo, y aquí el síntoma sería justo el de antes, un error sin rastro.
+     */
+    anotarFallo?: (raiz: string, fallo: {
+        error: unknown;
+        peticion: string;
+    }) => void;
+    /**
+     * Toma el «antes» de la sesión al ABRIR el proyecto y devuelve con qué nombrarlo cuando el
+     * id exista (`agent/sesiones/sesionGit.ts#fotoDeApertura`). Entra por opción como todo lo que toca
+     * el sistema: sin ella no se marca nada y la vista de ficheros dirá que no lo sabe, que es
+     * mejor que una lista vacía.
+     */
+    marcarSesion?: (raiz: string) => Promise<(id: string) => Promise<boolean>>;
+    /**
+     * ¿Había trabajo sin commitear en ese proyecto cuando se abrió?
+     * (`agent/sesiones/gitSync.ts#trabajoSinCommitear`). Entra por opción como todo lo que toca el
+     * sistema; ausente = esta ejecución no lo mira y arriba no se afirma nada.
+     *
+     * Se pregunta AL ABRIR, en el mismo instante que la foto del antes, y por el mismo
+     * motivo: más tarde la respuesta incluiría lo que esta sesión acabe de escribir. Es lo
+     * que permite decir «ya había esto cuando llegaste» sin acusar a nadie de nada.
+     */
+    sinCommitear?: (raiz: string) => Promise<TrabajoSinCommitear>;
+    /**
+     * COMMITEA lo que el turno dejó, al cerrarlo. Devuelve un aviso que decir, o `undefined`
+     * si no hay nada que contar (se commiteó, o no había nada que commitear, o esa carpeta no
+     * es un repo).
+     *
+     * Existe porque sin él no se commitea nunca —`prepararRepo` hace UN commit de baseline al
+     * descargar y ahí se acaba—, y de eso cuelgan dos cosas: que las sesiones se mezclan sin
+     * que nada pueda atribuir ni revertir lo de cada una, y que **`/sync subir` es
+     * inalcanzable**, porque su guarda exige árbol limpio.
+     *
+     * **Quién decide DÓNDE se commitea no es esto**: lo decide quien la cablea, mirando si la
+     * raíz cuelga del workspace que creó xonecode. Commitear cada turno dentro de la carpeta
+     * que abrió el usuario le ensuciaría su historial. Ausente = esta ejecución no commitea.
+     */
+    commitearTurno?: (raiz: string, mensaje: string, sesion: string) => Promise<string | undefined>;
+    /**
+     * El mantenimiento de la memoria del agente, al cerrar el turno. Devuelve qué contar, o
+     * nada — que es el caso normal, porque solo actúa pasada la cota.
+     *
+     * Entra por parámetro como `commitearTurno` y por lo mismo: toca disco, y el suite no
+     * puede depender de una base. Ausente = esta ejecución no hace mantenimiento.
+     */
+    mantenerMemoria?: (raiz: string) => string | undefined;
+    /**
+     * ¿Queda memoria del agente para ese hilo? El `thread_id` ES el id de la sesión
+     * (`agent/sesiones/checkpointer.ts`), así que preguntarlo es lo que convierte `historica` en un
+     * hecho comprobado en vez de en «se reabrió»: una sesión con checkpoint CONTINÚA, y una
+     * sin él —las de antes de que esto existiera, o una cuyo turno nunca llegó a correr—
+     * sigue siendo una relectura y se dice. Ausente = esta ejecución no persiste memoria, y
+     * entonces reabrir es releer, como siempre.
+     */
+    hayMemoriaDeHilo?: (raiz: string, hilo: string) => Promise<boolean>;
+    /**
+     * Olvida la memoria de una sesión borrada. Sin esto, borrar una conversación dejaría su
+     * checkpoint —con el contenido de los ficheros que se escribieron en ella— vivo en el
+     * fichero del proyecto para siempre, invisible desde la interfaz.
+     */
+    olvidarMemoriaDeHilo?: (raiz: string, hilo: string) => Promise<void>;
+    /**
+     * Quita la marca de una sesión que se borra (`agent/sesiones/sesionGit.ts#olvidarSesion`). Va
+     * aparejada a `marcarSesion` y por la misma razón que ella entra por opción: este fichero
+     * no ejecuta git. Sin ella la ref se queda apuntando al árbol de una sesión que ya no
+     * existe, y ese árbol no se lo lleva nunca `git gc`.
+     */
+    olvidarMarcaDeSesion?: (raiz: string, id: string) => Promise<void>;
+    /** Los entornos YA registrados, tal cual los lee `agent/config/settingsEnDisco.ts#cargarSettings`. */
+    entornos?: readonly Entorno[];
+    /**
+     * Dónde se bajan las copias locales — una FUNCIÓN, no un valor, y eso es la regla.
+     *
+     * `settings.workspace` se puede cambiar desde Ajustes con la consola en marcha, así que
+     * una base capturada al construir dejaría el resto del proceso bajando al sitio de antes
+     * mientras la pantalla enseña el nuevo: el ajuste escrito que no hace nada. Es la misma
+     * razón por la que `sinAprobacion` y el tope de concurrencia releen el disco en cada uso
+     * en vez de resolverse al arrancar.
+     */
+    baseDeWorkspace?: () => string;
+    /**
+     * Proveedores que ya tienen credencial. Por omisión `false` para todos, que es la
+     * dirección segura: preguntar de más molesta, no preguntar deja al usuario sin clave.
+     */
+    hayCredencial?: (proveedor: Proveedor) => boolean;
+    /**
+     * La escritura de la elección de modelo. `consolaWeb` LANZA por omisión a propósito
+     * (un no-op silencioso mentiría), así que quien monta la consola tiene que inyectarla:
+     * eso es este fichero, y por eso aquí la omisión sí es el escritor real.
+     */
+    guardarModeloGlobal?: Consola["guardarModeloGlobal"];
+    /** Adopta el fichero OAuth plano de antes de los entornos. Por omisión, el real. */
+    adoptarLegado?: (entorno: Entorno) => void;
+    /**
+     * El listado de proyectos de un entorno. Ausente = esta ejecución no habla con CloudStudio.
+     *
+     * Devuelve también cómo se llama el servidor (`serverInfo` del initialize) porque esta es
+     * la PRIMERA vez que se habla con él de verdad: el entorno se registró antes con lo único
+     * que se le pidió al usuario, la URL. Ver `proyectosDe` para qué se hace con eso.
+     */
+    proyectosDeEntorno?: (entorno: Entorno) => Promise<{
+        proyectos: readonly ProyectoRemoto[];
+        servidor?: {
+            nombre: string;
+        };
+    }>;
+    /** `proyecto` es el NOMBRE, no el id: el servidor abre por nombre y rechaza el
+     *  identificador. Ver `clienteCloudStudio`. */
+    ramasDeProyecto?: (entorno: Entorno, proyecto: string) => Promise<string[]>;
+    sesiones?: PuertoDeSesiones;
+    /**
+     * ¿Es esa raíz un proyecto con copia local? Solo la usa `abrirParaTarea`, que es la
+     * puerta sin nadie delante: por la otra, quien abre acaba de pulsar un proyecto de una
+     * lista que el servidor le dio. Por omisión, `esProyectoEnDisco`.
+     */
+    esProyecto?: (raiz: string) => boolean;
+    /** Costura de test: por omisión, la consola web de verdad. */
+    crearConsola?: (opciones: OpcionesDeConsolaWeb) => ConsolaWeb;
+    /** Costura de test: por omisión, `correrConsola`. */
+    correr?: typeof correrConsola;
+    /**
+     * La fábrica del ejecutor REAL (`crearEjecutorReal` de `main.ts`), con la misma forma que
+     * consume `cli/tui/correrTui.ts`. Se llama con un aviso de apertura porque el vestíbulo
+     * necesita la `SesionReal` para poder CERRARLA al cambiar de proyecto.
+     */
+    crearEjecutor?: (alAbrirSesion: (sesion: SesionCerrable) => void, 
+    /**
+     * Lo que depende de la CONSOLA que se está abriendo y no de su raíz. Hoy solo la
+     * carpeta de los adjuntos de una TAREA (`core/adjuntos.ts`): el agente la ve como
+     * `/adjuntos/`, de solo lectura, y solo la conoce quien abrió esta consola —el corredor
+     * de tareas—. Ausente en toda apertura de PERSONA, que es lo que impide que una consola
+     * de humano acabe con los adjuntos de la última tarea montados dentro.
+     *
+     * **No es el único origen de `/adjuntos/` desde IXCODE-7**: los que una persona anexa en
+     * el CHAT de su sesión no viajan por aquí — el propio ejecutor los deriva de la sesión
+     * (`cli/main.ts#carpetaDeAdjuntosDelEjecutor`, como `/artefactos/`). El vestíbulo sigue
+     * sin reenviarle a una PERSONA los de una tarea; el ejecutor es quien enseña los suyos.
+     */
+    opciones?: {
+        adjuntos?: string;
+        conectores?: ConectoresPort;
+    }) => EjecutorDeTurno;
+    /**
+     * Fuentes del modelo con las que arranca cada consola de proyecto. Como
+     * `dependenciasDeProyecto`, entra por FUNCIÓN y no por objeto, y aquí por una razón que
+     * no es la raíz sino el RELOJ: se llama al ABRIR cada consola, no al construir el
+     * vestíbulo.
+     *
+     * El `config.json` global es del usuario y esta misma consola lo reescribe cuando alguien
+     * elige modelo en Ajustes, así que una instantánea atada al arranque resolvía las sesiones
+     * NUEVAS contra el valor viejo — mientras Ajustes, que sí relee, enseñaba ya el nuevo. El
+     * síntoma es el de siempre en esta casa: dos lecturas del mismo dato que no se hacen en el
+     * mismo instante, y la que se quedó atrás es la que decide. Medido: el proceso arrancó con
+     * `gemini` en el fichero, el fichero pasó a `ollama`, y una sesión nueva seguía diciendo
+     * `gemini`.
+     */
+    fuentes?: () => FuentesDeEleccion;
+    /**
+     * Los dos valores de los que sale el modo con que NACE una sesión nueva de una persona
+     * (IXCODE-31): el del PROYECTO de esa raíz (`config.json#modoDeEscritura`) y el GLOBAL
+     * (`settings.json#modoDeEscritura`, Ajustes > General). Por la RAÍZ y no por `fuentes`: en la
+     * web `fuentes().proyecto` no se rellena nunca. Se pregunta en CADA apertura, así que cambiarlo
+     * alcanza a la sesión siguiente sin reiniciar. Ausente = ninguno, y entonces supervisado.
+     */
+    modoPorDefecto?: (raiz: string) => {
+        proyecto?: ModoDeEscritura;
+        global?: ModoDeEscritura;
+    };
+    /**
+     * El aparato con que NACE una sesión nueva, de una persona o de una TAREA (IXCODE-51,
+     * `settings.json#dispositivoPorDefecto`). Se pregunta en CADA apertura, como el modo. A
+     * diferencia del modo, sí alcanza a las tareas: no autoriza nada, y sin él sus scripts
+     * acababan en el emulador. Ausente = ninguno.
+     */
+    dispositivoPorDefecto?: () => DispositivoElegido | undefined;
+    /**
+     * Lo que la consola de PROYECTO necesita y `consolaWeb` no puede saber: `/sync`, los
+     * escritores de config del proyecto, el tema. Depende de la RAÍZ, que no existe hasta
+     * que se abre el proyecto, así que entra como función y no como objeto.
+     */
+    dependenciasDeProyecto?: (raiz: string) => Partial<Consola>;
+    /** Plazo de aprobación de las consolas de proyecto; se pasa tal cual a `consolaWeb`. */
+    msDeEspera?: number;
+    /**
+     * El nombre para el saludo de la bienvenida (`agent/config/persona.ts#nombreDePersona`, o
+     * `undefined` en los tests que no lo necesitan). Un dato ya resuelto y no una función:
+     * se calcula UNA vez, al arrancar, y no depende de nada que el vestíbulo sepa hacer
+     * (no es un puerto caro que haga falta invocar por turno).
+     */
+    nombre?: string;
+}
+/**
+ * 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 declare function motivoDeProyectoTrabajando(): string;
+export declare const MOTIVO_SESION_DE_TAREA_EN_CURSO: string;
+/**
+ * Por qué no corre un turno de persona en un proyecto donde ESCRIBE una tarea (IXCODE-36): sería un
+ * segundo escritor sobre la misma copia de trabajo. La conversación se puede abrir y leer; lo que no
+ * se puede es enviar —y por eso tampoco nace una conversación nueva: entra en el índice con su
+ * primer mensaje—.
+ */
+export declare const MOTIVO_PROYECTO_CON_TAREA: string;
+/** Una consola de proyecto viva. Solo hay una a la vez. */
+export interface ConsolaDeProyecto {
+    readonly raiz: string;
+    /** Lo que lleva consumido su sesión, si consta. Ver `Vestibulo.consumoDeSesion`. */
+    consumo?(): ConsumoDeSesionPorCuenta | undefined;
+    /**
+     * El estado de sesión de ESTA consola, ahora mismo. Es de dónde sale el modelo en vigor:
+     * `/modelo` lo cambia en caliente dentro del lazo y no toca disco, así que releer la
+     * configuración diría lo de antes.
+     */
+    readonly estadoDeSesion: EstadoDeSesion;
+    /** El id de la sesión, o `undefined` mientras no se haya volcado ningún acto. */
+    readonly sesion: string | undefined;
+    /**
+     * El id con el que se abrió el HILO, que existe desde el primer instante.
+     *
+     * No es lo mismo que `sesion` y la diferencia importa: `sesion` contesta «¿hay una fila
+     * que la barra pueda marcar?», y para eso hace falta la entrada del índice, que nace al
+     * VOLCAR el primer acto — o sea al final del turno. Este contesta «¿con qué id se montó
+     * el disco de esta conversación?», y de él cuelgan el hilo del checkpointer y la carpeta
+     * de artefactos. Los ARTEFACTOS obligaron a distinguirlos: el acto que anuncia uno se
+     * emite a mitad de turno, así que su enlace se pulsa mucho antes de que `sesion` exista,
+     * y con el otro id el visor habría contestado «no existe» durante todo el turno.
+     */
+    readonly idDeHilo: string;
+    /**
+     * Reabierta, SIN memoria del hilo y todavía sin turno nuevo. Las tres condiciones: desde
+     * que hay checkpointer persistente, reabrir una sesión con checkpoint continúa la
+     * conversación de verdad y no se marca nada. Deja de serlo en el PRIMER turno nuevo, no al
+     * primer acto: un `/ayuda` no convierte en presente una conversación que el modelo no
+     * recuerda.
+     */
+    readonly historica: boolean;
+    /**
+     * Qué había sin commitear en el proyecto en el INSTANTE de abrir esta consola, para
+     * poder decirlo. `undefined` = no se ha podido mirar (sin `sinCommitear` inyectado, o la
+     * medida falló), y entonces no se afirma nada.
+     *
+     * Es una promesa y no un valor porque abrir no espera a git —igual que la foto del
+     * antes—, y está CACHEADA: el alta se emite en los dos flancos de cada turno y la
+     * respuesta es de un instante que ya pasó, así que volver a medir daría otra foto y
+     * contaría como «tuyo» lo que esta sesión escribió. No rechaza nunca.
+     */
+    readonly trabajoAlAbrir: Promise<TrabajoSinCommitear | undefined>;
+    /**
+     * Con qué dispositivo trabaja esta sesión. Ausente = ninguno elegido.
+     *
+     * Vive AQUÍ y no solo en el índice porque el id de la sesión no existe hasta que se vuelca
+     * el primer acto: elegir dispositivo en una sesión recién abierta no tiene entrada que
+     * escribir, así que se queda en memoria y se anota en cuanto `volcar()` la crea. Es la
+     * misma forma de `sesionActiva` y por el mismo motivo.
+     */
+    readonly dispositivo: DispositivoElegido | undefined;
+    /** Elige —o quita, con `undefined`— el dispositivo preferido de esta sesión. */
+    elegirDispositivo(dispositivo: DispositivoElegido | undefined): void;
+    /**
+     * Liga esta sesión a un ticket de Jira (IXCODE-11).
+     *
+     * Misma forma que `elegirDispositivo`: si la sesión todavía no está en el índice —se abre
+     * ANTES del primer mensaje—, la elección se queda en memoria y `volcar()` la estampa en
+     * cuanto crea la entrada. Sin `undefined` a propósito: todavía no hay forma de desligar un
+     * ticket, nadie la pidió.
+     */
+    fijarTicket(ticket: TicketDeSesion): void;
+    /** El ticket ligado, si lo hay (Task 10, IXCODE-11): lo lee `atenderGestor` para saber a
+     *  qué tarea escribir «borradorDeCierre»/«cerrar». Ausente = esta sesión no tiene ninguna. */
+    readonly ticket: TicketDeSesion | undefined;
+    readonly cerrada: boolean;
+    /**
+     * Si esta consola tiene un turno EN VUELO ahora mismo.
+     *
+     * Existe porque desde que hay más de una consola humana viva a la vez hay dos decisiones
+     * que dependen de ello y no se pueden tomar desde fuera: no se cierra una consola de
+     * segundo plano mientras su agente trabaja, y no se abre otra sesión del MISMO proyecto
+     * mientras la que hay está escribiendo en esa copia de trabajo. Lo sabe el envoltorio del
+     * ejecutor, que es el único sitio que ve los dos flancos.
+     */
+    readonly turnoEnVuelo: boolean;
+    /** Hay turno en vuelo Y la sesión sabe DETENER y replanificar: lo que pinta el botón. */
+    readonly turnoDetenible: boolean;
+    /**
+     * Hay una pregunta de TEXTO LIBRE esperando a alguien en esta consola. Las de `decision`
+     * (la subida y sus diálogos) no cuentan. Ver `ConsolaWeb.hayPreguntaDeTextoPendiente`.
+     */
+    readonly preguntaPendiente: boolean;
+    readonly consola: ConsolaWeb;
+    /**
+     * Para el turno en vuelo sin cerrar la sesión (`SesionReal.cancelar`). Devuelve si había
+     * algo que parar: sin sesión real —el ejecutor guionizado, o un turno que ya terminó— no
+     * hay nada, y decirlo es mejor que fingir que se paró algo.
+     */
+    cancelarTurno(): boolean;
+    /** Un mensaje del navegador. Está aquí para que la ruta HTTP tenga UN solo objeto con
+     *  el que hablar; quien decide el fin de la marca histórica es el envoltorio del
+     *  ejecutor, no esto — una prosa que llega a mitad de turno solo entra en la cola. */
+    recibir(mensaje: MensajeDelCliente): void;
+    /** La `respuesta` de un móvil de la sesión remota: ver `ConsolaWeb.responderDesdeElMovil`. */
+    responderDesdeElMovil(texto: string): boolean;
+    conectar(enviar?: Sumidero): readonly Acto[];
+    /** Se va UN cliente (el suyo) o todos. Ver `Transporte`: la consola solo da por perdido
+     *  al humano cuando se va el ÚLTIMO. */
+    desconectar(enviar?: Sumidero): void;
+    /**
+     * El cable se MUDA a otra consola: esta suelta sus sumideros y nada más.
+     *
+     * No es `desconectar()`, y la diferencia es toda la razón de que exista. `desconectar`
+     * significa «se ha ido el humano»: despierta a todo el que esperaba respuesta con la
+     * cadena vacía y da por rechazada la aprobación que hubiera delante. Eso es cierto cuando
+     * el SSE se cae, y es FALSO cuando alguien cambia de sesión en la barra teniendo esta con
+     * un turno corriendo — la persona sigue ahí, solo que mirando otra cosa. Con `soltar`,
+     * esta consola sigue ATENDIDA (`eof()` sigue diciendo que hay alguien), así que su
+     * aprobación espera su plazo en vez de rechazarse sola, y al volver el foco se le reemite
+     * (`mensajesDeAprobacion`).
+     */
+    soltar(enviar?: Sumidero): void;
+    /** Las aprobaciones EN VUELO de esta consola, para reemitirlas a quien vuelve. Ver
+     *  `ConsolaWeb.mensajesDeAprobacion`. */
+    mensajesDeAprobacion(): readonly MensajeAlCliente[];
+    actos(): readonly Acto[];
+    /**
+     * Apunta un acto que resolvió el SERVIDOR (una propuesta de tareas encolada o descartada) y lo
+     * GUARDA en el acto si no hay turno en vuelo —con turno, lo guarda su `volcar` al acabar—. Sin
+     * esto, encolar fuera de un turno se pintaba y se olvidaba al reabrir: la tarjeta volvía a
+     * ofrecer encolar lo ya encolado. Opcional para los dobles; la consola de verdad lo tiene.
+     */
+    anotarActo?(acto: Acto): void;
+    cerrar(): Promise<void>;
+    /**
+     * Corre UN turno sobre esta consola con la `Consola` que se le pase.
+     *
+     * Existe para las tareas de fondo, y por una razón mecánica: el lazo (`correrConsola`)
+     * consume LÍNEAS de una conversación, y una tarea no es una conversación — tiene un
+     * encargo y nada más. Sin este campo, quien abre por `abrirParaTarea` no tendría forma
+     * de correr nada: el lazo vive dentro y desde fuera solo se le pueden meter líneas.
+     *
+     * Es EXACTAMENTE la función que este objeto le pasó a `correrConsola` —el mismo objeto,
+     * y hay un test que lo asegura—, así que una corrección al turno no puede alcanzar a una
+     * puerta y no a la otra. Lo que cambia entre las dos es la `Consola` que se le da.
+     */
+    readonly ejecutarTurno: EjecutorDeTurno;
+    /**
+     * Espera a que la marca de git de esta sesión esté escrita. Devuelve en el acto si no hay
+     * ninguna pendiente (nadie volcó nada, o el proyecto no tiene git usable).
+     *
+     * Existe para el corredor de tareas, que mide si lo escrito se puede REVISAR y lo mide
+     * justo después de cerrar: `volcar()` apunta la ref sin aguardarla, y medido con git de
+     * verdad la ref todavía no estaba. La espera NO va dentro de `cerrar()` a propósito —
+     * ver `esperarMarca` en la implementación.
+     */
+    esperarMarca(): Promise<void>;
+    /** El retorno de `correrConsola`. Resuelve cuando el lazo termina (EOF o `/salir`). */
+    readonly terminada: Promise<number>;
+}
+export interface Vestibulo {
+    /** La consola SIN raíz. Es la que pinta el asistente de cuenta y las preguntas del alta. */
+    readonly consola: ConsolaWeb;
+    /** El saludo de la bienvenida. Ver `OpcionesDelVestibulo.nombre`. */
+    readonly nombre: string | undefined;
+    pasosPendientes(): Promise<PasoDelVestibulo[]>;
+    opcionesDeEntorno(): readonly OpcionDeEntorno[];
+    /**
+     * Los entornos YA REGISTRADOS (`settings.json` más lo que este vestíbulo acaba de dar
+     * de alta), no los OFRECIDOS de `opcionesDeEntorno()` — esa es la lista fija de
+     * (WebStudio, Manager, Otro) para el paso de registro del wizard, y no sirve para saber
+     * de qué entorno listar proyectos cuando quien entra ya tiene uno registrado de antes.
+     * `arranque.ts` la usa para poblar la barra al conectar sin que nadie haya elegido
+     * entorno EN esta conexión.
+     */
+    entornosRegistrados(): readonly Entorno[];
+    /**
+     * El paso 1: `asistenteDeModelo` con la consola web detrás, exigiendo elección. Devuelve
+     * lo que pasó porque quien lo conduce (`arranque.ts`) lo usa como puerta: dar por hecho
+     * un paso que nadie resolvió es exactamente lo que dejaba al usuario con el modelo de
+     * omisión sin enterarse.
+     */
+    pasoDeCuenta(): Promise<ResultadoDelAsistente>;
+    guardarCredencialDe(proveedor: Proveedor, clave: string): Promise<{
+        ruta: string;
+    }>;
+    /** Devuelve el entorno tal y como quedó REGISTRADO: el id puede no ser el que llegó
+     *  (ver `identidadDeEntorno`), y quien registra necesita el bueno para seguir. */
+    registrarEntorno(entorno: Entorno): Promise<{
+        ruta: string;
+        entorno: Entorno;
+    }>;
+    /**
+     * Quita un entorno registrado: de `settings.json`, de sus credenciales y de la lista viva.
+     * Las copias bajadas se QUEDAN. Si puede o no quitarse ahora lo decide quien llama
+     * (`core/settings.ts#motivoParaNoOlvidarEntorno`), que sabe qué hay abierto y qué tareas viven.
+     */
+    olvidarEntorno(id: string, modo?: {
+        credenciales?: boolean;
+    }): Promise<{
+        ruta: string;
+    }>;
+    /**
+     * Qué proyectos de un entorno se enseñan en la barra. Se guarda CON el entorno
+     * (`settings.json`) porque es una preferencia sobre él, y una lista vacía es una
+     * elección —«ninguno»— y no un «no lo he dicho».
+     */
+    guardarProyectosVisibles(entorno: string, proyectos: readonly string[]): Promise<{
+        ruta: string;
+    }>;
+    /**
+     * Qué proyectos de un entorno van FIJADOS arriba de la barra. Se guarda con el entorno, igual
+     * que los visibles, y es la otra lista: `Entorno.fijados`. Las dos se escriben por separado y
+     * ninguna pisa a la otra — cada una parte del entorno registrado entero.
+     */
+    guardarProyectosFijados(entorno: string, proyectos: readonly string[]): Promise<{
+        ruta: string;
+    }>;
+    /**
+     * El NOMBRE con el que se enseña un entorno —su alias—, escrito a mano.
+     *
+     * Es un RÓTULO y no un identificador: el `id` —que sale de la URL y es segmento de la
+     * carpeta del workspace— NO se toca, así que renombrar no mueve ninguna copia local ni
+     * invalida ninguna credencial. Hasta ahora el nombre solo lo ponía el servidor (ver
+     * `renombrarConElServidor`), y sin forma de escribirlo el «Otro» de un on-premise se
+     * quedaba con el host por nombre para siempre.
+     *
+     * El nombre llega SUPUESTO VÁLIDO —la regla es
+     * `core/settings.ts#motivoDeNombreDeEntornoInaceptable` y quien llama la aplica para poder
+     * contestar 409— y aun así se vuelve a comprobar AQUÍ, que es la diferencia con
+     * `olvidarEntorno`: la condición de aquél no la puede ver el puerto (depende de qué consolas
+     * y tareas viven), pero ESTE dato lo tiene delante, y es el que mal puesto no deja un entorno
+     * sin nombre sino NINGÚN entorno — `validarEntorno` descarta al cargar los que no lo tienen.
+     *
+     * Dos entornos pueden acabar llamándose igual: el nombre no es la clave, y el duplicado se
+     * ADVIERTE en la pantalla en vez de impedirse aquí.
+     */
+    renombrarEntorno(id: string, nombre: string): Promise<{
+        ruta: string;
+    }>;
+    proyectosDe(entorno: string): Promise<readonly ProyectoRemoto[]>;
+    /**
+     * Las ramas de un proyecto. Acepta la identidad ENTERA (`{id, nombre}`) además del nombre
+     * suelto, por lo mismo que `completarProyecto`: quien llama desde la web tiene el id —es
+     * lo que viaja por el cable— y el servidor abre por NOMBRE. Pasarle el id acababa en un
+     * «no hay proyecto abierto» que no nombraba al culpable, que era el argumento.
+     */
+    ramasDe(entorno: string, proyecto: string | {
+        id: string;
+        nombre: string;
+    }): Promise<string[]>;
+    /**
+     * Dónde vive (o viviría) la copia local de un proyecto de ese entorno. Se calcula, no se
+     * consulta: `rutaDeWorkspace` es la misma función que usa el alta, y por eso la respuesta
+     * vale igual para un proyecto ya bajado que para uno que no.
+     */
+    raizDeProyecto(entorno: string, proyecto: string): string;
+    /** Las sesiones guardadas de una copia local. Sin copia, lista vacía. `consumo` es el
+     *  acumulado de la sesión entera, y ausente es «no consta» — nunca cero. */
+    sesionesDe(raiz: string): {
+        id: string;
+        titulo: string;
+        ultimoTurno?: string;
+        tarea?: string;
+        consumo?: ConsumoDeTurno;
+        ticket?: TicketDeSesion;
+    }[];
+    /**
+     * Borra una sesión guardada, con su marca de git.
+     *
+     * Si la sesión es la ABIERTA, se cierra primero. El orden no es cosmético: `cerrar()`
+     * llama a `volcar()`, que anota los actos pendientes y con ello RESUCITA la entrada del
+     * índice que se acaba de borrar. Cerrando antes, lo que se borra ya no lo va a reescribir
+     * nadie — y el cliente se queda sin proyecto abierto, que es lo honesto: la conversación
+     * que estaba mirando ya no existe.
+     *
+     * Y si la sesión es la de una TAREA en curso, no se borra: se DECLINA con `motivo`. Es el
+     * mismo problema con otro dueño —una consola de tarea tiene la misma `volcar` y no está
+     * en `abierto`, así que resucitaría la entrada al siguiente turno— pero no se puede
+     * resolver igual: cerrarla sería matar un turno del agente porque alguien limpió una fila
+     * de la barra. El `motivo` no lleva ninguna ruta de la máquina: sale por el cable, que
+     * puede ir por un túnel (`--anfitrion`).
+     */
+    borrarSesion(raiz: string, id: string): Promise<{
+        borrada: boolean;
+        cerroLaAbierta: boolean;
+        motivo?: string;
+    }>;
+    /**
+     * Borra la COPIA LOCAL de un proyecto: `<workspace>/<entorno>/<proyecto>/` entera, con sus
+     * sesiones, su historial, sus artefactos y lo que no se haya subido. Lo de CloudStudio no se
+     * toca: el proyecto vuelve a «sin descargar».
+     *
+     * El mismo orden que `borrarSesion`, y por lo mismo: si hay consola sobre esa raíz se CIERRA
+     * antes —su `volcar()` reescribiría el índice que se va a borrar— y después se suelta la
+     * conexión del checkpointer, que en Windows impediría borrar la carpeta. Se DECLINA con
+     * `motivo` (`core/settings.ts#motivoParaNoBorrarCopia`) si algo escribe ahí: un turno en vuelo
+     * de persona o de tarea, o una tarea sin terminar del índice que pasa quien llama. La ruta
+     * la compone el vestíbulo: de fuera llegan el entorno y el NOMBRE, nunca una ruta.
+     */
+    borrarCopia(entorno: string, proyecto: string, tareas: readonly {
+        estado: string;
+        raiz: string;
+    }[]): Promise<{
+        borrada: boolean;
+        cerroLaAbierta: boolean;
+        motivo?: string;
+    }>;
+    /**
+     * La persona CEDE un proyecto a sus tareas de fondo («Arrancar ahora»): se cierra SU consola de esa raíz, si la hay,
+     * para que la regla de «gana la persona» deje de aplicar ahí. La conversación queda guardada y se reabre como
+     * cualquier otra. Se DECLINA con motivo si esa consola tiene un turno en marcha: cerrarla lo cortaría. Por la cola,
+     * como todo lo que abre o cierra consolas. `cerroLaAbierta` dice si era la del foco (el cable se muda).
+     */
+    cederProyecto(raiz: string): Promise<{
+        cerroLaAbierta: boolean;
+        motivo?: string;
+    }>;
+    /**
+     * Lo que se MUDARÍA al cambiar el workspace a `hacia`, o por qué no se puede ahora — sin
+     * tocar nada. La misma decisión que `mudarWorkspace` vuelve a tomar dentro de la cola: entre
+     * esta foto y el «Aceptar» de la persona el estado puede cambiar.
+     */
+    planearWorkspace(hacia: string, casaXonecode: string, tareas: readonly {
+        estado: string;
+        raiz: string;
+    }[]): {
+        mudanzas: Mudanza[];
+        motivo?: string;
+    };
+    /**
+     * CAMBIA el workspace a `hacia` MUDANDO las copias que hay en el de ahora
+     * (`agent/config/mudanzaEnDisco.ts#mudarBaseDeWorkspace`: copiar, verificar, borrar).
+     *
+     * **Ocupa la cola ENTERA mientras dura**, no solo la comprobación: si un clic en la barra o
+     * un segundo navegador reabrieran una consola en la ruta vieja a mitad de la copia, lo que
+     * escribiera se perdería al borrar el origen, y su `checkpoint.sqlite` abierto bloquearía la
+     * lápida. El motivo se RECALCULA aquí dentro (`motivoParaNoMudarWorkspace`). Luego, el orden
+     * de `borrarCopia`: se cierran las consolas en reposo de la base y DESPUÉS se sueltan sus
+     * checkpointers —en Windows un SQLite abierto no se deja copiar entero ni borrar—.
+     */
+    mudarWorkspace(opciones: {
+        hacia: string;
+        casaXonecode: string;
+        tareas: () => readonly {
+            estado: string;
+            raiz: string;
+        }[];
+        guardar: (ruta: string) => void;
+        progreso?: (p: ProgresoDeMudanza) => void;
+    }): Promise<{
+        resultado: ResultadoDeCambioDeBase;
+        cerroLaAbierta: boolean;
+    }>;
+    /** Le pone nombre a una sesión guardada. `false` si no existe o el título viene vacío. */
+    renombrarSesion(raiz: string, id: string, titulo: string): boolean;
+    /** El paso 3 completo: escribe el alta y baja la copia local. */
+    completarProyecto(eleccion: {
+        entorno: string;
+        proyecto: string | {
+            id: string;
+            nombre: string;
+        };
+        rama: string;
+    }): Promise<{
+        raiz: string;
+        ruta: string;
+    }>;
+    abrirProyecto(apertura: {
+        raiz: string;
+        sesion?: string;
+    }): Promise<ConsolaDeProyecto>;
+    /**
+     * Abrir un proyecto para una TAREA de fondo: la misma construcción, sin registrarlo como
+     * el proyecto abierto ni mudar el sumidero del cable. Ver la implementación.
+     *
+     * Con `sesion`, REABRE esa exacta en vez de abrir una en blanco — es lo que hace que
+     * reanudar una tarea (un reintento, o un feedback) siga la MISMA conversación: el
+     * checkpointer trae su memoria porque el `thread_id` es el mismo id.
+     */
+    abrirParaTarea(raiz: string, sesion?: string, adjuntos?: string, tarea?: string): Promise<ConsolaDeProyecto>;
+    /**
+     * La consola EN FOCO: la que el cable está pintando. Sigue siendo una, y por eso este
+     * método no cambia de forma — de él cuelgan las veintitantas lecturas de `arranque.ts`,
+     * que hablan todas de «la sesión que se está mirando».
+     */
+    proyectoAbierto(): ConsolaDeProyecto | undefined;
+    /**
+     * TODAS las consolas de persona vivas, la del foco incluida.
+     *
+     * Desde que cambiar de sesión no mata el turno que estaba corriendo, «abierto» y «en
+     * foco» dejaron de ser lo mismo, y hay dos preguntas que solo esta lista contesta: qué
+     * raíces están ocupadas por una persona (la guarda de «gana la persona», que con una sola
+     * consola se quedaría abierta en silencio) y qué sesiones están trabajando, que es lo que
+     * la barra pinta.
+     *
+     * Una consola por RAÍZ: nunca dos sobre la misma copia de trabajo. Ver `abrirDeVerdad`.
+     */
+    proyectosAbiertos(): readonly ConsolaDeProyecto[];
+    /**
+     * Por qué no se puede guardar a mano en esa raíz ahora mismo (`core/settings.ts
+     * #motivoParaNoEditarFichero`), o `undefined`. Mira las consolas de persona que siguen en el
+     * mapa —una cerrada con el turno vivo cuenta MIENTRAS siga ahí, pero abrir otro proyecto la poda
+     * (`cerrarLasOciosasSalvo`) y desde entonces ya no se ve: límite declarado— y las de tarea, que
+     * no salen en `proyectosAbiertos()`.
+     */
+    motivoParaNoEditar(raiz: string): string | undefined;
+    /** El usuario se va sin terminar. No escribe nada; DICE lo que ya quedó escrito. */
+    cancelar(): Promise<void>;
+    /**
+     * Se avisa cuando el estado de sesión de la consola abierta cambia — o sea, cuando
+     * cambia el modelo en vigor. UNA sola escucha, que es la del cable; se instala al montar
+     * las rutas y vale para todas las consolas de proyecto que se abran después.
+     */
+    alCambiarEstadoDeSesion(escucha: (estado: EstadoDeSesion) => void): void;
+    /**
+     * Se avisa cuando empieza y cuando acaba un turno. UNA sola escucha, como la de estado:
+     * quien monta las rutas la instala para RECORDARLO, y así puede decírselo también a quien
+     * conecte después — el mensaje del cable se emite una vez y una pestaña que llega a mitad
+     * de turno no lo vio.
+     */
+    alCambiarTurno(escucha: (activo: boolean) => void): void;
+    /**
+     * Se avisa cuando cambia lo consumido por la sesión EN FOCO. Una sola escucha, como las
+     * otras dos, y por lo mismo: quien monta las rutas la instala para poder recordarlo y
+     * decírselo también a quien conecte después.
+     */
+    alCambiarConsumo(escucha: () => void): void;
+    /**
+     * Se avisa cuando cambia algo de lo que el PANEL de la sesión remota enseña de las consolas de
+     * persona —esté cada una en foco o no; las de tarea, nunca—: nace o termina una aprobación o
+     * una pregunta de texto libre, empieza o acaba un turno, se abre o se cierra una consola, se
+     * mueve el foco, o un volcado deja actos nuevos en el índice (título, última actividad).
+     *
+     * No dice qué cambió: quien escucha vuelve a mirar (`proyectosAbiertos()`, cada
+     * `mensajesDeAprobacion()` y `preguntaPendiente`). Por eso puede saltar de más, y quien lo
+     * convierte en mensajes lo acota. A diferencia de las tres de arriba, aquí caben VARIAS
+     * escuchas: devuelve con qué darse de baja.
+     */
+    alCambiarEsperas(escucha: () => void): () => void;
+    /**
+     * Lo que lleva consumido la sesión en foco, en sus dos cuentas. `undefined` es «no se
+     * sabe» —no hay sesión abierta, o es el ejecutor de pega— y NO es cero: un contador a 0
+     * donde no consta nada es la cifra inventada de siempre.
+     */
+    consumoDeSesion(): ConsumoDeSesionPorCuenta | undefined;
+    /** Cierra el proyecto abierto y el propio vestíbulo. */
+    cerrar(): Promise<void>;
+}
+/**
+ * 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 declare function escribirProyectoEnDisco(raiz: string, datos: DatosDeProyecto): {
+    ruta: string;
+};
+/**
+ * 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 declare function conexionDeVestibulo(urlDeLaWeb?: string): Pick<OpcionesDelVestibulo, "proyectosDeEntorno" | "ramasDeProyecto">;
+/**
+ * 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 declare function identidadDeEntorno(entorno: Entorno): Entorno;
+export declare function crearVestibulo(opciones: OpcionesDelVestibulo): Vestibulo;