xonecode 0.5.0 → 0.6.0

package/dist/web/servidor/arranque.js

@@ -33,9 +33,12 @@ 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 } from "../../core/agentes.js";
-import { borrarAgente, cargarAgentes, guardarAgente } from "../../agent/agentesEnDisco.js";
-import { detectarDispositivos, frameworkEnDispositivo } from "../../agent/dispositivosEnMaquina.js";
+import { 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";
+import { borrarAgente, cargarAgentes, esDeSerie, guardarAgente, renombrarAgente, restaurarAgente, } from "../../agent/subagentes/agentesEnDisco.js";
+import { detectarDispositivos, frameworkEnDispositivo } from "../../agent/dispositivos/dispositivosEnMaquina.js";
 /**
  * El veredicto de «¿se puede lanzar?» y el lanzamiento entero.
  *
@@ -45,41 +48,43 @@ import { detectarDispositivos, frameworkEnDispositivo } from "../../agent/dispos
  * donde puede dejar de estar montado, que es el patrón de fallo de esta casa. Lo único que este
  * lado aporta es `alFase`, que es cómo se cuenta el recorrido.
  */
-import { lanzarEnDispositivo, } from "../../agent/lanzamientoEnMaquina.js";
+import { lanzarEnDispositivo, } from "../../agent/dispositivos/lanzamientoEnMaquina.js";
 import { motivoDeBloqueo, puedeLanzarse, } from "../../core/puedeLanzarse.js";
 import { PLATAFORMAS_DE_DISPOSITIVO } from "../../core/settings.js";
-import { instalarHerramientaDeDispositivos, verificarDispositivo } from "../../agent/dispositivosEnMaquina.js";
-import { correrPasoDeReceta } from "../../agent/instalacionEnMaquina.js";
-import { modelosDeMotor } from "../../agent/modelosDeMotor.js";
+import { instalarHerramientaDeDispositivos, verificarDispositivo } from "../../agent/dispositivos/dispositivosEnMaquina.js";
+import { arrancarEmulador } from "../../agent/dispositivos/arranqueDeEmulador.js";
+import { correrPasoDeReceta } from "../../agent/dispositivos/instalacionEnMaquina.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/configEnDisco.js";
-import { borrarCredencial, guardarCredencial } from "../../agent/authEnDisco.js";
-import { borrarProveedorPersonalizado, guardarProveedorPersonalizado, proveedoresPersonalizados, } from "../../agent/configEnDisco.js";
-import { crearCheckpointerDeProyecto, hayCheckpoint, olvidarHilo, } from "../../agent/checkpointer.js";
-import { cargarSettings, guardarConcurrenciaDeTareas, guardarDispositivos, guardarEntorno as guardarEntornoEnDisco, } from "../../agent/settingsEnDisco.js";
+import { aplicarAuth, aplicarCredencialAlProceso, cargar, 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, hayCheckpoint, olvidarHilo, } from "../../agent/sesiones/checkpointer.js";
+import { cargarSettings, guardarConcurrenciaDeTareas, guardarDispositivos, guardarEntorno as guardarEntornoEnDisco, } from "../../agent/config/settingsEnDisco.js";
 import { dentroDelWorkspace, seAplicaSinAprobacion } from "../../core/settings.js";
-import { cloudstudioDelProyecto } from "../../agent/configEnDisco.js";
-import { abrirEnSistema } from "../../agent/cloudstudioMcp.js";
-import { nombreDePersona } from "../../agent/persona.js";
-import { cambiosDeSesion, fotoDeApertura, olvidarSesion, parcheDeSesion } from "../../agent/sesionGit.js";
-import { commitDeTurno, cambiosPendientes, trabajoSinCommitear } from "../../agent/gitSync.js";
+import { cloudstudioDelProyecto } from "../../agent/config/configEnDisco.js";
+import { abrirEnSistema } from "../../agent/cloudstudio/cloudstudioMcp.js";
+import { nombreDePersona } from "../../agent/config/persona.js";
+import { cambiosDeSesion, fotoDeApertura, olvidarSesion, parcheDeSesion } from "../../agent/sesiones/sesionGit.js";
+import { commitDeTurno, cambiosPendientes, trabajoSinCommitear } from "../../agent/sesiones/gitSync.js";
 import { marcarTareaDeSesion, sembrarConsumosPendientes } from "./sesiones.js";
 import { RUTA_ARTEFACTOS, esRutaDeArtefacto } from "../../core/artefactos.js";
-import { arbolDeProyecto, leerFicheroDeProyecto, motivoDeRutaInaceptable, } from "../../agent/arbolDeProyecto.js";
-import { leerArtefactoCrudo, leerArtefactoDeSesion, } from "../../agent/artefactosEnDisco.js";
-import { CatalogoModelos } from "../../agent/catalogoModelos.js";
-import { Modelos } from "../../agent/modelos.js";
-import { crearJuezDeTarea, invocarConModelos } from "../../agent/juezDeTarea.js";
+import { arbolDeProyecto, leerFicheroDeProyecto, motivoDeRutaInaceptable, } from "../../agent/grafo/arbolDeProyecto.js";
+import { leerArtefactoCrudo, leerArtefactoDeSesion, } from "../../agent/grafo/artefactosEnDisco.js";
+import { CatalogoModelos } from "../../agent/config/catalogoModelos.js";
+import { Modelos } from "../../agent/config/modelos.js";
+import { crearJuezDeTarea, invocarConModelos } from "../../agent/tareas/juezDeTarea.js";
+import { SIN_CONSUMO } from "../../agent/subagentes/consumoExterno.js";
 import { AumentadorGuionizado } from "../../core/ports.js";
 import { arrancarServidor } from "./servidor.js";
 import { consolaParaTarea, crearCorredorDeTareas, revisionConGit, } from "./corredorDeTareas.js";
 import { CONCURRENCIA_POR_OMISION, conEstado, darPorBuenaAMano, tituloDeTarea, } from "../../core/tareas.js";
-import { aplicarFeedback, TOPE_DE_ADJUNTO } from "../../agent/tareasEnDisco.js";
+import { aplicarFeedback, TOPE_DE_ADJUNTO } from "../../agent/tareas/tareasEnDisco.js";
 import { nombreDeAdjuntoAceptable } from "../../core/adjuntos.js";
-import { rutaMemoriaDeProyecto } from "../../agent/memoriaDeProyecto.js";
-import { crearAumentador, invocarParaAumentar } from "../../agent/aumentador.js";
+import { rutaMemoriaDeProyecto } from "../../agent/grafo/memoriaDeProyecto.js";
+import { crearAumentador, invocarParaAumentar } from "../../agent/tareas/aumentador.js";
 import { baseDeWorkspacePorOmision, conexionDeVestibulo, crearVestibulo, escribirProyectoEnDisco, esProyectoEnDisco, } from "./vestibulo.js";
 // Valor y no tipo: la traducción de una `Tarea` a lo que viaja vive JUNTO al tipo que
 // produce y no aquí. Estuvo en este cierre, y ahí se cayó `veredicto` sin que nada se
@@ -97,6 +102,24 @@ import { filaDeTarea } from "./transporte.js";
  * definición de que el aviso frena, que es justo lo que su propia regla prohíbe.
  */
 export const MS_DE_TRABAJO_AL_ABRIR = 2000;
+/**
+ * Cuánto se espera al arranque antes de entrar igual.
+ *
+ * Lo que se prepara es la sesión MCP y la lista de proyectos del primer entorno registrado,
+ * y el usuario pidió no entrar al Escritorio hasta tenerlo: entrar antes significa un
+ * Escritorio vacío que se rellena delante. Pero esperar SIN plazo es lo que convierte una
+ * espera en un cuelgue — medido con un MCP que descarta paquetes, el lienzo se quedaba para
+ * siempre, y eso es peor que lo que veníamos a arreglar.
+ *
+ * Generoso a propósito: una sesión MCP fría lleva descubrimiento OAuth y handshake, y
+ * cortarla pronto haría entrar en vacío justo a quien tiene la red lenta, que es a quien más
+ * le duele. Y como el lienzo DICE lo que está haciendo (`preparando`), la espera se lee como
+ * trabajo y no como una pantalla muerta.
+ *
+ * Igual que `MS_DE_TRABAJO_AL_ABRIR`, lo que se acota es la ESPERA y no el trabajo: la
+ * promesa sigue viva y lo que llegue tarde sale en el siguiente anuncio.
+ */
+export const MS_DE_PREPARACION = 10_000;
 export const RUTA_EVENTOS = "/eventos";
 export const RUTA_ACCION = "/accion";
 /**
@@ -109,6 +132,13 @@ export const RUTA_ACCION = "/accion";
  * el contrato de las skills que los escriben es «autocontenido».
  */
 export const RUTA_ARTEFACTO = "/artefacto";
+/**
+ * `POST /skill?nombre=<fichero.zip>&ambito=<global|proyecto>` — los BYTES de un `.zip`.
+ *
+ * Por HTTP y no por el cable, que lleva JSON: la misma razón y el mismo molde que
+ * `POST /adjunto`. Una ruta EXACTA, porque el servidor casa por ruta exacta.
+ */
+export const RUTA_SKILL = "/skill";
 /**
  * `POST /adjunto?tarea=<id>&nombre=<fichero>` — los BYTES de un adjunto.
  *
@@ -245,6 +275,14 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      * en la Trayectoria —la otra pestaña—, y el wizard repintaba el mismo paso sin decir nada.
      */
     let aviso;
+    /**
+     * Qué está preparando el arranque, mientras lo prepara. `undefined` = listo.
+     *
+     * Vive aquí y no en el anuncio porque el `alta` se emite también en los dos flancos de
+     * cada turno, y esos anuncios no están preparando nada: quien lo pone y lo quita es el
+     * arranque de la conexión, y los demás leen lo que haya.
+     */
+    let preparando;
     const destinoActual = () => vestibulo.proyectoAbierto() ?? vestibulo.consola;
     const emitir = (mensaje) => {
         for (const cliente of clientes)
@@ -436,6 +474,10 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 : {}),
             ...(vestibulo.nombre === undefined ? {} : { nombre: vestibulo.nombre }),
             ...(aviso === undefined ? {} : { aviso }),
+            // Ausente = listo, y solo entonces el cliente sale del lienzo. Se lee de la variable
+            // en cada anuncio en vez de pasarse por parámetro: los anuncios de los flancos del
+            // turno no preparan nada y tienen que decir lo que hay, no lo que había.
+            ...(preparando === undefined ? {} : { preparando }),
         });
     };
     /**
@@ -471,9 +513,15 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 motor: a.motor,
                 ...(a.modelo === undefined ? {} : { modelo: a.modelo }),
                 soloLectura: a.soloLectura,
+                // Ausente = no la tiene. No se emite `false` para que el cliente no tenga que
+                // distinguir entre «no» y «no consta»: aquí son lo mismo y la ausencia lo dice.
+                ...(a.ejecucion === true ? { ejecucion: true } : {}),
                 skills: a.skills,
                 instrucciones: a.instrucciones,
                 origen: a.origen,
+                // Ausente cuando el `.md` es del usuario, y eso es el dato: es lo que le pone la
+                // papelera en vez de un «Restaurar el de serie».
+                ...(a.semilla === undefined ? {} : { semilla: a.semilla }),
             })),
             problemas,
         };
@@ -489,6 +537,52 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      */
     const atenderAgente = (mensaje) => {
         const abierto = vestibulo.proyectoAbierto();
+        /**
+         * `restaurar` va ANTES de la guarda del ámbito porque no tiene ámbito que elegir: la
+         * siembra solo escribe en el global, así que la versión de serie solo puede volver ahí.
+         * Pasarlo por el `ambito` del mensaje sería ofrecer una decisión que no existe, y con un
+         * `ambito: "proyecto"` daría un «no hay ningún proyecto abierto» que no viene a cuento.
+         */
+        if (mensaje.accion === "restaurar") {
+            informar(restaurarAgente(homedir(), mensaje.agente.nombre)
+                ? `subagente «${mensaje.agente.nombre}» restaurado al de serie`
+                : `«${mensaje.agente.nombre}» no es uno de los de serie: no hay ninguna versión nuestra que poner`);
+            emitirAgentes();
+            return;
+        }
+        /**
+         * Y un de serie NO se borra. La negativa vive AQUÍ y no solo en el cliente, que le
+         * esconde el icono: esconderlo es presentación, y este mensaje lo puede mandar cualquier
+         * cosa que hable por el cable. Borrarlo no devolvía el de serie —`sembrarAgentes` no
+         * resiembra lo que consta entregado— así que era perderlo para siempre; lo que sí hace
+         * lo que aquello prometía es `restaurar`, y se dice en el mismo sitio donde se rechaza.
+         */
+        if (mensaje.accion === "borrar" && mensaje.ambito === "global" && esDeSerie(mensaje.agente.nombre)) {
+            informar(`«${mensaje.agente.nombre}» lo trae xonecode y no se borra: edítalo, o restaura el de serie si quieres el original`);
+            return;
+        }
+        /**
+         * Un renombrado de verdad: `renombrandoDe` puesto y DISTINTO del nombre nuevo. Con el
+         * mismo nombre es un guardado normal, y tratarlo de renombrado lo haría fallar por
+         * «destino ocupado» contra sí mismo.
+         */
+        const renombrandoDe = mensaje.accion === "guardar" &&
+            mensaje.renombrandoDe !== undefined &&
+            mensaje.renombrandoDe !== mensaje.agente.nombre
+            ? mensaje.renombrandoDe
+            : undefined;
+        /**
+         * Y un de serie tampoco se RENOMBRA, por lo mismo que no se borra: su nombre es lo que lo
+         * ata a la marca de la siembra (`.semilla.json` guarda el hash POR NOMBRE), así que
+         * moverlo lo convierte en un subagente del usuario y hace que el de serie vuelva a
+         * sembrarse al arrancar — dos especialistas donde había uno. La regla vive aquí y no en
+         * `renombrarAgente`, que mueve un fichero: dos sitios donde decidir lo mismo es cómo uno
+         * de los dos se queda sin la regla.
+         */
+        if (renombrandoDe !== undefined && mensaje.ambito === "global" && esDeSerie(renombrandoDe)) {
+            informar(`«${renombrandoDe}» lo trae xonecode y su nombre no se cambia: es lo que lo ata a la versión de serie`);
+            return;
+        }
         if (mensaje.ambito === "proyecto" && abierto === undefined) {
             informar("no hay ningún proyecto abierto: ese subagente solo se puede guardar como global");
             return;
@@ -515,8 +609,35 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                     informar(`no se guarda «${candidato.nombre}»: ${comprobado.error}`);
                     return;
                 }
-                guardarAgente(base, candidato);
-                informar(`subagente «${candidato.nombre}» guardado en ${mensaje.ambito}`);
+                /**
+                 * Y el NOMBRE tiene que ser un slug, aquí y no en el cargador: cargando solo se DICE
+                 * (`leerCarpetaDeAgentes`), porque rechazar al cargar haría desaparecer un subagente
+                 * que funciona. Guardar es el único momento con alguien delante para arreglarlo.
+                 *
+                 * No lo cubre `leerAgente`: el nombre no sale del `.md`, sale del FICHERO, así que
+                 * escribir y volver a leer no lo mira. Y tampoco `segmentoSeguro`, que impide salir de
+                 * la carpeta y nada más — `Documentador` pasa esa y no es un slug.
+                 */
+                const malNombre = motivoDeNombreInaceptable(candidato.nombre);
+                if (malNombre !== undefined) {
+                    informar(`no se guarda «${candidato.nombre}»: el nombre ${malNombre}`);
+                    return;
+                }
+                if (renombrandoDe === undefined) {
+                    guardarAgente(base, candidato);
+                    informar(`subagente «${candidato.nombre}» guardado en ${mensaje.ambito}`);
+                }
+                else {
+                    // Los tres desenlaces se dicen distintos: el destino ocupado y el origen que ya no
+                    // está son dos situaciones que el usuario arregla de formas distintas, y un «no se
+                    // pudo» para las dos le haría probar la equivocada.
+                    const como = renombrarAgente(base, renombrandoDe, candidato);
+                    informar(como === "hecho"
+                        ? `subagente «${renombrandoDe}» renombrado a «${candidato.nombre}»`
+                        : como === "sin-origen"
+                            ? `«${renombrandoDe}» ya no existía en ${mensaje.ambito}: no se ha renombrado`
+                            : `ya hay un subagente «${candidato.nombre}» en ${mensaje.ambito}: elige otro nombre, o bórralo primero`);
+                }
             }
         }
         catch (error) {
@@ -524,6 +645,132 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         }
         emitirAgentes();
     };
+    /**
+     * Las skills en vigor, compuestas pero sin mandar.
+     *
+     * `cargarSkills` cada vez y no una lista cacheada, por lo mismo que `mensajeDeAgentes`:
+     * las carpetas se pueden tocar a mano con la consola abierta, y una lista congelada al
+     * arrancar haría creer que el cambio no se aplicó.
+     *
+     * **El `cuerpo` viaja solo en las del USUARIO.** Las de serie son nueve ficheros que pasan
+     * de veinte mil caracteres cada uno; mandarlos en la ráfaga de bienvenida es pagar cientos
+     * de kilobytes por rellenar un formulario que nadie puede guardar. El suyo se pide a mano
+     * (`cuerpoDeSkill`), que es cuando alguien la está mirando de verdad.
+     */
+    const mensajeDeSkills = () => {
+        const abierto = vestibulo.proyectoAbierto();
+        const { skills, problemas } = cargarSkills(abierto?.raiz);
+        return {
+            clase: "skills",
+            skills: skills.map((s) => ({
+                nombre: s.nombre,
+                descripcion: s.descripcion,
+                origen: s.origen,
+                tokens: s.tokens,
+                ficheros: s.ficheros,
+                // El frontmatter va SIEMPRE: son cuatro líneas, y es lo que contesta qué declara el
+                // fichero. El CUERPO no, en las de serie: eso sí son decenas de miles de caracteres.
+                ...(s.frontmatter === undefined ? {} : { frontmatter: s.frontmatter }),
+                ...(s.origen === "serie" ? {} : { cuerpo: s.cuerpo }),
+            })),
+            problemas,
+        };
+    };
+    const emitirSkills = () => emitir(mensajeDeSkills());
+    /**
+     * El cuerpo de UNA skill, bajo demanda: al abrir la ficha de una de serie o al copiarla.
+     *
+     * Se contesta SOLO a quien lo pidió no se puede —el transporte habla con todos—, así que
+     * va a todos y el cliente se queda con la que tiene abierta. Es un fichero de texto que ya
+     * está en la lista, no un secreto.
+     *
+     * Lo que no se pudo leer se DICE con un `error`: una ficha que se abre en blanco se lee
+     * como que la skill está vacía, y entonces copiarla produciría una copia vacía.
+     */
+    const atenderCuerpoDeSkill = (mensaje) => {
+        const abierto = vestibulo.proyectoAbierto();
+        const skill = cargarSkills(abierto?.raiz).skills.find((s) => s.nombre === mensaje.nombre);
+        emitir(skill === undefined
+            ? { clase: "cuerpoDeSkill", nombre: mensaje.nombre, error: "ya no está en el catálogo" }
+            : { clase: "cuerpoDeSkill", nombre: mensaje.nombre, cuerpo: skill.cuerpo });
+    };
+    /**
+     * Alta, cambio y borrado de una skill del usuario. El mismo molde que `atenderAgente`.
+     *
+     * **Las de serie no se tocan, y la barrera está AQUÍ.** Viven dentro del paquete
+     * instalado: una edición se la llevaría el siguiente `npm install` sin decir nada, y un
+     * borrado no se puede reponer porque nada nuestro se copia nunca a la casa del usuario
+     * —no hay marca de siembra que consultar, a diferencia de los subagentes—. Lo que la
+     * consola ofrece sobre una de serie es COPIARLA, que es un `guardar` con otro nombre.
+     *
+     * `guardarSkill` DEVUELVE el motivo en vez de lanzar, así que los tres desenlaces —el
+     * nombre ocupado, el nombre de una de serie y el fallo de escritura— se dicen distintos:
+     * son tres cosas que el usuario arregla de tres formas.
+     */
+    const atenderSkill = (mensaje) => {
+        const abierto = vestibulo.proyectoAbierto();
+        const nombre = mensaje.skill.nombre;
+        if (mensaje.ambito === "proyecto" && abierto === undefined) {
+            informar("no hay ningún proyecto abierto: esa skill solo se puede guardar como global");
+            return;
+        }
+        const base = mensaje.ambito === "proyecto" ? abierto.raiz : homedir();
+        /**
+         * Borrar se INTENTA y el motivo sale de lo que pasó, no de una guarda previa por NOMBRE.
+         *
+         * La guarda por nombre era demasiado ancha: una skill del usuario que se llame como una
+         * de serie —tapándola, que es la forma de afinarla sin editar donde el `npm install` la
+         * pisaría— no se podía borrar nunca, porque `esDeSerie` mira el catálogo del paquete y no
+         * la carpeta del usuario. Lo que hay en la carpeta del usuario es del usuario y se borra;
+         * lo que no está ahí y ADEMÁS lo traemos nosotros es lo que se niega, con el camino al
+         * lado. Un solo sitio decide, que es `borrarSkill` contestando si había algo.
+         */
+        if (mensaje.accion === "borrar") {
+            informar(borrarSkill(base, nombre)
+                ? `skill «${nombre}» borrada`
+                : esDeSerieLaSkill(nombre)
+                    ? `la skill «${nombre}» la trae xonecode y no se borra: cópiala si quieres partir de ella`
+                    : `«${nombre}» no existía en ${mensaje.ambito}`);
+            emitirSkills();
+            return;
+        }
+        /**
+         * El nombre tiene que ser un slug, y se comprueba al GUARDAR y no al cargar: rechazar al
+         * cargar haría desaparecer una skill que funciona, y guardar es el único momento con
+         * alguien delante para arreglarlo. `segmentoSeguro` —que `guardarSkill` sí aplica— solo
+         * impide salir de la carpeta: `Mi Skill` la pasa y no es un slug, y el nombre de una
+         * skill viaja además dentro del `.md` de un subagente.
+         */
+        const malNombre = motivoDeNombreDeSkillInaceptable(nombre);
+        if (malNombre !== undefined) {
+            const sugerido = nombreDeSkillSugerido(nombre);
+            informar(`no se guarda «${nombre}»: el nombre ${malNombre}` +
+                (sugerido === undefined ? "" : ` (prueba «${sugerido}»)`));
+            return;
+        }
+        if (mensaje.skill.descripcion.trim() === "") {
+            // Es lo que el modelo lee para decidir si le sirve: sin ella la skill está en el
+            // catálogo y no la usa nadie nunca, que es peor que no estar.
+            informar(`no se guarda «${nombre}»: sin descripción, el orquestador no sabría cuándo usarla`);
+            return;
+        }
+        const renombrandoDe = mensaje.renombrandoDe !== undefined && mensaje.renombrandoDe !== nombre
+            ? mensaje.renombrandoDe
+            : undefined;
+        const escrita = guardarSkill(base, {
+            nombre,
+            descripcion: mensaje.skill.descripcion,
+            cuerpo: mensaje.skill.cuerpo ?? "",
+            // El frontmatter de ANTES, para conservar lo que no editamos. Ausente en un alta.
+            ...(mensaje.skill.frontmatter === undefined ? {} : { frontmatter: mensaje.skill.frontmatter }),
+        }, mensaje.renombrandoDe);
+        informar("error" in escrita
+            ? `no se guarda «${nombre}»: ${escrita.error}`
+            : renombrandoDe === undefined
+                ? `skill «${nombre}» guardada en ${mensaje.ambito}`
+                : `skill «${renombrandoDe}» renombrada a «${nombre}»`);
+        emitirSkills();
+    };
     /** El mensaje de modelos, compuesto pero sin mandar: `adjuntar` se lo da SOLO al cliente
      *  que acaba de llegar, y el resto de sitios lo emite a todos. */
     const mensajeDeModelos = () => {
@@ -602,6 +849,10 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         // se puede abrir en cuanto conecta, y sin esto enseñaría una lista vacía hasta que algo
         // los cambiara — que es indistinguible de «no tienes ninguno».
         const agentes = mensajeDeAgentes();
+        // Y las skills, por lo mismo que los subagentes y con una razón más: el editor de un
+        // subagente pinta sus skills como una lista de casillas, así que sin esto ese formulario
+        // se abriría sin ninguna casilla que marcar — que es indistinguible de «no hay ninguna».
+        const skills = mensajeDeSkills();
         // La cola de tareas, si esta ejecución las tiene: la misma regla que `agentes`, sin
         // esto la pestaña de tareas se quedaría vacía hasta el primer cambio de la cola.
         const tareas = mensajeDeTareas();
@@ -619,6 +870,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             cliente({ clase: "reemision", actos: [...actos] });
             cliente(modelos);
             cliente(agentes);
+            cliente(skills);
             if (tareas !== undefined)
                 cliente(tareas);
             if (consumoDeLaSesion !== undefined) {
@@ -708,20 +960,33 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      * heredar un «ya se intentó» que se quedó en `proyectos: []` para siempre. Esto puede
      * abrir el navegador de verdad si el token necesita reautenticar —`conectarCloudStudio`
      * ya lo hace así—, y es lo correcto: un token vivo no toca el puerto de callback en
-     * absoluto (arreglado en `agent/cloudstudioMcp.ts#abrirCliente`), así que dos conexiones
+     * absoluto (arreglado en `agent/cloudstudio/cloudstudioMcp.ts#abrirCliente`), así que dos conexiones
      * seguidas no chocan por intentarlo cada una.
      */
-    const poblarProyectosSiProcede = async () => {
+    /**
+     * De qué entorno se poblarían los proyectos al arrancar, o nada si no hay nada que
+     * preparar.
+     *
+     * Es la MISMA decisión que toma `poblarProyectosSiProcede`, extraída para que el arranque
+     * pueda anunciar la fase ANTES de empezarla. En dos sitios divergirían, y el precio sería
+     * de los peores: el lienzo esperando por un trabajo que nadie va a pedir (`preparando`
+     * puesto y nada que lo quite), o entrar en vacío justo cuando sí había algo que traer.
+     */
+    const entornoAPoblar = () => {
         if (vestibulo.proyectoAbierto() !== undefined)
-            return;
+            return undefined;
         if (entornoElegido !== undefined)
-            return;
+            return undefined;
         const [primero] = vestibulo.entornosRegistrados();
-        if (primero === undefined)
+        return primero === undefined ? undefined : { id: primero.id, nombre: primero.nombre };
+    };
+    const poblarProyectosSiProcede = async () => {
+        const destino = entornoAPoblar();
+        if (destino === undefined)
             return;
         try {
-            proyectos = await vestibulo.proyectosDe(primero.id);
-            entornoElegido = primero.id;
+            proyectos = await vestibulo.proyectosDe(destino.id);
+            entornoElegido = destino.id;
         }
         catch (error) {
             aviso = error instanceof Error ? error.message : String(error);
@@ -1033,7 +1298,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
     /**
      * «Se edita la tarea y se agrega el feedback del usuario» (§0 del diseño, textual):
      * añadir un feedback a una tarea «esperando feedback» la devuelve al lazo. Vive detrás de
-     * `aplicarFeedback` (`agent/tareasEnDisco.ts`) y no repite su lógica aquí, por el mismo
+     * `aplicarFeedback` (`agent/tareas/tareasEnDisco.ts`) y no repite su lógica aquí, por el mismo
      * motivo que `atenderCrearTarea`/`atenderAccionDeTarea` no reimplementan `conEstado`: la
      * regla de qué feedback vale y qué transición es legal está en una sola función, probada
      * sola y sin necesitar un servidor de mentira alrededor.
@@ -1051,6 +1316,12 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
     /** Los ajustes de destino, o `{}` —que es «se miran todos»— si esta ejecución no los lee. */
     const ajustesDeDispositivos = () => opciones.ajustesDeDispositivos?.() ?? {};
     let deteccionEnVuelo;
+    /**
+     * Cómo acabó el último «Arrancar». Viaja con la foto porque el resultado de arrancar ES la
+     * foto: `emulator` devuelve el control enseguida y lo que importa es si el aparato apareció.
+     * Se limpia al pedir una medida sin arranque de por medio, para no repetir un acuse viejo.
+     */
+    let ultimoArranque;
     const atenderDispositivos = () => {
         if (opciones.detectarDispositivos === undefined)
             return Promise.resolve();
@@ -1060,7 +1331,12 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         deteccionEnVuelo = (async () => {
             try {
                 informeDeDispositivos = sinRutas(await detectar());
-                emitir({ clase: "dispositivos", informe: informeDeDispositivos, ajustes: ajustesDeDispositivos() });
+                emitir({
+                    clase: "dispositivos",
+                    informe: informeDeDispositivos,
+                    ajustes: ajustesDeDispositivos(),
+                    ...(ultimoArranque === undefined ? {} : { arranque: ultimoArranque }),
+                });
             }
             catch (error) {
                 // El detector reparte los fallos por herramienta y no lanza por ninguno; que
@@ -1075,6 +1351,55 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         })();
         return deteccionEnVuelo;
     };
+    /**
+     * **Arrancar un AVD, y contarlo con la foto de después.**
+     *
+     * Tres guardas, en este orden:
+     *
+     * 1. **Que esta ejecución pueda.** Sin el puerto no hay arranque y se DICE: un botón que
+     *    llega a un servidor que no sabe arrancar nada es el control muerto de siempre.
+     * 2. **Que ese AVD esté en NUESTRA última medida.** El nombre llega por el cable y acaba
+     *    siendo un argumento de proceso; la lista de AVDs es lo único que lo autoriza. Sin
+     *    medida todavía no se arranca nada — no hay con qué comprobarlo.
+     * 3. **Uno a la vez.** Dos arranques del mismo AVD a la vez son dos emuladores peleándose
+     *    por el mismo puerto, y de otro AVD sería trabajo pesado en paralelo en la máquina de
+     *    quien mira. Se reenvía el estado, que es lo que hace la receta.
+     *
+     * Al acabar se vuelve a medir SIEMPRE, salga bien o mal: la foto es la que dice si arrancó.
+     */
+    let arranqueEnVuelo;
+    const atenderArranqueDeEmulador = async (avd) => {
+        const arrancar = opciones.arrancarEmulador;
+        if (arrancar === undefined) {
+            informar("esta ejecución no puede arrancar emuladores");
+            return;
+        }
+        if (arranqueEnVuelo !== undefined) {
+            informar(`ya estoy arrancando ${arranqueEnVuelo}`);
+            return;
+        }
+        if (informeDeDispositivos === undefined || !informeDeDispositivos.avds.includes(avd)) {
+            ultimoArranque = { avd, ok: false, detalle: `no consta ningún AVD llamado «${avd}» en la última medida` };
+            await atenderDispositivos().catch(contar);
+            return;
+        }
+        arranqueEnVuelo = avd;
+        try {
+            const r = await arrancar(avd);
+            ultimoArranque = { avd, ...r };
+        }
+        catch (error) {
+            // El puerto promete no lanzar; si lanzara, el botón no puede quedarse mudo.
+            ultimoArranque = { avd, ok: false, detalle: error instanceof Error ? error.message : String(error) };
+            contar(error);
+        }
+        finally {
+            arranqueEnVuelo = undefined;
+            // La medida nueva, pase lo que pase: es la que dice la verdad.
+            informeDeDispositivos = undefined;
+            await atenderDispositivos().catch(contar);
+        }
+    };
     /**
      * Verificar la conexión con UN dispositivo, y volver a emitir la foto con lo que contestó.
      *
@@ -1129,7 +1454,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         }
         catch (error) {
             // `ErrorCatalogoModelos` es publicable por contrato: nunca lleva la clave ni el
-            // cuerpo remoto (`agent/catalogoModelos.ts`).
+            // cuerpo remoto (`agent/config/catalogoModelos.ts`).
             catalogos.set(id, { error: error instanceof Error ? error.message : String(error) });
         }
         emitirModelos();
@@ -1470,6 +1795,31 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             // 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?.();
@@ -1761,7 +2111,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
     };
     /**
      * La sincronización con CloudStudio del proyecto abierto, pedida desde un control
-     * (la banda de arriba de Revisión, y «Volver a mirar»).
+     * (la banda de arriba de Revisión, y «Refrescar»).
      *
      * **`estado` se mide aquí; `subir` y `bajar` se ENCOLAN**, y la asimetría es deliberada.
      * Medir es leer una ref de git que ya está en local (`lecturaDeSync`), así que encolarla
@@ -1778,7 +2128,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      * Y lo que NO se hace es volver a emitir la lectura después de encolar: el servidor no
      * sabe cuándo termina una línea de la cola, y un «3 ficheros por subir» recién emitido
      * tras pulsar Subir sería una cifra que nadie ha vuelto a medir. La pestaña se refresca
-     * al volver a ella y al pulsar «Volver a mirar», que es cuando de verdad se mira.
+     * al volver a ella y al pulsar «Refrescar», que es cuando de verdad se mira.
      */
     const atenderSync = (accion) => {
         const abierto = vestibulo.proyectoAbierto();
@@ -2512,10 +2862,48 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         // documenta la medida).
         // Solo al recién llegado: los demás ya recibieron su saludo al conectar.
         sumidero({ clase: "bienvenida", ...(vestibulo.nombre === undefined ? {} : { nombre: vestibulo.nombre }) });
+        /**
+         * **Dos anuncios, y el primero va ANTES de preguntar a CloudStudio.**
+         *
+         * `pasos` se calcula del DISCO (`pasosPendientes`: de dónde vino el modelo y qué entornos
+         * hay registrados), así que en una máquina configurada ya se sabe «no falta nada» sin
+         * tocar la red. Con un solo anuncio detrás de `poblarProyectosSiProcede` —que abre la
+         * sesión MCP— el cliente no podía saberlo hasta que ese viaje terminara, y `App.tsx` lee
+         * un `alta` ausente como «todavía no consta»: enseñaba la pantalla del alta a alguien que
+         * no tiene nada que dar de alta. Medido en la máquina del usuario, con CloudStudio
+         * caliente: el `alta` llegaba a 1436 ms, y con el MCP lento o la red caída esa ventana
+         * crece hasta su tope. Es la misma forma que `MS_DE_TRABAJO_AL_ABRIR`: un dato que se
+         * sabe y no se dice porque va detrás de otro que tarda.
+         *
+         * El segundo anuncio lleva los proyectos, y sigue en un `finally` por lo de siempre: que
+         * `poblarProyectosSiProcede` acabe mal no puede dejar al cliente sin el anuncio. Es el
+         * mismo reparto que ya usaba el cambio de entorno (anunciar, luego preguntar).
+         */
+        /**
+         * La fase se pone ANTES del primer anuncio y se quita en el `finally`, así que el primer
+         * `alta` sale con ella y el segundo sin ella. Es lo que hace que el Escritorio no entre
+         * hasta estar preparado —lo que el usuario pidió— sin volver a esconder el «no falta
+         * ningún paso», que es lo que el `alta` adelantado vino a arreglar: el cliente sabe
+         * desde el primer mensaje que no hay nada que dar de alta Y que todavía está trayendo
+         * los proyectos, que son dos cosas distintas.
+         *
+         * Con la cuenta pendiente y un entorno ya registrado las dos cosas pasan a la vez, y eso
+         * está bien: la tarjeta pinta el paso de cuenta mientras el MCP trabaja por detrás. Es el
+         * cliente quien decide qué se ve, porque la fase es un dato, no una orden de pintar.
+         */
+        const aPreparar = entornoAPoblar();
+        preparando = aPreparar === undefined ? undefined : `conectando con ${aPreparar.nombre}…`;
         void conducirCuenta()
             .catch(contar)
-            .then(() => poblarProyectosSiProcede())
-            .finally(() => void anunciarAlta().catch(contar));
+            .then(() => anunciarAlta().catch(contar))
+            .then(() => conPlazo(poblarProyectosSiProcede(), MS_DE_PREPARACION))
+            .finally(() => {
+            // Se quita SIEMPRE, también cuando el plazo vence con el MCP todavía colgado: el
+            // lienzo no puede quedarse esperando a quien no contesta. Lo que llegue tarde entra
+            // en el siguiente anuncio, y lo que falló ya viaja en `aviso`.
+            preparando = undefined;
+            void anunciarAlta().catch(contar);
+        });
         peticion.on("close", () => {
             // Se va ESTE cliente, no «el cliente». La guarda de antes (`enviar !== sumidero`)
             // existía porque el `close` de una pestaña recargada puede llegar DESPUÉS de que el
@@ -2675,6 +3063,61 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      * - **Ninguna respuesta lleva una ruta de la máquina** ni nada de lo recibido, que es la
      *   regla de `POST /accion`.
      */
+    /**
+     * `POST /skill?nombre=<fichero.zip>&ambito=<global|proyecto>` — instalar una skill.
+     *
+     * Por HTTP y no por el cable, con el mismo molde que `POST /adjunto`: esto son bytes y el
+     * cable lleva JSON. `Host`, `Origin` y token los comprueba `servidor.ts` antes de llegar
+     * aquí, igual que a todas las rutas. Lo propio de ésta:
+     *
+     * - **El `nombre` de la query es el del FICHERO que subió la persona, y solo se usa como
+     *   nombre de respaldo** cuando el zip no trae una carpeta de la que sacarlo
+     *   (`core/zipDeSkill.ts`). No se compone ninguna ruta con él sin pasar por la regla del
+     *   slug, que es la misma de un subagente.
+     * - **El cuerpo se lee con el tope del ZIP y se corta ahí** (413), sin acumular. Y el otro
+     *   tope, el de lo DESCOMPRIMIDO, lo pone `planDeInstalacion`: éste no lo ve, que es
+     *   justamente lo que un zip bomba aprovecha.
+     * - **Ninguna respuesta lleva una ruta de la máquina ni nada de lo recibido**, que es la
+     *   regla de `POST /accion` — y aquí lo recibido es un fichero de alguien.
+     */
+    servidor.registrarRuta("POST", RUTA_SKILL, async (peticion, respuesta) => {
+        const responder = (codigo, texto) => {
+            respuesta.writeHead(codigo, { "Content-Type": "text/plain; charset=utf-8" });
+            respuesta.end(texto);
+        };
+        const query = new URLSearchParams((peticion.url ?? "").split("?")[1] ?? "");
+        const nombre = query.get("nombre");
+        const ambito = query.get("ambito") === "proyecto" ? "proyecto" : "global";
+        if (nombre === null || nombre === "") {
+            responder(400, "falta «nombre»");
+            return;
+        }
+        const abierto = vestibulo.proyectoAbierto();
+        if (ambito === "proyecto" && abierto === undefined) {
+            responder(409, "no hay ningún proyecto abierto: esa skill solo se puede instalar como global");
+            return;
+        }
+        let datos;
+        try {
+            datos = await leerCuerpoCrudo(peticion, TOPE_DEL_ZIP);
+        }
+        catch {
+            responder(413, "el .zip es demasiado grande");
+            return;
+        }
+        const instalada = instalarSkillDesdeZip(ambito === "proyecto" ? abierto.raiz : homedir(), new Uint8Array(datos), nombre);
+        if ("error" in instalada) {
+            // El motivo lo escribe el módulo y no lleva ninguna ruta de la máquina ni el nombre de
+            // una entrada del zip (sus tests lo vigilan). 422: el zip llegó entero y no vale.
+            informar(`no se instala la skill: ${instalada.error}`);
+            responder(422, instalada.error);
+            return;
+        }
+        informar(`skill «${instalada.nombre}» instalada en ${ambito}`);
+        emitirSkills();
+        respuesta.writeHead(204);
+        respuesta.end();
+    });
     servidor.registrarRuta("POST", RUTA_ADJUNTO, async (peticion, respuesta) => {
         const responder = (codigo, texto) => {
             respuesta.writeHead(codigo, { "Content-Type": "text/plain; charset=utf-8" });
@@ -2808,6 +3251,17 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "arrancarEmulador" &&
+            typeof mensaje.avd === "string") {
+            // Se contesta ya: arrancar tarda lo que tarda un emulador y la respuesta del POST no es
+            // el sitio donde se cuenta — eso viaja por el SSE con la foto nueva.
+            void atenderArranqueDeEmulador(mensaje.avd).catch(contar);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         /**
          * ANTES del `recibir` de la consola, y también antes que las demás clases de tarea: por
          * aquí no entra nada hacia ningún turno. Ver `atenderMirar`.
@@ -2918,6 +3372,18 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "skill") {
+            atenderSkill(mensaje);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "cuerpoDeSkill") {
+            atenderCuerpoDeSkill(mensaje);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "proveedor") {
             atenderProveedor(mensaje);
             respuesta.writeHead(204);
@@ -3034,6 +3500,19 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 respuesta.end();
                 return;
             }
+            /**
+             * **Y el acuse del último arranque se OLVIDA.**
+             *
+             * Sin esto se queda pegado para siempre: el usuario vio `pixel8 · apagado` con un
+             * «✓ pixel8 arrancado» al lado, o sea las dos cosas a la vez. El acuse pertenece a la
+             * foto que se tomó justo después de arrancar, no a todas las de después — y ahora que
+             * la sección remide al entrar y al volver, «todas las de después» son muchas.
+             *
+             * Ausente vuelve a significar «no se ha pedido ningún arranque en esta medida», que es
+             * lo que el campo declara. El `finally` de `atenderArranqueDeEmulador` lo pone y se
+             * salta este camino, así que su propia medida sí lo lleva.
+             */
+            ultimoArranque = undefined;
             informeDeDispositivos = undefined;
             void atenderDispositivos().catch(contar);
             respuesta.writeHead(204);
@@ -3080,7 +3559,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
  * Construye el corredor de tareas y la costura que lo conecta al cable.
  *
  * Extraído de `arrancarConsolaWeb` a su propia función por la MISMA razón que
- * `backendDeAgente` (`agent/proyecto.ts`): la composición vivía inline dentro de una
+ * `backendDeAgente` (`agent/grafo/proyecto.ts`): la composición vivía inline dentro de una
  * función que todos sus tests DOBLAN —`vestibulo`, `crearServidor`, `crearEjecutor`—, así
  * que esta costura concreta podía dejar de estar montada con el resto en verde. Aquí
  * tiene su propio test que la compone de VERDAD: construye un corredor real
@@ -3673,7 +4152,7 @@ export async function arrancarConsolaWeb(opciones) {
         borrarCredencial,
         guardarCredencial,
         /**
-         * El defecto se GUARDA en el `config.json` global (`agent/configEnDisco.ts#guardarModeloGlobal`),
+         * El defecto se GUARDA en el `config.json` global (`agent/config/configEnDisco.ts#guardarModeloGlobal`),
          * que es el último escalón de la precedencia y el único que sobrevive al proceso. Se
          * escribe para los TRES papeles porque elegir un modelo en la interfaz es una frase
          * sobre el producto y no sobre un papel — el mismo criterio que `/modelo`, que fija los
@@ -3699,7 +4178,7 @@ export async function arrancarConsolaWeb(opciones) {
         cambiosDeSesion,
         parcheDeSesion,
         // El proyecto tal como lo ve el agente, para la pestaña Ficheros: mismo filtro, misma
-        // barrera de rutas (`agent/arbolDeProyecto.ts`).
+        // barrera de rutas (`agent/grafo/arbolDeProyecto.ts`).
         arbolDelProyecto: async (raiz) => arbolDeProyecto(raiz),
         leerFichero: leerFicheroDeProyecto,
         leerArtefacto: leerArtefactoDeSesion,
@@ -3714,6 +4193,11 @@ export async function arrancarConsolaWeb(opciones) {
         guardarAjustesDeDispositivos: (ajustes) => void guardarDispositivos(undefined, ajustes),
         instalarHerramienta: instalarHerramientaDeDispositivos,
         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
+        // lanzamiento. `montarRutas` lo trata como ausente si falta, así que olvidarlo aquí
+        // dejaría el botón diciendo «esta ejecución no puede arrancar emuladores» con todo verde.
+        arrancarEmulador: (avd) => arrancarEmulador(avd),
         /**
          * Las cuatro de «¿se puede lanzar y lánzalo?», compuestas con las funciones REALES.
          *
@@ -3750,7 +4234,7 @@ export async function arrancarConsolaWeb(opciones) {
         guardarProveedor: (declarado) => guardarProveedorPersonalizado(declarado),
         borrarProveedor: (slug) => borrarProveedorPersonalizado(slug),
         /**
-         * El AUMENTADOR de la ventana de crear una tarea (`agent/aumentador.ts`), con el papel
+         * El AUMENTADOR de la ventana de crear una tarea (`agent/tareas/aumentador.ts`), con el papel
          * `trabajo` — es una tarea de redacción, no una clasificación.
          *
          * Tres cosas que se deciden aquí:
@@ -3885,7 +4369,7 @@ function vestibuloReal(opciones, servidor, escribir, informar) {
         // Se resuelve UNA vez, aquí, y no en cada `anunciarAlta`: `git config`/`os.userInfo`
         // no cambian a media conexión, y repetir el subproceso en cada anuncio del alta sería
         // gastar sin motivo. Nunca viaja hacia CloudStudio ni hacia ningún acto —
-        // `agent/persona.ts` lo documenta—.
+        // `agent/config/persona.ts` lo documenta—.
         nombre: nombreDePersona(opciones.cwd),
         catalogoModelos: new CatalogoModelos(),
         guardarCredencial,
@@ -3898,7 +4382,7 @@ function vestibuloReal(opciones, servidor, escribir, informar) {
         guardarModeloGlobal,
         guardarConfigDeProyecto: escribirProyectoEnDisco,
         // El «antes» de cada sesión: se fotografía al abrir el proyecto y se nombra cuando la
-        // sesión tiene id. Ver `agent/sesionGit.ts` para por qué es una ref y no un tag.
+        // sesión tiene id. Ver `agent/sesiones/sesionGit.ts` para por qué es una ref y no un tag.
         marcarSesion: fotoDeApertura,
         // Lo que ya había sin commitear al abrir, para poder decirlo. Comparte el hueco
         // declarado de `marcarSesion`: esta composición vive en un cierre que `vestibuloReal`