xonecode 0.38.44 → 0.39.2

package/dist/web/servidor/sesiones.d.ts

@@ -0,0 +1,342 @@
+/**
+ * Las sesiones de un proyecto, en su `.xonecode/sesiones/`.
+ *
+ * Ahí y no en global porque la sesión es del proyecto, ya hay precedente
+ * (`conversation_history/` en `agent/grafo/memoriaDeProyecto.ts`), la carpeta está denegada
+ * entera al agente (`permisosDe`) y **no sube nunca** a CloudStudio — el mismo trato que
+ * `.xonecode/` recibe en todas partes de este repo.
+ *
+ * Se guardan **actos** (`core/actos.ts`), no `DomainEvent`. La distinción no es cosmética:
+ * ningún evento lleva el texto que escribió el usuario — `tool.detalle` es la única
+ * excepción, y es una lista blanca de campo de ruta, nunca prosa —, así que un fichero de
+ * eventos daría una sesión reabierta con respuestas y sin preguntas. Y por construcción no
+ * hay filtrado que hacer para cumplir «nada de diffs ni contenido de fichero»: el tipo
+ * `Acto` no tiene ningún campo que pueda llevarlos. El único sitio del sistema donde el
+ * contenido de un fichero viaja es el mensaje de aprobación
+ * (`consolaWeb.ts#aprobacionesTui`), que no es un acto y se suelta en cuanto hay decisión
+ * — nunca llega aquí.
+ *
+ * Reabrir ya NO es releer, y este fichero dejó de ser la única memoria. El hilo del agente
+ * vive en el checkpointer de SQLite del proyecto (`agent/sesiones/checkpointer.ts`), indexado por el
+ * mismo id que titula estas entradas, así que una sesión reabierta continúa de verdad. Lo
+ * que sigue viviendo aquí es el TRANSCRIPT —lo que se pinta—, y son dos cosas distintas a
+ * propósito: un acto no puede llevar contenido de fichero ni argumentos de tool, y un
+ * checkpoint los lleva todos. Por eso el `.jsonl` puede viajar y el `.sqlite` no.
+ * `historica` deja de ser «se reabrió» y pasa a ser un hecho comprobado: se pregunta al
+ * checkpointer, y solo se marca si de ese hilo no queda memoria —una sesión de antes de que
+ * esto existiera, o una cuyo primer turno nunca corrió—. Fingir que la conversación continúa
+ * cuando el modelo no recuerda nada sería justo la clase de mentira muda que este repo evita
+ * (`bitacora.ts` es el mismo principio aplicado a los avisos de honestidad).
+ * `historica` no se escribe a disco — no es un campo de `EntradaIndice` ni del `.jsonl` —
+ * porque es un hecho del MOMENTO de reabrir, no del estado de la sesión: quien reabre
+ * decide en memoria cuándo el primer turno nuevo la desactiva, y persistir la marca
+ * obligaría a un segundo sitio a mantenerla sincronizada con ese momento.
+ *
+ * `indice.json` se reescribe entero (es pequeño, una entrada por sesión) con el mismo
+ * cuidado atómico que `agent/config/settingsEnDisco.ts#escribirAtomico` — temporal + rename (con el reintento de Windows, `agent/renombrarSobre.ts`),
+ * porque un `writeFileSync` a medias tras un crash dejaría corrompido el índice de TODAS
+ * las sesiones, no solo la que se estaba anotando. El `.jsonl` de una sesión, en cambio, se
+ * **anexa** (`appendFileSync`): reescribirlo entero en cada acto lo haría cuadrático en el
+ * número de actos de la sesión, y arriesgaría perder la sesión completa a un crash a mitad
+ * de escritura en vez de, como mucho, la última línea — que `reabrirSesion` ya tolera.
+ */
+import type { Acto, ConsumoDeTurno } from "../../core/actos.js";
+import { tituloDesde } from "../../core/textos.js";
+import type { Esfuerzo } from "../../core/esfuerzo.js";
+import type { MotorDeAgente } from "../../core/motor.js";
+import type { ModoDeEscritura } from "../../core/modoDeEscritura.js";
+/**
+ * El título automático de una sesión, a partir de su primera petición.
+ *
+ * Se movió a `core/textos.ts` cuando las TAREAS necesitaron el mismo título: `core/` no
+ * puede importar de `web/`, y una segunda copia habría divergido. Se reexporta con su
+ * nombre de siempre porque `anotarActo`, en este mismo fichero, y sus tests lo usan desde
+ * aquí.
+ */
+export { tituloDesde };
+/**
+ * El dispositivo preferido de una sesión: con cuál trabaja el agente.
+ *
+ * Se guarda la FOTO y no solo el id, y esa es la decisión que importa: los ids no son
+ * estables. `emulator-5554` es un puerto, un AVD recién arrancado se queda con el serial que
+ * haya libre, y el de un teléfono sobrevive pero el teléfono puede estar desenchufado. Con
+ * solo el id, al reabrir una sesión el selector enseñaría un serial crudo o nada; con la
+ * foto puede decir «iPhone 16 · no está ahora», que es lo que se sabe.
+ *
+ * Si está conectado AHORA no se guarda: eso se resuelve contra la última medida en el
+ * momento de emitir. Un «conectado» escrito en disco es falso en cuanto se desenchufa.
+ */
+export interface DispositivoElegido {
+    id: string;
+    nombre: string;
+    plataforma: "android" | "ios";
+    clase: "emulador" | "simulador" | "fisico";
+}
+/**
+ * El ticket de Jira al que queda ligada una sesión (IXCODE-11).
+ *
+ * `conector` es el id del conector MCP (`core/conectores.ts`) con el que se abrió, `sitio` es
+ * el subdominio de Atlassian (`<sitio>.atlassian.net`) —hace falta para componer la URL
+ * pública del ticket sin volver a preguntarle nada a Jira— y `clave` es la clave corta
+ * (`IXCODE-12`). Ni el resumen ni el asignado viajan aquí: eso se pide en caliente cuando
+ * hace falta pintarlo, y así una sesión vieja no enseña un título que quedó desactualizado.
+ */
+export interface TicketDeSesion {
+    conector: string;
+    sitio: string;
+    clave: string;
+}
+export interface EntradaIndice {
+    id: string;
+    titulo: string;
+    creada: string;
+    ultimoTurno: string;
+    /** Con cuál trabaja el agente. Ausente = ninguno elegido. */
+    dispositivo?: DispositivoElegido;
+    /**
+     * Cuánto razona el modelo en esta sesión. Ausente = ninguno fijado.
+     *
+     * Vive AQUÍ y no en el `.jsonl` por lo mismo que el dispositivo: es un dato DE la sesión,
+     * no uno de sus actos, y sin esto la elección se perdía al cerrar la pestaña — que es
+     * justo lo que hace inútil una palanca de coste, porque hay que volver a ponerla cada vez.
+     *
+     * **No hay defecto global**, y esa ausencia es la decisión: el esfuerzo se elige por
+     * SESIÓN y por SUBAGENTE (en su `.md`), que son los dos sitios donde alguien sabe lo que
+     * está pidiendo. Un tercer valor «para todas las nuevas» habría sido un ajuste que decide
+     * en nombre de conversaciones que todavía no existen.
+     */
+    esfuerzo?: Esfuerzo;
+    /**
+     * Con qué motor de agente NACIÓ esta sesión (`core/motor.ts`). Ausente = deepagents, que era el
+     * único cuando se escribió cualquier sesión sin el campo. Se guarda porque la memoria de un
+     * motor no la continúa el otro: cambiar la configuración no puede cambiarle el motor a una
+     * conversación que ya existe. No se enseña en ninguna parte, como pidió él.
+     */
+    motor?: MotorDeAgente;
+    /**
+     * El modo de escritura de esta sesión: supervisado o autónomo. Ausente = supervisado.
+     *
+     * Vive AQUÍ por lo mismo que el esfuerzo y el dispositivo: es un dato DE la sesión, no
+     * uno de sus actos, y sin esto la elección se perdía al cerrar la pestaña — que es justo
+     * lo que hace inútil una palanca, porque hay que volver a ponerla cada vez.
+     *
+     * **Ausente es supervisado y no «no consta»**, a diferencia del esfuerzo: de esto hay que
+     * decidir algo en cada escritura, así que el hueco se resuelve, y la única dirección
+     * segura para resolverlo es la que enseña el diff. Por eso perder la anotación no es un
+     * agujero: es volver a preguntar.
+     */
+    modo?: ModoDeEscritura;
+    /**
+     * El id de la TAREA de fondo que abrió esta sesión, si la abrió una.
+     *
+     * Ausente es **«no consta»** y no «es una conversación»: no la lleva ninguna sesión
+     * anterior a esta marca, ni la que se dé de alta por el camino defensivo de
+     * `anotarActo` (índice perdido a mitad). Quien lo pinte tiene que tratarlo como el lado
+     * conservador —liso—, no como una afirmación.
+     *
+     * Se guarda AQUÍ y no se deduce cruzando con la cola de tareas, que es lo que parecía
+     * gratis: la cola es opcional en las dos capas —`OpcionesDeMontaje.colaDeTareas` y el
+     * mensaje `tareas` del cable— y en un proceso que no las corre el cruce pintaría TODAS
+     * las sesiones de tarea como conversaciones, en silencio y en la dirección equivocada.
+     * Es el mismo camino que recorrió `historica`: de suposición a hecho comprobado.
+     */
+    tarea?: string;
+    /**
+     * Lo que ha gastado la sesión ENTERA, sumando los deltas de sus turnos.
+     *
+     * Ausente es **«no consta»** y no «gastó cero»: no lo lleva ninguna sesión escrita antes de
+     * esto —hasta que la siembra la alcance—, y tampoco una cuyo `.jsonl` no quepa en el tope de
+     * la siembra. Un cero aquí afirmaría una medida que nadie hizo, que es la cifra inventada de
+     * siempre. Y por eso **nunca es un acumulado parcial**: o es la sesión entera, o no está (ver
+     * `anotarConsumoDeActo`, que es donde se decide eso).
+     *
+     * NO lleva `ventana`, aunque el tipo la admita: la ventana es «cuánto ocupa el historial
+     * AHORA», y dentro de una sesión cerrada hace días sería un «ahora» congelado. Sigue en cada
+     * `fin` del `.jsonl`, que es donde se mide. `acumularTotales` es quien la quita.
+     */
+    consumo?: ConsumoDeTurno;
+    /**
+     * El ticket de Jira al que quedó ligada esta sesión (IXCODE-11). Ausente = ninguno.
+     *
+     * Vive AQUÍ por lo mismo que el dispositivo y el esfuerzo: es un dato DE la sesión, no uno
+     * de sus actos, y sin esto la elección se perdía al cerrar la pestaña.
+     */
+    ticket?: TicketDeSesion;
+}
+export interface SesionReabierta {
+    id: string;
+    actos: Acto[];
+    /** Siempre `true`: `reabrirSesion` solo se llama para releer una sesión ya cerrada. */
+    historica: boolean;
+    /** El dispositivo que tenía elegido. Ausente = ninguno, o la sesión es anterior a esto. */
+    dispositivo?: DispositivoElegido;
+    /** El esfuerzo que tenía fijado. Ausente = ninguno, o la sesión es anterior a esto. */
+    esfuerzo?: Esfuerzo;
+    /** El motor con el que nació. Ausente = deepagents (ver `EntradaIndice.motor`). */
+    motor?: MotorDeAgente;
+    /** El modo de escritura que tenía. Ausente = supervisado, o la sesión es anterior a esto. */
+    modo?: ModoDeEscritura;
+    /** El ticket al que quedó ligada. Ausente = ninguno, o la sesión es anterior a esto. */
+    ticket?: TicketDeSesion;
+}
+/** Las dos rutas de una sesión, para quien las EXPORTA (`soporte.ts`): el `.jsonl` de sus
+ *  actos y su carpeta (artefactos, adjuntos, memoria). Con la misma guarda del id. */
+export declare function rutaDeActosDeSesion(raiz: string, id: string): string;
+export declare function carpetaDeLaSesion(raiz: string, id: string): string;
+/** Un índice roto (JSON que no parsea, o que no es una lista) no se puede persistir como
+ * base: usar aquí la lista vacía que devuelve `leerIndice` para un JSON roto BORRARÍA del
+ * disco todas las sesiones que el índice roto todavía nombraba — el `.jsonl` de cada
+ * sesión sigue intacto, pero sin su entrada es irrecuperable. Misma disciplina que
+ * `settingsEnDisco.ts#leerCrudoOAbortar`: la lectura que alimenta una escritura PARA sin
+ * escribir ante JSON roto, en vez de recuperar el fichero por su cuenta.
+ */
+export declare class IndiceDeSesionesRoto extends Error {
+}
+/** Crea una sesión nueva y devuelve su id. El id es `randomUUID()`: no compone rutas por
+ * construcción, pero pasa igualmente por `rutaJsonl` (vía `segmentoSeguro`) en cuanto se
+ * anota o se reabre — la guarda no distingue de dónde vino el id.
+ */
+/**
+ * Da de alta una sesión en el índice.
+ *
+ * El id ENTRA por parámetro desde que es también el `thread_id` del grafo
+ * (`agent/sesiones/checkpointer.ts`): quien abre la consola lo decide al abrir, porque el hilo tiene
+ * que existir antes del primer turno, y esto solo escribe la entrada. Sin id se genera uno,
+ * que es lo que hacía siempre y lo que sigue valiendo para quien no tenga hilo.
+ */
+export declare function crearSesion(raiz: string, id?: string, tarea?: string): string;
+/** Anexa un acto al `.jsonl` de la sesión y refresca su entrada en el índice: fija el
+ * título en el PRIMER acto `usuario` (y no se vuelve a tocar) y actualiza `ultimoTurno`
+ * en cada llamada, sea cual sea el tipo de acto.
+ *
+ * El anexado va ANTES de tocar el índice a propósito: si el índice está roto y
+ * `leerIndiceOAbortar` lanza, el acto ya quedó escrito. Un turno completo no se pierde
+ * solo porque el índice —que es prescindible, se puede reconstruir barriendo los
+ * `.jsonl`— esté corrompido.
+ */
+export declare function anotarActo(raiz: string, id: string, acto: Acto): void;
+/**
+ * SIEMBRA la marca de tarea en una sesión que ya estaba en el índice. Devuelve si la tocó.
+ *
+ * Existe por las sesiones de tarea anteriores a `EntradaIndice.tarea`: sin esto, la primera
+ * que hubo en cada proyecto se queda para siempre pintada como una conversación. La corre el
+ * corredor al arrancar, recorriendo su propia cola — o sea leyendo la autoridad sobre de
+ * quién es cada sesión, la misma que escribió el dato.
+ *
+ * **Es MONOTÓNICA, y de ahí sale que sea segura**: solo añade. No pisa una marca puesta —la
+ * del disco es la que escribió quien abrió la sesión— y no quita ninguna, así que no hay
+ * forma de que convierta una sesión de tarea en una conversación, que es el único fallo
+ * abierto posible por aquí. Correrla dos veces no hace nada la segunda.
+ *
+ * Y **no da de alta la entrada que falte**: la cola vive en `~/.xonecode/tareas` y el índice
+ * en el proyecto, así que una tarea puede nombrar una sesión que alguien borró; crearla la
+ * resucitaría en la barra apuntando a un `.jsonl` que ya no está.
+ */
+export declare function marcarTareaDeSesion(raiz: string, id: string, tarea: string): boolean;
+/** Cuántas sesiones rellena UNA pasada de `sembrarConsumosPendientes`. */
+export declare const SESIONES_A_SEMBRAR = 12;
+/** Y por encima de este tamaño no se siembra: la siembra es SÍNCRONA y corre en el bucle de
+ *  eventos, así que un `.jsonl` enorme congelaría el servidor mientras lo lee. */
+export declare const TOPE_DE_BYTES_DE_SIEMBRA: number;
+/**
+ * Rellena el acumulado de las sesiones que ya existían antes de que se estampara. Devuelve
+ * cuántas tocó, que es lo que decide si merece la pena reanunciar el alta.
+ *
+ * Existe porque sin ella la función nace VACÍA en todas las sesiones anteriores: el índice solo
+ * aprende el gasto de una sesión cuando alguien la usa, y las que nadie vuelve a abrir se
+ * quedarían sin cifra para siempre. Esto es una siembra de PRESENTACIÓN, y no sostiene ninguna
+ * corrección: si no llega a una sesión —por el tope de número, por el de bytes o porque su
+ * `.jsonl` se fue— lo peor que pasa es que no enseñe cifra hasta su próximo turno, y entonces
+ * enseñará la BUENA (`anotarConsumoDeActo` relee cuando no hay acumulado del que partir).
+ *
+ * **Es MONOTÓNICA, como `marcarTareaDeSesion` y por el mismo motivo**: solo mira las entradas
+ * que NO traen acumulado, así que no puede pisar el de ninguna, y correrla dos veces no hace
+ * nada la segunda. Devuelve 0 la segunda vez.
+ *
+ * **Y no da de alta la entrada que falte**, tampoco como la otra: un `.jsonl` sin entrada en el
+ * índice es una sesión que alguien borró, y resucitarla la devolvería a la barra apuntando a un
+ * fichero que ya no está.
+ *
+ * Va de las MÁS RECIENTES hacia atrás porque el tope de número tiene que elegir, y lo que se
+ * mira en la barra es lo último que se hizo. **UNA sola escritura** al final y no una por
+ * entrada: el índice se reescribe entero cada vez.
+ */
+export declare function sembrarConsumosPendientes(raiz: string): number;
+/**
+ * Borra una sesión: su `.jsonl` y su entrada del índice. Devuelve si había algo que borrar.
+ *
+ * El fichero va PRIMERO y el índice después, al revés que en `anotarActo` y por el mismo
+ * razonamiento invertido: aquí lo que no se puede quedar a medias es una entrada de índice
+ * apuntando a un fichero que ya no está —la sesión saldría en la barra y reventaría al
+ * abrirla—. Al revés, un `.jsonl` huérfano no lo ve nadie: la barra se pinta con el índice.
+ *
+ * Un id desconocido devuelve `false` en vez de lanzar: borrar dos veces la misma sesión —dos
+ * pestañas abiertas, un doble clic— no es un error, y lo único que hay que saber es si
+ * quedaba algo.
+ */
+export declare function borrarSesion(raiz: string, id: string): boolean;
+/**
+ * Le pone nombre a una sesión. Devuelve si existía.
+ *
+ * Un título vacío se RECHAZA, y no es una validación de formulario: `anotarActo` fija el
+ * título en el primer acto de usuario y solo mientras esté vacío (`entrada.titulo === ""`).
+ * Dejarlo vacío devolvería la sesión al régimen automático, así que el siguiente turno la
+ * rebautizaría con la primera frase y el nombre que puso una persona desaparecería sin más.
+ * Se acota a `LARGO_TITULO` como los automáticos: la barra tiene el ancho que tiene.
+ */
+export declare function renombrarSesion(raiz: string, id: string, titulo: string): boolean;
+/**
+ * Fija —o quita, con `undefined`— el dispositivo preferido de una sesión.
+ *
+ * Devuelve si había una entrada que tocar: una sesión cuyo id todavía no existe en el índice
+ * (nace al volcar el primer acto) no se puede anotar aquí, y quien llama tiene que guardarlo
+ * en memoria hasta entonces — decirlo con un `false` es mejor que crear una entrada a medias
+ * que la barra enseñaría como una sesión vacía.
+ */
+export declare function elegirDispositivo(raiz: string, id: string, dispositivo: DispositivoElegido | undefined): boolean;
+/**
+ * Fija —o quita, con `undefined`— el esfuerzo de una sesión.
+ *
+ * Gemela de `elegirDispositivo` hasta en el `false`: una sesión cuyo id todavía no está en
+ * el índice (nace al volcar el primer acto) no se puede anotar, y crear ahí una entrada a
+ * medias la pintaría en la barra como una sesión vacía. Quien llama la tiene en memoria de
+ * todos modos —vive en `EstadoDeSesion`—, así que perder la anotación no pierde la
+ * elección: solo no sobrevive a cerrar, que es lo mismo que pasaba antes de esto.
+ */
+/** Anota el motor con el que nace una sesión. Gemela de `elegirEsfuerzo`, `false` incluido. */
+export declare function anotarMotor(raiz: string, id: string, motor: MotorDeAgente): boolean;
+export declare function elegirEsfuerzo(raiz: string, id: string, esfuerzo: Esfuerzo | undefined): boolean;
+/**
+ * Fija el modo de escritura de una sesión.
+ *
+ * Gemela de `elegirEsfuerzo` hasta en el `false`: una sesión cuyo id todavía no está en el
+ * índice (nace al volcar el primer acto) no se puede anotar, y crear ahí una entrada a
+ * medias la pintaría en la barra como una sesión vacía. Quien llama lo tiene en memoria de
+ * todos modos —vive en `EstadoDeSesion`—, así que perder la anotación no pierde la
+ * elección: solo no sobrevive a cerrar.
+ *
+ * **`supervisado` BORRA la clave en vez de escribirla.** Es la omisión, así que dejarla
+ * escrita daría dos formas de decir lo mismo, y la que sobra es la que hay que recordar
+ * mantener. La misma regla que el `false` que no se guardaba en el ajuste de disco que esto
+ * sustituyó.
+ */
+export declare function elegirModo(raiz: string, id: string, modo: ModoDeEscritura): boolean;
+/**
+ * Liga una sesión a un ticket de Jira (IXCODE-11).
+ *
+ * Gemela de `elegirEsfuerzo` hasta en el `false`: una sesión cuyo id todavía no está en el
+ * índice (nace al volcar el primer acto) no se puede anotar, y crear ahí una entrada a medias
+ * la pintaría en la barra como una sesión vacía. Quien llama lo tiene en memoria de todos
+ * modos —vive en `ConsolaDeProyecto`—, así que perder la anotación no pierde la elección: solo
+ * no sobrevive a cerrar. A diferencia del esfuerzo, no hay forma de QUITAR el ticket todavía
+ * —nadie la pidió—, así que esta función no acepta `undefined`.
+ */
+export declare function anotarTicket(raiz: string, id: string, ticket: TicketDeSesion): boolean;
+/** El índice completo, tal cual lo enseña la lista de sesiones del proyecto. */
+export declare function listarSesiones(raiz: string): EntradaIndice[];
+/** Relee una sesión entera. Una línea que no parsea (fichero truncado a mitad de un
+ * `appendFileSync`, por ejemplo por un crash) se SALTA en vez de tumbar la reapertura: una
+ * sesión que no se puede reabrir porque una línea se truncó es peor que una que reabre con
+ * una línea de menos.
+ */
+export declare function reabrirSesion(raiz: string, id: string): SesionReabierta;

package/dist/web/servidor/soporte.d.ts

@@ -0,0 +1,65 @@
+import type { Writable } from "node:stream";
+import { type AnalisisDeSesion } from "../../core/analisisDeSesion.js";
+import { type ManifiestoDeSoporte } from "../../core/paqueteDeSoporte.js";
+import type { Tarea } from "../../core/tareas.js";
+/** Cuántas sesiones, las más recientes, se analizan y se listan en la pestaña. */
+export declare const SESIONES_EN_SOPORTE = 50;
+/** Todo lo que el servidor sabe de un proyecto y el empaquetador necesita. */
+export interface FuenteDeSoporte {
+    raiz: string;
+    /** El nombre del proyecto, del listado del SERVIDOR. */
+    proyecto: string;
+    /** Las tareas de ESTE proyecto (decididas por la raíz). */
+    tareas: readonly Tarea[];
+    /** Dónde viven los adjuntos de una tarea; ausente = no se exportan. */
+    carpetaDeAdjuntosDeTarea?: (id: string) => string | undefined;
+    /** Los ids de sesión con un turno en marcha ahora mismo. */
+    sesionesEnVuelo: ReadonlySet<string>;
+    /** La raíz tiene un turno en marcha (aunque su sesión aún no tenga entrada). */
+    raizEnVuelo: boolean;
+    /** La versión de xonecode en marcha, si se sabe. */
+    version?: string;
+    /** El tope de contexto de un modelo («proveedor/modelo»), si se sabe. */
+    topeDeContexto?: (modelo: string) => number | undefined;
+}
+export interface FilaDeSoporte {
+    id: string;
+    titulo: string;
+    creada?: string;
+    ultimoTurno?: string;
+    /** Solo en una tarea. */
+    estado?: Tarea["estado"];
+    /** Solo en una tarea: la sesión donde corrió. */
+    sesion?: string;
+    /** Solo en una tarea: cuándo empezó y acabó, lo MISMO que enseña Finalizadas (petición suya: las fechas no coincidían). */
+    empezada?: string;
+    acabada?: string;
+    enVuelo?: true;
+    analisis: AnalisisDeSesion;
+}
+export interface ListadoDeSoporte {
+    chats: FilaDeSoporte[];
+    tareas: FilaDeSoporte[];
+}
+/** Lo que pinta la pestaña: las sesiones más recientes y las tareas, cada una con su análisis. */
+export declare function listarSoporte(fuente: FuenteDeSoporte, limite?: number): Promise<ListadoDeSoporte>;
+/** Quien pedía la descarga se fue a medias: no es un fallo del paquete. */
+export declare class ErrorDeDescargaCortada extends Error {
+    constructor();
+}
+export type PedidoDeSoporte = {
+    tipo: "proyecto";
+} | {
+    tipo: "chat";
+    id: string;
+} | {
+    tipo: "tarea";
+    id: string;
+};
+/** ¿Existe lo pedido? Lo decide el SERVIDOR con su propio índice: el id del cable no compone rutas sin esto. */
+export declare function motivoParaNoExportar(fuente: FuenteDeSoporte, pedido: PedidoDeSoporte): string | undefined;
+/**
+ * Escribe el paquete pedido en `destino`, entero, y devuelve su manifiesto (que va también
+ * DENTRO, como última entrada). Quien llama pone antes las cabeceras y cierra `destino` después.
+ */
+export declare function escribirPaquete(fuente: FuenteDeSoporte, pedido: PedidoDeSoporte, destino: Writable, ahora?: Date): Promise<ManifiestoDeSoporte>;