xonecode 0.38.15 → 0.38.20

package/dist/web/servidor/arranque.js

@@ -28,14 +28,14 @@
  * en la omisión (Ollama local) con una clave de Anthropic recién escrita al lado.
  */
 import { hayMemoriaDeHilo, olvidarMemoriaDeHilo } from "../../agent/sesiones/memoriaDeHilo.js";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { lineaDeVersion } from "../../core/version.js";
 import { esperarInterrupcion } from "./interrupcion.js";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
-import { escribirAgente, leerAgente, motivoDeNombreInaceptable } from "../../core/agentes.js";
+import { conLoQueLaVentanaNoEdita, escribirAgente, leerAgente, motivoDeNombreInaceptable } from "../../core/agentes.js";
 import { motivoDeNombreDeSkillInaceptable, nombreDeSkillSugerido, } from "../../core/skills.js";
 import { borrarSkill, cargarSkills, esDeSerie as esDeSerieLaSkill, guardarSkill, instalarSkillDesdeZip, } from "../../agent/grafo/skills.js";
 import { TOPE_DEL_ZIP } from "../../core/zipDeSkill.js";
@@ -125,6 +125,9 @@ import { servicioDeConectoresCableado } from "../../agent/conectores/servicioDeC
 import { crearGestorJira } from "../../agent/conectores/gestorJira.js";
 import { crearGestorNotion } from "../../agent/conectores/gestorNotion.js";
 import { admiteMiasDelVinculo, motivoDeProyectoInaceptable, transicionPropuesta, comentarioDeCierre, } from "../../core/gestorDeTareas.js";
+import { cerrarTicket, comentarioDeEncargo, encargoConTicket, esEstado, mapeoPropuesto } from "../../core/tareasEnElGestor.js";
+import { crearSondeoDelGestor } from "../../agent/tareas/sondeoDelGestor.js";
+import { anotarAvisoEnElDisco, conReflejoAlGuardar, crearReflejoEnElGestor } from "../../agent/tareas/reflejoEnElGestor.js";
 import { datosDeCierre } from "./datosDeCierre.js";
 import { ErrorDeDescargaCortada, escribirPaquete, listarSoporte, motivoParaNoExportar } from "./soporte.js";
 import { nombreDelPaquete } from "../../core/paqueteDeSoporte.js";
@@ -242,6 +245,65 @@ function escaparHtml(texto) {
 export function sinCorreos(texto) {
     return texto.replace(/[^\s@<>()"'«»]+@[^\s@<>()"'«»]+\.[^\s@<>()"'«»]+/g, "[correo]");
 }
+/** Un error de un gestor de tareas como texto que puede cruzar el cable y quedarse en una tarea: de Node solo el
+ *  `code`, y del resto la primera línea con los correos TACHADOS y recortada (la regla de `motivoDelGestor`). */
+export function motivoDeGestorParaElCable(error) {
+    return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string"
+        ? error.code
+        : sinCorreos((error instanceof Error ? error.message : String(error)).split(/\r?\n/)[0]).slice(0, 200);
+}
+/**
+ * Lo que lleva el comentario de cierre de una tarea: lo mismo que el «Cerrar en …» de un chat sobre SU conversación
+ * (ficheros y commits de la sesión, el último veredicto del verificador, la última respuesta). Sin conversación, o si
+ * no se puede leer, un cierre sin datos —«no corrió», nunca un «verde» inventado—.
+ */
+/**
+ * Las copias locales con el DISPARO del gestor encendido (la puerta 2): `<workspace>/<entorno>/<proyecto>` con su
+ * `config.json`, de donde salen su identidad (`cloudstudio.proyecto`: el id con el que la pestaña Tareas filtra) y su
+ * vínculo. Se relee en cada pasada: el interruptor se cambia con todo en marcha. Lo que no se puede leer se salta.
+ */
+export function copiasConGestor(base) {
+    const copias = [];
+    const carpetas = (ruta) => {
+        try {
+            return readdirSync(ruta, { withFileTypes: true })
+                .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+                .map((e) => e.name);
+        }
+        catch {
+            return [];
+        }
+    };
+    for (const entorno of carpetas(base)) {
+        for (const nombre of carpetas(join(base, entorno))) {
+            const raiz = join(base, entorno, nombre);
+            if (!existsSync(join(raiz, ".xonecode", "config.json")))
+                continue;
+            try {
+                const c = cargar(raiz).config.proyecto;
+                const vinculo = c?.gestorDeTareas;
+                const identidad = c?.cloudstudio?.proyecto;
+                if (vinculo?.automatico !== true || identidad === undefined)
+                    continue;
+                copias.push({ proyecto: { id: identidad.id, raiz, nombre: identidad.nombre }, vinculo });
+            }
+            catch {
+                // Un config.json roto no para a los demás proyectos.
+            }
+        }
+    }
+    return copias;
+}
+export async function datosDeCierreDeTarea(tarea) {
+    if (tarea.sesion === undefined)
+        return { ficheros: [], commits: [] };
+    try {
+        return await datosDeCierre(tarea.proyecto.raiz, tarea.sesion);
+    }
+    catch {
+        return { ficheros: [], commits: [] };
+    }
+}
 /**
  * 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.
@@ -962,11 +1024,17 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 // mismo fichero que se puede editar a mano, así que el cargador es la única
                 // autoridad sobre si vale. Si no pasara, el agente desaparecería al siguiente
                 // arranque sin que nadie hubiera hecho nada raro.
-                const candidato = {
+                /**
+                 * Los campos que la ventana no edita (`escribeEn`, `llama`, `espera`, `pensamiento`) no viajan por el cable: se
+                 * toman del agente que la persona tenía DELANTE —el en vigor con ese nombre, o el de antes en un renombrado—, o
+                 * el guardado los borraría (`core/agentes.ts#conLoQueLaVentanaNoEdita`).
+                 */
+                const previo = cargarAgentes(abierto?.raiz).agentes.find((a) => a.nombre === (renombrandoDe ?? mensaje.agente.nombre));
+                const candidato = conLoQueLaVentanaNoEdita(previo, {
                     ...mensaje.agente,
                     motor: mensaje.agente.motor,
                     origen: mensaje.ambito,
-                };
+                });
                 const comprobado = leerAgente(candidato.nombre, escribirAgente(candidato), mensaje.ambito);
                 if ("error" in comprobado) {
                     informar(`no se guarda «${candidato.nombre}»: ${comprobado.error}`);
@@ -1640,7 +1708,10 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      * que la propia ruta de subida aplica: forma de segmento llano, y que no sea ya una
      * tarea.
      */
-    borrador) => {
+    borrador, 
+    /** El ticket del gestor YA creado (`atenderCrearTareaEnGestor`): se copia a la tarea antes de guardarla, porque
+     *  guardar dispara al corredor y el reflejo de «empezar» tiene que encontrarlo. */
+    ticket) => {
         if (opciones.colaDeTareas === undefined)
             return undefined;
         const proyecto = proyectoParaTarea(proyectoId);
@@ -1668,10 +1739,88 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             adjuntos: opciones.colaDeTareas.listarAdjuntos(id),
             estado: "nuevo",
             creada: new Date().toISOString(),
+            ...(ticket === undefined ? {} : { ticket }),
         };
         opciones.colaDeTareas.guardar([...lista, nueva]);
         return { id: nueva.id };
     };
+    /**
+     * El gestor en el que vivirá una tarea NUEVA de ese proyecto, si lo tiene: su vínculo (del `config.json` del PROYECTO,
+     * leído aquí y no dicho por el cliente: la ventana se abre también desde el escritorio para otro proyecto) y un
+     * gestor que sabe CREAR. Sin vínculo, o con un gestor sin `crear`, `undefined` y la tarea se encola en local como
+     * siempre (límite declarado: lo dice la ventana).
+     */
+    const gestorParaTareaNueva = (proyectoId) => {
+        const proyecto = proyectoParaTarea(proyectoId);
+        if (proyecto === undefined)
+            return undefined;
+        let vinculo;
+        try {
+            vinculo = cargar(proyecto.raiz).config.proyecto?.gestorDeTareas;
+        }
+        catch {
+            return undefined;
+        }
+        if (vinculo === undefined)
+            return undefined;
+        const gestor = gestorDe(vinculo.conector);
+        if (gestor?.crear === undefined)
+            return undefined;
+        return { proyecto, vinculo, gestor: gestor };
+    };
+    /**
+     * Crear una tarea EN el gestor (`docs/superpowers/specs/2026-10-15-tareas-desde-el-gestor-design.md`, puerta 1): el
+     * ticket primero, luego el encargo como comentario, y SOLO entonces la tarea local con el ticket puesto. Si el gestor
+     * no deja crear, NO se crea la tarea local —con vínculo, una tarea que no está en el gestor es justo lo que se
+     * pierde— y se contesta 409 con el motivo. Si el ticket se creó pero el comentario no, la tarea se crea igual y se
+     * dice: el ticket ya existe.
+     */
+    const atenderCrearTareaEnGestor = async (destino, peticion, encargo, borrador) => {
+        if (opciones.colaDeTareas === undefined)
+            return { estado: 409, cuerpo: { motivo: "esta ejecución no tiene cola de tareas" } };
+        // El borrador se comprueba ANTES de tocar el gestor: un ticket creado para una tarea que luego no se guarda quedaría huérfano.
+        if (borrador !== undefined && !esBorradorLibre(borrador, opciones.colaDeTareas.listar())) {
+            return { estado: 409, cuerpo: { motivo: "ese borrador de adjuntos no vale (o ya es una tarea)" } };
+        }
+        const { gestor, vinculo } = destino;
+        // Solo para que el ticket llegue con su enlace: sin la url del sitio se crea igual, sin `url`.
+        await asegurarSitios(gestor).catch(() => { });
+        let creada;
+        try {
+            creada = await gestor.crear(vinculo, { titulo: tituloDeTarea(peticion), descripcion: peticion });
+        }
+        catch (error) {
+            return { estado: 409, cuerpo: { motivo: `no se pudo crear la tarea en el gestor: ${motivoDelGestor(error)}` } };
+        }
+        let aviso;
+        try {
+            await gestor.comentar(vinculo, creada.clave, comentarioDeEncargo(encargo));
+        }
+        catch (error) {
+            aviso = `se creó ${creada.clave}, pero no se pudo subir el encargo: ${motivoDelGestor(error)}`;
+        }
+        const ticket = {
+            conector: vinculo.conector,
+            sitio: vinculo.sitio,
+            proyecto: vinculo.proyecto,
+            clave: creada.clave,
+            ...(creada.url === undefined ? {} : { url: creada.url }),
+            ...(aviso === undefined ? {} : { aviso }),
+            // El mapeo de estados del vínculo, COPIADO: a qué estado pasa al empezar y al terminar.
+            ...(vinculo.estados === undefined ? {} : { estados: vinculo.estados }),
+        };
+        // Con la línea del ticket delante (`encargoConTicket`): en Jira el comentario lleva el encargo SIN ella —ya está en el ticket—.
+        const nueva = atenderCrearTarea(destino.proyecto.id, peticion, encargoConTicket(encargo, ticket), borrador, ticket);
+        if (nueva === undefined) {
+            return { estado: 409, cuerpo: { motivo: `se creó ${creada.clave} en el gestor, pero no la tarea local: créala de nuevo o bórrala allí` } };
+        }
+        opciones.revisarTareas?.();
+        emitirTareas();
+        return {
+            estado: 200,
+            cuerpo: { id: nueva.id, ticket: { clave: creada.clave, ...(creada.url === undefined ? {} : { url: creada.url }) }, ...(aviso === undefined ? {} : { aviso }) },
+        };
+    };
     /**
      * ¿Se puede adoptar ese id de borrador? Segmento llano Y que no sea ya una tarea.
      *
@@ -3671,6 +3820,9 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                                 proyecto: vinculo.proyecto,
                                 ...(nombre === undefined ? {} : { nombreDelSitio: nombre }),
                                 ...(nombreProyecto === undefined ? {} : { nombreDelProyecto: nombreProyecto }),
+                                ...(vinculo.estados === undefined ? {} : { estados: vinculo.estados }),
+                                ...(vinculo.automatico === true ? { automatico: true } : {}),
+                                ...(vinculo.revisarEncargo === true ? { revisarEncargo: true } : {}),
                             },
                         }),
                     ...(admiteMias === undefined ? {} : { admiteMias }),
@@ -3817,6 +3969,15 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                         proyecto: m.proyecto,
                         admiteMias,
                         ...(nombreVisto.trim() === "" ? {} : { nombreDelProyecto: nombreVisto }),
+                        // Volver a vincular el MISMO proyecto del gestor conserva su mapeo de estados y su disparo; otro proyecto
+                        // tiene otro flujo, y empieza sin ellos (apagado).
+                        ...(anterior !== undefined && anterior.conector === m.conector && anterior.sitio === m.sitio && anterior.proyecto === m.proyecto
+                            ? {
+                                ...(anterior.estados === undefined ? {} : { estados: anterior.estados }),
+                                ...(anterior.automatico === true ? { automatico: true } : {}),
+                                ...(anterior.revisarEncargo === true ? { revisarEncargo: true } : {}),
+                            }
+                            : {}),
                     };
                     if (!guardar(() => guardarGestorDeProyecto(raiz, vinculo)))
                         return;
@@ -3998,20 +4159,10 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                     // 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);
-                        }
-                    }
+                    // La secuencia de `core/tareasEnElGestor.ts#cerrarTicket`, la MISMA que cierra una tarea en background: si
+                    // `comentar` falla, sale al `catch` de fuera y NO se transiciona; si falla la transición, el comentario YA está
+                    // y sale `cerrado` sin `transicion` y con el motivo (contestar `error{cerrar}` invitaría a comentar DOS veces).
+                    const { falloDeTransicion } = await cerrarTicket(g, vinculo, ticket.clave, m.comentario, m.transicion, motivoDelGestor);
                     emitir({
                         clase: "gestor",
                         cerrado: {
@@ -5049,14 +5200,34 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             responder(403, "ese nombre no es de un artefacto");
             return;
         }
-        const abierto = vestibulo.proyectoAbierto();
-        if (abierto === undefined || opciones.leerArtefactoCrudo === undefined) {
+        // Sin `p` y `s`, el de la conversación ABIERTA. Con ellos, el de ESA conversación, que se está LEYENDO sin
+        // consola (una tarea finalizada, IXCODE-36): resuelta por el servidor como `leerSesion`, nunca por el texto.
+        let origen;
+        const pedidoProyecto = query.get("p");
+        const pedidaSesion = query.get("s");
+        if (pedidoProyecto !== null || pedidaSesion !== null) {
+            const resuelta = sesionDelDisco(pedidoProyecto, pedidaSesion);
+            if ("motivo" in resuelta) {
+                responder(404, "no hay artefacto");
+                return;
+            }
+            origen = resuelta;
+        }
+        else {
+            const abierto = vestibulo.proyectoAbierto();
+            if (abierto === undefined) {
+                responder(404, "no hay artefacto");
+                return;
+            }
+            origen = { raiz: abierto.raiz, sesion: abierto.idDeHilo };
+        }
+        if (opciones.leerArtefactoCrudo === undefined) {
             responder(404, "no hay artefacto");
             return;
         }
         let leido;
         try {
-            leido = await opciones.leerArtefactoCrudo(abierto.raiz, abierto.idDeHilo, nombre);
+            leido = await opciones.leerArtefactoCrudo(origen.raiz, origen.sesion, nombre);
         }
         catch (error) {
             // El mensaje de Node lleva la ruta absoluta: al cliente solo le llega el código, y a
@@ -5114,6 +5285,23 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         });
         respuesta.end(leido.datos);
     });
+    /**
+     * Una conversación de un proyecto, resuelta por el SERVIDOR a partir de los IDS que llegan del cable: el nombre
+     * sale del listado del entorno activo, la raíz la compone el vestíbulo y la sesión tiene que estar en el ÍNDICE
+     * del DISCO de ese proyecto. Nunca se lee nada que el cliente nombre. La comparten `leerSesion` y los artefactos
+     * de una conversación que se LEE sin consola (una tarea finalizada): dos copias de esta barrera divergirían.
+     */
+    const sesionDelDisco = (proyecto, sesion) => {
+        const identidad = proyectos.find((p) => p.id === proyecto);
+        if (entornoElegido === undefined || identidad === undefined)
+            return { motivo: "ese proyecto no está en el listado del entorno activo" };
+        const raiz = vestibulo.raizDeProyecto(entornoElegido, identidad.nombre);
+        if (!esProyectoEnDisco(raiz))
+            return { motivo: "ese proyecto no está descargado en este equipo" };
+        if (typeof sesion !== "string" || !listarSesiones(raiz).some((s) => s.id === sesion))
+            return { motivo: "esa conversación no está en el proyecto" };
+        return { raiz, sesion };
+    };
     /**
      * Lo que la pestaña Soporte necesita de UN proyecto, compuesto por el SERVIDOR a partir del
      * id: la raíz sale del listado del entorno activo (como `resumen` y `borrar`), las tareas se
@@ -6008,20 +6196,13 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 respuesta.writeHead(409, { "content-type": "application/json" });
                 respuesta.end(JSON.stringify({ motivo }));
             };
-            const identidad = proyectos.find((p) => p.id === mensaje.proyecto);
-            const sesion = mensaje.sesion;
-            if (entornoElegido === undefined || identidad === undefined)
-                return negar("ese proyecto no está en el listado del entorno activo");
-            const raiz = vestibulo.raizDeProyecto(entornoElegido, identidad.nombre);
-            if (!esProyectoEnDisco(raiz))
-                return negar("ese proyecto no está descargado en este equipo");
             // El índice del DISCO, la misma fuente que lee `reabrirSesion` justo debajo.
-            if (typeof sesion !== "string" || !listarSesiones(raiz).some((s) => s.id === sesion)) {
-                return negar("esa conversación no está en el proyecto");
-            }
+            const resuelta = sesionDelDisco(mensaje.proyecto, mensaje.sesion);
+            if ("motivo" in resuelta)
+                return negar(resuelta.motivo);
             let actos;
             try {
-                actos = reabrirSesion(raiz, sesion).actos;
+                actos = reabrirSesion(resuelta.raiz, resuelta.sesion).actos;
             }
             catch (error) {
                 contar(error);
@@ -6210,6 +6391,82 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "gestor" &&
+            (mensaje.accion === "estadosDelFlujo" || mensaje.accion === "ajustarVinculo")) {
+            /**
+             * El MAPEO de estados y el disparo del vínculo del proyecto ABIERTO (la puerta 2), contestados en la propia
+             * respuesta. `estadosDelFlujo` lee del gestor los estados de su flujo y propone el mapeo por categoría;
+             * `ajustarVinculo` lo guarda, comprobando que cada estado elegido EXISTE en ese flujo —un nombre que no está
+             * dejaría el disparo mudo—, y vuelve a emitir el estado del gestor.
+             */
+            const negar = (motivo) => {
+                respuesta.writeHead(409, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({ motivo }));
+            };
+            const abierto = vestibulo.proyectoAbierto();
+            if (abierto === undefined)
+                return negar("no hay ningún proyecto abierto");
+            let vinculo;
+            try {
+                vinculo = cargar(abierto.raiz).config.proyecto?.gestorDeTareas;
+            }
+            catch {
+                return negar("no se pudo leer la configuración del proyecto");
+            }
+            if (vinculo === undefined)
+                return negar("este proyecto no tiene un gestor de tareas vinculado");
+            const g = gestorDe(vinculo.conector);
+            if (g?.estados === undefined)
+                return negar("este gestor no sabe decir los estados de su flujo");
+            let lista;
+            try {
+                lista = await g.estados(vinculo);
+            }
+            catch (error) {
+                return negar(`no se pudieron leer los estados: ${motivoDelGestor(error)}`);
+            }
+            if (mensaje.accion === "estadosDelFlujo") {
+                respuesta.writeHead(200, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({ lista, propuesto: mapeoPropuesto(lista), ...(vinculo.estados === undefined ? {} : { actual: vinculo.estados }) }));
+                return;
+            }
+            const pedido = mensaje;
+            if (pedido.revisarEncargo !== undefined && typeof pedido.revisarEncargo !== "boolean")
+                return negar("petición mal formada");
+            if (typeof pedido.automatico !== "boolean" || typeof pedido.estados !== "object" || pedido.estados === null) {
+                return negar("petición mal formada");
+            }
+            const estados = {};
+            for (const papel of ["preparar", "lanzar", "terminar"]) {
+                const e = pedido.estados[papel];
+                if (e === undefined || e === "")
+                    continue;
+                if (typeof e !== "string" || !lista.some((x) => esEstado(x.nombre, e)))
+                    return negar(`«${String(e)}» no es un estado del flujo de este proyecto`);
+                estados[papel] = lista.find((x) => esEstado(x.nombre, e)).nombre;
+            }
+            // Encender el disparo pide saber cuándo LANZAR: sin ese estado no haría nada y parecería roto.
+            if (pedido.automatico && estados.lanzar === undefined)
+                return negar("para encender el disparo, elige el estado que lanza la tarea");
+            const { estados: _antes, automatico: _a, revisarEncargo: _r, ...resto } = vinculo;
+            try {
+                guardarGestorDeProyecto(abierto.raiz, {
+                    ...resto,
+                    ...(Object.keys(estados).length === 0 ? {} : { estados }),
+                    ...(pedido.automatico ? { automatico: true } : {}),
+                    ...(pedido.revisarEncargo === true ? { revisarEncargo: true } : {}),
+                });
+            }
+            catch (error) {
+                return negar(`no se pudo guardar en la configuración del proyecto (${codigoDe(error) ?? "su config.json no se puede leer"})`);
+            }
+            void atenderGestor({ clase: "gestor", accion: "estado" }).catch(contar);
+            respuesta.writeHead(204);
+            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`.
@@ -6272,6 +6529,36 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "artefacto" &&
+            typeof mensaje.nombre === "string" &&
+            (mensaje.proyecto !== undefined || mensaje.sesion !== undefined)) {
+            // El artefacto de una conversación que se LEE sin consola: se contesta en la PROPIA respuesta y no por el cable,
+            // donde el store lo guardaría por ruta y pisaría el de la conversación abierta con el mismo nombre.
+            const resuelta = sesionDelDisco(mensaje.proyecto, mensaje.sesion);
+            const negar = (motivo) => {
+                respuesta.writeHead(409, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify({ motivo }));
+            };
+            if ("motivo" in resuelta)
+                return negar(resuelta.motivo);
+            if (!esRutaDeArtefacto(`${RUTA_ARTEFACTOS}${mensaje.nombre}`))
+                return negar("ese nombre no es de un artefacto");
+            if (opciones.leerArtefacto === undefined)
+                return negar("esta ejecución no puede leer los artefactos");
+            let fichero;
+            try {
+                fichero = await opciones.leerArtefacto(resuelta.raiz, resuelta.sesion, mensaje.nombre);
+            }
+            catch (error) {
+                informar(`no se pudo leer el artefacto «${mensaje.nombre}» (${codigoDe(error)})`);
+                return negar("no se pudo leer el artefacto");
+            }
+            respuesta.writeHead(200, { "content-type": "application/json" });
+            respuesta.end(JSON.stringify(fichero));
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "artefacto" && typeof mensaje.nombre === "string") {
             void atenderArtefacto(mensaje.nombre).catch(contar);
             respuesta.writeHead(204);
@@ -6423,6 +6710,34 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 respuesta.end();
                 return;
             }
+            if (mensaje.accion === "mirarGestor") {
+                // «Mirar ahora»: una pasada del sondeo de la puerta 2, contestada con lo que hizo. Solo lo hace el proceso que
+                // ejecuta las tareas; en otro, el sondeo no hace nada y lo dice el resultado vacío.
+                if (opciones.mirarGestor === undefined) {
+                    respuesta.writeHead(409, { "content-type": "application/json" });
+                    respuesta.end(JSON.stringify({ motivo: "esta ejecución no mira el gestor de tareas" }));
+                    return;
+                }
+                const r = await opciones.mirarGestor();
+                emitirTareas();
+                respuesta.writeHead(200, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify(r));
+                return;
+            }
+            if (mensaje.accion === "destino") {
+                /**
+                 * Dónde vivirá una tarea NUEVA de ese proyecto: con qué gestor, si lo tiene vinculado y sabe crear. Lo pregunta la
+                 * ventana «Nueva tarea» al abrirse para decir ANTES del clic qué se va a escribir —crear es la autorización—, y se
+                 * decide con la MISMA función que `crear`, así que lo dicho y lo hecho no pueden divergir. Ni red ni gestor: lee el
+                 * `config.json` del proyecto. Del vínculo cruza el conector y el nombre del proyecto del gestor, nunca el sitio.
+                 */
+                const destino = gestorParaTareaNueva(mensaje.proyecto);
+                respuesta.writeHead(200, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify(destino === undefined
+                    ? {}
+                    : { gestor: { conector: destino.vinculo.conector, proyecto: destino.vinculo.nombreDelProyecto ?? destino.vinculo.proyecto } }));
+                return;
+            }
             if (mensaje.accion === "regenerarEncargo" && opciones.colaDeTareas !== undefined) {
                 /**
                  * Volver a PREPARAR el encargo de una tarea que no ha arrancado, desde su petición editada
@@ -6529,6 +6844,15 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 respuesta.end(JSON.stringify({ motivo: "se está cambiando la carpeta de los proyectos: crea la tarea cuando termine" }));
                 return;
             }
+            // Con gestor vinculado, la tarea vive en él: se contesta en la propia respuesta (la ventana no se cierra hasta saber
+            // si el gestor la creó). Sin él, el camino de siempre.
+            const enGestor = mensaje.accion === "crear" ? gestorParaTareaNueva(mensaje.proyecto) : undefined;
+            if (mensaje.accion === "crear" && enGestor !== undefined) {
+                const r = await atenderCrearTareaEnGestor(enGestor, mensaje.peticion, mensaje.encargo, mensaje.borrador);
+                respuesta.writeHead(r.estado, { "content-type": "application/json" });
+                respuesta.end(JSON.stringify(r.cuerpo));
+                return;
+            }
             if (mensaje.accion === "crear" && opciones.colaDeTareas !== undefined) {
                 const creada = atenderCrearTarea(mensaje.proyecto, mensaje.peticion, mensaje.encargo, mensaje.borrador);
                 if (creada !== undefined) {
@@ -7098,6 +7422,40 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
     });
     return { emitirTareas, cerrarRemoto: apagarRemoto };
 }
+/**
+ * El sondeo de la puerta 2 CABLEADO: extraído de `arrancarConsolaWeb` para poder probar la composición de verdad (el
+ * patrón de fallo de siempre: una regla de producción en un cierre que todos los tests doblan). Dos cosas que solo se
+ * ven aquí: lo que el sondeo guarda va por la cola ENVUELTA (así el reflejo en el gestor dispara), y tras guardar se
+ * EMITE la cola —el corredor solo emite en sus propias escrituras, y una tarea que no puede arrancar todavía (la
+ * persona tiene la consola de ese proyecto abierta) no salía en la pantalla—. Lo que falla en una pasada, también la
+ * primera, se dice.
+ */
+export function construirSondeoCableado(o) {
+    const sondeo = crearSondeoDelGestor({
+        copias: o.copias,
+        gestorDe: o.gestorDe,
+        ...(o.augmentar === undefined ? {} : { augmentar: o.augmentar }),
+        cola: o.cola,
+        revisar: () => {
+            o.corredor.revisar();
+            o.emitirTareas();
+        },
+        esDueño: () => o.corredor.corriendoAqui(),
+        motivoDe: motivoDeGestorParaElCable,
+        informar: o.informar,
+    });
+    const decir = (r) => {
+        for (const f of r.fallos)
+            o.informar(`el gestor de ${f.proyecto}${f.clave === undefined ? "" : ` (${f.clave})`}: ${f.motivo}`);
+        if (r.preparadas.length > 0)
+            o.emitirTareas();
+    };
+    return {
+        ...sondeo,
+        // «Mirar ahora» y la pasada del arranque dicen sus fallos igual que el reloj.
+        mirar: () => sondeo.mirar().then((r) => (decir(r), r)),
+    };
+}
 /**
  * Construye el corredor de tareas y la costura que lo conecta al cable.
  *
@@ -7743,7 +8101,27 @@ export function ajusteDeGestorCableado(ajuste) {
     };
 }
 export function construirCorredorDeTareasCableado(opciones) {
-    const disco = opciones.tareasFabrica === undefined ? undefined : opciones.tareasFabrica(opciones.informar);
+    const crudo = opciones.tareasFabrica === undefined ? undefined : opciones.tareasFabrica(opciones.informar);
+    /**
+     * El almacén con el `guardar` VIGILADO: un único punto por el que pasan todos los cambios de estado (corredor,
+     * reconciliación, rutas, feedback), y de ahí el reflejo en el gestor. Envuelto AQUÍ, donde nace, para que el
+     * corredor y las rutas (`opcionesDeMontaje.colaDeTareas`) compartan el mismo.
+     */
+    const reflejo = crudo === undefined || opciones.gestorDeTareas === undefined
+        ? undefined
+        : crearReflejoEnElGestor({
+            gestorDe: opciones.gestorDeTareas,
+            datosDeCierre: opciones.datosDeCierreDeTarea ?? datosDeCierreDeTarea,
+            // Escribe en disco y AVISA al cable: el corredor solo emite en sus propias escrituras, y sin esto el aviso
+            // («no se pudo pasar KAN-1 a EN CURSO») no salía en la fila hasta que cambiara otra cosa.
+            anotarAviso: (id, aviso) => {
+                anotarAvisoEnElDisco(crudo)(id, aviso);
+                emitirCambioDeTareas?.();
+            },
+            motivoDe: motivoDeGestorParaElCable,
+            informar: opciones.informar,
+        });
+    const disco = crudo === undefined ? undefined : reflejo === undefined ? crudo : conReflejoAlGuardar(crudo, reflejo);
     /**
      * El tope de concurrencia se LEE de `settings.json` en cada llamada, nunca se cachea —la
      * misma disciplina que `ajustesDeDispositivos` (más abajo) y que `sinAprobacion`: la
@@ -7986,6 +8364,8 @@ export async function arrancarConsolaWeb(opciones) {
         vestibulo: conVestibulo,
         tareasFabrica: opciones.tareas,
         informar,
+        // El MISMO gestor memoizado que el panel: con él, una tarea con ticket se refleja en su gestor al cambiar de estado.
+        gestorDeTareas: conectoresYGestor.gestorDeTareas,
         olvidarHiloDeSesion: olvidarMemoriaDeHilo,
         /**
          * El juez de QA de las tareas, con el papel `afilado` — el que `core/modelos.ts` le
@@ -8040,6 +8420,19 @@ export async function arrancarConsolaWeb(opciones) {
         escribir(`${aviso}\n`);
         abierto.consola.consola.escribir(`${aviso}\n`);
     }
+    /** El aumentador: el de «Nueva tarea» (por las rutas) y el de preparar encargos del sondeo del gestor. Ver su
+     *  comentario en las opciones de `montarRutas`. */
+    const augmentar = augmentacionCableada({
+        aumentador: opciones.guion === true
+            ? new AumentadorGuionizado()
+            : crearAumentador({
+                invocar: (papel, prompt, raiz) => invocarParaAumentar(new Modelos(fuentesDelJuez(raiz), proveedoresPersonalizados))(papel, prompt, raiz),
+            }),
+        contexto: contextoDelProyecto,
+    });
+    /** El sondeo de la puerta 2: nace con el corredor (más abajo); «Mirar ahora» llega por las rutas, montadas antes. */
+    let sondeo;
+    const espacioDeTrabajo = ajusteDeWorkspaceCableado({ casa: homedir() });
     const cable = montarRutas(servidor, vestibulo, {
         informar,
         // El interruptor se lee de `settings.json` (o `XONECODE_REMOTO=1`) en cada uso. Sin el
@@ -8239,14 +8632,8 @@ export async function arrancarConsolaWeb(opciones) {
          * - **Con `--guion` se monta el DOBLE**, no el real: esa bandera significa «sin gastar
          *   ni conectar», y el doble dice en el propio encargo que es de pega (`[DOBLE]`).
          */
-        augmentar: augmentacionCableada({
-            aumentador: opciones.guion === true
-                ? new AumentadorGuionizado()
-                : crearAumentador({
-                    invocar: (papel, prompt, raiz) => invocarParaAumentar(new Modelos(fuentesDelJuez(raiz), proveedoresPersonalizados))(papel, prompt, raiz),
-                }),
-            contexto: contextoDelProyecto,
-        }),
+        augmentar,
+        mirarGestor: async () => sondeo?.mirar() ?? { preparadas: [], lanzadas: [], fallos: [] },
     });
     // Con las rutas ya montadas: la reconciliación y el primer despacho cambian la cola, y
     // quien conecte después la recibe entera en su ráfaga de bienvenida.
@@ -8254,6 +8641,23 @@ export async function arrancarConsolaWeb(opciones) {
     // `cable.emitirTareas` y arranca en el orden correcto, así que no hay manera de llamarlo
     // mal desde aquí.
     await arrancarCorredorConectado(cable);
+    /**
+     * La puerta 2: el gestor de tareas DISPARA tareas (`agent/tareas/sondeoDelGestor.ts`). Solo con cola y corredor, y
+     * solo hace algo en el proceso que EJECUTA las tareas. Una pasada al arrancar recoge lo que se movió con esto parado.
+     */
+    if (corredor !== undefined && opcionesDeTareas.colaDeTareas !== undefined) {
+        sondeo = construirSondeoCableado({
+            corredor,
+            cola: opcionesDeTareas.colaDeTareas,
+            copias: () => copiasConGestor(espacioDeTrabajo.workspace()),
+            gestorDe: conectoresYGestor.gestorDeTareas,
+            augmentar,
+            emitirTareas: () => cable.emitirTareas(),
+            informar,
+        });
+        sondeo.arrancar();
+        void sondeo.mirar();
+    }
     /**
      * Con qué código corre ESTE proceso, antes que la URL.
      *