xonecode 0.38.44 → 0.39.2

package/dist/agent/motores/trueforge/recortes.d.ts

@@ -0,0 +1,47 @@
+/** Por encima de esto `ls`/`glob`/`grep` se truncan (el `truncateIfTooLong` de deepagents). */
+export declare const CARACTERES_ANTES_DE_TRUNCAR = 80000;
+export declare const AVISO_DE_TRUNCADO = "\n... [resultados truncados: afina el patr\u00F3n o la ruta]";
+/** Por encima de esto un resultado de `execute` o de una tool propia se desaloja del contexto. */
+export declare const CARACTERES_ANTES_DE_DESALOJAR: number;
+export declare const MAXIMO_DE_COINCIDENCIAS: 100;
+export declare function truncarSiLargo(texto: string): string;
+/** Cabeza y cola numeradas, con cuántas líneas se saltan en medio (`createContentPreview`). */
+export declare function vistaPrevia(texto: string, cabeza?: number, cola?: number): string;
+/** Lo que hace falta del backend para desalojar: escribir en la ruta virtual. */
+export interface EscritorDeDesalojo {
+    write(ruta: string, contenido: string): unknown;
+}
+/**
+ * El texto que VE el modelo: el mismo si cabe, o la ruta donde quedó y un extracto si no. Si no
+ * se puede guardar —sin carpeta de artefactos no hay dónde colgar `/large_tool_results/`, y la
+ * guarda del proyecto lo rechaza, como debe— se dice y va el extracto igual: meter el resultado
+ * entero es justo lo que esto evita.
+ */
+export declare function desalojarSiGrande(texto: string, backend: EscritorDeDesalojo, forzar?: boolean): Promise<string>;
+/**
+ * **El presupuesto de un PASO**, que el recorte de arriba no ve: cada resultado se mira solo, así
+ * que cinco `execute` en paralelo de 20.000 caracteres pasan uno a uno y juntos meten 100.000 en
+ * el contexto. Es la regla del `largeToolResponse` de TrueForge, con su umbral (10.000 tokens),
+ * portada y no montada: con los dos puestos la misma salida se procesaría dos veces.
+ */
+export declare const CARACTERES_DEL_PASO: number;
+/** Un error que haya que recortar se TRUNCA a esto en vez de desalojarse: ahí no hay nada que releer. */
+export declare const CARACTERES_DE_UN_ERROR = 500;
+/** Lo que se usa de un resultado de tool de TrueForge dentro de un `toolResponseProcessor`. */
+export interface ResultadoDelPaso {
+    message: {
+        content: unknown;
+    };
+    failure?: unknown;
+    isStructuredContent?: boolean;
+}
+/**
+ * Los resultados de UN paso, dentro del presupuesto: un error ENORME se trunca, y mientras el
+ * total se pase se desalojan los mayores primero. Modifica los resultados, que es el contrato del
+ * procesador de la librería; no quita ninguno (la librería lanza si falta uno).
+ */
+export declare function recortarPaso(resultados: ResultadoDelPaso[], backend: EscritorDeDesalojo): Promise<void>;
+/** El procesador que TrueForge llama con todos los resultados de un paso. */
+export declare function presupuestoDelPaso(backend: EscritorDeDesalojo): {
+    process: (resultados: ResultadoDelPaso[]) => Promise<{}>;
+};

package/dist/agent/motores/trueforge/resumenSeguro.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Un resumen de contexto VACÍO no puede sustituir a la conversación.
+ *
+ * La compactación de TrueForge (`ContextCompaction.mjs`) pide un resumen al modelo y **sustituye el
+ * contexto ENTERO** por su respuesta, sin comprobar que no venga vacía. Con una vacía el raíz se
+ * queda sin el encargo: en una sesión real el contexto acabó siendo `[{assistant: ""}, «resumen
+ * hecho»]`, y el agente contestó «no tengo ningún encargo» con el encargo a tres mensajes de
+ * distancia. Peor, la memoria del hilo quedó así, y reenviar el mensaje no lo arreglaba.
+ *
+ * Aquí se envuelve el modelo SOLO para esa llamada: una respuesta vacía se reintenta una vez, y si
+ * sigue vacía se sustituye por los mensajes de la persona, tal como llegaron al resumen. No mejora
+ * un resumen malo; evita que el encargo se pierda.
+ *
+ * **Límite declarado**: los mensajes se recuperan del texto que la librería le da al modelo
+ * (`<n><user>:…`), un formato suyo. Si cambia, el rescate devuelve un aviso sin mensajes en vez de
+ * lanzar, y el test de este fichero lo delata.
+ */
+export interface RespuestaDeResumen {
+    output: {
+        content?: unknown;
+        [k: string]: unknown;
+    };
+    [k: string]: unknown;
+}
+export interface ClienteDeResumen {
+    createNonStream: (cuerpo: never) => Promise<never>;
+    [k: string]: unknown;
+}
+/** Los mensajes de la persona del texto que la compactación le pasa al modelo, en orden. */
+export declare function mensajesDeLaPersona(candidato: string): string[];
+export declare function resumenDeRescate(candidato: string): string;
+/** El cliente con la compactación protegida. Todo lo demás del cliente pasa igual. */
+export declare function conResumenSeguro<T extends ClienteDeResumen>(cliente: T, avisar?: (texto: string) => void): T;

package/dist/agent/motores/trueforge/sesionTrueforge.d.ts

@@ -0,0 +1,273 @@
+import type { PendienteDeAprobacion } from "../../../core/events.js";
+import type { IconosPort, FuentesPort, ConectoresPort, ModelosPort, SkillInfo, SubagenteExternoPort, VerifierPort } from "../../../core/ports.js";
+import { opcionesDeSubagenteExterno } from "../../subagentes/escrituraExterna.js";
+import type { LineaDeDiff } from "../../../core/diff.js";
+import { type Decision } from "../../../vendor/hitl.js";
+import { bloqueDeAprendido } from "../../../core/aprendido.js";
+import { type Agente } from "../../../core/agentes.js";
+import type { SesionReal } from "../../turno/sesionReal.js";
+import { type HechosDelTurno, type VeredictoDelTurno } from "../../../core/juezDelTurno.js";
+import type { Entorno } from "../../config/entorno.js";
+import { type DiagnosticoDeTools } from "../../turno/diagnosticoDeTools.js";
+import { type CargarIndice } from "../../navegacion/indiceEnDisco.js";
+/**
+ * Cuando quien MAQUETA es un hijo de Claude Code con ejecución, el bucle lo hace ÉL: despliega, captura, compara con la
+ * maqueta y corrige (`textoDeTrabajoSinLlamar`). Medido en Maset: el orquestador, con `BUCLE_DE_CALIDAD`, volvía a pasar el
+ * crítico y le encargaba otra vuelta —y otra al diseñador por un SVG—, y cada vuelta era un Claude Code NUEVO que releía
+ * todo: unos quince minutos cada una, con las piezas ya bien. Dos bucles uno encima de otro.
+ */
+export declare function textoDeMaquetadorExterno(nombres: readonly string[]): string;
+/**
+ * Lo que el orquestador tiene que saber para DELEGAR en ESTE motor. Su prompt es el de siempre
+ * (`promptOrquestador`), que habla de `task` y de la ficha que va en su descripción: aquí la
+ * delegación es `create_sub_agent` y no tiene descripción por especialista, así que se traduce
+ * el nombre de la tool y las fichas van escritas aquí, con la MISMA función que deepagents.
+ */
+/**
+ * **El idioma de la SALIDA, dicho desde código**, al raíz y a cada especialista. Visto en la consola web (MyAllXOne):
+ * el texto entre herramientas salía en inglés («Let me call…») con la persona escribiendo en español: nuestros prompts
+ * están en español pero ninguno lo decía, y hay piezas internas en inglés que tiran de él (la identidad que añade
+ * TrueForge, las descripciones de las tools, la costumbre de DeepSeek de razonar en inglés).
+ *
+ * **Lo que importa es lo que LEE la persona, en SU idioma** (decisión suya): las respuestas, lo que se dice entre
+ * herramientas y lo que se entrega. El razonamiento queda libre. Y no es «español» a fuego, es el idioma del usuario: el
+ * raíz lo lee de su mensaje; un hijo no lo ve, así que sigue el de su encargo, que el raíz escribe en ese idioma.
+ */
+export declare const IDIOMA_DE_LA_RESPUESTA: string;
+/** Lo mismo para un ESPECIALISTA, que no ve el mensaje del usuario: sigue el idioma de su encargo. */
+export declare const IDIOMA_DEL_ESPECIALISTA: string;
+/**
+ * **Al desarrollador no se le cuenta la MAQUINARIA**, solo al raíz, que es quien le habla. Visto en la consola web: al
+ * saludar, el raíz explicaba que tenía «la foto del proyecto», que no la iba a «re-escanear», que el especialista lo
+ * llevaría «dentro del HANDOFF DE ANÁLISIS» y que usaría `xone_navegacion`. Es cómo trabaja el harness por dentro, no
+ * algo que le sirva a quien pide: petición suya. A los hijos no va, porque le hablan al raíz y no a la persona.
+ */
+export declare const SIN_HABLAR_DEL_HARNESS: string;
+/** Lo que recibe el agente en modo autónomo cuando pregunta sin marcar ninguna opción como recomendada. */
+/**
+ * Al raíz de una TAREA DE FONDO (`trabajoSinPersona`). Preguntar no está prohibido —la pregunta se contesta sola con su
+ * recomendada, y pasado el tope aparca la tarea—, pero cada una es una parada: se le pide decidir antes. Y como nadie
+ * ha visto el trabajo, la respuesta final es lo que la persona leerá: un resumen con lo que decidió sin preguntar.
+ */
+export declare const TRABAJO_SIN_PERSONA: string;
+/**
+ * Lo aprendido, para el ORQUESTADOR: lo que hay apuntado y cuándo apuntar él. Le toca sobre todo lo que le cuente un
+ * hijo de motor externo en su apartado «Aprendido:» (ese hijo no tiene la tool).
+ */
+export declare function textoDeAprendidoDelRaiz(lista: Parameters<typeof bloqueDeAprendido>[0]): string;
+/**
+ * La respuesta a una pregunta del agente cuando nadie la contesta y tenía opción recomendada. No es la opción a secas:
+ * medido en Maset, con solo «Opción A (Recommended)» el agente cerraba diciendo «lo decidiste tú», como si la hubiera
+ * elegido la persona. Es SU recomendación aplicada, y así tiene que contarla.
+ */
+export declare function respuestaAutonomaRecomendada(elegida: string): string;
+export declare const RESPUESTA_AUTONOMA_SIN_RECOMENDADA = "Modo aut\u00F3nomo: no hay nadie a quien preguntar. Decide t\u00FA con lo que dicen el encargo y el plan, sigue, y di en tu respuesta final qu\u00E9 elegiste y por qu\u00E9.";
+/** Un comando que saca una captura de pantalla del aparato. */
+export declare const COMANDO_DE_CAPTURA: RegExp;
+/** Con cuántas capturas de UN encargo se le avisa a quien ejecuta. */
+export declare const UMBRALES_DE_CAPTURAS: readonly [2, 4];
+/**
+ * El aviso de capturas. El prompt del conductor ya decía que una captura «no es una herramienta de diagnóstico», y una
+ * comprobación de una pasada real sacó 18 —61 ficheros y 92 pares casi iguales en total—, casi todas para mirar valores
+ * y excepciones que `getText`/`getFields` y el log contestan sin mirar nada. Un texto no es un contador.
+ */
+export declare function textoDeCapturas(capturas: number): string;
+/** Con cuántas comprobaciones seguidas se le avisa a quien lleva un lazo. El primero es el «tres vueltas» del prompt. */
+export declare const UMBRALES_DE_VUELTAS: readonly [3, 5];
+/**
+ * El aviso: no dice «para», dice «cambia de procedimiento». La misma familia de fallo se vio arreglada de cinco
+ * maneras (un control que falta, y al arreglarlo, otro): lo que hay que hacer es aislar la causa una vez y aplicarla
+ * a todos los sitios, no reescribir otra vez.
+ */
+export declare function textoDeVueltas(vueltas: number): string;
+/**
+ * Lo que se le cuenta a quien ESPERÓ a otros especialistas, al soltarse: a quién esperó y qué hay en el disco.
+ * Solo NOMBRES —los recursos de `icons/` y los `ASSETS.md`/`TASKS.md` del plan—, nunca su contenido: es lo que dejó
+ * el otro, que no viaja por ningún canal más que el disco. Sin recursos que nombrar, un aviso corto.
+ */
+export declare function textoDeLoQueDejaronLosEsperados(raiz: string, esperadas: readonly string[]): string;
+/**
+ * Lo que se le dice a quien puede llamar a otros. Cada llamada de estas es un hilo nuevo que solo sabe lo que le
+ * escribas (aunque recuerde sus encargos anteriores de la sesión), y lo que te devuelve es lo que vio, no un
+ * veredicto: decidir si lo que escribiste funciona sigue siendo cosa tuya, con lo que ese hijo te traiga.
+ */
+export declare function textoDelBucle(llama: readonly string[], opciones?: {
+    conCritica?: boolean;
+    conFuentes?: boolean;
+}): string;
+export declare function notaDeDelegacion(agentes: readonly Agente[], opciones?: {
+    conIconos?: boolean;
+    conFuentes?: boolean;
+    conComparacion?: boolean;
+    conMemoria?: boolean;
+    conBucle?: boolean;
+    conEsperas?: boolean;
+}): string;
+/**
+ * La frase de las tools que TIENE, sacada de los nombres que de verdad se le montan: escrita a
+ * mano se quedaba vieja en cuanto se añadía una —la nota decía cuatro y el modelo veía seis—.
+ */
+/**
+ * CUÁNDO usar el índice de atributos, junto a la lista de tools y solo a quien la tiene. Medido en calc13: con la tool
+ * montada y descrita, el consultor la consultó 9 veces y el desarrollador —quien escribe los atributos— ninguna, con 13
+ * lecturas de la skill: su prompt solo la nombraba en la lista, y el `SKILL.md` le manda a las referencias. No va en el
+ * `SKILL.md` porque ese llega también a los motores externos, que no tienen la tool.
+ */
+export declare const USO_DE_XONE_ATRIBUTOS: string;
+/**
+ * CUÁNDO convertir las medidas de una maqueta, por lo mismo que `USO_DE_XONE_ATRIBUTOS`: una tool nombrada solo en la
+ * lista no se usa. Medido en Maset: con la regla en la skill, el desarrollador copió los px de la maqueta como `p` y los
+ * iconos salieron unas 2,6 veces más pequeños.
+ */
+export declare const USO_DE_CONVERTIR_A_P: string;
+export declare function notaDeTools(nombres: readonly string[], limite: string): string;
+/**
+ * La pregunta del orquestador, como TEXTO del chat: la pregunta y sus opciones numeradas. Se pinta
+ * en la respuesta y no en un diálogo, a propósito: así llega igual a la web, a la TUI y al terminal
+ * sin tocar ninguna piel, y la persona contesta como contesta siempre, escribiendo.
+ */
+export declare function textoDePregunta(args: Record<string, unknown>): string;
+/**
+ * La pregunta y sus opciones como DATO (`events.ts#consulta`), de los argumentos que mandó el
+ * modelo: una sola lectura para el texto, la tarjeta y la respuesta, o las tres divergirían.
+ */
+export declare function consultaDe(args: Record<string, unknown>): {
+    pregunta: string;
+    opciones: string[];
+};
+/** Lo que escribió la persona, como respuesta: un número de opción se traduce a su texto. */
+export declare function respuestaAPregunta(args: Record<string, unknown>, escrito: string): string;
+/**
+ * El tope de llamadas del ORQUESTADOR en un turno. deepagents no le pone ninguno —no puede quedarse
+ * a medias— y TrueForge exige un número (su omisión, 25, es la del core); 100 es la omisión de su
+ * propio `AgentSpec`. Es POR TURNO porque el raíz se rehace desde su foto al acabar cada uno.
+ */
+export declare const LIMITE_DE_LLAMADAS_DEL_RAIZ = 100;
+export interface OpcionesDeSesionTrueforge {
+    raiz: string;
+    modelos: ModelosPort;
+    entorno: Entorno;
+    /**
+     * El catálogo de skills de la sesión. OBLIGATORIO: sin él cada especialista se quedaría sin
+     * el anuncio de las suyas y trabajaría como si no las tuviera, sin un error que leer — el
+     * patrón de fallo del campo opcional.
+     */
+    skills: readonly SkillInfo[];
+    pedirAprobacion?: (pendientes: PendienteDeAprobacion[], ficheros: Map<string, string>, diffs: Map<string, LineaDeDiff[]>) => Promise<Map<string, Decision>>;
+    /** El modo autónomo de la sesión, leído en CADA ronda (`core/modoDeEscritura.ts`). */
+    sinAprobacion?: () => boolean;
+    /** La carpeta de artefactos de la sesión (lo que el agente ve como `/artefactos/`). */
+    artefactos?: string;
+    /**
+     * La carpeta de los ADJUNTOS — lo que el agente ve como `/adjuntos/`, de solo lectura
+     * (`core/adjuntos.ts`, `agent/grafo/proyecto.ts#backendConAdjuntos`). Ausente es «no hay»
+     * y `/adjuntos/` no se monta; una cadena vacía montaría el cwd del proceso.
+     *
+     * **Antes de IXCODE-7 este motor no recibía este dato en absoluto**: una tarea con
+     * adjuntos corría en TrueForge sin `/adjuntos/` montada, mudo — los tests de la pieza
+     * pasaban igual porque la composición vivía en `montarBackend`, que ningún test doblaba.
+     */
+    adjuntos?: string;
+    /** De dónde salen los iconos (IXCODE-18). Ausente = `buscar_icono` no se monta. */
+    iconos?: IconosPort;
+    /** De dónde salen las fuentes (Google Fonts). Ausente = `buscar_fuente`/`traer_fuente` no se montan. */
+    fuentes?: FuentesPort;
+    /**
+     * El raíz puede PROPONER repartir un encargo grande en tareas de fondo encadenadas (`proponer_tareas`,
+     * `core/repartoDeEncargo.ts`). Solo una sesión de PERSONA de la web, que es la que tiene la cola de tareas y la
+     * tarjeta para encolarlas: nunca una consola de tarea (encadenaría trabajo sin nadie), ni el terminal, `run` o los
+     * evals. Ausente es no.
+     */
+    puedeProponerTareas?: boolean;
+    /**
+     * Una TAREA DE FONDO: nadie delante. El raíz resuelve sus dudas solo, como en modo autónomo (la opción recomendada, o
+     * «decide tú»), con el mismo tope por turno, y su prompt le pide cerrar con un resumen (`TRABAJO_SIN_PERSONA`).
+     * Medido en Maset: cada duda paraba la tarea a preguntar, y la persona contestaba «Continúa donde lo dejaste».
+     */
+    trabajoSinPersona?: boolean;
+    /**
+     * Los conectores MCP del proyecto (Stitch…). El MISMO servicio de Ajustes, que solo tiene la
+     * web: ausente —el terminal, `run`, los evals— es que ningún agente recibe sus tools.
+     */
+    conectores?: ConectoresPort;
+    hilo?: string;
+    /**
+     * El índice de `xone_navegacion`. Solo para doblarlo en un test: ausente es el REAL, sobre la
+     * raíz (`indiceEnDisco`), y la omisión vive aquí y no en quien llama por el patrón de fallo de
+     * siempre — compuesta en un cierre que los tests doblan, la tool quedaría escrita y sin montar.
+     */
+    navegacion?: CargarIndice;
+    /**
+     * El simulador. Entra por parámetro, como en deepagents, para que `npm test` siga sin él; en
+     * producción lo pasa `abrirSesionReal`, que es quien lo recibe de todas las pieles.
+     */
+    verifier?: VerifierPort;
+    /** Solo para doblar la traza en un test; ausente es la real (`crearDiagnosticoDeTools`). */
+    diagnostico?: DiagnosticoDeTools;
+    /** Tope de rondas de aprobación con alguien delante (el de la consola). */
+    topeDeRondas?: number;
+    /**
+     * Que cada especialista recuerde sus encargos anteriores de la sesión (`memoriaDeEspecialistas.ts`).
+     * Por omisión SÍ; `XONECODE_SIN_MEMORIA_DE_ESPECIALISTAS=1` lo apaga, para comparar una pasada con y sin ella.
+     */
+    memoriaDeEspecialistas?: boolean;
+    /**
+     * El BUCLE del desarrollador: quien escribe puede llamar por su cuenta a los especialistas que su `.md`
+     * declara en `llama` (hoy `device-controller`), y así prueba lo que escribe sin pasar por el orquestador.
+     * Apagado por omisión: `XONECODE_BUCLE_DEL_DEVELOPER=1` lo enciende, para compararlo con una pasada sin él.
+     */
+    bucleDelDesarrollador?: boolean;
+    /**
+     * Que un hijo espere al fin de los que su `.md` declara en `espera` cuando el orquestador los lanza a la vez
+     * (`esperas.ts`). Por omisión SÍ: es una regla de coherencia, no una palanca de coste.
+     */
+    esperasEntreHijos?: boolean;
+    /**
+     * El crítico VISUAL y el JUEZ del turno, los MISMOS puertos que deepagents
+     * (`turnoReal.ts#abrirSesionReal`): llaman a un modelo, así que entran por parámetro y
+     * `npm test` no pregunta a nadie. Ausente es «esta ejecución no tiene», nunca «está bien».
+     */
+    criticaVisual?: (captura: {
+        base64: string;
+        mime: string;
+    }, pantalla: string) => Promise<{
+        veredicto: string;
+        observaciones: string[];
+    }>;
+    juezDelTurno?: (caso: {
+        objetivo: string;
+        respuesta: string;
+        hechos: HechosDelTurno;
+    }) => Promise<VeredictoDelTurno>;
+    /**
+     * La FÁBRICA del puerto de los motores externos (Claude Code, Codex, OpenCode), no el puerto:
+     * así un test recibe las opciones que la sesión COMPONE —política, modo, cola, consumo— y las
+     * comprueba una a una. Ausente es la real (`crearSubagenteExterno`), y la omisión vive aquí por
+     * el patrón de fallo de siempre: compuesta en un cierre que los tests doblan, quedaría escrita.
+     */
+    subagenteExterno?: (opciones: ReturnType<typeof opcionesDeSubagenteExterno>) => SubagenteExternoPort;
+    /**
+     * ¿Las dos trazas opt-in van encendidas sin variable de entorno? Resuelto por quien LLAMA,
+     * igual que en deepagents (`turnoReal.ts#abrirSesionReal`) — ver ahí el porqué de que
+     * ausente se comporte exactamente como hoy.
+     */
+    depurar?: boolean;
+}
+/**
+ * ¿Cambió algún fichero del proyecto (fuera de `.xonecode/`) después de `desde`? Por la hora de modificación del disco,
+ * que es lo que vale para los dos motores: un hijo de Claude Code escribe con sus tools y no pasa por las nuestras. Lo
+ * que no se puede mirar no cuenta como cambio.
+ */
+export declare function cambioDespuesDe(raiz: string, desde: number): boolean;
+/**
+ * `agregarNota` no vive todavía en `SesionReal` (IXCODE-4, Task 6 se la añade ahí como opcional,
+ * compartida con deepagents): se ensancha el tipo de retorno AQUÍ, en vez de esperar a esa task,
+ * porque una sesión sin ella tipado como `SesionReal` a secas dejaría `s.agregarNota(...)` en
+ * rojo bajo `tsc --noEmit` desde este mismo commit. Sigue siendo un `SesionReal` válido en
+ * cualquier sitio que lo espere (`turnoReal.ts#abrirSesionReal`), por ser una intersección.
+ */
+export declare function abrirSesionTrueforge(opciones: OpcionesDeSesionTrueforge): Promise<SesionReal & {
+    agregarNota(texto: string): void;
+    detener(texto: string): void;
+    readonly llamadasTiradasPorDetener: number;
+}>;

package/dist/agent/motores/trueforge/skillsTrueforge.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Las skills de un agente de TrueForge: **las de SU `.md` y ninguna más**, la misma regla que en
+ * deepagents, donde el orquestador no recibe ninguna y cada subagente recibe su catálogo declarado
+ * (`xoneAgent.ts`: «los subagentes no heredan las skills del orquestador»).
+ *
+ * En deepagents las anuncia el `SkillsMiddleware` —nombre y descripción— y el agente lee el
+ * `SKILL.md` cuando la necesita. TrueForge no tiene ese middleware, así que se anuncian en el prompt
+ * con la misma forma: qué hay, para qué sirve y dónde leerlo. El contenido no se inyecta: son
+ * decenas de miles de caracteres, y cargarlas todas en cada llamada es el gasto que la carga bajo
+ * demanda existe para evitar.
+ *
+ * Puro: el catálogo entra por parámetro.
+ */
+import type { Agente } from "../../../core/agentes.js";
+import type { SkillInfo } from "../../../core/ports.js";
+export declare function anuncioDeSkills(agente: Pick<Agente, "skills">, catalogo: readonly SkillInfo[]): string;

package/dist/agent/motores/trueforge/toolsDeConectores.d.ts

@@ -0,0 +1,36 @@
+import { type EscritorDeDesalojo } from "./recortes.js";
+import { type ConectorParaElAgente, type ToolConEsquema } from "../../../core/conectores.js";
+import type { ConectoresPort } from "../../../core/ports.js";
+import type { LineaDeDiff } from "../../../core/diff.js";
+/** Una tool de un conector, ya con el nombre con que la ve el agente. */
+export interface ToolMontada {
+    nombre: string;
+    conector: {
+        id: string;
+        nombre: string;
+    };
+    tool: ToolConEsquema;
+    /** Los campos que el catálogo le quita a su resultado (`camposFueraDelResultado`). */
+    recortar?: readonly string[];
+}
+export type ClaseDeTool = "lectura" | "escritura";
+/** Cuánto se espera antes de repetir una tool de LECTURA que falló (Stitch devolvió una vez «The service is currently unavailable»). */
+export declare const PAUSA_ANTES_DE_REPETIR_MS = 2000;
+export interface ConectoresDeSesion {
+    /** Hay algún conector que montar (sin preguntar a la red). */
+    readonly hay: boolean;
+    /** El `ToolSource` de TrueForge con las tools de esa clase. */
+    fuente(clase: ClaseDeTool, backend: EscritorDeDesalojo): Record<string, unknown>;
+    /** La tool REMOTA que escribe con ese nombre, si lo es. Para la tarjeta de aprobación. */
+    remotaDe(nombre: string): ToolMontada | undefined;
+}
+export declare function crearConectoresDeSesion(puerto: ConectoresPort, conectores: readonly ConectorParaElAgente[], esperar?: (ms: number) => Promise<void>): ConectoresDeSesion;
+/**
+ * La tarjeta de aprobación de una tool remota: qué conector, qué tool y sus argumentos ENTEROS —
+ * es el único sitio donde los argumentos de una tool se enseñan (`core/events.ts`), y aquí se
+ * DECIDE sobre ellos—. Van como líneas añadidas del diff, que es lo que la tarjeta ya pinta.
+ */
+export declare function tarjetaDeRemota(m: ToolMontada, args: Record<string, unknown>): {
+    descripcion: string;
+    lineas: LineaDeDiff[];
+};

package/dist/agent/motores/trueforge/toolsDeFichero.d.ts

@@ -0,0 +1,146 @@
+import type { DispositivoDeLaSesion } from "../../../core/dispositivoDeSesion.js";
+/** El backend de deepagents en su versión nueva, en lo que se usa. */
+export interface BackendDeFicheros {
+    ls(ruta: string): unknown;
+    read(ruta: string, offset?: number, limit?: number): unknown;
+    write(ruta: string, contenido: string): unknown;
+    edit(ruta: string, viejo: string, nuevo: string, todas?: boolean): unknown;
+    glob(patron: string, ruta?: string): unknown;
+    grep(patron: string, ruta?: string | null, glob?: string | null): unknown;
+}
+/** Una regla de `permisosDe`, tal cual la escribe. */
+export interface ReglaDeRuta {
+    operations: readonly ("read" | "write")[];
+    paths: readonly string[];
+    mode?: "allow" | "deny";
+}
+/** La misma decisión que `decidePathAccess` de deepagents: primera que casa, y permitir por
+ *  omisión. Con `micromatch` y `dot: true`, que es como la librería compara. */
+export declare function decidirAccesoDeRuta(reglas: readonly ReglaDeRuta[], operacion: "read" | "write", ruta: string): "allow" | "deny";
+/** Las seis tools y lo que cada una toca, para decidir el permiso antes de llamar al backend. */
+export declare const TOOLS_DE_FICHERO: readonly ["ls", "read_file", "write_file", "edit_file", "glob", "grep"];
+export type ToolDeFichero = (typeof TOOLS_DE_FICHERO)[number];
+/** Las que ESCRIBEN: son las que piden aprobación, igual que el HITL de deepagents. */
+export declare const TOOLS_QUE_ESCRIBEN: readonly ToolDeFichero[];
+/**
+ * La ruta VIRTUAL que el backend entiende, desde lo que escriba el modelo. Medido en la primera
+ * sesión real: el modelo pidió `ls .` y `read_file MEMORIA_PROYECTO.md`, sin la barra, y el
+ * backend —que solo sabe de rutas absolutas del espacio virtual— contestó «no existe» sobre un
+ * fichero que sí está; el agente acabó barriendo los `.xne` a mano. Vacía o `.` es la raíz, y
+ * lo relativo cuelga de ella.
+ *
+ * **Se normaliza ANTES de evaluar los permisos**, y es lo que importa: las reglas de `permisosDe`
+ * están escritas sobre rutas absolutas (`/.env`), así que una relativa (`.env`) no casaría con
+ * ninguna y pasaría. Y una que se sale de la raíz con `..` no es una ruta del proyecto: `undefined`,
+ * que quien llama rechaza — lo mismo que hace deepagents.
+ */
+export declare function normalizarRuta(bruta: string): string | undefined;
+/**
+ * Las líneas que devuelve un `read_file` sin `limit`, y el tope de caracteres que las acota. Eran 100, el valor de
+ * deepagents copiado al adaptador, y medido en una pasada real (calc10): un fichero de 450 líneas se leía en tres o
+ * cuatro páginas, y las lecturas por página eran la mayoría de las «relecturas» de la traza. opencode devuelve hasta
+ * 2.000 líneas o 50 KB; aquí lo mismo, y lo que no cabe se DICE con el `offset` por donde seguir.
+ */
+export declare const LINEAS_POR_LECTURA = 2000;
+export declare const CARACTERES_POR_LECTURA = 50000;
+export declare function seReescribeConEdit(ruta: string): boolean;
+export declare function textoDeReescrituraRechazada(ruta: string): string;
+/** El contenido numerado, cortado por una LÍNEA entera si pasa del tope de caracteres, diciendo por dónde seguir. */
+export declare function lecturaAcotada(contenido: string, desde: number, tope?: number): string;
+/**
+ * El `ToolSource` de TrueForge con las seis tools. La aprobación NO se decide aquí: la pone el
+ * `ToolSet` que lo envuelve (`requireApprovalForTools`), y la tool solo corre tras el «sí».
+ */
+export declare function fuenteDeFicheros(opciones: {
+    backend: BackendDeFicheros;
+    reglas: readonly ReglaDeRuta[];
+    /** Cuáles se ofrecen. Ausente = las seis. El `device-controller` no escribe ficheros: ejecuta. */
+    tools?: readonly ToolDeFichero[];
+}): {
+    name: string;
+    id: string;
+    listTools: () => Promise<{
+        result: {
+            tools: {
+                name: "read_file" | "ls" | "write_file" | "edit_file" | "glob" | "grep";
+                description: string;
+                inputSchema: {
+                    type: "object";
+                    properties: Record<string, unknown>;
+                    required: string[];
+                };
+                preload: boolean;
+            }[];
+        };
+        wasInitialized: undefined;
+    }>;
+    callTool: (params: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }) => Promise<import("@truefoundry/trueforge-core/core/mcp/IMCPServer.mjs").CallToolResolvedResponse>;
+    toolCallInfo: (params: {
+        name: string;
+    }) => Promise<{
+        type: "mcp";
+        mcp_server_id: string;
+        mcp_server_name: string;
+        original_tool_name: string;
+    }>;
+};
+/** Las que solo LEEN: las que lleva un subagente que no escribe el proyecto. */
+export declare const TOOLS_DE_LECTURA: readonly ToolDeFichero[];
+/** Lo que devuelve la shell de deepagents (`ExecuteResponse`), en lo que se usa. */
+interface BackendQueEjecuta {
+    execute(comando: string): unknown;
+    /** Para desalojar una salida grande a `/large_tool_results/`, como deepagents. */
+    write(ruta: string, contenido: string): unknown;
+}
+/**
+ * `execute`: la shell del `device-controller`, sobre el MISMO backend que le monta deepagents
+ * (`backendDeAgente` con `ejecucion`), así que su entorno —los scripts de las skills en el PATH, sin
+ * las claves de API, con el fichero del dispositivo de la sesión— y el anuncio de los artefactos que
+ * deje un comando son los de siempre.
+ *
+ * **Solo la lleva UN agente**, como en deepagents: una shell no pasa por `permisosDe` ni por la
+ * aprobación, así que no se le da al que escribe el proyecto. Y no pregunta antes de cada comando:
+ * lo que lo compensa es que el comando entero se VE en el chat (`resumenDeTool.ts` lo tiene en su
+ * lista blanca).
+ */
+export declare function fuenteDeEjecucion(backend: BackendQueEjecuta, 
+/** El aparato de la sesión, leído en CADA comando (IXCODE-32). Ausente = no hay ninguno elegido. */
+dispositivo?: () => DispositivoDeLaSesion | undefined): {
+    name: string;
+    id: string;
+    listTools: () => Promise<{
+        result: {
+            tools: {
+                name: string;
+                description: string;
+                inputSchema: {
+                    type: "object";
+                    properties: {
+                        command: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+                preload: boolean;
+            }[];
+        };
+        wasInitialized: undefined;
+    }>;
+    callTool: (params: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }) => Promise<import("@truefoundry/trueforge-core/core/mcp/IMCPServer.mjs").CallToolResolvedResponse>;
+    toolCallInfo: (params: {
+        name: string;
+    }) => Promise<{
+        type: "mcp";
+        mcp_server_id: string;
+        mcp_server_name: string;
+        original_tool_name: string;
+    }>;
+};
+export {};

package/dist/agent/motores/trueforge/toolsPropias.d.ts

@@ -0,0 +1,38 @@
+import { type EscritorDeDesalojo } from "./recortes.js";
+/** Lo que se usa de una tool de LangChain: su nombre, su descripción, su esquema y llamarla. */
+export interface ToolDeLangchain {
+    name: string;
+    description: string;
+    schema: unknown;
+    invoke(entrada: unknown): Promise<unknown>;
+}
+/** Un `ToolSource` de TrueForge con estas tools, llamadas tal cual. */
+export declare function fuenteDeLangchain(tools: readonly ToolDeLangchain[], backend: EscritorDeDesalojo): {
+    name: string;
+    id: string;
+    listTools: () => Promise<{
+        result: {
+            tools: {
+                name: string;
+                description: string;
+                inputSchema: {
+                    type: "object";
+                };
+                preload: boolean;
+            }[];
+        };
+        wasInitialized: undefined;
+    }>;
+    callTool: (params: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }) => Promise<import("@truefoundry/trueforge-core/core/mcp/IMCPServer.mjs").CallToolResolvedResponse>;
+    toolCallInfo: (params: {
+        name: string;
+    }) => Promise<{
+        type: "mcp";
+        mcp_server_id: string;
+        mcp_server_name: string;
+        original_tool_name: string;
+    }>;
+};

package/dist/agent/motores/trueforge/traerDeStitch.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import type { Artefacto } from "../../../core/artefactos.js";
+import type { ConectoresPort } from "../../../core/ports.js";
+export declare const NOMBRE_TRAER_DE_STITCH = "traer_pantalla_de_stitch";
+/** El id del conector en el catálogo: la tool solo se monta si la sesión lo tiene. */
+export declare const CONECTOR_STITCH = "stitch";
+/** Lo que devuelve una descarga: los bytes y el `content-type` que dijo el servidor. */
+export type Descargar = (url: string, tope: number) => Promise<{
+    bytes: Buffer;
+    tipo: string;
+}>;
+/** Tope de una descarga: una pantalla son cientos de KB. */
+export declare const TOPE_DE_DESCARGA_MS: number;
+/** La red de verdad: `fetch` con tope de tiempo y de tamaño (se corta al pasarse, no al acabar). */
+export declare const descargarEnRed: Descargar;
+export interface DependenciasDeTraerDeStitch {
+    conectores: ConectoresPort;
+    /** La carpeta de artefactos de la sesión, en disco. */
+    carpeta: string;
+    alEscribir?: (a: Artefacto) => void;
+    descargar?: Descargar;
+    /**
+     * Una TAREA (sin nadie delante): una pantalla nombrada que no aparece NO se sustituye por una parecida (decisión suya).
+     * Medido en Maset: «Menu Listado Entregas» no salía y el orquestador construyó la ventana con «Albaranes Pendientes».
+     */
+    sinPersona?: boolean;
+    /** Se pidió una pantalla por título y no casó ninguna: el harness lo apunta para el cierre (`## CRITICAL`). */
+    alNoEncontrar?: (titulo: string) => void;
+    /** Se trajo una pantalla: su título, para dar por resuelto lo que no se encontró antes con otras palabras. */
+    alTraer?: (titulo: string) => void;
+}
+export declare function crearTraerDeStitch(deps: DependenciasDeTraerDeStitch): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    pantalla: z.ZodOptional<z.ZodString>;
+    titulo: z.ZodOptional<z.ZodString>;
+    proyecto: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    pantalla?: string | undefined;
+    titulo?: string | undefined;
+    proyecto?: string | undefined;
+}, {
+    pantalla?: string | undefined;
+    titulo?: string | undefined;
+    proyecto?: string | undefined;
+}, string, unknown, "traer_pantalla_de_stitch">;
+/**
+ * Trae UNA pantalla por su `name` (`projects/<id>/screens/<id>`) a la carpeta de diseño de la sesión: la imagen a tamaño
+ * real, su code.html y el DESIGN.md. Es lo que hace la tool, y lo usa también el corredor de tareas para dejar puesta,
+ * ANTES del primer turno, la pantalla que la persona ELIGIÓ para la tarea (`Tarea.pantallaDeStitch`). Devuelve el texto
+ * para el agente; nunca lanza.
+ */
+export declare function traerPantalla(deps: DependenciasDeTraerDeStitch, nombre: string): Promise<string>;
+/** La marca de la pantalla ELEGIDA para la tarea, dentro de la carpeta de diseño de la sesión (la escribe el corredor). */
+export declare const MARCA_DE_PANTALLA_ELEGIDA = ".elegida.json";
+/** La pantalla elegida de esta sesión, o `undefined` (sin marca, o ilegible: entonces la tool busca como siempre). */
+export declare function pantallaElegidaDeLaSesion(carpeta: string): {
+    name: string;
+    titulo: string;
+} | undefined;
+/** Deja la marca: SIEMPRE, también si traerla falla (la tool la traerá por su id, y no buscará otra). */
+export declare function marcarPantallaElegida(carpeta: string, pantalla: {
+    name: string;
+    titulo: string;
+}): void;