xonecode 0.38.44 → 0.39.2

package/dist/cli/tema.d.ts

@@ -0,0 +1,68 @@
+/**
+ * El vocabulario de color de las pieles: tokens SEMÁNTICOS, nunca colores.
+ *
+ * Una piel pide significado (`tema.exito`, `tema.mudo`) igual que la TUI de
+ * qwen-code pide `theme.status.success`: si mañana hay temas de usuario o el diff
+ * quiere fondos en vez de texto, se cambia ESTE fichero y ninguna piel se entera.
+ * Es el mismo principio que `core/ports.ts` aplicado al color: lo que puede cambiar
+ * entra por una costura, no se pega a quien lo usa.
+ *
+ * La otra mitad del contrato: **con `conColor: false`, TODO token es cadena vacía.**
+ * Las pieles no ramifican por TTY — componen `${t.mudo}texto${t.reset}` igual en una
+ * tubería que en un terminal, y lo que mantiene limpios los pipes y los logs de CI es
+ * que el tema apagado no tiene nada que poner. (Y `src/cli/tema.test.ts` recorre
+ * `src/` entera y falla si alguien escribe un ANSI fuera de aquí.)
+ */
+/** Códigos de apertura; `reset` cierra. `texto` es vacío también con color: el color por omisión del terminal. */
+export interface Tema {
+    texto: string;
+    mudo: string;
+    negrita: string;
+    exito: string;
+    aviso: string;
+    grave: string;
+    /** El `+` de un diff. */
+    anadido: string;
+    /** El `-` de un diff. */
+    quitado: string;
+    prompt: string;
+    reset: string;
+    /**
+     * Borrar del cursor al final de la línea (EL). Lo usa el spinner para dejar limpia
+     * su línea antes de escribir la estática — el fotograma animado puede ser más largo
+     * que la línea que lo reemplaza. Sin color es vacío porque el spinner ni arranca.
+     */
+    borrar: string;
+    /** Borrar la línea entera, cursor incluido (EL con parámetro 2). Lo usa el panel de avisos para repintar. */
+    limpiarLinea: string;
+    /**
+     * Mover el cursor N líneas hacia arriba (CUU parametrizado): la única forma de
+     * repintar las líneas del panel de avisos, que viven POR ENCIMA del punto de
+     * escritura. `0` líneas no escribe nada.
+     */
+    arriba: (lineas: number) => string;
+}
+/** Identificadores estables: los comandos y la TUI nunca dependen de un color concreto. */
+export type IdTema = "xone" | "clear" | "midnight" | "graphite" | "ember";
+export declare const TEMAS: readonly {
+    id: IdTema;
+    etiqueta: string;
+    detalle: string;
+}[];
+export declare function temaActivo(): IdTema;
+export declare function seleccionarTema(id: IdTema): void;
+export declare function esTema(valor: string): valor is IdTema;
+export declare function crearTema(conColor: boolean, id?: IdTema): Tema;
+/**
+ * Los modos de terminal de la TUI (`cli/tui/raton.ts`), aquí porque este es el único
+ * fichero de producción con escapes ANSI (tema.test.ts lo vigila): son control de
+ * terminal, como `arriba` o `limpiarLinea`, no color. Solo se escriben con stdout TTY.
+ */
+export declare const MODOS_DE_TERMINAL: {
+    /** `?1049h` entra en la pantalla alternativa (la de vim); `H` lleva el cursor arriba a la izquierda. */
+    readonly entrarPantallaAlternativa: "\u001B[?1049h\u001B[H";
+    readonly salirPantallaAlternativa: "\u001B[?1049l";
+    /** `?1000h` pide botones (la rueda son los botones 64/65); `?1006h` los codifica en SGR, legibles. */
+    readonly activarRaton: "\u001B[?1000h\u001B[?1006h";
+    readonly desactivarRaton: "\u001B[?1006l\u001B[?1000l";
+};

package/dist/cli/tokens.d.ts

@@ -0,0 +1,16 @@
+/**
+ * El formato compacto de cifras, COMPARTIDO por las dos pieles.
+ *
+ * Vivía duplicado — `formatearTokens` en `main.ts` y un `compacto` propio en
+ * `tui/sidebar.tsx` — y las pieles divergían: la sidebar decía «200.0K» donde stdio
+ * decía «200K». Un indicador que da dos cifras según la piel no es un formato, son
+ * dos a la espera de desincronizarse; la cifra compacta vive aquí y ninguna piel
+ * compone la suya. (No puede vivir en `main.ts` porque `cli/tui/` no lo importa:
+ * sería un ciclo.)
+ */
+/** `999`, `12.8K`, `200K`, `1.5M` — un decimal cuando hace falta, `.0` de cortesía nunca. */
+export declare function compacto(n: number): string;
+/** Token compacto para la línea de estado: `0 tokens` hasta 999, `12.8K tokens` a partir de 1000. */
+export declare function formatearTokens(total: number): string;
+/** El tope de contexto, compacto: `131K`, `200K`, `1M`. Sin decimales de cortesía. */
+export declare function formatearTope(tope: number): string;

package/dist/cli/traza.d.ts

@@ -0,0 +1,19 @@
+import { type Escribir } from "./stdio.js";
+/**
+ * `xonecode traza [--todas]`: a dónde se fueron los tokens del proyecto del cwd.
+ *
+ * Lee `.xonecode/traza-tools.jsonl` —lo que dejó una sesión corrida con
+ * `XONECODE_TRACE_TOOLS=1`— y lo agrega por origen y por tool. No toca red, ni modelo, ni
+ * el proyecto: es un lector.
+ *
+ * **Por omisión informa de la ÚLTIMA sesión**, que es la que acabas de medir, y DICE cuántas
+ * hay en el fichero. El fichero es append-only y una máquina acumula ejecuciones de días:
+ * sumarlas todas en una cifra daría un número plausible del turno de ayer más el de ahora.
+ *
+ * Que no haya traza sale con **70**, no con 0: falta lo que este comando necesita para
+ * trabajar y el proyecto no tiene nada que ver — el mismo trato que `verify` le da a un
+ * simulador que no está. Un 0 con un informe en blanco se leería como «no gastaste nada».
+ */
+export declare function cmdTraza(raiz: string, escribir?: Escribir, opciones?: {
+    todas?: boolean;
+}): Promise<number>;

package/dist/cli/tui/app.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from "react";
+import { crearStore, type Ranura, type VistaDeTui } from "./store.js";
+import { type DatosDeSidebar } from "./sidebar.js";
+import type { EmisorDeRueda } from "./raton.js";
+type Store = ReturnType<typeof crearStore>;
+export declare function App({ store, vista: ranuraVista, alEnviar, responder, responderSelector, completa, historial, datosSidebar, alCancelarTurno, rueda, }: {
+    store: Store;
+    vista: Ranura<VistaDeTui>;
+    alEnviar: (linea: string) => void;
+    /** La respuesta a la pregunta viva (la ranura la enruta a quien preguntó). */
+    responder: (linea: string) => void;
+    /** La respuesta del selector vivo (Enter entrega id; Escape cancela). */
+    responderSelector: (id: string | undefined) => void;
+    completa: (linea: string) => [string[], string];
+    /** Contrato de Entrada: la MÁS RECIENTE en el índice 0. */
+    historial: readonly string[];
+    /** Se lee en CADA render: los tokens y el modelo cambian mientras corre el turno. */
+    datosSidebar: () => DatosDeSidebar;
+    alCancelarTurno: () => void;
+    /** Las muescas de la rueda del ratón para el transcript; sin ratón, no hay emisor. */
+    rueda?: EmisorDeRueda;
+}): ReactNode;
+export {};

package/dist/cli/tui/aprobarTui.d.ts

@@ -0,0 +1,46 @@
+/**
+ * El modal de aprobación de la TUI: el reductor puro, la promesa del puerto
+ * `pedirAprobacion` y el componente Ink. Mismo espíritu que `cli/aprobar.ts` (las
+ * mismas constantes de diff, el mismo fail-closed) pero el destino es el store de la
+ * TUI y no un `preguntar` de stdin.
+ */
+import { type Decision } from "../../vendor/hitl.js";
+import type { PendienteDeAprobacion } from "../../core/events.js";
+import { type LineaDeDiff } from "../../core/diff.js";
+import type { ReactNode } from "react";
+export interface EstadoDeAprobacion {
+    pendientes: PendienteDeAprobacion[];
+    indice: number;
+    decisiones: Map<string, Decision>;
+    /** Solo al agotar la lista: una decisión POR CADA pendiente. */
+    terminado?: Map<string, Decision>;
+}
+export declare function estadoInicial(pendientes: PendienteDeAprobacion[]): EstadoDeAprobacion;
+/**
+ * Puro: una respuesta («aprobar» | «rechazar») avanza el índice y acumula la decisión
+ * del pendiente actual. Al agotar la lista, `terminado` lleva el Map completo — el
+ * fail-closed de los pendientes sin responder vive en `pedirDecisionesTui`, que rellena
+ * con RECHAZO lo que falte, pero el contrato aquí es que lo agotado está decidido entero.
+ */
+export declare function reductorDeAprobacion(s: EstadoDeAprobacion, respuesta: "aprobar" | "rechazar"): EstadoDeAprobacion;
+/** Las props que `montar` recibe para pintar el modal: lo que mira y a quién avisa. */
+export interface PropsDelModal {
+    pendientes: PendienteDeAprobacion[];
+    fichero: (id: string) => string | undefined;
+    diff: (id: string) => LineaDeDiff[] | undefined;
+    alTerminar: (d: Map<string, Decision>) => void;
+}
+/**
+ * El puerto `pedirAprobacion` en TUI — MISMA firma que `abrirSesionReal` espera. `montar`
+ * lo pone en el store de la app (el modal se pinta); la promesa resuelve con TODAS las
+ * decisiones. **Desmontar el modal sin responder es rechazo de los restantes** — la
+ * costura del fail-closed está aquí, porque aprobar ESCRIBE y lo que no se entiende no
+ * toca nada.
+ */
+export declare function pedirDecisionesTui(pendientes: PendienteDeAprobacion[], ficheros: Map<string, string>, diffs: Map<string, LineaDeDiff[]>, montar: (props: PropsDelModal) => void): Promise<Map<string, Decision>>;
+/**
+ * El modal: enseña el pendiente actual con su diff coloreado (el ÚNICO sitio donde el
+ * contenido de una escritura se enseña, porque aquí se DECIDE sobre él) y lee el teclado.
+ * **Fail-closed por tecla**: solo «s»/«S» aprueba; «n», Enter, Escape y Ctrl-C rechazan.
+ */
+export declare function ModalAprobacion({ pendientes, fichero, diff, alTerminar }: PropsDelModal): ReactNode;

package/dist/cli/tui/barra.d.ts

@@ -0,0 +1,43 @@
+/**
+ * El bloque con barra izquierda: la forma de los mensajes del usuario, de la Entrada y
+ * de la Pregunta. Solo el lado izquierdo, con `┃` (la vertical gruesa de cajas, la de
+ * OpenCode: MEDIDO, `▌` no llena la celda en vertical con la fuente del usuario y salía a
+ * trozos entre filas; los glifos de cajas están hechos para empalmar), y NUNCA borde arriba ni abajo: en el
+ * transcript un acto es una fila (`ventanaDe` cuenta así), y una caja de tres filas por
+ * mensaje se saldría de la pantalla. Vive aparte de los componentes para que las tres
+ * cajas no puedan divergir en la barra. La Entrada (entrada.tsx) extiende esta forma: pone
+ * `paddingLeft` a 0 y mete el aire dentro de cada fila, con fondo, porque es la tarjeta
+ * donde se escribe y tiene que verse; la barra sigue siendo esta.
+ *
+ * TypeScript puro: son props de Box, pero no importa ink — no hace falta.
+ */
+/** El estilo de borde: `left` es lo único que se pinta, el resto queda vacío por contrato. */
+export declare const BORDE_BARRA: {
+    readonly topLeft: "";
+    readonly top: "";
+    readonly topRight: "";
+    readonly right: "";
+    readonly bottomRight: "";
+    readonly bottom: "";
+    readonly bottomLeft: "";
+    readonly left: "┃";
+};
+/** Las props de un `<Box>` de Ink para un bloque con barra izquierda del color dado. */
+export declare function barra(color: string): {
+    readonly borderStyle: {
+        readonly topLeft: "";
+        readonly top: "";
+        readonly topRight: "";
+        readonly right: "";
+        readonly bottomRight: "";
+        readonly bottom: "";
+        readonly bottomLeft: "";
+        readonly left: "┃";
+    };
+    readonly borderTop: false;
+    readonly borderRight: false;
+    readonly borderBottom: false;
+    readonly borderLeft: true;
+    readonly borderLeftColor: string;
+    readonly paddingLeft: 1;
+};

package/dist/cli/tui/correrTui.d.ts

@@ -0,0 +1,119 @@
+import { type FuentesDeEleccion } from "../../core/modelos.js";
+import type { CatalogoModelosPort } from "../../core/ports.js";
+import type { SesionReal } from "../../agent/turno/sesionReal.js";
+import { type Consola, type EjecutorDeTurno } from "../consola.js";
+import { type Acto, type VistaDeTui } from "./store.js";
+import type { DatosDeSidebar } from "./sidebar.js";
+/**
+ * La raíz con el HOME abreviado a `~`, para el pie: `/Users/x/dev/MinitMT` sale como
+ * `~/dev/MinitMT`. La ruta absoluta entera es ruido —y en una captura de pantalla, el
+ * nombre de usuario— y el pie tiene sitio contado. Pura, con `home` inyectable: así se
+ * prueba sin depender del HOME de quien corre los tests.
+ *
+ * Solo el PREFIJO, y solo si es el home entero o el home seguido de separador:
+ * `/Users/xy` no empieza por `/Users/x` como carpeta, aunque sí como texto.
+ */
+export declare function abreviarHome(ruta: string, home?: string): string;
+export interface OpcionesDeConsolaTui {
+    raiz: string;
+    /** El montaje de `main` comparte esta instancia con la consola stdio. */
+    catalogoModelos: CatalogoModelosPort;
+    /** Persistencia inyectada: la piel no conoce el adaptador de disco de `agent/`. */
+    guardarModeloGlobal: Consola["guardarModeloGlobal"];
+    guardarTemaDeProyecto?: NonNullable<Consola["guardarTemaDeProyecto"]>;
+    conectarCloudStudio?: Consola["conectarCloudStudio"];
+    guardarCloudStudioDeProyecto?: Consola["guardarCloudStudioDeProyecto"];
+    guardarModoDeProyecto?: Consola["guardarModoDeProyecto"];
+    guardarProyectoCloudStudioDeProyecto?: Consola["guardarProyectoCloudStudioDeProyecto"];
+    ramasDeCloudStudio?: Consola["ramasDeCloudStudio"];
+    guardarRamaDeProyecto?: Consola["guardarRamaDeProyecto"];
+    guardarModelosDeProyecto?: Consola["guardarModelosDeProyecto"];
+    /** Sincronización con CloudStudio inyectada desde `main.ts`: la TUI no conoce MCP ni git. */
+    sincronizar?: Consola["sincronizar"];
+    /** Fuentes del modelo de sesión: deciden el modelo que la sidebar enseña al arrancar. */
+    fuentes?: FuentesDeEleccion;
+    /** Costura de test: los tests no preguntan a git. */
+    rama?: string;
+    /** El tope de contexto del modelo actual (proyecto > global), como lo declara /config. */
+    topeDe?: (id: string) => number | undefined;
+}
+/**
+ * La envoltura de ocupación: un turno más, Ctrl-C pasa a cancelarlo y la Entrada puede
+ * encolar seguimiento. Exportada para probarla sin montar Ink — y aplicada a LOS DOS caminos de
+ * ejecutor (el real y el guionizado por omisión): `--guion` fuerza `crearEjecutor` a
+ * undefined, y un envoltorio solo para la rama real dejaba el turno guionizado sin
+ * ocupación nunca.
+ */
+export declare function envolverConOcupacion(ejecutor: EjecutorDeTurno, ocupar: (ocupado: boolean) => void): EjecutorDeTurno;
+/**
+ * La Consola completa que la TUI implementa: una cola async de líneas (lo que entra por
+ * la Entrada), un `escribir` que cae en el store, la piel TUI, las preguntas por la
+ * misma entrada y las aprobaciones por el modal. Devuelve también las piezas que `App`
+ * necesita pintar, porque todas comparten ESTE cierre (store, cola, historial): quien
+ * reparte a mano acabarían siendo dos mundos.
+ */
+export declare function crearConsolaTui(opciones: OpcionesDeConsolaTui): {
+    consola: Consola;
+    store: {
+        estado: () => import("./store.js").EstadoDeTui;
+        suscribir(suscriptor: () => void): () => void;
+        token(texto: string): void;
+        cerrarLinea(): void;
+        linea(texto: string, tipo?: "error" | "usuario" | "asistente" | "razonamiento" | "sistema" | "fase" | "tool"): void;
+        usuario(texto: string): void;
+        error(texto: string): void;
+        fase(texto: string): void;
+        pausa(): void;
+        rearmar(): void;
+        fin(ms: number, modelo?: string): void;
+    };
+    vista: import("./store.js").Ranura<VistaDeTui>;
+    enviar: (linea: string) => void;
+    /** Lo que la Entrada/Pregunta llama con la línea final: resuelve la pregunta viva. */
+    responder: (linea: string) => void;
+    /** Resuelve el selector visible; Enter entrega un id y Escape `undefined`. */
+    seleccionar: (id: string | undefined) => void;
+    /** Ctrl-C durante un turno: la piel del turno en curso lanza en su próximo acto. */
+    cancelar: () => void;
+    /** La costura por la que el ejecutor real apunta la sidebar a su tracker. */
+    alAbrirSesion: (sesion: SesionReal) => void;
+    actos: () => Acto[];
+    historial: string[];
+    completa: (linea: string) => [string[], string];
+    datosSidebar: () => DatosDeSidebar;
+};
+export interface OpcionesDeMontaje {
+    fuentes: FuentesDeEleccion;
+    raiz: string;
+    guion: boolean;
+    catalogoModelos: CatalogoModelosPort;
+    guardarModeloGlobal: Consola["guardarModeloGlobal"];
+    guardarTemaDeProyecto?: NonNullable<Consola["guardarTemaDeProyecto"]>;
+    conectarCloudStudio?: Consola["conectarCloudStudio"];
+    guardarCloudStudioDeProyecto?: Consola["guardarCloudStudioDeProyecto"];
+    guardarModoDeProyecto?: Consola["guardarModoDeProyecto"];
+    guardarProyectoCloudStudioDeProyecto?: Consola["guardarProyectoCloudStudioDeProyecto"];
+    ramasDeCloudStudio?: Consola["ramasDeCloudStudio"];
+    guardarRamaDeProyecto?: Consola["guardarRamaDeProyecto"];
+    guardarModelosDeProyecto?: Consola["guardarModelosDeProyecto"];
+    sincronizar?: Consola["sincronizar"];
+    /** La inspección del prólogo; el real ejecuta el simulador y entra por omisión. */
+    inspeccionarProyecto?: (raiz: string) => Promise<{
+        colecciones: number;
+        esProyectoXone: boolean;
+    }>;
+    /** El asistente de creación de proyecto; desde `main.ts`, para no duplicarlo. */
+    ofrecer?: (raiz: string, consola: Consola) => Promise<boolean>;
+    /**
+     * La fábrica del ejecutor REAL (`crearEjecutorReal` en main.ts), inyectada y llamada
+     * UNA vez: su cierre guarda la sesión entre turnos. Con `--guion` (o sin fábrica) el
+     * lazo cae en `ejecutarTurnoGuionizado`, el valor por omisión de `correrConsola`.
+     */
+    crearEjecutor?: (alAbrirSesion: (sesion: SesionReal) => void) => EjecutorDeTurno;
+    topeDe?: (id: string) => number | undefined;
+    /** ¿Se captura el ratón para que la rueda mueva el transcript? `--sin-raton` lo apaga. Por omisión, sí. */
+    raton?: boolean;
+    /** `main` lo activa solo al entrar realmente por la TUI; los montajes de test no preguntan. */
+    asistenteInicial?: boolean;
+}
+export declare function correrConsolaTui(opciones: OpcionesDeMontaje): Promise<number>;

package/dist/cli/tui/entrada.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from "react";
+export declare function Entrada({ alEnviar, completa, ocupado, pendientes, historial, modelo, ancho, }: {
+    alEnviar: (linea: string) => void;
+    /** El completer puro de `consola.ts`: `(linea) => [candidatos, linea]`. */
+    completa: (linea: string) => [string[], string];
+    ocupado: boolean;
+    /** Solicitudes que esperan detrás del turno actual. */
+    pendientes?: readonly string[];
+    historial: readonly string[];
+    /** El modelo de trabajo vigente: la última fila de la tarjeta, en mudo (la maqueta). */
+    modelo: string;
+    /** Columnas DESPUÉS de la barra: lo que cada fila rellena de fondo. La conoce `App`. */
+    ancho: number;
+}): ReactNode;

package/dist/cli/tui/filas.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Partir un texto en filas de una anchura dada, por caracteres.
+ *
+ * La Entrada pinta su fondo fila a fila (Ink 5.2.1 solo da fondo a `Text`, no a `Box`),
+ * así que necesita saber DÓNDE se parte el texto en vez de dejar que Ink lo envuelva.
+ * Se cuenta por puntos de código (`Array.from`), no por bytes ni por unidades UTF-16: una
+ * «ñ» o un emoji es UN carácter. Un emoji ancho ocupa dos celdas en el terminal y aquí
+ * cuenta una; el relleno de esa fila queda una celda corto y nada más — para una línea
+ * de prompt es un desajuste asumible frente a traer `string-width`.
+ *
+ * TypeScript puro, sin ink: se prueba como función.
+ */
+export declare function filasDe(texto: string, ancho: number): string[];

package/dist/cli/tui/logo.d.ts

@@ -0,0 +1,20 @@
+/**
+ * El logotipo XONE en letras de bloque, para la cabecera de la sidebar.
+ *
+ * Un array de cadenas y no figlet: el logotipo es UN dibujo fijo, y una dependencia
+ * más para cinco filas no lo acorta (mismo criterio por el que la Entrada no usa
+ * `ink-text-input`). Cada letra mide 5 columnas, con 2 de separación: 26 en total,
+ * que caben en las 38 de contenido de la sidebar (42 menos 2 de padding por lado). Solo
+ * `█` y espacio: ningún carácter que un terminal pueda medir como doble ancho y
+ * descuadrar el bloque. No tiene umbral propio: se pinta siempre que hay sidebar, y la
+ * sidebar solo se monta cuando cabe (`cabeSidebar`, en sidebar.tsx).
+ */
+export declare const LOGO_XONE: readonly string[];
+/** Trazos alternativos para la marca; la fuente real la elige el terminal del usuario. */
+export declare const LOGOS_XONE: {
+    readonly xone: readonly string[];
+    readonly clear: readonly ["X   X   OOO   N   N  EEEEE", " X X   O   O  NN  N  E    ", "  X    O   O  N N N  EEEE ", " X X   O   O  N  NN  E    ", "X   X   OOO   N   N  EEEEE"];
+    readonly midnight: readonly ["█   █  █████  █   █  █████", " █ █   █   █  ██  █  █    ", "  █    █   █  █ █ █  ████ ", " █ █   █   █  █  ██  █    ", "█   █  █████  █   █  █████"];
+    readonly graphite: readonly ["X   X  OOOOO  N   N  EEEEE", " X X   O   O  NN  N  E    ", "  X    O   O  N N N  EEEE ", " X X   O   O  N  NN  E    ", "X   X  OOOOO  N   N  EEEEE"];
+    readonly ember: readonly ["╲ ╱   ╭─╮  ╱╲╱╲  ════", " ╳   │ │  │╲  │  ══  ", "╱ ╲   ╰─╯  │ ╲ │  ════"];
+};

package/dist/cli/tui/pielTui.d.ts

@@ -0,0 +1,15 @@
+/**
+ * La piel TUI: implementa la interfaz `Piel` de `core/turno.ts` delegando en el store.
+ * Es deliberadamente fina — la semántica ya vive en el store — y existe para que el
+ * motor no sepa que hay una TUI.
+ *
+ * `modeloActual` es la única cosa que la piel sabe y el motor no: `Piel.fin` solo trae
+ * la duración, y la etiqueta «■ modelo · Ns» del transcript necesita el modelo que corrió
+ * el turno. Se lee en el momento del `fin`, y quien monta la TUI (`correrTui.ts`) pasa
+ * el cierre que conoce el modelo de trabajo vigente.
+ */
+import type { Piel } from "../../core/turno.js";
+import type { crearStore } from "./store.js";
+type Store = ReturnType<typeof crearStore>;
+export declare function crearPielTui(store: Store, modeloActual?: () => string): Piel;
+export {};

package/dist/cli/tui/raton.d.ts

@@ -0,0 +1,68 @@
+/**
+ * El ratón y los modos de terminal de la TUI. TypeScript puro: sin ink.
+ *
+ * La rueda del ratón la recibe el TERMINAL, no la aplicación, y mueve el scrollback
+ * entero — «todo scrollea», medido con el usuario. Para que mueva el panel central hay que
+ * pedirle al terminal los eventos de ratón (seguimiento SGR) y, como Ink lee stdin y
+ * trataría esas secuencias como teclas (acabarían como texto en la Entrada), el filtro
+ * va DELANTE de Ink: `crearStdinSinRaton` envuelve el stdin real con la superficie que
+ * Ink usa, quita el ratón y entrega las muescas de rueda por un emisor.
+ *
+ * La pantalla alternativa (la de vim o htop) va en el mismo sitio porque persigue lo
+ * mismo: mientras xonecode corre no hay scrollback que mover, y al salir el terminal
+ * recupera lo que tenía. Los modos SOLO se escriben con stdout TTY: sin él, ni un escape.
+ */
+import { EventEmitter } from "node:events";
+/** Las secuencias de modo, tal cual se escriben en stdout. */
+export declare const MODOS: {
+    readonly entrarPantallaAlternativa: "\u001B[?1049h\u001B[H";
+    readonly salirPantallaAlternativa: "\u001B[?1049l";
+    readonly activarRaton: "\u001B[?1000h\u001B[?1006h";
+    readonly desactivarRaton: "\u001B[?1006l\u001B[?1000l";
+};
+/**
+ * Separa un chunk de stdin en teclas (lo que Ink debe ver), muescas de rueda (+1 arriba,
+ * -1 abajo, sumadas) y el prefijo incompleto que hay que pegar al chunk siguiente.
+ * Pura y total: lo que no es ratón pasa tal cual, incluidos un ESC solo y las flechas.
+ */
+export declare function separarRaton(entrada: string): {
+    teclas: string;
+    rueda: number;
+    resto: string;
+};
+/** Un emisor mínimo de muescas: quien monta lo crea, el filtro emite, el Transcript se suscribe. */
+export declare function crearEmisorDeRueda(): {
+    emitir(delta: number): void;
+    suscribir(f: (delta: number) => void): () => void;
+};
+export type EmisorDeRueda = ReturnType<typeof crearEmisorDeRueda>;
+/** La superficie de stdin que Ink 5 usa (ink.js y components/App.js), y nada más. */
+export interface StdinParaInk extends EventEmitter {
+    isTTY?: boolean;
+    read(): string | null;
+    setRawMode(modo: boolean): void;
+    setEncoding(codificacion: string): void;
+    resume(): void;
+    pause(): void;
+    ref(): void;
+    unref(): void;
+}
+/**
+ * El stdin que se le da a Ink: el real, con el ratón quitado. Lee del real en cada
+ * `readable`, guarda las teclas en una cola y emite su propio `readable` SOLO si hay
+ * teclas (un chunk que era solo ratón no despierta a Ink). Todo lo demás se delega.
+ */
+export declare function crearStdinSinRaton(real: StdinParaInk, alRueda: (delta: number) => void): StdinParaInk;
+/**
+ * Entra en los modos (pantalla alternativa y, si se pide, ratón) y devuelve la salida,
+ * idempotente. Sin `isTTY` no escribe nada: los tests con stdout falso y las tuberías
+ * siguen byte-idénticos. La salida deshace en orden inverso, y quien la llama debe
+ * hacerlo DESPUÉS de desmontar Ink, para que el último frame no caiga fuera de la pantalla
+ * alternativa.
+ */
+export declare function entrarEnModos(stdout: {
+    isTTY?: boolean;
+    write: (texto: string) => boolean;
+}, opciones: {
+    raton: boolean;
+}): () => void;

package/dist/cli/tui/sidebar.d.ts

@@ -0,0 +1,63 @@
+import type { ReactNode } from "react";
+import type { Papel } from "../../core/ports.js";
+export interface DatosDeSidebar {
+    contexto: number;
+    /** Tokens de entrada acumulados durante la sesión. */
+    tokenIn?: number;
+    /** Tokens de salida acumulados durante la sesión. */
+    tokenOut?: number;
+    tope?: number;
+    modelo: string;
+    modelosPorPapel: Partial<Record<Papel, string>>;
+    proyecto: string;
+    /** La raíz del proyecto (con el `$HOME` ya abreviado a `~`) para el pie; `proyecto` es su basename. */
+    ruta: string;
+    rama?: string;
+    version: string;
+    /** Alto disponible para extender el fondo diferenciado hasta el pie. */
+    altura?: number;
+}
+/**
+ * El porcentaje de contexto, o `undefined` si no hay tope que dividir. La regla de
+ * `core/contextos.ts` («porcentaje SOLO con tope») en UNA función: la sidebar y el pie
+ * la enseñan en dos sitios, y dos copias de la misma cuenta se separan tarde o temprano.
+ * Un tope 0 es un tope que no se sabe: dividir daría `Infinity`, no un dato. Un
+ * porcentaje definido implica, pues, un tope definido: por eso los llamadores pueden
+ * afirmarlo al formatear el denominador.
+ */
+export declare function porcentaje(contexto: number, tope: number | undefined): number | undefined;
+/**
+ * La regla de anchura, copiada de OpenCode (`packages/tui/src/routes/session/index.tsx`):
+ * la sidebar NO se redimensiona — mide fijo y aparece solo con MÁS de 120 columnas de
+ * terminal (estricto, como allí). Por debajo, el transcript se queda con todo el ancho y
+ * el pie enseña `ruta:rama`. Quien decide es `App`, que es quien conoce `stdout.columns`.
+ */
+export declare const ANCHO_DE_SIDEBAR = 42;
+export declare const ANCHO_MINIMO_PARA_SIDEBAR = 120;
+export declare function cabeSidebar(columnas: number): boolean;
+export declare function Sidebar(d: DatosDeSidebar): ReactNode;
+/**
+ * El pie a dos extremos: la ruta a la izquierda; a la derecha las cifras de contexto y
+ * el recordatorio de `/ayuda`. Pura, para probar la composición sin montar Ink (mismo
+ * patrón que `ventanaDe` en transcript.tsx). `cifras` vive aparte de `derecha` porque
+ * se pinta en mudo y `/ayuda` en texto; `derecha` es la línea completa, para los tests.
+ * Porcentaje SOLO con tope, y sin medición (`contexto === 0`) ninguna cifra: las dos
+ * reglas de `core/contextos.ts` y de la sidebar. `rama` llega solo cuando NO hay
+ * sidebar que la enseñe (terminal estrecho): entonces la izquierda es `ruta:rama`.
+ */
+export declare function pie(d: {
+    ruta: string;
+    rama?: string;
+    contexto: number;
+    tope?: number;
+}): {
+    izquierda: string;
+    cifras: string;
+    derecha: string;
+};
+export declare function BarraDeEstado(d: {
+    ruta: string;
+    rama?: string;
+    contexto: number;
+    tope?: number;
+}): ReactNode;

package/dist/cli/tui/store.d.ts

@@ -0,0 +1,102 @@
+/**
+ * El estado de presentación de la TUI, SIN React.
+ *
+ * Los componentes solo pintan; la semántica (qué cierra una fase, cuándo una línea
+ * confirmada es definitiva) vive aquí y se prueba sin montar nada. Es el mismo pacto
+ * que la piel stdio —tokens a colchón, cascada de fases— pero el destino es el estado,
+ * no stdout: en TUI el repintado es total y no hay append-only que respetar.
+ */
+import type { PropsDelModal } from "./aprobarTui.js";
+import type { SelectorDeConsola } from "../consola.js";
+import type { Acto } from "../../core/actos.js";
+import { conLineaDeTool } from "../../core/actos.js";
+export type { Acto };
+export { conLineaDeTool };
+export interface EstadoDeTui {
+    actos: Acto[];
+    /** El streaming en curso: la frase a medio confirmar. */
+    colchon: string;
+    faseActiva?: {
+        texto: string;
+        t0: number;
+    };
+    aprobacionPendiente: boolean;
+}
+/** Los actos que son solo texto: los que admite `linea`. `fase` y `fin` llevan `ms` y el store los construye solo. */
+type ActoDeTexto = Extract<Acto, {
+    texto: string;
+}>;
+/** Lo que `linea` acepta: los de texto y «tool», que no es un acto sino una línea del grupo `herramientas`. */
+type TipoDeLinea = ActoDeTexto["tipo"] | "tool";
+export interface OpcionesDelStore {
+    /** Costura de test del reloj: la duración de una fase no puede dormir el test. */
+    ahora?: () => number;
+}
+export declare function crearStore(opciones?: OpcionesDelStore): {
+    estado: () => EstadoDeTui;
+    /** Devuelve la función de desuscripción: el cleanup del useEffect es su llamador natural. */
+    suscribir(suscriptor: () => void): () => void;
+    token(texto: string): void;
+    cerrarLinea(): void;
+    /**
+     * Línea de sistema/tool/aviso: acto inmediato, texto ya finalizado. Una de tool se
+     * une al grupo `herramientas` que esté al final (o abre uno); las demás son actos.
+     */
+    linea(texto: string, tipo?: TipoDeLinea): void;
+    /** Lo que el humano escribió: acto inmediato, llega entero de una vez. */
+    usuario(texto: string): void;
+    /** Un fallo del motor: acto inmediato, con su propio tipo para que se pinte en rojo. */
+    error(texto: string): void;
+    fase(texto: string): void;
+    pausa(): void;
+    /**
+     * El rearme: `pausa` solo sube a true, y el modal que la cerró es quien sabe que
+     * ya no hay nada pendiente — si no baja, la TUI se queda «en pausa» para siempre
+     * tras la primera aprobación.
+     */
+    rearmar(): void;
+    /**
+     * El cierre del turno. `modelo` es el que lo corrió, capturado por quien llama EN
+     * este momento (no en el render): un /modelo posterior no debe reetiquetar turnos
+     * ya cerrados. Sin modelo no se escribe la clave, para que los actos viejos y los
+     * tests que los comparan con `toEqual` no cambien.
+     */
+    fin(ms: number, modelo?: string): void;
+};
+/**
+ * Lo que la TUI muestra además del transcript y que TAMBIÉN cambia mientras corre:
+ * si hay un turno en curso, una pregunta de consola viva (crear proyecto, la clave
+ * de /provider) o un modal de aprobación montado. Vive en su propia ranura y no en
+ * `EstadoDeTui` porque es estado de MONTAJE (quién tiene el teclado), no contenido
+ * del transcript.
+ */
+export type VistaDeTui = {
+    /** Hay un turno corriendo: Ctrl-C lo cancela, pero la Entrada sigue disponible para encolar. */
+    ocupado: boolean;
+    /** Peticiones confirmadas que esperan a que acabe el turno activo. */
+    enCola: string[];
+    /**
+     * La pregunta de `consola.preguntar`/`leerSecreto` sin resolver. Mientras vive,
+     * la app la pinta EN LUGAR de la Entrada (un solo teclado a la vez). `oculto`
+     * pinta asteriscos: es la clave de `/provider`.
+     */
+    pregunta: {
+        texto: string;
+        oculto: boolean;
+        responder: (respuesta: string) => void;
+    } | null;
+    /** Selector navegable de una piel rica; sustituye temporalmente a la Entrada. */
+    selector: (SelectorDeConsola & {
+        responder: (id: string | undefined) => void;
+    }) | null;
+    /** El modal de aprobación montado, con las props que `pedirDecisionesTui` dejó. */
+    modal: PropsDelModal | null;
+};
+/** Un trocito observable de la vista: lo que `App` consume con `useSincronizado`. */
+export interface Ranura<T extends object> {
+    ver(): T;
+    mutar(cambio: Partial<T>): void;
+    suscribir(f: () => void): () => void;
+}
+export declare function crearRanura<T extends object>(inicial: T): Ranura<T>;
+export declare function vistaInicial(): VistaDeTui;

package/dist/cli/tui/tarjeta.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+export declare function Fila({ ancho, visible, color, fondo, children, }: {
+    ancho: number;
+    visible: number;
+    color?: string;
+    fondo?: string;
+    children?: ReactNode;
+}): ReactNode;