xonecode 0.6.0 → 0.8.0

package/dist/web/servidor/arranque.js

@@ -62,8 +62,10 @@ import { aplicarAuth, aplicarCredencialAlProceso, cargar, guardarModeloGlobal, }
 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 { 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";
@@ -73,7 +75,7 @@ import { marcarTareaDeSesion, sembrarConsumosPendientes } from "./sesiones.js";
 import { RUTA_ARTEFACTOS, esRutaDeArtefacto } from "../../core/artefactos.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 { 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";
@@ -85,13 +87,14 @@ import { aplicarFeedback, TOPE_DE_ADJUNTO } from "../../agent/tareas/tareasEnDis
 import { nombreDeAdjuntoAceptable } from "../../core/adjuntos.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";
+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.
@@ -486,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.
      *
@@ -493,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.
      *
@@ -516,6 +537,8 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 // 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,
@@ -781,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()),
@@ -845,6 +901,20 @@ 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».
@@ -856,6 +926,9 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
         // 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
@@ -873,6 +946,8 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             cliente(skills);
             if (tareas !== undefined)
                 cliente(tareas);
+            if (workspace !== undefined)
+                cliente(workspace);
             if (consumoDeLaSesion !== undefined) {
                 cliente({
                     clase: "consumo",
@@ -1011,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;
@@ -1450,7 +1540,28 @@ 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
@@ -1876,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);
@@ -3329,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);
@@ -3366,6 +3577,12 @@ 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);
@@ -3841,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);
     /**
@@ -4040,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,
@@ -4143,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),
@@ -4227,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.
@@ -4393,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),