xonecode 0.5.1 → 0.8.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,48 +48,53 @@ 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 { 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 { 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, guardarWorkspace as guardarWorkspaceEnDisco, guardarDispositivos, guardarEntorno as guardarEntornoEnDisco, } from "../../agent/config/settingsEnDisco.js";
+import { dentroDelWorkspace, expandirConCasa, motivoDeWorkspaceInaceptable, seAplicaSinAprobacion, } from "../../core/settings.js";
+import { mudarWorkspaceLegado } from "../../agent/config/mudanzaEnDisco.js";
+import { elegirCarpetaEnMaquina, haySelectorDeCarpeta } from "../../agent/config/selectorEnMaquina.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, baseUrlDeOllama, baseUrlDeOllamaCloud, capacidadesDeOllama, } 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 { baseDeWorkspacePorOmision, conexionDeVestibulo, crearVestibulo, escribirProyectoEnDisco, esProyectoEnDisco, } from "./vestibulo.js";
+import { rutaMemoriaDeProyecto } from "../../agent/grafo/memoriaDeProyecto.js";
+import { crearAumentador, invocarParaAumentar } from "../../agent/tareas/aumentador.js";
+import { baseDeWorkspaceLegada, 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
 // pusiera rojo (F1 de la revisión final) — el patrón de fallo que este repo ya tiene
 // documentado cinco veces: una composición de producción dentro de algo que los tests
 // doblan.
 import { filaDeTarea } from "./transporte.js";
+import { esEsfuerzo, nivelesDeEsfuerzo } from "../../core/esfuerzo.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.
@@ -97,6 +105,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 +135,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 +278,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 +477,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 }),
         });
     };
     /**
@@ -444,6 +489,18 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      * recuerda —como fallo— hasta que alguien lo vuelva a pedir a propósito.
      */
     const catalogos = new Map();
+    /**
+     * Lo que el servidor de Ollama ha dicho de cada modelo, por `proveedor/modelo`.
+     *
+     * Es una memoria y no una caché con plazo: se llena la primera vez que ese modelo está en
+     * vigor y se vuelve a emitir el estado cuando llega. Ollama es el único que necesita esto
+     * —los demás salen de la tabla, que es síncrona—, y lo necesita porque sus modelos los
+     * elige el usuario: no hay prefijo que diga si `ministral-3:3b` piensa, pero `/api/show`
+     * sí lo contesta.
+     */
+    const capacidadesVivas = new Map();
+    /** Las que ya se están preguntando, para no lanzar una consulta por cliente conectado. */
+    const capacidadesEnVuelo = new Set();
     /**
      * El estado de modelos: qué está en vigor y qué se puede elegir.
      *
@@ -451,7 +508,13 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      * proyecto abierto no hay sesión y por tanto no hay modelo que afirmar: el campo se va
      * y el cliente pinta «Elige modelo» en vez de una fila muerta.
      */
-    const emitirModelos = () => emitir(mensajeDeModelos());
+    const emitirModelos = () => {
+        emitir(mensajeDeModelos());
+        // Después de emitir, no antes: lo que ya se sabe se pinta ya, y lo que falta llega en
+        // una segunda emisión. Al revés, cada cambio de modelo dejaría la pastilla esperando
+        // una consulta de red para pintar lo que no depende de ella.
+        asegurarCapacidades();
+    };
     /**
      * Los subagentes en vigor, compuestos pero sin mandar.
      *
@@ -471,9 +534,17 @@ 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 } : {}),
+                // Igual que arriba: ausente es «no hay ninguno fijado», que es un dato y no un hueco.
+                ...(a.esfuerzo === undefined ? {} : { esfuerzo: a.esfuerzo }),
                 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 +560,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 +632,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 +668,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 = () => {
@@ -534,10 +804,43 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         // pueda leer el config global. Sin el segundo, Ajustes enseñaría «sin elegir» sobre una
         // máquina con un defecto escrito, justo en la pantalla donde se configura.
         const porDefecto = opciones.modeloPorDefecto?.();
+        /**
+         * El esfuerzo del modelo EN VIGOR, que es lo único de lo que se puede afirmar algo.
+         *
+         * Sin sesión no hay modelo en vigor y no viaja: la pastilla no se pinta, igual que
+         * `actual` no se inventa. Los niveles salen de la tabla pura; para Ollama hacen falta
+         * las capacidades vivas, y mientras no hayan llegado tampoco se afirma nada — se
+         * piden aparte y el estado se vuelve a emitir cuando contesten.
+         */
+        const niveles = trabajo === undefined
+            ? undefined
+            : nivelesDeEsfuerzo(trabajo.proveedor, trabajo.modelo, capacidadesVivas.get(`${trabajo.proveedor}/${trabajo.modelo}`));
+        const elegido = abierto?.estadoDeSesion.esfuerzo;
         return {
             clase: "modelos",
             ...(trabajo === undefined ? {} : { actual: `${trabajo.proveedor}/${trabajo.modelo}` }),
             ...(porDefecto === undefined ? {} : { porDefecto }),
+            ...(niveles === undefined
+                ? {}
+                : {
+                    esfuerzo: {
+                        niveles: [...niveles],
+                        // El nivel guardado solo viaja si ESTE modelo lo admite. Si no, la pastilla
+                        // diría «xhigh» sobre un modelo que va a ignorarlo — el valor sigue en la
+                        // sesión y vuelve solo al cambiar a un modelo que lo acepte.
+                        ...(elegido !== undefined && niveles.includes(elegido) ? { actual: elegido } : {}),
+                        // La nota de Ollama, MEDIDA: su servidor valida los cuatro niveles, pero el
+                        // efecto lo pone el template de cada modelo y no es monótono —en
+                        // `glm-5.3-flash:cloud`, `high` mide menos razonamiento que `medium`—.
+                        // Callarlo haría que la pastilla afirmara una escala que ahí no existe.
+                        ...(trabajo?.proveedor === "ollama" || trabajo?.proveedor === "ollama-cloud"
+                            ? {
+                                nota: "En Ollama el efecto de cada nivel lo decide el modelo, no el servidor:"
+                                    + " medido, en algunos «high» razona MENOS que «medium».",
+                            }
+                            : {}),
+                    },
+                }),
             proveedores: [...PROVEEDORES, ...idsPersonalizados()].map((p) => ({
                 id: p,
                 nombre: nombreDeProveedor(p, personalizados()),
@@ -598,13 +901,34 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         for (const cliente of destinatarios)
             actos = destino.conectar(cliente);
         const modelos = mensajeDeModelos();
+        /**
+         * Y se pregunta por lo que falte, que en esta rama hay que pedir A MANO.
+         *
+         * La ráfaga COMPONE el mensaje en vez de emitirlo —va solo al recién llegado—, así que
+         * no pasa por `emitirModelos` y sin esta línea el camino más normal de todos —abrir el
+         * navegador sobre un proyecto ya abierto— no preguntaba nunca: la pastilla de esfuerzo
+         * no aparecía con Ollama hasta que algo más provocara una emisión. Lo encontró el test
+         * del cable, que es exactamente el patrón de fallo de esta arquitectura.
+         *
+         * No se mete DENTRO de `mensajeDeModelos` porque eso es un compositor: un efecto de red
+         * escondido en la función que arma un mensaje es la clase de cosa que luego dispara
+         * desde sitios que nadie esperaba.
+         */
+        asegurarCapacidades();
         // Los subagentes van en la ráfaga por lo mismo que los modelos: la ventana de ajustes
         // 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();
+        // El workspace, por lo mismo que los subagentes y las skills: Ajustes se puede abrir en
+        // cuanto conecta, y un campo en blanco se lee como «no hay ninguno puesto».
+        const workspace = mensajeDeWorkspace();
         /**
          * Lo consumido por la sesión que se va a pintar. Va en la ráfaga por lo mismo que los
          * modelos: una pestaña que conecta a mitad de sesión no vio los cambios anteriores, y
@@ -619,8 +943,11 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             cliente({ clase: "reemision", actos: [...actos] });
             cliente(modelos);
             cliente(agentes);
+            cliente(skills);
             if (tareas !== undefined)
                 cliente(tareas);
+            if (workspace !== undefined)
+                cliente(workspace);
             if (consumoDeLaSesion !== undefined) {
                 cliente({
                     clase: "consumo",
@@ -708,20 +1035,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);
@@ -746,6 +1086,21 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
     });
     /** Los cuatro nombres conocidos y nada más: lo que llega por el cable no elige binario. */
     const esNombreDeHerramienta = (v) => v === "adb" || v === "emulator" || v === "xcrun" || v === "devicectl";
+    const mensajeDeWorkspace = () => {
+        const ruta = opciones.workspace?.();
+        if (ruta === undefined)
+            return undefined;
+        // `puedeElegir` va solo cuando es cierto: ausente ya significa que no, y un `false`
+        // escrito solo daría dos formas de decir lo mismo.
+        return opciones.elegirCarpeta === undefined
+            ? { clase: "workspace", ruta }
+            : { clase: "workspace", ruta, puedeElegir: true };
+    };
+    const emitirWorkspace = () => {
+        const m = mensajeDeWorkspace();
+        if (m !== undefined)
+            emitir(m);
+    };
     const mensajeDeTareas = () => {
         if (opciones.colaDeTareas === undefined)
             return undefined;
@@ -1033,7 +1388,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 +1406,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 +1421,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 +1441,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ó.
      *
@@ -1125,11 +1540,32 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         }
         try {
             const modelos = await opciones.catalogoDeModelos(id);
-            catalogos.set(id, { modelos: modelos.map((m) => ({ id: m.id, ...(m.nombre === undefined ? {} : { nombre: m.nombre }) })) });
+            /**
+             * Cada modelo viaja con los niveles de esfuerzo que ADMITE, y se calculan aquí.
+             *
+             * Aquí y no en el cliente porque la tabla vive en `core/esfuerzo.ts` y la frontera
+             * prohíbe que `apps/web/` importe de `src/`. La alternativa era una copia DECLARADA
+             * al otro lado —como la del slug o la del workspace—, y no compensa: aquéllas son una
+             * regla de tres líneas, y ésta es una tabla por familia que además cambia cada vez que
+             * alguien MIDE un modelo nuevo. Dos tablas es un sitio donde una queda vieja sin que
+             * nada lo diga.
+             *
+             * Ausente = ese modelo no admite ninguno, y entonces el control no se pinta.
+             */
+            catalogos.set(id, {
+                modelos: modelos.map((m) => {
+                    const niveles = nivelesDeEsfuerzo(id, m.id);
+                    return {
+                        id: m.id,
+                        ...(m.nombre === undefined ? {} : { nombre: m.nombre }),
+                        ...(niveles === undefined ? {} : { esfuerzos: [...niveles] }),
+                    };
+                }),
+            });
         }
         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 +1906,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?.();
@@ -1526,6 +1987,72 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      * Si no hay escritor, se DICE que no se ha guardado en vez de callarlo: un ajuste que
      * parece puesto y no lo está es peor que uno que falta.
      */
+    /**
+     * El esfuerzo de la sesión abierta. `nivel` ausente = quitarlo.
+     *
+     * Se encola `/esfuerzo`, que es el MISMO manejador que usa el terminal: la función se
+     * comparte y la sintaxis no se exporta, igual que con `/modelo`. Y **no se guarda ningún
+     * defecto**: a diferencia del modelo, esto es de la sesión y solo de la sesión — un
+     * defecto persistido es otra decisión y no se toma por inercia.
+     *
+     * Sin proyecto abierto no hay sesión a la que aplicárselo, y se DICE en vez de callarlo:
+     * la pastilla solo se pinta con sesión, así que llegar aquí sin ella es un cliente
+     * desincronizado y merece una frase, no un silencio.
+     */
+    const atenderEsfuerzo = (nivel) => {
+        const abierto = vestibulo.proyectoAbierto();
+        if (abierto === undefined) {
+            informar("no hay ninguna sesión abierta a la que fijarle el esfuerzo");
+            return;
+        }
+        if (nivel === undefined) {
+            abierto.consola.encolar("/esfuerzo ninguno");
+            return;
+        }
+        // Se criba contra el vocabulario ANTES de encolar: lo que llega del cable acaba siendo
+        // un parámetro de una API, y el manejador ya lo rechazaría, pero su rechazo se
+        // imprimiría como una línea de consola en vez de un aviso. Aquí se dice mejor.
+        if (!esEsfuerzo(nivel)) {
+            informar(`«${nivel}» no es un nivel de esfuerzo`);
+            return;
+        }
+        abierto.consola.encolar(`/esfuerzo ${nivel}`);
+    };
+    /**
+     * Pregunta a Ollama si el modelo en vigor piensa, y vuelve a emitir cuando conteste.
+     *
+     * Una vez por modelo y por proceso: la respuesta se guarda en `capacidadesVivas`, y sin
+     * el conjunto `capacidadesEnVuelo` cada cliente que se conecta lanzaría la suya. Mismo
+     * molde que `catalogos`.
+     *
+     * Solo Ollama, porque solo Ollama lo necesita: los demás salen de la tabla, que es pura
+     * y síncrona. Y su fallo se TRAGA — lo que no se pudo preguntar deja la pastilla sin
+     * pintar, que es la dirección segura y ya es lo que pasaba antes de que esto existiera.
+     */
+    const asegurarCapacidades = () => {
+        if (opciones.capacidadesDeModelo === undefined)
+            return;
+        const abierto = vestibulo.proyectoAbierto();
+        if (abierto === undefined)
+            return;
+        const trabajo = resolver(abierto.estadoDeSesion.fuentes).trabajo;
+        if (trabajo.proveedor !== "ollama" && trabajo.proveedor !== "ollama-cloud")
+            return;
+        const clave = `${trabajo.proveedor}/${trabajo.modelo}`;
+        if (capacidadesVivas.has(clave) || capacidadesEnVuelo.has(clave))
+            return;
+        capacidadesEnVuelo.add(clave);
+        void opciones
+            .capacidadesDeModelo(trabajo.proveedor, trabajo.modelo)
+            .then((vivas) => {
+            if (vivas !== undefined) {
+                capacidadesVivas.set(clave, vivas);
+                emitirModelos();
+            }
+        })
+            .catch(() => { })
+            .finally(() => capacidadesEnVuelo.delete(clave));
+    };
     const atenderModelo = (id) => {
         try {
             parsear(id);
@@ -1761,7 +2288,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 +2305,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 +3039,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 +3240,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 +3428,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`.
@@ -2875,6 +3506,40 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "workspace" && typeof mensaje.ruta === "string") {
+            /**
+             * La regla se aplica AQUÍ además de en la pantalla. El cliente lleva su copia
+             * declarada para poder explicar el no —`informar` no llega al navegador desde el
+             * vestíbulo—, pero la barrera vive en el servidor: una pantalla solo esconde un botón.
+             *
+             * Y se reemite SIEMPRE, se haya escrito o no: con el valor nuevo cuando valió y con el
+             * de antes cuando no, así el campo acaba enseñando lo que hay en disco y no lo que se
+             * tecleó. Un rechazo mudo dejaría la pantalla afirmando un ajuste que no está puesto.
+             */
+            opciones.guardarWorkspace?.(mensaje.ruta);
+            emitirWorkspace();
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "elegirCarpeta") {
+            /**
+             * El diálogo lo abre el SISTEMA donde corre la consola, así que esto tarda lo que
+             * tarde una persona. Se contesta 204 en el acto y la carpeta llega después por el SSE:
+             * dejar la petición abierta minutos enteros es lo que este servidor no hace en ningún
+             * otro sitio.
+             *
+             * Se emite SIEMPRE, también sin carpeta: el cliente encendió su «abriendo…» al pedirlo
+             * y sin respuesta se quedaría encendido para siempre después de un simple «cancelar».
+             */
+            void (async () => {
+                const elegida = await opciones.elegirCarpeta?.(opciones.workspace?.());
+                emitir(elegida === undefined ? { clase: "carpetaElegida" } : { clase: "carpetaElegida", ruta: elegida });
+            })().catch(contar);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "modelosDeMotor" && typeof mensaje.motor === "string") {
             void atenderModelosDeMotor(mensaje.motor).catch(contar);
             respuesta.writeHead(204);
@@ -2912,12 +3577,30 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "esfuerzo") {
+            atenderEsfuerzo(mensaje.nivel);
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "agente") {
             atenderAgente(mensaje);
             respuesta.writeHead(204);
             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 +3717,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 +3776,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
@@ -3362,12 +4058,71 @@ export function augmentacionCableada(opciones) {
 export function commitDeTurnoCableado(opciones) {
     const commitear = opciones.commitear ?? commitDeTurno;
     return async (raiz, mensaje, sesion) => {
-        if (!dentroDelWorkspace(raiz, opciones.base))
+        if (!dentroDelWorkspace(raiz, opciones.base()))
             return undefined;
         const hecho = await commitear(raiz, mensaje, sesion);
         return hecho.via === "fallo" ? `no se pudo commitear el turno: ${hecho.motivo}` : undefined;
     };
 }
+/**
+ * La mudanza de una vez de las copias que siguen en el reparto viejo, cableada — y extraída
+ * por el motivo de siempre: compuesta dentro del cierre de `arrancarConsolaWeb`, que todos
+ * sus tests doblan, la regla estaría escrita y no probada.
+ *
+ * Lo que aquí se puede caer sin que TypeScript diga nada son las DOS bases, que no son la
+ * misma cuenta: la VIEJA es `settings.workspace` si estaba puesto —el reparto viejo metía su
+ * `workspace/` en medio fuera cual fuera la base— o `~/.xonecode` a secas; la de AHORA es ese
+ * mismo `settings.workspace` o `~/.xonecode/workspace`. Confundirlas en cualquiera de los dos
+ * sentidos da el mismo resultado: una mudanza que no encuentra nada y no dice nada.
+ *
+ * Y se ESCRIBE en el terminal, nunca por el cable: lo que se cuenta son rutas de la máquina
+ * y nombres de proyecto (`sinRutas`). Corre antes de que exista el vestíbulo, así que ni
+ * siquiera hay cable donde emitirlo.
+ */
+export function mudarWorkspaceLegadoCableado(opciones) {
+    const mudar = opciones.mudar ?? mudarWorkspaceLegado;
+    return mudar({
+        legado: opciones.settings.workspace ?? baseDeWorkspaceLegada(),
+        workspace: opciones.settings.workspace ?? baseDeWorkspacePorOmision(),
+        entornos: opciones.settings.entornos.map((e) => e.id),
+        escribir: opciones.escribir,
+    });
+}
+/**
+ * Las dos mitades del ajuste del workspace, cableadas — y extraídas por el motivo de
+ * siempre: dentro del cierre de `arrancarConsolaWeb`, que todos sus tests doblan, ni una ni
+ * otra estaría probada. Y aquí `guardarWorkspace` LLEVABA la marca: existía en
+ * `agent/config/settingsEnDisco.ts` con un test propio y CERO llamadores de producción, o
+ * sea el ajuste escrito que no hacía nada porque nadie lo había enchufado.
+ *
+ * Tres cosas que se deciden aquí y no en la pantalla:
+ * - **Qué se LEE**: el disco, en cada emisión, no un valor capturado al arrancar. Es la misma
+ *   regla que `baseDeWorkspace`, y aquí además cierra el lazo: lo que se acaba de guardar es
+ *   lo que se vuelve a emitir.
+ * - **Qué se ACEPTA**: `motivoDeWorkspaceInaceptable` sobre la ruta ya expandida, en el
+ *   servidor. El cliente lleva su copia declarada para explicar el no, pero una pantalla
+ *   solo esconde un botón.
+ * - **Qué se GUARDA y qué se ENSEÑA**: la ruta ENTERA, nunca un `~/…`. En el fichero porque
+ *   la casa cambia de una máquina a otra y un `~` dentro solo significa algo para quien lo
+ *   escribió; en la pantalla porque una ruta abreviada no se puede comprobar de un vistazo,
+ *   que es para lo que ese campo existe. Se probó a mandarla abreviada —para que el caso
+ *   normal no llevara el nombre de la cuenta— y no se sostiene: la cabecera de esa misma
+ *   consola ya saluda por el nombre del usuario. El `~` sigue ACEPTÁNDOSE al teclear, que es
+ *   comodidad de entrada y otra cosa.
+ */
+export function ajusteDeWorkspaceCableado(opciones) {
+    const leer = opciones.leer ?? (() => cargarSettings().settings.workspace);
+    const guardar = opciones.guardar ?? ((ruta) => void guardarWorkspaceEnDisco(undefined, ruta));
+    return {
+        workspace: () => leer() ?? baseDeWorkspacePorOmision(),
+        guardarWorkspace: (ruta) => {
+            const absoluta = expandirConCasa(ruta, opciones.casa);
+            if (motivoDeWorkspaceInaceptable(absoluta) !== undefined)
+                return;
+            guardar(absoluta);
+        },
+    };
+}
 export function construirCorredorDeTareasCableado(opciones) {
     const disco = opciones.tareasFabrica === undefined ? undefined : opciones.tareasFabrica(opciones.informar);
     /**
@@ -3561,6 +4316,17 @@ export async function arrancarConsolaWeb(opciones) {
     if (offline && opciones.guion !== true) {
         escribir("este directorio es un proyecto offline: ábrelo con «xonecode --cli»\n");
     }
+    /**
+     * La mudanza del reparto viejo, ANTES de que exista el vestíbulo y de que arranque el
+     * corredor de tareas. El orden no es estético: el vestíbulo compone raíces con el reparto
+     * de AHORA y una tarea pendiente lleva su raíz grabada, así que cualquiera de los dos
+     * corriendo antes abriría una carpeta que esta función está a punto de mover.
+     *
+     * Y va aquí y no en el vestíbulo porque no es del vestíbulo: es de la MÁQUINA, pasa una
+     * sola vez, y cuando no quede nadie con el reparto viejo en disco se retira de un tirón
+     * junto con `core/mudanzaDeWorkspace.ts`.
+     */
+    mudarWorkspaceLegadoCableado({ settings: cargarSettings().settings, escribir });
     const arrancar = opciones.crearServidor ?? arrancarServidor;
     const servidor = await arrancar({
         puerto: opciones.puerto,
@@ -3664,6 +4430,15 @@ export async function arrancarConsolaWeb(opciones) {
         // la raíz que la tarea necesita para poder correr. Ver el comentario de
         // `OpcionesDeMontaje.colaDeTareas`.
         ...opcionesDeTareas,
+        // Dónde se bajan las copias: leerlo y elegirlo. La composición está EXTRAÍDA y probada
+        // (`ajusteDeWorkspaceCableado`) por el patrón de fallo de siempre — y aquí el escritor
+        // ya venía con la marca puesta: existía con su test y sin un solo llamador.
+        ...ajusteDeWorkspaceCableado({ 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()
+            ? { elegirCarpeta: (desde) => elegirCarpetaEnMaquina(desde === undefined ? {} : { desde }) }
+            : {}),
         // Los dos puertos del selector de modelos, con las piezas reales: quién tiene
         // credencial (`auth.json` o el entorno, leído desde el cwd) y el catálogo VIVO.
         hayCredencial: (proveedor) => hayCredencial(proveedor, opciones.cwd),
@@ -3673,7 +4448,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 +4474,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 +4489,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.
          *
@@ -3743,6 +4523,14 @@ export async function arrancarConsolaWeb(opciones) {
             const modelos = await new CatalogoModelos(undefined, undefined, proveedoresPersonalizados).listar(proveedor);
             return modelos.map((m) => ({ id: m.id, ...(m.nombre === undefined ? {} : { nombre: m.nombre }) }));
         },
+        /**
+         * Solo Ollama tiene a quién preguntarle esto, y por eso los demás devuelven «no consta»
+         * aquí en vez de que lo decida `asegurarCapacidades`: quien sabe qué proveedores saben
+         * contestar es este cableado, no el servidor.
+         */
+        capacidadesDeModelo: async (proveedor, modelo) => proveedor === "ollama" || proveedor === "ollama-cloud"
+            ? capacidadesDeOllama(modelo, proveedor === "ollama" ? baseUrlDeOllama() : baseUrlDeOllamaCloud())
+            : undefined,
         // Se releen de disco en cada consulta, igual que los ajustes de dispositivos: esta
         // misma ventana los da de alta, y una lista capturada al montar las rutas se quedaría
         // vieja hasta reiniciar el proceso.
@@ -3750,7 +4538,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 +4673,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 +4686,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`
@@ -3909,14 +4697,25 @@ function vestibuloReal(opciones, servidor, escribir, informar) {
         // El commit del turno, con el sello de la sesión. La composición está EXTRAÍDA y probada
         // (`commitDeTurnoCableado`): el argumento que se cae en una lambda escrita a mano es
         // justo el que sostiene la atribución de Revisión.
-        commitearTurno: commitDeTurnoCableado({ base: settings.workspace ?? baseDeWorkspacePorOmision() }),
+        commitearTurno: commitDeTurnoCableado({
+            base: () => cargarSettings().settings.workspace ?? baseDeWorkspacePorOmision(),
+        }),
         olvidarMarcaDeSesion: olvidarSesion,
         // La memoria del agente por hilo. `historica` deja de ser «se reabrió» para ser «no hay
         // checkpoint que cargar», y borrar una sesión se lleva también su checkpoint.
         hayMemoriaDeHilo: async (raiz, hilo) => hayCheckpoint(crearCheckpointerDeProyecto(raiz), hilo),
         olvidarMemoriaDeHilo: async (raiz, hilo) => olvidarHilo(crearCheckpointerDeProyecto(raiz), hilo),
         entornos: settings.entornos,
-        ...(settings.workspace === undefined ? {} : { baseDeWorkspace: settings.workspace }),
+        /**
+         * Dónde se bajan las copias, RELEÍDO en cada uso y no resuelto aquí.
+         *
+         * `settings.workspace` se cambia desde Ajustes con la consola en marcha, así que un
+         * valor capturado al arrancar dejaría el resto del proceso bajando al sitio de antes
+         * mientras la pantalla enseña el nuevo — el ajuste escrito que no hace nada. Es lo
+         * mismo que ya hacen `sinAprobacion` y el tope de concurrencia, y por lo mismo: releer
+         * un JSON pequeño no cuesta nada al lado de equivocarse de carpeta.
+         */
+        baseDeWorkspace: () => cargarSettings().settings.workspace ?? baseDeWorkspacePorOmision(),
         // La URL de la web para que la página del callback devuelva AQUÍ y no diga «vuelve a
         // la terminal», que en un navegador es falso.
         ...conexionDeVestibulo(servidor.url),