xonecode 0.38.41 → 0.39.2

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

@@ -0,0 +1,67 @@
+/**
+ * El vocabulario de color de la TUI: las MISMAS claves semánticas que `cli/tema.ts`
+ * (`exito`, `grave`, `mudo`…), traducidas a la paleta de la TUI. La piel stdio pide
+ * ANSI a tema.ts y la TUI pide hex a aquí — un solo significado, dos renderizadores.
+ * Paleta dark-first con los azules de XOne (medidos en el CSS de xone.es: navy #00396f,
+ * azul #47abd6, cian #2ac4ea).
+ *
+ * Los tokens de CONTROL de tema.ts (`reset`, `borrar`, `limpiarLinea`, `arriba`)
+ * se reflejan como no-ops: Ink compone spans y gestiona el cursor, así que aquí no
+ * hay nada que emitir — pero la clave existe, para que el test de espejo que recorre
+ * `Object.keys(crearTema(true))` pruebe que ningún token nuevo de tema.ts se olvida.
+ */
+import type { IdTema } from "../tema.js";
+export type TemaInk = {
+    texto: string;
+    mudo: string;
+    negrita: string;
+    exito: string;
+    aviso: string;
+    grave: string;
+    anadido: string;
+    quitado: string;
+    /** El `▏` del cursor. El cian de xone.es (#2ac4ea), del mismo tono frío que `acento`. */
+    prompt: string;
+    /** No-op: Ink abre y cierra sus spans solos; un reset ANSI dentro de un span lo rompería. */
+    reset: string;
+    /** No-ops de control: el render de Ink repinta; ni borra líneas ni mueve el cursor. */
+    borrar: string;
+    limpiarLinea: string;
+    arriba: () => string;
+    /** El azul claro de xone.es: cabeceras de sidebar, viñetas, el ■ del fin, el logotipo. */
+    acento: string;
+    /** Reservado: token de maqueta SIN consumidor hoy — el test de espejo lo lista. */
+    borde: string;
+    /**
+     * El fondo de la tarjeta de la Entrada, pintado fila a fila en cada `Text` (Ink 5.2.1
+     * no da fondo a `Box`). El gris de OpenCode (`backgroundElement`, darkStep3) sobre su
+     * terminal `#0a0a0a`: un escalón visible, no un matiz.
+     */
+    fondoInput: string;
+    /** Fondo casi negro para una petición pendiente: se aparta de la conversación activa. */
+    fondoCola: string;
+    /**
+     * Superficie de la sidebar: un azul pizarra separado del transcript para que el
+     * contexto se lea como panel, no como una continuación de la conversación.
+     */
+    fondoSidebar: string;
+    /**
+     * El navy dominante de xone.es. SOLO para barras y bordes: como color de texto sobre
+     * un terminal oscuro es casi invisible, y un color de marca que no se lee no es marca.
+     */
+    marca: string;
+    /**
+     * El único tono cálido de la paleta: la línea «+ fase: Ns» se distingue del texto mudo
+     * sin competir con el acento azul. No es color XOne; es un token de TUI declarado.
+     */
+    fase: string;
+    /**
+     * Un gris por debajo de `mudo`: las líneas de herramientas son paisaje y tienen que
+     * leerse como tal, más apagadas que los avisos y que el detalle de una fase.
+     */
+    tenue: string;
+};
+/** Identidad estable: los componentes importan este objeto y React se repinta al cambiar la ranura de vista. */
+export declare const temaInk: TemaInk;
+export declare function aplicarTemaInk(id: IdTema): void;
+export declare function temaInkActivo(): IdTema;

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

@@ -0,0 +1,32 @@
+import type { ReactNode } from "react";
+import { crearStore, type Acto } from "./store.js";
+import { type EstiloDeSegmento } from "../markdown.js";
+import type { EmisorDeRueda } from "./raton.js";
+type Store = ReturnType<typeof crearStore>;
+/** Cuántos actos mueve una muesca de la rueda del ratón: menos que una página, más que uno. */
+export declare const PASO_DE_RUEDA = 3;
+/** Cuántas líneas de un grupo de herramientas se enseñan: las últimas. Medido con el usuario: 4. */
+export declare const LINEAS_DE_HERRAMIENTAS = 4;
+/**
+ * Los actos visibles: los ÚLTIMOS `altura`, subidos `desfase` hacia arriba.
+ *
+ * Pura y total: un desfase mayor que el contenido da una ventana VACÍA antes que
+ * repetir o inventar actos; el acotado lo hace `moverDesfase`.
+ */
+export declare function ventanaDe<T extends Acto>(actos: readonly T[], altura: number, desfase: number): T[];
+/** El desfase tras moverse `delta` actos, acotado sin vaciar nunca el transcript. */
+export declare function moverDesfase(desfase: number, total: number, delta: number): number;
+/** El color de un segmento inline. Pura: los tests no ven color, y esta decisión sí se prueba. */
+export declare function colorDeSegmento(estilo: EstiloDeSegmento): string | undefined;
+export declare function Transcript({ store, altura, rueda, ancho, }: {
+    store: Store;
+    altura: number;
+    /** Las muescas de la rueda del ratón (+ arriba, − abajo), ya filtradas de stdin por `raton.ts`. */
+    rueda?: EmisorDeRueda;
+    /**
+     * Columnas que rellena de fondo la tarjeta de usuario — el MISMO ancho que la Entrada,
+     * que es quien lo mide (`App`). Con omisión (tests que no hablan de tarjetas), 80.
+     */
+    ancho?: number;
+}): ReactNode;
+export {};

package/dist/cli/verify.d.ts

@@ -0,0 +1,9 @@
+import { SimuladorVerifier } from "../agent/turno/verificador.js";
+import { type Escribir } from "./stdio.js";
+/**
+ * Corre el verificador REAL sobre un proyecto y cuenta lo que encuentra.
+ *
+ * Sale con 1 si hay errores. Los avisos no tumban el comando: son de otra severidad y
+ * colapsarlos con los errores es una decisión de producto que nadie ha tomado.
+ */
+export declare function cmdVerify(ruta: string, escribir?: Escribir, verificador?: SimuladorVerifier): Promise<number>;

package/dist/cli/wizardInicial.d.ts

@@ -0,0 +1,59 @@
+import { type Proveedor, type Eleccion } from "../core/modelos.js";
+import type { Consola } from "./consola.js";
+export interface ContextoDelAsistente {
+    /**
+     * El `origen` con el que resolvió el papel `trabajo` (`Eleccion["origen"]` de
+     * `core/modelos.ts`, no una cadena suelta): así un origen mal escrito en el sitio que
+     * llama a `asistenteDeModelo` es un error de compilación y no un asistente que nunca
+     * se ofrece — el bug mudo que este repo evita en todas partes.
+     */
+    origenDeTrabajo: Eleccion["origen"];
+    /** Proveedores que ya tienen credencial guardada. */
+    hayCredencial?: (proveedor: Proveedor) => boolean;
+    /**
+     * Devuelve la ruta donde quedó, igual que `agent/config/authEnDisco.ts#guardarCredencial`:
+     * si cancelar más adelante (en el paso de MODELO) deja la clave ya escrita, el aviso
+     * de cancelación tiene que poder decir, justo antes, QUÉ se guardó y DÓNDE — como ya
+     * hace `/provider` (`consola.ts`, «credencial de … guardada en …») — para que ese
+     * «cancelado» no dé a entender, en silencio, que no pasó nada.
+     */
+    guardarCredencial?: (proveedor: Proveedor, clave: string) => {
+        ruta: string;
+    };
+    /**
+     * Pone la clave en el proceso SIN escribirla en disco
+     * (`agent/config/configEnDisco.ts#aplicarCredencialAlProceso`).
+     *
+     * Es lo que permite PROBARLA antes de guardarla: el catálogo la lee de `process.env`, así
+     * que sin esta costura el único orden posible era escribir y después preguntar — y una
+     * clave mal tecleada quedaba en `auth.json` para siempre, con el asistente confesando
+     * dónde la había dejado. Ausente = no se puede probar antes, y entonces se conserva el
+     * orden viejo (escribir y luego listar), que es peor pero no miente: lo dice.
+     */
+    aplicarCredencial?: (proveedor: Proveedor, clave: string) => void;
+    /**
+     * `true` = cancelar no sale: se vuelve a preguntar mientras haya alguien conectado. Lo
+     * pide la consola web, donde este paso es una puerta y no una comodidad. Omitido
+     * (terminal) se conserva el trato de siempre: cancelar cancela.
+     */
+    exigirEleccion?: boolean;
+    /** Un motivo para el PRIMER selector, de quien ya sabe por qué se está preguntando otra
+     *  vez (una reconexión a mitad del alta, por ejemplo). */
+    aviso?: string;
+}
+/**
+ * Qué pasó, para que quien llama no tenga que adivinarlo mirando el disco.
+ *
+ * `sin-preguntar` no es un fallo: es que no había nada que preguntar (ya hay elección, o
+ * la piel no tiene selector). Quien usa esto como puerta —`web/servidor/arranque.ts`—
+ * necesita distinguirlo de `cancelado`, o dejaría fuera para siempre a quien no puede
+ * contestar.
+ */
+export type ResultadoDelAsistente = "elegido" | "cancelado" | "sin-preguntar";
+/**
+ * La opción «volver» de la lista de modelos. El id lleva una flecha a propósito: tiene que
+ * ser imposible de confundir con el id de un modelo del catálogo, que es lo único que
+ * comparte lista con ella. Va la ÚLTIMA de la lista, detrás de los modelos de verdad.
+ */
+export declare const ID_VOLVER = "\u2190proveedor";
+export declare function asistenteDeModelo(consola: Consola, contexto: ContextoDelAsistente): Promise<ResultadoDelAsistente>;

package/dist/core/actos.d.ts

@@ -0,0 +1,437 @@
+/**
+ * Un acto del transcript: lo que ya no cambia y se pinta por su tipo.
+ *
+ * Vivía en `cli/tui/store.ts` porque solo lo usaba la TUI. Ahora lo usan DOS pieles —la
+ * TUI y la web—, y el servidor web no puede importar de `cli/tui/` sin romper la frontera
+ * de Ink. Así que baja a `core/`, que es donde vive lo que comparten las pieles.
+ *
+ * Ningún acto lleva argumentos de tool: `herramientas.lineas` son líneas YA resumidas por
+ * `agent/turno/resumenDeTool.ts`, con la lista blanca de campos por nombre de tool. Lo que se
+ * añadió después (`detalles`) tampoco los lleva: es el NOMBRE de la tool, su error y su blanco
+ * (la ruta o el patrón de esa misma lista blanca, que ya iba dentro de la línea), que el evento
+ * ya traía y el acto tiraba al componer la línea.
+ */
+import type { AccionDeSincronizacion } from "./cloudstudio.js";
+import type { HallazgoDelTurno, OrigenDeLaTool } from "./events.js";
+import type { TareaPropuesta } from "./repartoDeEncargo.js";
+/**
+ * Lo que se sabe de la línea i-ésima de un acto de herramientas.
+ *
+ * Existe porque el evento `tool` lleva `{nombre, detalle, error}` y hasta ahora llegaba al
+ * cliente como UNA cadena ya compuesta: la piel podía pintarla, pero no distinguir una
+ * lectura de una escritura ni una llamada que falló de una que fue bien. No expone nada
+ * nuevo: el nombre de la tool y su blanco (la ruta o el patrón de la lista blanca) ya iban
+ * dentro del texto, y aquí van como dato.
+ *
+ * `nombre` es OPCIONAL y su ausencia significa algo: por `Piel.linea` no llegan solo tools.
+ * También pasan por ahí las líneas de plan, de tarea y de verificación (`core/turno.ts` las
+ * escribe con el mismo `escribirLinea`), y esas no son una llamada a nada. Marcarlas como
+ * tool sería la misma mentira que un contador inventado; sin nombre, quien pinte sabe que
+ * es un paso del motor y no una herramienta.
+ */
+export interface DetalleDeLinea {
+    /** La tool que produjo la línea. Ausente = la línea no vino de una tool. */
+    nombre?: string;
+    /** El motivo, si la llamada falló. Un error nunca se colapsa con la racha. */
+    error?: string;
+    /**
+     * Quién la pidió: el orquestador o un especialista, y cuál si se sabe
+     * (`core/events.ts#OrigenDeLaTool`). Ausente = no consta, que es el caso de una sesión
+     * guardada antes de que existiera y de una línea que no es de ninguna tool.
+     */
+    origen?: OrigenDeLaTool;
+    /**
+     * La ruta o el patrón de UNA llamada (`core/notify.ts#LineaDeTool.blanco`): el `detalle` de la
+     * lista blanca de `resumenDeTool.ts`, que YA iba dentro del texto de la línea. Viaja aparte para
+     * que la web pinte el verbo a su manera («Leyó /login.js») sin re-parsear la frase. No es una
+     * ruta nueva por el cable: es la misma, como dato. Ausente = no consta o la tool no tiene.
+     */
+    blanco?: string;
+    /** En la línea que CIERRA una racha: cuántas llamadas cuenta (≥ 2). */
+    veces?: number;
+    /** En el cierre: los tres primeros blancos distintos de la racha. */
+    blancos?: string[];
+    /** En el cierre: cuántos blancos distintos más hubo. */
+    masBlancos?: number;
+}
+/**
+ * La memoria del proyecto en un turno: que alguien PIDIÓ leerla, y quién si consta
+ * (`Piel.memoriaPedida?`). Presente = se pidió al menos una vez; `por` son los orígenes que
+ * constan, en orden y sin repetir, y puede ir VACÍO si ninguna petición traía origen. Ausente
+ * es «no se pidió» o «la sesión es anterior». Nunca lleva contenido de la memoria.
+ */
+export interface MemoriaDelTurno {
+    por: OrigenDeLaTool[];
+}
+/**
+ * El veredicto del verificador sobre lo que el turno escribió, como DATO (`Piel.verificacion?`).
+ * Es el evento `verificacion` sin su `tipo`: fichero RELATIVO, línea, código y mensaje del
+ * simulador — nunca contenido de un fichero. Los `preexistentes` son solo una cifra porque el
+ * evento no los lista: atribuirlos al turno sería falso, y listarlos no se puede.
+ */
+export interface VeredictoDelTurno {
+    verde: boolean;
+    errores: number;
+    avisos: number;
+    hallazgos?: HallazgoDelTurno[];
+    preexistentes?: number;
+}
+export type Acto = 
+/** `adjuntos` (IXCODE-7): los NOMBRES que la persona anexó con este mensaje, si hubo alguno
+ *  aceptable. Ausente ≠ vacío: un mensaje sin adjuntos no lleva el campo. */
+/**
+ * `cuando` (IXCODE-24): la hora ISO en que la persona lo MANDÓ, en `usuario`, y en que la respuesta
+ * EMPEZÓ a llegar, en `asistente` —la de empezar y no la de acabar, como `sincronizacion`: una
+ * respuesta larga no se fecha por su último token—. Se estampa al crear el acto y viaja con él al
+ * disco, así que una sesión reabierta enseña la hora real y no la de reabrirla. Ausente en las
+ * sesiones de antes: «no consta», y entonces no se pinta.
+ */
+{
+    tipo: "usuario";
+    texto: string;
+    adjuntos?: string[];
+    cuando?: string;
+} | {
+    tipo: "asistente";
+    texto: string;
+    cuando?: string;
+}
+/**
+ * El razonamiento del modelo, si lo publica. Es un acto APARTE de `asistente` porque no
+ * es la respuesta: se pinta distinto (apagado, plegable) y quien lea el transcript tiene
+ * que poder distinguir lo que el modelo pensó de lo que dijo.
+ */
+ | {
+    tipo: "razonamiento";
+    texto: string;
+    origen?: OrigenDeLaTool;
+}
+/**
+ * Las líneas de tool CONSECUTIVAS de un turno, en un solo acto: son paisaje, y el
+ * transcript enseña solo las últimas. Una línea del asistente (o de sistema) cierra el
+ * grupo; la siguiente tool abre otro.
+ */
+/**
+ * `detalles` corre EN PARALELO a `lineas`, misma longitud y mismo orden. Es opcional
+ * porque las sesiones guardadas antes de que existiera no lo traen: ausente significa
+ * «esta sesión es anterior», no «ninguna línea vino de una tool», y quien pinte tiene que
+ * poder distinguirlo — por eso no se rellena con un array de vacíos al leer del disco.
+ */
+ | {
+    tipo: "herramientas";
+    lineas: string[];
+    detalles?: DetalleDeLinea[];
+}
+/**
+ * Una línea del harness, no de la conversación: la respuesta a un comando, un aviso de
+ * honestidad, lo que se autorizó sin preguntar.
+ *
+ * **`clase` dice DE QUÉ es, y viaja con el acto en vez de deducirse del texto.** Es la
+ * misma regla que la FORMA de una pregunta (`DecisionDeConsola`): mirar el enunciado para
+ * decidir cómo se pinta es leer la sintaxis que la propia piel acaba de escribir, y aquí
+ * se rompería en las dos direcciones — un «hecho: …» que empieza igual que un aviso, y un
+ * aviso que mañana cambie de redacción.
+ *
+ * Solo dos clases, y las dos son lo que el HARNESS dice SOBRE el turno: `aviso` (la
+ * bitácora de honestidad, el juez, el crítico de pantalla) y `permiso` (una escritura que
+ * se aplicó sin preguntar porque la sesión está en autónomo). Esas se agrupan y se pliegan.
+ *
+ * **Ausente es lo de siempre, y eso es la decisión**: una respuesta a un comando —«hecho:
+ * cada escritura vuelve a pedir aprobación»— es el acuse de un botón que la persona acaba
+ * de pulsar, y plegarlo sería no contestarle. Sigue suelta y a la vista, como las sesiones
+ * guardadas antes de que este campo existiera.
+ */
+ | {
+    tipo: "sistema";
+    texto: string;
+    clase?: "aviso" | "permiso" | "resumen";
+}
+/**
+ * Un artefacto que el agente dejó escrito: un diagrama, un panel, una captura
+ * (`core/artefactos.ts`). Es un acto propio y no una línea de `herramientas` porque es lo
+ * único del turno que se escribió SIN pasar por la aprobación humana —no es del proyecto—
+ * y eso hay que poder decirlo, y porque desde él se abre el fichero.
+ *
+ * Lleva metadatos y NUNCA el contenido: por aquí pasa lo que se guarda en el `.jsonl` y
+ * viaja por el cable, y un panel de `artifacts-builder` son cientos de kilobytes.
+ */
+ | {
+    tipo: "artefacto";
+    ruta: string;
+    nombre: string;
+    bytes: number;
+    mime?: string;
+}
+/**
+ * Una PREGUNTA del agente con opciones (`events.ts#consulta`). Se guarda en el `.jsonl`
+ * como cualquier acto, y eso es lo que hace que la tarjeta VUELVA al reabrir una sesión
+ * que se quedó esperando respuesta: sigue pendiente mientras no haya un acto de usuario
+ * detrás. El texto de la pregunta no se repite aquí como mensaje: ya está en el del
+ * asistente.
+ */
+ | {
+    tipo: "consulta";
+    pregunta: string;
+    opciones: string[];
+}
+/**
+ * Una pregunta que el harness contestó solo en modo autónomo (`events.ts#consulta-autonoma`): la misma tarjeta que una
+ * `consulta` contestada, a la vista en el hilo y no plegada entre los avisos, con lo que se eligió marcado. Nunca está
+ * pendiente: no espera a nadie.
+ */
+ | {
+    tipo: "consulta-autonoma";
+    pregunta: string;
+    opciones: string[];
+    elegida?: string;
+}
+/**
+ * El agente PROPONE repartir el encargo en tareas de fondo encadenadas (`proponer_tareas`,
+ * `core/repartoDeEncargo.ts`). `id` lo pone la piel web: es con lo que la tarjeta se encola o se
+ * descarta, y con lo que el servidor comprueba que la propuesta existe y sigue pendiente. Las
+ * tareas van como las escribió el agente —título, petición, adjuntos por nombre—; el encargo
+ * AUMENTADO no se guarda aquí: se pide al pintar la tarjeta y lo edita la persona.
+ */
+ | {
+    tipo: "propuesta-de-tareas";
+    id: string;
+    motivo: string;
+    tareas: TareaPropuesta[];
+}
+/**
+ * Cómo acabó una propuesta: `encoladas` son los ids de las tareas creadas, en orden; ausente es
+ * que se DESCARTÓ, y `enChat` que se descartó para hacerlo en la propia conversación. Es un acto aparte y no una marca en el de la propuesta porque el `.jsonl` solo
+ * crece, y la propuesta puede venir de lo releído. Con él la tarjeta no se encola dos veces.
+ */
+ | {
+    tipo: "propuesta-resuelta";
+    propuesta: string;
+    encoladas?: string[];
+    enChat?: true;
+}
+/**
+ * `fase` es el valor del enum (`core/events.ts#Fase`), que el acto tiraba al quedarse
+ * solo con su texto en español. Opcional por lo mismo que `detalles`: las sesiones
+ * viejas no lo traen. Sirve para filtrar y agrupar sin re-parsear la prosa, que es lo
+ * que habría que hacer si solo estuviera el texto — y una prosa que alguien reescriba
+ * rompería el filtro sin que nada avisara.
+ */
+ | {
+    tipo: "fase";
+    texto: string;
+    ms: number;
+    fase?: string;
+}
+/**
+ * El cierre del turno: duración, el modelo que lo corrió y lo que COSTÓ.
+ *
+ * `consumo` es el gasto de ESTE turno y va como **delta**, no como el acumulado de la
+ * sesión. Es la diferencia que hace que sobreviva a un cierre: el tracker vive en el
+ * cierre de `abrirSesionReal` y arranca de cero en cada proceso, así que un acumulado
+ * estampado aquí sería un absoluto de una escala que cada arranque reinicia — y sumar
+ * dos de esos no da nada. Los deltas, en cambio, suman lo mismo dentro de un proceso que
+ * repartidos en tres: reabrir y seguir trabajando da el mismo total que no haber cerrado.
+ *
+ * Se suman los TOKENS de las dos cuentas y nunca su coste, igual que en la pantalla
+ * (`componentes/ContadorDeTokens.tsx`): los del grafo van contra la clave de API del
+ * usuario y los del agente externo contra su suscripción del producto.
+ *
+ * `ventana` es lo que ocupaba el historial al cerrar el turno. Es un NIVEL y no un flujo
+ * —por eso no se suma—, y va aquí para que una sesión reabierta pueda decir cuánto
+ * margen quedaba antes de resumir, que es la única cifra de la que no hay otra fuente.
+ *
+ * Opcional por lo mismo que `detalles` y `fase`: las sesiones guardadas antes de que
+ * existiera no lo traen, y ausente significa «anterior» o «esta piel no lo sabe» —nunca
+ * cero—. Quien lo lea tiene que poder distinguirlo, que es lo que hace `consumoDeLosActos`.
+ */
+ | {
+    tipo: "fin";
+    ms: number;
+    modelo?: string;
+    consumo?: ConsumoDeTurno;
+    memoria?: MemoriaDelTurno;
+}
+/**
+ * Un veredicto del verificador. Es PULSO del turno —vive en el tramo de trabajo—, y el ROJO
+ * con el que un turno TERMINA sale además fuera del plegado, con un botón por hallazgo.
+ */
+ | ({
+    tipo: "verificacion";
+} & VeredictoDelTurno) | {
+    tipo: "error";
+    texto: string;
+}
+/**
+ * UNA operación de sincronización con CloudStudio —subir o bajar—, contada entera y de una
+ * pieza: las líneas que el terminal habría impreso, su hora y cuál de las tres acciones fue.
+ *
+ * **No es una conversación, y por eso no es una línea de `sistema`.** El hilo es lo que se
+ * habla con el agente; una subida es un suceso del PROYECTO, que pasó porque alguien pulsó un
+ * botón y no porque se preguntara nada. Metido en el chat eran nueve renglones de consola
+ * cruda —el plan con su sangría, el `→ APROBADO`, el recuento— entre dos mensajes, y la
+ * conversación había que buscarla alrededor; y como acto `sistema` suelto, además, cada línea
+ * era un acto MÁS que se persistía y reaparecía al reabrir. Agrupadas aquí, la pestaña
+ * Revisión las lee como lo que son: operaciones, una detrás de otra, cada una con su hora.
+ *
+ * **Las líneas van TAL CUAL las escribió la operación**, sin recomponer ni resumir: es lo
+ * mismo que se habría visto en el terminal, y recomponerlas aquí sería una segunda versión de
+ * algo que ya se cuenta en `agent/cloudstudio/subida.ts`, `agent/cloudstudio/descarga.ts` y `cli/main.ts` — dos
+ * copias de la misma frase divergen, y la que nadie vuelve a leer es la que se queda vieja.
+ *
+ * `cuando` es ISO y es la hora de EMPEZAR, no la de acabar: es el instante que se recuerda
+ * («subí aquello a las 14:32»), y así una subida larga no se fecha por su último segundo.
+ *
+ * No lleva lo que no es de la operación: ni el enunciado de la pregunta —eso es la tarjeta de
+ * `preguntar`, y el `→ APROBADO` ya dice cómo se resolvió— ni los errores de uso del comando.
+ */
+ | {
+    tipo: "sincronizacion";
+    accion: AccionDeSincronizacion;
+    cuando: string;
+    lineas: string[];
+    /**
+     * Lo que pasó con una SUBIDA que llegó a correr, como DATO: cuántos ficheros subieron y
+     * cuántos fallaron. Es lo que lee el diálogo de la subida para decir «todo subido» o no,
+     * en vez de leer «subidos N, fallaron M» del texto de una línea. Ausente = la operación
+     * no terminó con un informe (otra acción, el árbol sucio, o una excepción).
+     */
+    resultado?: ResultadoDeSubida;
+    /** Cuántos ficheros trajo una BAJADA que terminó. Ausente = no terminó, u otra acción. */
+    bajados?: number;
+    /**
+     * La operación LANZÓ, y esto es lo que se dijo: el MISMO texto que el bucle de comandos
+     * escribe en el hilo (`describirError`), así que no viaja nada nuevo por el cable. Va como
+     * dato para que el diálogo de la operación lo enseñe donde se pulsó Aceptar.
+     */
+    error?: string;
+};
+/** El recuento de una subida que corrió. Ver `resultado` en el acto `sincronizacion`. */
+export interface ResultadoDeSubida {
+    subidos: number;
+    fallidos: number;
+    /**
+     * Lo que no falló pero no se pudo CONFIRMAR (hoy: la rama activa de Studio antes de subir).
+     * Ausente = nada que avisar; nunca un array vacío.
+     */
+    avisos?: string[];
+}
+/**
+ * El acto `sincronizacion` SIN su discriminante: lo que se le entrega a la piel para que lo
+ * guarde.
+ *
+ * Existe para que el `tipo` se escriba UNA vez —donde vive el acto, que es `core/`— y quien lo
+ * construye en `cli/` no tenga que repetirlo: dos sitios escribiendo el mismo literal es el que
+ * se queda atrás el día que se renombre, y este repo ya sabe cómo acaba eso.
+ */
+export type NarracionDeSincronizacion = Omit<Extract<Acto, {
+    tipo: "sincronizacion";
+}>, "tipo">;
+/** Los tokens de UNA cuenta. La forma que ya usa `ConsumoDeSesionPorCuenta` (`core/ports.ts`). */
+export interface ConsumoDeUnaCuenta {
+    entrada: number;
+    salida: number;
+    /** Tokens leídos de caché. Va APARTE de la entrada, como en `vendor/tokenTracking.ts`:
+     *  meterlo dentro inflaría la cifra que se enseña. */
+    cache: number;
+}
+/**
+ * Lo que costó un turno: las DOS cuentas por SEPARADO, más lo que ocupaba la ventana al
+ * cerrarlo.
+ *
+ * Las dos cuentas viajan sin sumar hasta la pantalla, que es la regla que ya rige el
+ * mensaje `consumo` (`web/servidor/transporte.ts`): los del grafo van contra la clave de
+ * API del usuario y los del agente externo contra su suscripción del producto, así que
+ * sumarlos aquí perdería el desglose para siempre — una sesión reabierta ya no podría decir
+ * cuánto fue de un agente externo, porque de un total no se vuelve a las partes.
+ *
+ * `ventana` es lo que ocupaba el historial al cerrar el turno. Es un NIVEL y no un flujo
+ * —por eso no se suma—, y va aquí para que una sesión reabierta pueda decir cuánto margen
+ * quedaba antes de resumir, que es la única cifra de la que no hay otra fuente.
+ */
+export interface ConsumoDeTurno {
+    modelo: ConsumoDeUnaCuenta;
+    externo: ConsumoDeUnaCuenta;
+    /** Ocupación del historial al cerrar el turno. Ausente = no consta. */
+    ventana?: number;
+    /**
+     * Lo mismo, POR MODELO: un especialista puede correr en otro modelo que el raíz (el `modelo:` de
+     * su `.md`), y el total no dice cuál gastó qué. Cada entrada dice a qué CUENTA pertenece, porque
+     * las dos cuentan la caché distinto. Ausente = no se midió (un turno de antes de esto): al sumar
+     * cae en `SIN_DESGLOSE`, así el desglose cuadra siempre con el total sin inventar de quién fue.
+     */
+    porModelo?: ConsumoPorModelo;
+}
+/** El consumo de UN modelo, y la cuenta a la que pertenece. */
+export interface ConsumoDeUnModelo extends ConsumoDeUnaCuenta {
+    cuenta: "modelo" | "externo";
+}
+/**
+ * Por id de modelo: `deepseek/deepseek-chat` en el grafo; `claude-code:claude-sonnet-4-5` (motor y,
+ * si se sabe, modelo) en uno externo.
+ */
+export type ConsumoPorModelo = Record<string, ConsumoDeUnModelo>;
+/** La fila de lo que se gastó sin saber en qué modelo: turnos de antes de medirlo. */
+export declare const SIN_DESGLOSE = "(sin desglose)";
+/**
+ * El desglose de un consumo: el suyo si lo trae, o sus dos cuentas bajo `SIN_DESGLOSE` (sin las que
+ * van a cero). Es lo que hace que la suma de un turno viejo y uno nuevo no pierda tokens.
+ */
+export declare function desgloseDe(c: ConsumoDeTurno): ConsumoPorModelo;
+/** Suma dos desgloses, modelo a modelo. Devuelve uno NUEVO. */
+export declare function sumarPorModelo(a: ConsumoPorModelo, b: ConsumoPorModelo): ConsumoPorModelo;
+/** Lo que va de `antes` a `despues`, modelo a modelo, sin negativos y sin los que no se movieron. */
+export declare function restarPorModelo(despues: ConsumoPorModelo, antes: ConsumoPorModelo): ConsumoPorModelo;
+/** Suma dos consumos, cuenta por cuenta. La ventana gana la del SEGUNDO: es la más reciente. */
+export declare function sumarConsumo(a: ConsumoDeTurno, b: ConsumoDeTurno): ConsumoDeTurno;
+/**
+ * Lo que costó una CONVERSACIÓN, leída de sus actos.
+ *
+ * Suma los deltas de los `fin` y se queda con la última ventana que CONSTA —la más
+ * reciente que se midió, que es la mejor respuesta a «cuánto ocupa el historial ahora»
+ * cuando el último turno no la midió—. Devuelve `undefined` cuando NINGÚN `fin` lo trae,
+ * que es lo que distingue una sesión anterior a esto de una que gastó cero: pintar un cero
+ * que nadie ha medido es la cifra inventada de siempre (`ContadorDeTokens`), y aquí se
+ * puede caer en ella con una sesión vieja delante.
+ *
+ * Vive en `core/` y no en el servidor porque es una lectura de actos, no de disco: los
+ * actos que le llegan pueden venir del `.jsonl` recién releído o de cualquier otra fuente.
+ */
+export declare function consumoDeLosActos(actos: readonly Acto[]): ConsumoDeTurno | undefined;
+/**
+ * El ACUMULADO de una sesión: se suma un turno detrás de otro, y **la ventana NO viaja**.
+ *
+ * Es la diferencia con `sumarConsumo`, y es la razón de que esto exista con nombre propio en
+ * vez de ser un `sumarConsumo` más en la llamada. `consumoDeLosActos` compone los actos de UNA
+ * conversación que se está mirando AHORA, y ahí la ventana tiene sentido: «cuánto ocupa el
+ * historial» es una pregunta del momento, y la del último turno que midió es la respuesta.
+ * Un acumulado estampado en el índice es otra cosa —el gasto de una sesión ya cerrada—, y una
+ * ventana dentro sería un «ahora» congelado hace tres días que alguien leería como el de hoy.
+ * El dato no se pierde: sigue en cada `fin` del `.jsonl`, que es donde se mide.
+ *
+ * `a` ausente es el primer `fin` de la sesión: devuelve una copia del delta, no el delta —quien
+ * lo llame lo va a guardar en el índice, y los actos del lazo no son de nadie para mutarlos.
+ */
+export declare function acumularTotales(a: ConsumoDeTurno | undefined, delta: ConsumoDeTurno): ConsumoDeTurno;
+/**
+ * Añadir una línea de tool al grupo: si es el cierre de la racha cuya apertura es la
+ * última línea, la SUSTITUYE. El colapsador escribe apertura y cierre porque stdio solo
+ * añade; una piel que repinta (TUI, web) no puede permitirse dos líneas para la misma
+ * racha. Pura, y vivía en `cli/tui/store.ts` hasta que la web empezó a necesitarla
+ * también: dos copias de esta sutileza es cómo divergen.
+ */
+export declare function conLineaDeTool(lineas: readonly string[], linea: string): string[];
+/**
+ * La misma fusión, sobre las DOS listas a la vez.
+ *
+ * Los `detalles` van en paralelo a las `lineas`, así que aplicarles la regla por separado
+ * es cómo se desincronizan: la sustitución del cierre de una racha quita un elemento de
+ * una lista y no de la otra, y a partir de ahí cada línea lleva el detalle de su vecina.
+ * Una sola función que devuelva las dos lo hace imposible por construcción.
+ */
+export declare function conLlamadaDeTool(grupo: {
+    lineas: readonly string[];
+    detalles?: readonly DetalleDeLinea[];
+}, linea: string, detalle: DetalleDeLinea): {
+    lineas: string[];
+    detalles: DetalleDeLinea[];
+};