xonecode 0.38.41 → 0.39.2

package/dist/cli/main.d.ts

@@ -0,0 +1,291 @@
+/**
+ * El despachador. Cada comando expone `cmdX(...)` y se registra aquí.
+ *
+ * Sin librería de argumentos a propósito: hoy hay un comando y una bandera, y una
+ * dependencia más es una dependencia más que fijar y vigilar. Cuando haya cinco, se mete.
+ */
+import { type MotorDeAgente } from "../core/motor.js";
+import * as readline from "node:readline";
+import type { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import { type FuentesDeEleccion } from "../core/modelos.js";
+import { cargar } from "../agent/config/configEnDisco.js";
+import { sesionCloudStudio } from "../agent/cloudstudio/cloudstudioMcp.js";
+import { clienteCloudStudio } from "../agent/cloudstudio/cloudstudioClient.js";
+import { cargarSettings } from "../agent/config/settingsEnDisco.js";
+import { descargarProyecto } from "../agent/cloudstudio/descarga.js";
+import { arbolLimpio, cambiosPendientes, esRepoPropio, prepararRepo, sinCommitear, vaciarCopia } from "../agent/sesiones/gitSync.js";
+import { subir } from "../agent/cloudstudio/subida.js";
+import { type Consola, type EjecutorDeTurno } from "./consola.js";
+import { type Escribir } from "./stdio.js";
+import type { ConectoresPort } from "../core/ports.js";
+import type { SesionReal } from "../agent/turno/sesionReal.js";
+/**
+ * Las banderas de modelo llevan valor suelto (`--modelo x`, no `--modelo=x`), y ese
+ * valor NO empieza por `--`: si no se quita aquí, el join de la petición en `run` lo
+ * comería como texto. Devuelve las fuentes ya resueltas y el argv SIN las banderas ni
+ * sus valores sueltos, para que `--lento` y el filtro de `--` sigan funcionando igual.
+ */
+export declare function extraerBanderasDeModelo(argv: string[]): {
+    fuentes: FuentesDeEleccion;
+    resto: string[];
+};
+/**
+ * El formato compacto ya no vive aquí: `tokens.ts` lo comparte con la sidebar de la
+ * TUI, para que las dos pieles digan la misma cifra (ver el comentario de allí).
+ */
+/** Las piezas de la barra de estado, ya resueltas: aquí solo queda darles formato. */
+export interface PiezasDeBarra {
+    proyecto: string;
+    colecciones: number;
+    /** El modelo de la sesión, «proveedor/modelo». */
+    modelo: string;
+    /** Tokens acumulados de la sesión (input + output). */
+    tokens: number;
+    /** Cuánto ocupa AHORA la ventana del modelo; 0 antes de la primera llamada. */
+    contexto: number;
+    /** El tope de la ventana, si se sabe (`core/contextos.ts` + config). */
+    tope?: number;
+}
+/**
+ * La barra de estado como función PURA: la compone quien tiene los valores y
+ * la pinta quien tiene el color. Así la barra se puede probar sin TTY — y es
+ * que solo se pinta con TTY, que es justo el caso que los tests no pueden ser.
+ *
+ * La sección `ctx` solo existe si hay algo que medir, y el porcentaje solo si
+ * hay tope: sin tope conocido, la cifra va pelada antes que calcular un
+ * porcentaje sobre un número inventado.
+ */
+export declare function formatearBarra(p: PiezasDeBarra): string;
+/**
+ * El tope de la ventana del modelo ACTUAL: tabla de `core/contextos.ts` + lo que el
+ * usuario haya fijado en `config.json` (lo de proyecto gana a lo global, como los
+ * modelos). Fábrica PORQUE la barra lo lee en cada llamada y no en el arranque:
+ * /modelo cambia el modelo en caliente, y un tope del modelo equivocado es un
+ * porcentaje que miente. Si el id no parsea —no debería, viene de `resolver`—, no hay
+ * tope y no pasa nada.
+ *
+ * Exportada para que la TUI calcule su `ctx` con LA MISMA función que usa la barra de
+ * stdio y la que /config declara: dos pieles no pueden divergir en el tope.
+ */
+export declare function crearTopeDelModelo(raiz: string): (id: string) => number | undefined;
+/**
+ * ¿TUI o stdio? `--no-tui` gana siempre (el usuario pidió explícitamente la consola
+ * clásica); después `--tui` fuerza la TUI aunque no haya TTY (quien la pide, la tiene:
+ * sin TTY el raw mode no funciona y el resultado es suyo); por omisión, AMBOS lados
+ * TTY → TUI (solo mirar stdout monta la TUI con stdin de tubería — «echo /salir |
+ * xonecode» en un terminal real — y los bytes del pipe se consumen como teclas mientras
+ * el EOF del pipe no termina el lazo) y cualquier tubería → stdio, que es lo que
+ * mantiene el e2e de pipe byte-idéntico.
+ */
+/**
+ * ¿Captura la TUI el ratón? Con él, la rueda mueve el transcript y no el scrollback del
+ * terminal, a cambio de que seleccionar texto sea Alt/Shift + arrastre. `--sin-raton` lo
+ * apaga. Pura, para probarla.
+ */
+export declare function quiereRaton(argv?: string[]): boolean;
+export declare function decidirTui(argv?: string[]): boolean;
+/**
+ * Error de USO: una bandera imposible de obedecer, nunca un fallo del harness. Mismo
+ * tratamiento que `ModeloMalEscrito` en el `catch` de `main` — mensaje a stderr, sin
+ * traza, código 64 — pero con su propia clase: reusar `ModeloMalEscrito` aquí mentiría
+ * sobre la causa, y el contrato de códigos de salida lo lee CI.
+ */
+export declare class ErrorDeUso extends Error {
+}
+export type PielElegida = "web" | "consola";
+export declare function decidirPiel(argv?: string[], entorno?: {
+    stdinTTY?: boolean;
+}): PielElegida;
+export interface OpcionesWeb {
+    puerto: number;
+    abrir: boolean;
+    /** `--anfitrion <host>`: un nombre extra aceptado en la cabecera `Host`, para un túnel. */
+    anfitrion?: string;
+}
+export declare function parsearOpcionesWeb(argv: string[]): OpcionesWeb;
+/**
+ * Qué carpeta ve el agente como `/adjuntos/` en ESTA consola (IXCODE-7). Pura y exportada
+ * para poder probar la regla sin construir una sesión de verdad — `crearEjecutorReal` no
+ * tenía costura para mirar las opciones que le llegan a `abrirSesionReal`.
+ *
+ * Ganan los de una TAREA (`deTarea`, la carpeta que el corredor conoce y reenvía por la
+ * fábrica). Sin tarea, y con carpeta de artefactos POR SESIÓN (`hayArtefactosPorSesion` —
+ * cierto en la web, que deriva `/artefactos/` del `hilo`), se montan los adjuntos de la
+ * MISMA sesión (`carpetaDeAdjuntosDeSesion`, hermana de `artefactos/`): son los que una
+ * persona anexó en el CHAT, y nadie más que este ejecutor sabe en qué sesión está. Sin
+ * carpeta de artefactos por sesión (el terminal: su `hilo` es un uuid nuevo en cada
+ * arranque, y una carpeta por hilo dejaría basura que nadie puede volver a abrir) no hay
+ * nada que montar: `undefined`, y el llamador NO pone el campo (una cadena vacía montaría
+ * el cwd del proceso).
+ */
+export declare function carpetaDeAdjuntosDelEjecutor(raiz: string, hilo: string, deTarea: string | undefined, hayArtefactosPorSesion: boolean): string | undefined;
+/**
+ * El ejecutor de turno REAL de la consola: cada línea de prosa corre sobre una `SesionReal`
+ * que sobrevive entre turnos (mismo agente, mismo hilo).
+ *
+ * La sesión se construye PEREZOSA, en el primer turno de prosa y no al arrancar
+ * `entrarEnConsola`, por dos razones:
+ *  - El `Entorno` completo lo pide `inspeccionar` (el real de `agent/entorno.js`), no el
+ *    doble `{colecciones}` de la cabecera, y abrir la sesión construye el grafo: hacerlo en
+ *    el arranque gastaría en una consola que quizá solo se use para `/ayuda` o `/config`.
+ *  - El detector de `/modelo` y `/nuevo` es la comparación de `estado` entre turnos: los
+ *    manejadores de `consola.ts` no tocan la sesión (no la conocen), así que la única
+ *    costura es el `estado` que este ejecutor recibe en cada llamada.
+ *
+ * `alAbrirSesion` se llama UNA vez, justo tras `abrirSesionReal`, y es la costura por la
+ * que `entrarEnConsola` apunta la barra de estado al tracker de la sesión (que alimenta
+ * el agente; el de `createTokenTracker()` de cabecera se descarta al reasignarse).
+ *
+ * Exportada porque la consola web la monta tal cual: es exactamente lo que espera la
+ * opción `crearEjecutor` del vestíbulo (`web/servidor/vestibulo.ts`), que usa esa misma
+ * costura para poder CERRAR la sesión al cambiar de proyecto. Una segunda fábrica para la
+ * web habría sido un segundo sitio donde arreglar cada bug del ejecutor real.
+ */
+/**
+ * `checkpointerDeProyecto` entra por parámetro y no se importa aquí, y no es purismo: la
+ * consola de TERMINAL no lo pasa. Su hilo es un uuid nuevo en cada arranque y no hay índice
+ * de sesiones donde reanudarlo, así que persistirlo solo dejaría hilos que nadie puede
+ * volver a abrir engordando el fichero del proyecto. Persistir es de quien tiene identidad
+ * que reanudar — hoy, la consola web.
+ */
+export declare function crearEjecutorReal(alAbrirSesion: (sesion: SesionReal) => void, checkpointerDeProyecto?: (raiz: string) => BaseCheckpointSaver | undefined, carpetaDeArtefactos?: (raiz: string, hilo: string) => string, 
+/**
+ * La carpeta de los ADJUNTOS de una TAREA — `/adjuntos/` para el agente, de solo lectura.
+ *
+ * Es un valor y no una función de `(raiz, hilo)` como las dos de arriba, y esa diferencia
+ * es el dato: los artefactos se derivan de la sesión, pero los adjuntos de una tarea son de
+ * la TAREA, y la tarea solo la conoce quien abrió esta consola (el corredor). Por eso llega
+ * a la FÁBRICA: es una propiedad de la consola, igual que su checkpointer.
+ *
+ * Ausente en toda tarea sin adjuntos. **No es «ausente en toda consola de persona»**
+ * (IXCODE-7): una consola de PERSONA con carpeta de artefactos por sesión —la web—
+ * monta los adjuntos que la persona anexó en el CHAT de ESA sesión, derivados con
+ * `carpetaDeAdjuntosDelEjecutor` y no reenviados por nadie (ver ahí el porqué). Sin
+ * carpeta de artefactos por sesión (el terminal) no hay nada que derivar.
+ */
+carpetaDeAdjuntos?: string, 
+/** Misma costura que `adaptadoresDeProyecto`: los tests no pueden leer el
+ *  `~/.xonecode/settings.json` de quien corre la suite. */
+leerSettings?: typeof cargarSettings, 
+/** Los conectores MCP, el mismo servicio de Ajustes. Solo la web lo tiene; ver `abrirSesionReal`. */
+conectores?: ConectoresPort): EjecutorDeTurno;
+/**
+ * Los adaptadores de disco y de red que dependen SOLO de la raíz del proyecto.
+ *
+ * Existe porque estaban escritos dos veces —una en la rama TUI y otra en la stdio— y eso
+ * ya divergió, medido: el arreglo del `entorno` caducado de `/connect-studio` entró en la
+ * rama TUI y no en la de stdio, así que por la consola de terminal seguía guardándose una
+ * `url` nueva encima de un `entorno` que nombraba el juego de credenciales de OTRO
+ * servidor. Es el mismo principio que ya rige aquí para los comandos («la consola y la
+ * shell no divergen porque comparten función»), aplicado a los adaptadores: con una sola
+ * definición, «las dos ramas hacen lo mismo» deja de ser algo que haya que recordar.
+ */
+export declare function adaptadoresDeProyecto(raiz: string, 
+/** Misma costura que `guardarEndpointYEntorno`: los tests no pueden leer el
+ *  `~/.xonecode/settings.json` de quien corre la suite. */
+leerSettings?: typeof cargarSettings): Pick<Consola, "guardarTemaDeProyecto" | "guardarCloudStudioDeProyecto" | "guardarModoDeProyecto" | "guardarProyectoCloudStudioDeProyecto" | "ramasDeCloudStudio" | "guardarRamaDeProyecto" | "guardarModelosDeProyecto" | "sincronizar">;
+/**
+ * El completer que monta la consola: comandos Y, tras una «@», ficheros del proyecto.
+ *
+ * Los ficheros se piden en el momento del Tab (`() => ficherosDelProyecto(raiz)`, no la
+ * lista ya hecha): el completer se construye una sola vez al arrancar el rl y la lista
+ * quedaría congelada en el primer instante de la sesión.
+ */
+export declare function crearCompleterDelProyecto(raiz: string, escribir?: Escribir): (linea: string) => [string[], string];
+/**
+ * Las piezas de la sincronización, para poder probar `crearSincronizador` y
+ * `crearListaDeRamas` sin red ni MCP: los tests inyectan dobles y el valor por omisión es
+ * el adaptador real de `agent/`. `leerConfig` es literalmente `cargar` de
+ * `agent/config/configEnDisco.ts` — no existe (ni hace falta) un `leerCloudStudioDeProyecto`.
+ */
+export interface PiezasDeSincronizacion {
+    leerConfig: typeof cargar;
+    /** Los entornos registrados, para resolver el `entorno` que al `config.json` le falte. */
+    leerSettings: typeof cargarSettings;
+    sesion: typeof sesionCloudStudio;
+    cliente: typeof clienteCloudStudio;
+    descargar: typeof descargarProyecto;
+    preparar: typeof prepararRepo;
+    pendientes: typeof cambiosPendientes;
+    limpio: typeof arbolLimpio;
+    sinCommitear: typeof sinCommitear;
+    subirProyecto: typeof subir;
+    /** Dejar la copia vacía para bajarla entera (`gitSync.ts#vaciarCopia`). */
+    vaciar: typeof vaciarCopia;
+    /** Si la carpeta es la raíz de su propio repo: decide si hay historia que perder. */
+    repoPropio: typeof esRepoPropio;
+    /** La base del workspace EN VIGOR, leída en cada uso. */
+    baseDeWorkspace: () => string;
+    /** Apuntar en el registro de fallos del proyecto una sincronización que REVENTÓ. */
+    anotarFallo: (raiz: string, fallo: {
+        error: unknown;
+        peticion: string;
+    }) => void;
+}
+/** Vive en `core/settings.ts` desde que `agent/` también la necesita (la identidad para
+ *  DeepSeek); se reexporta aquí para que ningún llamador cambie. */
+export { entornoDeUrl } from "../core/settings.js";
+/**
+ * El adaptador de `/connect-studio`: guarda el endpoint Y vuelve a resolver el `entorno`.
+ *
+ * Las dos escrituras van juntas a propósito. Separarlas es lo que dejaba el `entorno`
+ * caducado apuntando al juego de credenciales de otro servidor — el fallo peor de todo
+ * este arreglo, porque manda un token válido a un endpoint que no lo emitió.
+ */
+export declare function guardarEndpointYEntorno(raiz: string, url: string, scopes: readonly string[], leerSettings?: typeof cargarSettings): {
+    ruta: string;
+    url: string;
+    scopes: string[];
+};
+/**
+ * El adaptador real de `consola.sincronizar`: abre una sesión MCP VIVA con
+ * `sesionCloudStudio` —`conectarCloudStudio` cierra su transporte al terminar y sirve
+ * para el alta, pero no para operar— y la cierra siempre en un `finally`, tanto si la
+ * operación termina bien como si revienta.
+ *
+ * El orden dentro de «bajar» es crítico: `descargarProyecto` (que ya retira las vistas
+ * aplanadas) y DESPUÉS `prepararRepo`. Al revés, git vería esos `.xml` como borrados y la
+ * primera subida los borraría en Studio.
+ *
+ * Las dos direcciones se niegan con el árbol sucio ANTES de abrir sesión ni tocar
+ * CloudStudio: «subir» porque se sube el estado de un commit y no un borrador (para que
+ * mover la ref signifique algo), y «bajar» porque la descarga SOBRESCRIBE el disco y el
+ * baseline se construye después — sin un commit debajo, el trabajo local no se recupera.
+ */
+export declare function crearSincronizador(piezas?: PiezasDeSincronizacion): NonNullable<Consola["sincronizar"]>;
+/**
+ * El adaptador real de `consola.ramasDeCloudStudio`: mismo patrón de sesión VIVA +
+ * `finally`. Se usa durante el alta, con `proyecto` y `url` ya guardados pero la rama
+ * todavía sin elegir — por eso lee el config en cada llamada en vez de recibirlo cerrado.
+ */
+export declare function crearListaDeRamas(raiz: string, piezas?: Pick<PiezasDeSincronizacion, "leerConfig" | "leerSettings" | "sesion" | "cliente">): (proyecto: string) => Promise<string[]>;
+export declare function entrarEnConsola(fuentes: FuentesDeEleccion, raiz?: string, escribir?: Escribir, inspeccionarProyecto?: (raiz: string) => Promise<{
+    colecciones: number;
+    esProyectoXone: boolean;
+}>, crearRl?: () => readline.Interface, guion?: boolean, 
+/** Costura de test del «¿hay alguien al otro lado?»: sin TTY no se pregunta nada. */
+interactivo?: boolean, 
+/**
+ * ¿Arranca la TUI? Costura de test: los tests corren sin TTY y pasan `false` (o no
+ * la pasan, y `decidirTui` sin banderas cae en el `isTTY` del proceso). En la rama
+ * TUI este parámetro de `interactivo` no se usa: la TUI es interactiva por diseño.
+ */
+usarTui?: boolean, 
+/** ¿Ratón en la TUI? Solo la rama TUI lo mira. */
+raton?: boolean, 
+/** Adaptadores compartidos por stdio y TUI; `main` construye una sola instancia real. */
+dependencias?: Pick<Consola, "catalogoModelos" | "guardarModeloGlobal" | "conectarCloudStudio">): Promise<number>;
+/**
+ * `--motor <deepagents|trueforge>`, el punto de entrada para arrancar con un motor concreto sin
+ * tocar la configuración (`npm run web -- --motor deepagents`). Se quita del argv con su valor y se deja en
+ * `XONECODE_MOTOR`, que es la fuente que ya lee `resolverMotor`: una bandera no es una tercera
+ * regla, es otra forma de poner la variable —y la única que vale igual en Windows, donde un
+ * `XONECODE_MOTOR=…` delante del comando no funciona—. Un valor que no es un motor es un error de
+ * USO: arrancar con el de siempre callando la errata haría creer que se está probando el otro.
+ */
+export declare function extraerMotor(argv: readonly string[]): {
+    resto: string[];
+    motor?: MotorDeAgente;
+    error?: string;
+};
+export declare function main(argvCrudo: string[]): Promise<number>;

package/dist/cli/markdown.d.ts

@@ -0,0 +1,126 @@
+import type { Tema } from "./tema.js";
+/**
+ * El markdown del asistente, pintado en una consola que NO repinta.
+ *
+ * Esa es la regla que gobierna todo el módulo: **lo escrito, escrito está**. Una línea
+ * solo se puede renderizar cuando su texto es definitivo, y un párrafo largo que llega
+ * en trozos solo se puede cortar por donde el corte no rompa un marcador — de ahí
+ * `puntoSeguro`. No hay reflow posible: el historial vive en el scrollback del
+ * terminal, que no es direccionable.
+ *
+ * Se pinta lo que los modelos EMITEN de verdad (medido): negritas, `código` en línea,
+ * cabeceras, viñetas (anidadas y numeradas), citas, hr, cursiva, enlaces y cercos ```.
+ * Lo que no empareja queda literal — inventarse un cierre sería un bug mudo delante
+ * del usuario. Las tablas no se maquetan: pasan literales.
+ */
+/**
+ * Los marcadores EN LÍNEA: `**negrita**` y `` `código` ``.
+ *
+ * Puro: recibe el tema y devuelve la línea lista para escribir. Con un tema sin color
+ * (pipe, CI) los tokens son cadena vacía y la salida queda limpia.
+ */
+export declare function renderizarInline(texto: string, tema: Tema): string;
+/**
+ * Por dónde cortar un párrafo que llega en trozos y aún no ha visto su `\n`.
+ *
+ * El streaming tiene que verse (un colchón que solo se suelta al final es un `ainvoke`
+ * disfrazado), pero cortar por donde sea rompe marcadores: un `**` partido entre dos
+ * escrituras queda literal para siempre. Así que el corte es en un ESPACIO, con los
+ * pares `**` y `` ` `` CERRADOS en lo escrito. Se devuelve el ÚLTIMO corte seguro
+ * (menos escrituras), y `undefined` si no hay ninguno — entonces se espera.
+ */
+export declare function puntoSeguro(colchon: string, minimo: number): number | undefined;
+/**
+ * ¿Qué líneas de una lista están DENTRO de un cerco? Una por línea, en orden: el
+ * estado ANTES de cada línea (así la del ```, abierta o cerrada, queda fuera).
+ *
+ * La TUI necesita saberlo POR LÍNEA y sin estado propio: sus actos asistente son líneas
+ * definitivas en orden, así que un pase sobre ellas basta. Un cerco sin cerrar deja el
+ * resto dentro — inventarse un cierre sería un bug mudo delante del usuario.
+ */
+export declare function estadosDeCerco(lineas: readonly string[]): boolean[];
+/** Una línea de markdown ya clasificada: lo que la piel pinta sin volver a parsear. */
+export type LineaDeMarkdown = {
+    tipo: "cabecera";
+    nivel: 1 | 2 | 3;
+    texto: string;
+} | {
+    tipo: "vineta";
+    nivel: number;
+    texto: string;
+} | {
+    tipo: "numerada";
+    nivel: number;
+    numero: number;
+    texto: string;
+} | {
+    tipo: "cita";
+    nivel: number;
+    texto: string;
+} | {
+    tipo: "horizontal";
+}
+/** Abre o cierra: quien llama lo sabe por `estadosDeCerco`, no por la cadena. */
+ | {
+    tipo: "cerco";
+    lenguaje: string;
+} | {
+    tipo: "texto";
+    texto: string;
+};
+/**
+ * Clasificar UNA línea definitiva de markdown: solo ve líneas que empiezan de verdad
+ * (una continuación de párrafo es el colchón, y ese se pinta por su lado). La sangría
+ * es 2 espacios por nivel, la medida que los modelos emiten de verdad.
+ */
+export declare function clasificarLinea(texto: string): LineaDeMarkdown;
+/** Una línea de tabla ya parseada, con los anchos que comparte con TODA su tabla. */
+export interface LineaDeTabla {
+    celdas: string[];
+    anchos: number[];
+    rol: "cabecera" | "separador" | "fila";
+    /** La última línea del tramo: el skin pinta el cierre después de ella. */
+    esUltima: boolean;
+}
+/**
+ * Detectar las tablas de una lista de líneas (la que la TUI ya sabe que es asistente):
+ * una tabla es cabecera + separador + filas consecutivas que empiezan por `|`; una
+ * línea vacía o de otro tipo la corta. Sin separador NO hay tabla — las barras de un
+ * párrafo normal quedan literales. El resultado, uno por línea: qué celdas lleva, qué
+ * anchos comparte toda la tabla (el máximo por columna, recortado con «…» al ancho
+ * disponible) y si es la última del tramo (para pintar el cierre).
+ */
+export declare function contextoDeTabla(lineas: readonly string[], ancho?: number): (LineaDeTabla | null)[];
+/** El estado de bloque que sobrevive entre líneas: solo el cerco de código. */
+export declare class RenderizadorDeMarkdown {
+    private readonly tema;
+    private enCerco;
+    constructor(tema: Tema);
+    /**
+     * Una línea (o un corte de párrafo) tal como llega del flujo, SIN su `\n`.
+     *
+     * `inicioDeLinea` dice si este trozo empieza línea de verdad: una continuación de
+     * párrafo no puede ser cabecera ni viñeta, aunque empiece por «##» o «- ».
+     *
+     * **Sin color (pipe, CI), la línea sale tal cual**: no se quitan «##», ni «- » se
+     * vuelve «•», ni el cerco desaparece. Despintar el markdown sin dar nada a cambio
+     * es quitarle información a quien lee la salida.
+     */
+    linea(texto: string, inicioDeLinea?: boolean): string;
+}
+/** Un trozo de línea con su significado: la TUI lo pinta y la stdio lo colorea. */
+export type EstiloDeSegmento = "normal" | "negrita" | "mudo" | "codigo" | "cursiva" | "enlace";
+export interface Segmento {
+    texto: string;
+    estilo: EstiloDeSegmento;
+}
+/**
+ * Parte una línea en segmentos inline — la MISMA gramática que `renderizarInline`
+ * (`**negrita**`, `` `código` ``) más lo que la TUI maqueta y la stdio no: `*cursiva*`
+ * y `[enlace](url)`, que se pide en DATOS y no en ANSI (un `<Text>` de Ink no puede
+ * llevar códigos de escape dentro). El código y el enlace llevan estilo PROPIO
+ * («codigo», «enlace»), que la TUI pinta en acento; la url del enlace va aparte, en
+ * mudo y entre paréntesis — en TUI no hay clic, y despintar la url es quitarle
+ * información a quien lee.
+ */
+export declare function segmentosDe(texto: string): Segmento[];

package/dist/cli/panel.d.ts

@@ -0,0 +1,38 @@
+/**
+ * El panel de avisos: el recinto de hasta `tope` líneas grises donde viven las
+ * notificaciones de sistema (pausas, avisos deterministas, el tiempo final) MIENTRAS
+ * dura, en vez de ir dejando un rastro en el scrollback.
+ *
+ * La regla que hereda del append-only de la consola, y su excepción a la vez: el panel
+ * vive POR ENCIMA del punto de escritura y se repinta en sitio — la única cosa de la
+ * piel que escribe por encima de la última línea, acotada a `tope` líneas. Cualquier
+ * contenido real la solidifica antes de escribir (la cascada de `stdio.ts`), y del
+ * panel solo queda entonces la última línea, como línea gris de siempre.
+ *
+ * La mecánica es de borrado EXACTO, nunca «borrar hasta el fin de pantalla»: tanto el
+ * repintado como el colapso limpian una a una las líneas que sobran, porque debajo del
+ * panel puede haber una línea viva (el spinner de fase) que no es suya y no puede
+ * comerse. Por lo mismo, cada línea pintada termina en `\n`: el cursor descansa en el
+ * punto de escritura, que siempre está DEBAJO del panel.
+ */
+import type { Escribir } from "./stdio.js";
+import type { Tema } from "./tema.js";
+/** Cuántas líneas grises vive el panel como máximo antes de reciclar al más viejo. */
+export declare const TOPE_DEL_PANEL = 5;
+export declare class PanelDeAvisos {
+    private readonly escribir;
+    private readonly tema;
+    private readonly tope;
+    private readonly lineas;
+    private pintadas;
+    constructor(escribir: Escribir, tema: Tema, tope?: number);
+    /** Añade un aviso (reciclando al más viejo si se pasa del tope) y repinta el panel. */
+    avisa(texto: string): void;
+    /**
+     * Colapsa el panel: deja SOLO la última línea en el historial — colocada donde
+     * empezaba el panel— y limpia las demás. Con el panel vacío no escribe nada.
+     */
+    solidifica(): void;
+    /** Una línea del panel: limpia, texto en mudo, y el salto que baja al punto de escritura. */
+    private pintar;
+}

package/dist/cli/podar.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `xonecode podar`: adelgazar de una vez la memoria del agente de los proyectos que ya están
+ * gordos.
+ *
+ * **Existe porque el mantenimiento automático no alcanza a lo que ya pasó.** La poda del
+ * cierre de turno (`web/servidor/vestibulo.ts`) solo corre cuando alguien vuelve a trabajar
+ * en ese proyecto, y cuando esto se escribió había 1,5 GB repartidos en siete copias del
+ * workspace, la mayoría sin tocar desde hacía días. Un comando lo resuelve hoy; el
+ * automático evita que vuelva.
+ *
+ * **La autorización es teclear el comando**, como `/pdf` o crear una tarea: esto borra, y lo
+ * pide quien está delante — no el modelo, que ni siquiera lo alcanza.
+ *
+ * Y se dice lo que se hizo POR PROYECTO, no un total: un total no deja comprobar nada.
+ */
+import { crearCheckpointerDeProyecto, hayPendientesEnLaBase, podarCheckpointer, tamanoDelCheckpointer } from "../agent/sesiones/checkpointer.js";
+export interface ProyectoQuePodar {
+    /** Cómo se llama para una persona. Lo que se ENSEÑA: la ruta no se pinta. */
+    nombre: string;
+    raiz: string;
+}
+export declare function cmdPodar(proyectos: ProyectoQuePodar[], escribirCrudo: (texto: string) => void, deps?: {
+    podar?: typeof podarCheckpointer;
+    checkpointer?: typeof crearCheckpointerDeProyecto;
+    tamano?: typeof tamanoDelCheckpointer;
+    pendientes?: typeof hayPendientesEnLaBase;
+}): number;
+/**
+ * Los proyectos que hay bajo el workspace, `<workspace>/<entorno>/<proyecto>`.
+ *
+ * Se recorre el DISCO y no el `settings.json`: lo que hay que podar es lo que está bajado,
+ * y un entorno dado de baja deja sus copias ahí igual. Lo que no se pueda leer se salta —
+ * este comando no puede fallar por una carpeta rara.
+ *
+ * El nombre que se enseña es `entorno/proyecto`, que es como el usuario los distingue, y
+ * NUNCA la ruta: es el mismo trato que le da el cable (`sinRutas`).
+ */
+export declare function proyectosDelWorkspace(base: string): ProyectoQuePodar[];

package/dist/cli/run.d.ts

@@ -0,0 +1,30 @@
+import { type Escribir } from "./stdio.js";
+import { hidratarFuentesDeDisco } from "./fuentesDeDisco.js";
+import type { FuentesDeEleccion } from "../core/modelos.js";
+export interface OpcionesRun {
+    peticion: string;
+    escribir?: Escribir;
+    retardoMs?: number;
+    /** `--real`: corre el agente real sobre el proyecto del cwd, no el guion. */
+    real?: boolean;
+    /** Las fuentes de modelo resueltas en `main.ts`, para construir los clientes reales. */
+    fuentes?: FuentesDeEleccion;
+    /**
+     * De dónde salen la configuración de disco y las credenciales. Entra por parámetro —con la
+     * de verdad por omisión— porque es la costura que ningún test alcanzaba: compuesta dentro
+     * de `correrReal`, que no se puede correr sin abrir una sesión real, la regla se quedaba
+     * escrita. El mismo trato que `verifier` en `abrirSesionReal`.
+     */
+    hidratar?: typeof hidratarFuentesDeDisco;
+    /** El entorno del proceso, del que se lee `XONECODE_TOPE_DE_RONDAS`. Por parámetro para poder probarlo. */
+    entornoDeProceso?: Record<string, string | undefined>;
+}
+/**
+ * Un disparo: una petición, un turno, y a la calle. Pipeable.
+ *
+ * Devuelve el código de salida. **Una pausa sin humano no es un éxito**: en modo un
+ * disparo no hay a quién preguntar, así que se sale con código distinto de cero para que
+ * CI no lea como «hecho» un turno que se quedó esperando una aprobación que nadie iba a
+ * dar. No se aprueba por omisión: aprobar EJECUTA, y ante la duda va la opción recuperable.
+ */
+export declare function cmdRun(opciones: OpcionesRun): Promise<number>;

package/dist/cli/spinner.d.ts

@@ -0,0 +1,37 @@
+import type { Tema } from "./tema.js";
+import type { Escribir } from "./stdio.js";
+/** Los segundos que lleva la fase: vacío hasta que cumple el primer segundo. */
+export declare function sufijoDeTiempo(ms: number): string;
+export declare class AnimadorDeFase {
+    private readonly escribir;
+    private readonly tema;
+    /** Cómo de seguido repinta el fotograma. Entra por parámetro para los tests. */
+    private readonly intervalo;
+    /** El reloj, inyectado por la misma razón: un test mueve el tiempo, no lo espera. */
+    private readonly reloj;
+    private cuadro;
+    private texto;
+    private t0;
+    private temporizador;
+    constructor(escribir: Escribir, tema: Tema, 
+    /** Cómo de seguido repinta el fotograma. Entra por parámetro para los tests. */
+    intervalo?: number, 
+    /** El reloj, inyectado por la misma razón: un test mueve el tiempo, no lo espera. */
+    reloj?: () => number);
+    activo(): boolean;
+    /**
+     * Empieza a animar una fase. Sin color es la línea estática de siempre y no arranca
+     * nada; con color, la fase anterior (si la había) queda como línea estática.
+     */
+    empieza(texto: string): void;
+    /**
+     * Repinta el fotograma. Público a propósito: el `setInterval` llama aquí, y los
+     * tests también — sin esperar 120 ms de verdad.
+     */
+    pinta(): void;
+    /**
+     * Deja la fase como línea estática en el historial y para el reloj. Sin fase activa
+     * no escribe nada: la cascada lo llama antes de CUALQUIER otra escritura.
+     */
+    termina(): void;
+}

package/dist/cli/stdio.d.ts

@@ -0,0 +1,94 @@
+import * as readline from "node:readline";
+import type { Piel } from "../core/turno.js";
+import { type Preguntar } from "./aprobar.js";
+import { type Tema } from "./tema.js";
+/** Escribe SIN añadir salto de línea. La implementación real hace flush. */
+export type Escribir = (texto: string) => void;
+/**
+ * La piel de terminal.
+ *
+ * El streaming del asistente se suelta por LÍNEA CONFIRMADA (y, en párrafos largos, por
+ * cortes que no rompen marcadores), y no por trozo: una consola que NO repinta solo
+ * puede escribir una línea cuando su texto es definitivo — un `**` partido entre dos
+ * escrituras queda literal para siempre. Sigue siendo streaming: la línea confirmada
+ * se pinta en el acto, y un colchón que solo se suelta al final sería un `ainvoke`
+ * disfrazado.
+ *
+ * Las otras dos cosas medidas, con el mismo síntoma (el streaming no se ve) y causas
+ * distintas:
+ *
+ * 1. **`flush` explícito** (en `escribirEnStdout`). Sin él la salida se queda en el
+ *    buffer y no aparece hasta que se vacía sola — un fallo que solo se manifiesta en
+ *    procesos de larga duración, o sea justo en el caso de uso real.
+ * 2. **Un solo `escribir` por línea confirmada**: juntar trozos en un buffer y volcar
+ *    al final también evita frases partidas, pero deja de ser streaming.
+ */
+export declare function crearPielStdio(escribir: Escribir, tema?: Tema): Piel;
+/**
+ * El `escribir` de producción. El `flush` es implícito en Node —`process.stdout.write`
+ * escribe ya—, pero se pasa por aquí para que exista UN solo sitio que cambiar si algún
+ * día hace falta forzarlo.
+ */
+export declare const escribirEnStdout: Escribir;
+/**
+ * ¿Se acabó la entrada? Es la ÚNICA definición de «este readline ya está cerrado», y la
+ * comparten `crearPreguntar` (para no lanzar) y `pedirDecisiones` (para no confundir un
+ * EOF con un Enter). Dos definiciones de esto acabarían divergiendo, y divergir aquí es
+ * aprobar una escritura que nadie autorizó.
+ *
+ * `rl.closed` existe en runtime pero no está en los tipos de esta versión de @types/node
+ * — mismo caso que `rl.history` más abajo, y mismo cast justificado.
+ */
+export declare function crearDetectorDeEof(rl: readline.Interface): () => boolean;
+/**
+ * El `preguntar` de producción para la consola: usa el ÚNICO `readline.Interface`
+ * compartido con el lazo de líneas y con `leerSecreto`. Tres lectores de stdin no pueden
+ * competir por sus eventos `data`; con un solo `rl`, `rl.question` se intercala sin
+ * robarle líneas al `for await` del lazo (es readline quien arbitra internamente).
+ *
+ * **Si el rl ya está cerrado (o se cierra a media pregunta), resuelve con cadena vacía
+ * y no lanza.** Es el EOF de un pipe que se agota mientras el turno corre — medido en
+ * e2e: la aprobación pregunta 20 segundos después de que stdin hiciera EOF, y el
+ * `readline was closed` abortaba el turno con el interrupt colgado. Mismo pacto que
+ * `leerSecreto` con su `alCerrar`.
+ *
+ * **Y esa cadena vacía NO es segura por sí sola** —el comentario que estuvo aquí decía lo
+ * contrario y era falso—: `interpretAnswer` la RECHAZA sin TTY, pero CON TTY la aprueba,
+ * porque el Enter a secas vale por un sí (`APPROVALS_TTY`, `vendor/hitl.ts`). Con un
+ * terminal de verdad delante, un Ctrl-D aprobaba una escritura de fichero. Por eso quien
+ * decide sobre una aprobación necesita además `crearDetectorDeEof`: sirve para distinguir
+ * las dos cosas que aquí llegan idénticas —un humano que pulsa Enter y un stdin que se
+ * acabó—, que es justo lo que la cadena vacía sola no puede contar.
+ * **Y el enunciado de una decisión se enseña CON su pista de tecleo, que la añade aquí.**
+ * `politicaInteractiva` pregunta «¿Subir a CloudStudio?» a secas porque el `[s/N]` es la
+ * pista de una piel con teclado, y esa piel es ésta: la tarjeta de la consola web no tiene
+ * campo donde teclear, así que ahí la pista sobra. Se decide por `decision` —un dato— y no
+ * buscando un `[s/N]` dentro del texto, que sería leer la sintaxis que este mismo fichero
+ * acaba de escribir.
+ */
+export declare function crearPreguntar(rl: readline.Interface): Preguntar;
+/**
+ * `leerSecreto` de producción (para `/provider <nombre>`): mismo `rl` que el lazo y
+ * `preguntar`, con el eco apagado mientras dura la pregunta.
+ *
+ * **No hay API pública de readline para silenciar el eco por tecla manteniendo la edición
+ * de línea** (backspace, etc.): la única costura es `_writeToOutput`, un método interno y
+ * no documentado — verificado contra Node 22 (existe, y es la vía que usan las
+ * herramientas de terminal que piden contraseña sin librería aparte). Se sustituye para
+ * dejar pasar SOLO el propio prompt (para que se vea la pregunta) y silenciar cualquier
+ * otra escritura —el eco de cada tecla— hasta que la pregunta termine. `rl.history`
+ * tampoco está en los tipos de esta versión de @types/node aunque existe en runtime
+ * (documentado desde Node 15.8), así que comparte el mismo cast justificado.
+ *
+ * Se restaura SIEMPRE, y por DOS vías, porque un terminal que se queda sin eco obliga al
+ * usuario a cerrarlo:
+ *   1. En el callback de `rl.question`: el camino normal.
+ *   2. En un `close` de `rl` a media pregunta (Ctrl-D/EOF sin dar línea): sin esto la
+ *      promesa no se resuelve nunca y el manejador de `/provider` se queda colgado para
+ *      siempre dentro del lazo de la consola.
+ *
+ * Y se borra la clave de `rl.history` tras leerla: readline añade la respuesta de
+ * `question` al historial igual que cualquier línea, y una flecha-arriba la recuperaría
+ * en claro en la MISMA sesión.
+ */
+export declare function crearLeerSecreto(rl: readline.Interface): (pregunta: string) => Promise<string>;