xonecode 0.3.0 → 0.5.1

package/dist/cli/consola.js

@@ -7,6 +7,7 @@
  * lista de líneas y un acumulador. Sin esa costura la consola no se puede probar.
  */
 import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { cmdConfig } from "./config.js";
@@ -15,21 +16,250 @@ import { cmdDoctor } from "./doctor.js";
 import { cmdVerify } from "./verify.js";
 import { AgenteGuionizado } from "../agent/guionizado.js";
 import { correrTurno } from "../core/turno.js";
-import { PAPELES, POR_OMISION, ModeloMalEscrito, parsear, PROVEEDORES } from "../core/modelos.js";
-import { esDoble } from "../core/ports.js";
+import { PAPELES, POR_OMISION, ModeloMalEscrito, parsear, PROVEEDORES, VARIABLES_POR_PROVEEDOR, esProveedorPersonalizado, variableDeProveedor, } from "../core/modelos.js";
+import { motivoDeClaveInaceptable } from "../core/config.js";
+import { ES_DOBLE, esDoble } from "../core/ports.js";
+import { interpretAnswer } from "../vendor/hitl.js";
 import { crearPielStdio } from "./stdio.js";
+import { esTema, seleccionarTema, TEMAS } from "./tema.js";
+import { acuseDeModelo } from "./acuseDeModelo.js";
 import { guardarCredencial, AuthRotoEnDisco } from "../agent/authEnDisco.js";
-import { cargar, NOMBRE_CARPETA } from "../agent/configEnDisco.js";
+import { cargarSettings, guardarSinAprobacion } from "../agent/settingsEnDisco.js";
+import { seAplicaSinAprobacion } from "../core/settings.js";
+import { URL_CLOUDSTUDIO_POR_OMISION } from "../agent/cloudstudioMcp.js";
+import { cargar, cloudstudioDelProyecto, NOMBRE_CARPETA } from "../agent/configEnDisco.js";
+import { rutaMemoriaDeProyecto } from "../agent/memoriaDeProyecto.js";
 /**
- * Duplicado a propósito de `cli/config.ts` (que a su vez lo duplica de
- * `agent/configEnDisco.ts`, no exportado y no tocable): misma regla y misma
- * omisión — `ollama` no lleva variable porque no necesita credencial.
+ * Saludo local de la consola. No procede del modelo ni se incorpora al hilo: debe hacer
+ * visible que xonecode está listo sin gastar tokens ni sesgar la primera petición.
  */
-const VARIABLE_POR_PROVEEDOR = {
-    anthropic: "ANTHROPIC_API_KEY",
-    openai: "OPENAI_API_KEY",
-    gemini: "GOOGLE_API_KEY",
-};
+export const MENSAJE_BIENVENIDA = "¡Bienvenido a xonecode! Puedo analizar, explicar y modificar tu proyecto XOne. Escribe `/` para ver los comandos o cuéntame qué necesitas.\n";
+/**
+ * Hay estado que retomar solo cuando existe la memoria del PROYECTO. Una carpeta
+ * `.xonecode` con `config.json` aislado no representa trabajo anterior y debe conservar
+ * el saludo de primera visita.
+ */
+export function hayEstadoDeProyecto(raiz) {
+    return existsSync(rutaMemoriaDeProyecto(raiz));
+}
+/**
+ * Petición interna de reanudación. Es deliberadamente de solo lectura y estrecha para
+ * que abrir una sesión existente no se convierta en otra exploración exhaustiva.
+ */
+export const PETICION_REANUDAR_PROYECTO = "Reanuda el proyecto. Lee solo /MEMORIA_PROYECTO.md y resume brevemente el contexto, " +
+    "los pendientes confirmados y el siguiente paso recomendado. No modifiques nada, no cargues skills " +
+    "ni explores el código salvo que la memoria cite una ruta imprescindible para aclarar un pendiente; " +
+    "en ese caso lee solo sus primeras 50 líneas. Termina preguntando si quieres continuar ese paso.";
+export const MENSAJE_REANUDANDO = "Analizando el estado guardado del repositorio…\n";
+// Movida a `agent/cloudstudioMcp.ts`: es la dirección de un servidor, no un detalle de
+// esta piel, y `adoptarLegadoSiProcede` (Task 4 del plan de la consola web) la necesita
+// desde `agent/`, que no puede importar de `cli/`. Se reexporta para no romper a quien
+// la importaba de aquí.
+export { URL_CLOUDSTUDIO_POR_OMISION };
+const SCOPES_STUDIO_LECTURA = ["openid", "profile", "email", "offline_access", "mcp.read"];
+const SCOPES_STUDIO_AGENTE = [
+    "openid", "profile", "email", "offline_access", "xonewebstudioapi",
+    "mcp.read", "mcp.write", "mcp.execute", "mcp.branch",
+];
+function modoStudio(valor) {
+    if (valor === "lectura")
+        return { nombre: "lectura", scopes: SCOPES_STUDIO_LECTURA };
+    if (valor === undefined || valor === "agente")
+        return { nombre: "agente", scopes: SCOPES_STUDIO_AGENTE };
+    return undefined;
+}
+/**
+ * Primer contacto con una carpeta. En pipes no se crea estado ni se pregunta: el modo
+ * offline histórico permanece exactamente igual. Cloud se persiste SOLO después de
+ * autenticar y descubrir el MCP, de modo que un login cancelado deja la carpeta virgen.
+ */
+export async function configurarModoInicial(raiz, consola) {
+    if (existsSync(join(raiz, NOMBRE_CARPETA)) || !consola.interactivo || consola.guardarModoDeProyecto === undefined)
+        return;
+    let modo;
+    if (consola.seleccionar !== undefined) {
+        const elegido = await consola.seleccionar({
+            titulo: "Modo de proyecto",
+            opciones: [
+                { id: "cloud", etiqueta: "Cloud connected", detalle: "Conecta CloudStudio y trabaja sobre una copia sincronizada." },
+                { id: "offline", etiqueta: "Offline", detalle: "Trabaja solo con los ficheros presentes en esta carpeta." },
+            ],
+        });
+        modo = elegido === "cloud" || elegido === "offline" ? elegido : undefined;
+    }
+    else {
+        consola.escribir("modo de proyecto:\n  1. Cloud connected\n  2. Offline\n");
+        const elegido = (await consola.preguntar("número (Enter cancela): ")).trim();
+        modo = elegido === "1" ? "cloud" : elegido === "2" ? "offline" : undefined;
+    }
+    if (modo === undefined) {
+        consola.escribir("inicio cancelado: elige un modo para crear .xonecode\n");
+        return;
+    }
+    if (modo === "offline") {
+        consola.guardarModoDeProyecto("offline");
+        consola.escribir("→ Modo offline listo\n");
+        return;
+    }
+    if (consola.conectarCloudStudio === undefined || consola.guardarCloudStudioDeProyecto === undefined || consola.guardarProyectoCloudStudioDeProyecto === undefined) {
+        consola.escribir("CloudStudio no está disponible en esta ejecución; no se ha creado .xonecode\n");
+        return;
+    }
+    // El endpoint es parte de la identidad del entorno: incluso teniendo uno oficial
+    // por omisión, el primer arranque debe permitir elegir el CloudStudio concreto.
+    // Enter conserva la URL pública sin obligar a teclearla.
+    const escrita = await consola.preguntar(`URL MCP de CloudStudio [${URL_CLOUDSTUDIO_POR_OMISION}]: `);
+    const url = escrita.trim() || URL_CLOUDSTUDIO_POR_OMISION;
+    consola.escribir("Configurando CloudStudio…\n");
+    let resultado;
+    try {
+        resultado = await consola.conectarCloudStudio(url, SCOPES_STUDIO_AGENTE, consola.escribir);
+    }
+    catch (error) {
+        // El asistente inicial nunca puede tirar abajo la consola: ni un OAuth cancelado
+        // ni un MCP con un catálogo distinto deben dejar la carpeta a medio configurar.
+        const detalle = error instanceof Error ? error.message : String(error);
+        consola.escribir(`No se pudo conectar a CloudStudio: ${detalle}\n`);
+        consola.escribir("No se ha creado .xonecode. Reinicia xonecode para elegir Offline o probar otra URL.\n");
+        return;
+    }
+    if (resultado.proyectos.length === 0) {
+        consola.escribir("CloudStudio no devolvió proyectos seleccionables; no se ha creado .xonecode\n");
+        return;
+    }
+    let id;
+    if (consola.seleccionar !== undefined) {
+        id = await consola.seleccionar({
+            titulo: "Proyecto de CloudStudio",
+            opciones: resultado.proyectos.map((proyecto) => ({ id: proyecto.id, etiqueta: proyecto.nombre, detalle: proyecto.id })),
+        });
+    }
+    else {
+        for (const [indice, proyecto] of resultado.proyectos.entries())
+            consola.escribir(`  ${indice + 1}. ${proyecto.nombre}\n`);
+        const indice = Number((await consola.preguntar("número (Enter cancela): ")).trim()) - 1;
+        id = Number.isInteger(indice) ? resultado.proyectos[indice]?.id : undefined;
+    }
+    const proyecto = resultado.proyectos.find((candidato) => candidato.id === id);
+    if (proyecto === undefined) {
+        consola.escribir("selección cancelada; no se ha creado .xonecode\n");
+        return;
+    }
+    consola.guardarCloudStudioDeProyecto(resultado.url, resultado.scopes);
+    consola.guardarProyectoCloudStudioDeProyecto(proyecto);
+    // El modo se guarda YA: `sincronizar` (más abajo) relee la config del disco, y un
+    // fallo en la descarga no puede dejar «cloudstudio» apuntado sin ningún «modo».
+    consola.guardarModoDeProyecto("cloud");
+    // Paso 3: rama ORIGEN (de la que se baja y contra la que se compara) y descarga de la
+    // copia local. Las ramas entran inyectadas, hermanas de `conectarCloudStudio`: esta capa
+    // tampoco conoce MCP para esto. Hoy los proyectos suelen tener solo `master`, y con una
+    // sola opción no se pregunta: preguntar lo que no tiene alternativa es ruido.
+    let ramas = [];
+    try {
+        ramas = (await consola.ramasDeCloudStudio?.(proyecto.nombre)) ?? [];
+    }
+    catch (error) {
+        // Igual que el fallo de `conectarCloudStudio`: no puede tirar abajo un alta que ya
+        // guardó proyecto y modo. La rama cae al valor por defecto y se avisa.
+        const detalle = error instanceof Error ? error.message : String(error);
+        consola.escribir(`no se pudieron listar las ramas de CloudStudio: ${detalle}\n`);
+    }
+    let rama = ramas[0] ?? "master";
+    if (ramas.length > 1) {
+        let elegida;
+        if (consola.seleccionar !== undefined) {
+            elegida = await consola.seleccionar({
+                titulo: "Rama origen",
+                opciones: ramas.map((r) => ({ id: r, etiqueta: r })),
+            });
+        }
+        else {
+            consola.escribir("rama origen:\n");
+            for (const [indice, r] of ramas.entries())
+                consola.escribir(`  ${indice + 1}. ${r}\n`);
+            const indice = Number((await consola.preguntar("número (Enter cancela): ")).trim()) - 1;
+            elegida = Number.isInteger(indice) ? ramas[indice] : undefined;
+        }
+        if (elegida === undefined) {
+            // A diferencia de la cancelación del modo o del proyecto, aquí YA se guardó
+            // `cloudstudio` y `modo: "cloud"`: decir «no se ha creado .xonecode» sería mentir.
+            // Se cae a la primera rama en vez de dejar el proyecto sin rama origen.
+            consola.escribir(`selección cancelada; se usa «${rama}» como rama origen\n`);
+        }
+        else {
+            rama = elegida;
+        }
+    }
+    consola.guardarRamaDeProyecto?.(rama);
+    if (consola.sincronizar !== undefined) {
+        consola.escribir("Descargando el proyecto…\n");
+        try {
+            const bajada = await consola.sincronizar("bajar", raiz, undefined, consola.escribir);
+            if (bajada.tipo === "texto")
+                consola.escribir(bajada.texto);
+            else {
+                // El alta es el camino por el que se pierde trabajo sin haber escrito `/sync`:
+                // quien arranca xonecode en una carpeta con trabajo y elige modo cloud. Bajar
+                // sobrescribe el disco, así que aquí se dice qué hay y NO se baja nada.
+                consola.escribir(`no se ha descargado nada: hay trabajo local sin commitear (${bajada.pendientes.join(", ")}). ` +
+                    "La descarga sobrescribe el disco; commitea (o guarda) y usa /sync bajar\n");
+            }
+        }
+        catch (error) {
+            // Un fallo de red o de servidor durante la descarga no puede tirar abajo el alta:
+            // .xonecode ya quedó escrito y el usuario puede reintentar con /sync bajar.
+            const detalle = error instanceof Error ? error.message : String(error);
+            consola.escribir(`no se pudo descargar el proyecto: ${detalle}; prueba /sync bajar\n`);
+        }
+    }
+    // Paso 4: modelo propio del proyecto, opcional. Por omisión NO: hereda el global, que
+    // es lo que el usuario acaba de elegir en el asistente de cuenta.
+    if (consola.guardarModelosDeProyecto !== undefined) {
+        let quierePropio = false;
+        if (consola.seleccionar !== undefined) {
+            const elegido = await consola.seleccionar({
+                titulo: "Modelo de este proyecto",
+                opciones: [
+                    { id: "global", etiqueta: "Usar el modelo global", detalle: "lo normal" },
+                    { id: "propio", etiqueta: "Elegir uno solo para este proyecto" },
+                ],
+            });
+            quierePropio = elegido === "propio";
+        }
+        else {
+            consola.escribir("modelo de este proyecto:\n  1. Usar el modelo global\n  2. Elegir uno para este proyecto\n");
+            quierePropio = (await consola.preguntar("número (Enter = usar el global): ")).trim() === "2";
+        }
+        if (quierePropio) {
+            let proveedor;
+            if (consola.seleccionar !== undefined) {
+                const elegido = await consola.seleccionar({
+                    titulo: "Proveedor del modelo de este proyecto",
+                    opciones: PROVEEDORES.map((p) => ({ id: p, etiqueta: p })),
+                });
+                proveedor = validarProveedor(elegido);
+            }
+            else {
+                consola.escribir(`proveedores: ${PROVEEDORES.join(", ")}\n`);
+                proveedor = validarProveedor((await consola.preguntar("proveedor: ")).trim());
+            }
+            if (proveedor === undefined) {
+                consola.escribir("proveedor inválido; se mantiene el modelo global\n");
+            }
+            else {
+                const modeloId = await seleccionarModelo(proveedor, consola);
+                if (modeloId !== undefined) {
+                    const id = `${proveedor}/${modeloId}`;
+                    for (const papel of PAPELES)
+                        consola.guardarModelosDeProyecto(papel, id);
+                    consola.escribir(`→ ${id} guardado para este proyecto\n`);
+                }
+            }
+        }
+    }
+    // No se vuelca el catálogo: es configuración de transporte, no parte de la conversación.
+    consola.escribir("→ Entorno cloud listo\n");
+}
 /**
  * Un turno con `AgenteGuionizado`, igual que el `cmdRun` sin `--real`.
  *
@@ -39,7 +269,9 @@ const VARIABLE_POR_PROVEEDOR = {
  */
 export async function ejecutarTurnoGuionizado(peticion, _estado, consola) {
     const agente = new AgenteGuionizado();
-    const piel = crearPielStdio(consola.escribir);
+    // La costura: la piel de la consola si la aporta (la TUI), y el render stdio de siempre
+    // si no — el camino de hoy, byte-idéntico cuando el campo no está.
+    const piel = consola.piel?.() ?? crearPielStdio(consola.escribir);
     if (esDoble(agente)) {
         consola.escribir("⚠  AGENTE DE PEGA: esto es un guion, no ha corrido ningún modelo.\n\n");
     }
@@ -47,6 +279,13 @@ export async function ejecutarTurnoGuionizado(peticion, _estado, consola) {
         avisos: (b) => (b.corrio("verify") && esDoble(agente) ? ["⚠  El veredicto es de pega."] : []),
     });
 }
+// La función entera es de pega, no un turno suyo en concreto: TODO turno que pase por aquí
+// usa `new AgenteGuionizado()`, así que la marca no depende de qué pasó en esta llamada.
+// `web/servidor/vestibulo.ts#volcar` la mira para decidir si un turno se escribe a
+// `.xonecode/sesiones/` — un transcript de pega indistinguible de uno real ensuciaría el
+// historial del proyecto, y la decisión tiene que tomarla esta marca y no un booleano ni
+// una bandera leída del argv, por la misma razón de siempre: se puede olvidar.
+ejecutarTurnoGuionizado[ES_DOBLE] = true;
 /** El nombre del tipo de error y su mensaje: «ModeloMalEscrito: ...» no cuenta lo mismo que «Error: ...». */
 function describirError(e) {
     if (e instanceof Error)
@@ -61,6 +300,221 @@ function describirError(e) {
 function rutaAuthParaAviso() {
     return join(homedir(), NOMBRE_CARPETA, "auth.json");
 }
+/** Filtra por id o nombre sin alterar el orden publicado por el proveedor. */
+export function filtrarModelos(modelos, filtro) {
+    const buscado = filtro.trim().toLowerCase();
+    if (buscado === "")
+        return [...modelos];
+    return modelos.filter((modelo) => modelo.id.toLowerCase().includes(buscado) || modelo.nombre?.toLowerCase().includes(buscado));
+}
+/** Un número visible es uno basado en uno; Enter significa cancelar, no elegir el primero. */
+export function elegirPorNumero(modelos, respuesta) {
+    const texto = respuesta.trim();
+    if (texto === "")
+        return { tipo: "cancelado" };
+    if (!/^\d+$/.test(texto))
+        return { tipo: "invalido" };
+    const modelo = modelos[Number(texto) - 1];
+    return modelo === undefined ? { tipo: "invalido" } : { tipo: "elegido", modelo };
+}
+/** Un papel vacío permite salir del flujo, pero cualquier otro texto debe ser exacto. */
+export function elegirPapel(respuesta) {
+    const texto = respuesta.trim().toLowerCase();
+    return PAPELES.includes(texto) ? texto : undefined;
+}
+/** La global solo tiene efecto inmediato si no hay una fuente de rango superior para ese papel. */
+export function fuenteQueEclipsaGlobal(papel, fuentes, seleccionesDeCatalogo = {}) {
+    if ((fuentes.porPapel?.[papel] !== undefined &&
+        fuentes.porPapel[papel] !== seleccionesDeCatalogo[papel]) ||
+        fuentes.bandera !== undefined) {
+        return "bandera";
+    }
+    if (fuentes.entorno?.XONECODE_MODELO !== undefined)
+        return "entorno";
+    if (fuentes.proyecto?.modelos?.[papel] !== undefined || fuentes.proyecto?.modelo !== undefined) {
+        return "proyecto";
+    }
+    return undefined;
+}
+/**
+ * El proveedor que se teclea en `/modelos` y en `/provider`.
+ *
+ * Acepta también un personalizado por su FORMA (`custom:<slug>`), igual que `parsear`: que
+ * ese slug esté dado de alta lo dirá el catálogo, con un mensaje que dice dónde darlo de
+ * alta. Rechazarlo aquí obligaría a este módulo a leer el `config.json` global solo para
+ * validar un nombre.
+ */
+function validarProveedor(nombre) {
+    if (nombre === undefined)
+        return undefined;
+    if (PROVEEDORES.includes(nombre))
+        return nombre;
+    return esProveedorPersonalizado(nombre) ? nombre : undefined;
+}
+/** Exportada: `main.ts` la usa para el contexto de `asistenteDeModelo` (stdio y TUI). */
+export function hayCredencial(proveedor, raiz) {
+    const variable = variableDeProveedor(proveedor);
+    if (variable === undefined)
+        return true;
+    const enEntorno = process.env[variable];
+    if (enEntorno !== undefined && enEntorno.trim() !== "")
+        return true;
+    return cargar(raiz).auth[proveedor] !== undefined;
+}
+function describirModelo(modelo) {
+    const etiqueta = modelo.nombre ?? modelo.id;
+    const contexto = modelo.contexto === undefined ? "" : `, ctx ${modelo.contexto}`;
+    return `${etiqueta} (${modelo.proveedor}/${modelo.id}${contexto})`;
+}
+/**
+ * El selector de modelo de un catálogo ya elegido: la parte que `/modelos` y el alta de
+ * proyecto (`configurarModoInicial`) COMPARTEN, para que no haya dos copias del mismo
+ * flujo (rico con `seleccionar`, o numerado por `preguntar` cuando esa costura no existe).
+ * Devuelve el id crudo del catálogo (sin el prefijo `<proveedor>/`) o `undefined` si se
+ * canceló o no había nada entre lo que elegir — los mensajes de cada caso ya se escriben
+ * aquí, así que quien llama no repite el aviso.
+ */
+export async function seleccionarModelo(proveedor, consola) {
+    const modelos = await consola.catalogoModelos.listar(proveedor);
+    if (modelos.length === 0) {
+        consola.escribir(`no hay modelos disponibles para ${proveedor}\n`);
+        return undefined;
+    }
+    if (consola.seleccionar !== undefined) {
+        const opciones = modelos.map((modelo) => ({
+            id: modelo.id,
+            etiqueta: modelo.nombre ?? modelo.id,
+            detalle: describirModelo(modelo),
+        }));
+        const elegido = await consola.seleccionar({ titulo: `Modelos de ${proveedor}`, opciones });
+        const modelo = modelos.find((candidato) => candidato.id === elegido);
+        if (modelo === undefined) {
+            consola.escribir("selección cancelada\n");
+            return undefined;
+        }
+        return modelo.id;
+    }
+    const filtro = await consola.preguntar("filtro (Enter para todos): ");
+    const filtrados = filtrarModelos(modelos, filtro);
+    if (filtrados.length === 0) {
+        consola.escribir("no hay modelos que coincidan con el filtro\n");
+        return undefined;
+    }
+    for (const [indice, modelo] of filtrados.entries()) {
+        consola.escribir(`${indice + 1}. ${describirModelo(modelo)}\n`);
+    }
+    const eleccion = elegirPorNumero(filtrados, await consola.preguntar("número (Enter cancela): "));
+    if (eleccion.tipo === "cancelado") {
+        consola.escribir("selección cancelada\n");
+        return undefined;
+    }
+    if (eleccion.tipo === "invalido") {
+        consola.escribir("número inválido\n");
+        return undefined;
+    }
+    return eleccion.modelo.id;
+}
+/** Flujo interactivo de catálogo; los fallos previstos nunca devuelven un estado nuevo. */
+async function elegirModelo(args, estado, consola) {
+    const proveedor = validarProveedor(args[0]);
+    if (proveedor === undefined) {
+        const escrito = args[0];
+        consola.escribir(escrito === undefined
+            ? `uso: /modelos <proveedor> — proveedores: ${PROVEEDORES.join(", ")} (o «custom:<id>»)\n`
+            : `proveedor «${escrito}» desconocido. Los que hay: ${PROVEEDORES.join(", ")} (o «custom:<id>», dado de alta en Ajustes)\n`);
+        return { seguir: true };
+    }
+    if (!hayCredencial(proveedor, estado.raiz)) {
+        consola.escribir(`falta la credencial para ${proveedor}; usa /provider ${proveedor}\n`);
+        return { seguir: true };
+    }
+    const modeloId = await seleccionarModelo(proveedor, consola);
+    if (modeloId === undefined)
+        return { seguir: true };
+    let papel;
+    if (consola.seleccionar !== undefined) {
+        const papelElegido = await consola.seleccionar({
+            titulo: "Asignar modelo a",
+            opciones: PAPELES.map((p) => ({ id: p, etiqueta: p })),
+        });
+        papel = elegirPapel(papelElegido ?? "");
+    }
+    else {
+        const respuestaPapel = await consola.preguntar("papel (rapido/trabajo/afilado): ");
+        if (respuestaPapel.trim() === "") {
+            consola.escribir("selección cancelada\n");
+            return { seguir: true };
+        }
+        papel = elegirPapel(respuestaPapel);
+        if (papel === undefined) {
+            consola.escribir(`papel inválido; elige: ${PAPELES.join(", ")}\n`);
+            return { seguir: true };
+        }
+    }
+    if (papel === undefined) {
+        consola.escribir("selección cancelada\n");
+        return { seguir: true };
+    }
+    return guardarEleccionDeModelo(proveedor, modeloId, papel, estado, consola);
+}
+/** Selector de tema: misma costura rica que /modelos, con pregunta numerada en stdio. */
+async function elegirTema(_args, _estado, consola) {
+    let id;
+    if (consola.seleccionar !== undefined) {
+        id = await consola.seleccionar({
+            titulo: "Tema de xonecode",
+            opciones: TEMAS.map((tema) => ({ id: tema.id, etiqueta: tema.etiqueta, detalle: tema.detalle })),
+        });
+    }
+    else {
+        consola.escribir("temas:\n");
+        for (const [indice, tema] of TEMAS.entries()) {
+            consola.escribir(`  ${indice + 1}. ${tema.etiqueta} — ${tema.detalle}\n`);
+        }
+        const respuesta = (await consola.preguntar("número (Enter cancela): ")).trim();
+        if (respuesta === "")
+            return { seguir: true };
+        const indice = Number(respuesta) - 1;
+        id = Number.isInteger(indice) ? TEMAS[indice]?.id : undefined;
+    }
+    if (id === undefined) {
+        consola.escribir("selección cancelada\n");
+        return { seguir: true };
+    }
+    if (!esTema(id)) {
+        consola.escribir("tema inválido\n");
+        return { seguir: true };
+    }
+    (consola.aplicarTema ?? seleccionarTema)(id);
+    const tema = TEMAS.find((candidato) => candidato.id === id);
+    const guardado = consola.guardarTemaDeProyecto?.(id);
+    consola.escribir(guardado === undefined
+        ? `tema activo: ${tema.etiqueta}\n`
+        : `tema activo: ${tema.etiqueta} · guardado en ${guardado.ruta}\n`);
+    return { seguir: true };
+}
+function guardarEleccionDeModelo(proveedor, modeloId, papel, estado, consola) {
+    const id = `${proveedor}/${modeloId}`;
+    consola.guardarModeloGlobal(papel, id);
+    const eclipsa = fuenteQueEclipsaGlobal(papel, estado.fuentes, estado.seleccionesDeCatalogo);
+    if (eclipsa !== undefined) {
+        consola.escribir(`modelo ${papel} guardado en global; sigue activo el de ${eclipsa}\n`);
+        return { seguir: true };
+    }
+    const fuentes = {
+        ...estado.fuentes,
+        porPapel: { ...estado.fuentes.porPapel, [papel]: id },
+    };
+    consola.escribir(acuseDeModelo(papel, id));
+    return {
+        seguir: true,
+        estado: {
+            ...estado,
+            fuentes,
+            seleccionesDeCatalogo: { ...estado.seleccionesDeCatalogo, [papel]: id },
+        },
+    };
+}
 /**
  * El `completer` de readline (ver docs de node:readline: firma síncrona
  * `(line: string) => [string[], string]`). Dos mundos:
@@ -148,8 +602,92 @@ function manejadorDeModelo(papel) {
         const fuentes = papel === undefined
             ? { ...estado.fuentes, bandera: valor }
             : { ...estado.fuentes, porPapel: { ...estado.fuentes.porPapel, [papel]: valor } };
-        consola.escribir(papel === undefined ? `modelo (los tres papeles): ${valor}\n` : `modelo ${papel}: ${valor}\n`);
-        return { seguir: true, estado: { ...estado, fuentes } };
+        // La frase vive en `acuseDeModelo.ts`: la TUI la re-parsea para su sidebar, así
+        // que escribir y leer comparten módulo — retocar la frase aquí no rompe a ciegas.
+        consola.escribir(acuseDeModelo(papel, valor));
+        const seleccionesDeCatalogo = { ...estado.seleccionesDeCatalogo };
+        if (papel === undefined) {
+            for (const p of PAPELES)
+                delete seleccionesDeCatalogo[p];
+        }
+        else {
+            delete seleccionesDeCatalogo[papel];
+        }
+        return {
+            seguir: true,
+            estado: {
+                ...estado,
+                fuentes,
+                seleccionesDeCatalogo: Object.keys(seleccionesDeCatalogo).length === 0 ? undefined : seleccionesDeCatalogo,
+            },
+        };
+    };
+}
+/**
+ * La ÚNICA política de aprobación que existe hoy: rellena el hueco de
+ * `core/cloudstudio.ts#PoliticaDeAprobacion` con un humano que ve el plan y responde.
+ * Vive aquí, en `cli/`, y no en `agent/subida.ts`: la política es de la piel, el hueco es
+ * del motor.
+ *
+ * **Es MÁS estricta que `cli/aprobar.ts`, a propósito: aquí el Enter a secas no aprueba
+ * ni con TTY.** No es el mismo acto. En `aprobar.ts` se autoriza una escritura con su
+ * diff delante, línea a línea, y el Enter que aprueba lo pulsa alguien que está mirando
+ * el cambio; aquí se PUBLICA en un servidor remoto, lo que hay en pantalla es una lista
+ * de rutas —no el contenido— y es la operación menos reversible del producto. El detalle
+ * que lo hace peligroso no se ve: `APPROVALS_TTY` (`vendor/hitl.ts`) contiene la cadena
+ * VACÍA, así que pasarle `interactive` a `interpretAnswer` convertiría en «sube» toda
+ * respuesta vacía — y `consola.preguntar` devuelve "" también cuando el readline ya está
+ * cerrado (Ctrl-D, un stdin agotado a mitad de turno). Un EOF no puede publicar. Por eso
+ * se llama sin opciones, contra `APPROVALS_NO_TTY`, y el prompt enseña `[s/N]` siempre:
+ * un default visible que no fuera el real sería mentir en el paso que sube.
+ *
+ * **Y el plan viaja CON la pregunta, no solo delante de ella** (`DecisionDeConsola`): la
+ * tarjeta de la consola web enseña la lista y ofrece Aceptar/Cancelar, sin campo donde
+ * teclear, y para eso hay que decirle que la respuesta es sí o no. Adivinarlo del `[s/N]`
+ * sería leer la sintaxis, y el día que ese prompt cambie la tarjeta ofrecería un editor
+ * para una decisión —o dos botones sobre una pregunta abierta— sin un solo error.
+ *
+ * La política AUTÓNOMA (el papel `afilado` decidiendo sin que nadie mire) todavía no
+ * existe — hace falta, además del veredicto del juez, que el código compruebe
+ * condiciones deterministas (verificador en verde, árbol limpio, plan sin pendientes):
+ * ver el comentario de `PoliticaDeAprobacion`.
+ *
+ * **`decir` es el sumidero de la operación**, y entra por parámetro porque el plan NO siempre
+ * se cuenta en el scrollback: una piel con registro propio (`anotarSincronizacion`) guarda la
+ * operación entera y no quiere ni una línea suelta en el hilo. Por omisión es `consola.escribir`,
+ * así que quien no pase nada —los tests, cualquier otro llamador— tiene el comportamiento de
+ * siempre.
+ */
+export function politicaInteractiva(consola, decir = (texto) => consola.escribir(texto)) {
+    return async (plan) => {
+        // El plan se compone ANTES de escribirlo, y no es por estilo: las MISMAS líneas que van
+        // al scrollback viajan en la PREGUNTA, para que una piel con tarjeta las enseñe dentro
+        // de ella —el paso donde se decide— en vez de dejarlas en un transcript que puede estar
+        // a varias pantallas de scroll. Se escriben una a una, como siempre: en la web cada
+        // acto de sistema es una línea, y las pieles de terminal no cambian.
+        //
+        // Cada línea lleva ADEMÁS lo que el signo significa (`cambio`), y el signo se deriva de
+        // ahí en vez de al revés: una piel que quiera enseñar qué se añade y qué se borra no
+        // puede leer el `+`/`~`/`-`, que es sintaxis. Y la clase sale de la OPERACIÓN, que es
+        // de donde la sabe `planDeSubida`: un `borrado` no la lleva —su `tipo` ya la dice—, así
+        // que la línea de un borrado la toma del `tipo`.
+        const lineas = [
+            { texto: `SUBIDA A CLOUDSTUDIO — ${plan.length} ${plan.length === 1 ? "operación" : "operaciones"}` },
+            ...plan.map((operacion) => {
+                const cambio = operacion.tipo === "borrado" ? "borrado" : operacion.clase;
+                const signo = cambio === "borrado" ? "-" : cambio === "nuevo" ? "+" : "~";
+                return { texto: `  ${signo} ${operacion.ruta}`, cambio };
+            }),
+        ];
+        decir(`\n${"─".repeat(60)}\n`);
+        for (const linea of lineas)
+            decir(`${linea.texto}\n`);
+        // Sin pista de tecleo en el enunciado: la pone la piel que se contesta escribiendo
+        // (`PISTA_DE_DECISION`), y por eso viaja un `decision` con esta pregunta.
+        const respuesta = await consola.preguntar("¿Subir a CloudStudio?", { lineas });
+        const decision = interpretAnswer(respuesta);
+        decir(decision.type === "approve" ? "  → APROBADO\n" : "  → rechazado, no se ha aplicado nada\n");
+        return decision.type === "approve";
     };
 }
 export const COMANDOS = {
@@ -211,6 +749,174 @@ export const COMANDOS = {
         descripcion: "cambia el papel `afilado` en caliente: /modelo-afilado <proveedor>/<modelo>",
         manejador: manejadorDeModelo("afilado"),
     },
+    modelos: {
+        descripcion: "elige un modelo del catálogo de un proveedor y lo guarda globalmente: /modelos <proveedor>",
+        manejador: elegirModelo,
+    },
+    themes: {
+        descripcion: "elige tema visual: XOne, Clear, Midnight, Graphite o Ember",
+        manejador: elegirTema,
+    },
+    "connect-studio": {
+        descripcion: "conecta CloudStudio una vez: /connect-studio [url] [agente|lectura]",
+        manejador: async (args, _estado, consola) => {
+            if (consola.conectarCloudStudio === undefined || consola.guardarCloudStudioDeProyecto === undefined) {
+                consola.escribir("la conexión CloudStudio no está disponible en esta ejecución\n");
+                return { seguir: true };
+            }
+            const primerArgEsModo = args[0] === "lectura" || args[0] === "agente";
+            const escrita = primerArgEsModo ? "" : args[0] ?? await consola.preguntar(`URL MCP de CloudStudio [${URL_CLOUDSTUDIO_POR_OMISION}]: `);
+            const url = escrita.trim() || URL_CLOUDSTUDIO_POR_OMISION;
+            const modo = modoStudio(primerArgEsModo ? args[0] : args[1]);
+            if (modo === undefined) {
+                consola.escribir("modo inválido; elige agente o lectura\n");
+                return { seguir: true };
+            }
+            consola.escribir("Configurando CloudStudio…\n");
+            const resultado = await consola.conectarCloudStudio(url, modo.scopes, consola.escribir);
+            const guardado = consola.guardarCloudStudioDeProyecto(resultado.url, resultado.scopes);
+            // El catálogo completo es material de configuración, no una respuesta de consola:
+            // varias descripciones ocupan cientos de líneas y apartan al usuario de su tarea.
+            // La URL y los scopes siguen guardados en `.xonecode/config.json` para diagnóstico.
+            void guardado;
+            consola.escribir("→ Entorno listo\n");
+            return { seguir: true };
+        },
+    },
+    sync: {
+        descripcion: "sincroniza con CloudStudio: /sync [estado|bajar|subir]",
+        manejador: async (args, estado, consola) => {
+            if (consola.sincronizar === undefined) {
+                consola.escribir("la sincronización no está disponible en esta ejecución\n");
+                return { seguir: true };
+            }
+            const accion = args[0] ?? "estado";
+            if (accion !== "estado" && accion !== "bajar" && accion !== "subir") {
+                consola.escribir("uso: /sync [estado|bajar|subir]\n");
+                return { seguir: true };
+            }
+            // Estas dos salidas de arriba NO son una operación y no van al registro: son el mismo
+            // aviso de uso que da cualquier comando mal escrito, y no hay nada que contarle a nadie
+            // sobre una sincronización que no llegó a empezar.
+            /**
+             * **Dónde se cuenta esta operación.** Es la decisión de todo el comando, y por eso está
+             * en una sola variable.
+             *
+             * Sin `anotarSincronizacion` —stdio, la TUI, la consola de una tarea, los dobles— el
+             * sumidero ES `escribir`: al vuelo, en orden, byte a byte como siempre. Con él, las
+             * líneas se acumulan y se entrega UNA operación al final, ya con su acción y su hora:
+             * en el navegador el recorrido de una subida no tiene por qué meterse en el hilo, donde
+             * son nueve renglones de consola cruda entre dos mensajes de verdad (medido).
+             *
+             * Las líneas se guardan TAL CUAL y solo se les quita el `\n` final y las que van vacías:
+             * el salto de línea es del scrollback —donde cada `escribir` es una línea— y no del dato,
+             * y la raya que `politicaInteractiva` dibuja arriba del plan es parte de lo que se dijo.
+             * Recomponer aquí sería una segunda versión de algo que ya está contado en `agent/`, y
+             * la copia que nadie vuelve a leer es la que se queda vieja.
+             */
+            const anotar = consola.anotarSincronizacion;
+            const lineas = [];
+            const decir = anotar === undefined
+                ? (texto) => consola.escribir(texto)
+                : (texto) => {
+                    for (const linea of texto.replace(/\n$/, "").split("\n")) {
+                        if (linea.trim() !== "")
+                            lineas.push(linea);
+                    }
+                };
+            const cuando = new Date().toISOString();
+            try {
+                // El hueco de política solo se rellena para «subir»: es la única acción que
+                // escribe. `agent/subida.ts#subir` la invoca con el plan YA CONSTRUIDO, así que
+                // esto puede pasarse siempre — si el árbol está sucio o no hay nada que subir, ni
+                // siquiera llega a invocarse.
+                const politicaDeAprobacion = accion === "subir" ? politicaInteractiva(consola, decir) : undefined;
+                const resultado = await consola.sincronizar(accion, estado.raiz, politicaDeAprobacion, decir);
+                if (resultado.tipo === "arbol-sucio") {
+                    // Al subir se sube el estado de un COMMIT, no un borrador: así «lo que está
+                    // arriba» es siempre un commit concreto y mover la ref significa algo. Al bajar
+                    // el motivo es otro y hay que decirlo: la descarga SOBRESCRIBE el disco.
+                    const porque = resultado.accion === "subir"
+                        ? "commitea antes de subir"
+                        : "la descarga sobrescribe el disco; commitea antes de bajar (o guarda una copia, si no llevas git)";
+                    decir(`hay cambios sin commitear (${resultado.pendientes.join(", ")}); ${porque}\n`);
+                }
+                else {
+                    decir(resultado.texto);
+                }
+            }
+            finally {
+                // En el `finally` y no al final del `try`, por un motivo medido: `crearSincronizador`
+                // puede LANZAR —`limpio`, `descargar`, `subirProyecto` y hasta el `sesion.cerrar()` de
+                // su propio `finally` son `await` de cosas que tocan la red y el disco—, y con las
+                // líneas acumuladas una excepción se llevaría por delante todo lo que ya se había
+                // contado. En el scrollback de stdio, que es append-only, no se perdía nada.
+                //
+                // La excepción se deja PROPAGAR: un fallo inesperado lo dice el harness en el hilo,
+                // que es donde tiene que verse. Esconderlo en el registro sería lo contrario de lo
+                // que esto busca — el registro es de las operaciones que corrieron, no de las que no.
+                anotar?.({ accion, cuando, lineas });
+            }
+            return { seguir: true };
+        },
+    },
+    aprobacion: {
+        descripcion: "quién aprueba las escrituras aquí: /aprobacion [humana|automatica]",
+        manejador: async (args, estado, consola) => {
+            const raiz = estado.raiz;
+            // Del DISCO y por la raíz: en la consola web `fuentes.proyecto` no se rellena, así
+            // que preguntárselo daría «offline» para cualquier proyecto, conectado o no.
+            const cloudstudio = cloudstudioDelProyecto(raiz);
+            const vigente = () => seAplicaSinAprobacion({
+                raiz,
+                sinAprobacion: cargarSettings().settings.sinAprobacion,
+                cloudstudio,
+                // La misma cuenta que `pedirDecisiones`: `interactivo` a secas es `true` a fuego
+                // en la consola web, así que sin el `eof` este comando diría «automatica» con la
+                // pestaña ya cerrada.
+                interactivo: consola.interactivo && !(consola.eof?.() ?? false),
+            });
+            const que = args[0];
+            if (que === undefined) {
+                consola.escribir(vigente()
+                    ? "automatica: las escrituras de este proyecto se aplican SIN preguntar\n"
+                    : "humana: cada escritura pide aprobación con su diff delante\n");
+                // Las tres condiciones se dicen cuando la respuesta es «humana», porque entonces la
+                // pregunta que sigue siempre es «¿y por qué?». Un «no» sin motivo manda a adivinar.
+                if (!vigente() && cargarSettings().settings.sinAprobacion?.[raiz] === true) {
+                    consola.escribir(cloudstudio !== undefined
+                        ? "  (está puesta, pero no se aplica: este proyecto sube a CloudStudio)\n"
+                        : "  (está puesta, pero no se aplica: no hay nadie delante que pueda decidir)\n");
+                }
+                return { seguir: true };
+            }
+            if (que !== "humana" && que !== "automatica") {
+                consola.escribir("uso: /aprobacion [humana|automatica]\n");
+                return { seguir: true };
+            }
+            // Se RECHAZA en vez de guardarse y no aplicarse: un ajuste escrito que no hace nada
+            // es peor que no poder ponerlo, porque quien lo puso se cree protegido al revés.
+            if (que === "automatica" && cloudstudio !== undefined) {
+                consola.escribir("no: este proyecto está conectado a CloudStudio, y lo que se escriba aquí sube al\n" +
+                    "trabajo de otras personas. La aprobación no es una preferencia ahí.\n");
+                return { seguir: true };
+            }
+            const { ruta } = guardarSinAprobacion(undefined, raiz, que === "automatica");
+            if (que === "automatica") {
+                // La ruta del SETTINGS sí se dice —es donde se edita a mano, y `/config` y `/tema`
+                // ya imprimen la suya—, pero la del proyecto no: quien teclea esto sabe dónde está,
+                // y por esta salida pasa un acto del transcript que viaja por el cable.
+                consola.escribir("hecho: las escrituras de este proyecto se aplicarán SIN preguntar.\n" +
+                    `  Cada turno que escriba lo dirá, con los nombres de los ficheros.\n` +
+                    `  Se guarda en ${ruta} —en tu máquina, no en el proyecto— y renombrar la\n` +
+                    "  carpeta lo pierde: entonces se vuelve a preguntar.\n");
+            }
+            else {
+                consola.escribir(`hecho: cada escritura vuelve a pedir aprobación. Guardado en ${ruta}.\n`);
+            }
+            return { seguir: true };
+        },
+    },
     hilo: {
         descripcion: "muestra el hilo (thread_id) de esta sesión",
         manejador: async (_args, estado, consola) => {
@@ -223,7 +929,17 @@ export const COMANDOS = {
         manejador: async (_args, estado, consola) => {
             // Mismo patrón que run.ts: prefijo xonecode- + uuid.
             const nuevoHilo = `xonecode-${randomUUID()}`;
-            consola.escribir(`hilo nuevo: ${nuevoHilo}\n`);
+            // Y se DICE lo que cuesta desde que el hilo se guarda en disco: en la web el hilo de
+            // una sesión ES su id, así que este hilo nuevo no es de ninguna sesión — al reabrirla
+            // se vuelve al de antes, y lo que se hable a partir de aquí no se podrá reabrir.
+            // Callarlo sería prometer que la conversación que empieza ahora se guarda como las
+            // demás. Quien quiere empezar de cero Y poder volver, abre una sesión nueva.
+            //
+            // En UN `escribir`, no en dos: `main.ts` repinta la barra de estado al ver una línea
+            // que empieza por «hilo nuevo:», así que partido en dos la barra caía en medio de las
+            // dos frases. El regex sigue casando porque la primera línea no cambia.
+            consola.escribir(`hilo nuevo: ${nuevoHilo}\n` +
+                "ojo: este hilo no es el de la sesión; al reabrirla se vuelve al anterior\n");
             return { seguir: true, estado: { ...estado, hilo: nuevoHilo } };
         },
     },
@@ -236,7 +952,7 @@ export const COMANDOS = {
                 // existía): mismo orden de mirón que cmdConfig — primero env, luego disco.
                 const cargado = cargar(estado.raiz);
                 for (const p of PROVEEDORES) {
-                    const variable = VARIABLE_POR_PROVEEDOR[p];
+                    const variable = VARIABLES_POR_PROVEEDOR[p];
                     const enEntorno = variable !== undefined && process.env[variable] !== undefined;
                     const enAuth = !enEntorno && cargado.auth[p] !== undefined;
                     // ollama no se marca «sin credencial»: no la necesita, no le falta nada.
@@ -270,6 +986,14 @@ export const COMANDOS = {
                 consola.escribir("clave vacía: no se guardó nada\n");
                 return { seguir: true };
             }
+            // La MISMA criba que el asistente de cuenta (`core/config.ts`), no una copia: lo que
+            // el propio campo ya delata —una línea `NOMBRE=valor` pegada entera, comillas,
+            // espacios— no llega a `auth.json`, donde solo se ve al fallar una petición.
+            const motivo = motivoDeClaveInaceptable(clave);
+            if (motivo !== undefined) {
+                consola.escribir(`no se guardó nada: ${motivo}\n`);
+                return { seguir: true };
+            }
             try {
                 const { ruta, avisos } = guardarCredencial(nombre, clave);
                 consola.escribir(`credencial de ${nombre} guardada en ${ruta}\n`);
@@ -304,11 +1028,14 @@ export const COMANDOS = {
  */
 export async function correrConsola(consola, estado, ejecutarTurno = ejecutarTurnoGuionizado) {
     for await (const cruda of consola.lineas) {
-        const linea = cruda.trim();
+        // Una `string` a secas es una piel donde el teclado manda (stdio, la TUI, una consola de
+        // tarea, los dobles): se lee como siempre. Ver `LineaDeConsola`.
+        const { texto, comoComando } = typeof cruda === "string" ? { texto: cruda, comoComando: true } : cruda;
+        const linea = texto.trim();
         // Un Enter de más no gasta ni una llamada al modelo ni un error: no hay nada que hacer.
         if (linea === "")
             continue;
-        if (linea.startsWith("/")) {
+        if (comoComando && linea.startsWith("/")) {
             // El comando se compara en minúsculas; los args respetan lo tecleado (p.ej. un id
             // de Ollama con mayúsculas tiene que llegar entero a `parsear`).
             const trozos = linea.split(/\s+/);
@@ -325,8 +1052,12 @@ export async function correrConsola(consola, estado, ejecutarTurno = ejecutarTur
                     return 0;
                 // El estado MÁS RECIENTE manda: el turno siguiente parte de lo que devolvió el
                 // último manejador, no del estado de arranque.
-                if (resultado.estado !== undefined)
+                if (resultado.estado !== undefined) {
                     estado = resultado.estado;
+                    // Solo cuando cambia de verdad: avisar en cada línea haría que una piel que
+                    // reemite por esto mandara un mensaje por cada `/ayuda`.
+                    consola.alEstado?.(estado);
+                }
             }
             catch (e) {
                 consola.escribir(`${describirError(e)}\n`);