xonecode 0.14.1 → 0.17.0

package/dist/web/servidor/arranque.js

@@ -55,18 +55,18 @@ import { PLATAFORMAS_DE_DISPOSITIVO } from "../../core/settings.js";
 import { instalarHerramientaDeDispositivos, verificarDispositivo } from "../../agent/dispositivos/dispositivosEnMaquina.js";
 import { arrancarEmulador } from "../../agent/dispositivos/arranqueDeEmulador.js";
 import { correrPasoDeReceta } from "../../agent/dispositivos/instalacionEnMaquina.js";
-import { abrirCarpetaDelSistema } from "../../agent/config/selectorEnMaquina.js";
+import { abrirCarpetaDelSistema, abrirDirectorioDelSistema } from "../../agent/config/selectorEnMaquina.js";
 import { modelosDeMotor } from "../../agent/config/modelosDeMotor.js";
 import { parsear, compatibleConOpenAi, esProveedorPersonalizado, idDeProveedorPersonalizado, motivoDeEndpointInaceptable, motivoDeSlugInaceptable, nombreDeProveedor, PROVEEDORES, slugDesdeNombre, resolver, SIN_CREDENCIAL, PAPELES, } from "../../core/modelos.js";
 import { hayCredencial } from "../../cli/consola.js";
 import { motivoDeClaveInaceptable } from "../../core/config.js";
-import { aplicarAuth, aplicarCredencialAlProceso, cargar, guardarModeloGlobal, } from "../../agent/config/configEnDisco.js";
+import { aplicarAuth, aplicarCredencialAlProceso, cargar, guardarConectoresDeProyecto, guardarGestorDeProyecto, guardarModeloGlobal, } from "../../agent/config/configEnDisco.js";
 import { borrarCredencial, guardarCredencial } from "../../agent/config/authEnDisco.js";
 import { borrarProveedorPersonalizado, guardarProveedorPersonalizado, proveedoresPersonalizados, } from "../../agent/config/configEnDisco.js";
 import { crearCheckpointerDeProyecto, mantenimientoDelCheckpointer, } from "../../agent/sesiones/checkpointer.js";
 import { resumenDePoda } from "../../core/podaDeCheckpoint.js";
 import { cargarSettings, guardarConcurrenciaDeTareas, guardarDepurar, guardarWorkspace as guardarWorkspaceEnDisco, guardarDispositivos, guardarEntorno as guardarEntornoEnDisco, olvidarEntornoDeSettings, copiasDeEntorno, borrarCopiasDeEntorno, } from "../../agent/config/settingsEnDisco.js";
-import { dentroDelWorkspace, depuracionActiva, expandirConCasa, motivoParaNoOlvidarEntorno, motivoDeNombreDeEntornoInaceptable, motivoDeWorkspaceInaceptable, } from "../../core/settings.js";
+import { dentroDelWorkspace, depuracionActiva, expandirConCasa, mismaRuta, motivoParaNoOlvidarEntorno, motivoDeNombreDeEntornoInaceptable, motivoDeWorkspaceInaceptable, } from "../../core/settings.js";
 import { esModoDeEscritura, MODO_POR_OMISION, } from "../../core/modoDeEscritura.js";
 import { mudarWorkspaceLegado } from "../../agent/config/mudanzaEnDisco.js";
 import { elegirCarpetaEnMaquina, haySelectorDeCarpeta } from "../../agent/config/selectorEnMaquina.js";
@@ -107,8 +107,12 @@ import { baseDeWorkspaceLegada, baseDeWorkspacePorOmision, conexionDeVestibulo,
 // doblan.
 import { filaDeTarea } from "./transporte.js";
 import { esEsfuerzo, nivelesDeEsfuerzo } from "../../core/esfuerzo.js";
-import { definicionDelCable, RUTA_CALLBACK_MCP } from "../../core/conectores.js";
+import { CATALOGO_DE_CONECTORES, definicionDelCable, RUTA_CALLBACK_MCP } from "../../core/conectores.js";
 import { servicioDeConectoresCableado } from "../../agent/conectores/servicioDeConectores.js";
+import { crearGestorJira } from "../../agent/conectores/gestorJira.js";
+import { crearGestorNotion } from "../../agent/conectores/gestorNotion.js";
+import { admiteMiasDelVinculo, motivoDeProyectoInaceptable, transicionPropuesta, comentarioDeCierre, } from "../../core/gestorDeTareas.js";
+import { datosDeCierre } from "./datosDeCierre.js";
 /** Las dos rutas del cable. El cliente las tiene escritas en `apps/web/src/conexion.ts`. */
 /**
  * Cuánto se espera al aviso de «lo que ya había sin commitear» antes de anunciar sin él.
@@ -208,6 +212,86 @@ function tipoServido(mime) {
 function escaparHtml(texto) {
     return texto.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
 }
+/**
+ * El texto con cada cosa con forma de CORREO cambiada por «[correo]». Para lo que cruza el cable
+ * desde el gestor de tareas: ni correos por el cable (IXCODE-11), y el texto de error de una tool
+ * de Jira es suyo, no nuestro. La forma es deliberadamente ANCHA —algo@algo.algo sin espacios—:
+ * tachar de más en un mensaje de error cuesta poco; dejar pasar un correo, no.
+ */
+export function sinCorreos(texto) {
+    return texto.replace(/[^\s@<>()"'«»]+@[^\s@<>()"'«»]+\.[^\s@<>()"'«»]+/g, "[correo]");
+}
+/**
+ * El mensaje `gestor` con los campos que su ACCIÓN pide, o `undefined`. Llega del navegador sin
+ * tipos: `atenderGestor` confía en esta forma, así que se comprueba aquí y no dentro.
+ */
+function gestorBienFormado(m) {
+    const x = m;
+    const texto = (k) => typeof x[k] === "string";
+    switch (x.accion) {
+        case "estado":
+            return { clase: "gestor", accion: "estado" };
+        case "desvincular":
+            return { clase: "gestor", accion: "desvincular" };
+        case "sitios":
+            return texto("conector") ? { clase: "gestor", accion: "sitios", conector: x.conector } : undefined;
+        case "proyectos":
+            return texto("conector") && texto("sitio")
+                ? { clase: "gestor", accion: "proyectos", conector: x.conector, sitio: x.sitio }
+                : undefined;
+        case "buscarProyectos":
+            return texto("conector") && texto("texto")
+                ? { clase: "gestor", accion: "buscarProyectos", conector: x.conector, texto: x.texto }
+                : undefined;
+        case "describir":
+            return texto("conector") && texto("proyecto")
+                ? { clase: "gestor", accion: "describir", conector: x.conector, proyecto: x.proyecto }
+                : undefined;
+        case "vincular":
+            return texto("conector") && texto("sitio") && texto("proyecto")
+                ? { clase: "gestor", accion: "vincular", conector: x.conector, sitio: x.sitio, proyecto: x.proyecto }
+                : undefined;
+        case "usarConector":
+            return texto("conector") && typeof x.usar === "boolean"
+                ? { clase: "gestor", accion: "usarConector", conector: x.conector, usar: x.usar }
+                : undefined;
+        case "pendientes":
+            if (x.texto !== undefined && !texto("texto"))
+                return undefined;
+            if (x.mias !== undefined && typeof x.mias !== "boolean")
+                return undefined;
+            return {
+                clase: "gestor",
+                accion: "pendientes",
+                ...(x.texto === undefined ? {} : { texto: x.texto }),
+                ...(x.mias === true ? { mias: true } : {}),
+            };
+        case "ficha":
+            return texto("clave") ? { clase: "gestor", accion: "ficha", clave: x.clave } : undefined;
+        case "transiciones":
+            return texto("clave") && (x.para === "empezar" || x.para === "cerrar")
+                ? { clase: "gestor", accion: "transiciones", clave: x.clave, para: x.para }
+                : undefined;
+        case "empezar": {
+            if (!texto("clave"))
+                return undefined;
+            if (x.transicion !== undefined && !texto("transicion"))
+                return undefined;
+            return { clase: "gestor", accion: "empezar", clave: x.clave, ...(x.transicion === undefined ? {} : { transicion: x.transicion }) };
+        }
+        case "borradorDeCierre":
+            return { clase: "gestor", accion: "borradorDeCierre" };
+        case "cerrar": {
+            if (!texto("comentario"))
+                return undefined;
+            if (x.transicion !== undefined && !texto("transicion"))
+                return undefined;
+            return { clase: "gestor", accion: "cerrar", comentario: x.comentario, ...(x.transicion === undefined ? {} : { transicion: x.transicion }) };
+        }
+        default:
+            return undefined;
+    }
+}
 /**
  * Monta `/eventos` y `/accion` sobre un servidor ya levantado.
  *
@@ -279,6 +363,13 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
     let proyectoElegido;
     let proyectos = [];
     let ramas = [];
+    /**
+     * De QUÉ proyecto son las `ramas` (su id). Viaja con ellas en el alta: sin esto la ventana de
+     * sesión nueva pintaba las ramas del ÚLTIMO proyecto preguntado mientras llegaban las del
+     * nuevo, y se podía empezar con la rama de otro proyecto. Se asigna DESPUÉS de la espera,
+     * junto a las ramas, y se vacía ANTES: una consulta que falla no deja la pareja cruzada.
+     */
+    let ramasDe;
     /**
      * El paso de cuenta ya conducido en ESTE proceso. Hace falta porque `origenDeTrabajo` se
      * congela al construir el vestíbulo: `pasosPendientes()` seguiría diciendo «cuenta»
@@ -448,6 +539,8 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 // Solo si el entorno lo dice: ausente es «no lo he elegido», y el cliente aplica su
                 // omisión. Mandar `[]` en su lugar sería decir «ninguno», que es otra cosa.
                 ...(e.proyectos === undefined ? {} : { proyectos: [...e.proyectos] }),
+                // Los fijados, con la misma regla: sin lista no viaja nada.
+                ...(e.fijados === undefined || e.fijados.length === 0 ? {} : { fijados: [...e.fijados] }),
                 // Cuántas copias tiene bajadas: lo que la casilla de «borrarlas también» cuenta.
                 ...(() => {
                     const copias = copiasDeEntorno(opciones.workspace?.() ?? baseDeWorkspacePorOmision(), e.id);
@@ -481,9 +574,20 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                     // qué enseña la ventana de sesión nueva, y decidirlo en el cliente exigiría
                     // que supiera dónde vive la copia local.
                     ...(hayCopiaLocal(p.nombre) ? { local: true } : {}),
+                    // La rama de la que se BAJÓ la copia (`config.json`), que la barra pinta debajo del
+                    // nombre. Solo con copia: sin ella no hay rama de nadie, y leer el fichero de una
+                    // carpeta a medias diría la de un alta que no terminó.
+                    ...(() => {
+                        if (!hayCopiaLocal(p.nombre))
+                            return {};
+                        const raiz = raizDeProyectoOSilencio(p.nombre);
+                        const rama = raiz === undefined ? undefined : cloudstudioDelProyecto(raiz)?.rama;
+                        return typeof rama === "string" && rama !== "" ? { rama } : {};
+                    })(),
                 };
             }),
             ramas,
+            ...(ramasDe === undefined || ramas.length === 0 ? {} : { ramasDe }),
             proyectoAbierto,
             ...(modo === undefined ? {} : { modo }),
             // Solo «XOneCode X.X.X», para el pie de la barra: ahí no hay sitio para el commit ni
@@ -1830,6 +1934,15 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 ...(s.tarea === undefined ? {} : { deTarea: true }),
                 ...(trabajando.has(s.id) ? { trabajando: true } : {}),
                 ...(s.consumo === undefined ? {} : { consumo: s.consumo }),
+                // Solo la CLAVE: el resto del ticket (conector, sitio) se queda en el host hasta
+                // que algo lo necesite (`SesionDelCable.ticket`). `?.` y no `===undefined`: un
+                // índice tocado a mano puede traer `ticket: null`, y esto no es sitio para tumbar
+                // la lista ENTERA de sesiones del proyecto por una entrada mal formada.
+                ...(typeof s.ticket?.clave === "string" ? { ticket: s.ticket.clave } : {}),
+                // IXCODE-15: y el CONECTOR del ticket, que es con quien se cierra (`cerrar` usa
+                // `ticket.conector`, no el gestor vinculado ahora): «Cerrar en Jira» en una sesión de una
+                // tarea de Jira aunque el proyecto ya esté vinculado a Notion. El sitio sigue en el host.
+                ...(typeof s.ticket?.clave === "string" && typeof s.ticket.conector === "string" ? { ticketConector: s.ticket.conector } : {}),
             }));
         }
         catch {
@@ -2048,6 +2161,45 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
     const anunciarAbriendo = (que) => {
         emitir(que === undefined ? { clase: "abriendo", activo: false } : { clase: "abriendo", activo: true, ...que });
     };
+    /**
+     * Lo que sigue a abrir una sesión desde el cable, sea la que la persona pidió en la barra
+     * (`atenderSesion`) o la que abre «Empezar» en el panel del proyecto (`atenderGestor`). Una
+     * sola copia: dos caminos que abren sesión con dos colas distintas dejarían a uno sin el
+     * contador limpio o sin mirar la cola de tareas.
+     */
+    const trasAbrirSesion = () => {
+        // El cable se muda a la consola del proyecto, como en el alta: sin esto el usuario
+        // mira un transcript vivo cuyas aprobaciones se rechazan solas al otro lado.
+        adjuntar();
+        /**
+         * Y el contador se REEMITE, porque el gasto es de UNA conversación.
+         *
+         * `consumo` solo viaja cuando el consumo CAMBIA (`alCambiarConsumo`), y abrir otra
+         * sesión no cambia nada: cambia de quién es la cuenta. Sin esto —medido en la pantalla
+         * del usuario— la caja seguía enseñando los tokens de la conversación anterior hasta la
+         * primera llamada al modelo de la nueva, que puede tardar.
+         *
+         * **No se usa `emitirConsumo()`, y ese es el detalle que costó el primer intento**: esa
+         * función CALLA cuando no consta la cuenta, y al abrir no consta — el `SesionReal` no se
+         * registra hasta que el primer turno lo construye. O sea que justo en el instante que
+         * hay que limpiar, la vía normal no manda nada. Aquí el cero SÍ está medido: una
+         * conversación recién abierta no ha gastado nada, y su tracker nace a cero aunque la
+         * sesión sea vieja. El cliente no pinta un cero, así que el contador desaparece.
+         *
+         * Y si la cuenta SÍ consta —volver al foco de una consola que está corriendo un turno—
+         * se manda la de verdad: mandar cero ahí borraría un contador vivo a mitad de turno.
+         */
+        const alAbrir = vestibulo.consumoDeSesion();
+        emitir({
+            clase: "consumo",
+            modelo: alAbrir?.modelo ?? SIN_CONSUMO,
+            externo: alAbrir?.externo ?? SIN_CONSUMO,
+            ventana: ventanaDeAhora(alAbrir?.contexto ?? 0),
+        });
+        // Y la cola se vuelve a mirar: este proyecto queda bloqueado para las tareas —gana la
+        // persona— y el que estuviera abierto antes acaba de quedar libre.
+        opciones.revisarTareas?.();
+    };
     const atenderSesion = async (peticion) => {
         aviso = undefined;
         // Antes de la primera espera, no después: entre el clic y aquí no hay nada que pintar.
@@ -2071,41 +2223,14 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 proyectoElegido = peticion.proyecto;
                 // La identidad ENTERA, no el id: el servidor abre por nombre. `identidad` ya está
                 // resuelta unas líneas más arriba contra el listado.
+                ramas = [];
+                ramasDe = undefined;
                 ramas = await vestibulo.ramasDe(entornoElegido, identidad ?? peticion.proyecto);
+                ramasDe = peticion.proyecto;
                 return;
             }
             await vestibulo.abrirProyecto({ raiz, ...(peticion.sesion === undefined ? {} : { sesion: peticion.sesion }) });
-            // El cable se muda a la consola del proyecto, como en el alta: sin esto el usuario
-            // mira un transcript vivo cuyas aprobaciones se rechazan solas al otro lado.
-            adjuntar();
-            /**
-             * Y el contador se REEMITE, porque el gasto es de UNA conversación.
-             *
-             * `consumo` solo viaja cuando el consumo CAMBIA (`alCambiarConsumo`), y abrir otra
-             * sesión no cambia nada: cambia de quién es la cuenta. Sin esto —medido en la pantalla
-             * del usuario— la caja seguía enseñando los tokens de la conversación anterior hasta la
-             * primera llamada al modelo de la nueva, que puede tardar.
-             *
-             * **No se usa `emitirConsumo()`, y ese es el detalle que costó el primer intento**: esa
-             * función CALLA cuando no consta la cuenta, y al abrir no consta — el `SesionReal` no se
-             * registra hasta que el primer turno lo construye. O sea que justo en el instante que
-             * hay que limpiar, la vía normal no manda nada. Aquí el cero SÍ está medido: una
-             * conversación recién abierta no ha gastado nada, y su tracker nace a cero aunque la
-             * sesión sea vieja. El cliente no pinta un cero, así que el contador desaparece.
-             *
-             * Y si la cuenta SÍ consta —volver al foco de una consola que está corriendo un turno—
-             * se manda la de verdad: mandar cero ahí borraría un contador vivo a mitad de turno.
-             */
-            const alAbrir = vestibulo.consumoDeSesion();
-            emitir({
-                clase: "consumo",
-                modelo: alAbrir?.modelo ?? SIN_CONSUMO,
-                externo: alAbrir?.externo ?? SIN_CONSUMO,
-                ventana: ventanaDeAhora(alAbrir?.contexto ?? 0),
-            });
-            // Y la cola se vuelve a mirar: este proyecto queda bloqueado para las tareas —gana la
-            // persona— y el que estuviera abierto antes acaba de quedar libre.
-            opciones.revisarTareas?.();
+            trasAbrirSesion();
         }
         catch (error) {
             aviso = error instanceof Error ? error.message : String(error);
@@ -2843,6 +2968,15 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
     const motivoLegible = (error) => typeof error === "object" && error !== null && "code" in error
         ? codigoDe(error)
         : (error instanceof Error ? error.message : String(error)).split(/\r?\n/)[0].slice(0, 200);
+    /**
+     * `motivoLegible` para el GESTOR de tareas, con los correos TACHADOS: el texto de una tool de
+     * Jira que falla llega tal cual (`servicioDeConectores.ts#ErrorDeTool`) y puede nombrar a una
+     * persona por su correo, que no cruza el cable (IXCODE-11). Se tacha ANTES de recortar: un
+     * correo cortado por el tope queda sin su punto y ya no lo reconoce ningún patrón.
+     */
+    const motivoDelGestor = (error) => typeof error === "object" && error !== null && "code" in error
+        ? codigoDe(error)
+        : sinCorreos((error instanceof Error ? error.message : String(error)).split(/\r?\n/)[0]).slice(0, 200);
     /**
      * El árbol del proyecto abierto. Sin proyecto no hay pestaña que lo pida, así que no se
      * contesta nada; sin PUERTO sí se contesta, con error: un árbol que nunca llega deja al
@@ -2914,6 +3048,507 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             emitir({ clase: "planes", error: "no se pudieron leer los planes" });
         }
     };
+    /**
+     * El gestor de tareas de cada conector, UNO por conector mientras viva este cable
+     * (IXCODE-11). La fábrica puede devolver una instancia nueva en cada llamada, y el adaptador
+     * de Jira guarda en la instancia la url pública de cada sitio —la que compone el enlace de
+     * cada tarea—, así que pedirla otra vez en cada mensaje perdería esa url. Se memoriza también
+     * el `undefined`: un conector que no es un gestor no deja de serlo entre dos mensajes.
+     */
+    const gestores = new Map();
+    const gestorDe = (conector) => {
+        if (opciones.gestorDeTareas === undefined)
+            return undefined;
+        if (!gestores.has(conector))
+            gestores.set(conector, opciones.gestorDeTareas(conector));
+        return gestores.get(conector);
+    };
+    /**
+     * Las instancias cuyo `sitios()` ya contestó en este proceso, y el nombre de cada sitio.
+     * Sin esa pregunta el adaptador no sabe la url del sitio y las tareas llegarían SIN enlace
+     * —ausente, no inventado—; con ella llegan con el suyo. Se marca solo lo que CONTESTÓ: un
+     * fallo se vuelve a intentar en la acción siguiente.
+     */
+    const conSitios = new WeakSet();
+    const nombreDelSitio = new Map();
+    const preguntarSitios = async (gestor) => {
+        const lista = (await gestor.sitios()).map((x) => ({ id: x.id, nombre: x.nombre }));
+        conSitios.add(gestor);
+        for (const x of lista)
+            nombreDelSitio.set(x.id, x.nombre);
+        return lista;
+    };
+    const asegurarSitios = async (gestor) => {
+        if (!conSitios.has(gestor))
+            await preguntarSitios(gestor);
+    };
+    /**
+     * El nombre para mostrar de cada proyecto que un gestor ha NOMBRADO en este proceso (IXCODE-15):
+     * de `proyectos` (Jira) o de `describir`/`vincular` (Notion, donde el proyecto es un
+     * `collection://…` que no se lee). Lo que no se ha oído no se inventa: el vínculo va sin él.
+     */
+    const nombreDelProyecto = new Map();
+    const claveDeProyecto = (conector, sitio, proyecto) => JSON.stringify([conector, sitio, proyecto]);
+    /**
+     * El nombre del conector tal como lo enseña el catálogo («Jira», «Notion»): los rótulos salen de
+     * aquí y no a fuego (IXCODE-15). Sin servicio, la fila del catálogo de CÓDIGO; sin fila, el id.
+     */
+    const nombreDelConector = (conector) => {
+        let catalogo = CATALOGO_DE_CONECTORES;
+        try {
+            if (servicioConectores !== undefined)
+                catalogo = servicioConectores.lista().catalogo;
+        }
+        catch {
+            // Un fichero de conectores ilegible no puede tumbar un rótulo: queda el catálogo de código.
+        }
+        return catalogo.find((c) => c.id === conector)?.nombre ?? conector;
+    };
+    /** El texto que «Empezar» deja en el compositor. Lo que no consta no se escribe: ni una
+     *  línea `undefined` por un enlace que falta, ni un párrafo vacío por una descripción vacía.
+     *  La cabecera lleva lo que se ENSEÑA (`etiqueta ?? clave`) y el gestor por su NOMBRE. */
+    const borradorDeTarea = (f, conector) => {
+        const cabecera = [`${f.etiqueta ?? f.clave} — ${f.titulo}`, `Estado: ${f.estado}`, ...(f.url === undefined ? [] : [f.url])].join("\n");
+        const descripcion = f.descripcion.trim();
+        return `Trabaja en esta tarea de ${nombreDelConector(conector)}.\n\n${cabecera}${descripcion === "" ? "" : `\n\n${descripcion}`}`;
+    };
+    /**
+     * El gestor de tareas del proyecto abierto (IXCODE-11, panel del proyecto). Mismas reglas
+     * que `atenderPlanes`: sin proyecto no se contesta; sin gestor en esta ejecución se contesta
+     * con error —un panel en «consultando…» para siempre es un fallo mudo—; y un fallo viaja
+     * sin la ruta de la máquina (`motivoLegible`: nuestra frase, o el código si es de Node).
+     *
+     * La configuración se lee y se escribe en el `config.json` del PROYECTO, nunca fusionada con
+     * la global: el vínculo y los conectores son de esta carpeta.
+     *
+     * **Cuatro acciones ESCRIBEN en Jira (Task 10), y solo esas**: `transicionar` dentro de
+     * `empezar` (con `transicion`) y dentro de `cerrar` (con `transicion`), y `comentar` dentro
+     * de `cerrar`. Las cuatro entran por un mensaje EXPLÍCITO del cliente —la persona aprobó una
+     * tarjeta—, nunca solas: `pendientes`, `transiciones` y `borradorDeCierre` son de solo
+     * LECTURA. `empezar` abre una sesión y propone un borrador; `borradorDeCierre` compone el
+     * texto de cierre de la sesión ABIERTA sin mandarlo.
+     */
+    const atenderGestor = async (m) => {
+        const abierto = vestibulo.proyectoAbierto();
+        if (abierto === undefined)
+            return;
+        const raiz = abierto.raiz;
+        // `sinCorreos` también aquí, y no solo en `motivoDelGestor`: la frase de un fallo puede
+        // llevar un texto del gestor (una clave de proyecto, un nombre de conector) sin pasar por él.
+        // El fallo de `ficha` lleva la CLAVE: con dos filas desplegadas una tras otra, el de la
+        // primera no puede acabar pintado bajo la segunda.
+        // IXCODE-15: el de `buscarProyectos` lleva el TEXTO buscado y el de `describir` la base PEDIDA,
+        // por la misma razón que la clave de `ficha`: el cliente no pinta el fallo de una búsqueda o
+        // una base que ya no tiene delante.
+        const fallo = (motivo) => emitir({
+            clase: "gestor",
+            error: {
+                accion: m.accion,
+                motivo: sinCorreos(motivo),
+                ...(m.accion === "ficha" ? { clave: m.clave } : {}),
+                ...(m.accion === "buscarProyectos" ? { texto: m.texto } : {}),
+                ...(m.accion === "describir" ? { pedido: m.proyecto } : {}),
+            },
+        });
+        if (opciones.gestorDeTareas === undefined)
+            return fallo("esta ejecución no tiene gestor de tareas");
+        const delProyecto = () => {
+            const c = cargar(raiz).config.proyecto;
+            return { conectores: c?.conectores ?? [], vinculo: c?.gestorDeTareas };
+        };
+        /**
+         * El estado del gestor del proyecto, SIN tocar la red (IXCODE-15): lo contestan `vincular`,
+         * `desvincular` y `usarConector`, y un gestor que no responde no puede colgar la casilla de un
+         * conector del chat. `admiteMias` se decidió AL VINCULAR y vive en el `config.json`
+         * (`admiteMiasDelVinculo`: lo guardado, o `true` para un Jira de antes); viaja solo con vínculo.
+         */
+        const emitirEstado = () => {
+            const { conectores, vinculo } = delProyecto();
+            const nombre = vinculo === undefined ? undefined : nombreDelSitio.get(vinculo.sitio);
+            // El nombre del proyecto se GUARDA con el vínculo (IXCODE-15) y sobrevive a un reinicio; lo
+            // oído en este proceso solo sirve de respaldo para un vínculo escrito antes de ese campo.
+            const nombreProyecto = vinculo === undefined
+                ? undefined
+                : (vinculo.nombreDelProyecto ?? nombreDelProyecto.get(claveDeProyecto(vinculo.conector, vinculo.sitio, vinculo.proyecto)));
+            const admiteMias = vinculo === undefined ? undefined : admiteMiasDelVinculo(vinculo);
+            emitir({
+                clase: "gestor",
+                estado: {
+                    conectores,
+                    ...(vinculo === undefined
+                        ? {}
+                        : {
+                            vinculo: {
+                                conector: vinculo.conector,
+                                sitio: vinculo.sitio,
+                                proyecto: vinculo.proyecto,
+                                ...(nombre === undefined ? {} : { nombreDelSitio: nombre }),
+                                ...(nombreProyecto === undefined ? {} : { nombreDelProyecto: nombreProyecto }),
+                            },
+                        }),
+                    ...(admiteMias === undefined ? {} : { admiteMias }),
+                },
+            });
+        };
+        /** Escribir el `config.json`: su error puede llevar la ruta, así que al cable va una frase fija. */
+        const guardar = (escribir) => {
+            try {
+                escribir();
+                return true;
+            }
+            catch (error) {
+                informar(`no se pudo guardar la configuración del proyecto (${codigoDe(error)})`);
+                fallo("no se pudo guardar la configuración del proyecto");
+                return false;
+            }
+        };
+        const gestorOFallo = (conector) => {
+            const g = gestorDe(conector);
+            if (g === undefined)
+                fallo(`«${conector}» no es un gestor de tareas de esta ejecución`);
+            return g;
+        };
+        /**
+         * IXCODE-15: una LECTURA que depende del vínculo del proyecto (pendientes, ficha, las
+         * transiciones de «empezar») tarda lo que tarde el gestor, y mientras tanto la persona puede
+         * vincular OTRO. La respuesta es del vínculo de ANTES: se relee el de ahora al volver y, si ya
+         * no es el mismo, la respuesta —o su fallo— se TIRA sin emitir nada. El panel ya pidió lo suyo
+         * al nuevo vínculo; fundirla pintaría filas de Jira bajo la base de Notion. `undefined` = tirada.
+         */
+        const delMismoVinculo = async (usado, leer) => {
+            const sigue = () => {
+                const ahora = delProyecto().vinculo;
+                return ahora !== undefined && ahora.conector === usado.conector && ahora.sitio === usado.sitio && ahora.proyecto === usado.proyecto;
+            };
+            try {
+                const valor = await leer();
+                return sigue() ? { valor } : undefined;
+            }
+            catch (error) {
+                if (!sigue())
+                    return undefined;
+                throw error;
+            }
+        };
+        let anunciada = false;
+        try {
+            switch (m.accion) {
+                case "estado":
+                    return emitirEstado();
+                case "sitios": {
+                    const g = gestorOFallo(m.conector);
+                    if (g === undefined)
+                        return;
+                    emitir({ clase: "gestor", sitios: { conector: m.conector, lista: await preguntarSitios(g) } });
+                    return;
+                }
+                case "proyectos": {
+                    const g = gestorOFallo(m.conector);
+                    if (g === undefined)
+                        return;
+                    const lista = (await g.proyectos(m.sitio)).map((x) => ({ clave: x.clave, nombre: x.nombre }));
+                    for (const x of lista)
+                        nombreDelProyecto.set(claveDeProyecto(m.conector, m.sitio, x.clave), x.nombre);
+                    emitir({ clase: "gestor", proyectos: { sitio: m.sitio, lista } });
+                    return;
+                }
+                // IXCODE-15, de solo LECTURA: buscar proyectos por texto (Notion: sus bases). Un gestor que
+                // no busca (Jira) lo DICE; una lista vacía afirmaría que no hay nada que se llame así.
+                case "buscarProyectos": {
+                    const g = gestorOFallo(m.conector);
+                    if (g === undefined)
+                        return;
+                    if (g.buscarProyectos === undefined)
+                        return fallo(`en ${nombreDelConector(m.conector)} los proyectos se eligen de la lista`);
+                    const lista = (await g.buscarProyectos(m.texto)).map((x) => ({ proyecto: x.proyecto, nombre: x.nombre, ...(x.ruta === undefined ? {} : { ruta: x.ruta }) }));
+                    emitir({ clase: "gestor", busqueda: { conector: m.conector, texto: m.texto, lista } });
+                    return;
+                }
+                // IXCODE-15, de solo LECTURA: lo que se entiende del esquema de un proyecto ANTES de
+                // vincularlo. `pedido` es lo que llegó (el id de la base); `esquema.proyecto` es lo que
+                // hay que mandar a `vincular` (el data source ya resuelto). Un «no vale» viaja como
+                // `motivo`, no como `error`: la acción salió bien, y la respuesta es que esa base no sirve.
+                case "describir": {
+                    const g = gestorOFallo(m.conector);
+                    if (g === undefined)
+                        return;
+                    if (g.describirProyecto === undefined)
+                        return fallo(`${nombreDelConector(m.conector)} no describe sus proyectos`);
+                    const [sitio] = await g.sitios();
+                    const d = await g.describirProyecto({ conector: m.conector, sitio: sitio?.id ?? "", proyecto: m.proyecto });
+                    if ("esquema" in d && sitio !== undefined)
+                        nombreDelProyecto.set(claveDeProyecto(m.conector, sitio.id, d.esquema.proyecto), d.esquema.nombre);
+                    emitir({ clase: "gestor", descripcion: { conector: m.conector, pedido: m.proyecto, ...d } });
+                    return;
+                }
+                case "vincular": {
+                    // La forma se comprueba ANTES de preguntar, con la regla de SU conector (IXCODE-15): la
+                    // clave de Jira entra en una JQL, el data source de Notion en un SQL.
+                    const motivo = motivoDeProyectoInaceptable(m.conector, m.proyecto);
+                    if (motivo !== undefined)
+                        return fallo(motivo);
+                    const g = gestorOFallo(m.conector);
+                    if (g === undefined)
+                        return;
+                    // Solo se escribe lo que el gestor DICE que existe: un vínculo a un proyecto que no se
+                    // ve no daría ni una pendiente, y el fallo aparecería lejos de donde se cometió. Quien
+                    // sabe DESCRIBIR (Notion) lo comprueba así —que el data source existe Y que su esquema
+                    // vale como gestor—; quien no (Jira), contra la lista de proyectos del sitio, como siempre.
+                    // `admiteMias` se DECIDE aquí, con la base ya descrita, y se guarda con el vínculo: así
+                    // `estado` no pregunta a nadie. Con esquema, solo si tiene una propiedad de persona;
+                    // sin describir (Jira), siempre —`currentUser()` no depende del proyecto—.
+                    let admiteMias = true;
+                    /** El nombre que el gestor DIJO del proyecto: se guarda con el vínculo, para mostrarlo tras un reinicio. */
+                    let nombreVisto;
+                    if (g.describirProyecto !== undefined) {
+                        if (!(await g.sitios()).some((x) => x.id === m.sitio))
+                            return fallo(`«${m.sitio}» no es un sitio de ${nombreDelConector(m.conector)}`);
+                        const d = await g.describirProyecto({ conector: m.conector, sitio: m.sitio, proyecto: m.proyecto });
+                        if ("motivo" in d)
+                            return fallo(d.motivo);
+                        if (d.esquema.proyecto !== m.proyecto)
+                            return fallo("ese proyecto no es el que se describió");
+                        nombreDelProyecto.set(claveDeProyecto(m.conector, m.sitio, m.proyecto), d.esquema.nombre);
+                        nombreVisto = d.esquema.nombre;
+                        admiteMias = d.esquema.asignado !== undefined;
+                    }
+                    else {
+                        const visibles = await g.proyectos(m.sitio);
+                        const visto = visibles.find((x) => x.clave === m.proyecto);
+                        if (visto === undefined)
+                            return fallo(`«${m.proyecto}» no está entre los proyectos de ese sitio`);
+                        nombreDelProyecto.set(claveDeProyecto(m.conector, m.sitio, m.proyecto), visto.nombre);
+                        nombreVisto = visto.nombre;
+                    }
+                    // UN gestor por proyecto (IXCODE-15): vincular uno SUSTITUYE al de antes, y el conector
+                    // del de antes deja de estar usado —el panel no tiene casilla para un gestor, así que
+                    // quedarse en `conectores` lo dejaría usado sin control que lo quite—.
+                    const { conectores, vinculo: anterior } = delProyecto();
+                    const vinculo = {
+                        conector: m.conector,
+                        sitio: m.sitio,
+                        proyecto: m.proyecto,
+                        admiteMias,
+                        ...(nombreVisto.trim() === "" ? {} : { nombreDelProyecto: nombreVisto }),
+                    };
+                    if (!guardar(() => guardarGestorDeProyecto(raiz, vinculo)))
+                        return;
+                    const sinAnterior = anterior !== undefined && anterior.conector !== m.conector ? conectores.filter((c) => c !== anterior.conector) : conectores;
+                    const nuevos = sinAnterior.includes(m.conector) ? sinAnterior : [...sinAnterior, m.conector];
+                    if (nuevos.join("\u0000") !== conectores.join("\u0000") && !guardar(() => guardarConectoresDeProyecto(raiz, nuevos)))
+                        return;
+                    return emitirEstado();
+                }
+                case "desvincular": {
+                    // Desvincular también DEJA DE USAR el conector del vínculo: el panel ya no ofrece una
+                    // casilla aparte para un gestor de tareas —vincular lo marca como usado, y esto es la
+                    // vuelta—, así que quedarse en `conectores` lo dejaría usado sin control que lo quite.
+                    const { conectores, vinculo } = delProyecto();
+                    if (!guardar(() => guardarGestorDeProyecto(raiz, undefined)))
+                        return;
+                    if (vinculo !== undefined && conectores.includes(vinculo.conector)) {
+                        if (!guardar(() => guardarConectoresDeProyecto(raiz, conectores.filter((c) => c !== vinculo.conector))))
+                            return;
+                    }
+                    return emitirEstado();
+                }
+                case "usarConector": {
+                    // Solo se AÑADE lo que esta consola conoce (`catálogo ∪ definiciones`): un id cualquiera
+                    // escrito en el config.json no sería un conector de nadie. QUITAR no se comprueba, para
+                    // poder limpiar uno que ya no existe.
+                    if (m.usar) {
+                        if (servicioConectores === undefined)
+                            return fallo("esta ejecución no tiene conectores");
+                        if (!servicioConectores.lista().catalogo.some((c) => c.id === m.conector))
+                            return fallo(`«${m.conector}» no es un conector de esta consola`);
+                    }
+                    const { conectores } = delProyecto();
+                    const nuevos = m.usar
+                        ? (conectores.includes(m.conector) ? conectores : [...conectores, m.conector])
+                        : conectores.filter((c) => c !== m.conector);
+                    if (!guardar(() => guardarConectoresDeProyecto(raiz, nuevos)))
+                        return;
+                    return emitirEstado();
+                }
+                case "pendientes": {
+                    const { vinculo } = delProyecto();
+                    if (vinculo === undefined)
+                        return fallo("este proyecto no tiene gestor de tareas");
+                    const g = gestorOFallo(vinculo.conector);
+                    if (g === undefined)
+                        return;
+                    const cuando = Date.now();
+                    const mias = m.mias === true;
+                    const leida = await delMismoVinculo(vinculo, async () => {
+                        await asegurarSitios(g);
+                        return g.pendientes(vinculo, m.texto, mias ? { mias } : undefined);
+                    });
+                    if (leida === undefined)
+                        return;
+                    const lista = leida.valor;
+                    emitir({
+                        clase: "gestor",
+                        pendientes: { cuando, ...(m.texto === undefined ? {} : { texto: m.texto }), ...(mias ? { mias: true } : {}), lista },
+                    });
+                    return;
+                }
+                // De solo LECTURA: la descripción de UNA tarea, para desplegarla en su fila. Viajan la
+                // clave y el texto y nada más —el resto de la ficha ya está en la fila—.
+                case "ficha": {
+                    const { vinculo } = delProyecto();
+                    if (vinculo === undefined)
+                        return fallo("este proyecto no tiene gestor de tareas");
+                    const g = gestorOFallo(vinculo.conector);
+                    if (g === undefined)
+                        return;
+                    const leida = await delMismoVinculo(vinculo, () => g.ficha(vinculo, m.clave));
+                    if (leida === undefined)
+                        return;
+                    const f = leida.valor;
+                    emitir({ clase: "gestor", ficha: { clave: f.clave, descripcion: f.descripcion } });
+                    return;
+                }
+                // Task 10 (IXCODE-11): la primera de las CUATRO acciones que escriben en Jira, y
+                // solo LEE —la lista de transiciones y cuál se propone—, para las dos tarjetas que
+                // van a pedir la aprobación (una tarea del cliente).
+                case "transiciones": {
+                    // Las de CIERRE se piden al conector y sitio del TICKET de la sesión, que es a donde
+                    // `cerrar` las aplica: los ids de una transición son de SU sitio, y el vínculo del
+                    // proyecto puede apuntar ya a otro —o a ninguno—.
+                    const ticket = abierto.ticket;
+                    if (m.para === "cerrar" && ticket === undefined)
+                        return fallo("esta sesión no está ligada a una tarea");
+                    const vinculo = m.para === "cerrar" && ticket !== undefined
+                        ? { conector: ticket.conector, sitio: ticket.sitio, proyecto: delProyecto().vinculo?.proyecto ?? "" }
+                        : delProyecto().vinculo;
+                    if (vinculo === undefined)
+                        return fallo("este proyecto no tiene gestor de tareas");
+                    const g = gestorOFallo(vinculo.conector);
+                    if (g === undefined)
+                        return;
+                    // Las de CIERRE van con el TICKET, que no cambia al revincular: solo las de «empezar»
+                    // (del vínculo del proyecto) se tiran si el vínculo cambió mientras se leían.
+                    const leida = m.para === "cerrar" ? { valor: await g.transiciones(vinculo, m.clave) } : await delMismoVinculo(vinculo, () => g.transiciones(vinculo, m.clave));
+                    if (leida === undefined)
+                        return;
+                    const lista = leida.valor;
+                    const propuesta = transicionPropuesta(lista, m.para)?.id;
+                    emitir({ clase: "gestor", transiciones: { clave: m.clave, para: m.para, lista, ...(propuesta === undefined ? {} : { propuesta }) } });
+                    return;
+                }
+                case "empezar": {
+                    // Con un turno en vuelo `abrirProyecto` devuelve la MISMA consola (el vestíbulo vuelve a
+                    // lo que trabaja): transicionar antes de saberlo movería el ticket en Jira y luego
+                    // contestaría «no se pudo abrir una sesión nueva». Se comprueba ANTES de tocar nada.
+                    if (abierto.turnoEnVuelo)
+                        return fallo("espera a que termine el turno");
+                    const { vinculo } = delProyecto();
+                    if (vinculo === undefined)
+                        return fallo("este proyecto no tiene gestor de tareas");
+                    const g = gestorOFallo(vinculo.conector);
+                    if (g === undefined)
+                        return;
+                    await asegurarSitios(g);
+                    // La ficha ANTES de abrir nada: si el gestor no contesta, no queda una sesión vacía.
+                    const ficha = await g.ficha(vinculo, m.clave);
+                    // La transición ANTES de abrir la sesión, y su fallo no aborta el resto: la persona
+                    // ya aprobó la tarjeta esperando entrar a trabajar, y quedarse sin sesión por un
+                    // «no se pudo transicionar» sería peor que decirlo y abrir igual con el borrador.
+                    if (m.transicion !== undefined) {
+                        try {
+                            await g.transicionar(vinculo, ficha.clave, m.transicion);
+                        }
+                        catch (error) {
+                            fallo(motivoDelGestor(error));
+                        }
+                    }
+                    const hiloDeAntes = abierto.idDeHilo;
+                    // Como en `atenderSesion`: un aviso de otra apertura no viaja en el alta de esta.
+                    aviso = undefined;
+                    // Una sesión NUEVA del mismo proyecto: el camino de `atenderSesion` sin `sesion`.
+                    const nueva = await vestibulo.abrirProyecto({ raiz });
+                    trasAbrirSesion();
+                    // El ticket se estampa solo si de verdad se abrió OTRA: estamparlo en la de antes
+                    // ligaría a la tarea una conversación que no se abrió para ella.
+                    if (nueva.raiz !== raiz || nueva.idDeHilo === hiloDeAntes)
+                        return fallo("no se pudo abrir una sesión nueva");
+                    nueva.fijarTicket({ conector: vinculo.conector, sitio: vinculo.sitio, clave: ficha.clave });
+                    // El alta ANTES que el borrador: el cliente tiene que estar ya en la sesión nueva
+                    // cuando el texto llega al compositor, o el cambio de sesión se lo llevaría.
+                    await anunciarAlta().catch(contar);
+                    anunciada = true;
+                    emitir({ clase: "gestor", borrador: { clave: ficha.clave, texto: borradorDeTarea(ficha, vinculo.conector) } });
+                    return;
+                }
+                // Las otras dos acciones que ESCRIBEN (Task 10): de la sesión ABIERTA, no del proyecto
+                // —una sesión puede seguir ligada a un ticket aunque el proyecto se haya desvinculado
+                // o vinculado a otro sitio después—, y solo con el turno ya terminado: escribir sobre
+                // una sesión que sigue trabajando compite con lo que el agente está a punto de dejar.
+                case "borradorDeCierre": {
+                    const ticket = abierto.ticket;
+                    if (ticket === undefined)
+                        return fallo("esta sesión no está ligada a una tarea");
+                    if (abierto.turnoEnVuelo)
+                        return fallo("espera a que termine el turno");
+                    const comentario = comentarioDeCierre(await datosDeCierre(raiz, abierto.idDeHilo));
+                    emitir({ clase: "gestor", cierre: { clave: ticket.clave, comentario } });
+                    return;
+                }
+                case "cerrar": {
+                    const ticket = abierto.ticket;
+                    if (ticket === undefined)
+                        return fallo("esta sesión no está ligada a una tarea");
+                    if (abierto.turnoEnVuelo)
+                        return fallo("espera a que termine el turno");
+                    if (m.comentario.trim() === "")
+                        return fallo("el comentario no puede estar vacío");
+                    const g = gestorOFallo(ticket.conector);
+                    if (g === undefined)
+                        return;
+                    // El adaptador de Jira solo mira `sitio` para comentar y transicionar
+                    // (`gestorJira.ts#comentar`/`#transicionar`), y el de Notion saca el data source de la
+                    // PROPIA página (`gestorNotion.ts#fuenteParaPagina`): el `proyecto` del vínculo del
+                    // TICKET no hace falta para escribir, así que basta con lo que la sesión guardó al
+                    // abrirse. Se completa con el del proyecto por si acaso; vacío si ya no hay vínculo.
+                    const vinculo = { conector: ticket.conector, sitio: ticket.sitio, proyecto: delProyecto().vinculo?.proyecto ?? "" };
+                    // Si `comentar` falla, la excepción sale al `catch` de fuera: NO se transiciona.
+                    await g.comentar(vinculo, ticket.clave, m.comentario);
+                    // El comentario YA está en Jira: si la transición falla, contestar `error{cerrar}`
+                    // invitaría a repetir el cierre entero —y a comentar DOS veces—. Sale `cerrado`, sin
+                    // `transicion` y con el motivo en `falloDeTransicion`.
+                    let falloDeTransicion;
+                    if (m.transicion !== undefined) {
+                        try {
+                            await g.transicionar(vinculo, ticket.clave, m.transicion);
+                        }
+                        catch (error) {
+                            falloDeTransicion = motivoDelGestor(error);
+                        }
+                    }
+                    emitir({
+                        clase: "gestor",
+                        cerrado: {
+                            clave: ticket.clave,
+                            comento: true,
+                            ...(m.transicion === undefined || falloDeTransicion !== undefined ? {} : { transicion: m.transicion }),
+                            ...(falloDeTransicion === undefined ? {} : { falloDeTransicion }),
+                        },
+                    });
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            fallo(motivoDelGestor(error));
+        }
+        finally {
+            // `empezar` pudo cambiar de sesión y fallar después: el alta dice cuál es la de ahora,
+            // igual que al final de `atenderSesion`. Si ya salió antes del borrador, no se repite. Las
+            // demás acciones no mueven el foco, y no se reanuncia nada.
+            if (m.accion === "empezar" && !anunciada)
+                await anunciarAlta().catch(contar);
+        }
+    };
     /**
      * La foto del modelo XOne del proyecto abierto. Mismas reglas que el árbol: sin proyecto no
      * se contesta, sin puerto se contesta con error —un «consultando…» eterno es un fallo mudo—,
@@ -3196,7 +3831,10 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 // alternativa a inventarse las del primero de la lista antes de que nadie elija.
                 proyectoElegido = proyecto;
                 // Igual que arriba: el servidor abre por NOMBRE, y el cable trae el id.
+                ramas = [];
+                ramasDe = undefined;
                 ramas = await vestibulo.ramasDe(entornoElegido, proyectos.find((p) => p.id === proyecto) ?? proyecto);
+                ramasDe = proyecto;
                 return;
             }
             // El proyecto que viene en ESTE mensaje, no el cacheado: lo enviado es la verdad y
@@ -3873,6 +4511,111 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "entorno" &&
+            mensaje.accion === "fijados") {
+            // El mismo trato que `visibles`: se guarda con el entorno y el alta siguiente lo trae.
+            void vestibulo
+                .guardarProyectosFijados(mensaje.entorno, mensaje.proyectos)
+                .catch(contar)
+                .finally(() => void anunciarAlta().catch(contar));
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "copiaLocal" && mensaje.accion === "resumen") {
+            // La FOTO del resumen del proyecto: lo que solo sabe el servidor, contestado en la
+            // propia respuesta —como el 409 de las negativas—, así que llega solo a quien la pidió.
+            // Del cable llega el ID; el nombre y la raíz los pone el servidor, como en `borrar`.
+            const identidad = proyectos.find((p) => p.id === mensaje.proyecto);
+            if (entornoElegido === undefined || identidad === undefined) {
+                respuesta.writeHead(409, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({ motivo: "ese proyecto no está en el listado del entorno activo" }));
+                return;
+            }
+            const raiz = vestibulo.raizDeProyecto(entornoElegido, identidad.nombre);
+            // Las tareas de ESTE proyecto las decide la RAÍZ y no el id: una tarea no lleva su
+            // entorno, y el mismo id en otro entorno —o un clon del mismo servidor con otro id—
+            // se colaría filtrando en el cliente. Viajan los ids; sus datos vivos ya están allí.
+            const tareas = (opciones.colaDeTareas?.listar() ?? [])
+                .filter((t) => mismaRuta(t.proyecto.raiz, raiz))
+                .map((t) => t.id);
+            let sync;
+            if (esProyectoEnDisco(raiz)) {
+                // La MISMA lectura que la banda de CloudStudio en Revisión, y no una segunda cuenta:
+                // dos pantallas midiendo lo mismo de dos formas acaban diciendo dos cifras.
+                const { clase: _clase, ...medida } = await lecturaDeSync(raiz);
+                sync = medida;
+            }
+            const foto = { tareas, ...(sync === undefined ? {} : { sync }) };
+            respuesta.writeHead(200, { "content-type": "application/json" });
+            respuesta.end(JSON.stringify(foto));
+            return;
+        }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "copiaLocal" && mensaje.accion === "abrirCarpeta") {
+            // Como `borrar`: del cable llega el ID, el nombre sale del listado del servidor y la
+            // ruta la compone el vestíbulo. Solo con la copia BAJADA: una carpeta a medias de un alta
+            // que falló no es «los ficheros del proyecto».
+            const identidad = proyectos.find((p) => p.id === mensaje.proyecto);
+            const negar = (motivo) => {
+                respuesta.writeHead(409, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({ motivo }));
+            };
+            if (entornoElegido === undefined || identidad === undefined) {
+                negar("ese proyecto no está en el listado del entorno activo");
+                return;
+            }
+            if (opciones.abrirCarpetaDeProyecto === undefined) {
+                negar("esta ejecución no puede abrir carpetas del sistema");
+                return;
+            }
+            const raiz = vestibulo.raizDeProyecto(entornoElegido, identidad.nombre);
+            if (!esProyectoEnDisco(raiz)) {
+                negar("ese proyecto no está descargado en este equipo");
+                return;
+            }
+            opciones.abrirCarpetaDeProyecto(raiz);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "copiaLocal" && mensaje.accion === "borrar") {
+            // Como `olvidar`: la negativa se decide AQUÍ y se ESPERA, para poder devolver el motivo
+            // con un 409 — `informar` no llega al navegador desde el vestíbulo. El nombre sale del
+            // listado del SERVIDOR para ese id: del cliente no se acepta ni un nombre ni una ruta.
+            const identidad = proyectos.find((p) => p.id === mensaje.proyecto);
+            if (entornoElegido === undefined || identidad === undefined) {
+                respuesta.writeHead(409, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({ motivo: "ese proyecto no está en el listado del entorno activo" }));
+                return;
+            }
+            let resultado;
+            try {
+                resultado = await vestibulo.borrarCopia(entornoElegido, identidad.nombre, (opciones.colaDeTareas?.listar() ?? []).map((t) => ({ estado: t.estado, raiz: t.proyecto.raiz })));
+            }
+            catch (error) {
+                contar(error);
+                resultado = { cerroLaAbierta: false, motivo: "no se pudo borrar la copia local" };
+            }
+            // Lo mismo que al borrar la sesión abierta: el cable se quedaría enganchado a una
+            // consola muerta, así que se muda al vestíbulo —el cliente pinta el escritorio—, y la
+            // raíz queda LIBRE, así que la cola de tareas se vuelve a mirar.
+            if (resultado.cerroLaAbierta) {
+                adjuntar();
+                opciones.revisarTareas?.();
+            }
+            // El alta siguiente ya trae `local` falso, y sin `proyectoActivo` si era el del foco.
+            await anunciarAlta().catch(contar);
+            if (resultado.motivo !== undefined) {
+                respuesta.writeHead(409, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({ motivo: resultado.motivo }));
+                return;
+            }
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" &&
             mensaje !== null &&
             mensaje.clase === "entorno" &&
@@ -3968,6 +4711,22 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "gestor") {
+            // Los campos se comprueban por ACCIÓN, como `modeloDelCambio`: un mensaje mal formado
+            // se contesta con su error, no revienta dentro de `atenderGestor`.
+            const bien = gestorBienFormado(mensaje);
+            if (bien === undefined) {
+                const accion = typeof mensaje.accion === "string" ? mensaje.accion : "desconocida";
+                if (vestibulo.proyectoAbierto() !== undefined)
+                    emitir({ clase: "gestor", error: { accion, motivo: "petición mal formada" } });
+            }
+            else {
+                void atenderGestor(bien).catch(contar);
+            }
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "colecciones") {
             void atenderColecciones().catch(contar);
             respuesta.writeHead(204);
@@ -4866,6 +5625,48 @@ export function ajusteDeDepuracionCableado(opciones = {}) {
 export function ajusteDeConectoresCableado(opciones) {
     return { conectores: (alCambiar) => servicioDeConectoresCableado({ casa: opciones.casa, alCambiar }) };
 }
+/**
+ * Las opciones `conectores` y `gestorDeTareas` de `montarRutas`, cableadas JUNTAS (IXCODE-11).
+ *
+ * Juntas porque el gestor de Jira llama por el MISMO servicio de conectores que `montarRutas`
+ * construye con la fábrica `conectores` —el que lleva en memoria las autorizaciones
+ * pendientes: un segundo servicio no vería la de Ajustes y pisaría su verificador PKCE—. Así
+ * que aquí se ENVUELVE esa fábrica para quedarse con el servicio que devuelve, y el gestor le
+ * llama a ese. El gestor de `"jira"` es UNO (el adaptador guarda la url de cada sitio en la
+ * instancia), y el de `"notion"` también (guarda el esquema de cada base, IXCODE-15); cualquier
+ * otro conector no es un gestor. Extraída y probada por el patrón de
+ * fallo de siempre: un literal dentro de `arrancarConsolaWeb` no lo mira ningún test.
+ */
+export function ajusteDeGestorCableado(ajuste) {
+    let servicio;
+    /** Uno por conector: el de Jira guarda la url de cada sitio, el de Notion el esquema de cada base. */
+    const gestores = new Map();
+    /** Las fábricas de los gestores conocidos (IXCODE-15: Jira y Notion). Cualquier otro conector no es un gestor. */
+    const FABRICAS = {
+        jira: crearGestorJira,
+        notion: crearGestorNotion,
+    };
+    return {
+        conectores: (alCambiar) => (servicio = ajuste.conectores(alCambiar)),
+        gestorDeTareas: (conector) => {
+            const fabrica = Object.hasOwn(FABRICAS, conector) ? FABRICAS[conector] : undefined;
+            if (fabrica === undefined)
+                return undefined;
+            let g = gestores.get(conector);
+            if (g === undefined) {
+                g = fabrica((nombre, args) => {
+                    // `montarRutas` construye el servicio al montar, antes de atender ningún mensaje; esto
+                    // solo salta si alguien usa el gestor sin haber pasado `conectores` a `montarRutas`.
+                    if (servicio === undefined)
+                        return Promise.reject(new Error("esta ejecución no tiene conectores"));
+                    return servicio.llamar(conector, nombre, args);
+                });
+                gestores.set(conector, g);
+            }
+            return g;
+        },
+    };
+}
 export function construirCorredorDeTareasCableado(opciones) {
     const disco = opciones.tareasFabrica === undefined ? undefined : opciones.tareasFabrica(opciones.informar);
     /**
@@ -5185,7 +5986,9 @@ export async function arrancarConsolaWeb(opciones) {
         ...ajusteDeDepuracionCableado(),
         // Los conectores MCP, con la MISMA disciplina: la composición extraída y probada
         // (`ajusteDeConectoresCableado`), nunca un literal aquí dentro.
-        ...ajusteDeConectoresCableado({ casa: homedir() }),
+        // Y el gestor de tareas (IXCODE-11) llama por ESE mismo servicio: los dos salen de
+        // `ajusteDeGestorCableado`, que envuelve la fábrica de conectores.
+        ...ajusteDeGestorCableado(ajusteDeConectoresCableado({ casa: homedir() })),
         // El selector nativo, solo si este sistema tiene uno. En el que no, la opción no se
         // monta y el botón no llega a existir.
         ...(haySelectorDeCarpeta()
@@ -5247,6 +6050,7 @@ export async function arrancarConsolaWeb(opciones) {
         guardarAjustesDeDispositivos: (ajustes) => void guardarDispositivos(undefined, ajustes),
         instalarHerramienta: instalarHerramientaDeDispositivos,
         abrirCarpetaDeHerramienta: abrirCarpetaDelSistema,
+        abrirCarpetaDeProyecto: abrirDirectorioDelSistema,
         verificarDispositivo,
         // Con la función REAL, y no declarada y sin pasar: es la trampa que este repo ha pagado
         // nueve veces, y la que el comentario de justo abajo describe para las cuatro del