xonecode 0.38.41 → 0.39.2

package/dist/agent/grafo/traerDeLaMaquina.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { type Artefacto } from "../../core/artefactos.js";
+/**
+ * Traer al área de trabajo un fichero que la PERSONA ha nombrado por su ruta.
+ *
+ * ## El caso, medido
+ *
+ * «Usa el diseño de `/Users/…/Downloads/stitch_calculadora.zip`». Esa ruta no es del proyecto,
+ * y las tools de fichero van confinadas a su raíz, así que el agente no podía abrirla: la
+ * resolvía DENTRO del proyecto, recibía un ENOENT que decía «no existe» sobre un fichero que
+ * sí existe, concluía que estaba enjaulado y se iba a delegar en el único especialista con
+ * shell para que lo copiara. Dieciocho pasos y un `unzip` para un fichero que le acababan de
+ * nombrar.
+ *
+ * ## Por qué COPIAR y no montar el disco
+ *
+ * La primera versión montaba la máquina entera bajo `/disco/`, de solo lectura. **Rompió un
+ * turno de producción**: con `/` dentro del `CompositeBackend`, toda operación recursiva sin
+ * ruta lo recorre — un `grep` sobre el PROYECTO tardaba 30 segundos y moría con
+ * `EPERM … scandir '/Volumes/com.apple.TimeMachine.localsnapshots'`.
+ *
+ * Y al mirarlo se vio que montar era más de lo que hacía falta. Lo que se necesita no es
+ * navegar el disco: es **traerse un fichero concreto**. Copiar tiene tres ventajas que el
+ * montaje no puede dar: no hay nada recursivo que se descontrole, lo traído queda en el área
+ * de trabajo —donde se ANUNCIA y se puede volver a leer—, y un BINARIO sobrevive: un `.zip` o
+ * un `.png` no aguantan un `read_file` + `write_file`, que son de TEXTO. Es el mismo reparto
+ * que `copiar_artefacto` y que el PDF: lo hace el harness porque el agente no puede.
+ *
+ * ## Las guardas
+ *
+ * 1. **Lo que se acepta es una lista BLANCA de forma** (`core/traerDeLaMaquina.ts`): una ruta
+ *    absoluta de verdad, y nada del propio harness —`auth.json` guarda las claves en claro y
+ *    cualquier `.xonecode/` lleva la conversación entera—.
+ * 2. **El DESTINO no se recibe**: lo deriva el código dentro de la carpeta de artefactos. Con
+ *    un destino por parámetro esto sería una forma de escribir donde se quisiera.
+ * 3. **Tope de tamaño**, porque el área de trabajo no es un almacén y un fichero enorme se
+ *    copia igual de callado que uno pequeño.
+ * 4. Y la ruta se comprueba **dos veces**, por TEXTO y por `realpath`, como en
+ *    `arbolDeProyecto.ts`: un enlace puede apuntar a otro sitio.
+ */
+export declare const NOMBRE_TRAER = "traer_de_la_maquina";
+export interface DependenciasDeTraida {
+    /** La carpeta de artefactos de la sesión. Sin ella no hay dónde dejarlo. */
+    carpeta?: string;
+    /**
+     * Para ANUNCIARLO, con el mismo evento que una escritura de artefacto.
+     *
+     * No es cosmético: lo traído cae en una carpeta que se escribe SIN aprobación, y la regla de
+     * este repo es que lo que nadie aprueba no puede ser además mudo. Sin esto, el fichero
+     * existiría en el disco y no existiría para nadie.
+     */
+    alEscribir?: (a: Artefacto) => void;
+}
+export declare function crearTraerDeLaMaquina(deps: DependenciasDeTraida): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    ruta: z.ZodString;
+}, z.core.$strip>, {
+    ruta: string;
+}, {
+    ruta: string;
+}, string, unknown, "traer_de_la_maquina">;

package/dist/agent/grafo/unirSecciones.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { type QuienDecidePermisos } from "./perfiles.js";
+export declare const NOMBRE_UNIR_SECCIONES = "unir_secciones";
+/** Topes: una carpeta con cientos de secciones o megas de texto no es un documento, es un error. */
+export declare const TOPE_DE_SECCIONES = 300;
+export declare const TOPE_DE_CARACTERES = 5000000;
+/** El documento que sale de una carpeta de secciones: la carpeta sin su barra final, más `.md`. */
+export declare function documentoDeCarpeta(carpeta: string): string;
+/** Los números de orden que llevan DOS o más secciones, con cuáles: `06 (06-a.md, 06-b.md)`. */
+export declare function numerosRepetidos(nombres: readonly string[]): string[];
+export declare function crearUnirSecciones(donde: {
+    raiz: string;
+    perfil: QuienDecidePermisos;
+}): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    carpeta: z.ZodString;
+}, z.core.$strip>, {
+    carpeta: string;
+}, {
+    carpeta: string;
+}, string, unknown, "unir_secciones">;

package/dist/agent/grafo/validacionXone.d.ts

@@ -0,0 +1,35 @@
+import type { HallazgoDeEscritura } from "../../core/validacionDeEscritura.js";
+/** Lo que esta guarda necesita saber hacer. Entra por parámetro: `npm test` no abre ficheros. */
+export type ValidarContenido = (ruta: string, contenido: string) => Promise<HallazgoDeEscritura[] | undefined>;
+/**
+ * El validador de PRODUCCIÓN, sobre `xone-linter`.
+ *
+ * **Devuelve `undefined` cuando no se pudo mirar**, que no es lo mismo que «no hay hallazgos» y
+ * por eso no es una lista vacía. Quien lo lea tiene que poder distinguir «esto está limpio» de
+ * «no sé»: lo primero deja escribir porque se comprobó, lo segundo deja escribir porque un fallo
+ * del ENTORNO no puede convertirse en un veredicto sobre el trabajo del agente. Es la misma
+ * frontera que `ErrorDelSimulador` frente a un informe en rojo.
+ */
+export declare function validarConXoneLinter(): ValidarContenido;
+/**
+ * Lo que un `edit` va a dejar en el fichero, o `undefined` si no se puede saber.
+ *
+ * **Se calcula aquí en vez de dejar escribir y mirar después**, porque mirar después obliga a
+ * deshacer, y deshacer es escribir dos veces en el proyecto del usuario — con la ventana en la
+ * que el fichero malo existe si el proceso se muere en medio.
+ *
+ * Y **cuando el reemplazo no es exacto se devuelve `undefined` y NO se juzga**: si `oldString`
+ * no aparece, o aparece varias veces sin `replaceAll`, deepagents va a rechazar el edit él
+ * mismo. Adivinar ahí sería validar un contenido que nunca va a existir.
+ */
+export declare function contenidoTrasEditar(actual: string, oldString: string, newString: string, replaceAll: boolean): string | undefined;
+/**
+ * Envuelve el backend para que un `write` o un `edit` que INTRODUZCA un problema no llegue a
+ * disco.
+ *
+ * Cuarta guarda del mismo Proxy que `sinVistasAplanadas`, `sinArtefactosEnElProyecto` y
+ * `sinDescargasEnElProyecto`, con su misma forma: **se DEVUELVE `{error}`, nunca se lanza**.
+ * deepagents devuelve ese error al modelo como resultado de la tool y puede reintentar; una
+ * excepción se lleva el turno por delante y el agente no reintenta.
+ */
+export declare function sinContenidoInvalido<T extends object>(backend: T, validar: ValidarContenido): T;

package/dist/agent/grafo/validarFicheroXone.d.ts

@@ -0,0 +1,33 @@
+import type { FilesystemBackend } from "deepagents";
+import { z } from "zod";
+/**
+ * `validar_fichero_xone`: ¿está bien este `.xne`, `.xml` (el `app.xml`), `.css` o `.js`? Una respuesta
+ * exacta en vez de leer el fichero a ojo. Cada extensión con su comprobador puro de `core/`:
+ * `comprobarXml` (bien formado), `comprobarCss` (estructura de la hoja, con la gramática de XOne) y
+ * `comprobarJs` (lo que lee Rhino, el motor de Android: `acorn` a ES2015 más la rodaja medida que le
+ * falta).
+ *
+ * Existe por un turno real (soporte de APPSalud): la persona pegó un error del parser de Studio
+ * («'name' is an unexpected token…, Line 381») y el agente, sin forma de comprobarlo, se pasó
+ * minutos releyendo un fichero que estaba BIEN —lo dijo a los dos minutos y no se lo creyó—.
+ *
+ * - **Sin llamar a nadie**: el comprobador es puro (`core/xmlBienFormado.ts`), ni simulador ni
+ *   linter ni red.
+ * - **Lee por el backend** (`readRaw`), así que hereda la codificación del fichero, las vistas
+ *   aplanadas y el resto de guardas; y **reaplica `puedeLeerRuta` a mano**, porque una tool de
+ *   LangChain añadida por xonecode no pasa por el middleware de permisos.
+ * - **Solo lectura**: no corrige nada. Y su descripción dice qué significa un «bien formado»
+ *   frente a un error que alguien ha visto: que ese error viene de OTRA copia del fichero.
+ */
+export declare const NOMBRE_VALIDAR_FICHERO_XONE = "validar_fichero_xone";
+/** Cuántos ficheros como mucho en una pasada sobre una carpeta. */
+export declare const TOPE_DE_FICHEROS_A_VALIDAR = 300;
+type BackendDeValidacion = Pick<FilesystemBackend, "glob" | "readRaw">;
+export declare function crearValidarFicheroXone(backend: BackendDeValidacion): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    path: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>, {
+    path: string;
+}, {
+    path?: string | undefined;
+}, string, unknown, "validar_fichero_xone">;
+export {};

package/dist/agent/grafo/xoneAgent.d.ts

@@ -0,0 +1,166 @@
+import { type Agente } from "../../core/agentes.js";
+import type { SubagenteExternoPort } from "../../core/ports.js";
+import type { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import type { Artefacto } from "../../core/artefactos.js";
+import { type QuienDecidePermisos } from "./perfiles.js";
+import { type CargarIndice } from "../navegacion/indiceEnDisco.js";
+import type { CargarEstilos } from "../navegacion/estilosEnDisco.js";
+import type { DiagnosticoDeTools } from "../turno/diagnosticoDeTools.js";
+import { type Calificador } from "../turno/rubrica.js";
+import { type AlContarTokens, type TokenTracker } from "../../vendor/tokenTracking.js";
+import type { IconosPort, SkillsPort, ModelosPort } from "../../core/ports.js";
+export interface OpcionesDelAgente {
+    raiz: string;
+    /** Todas las rutas del proyecto, para saber cuáles son vistas aplanadas. */
+    ficheros: ReadonlySet<string>;
+    /**
+     * Se avisa en cada llamada al modelo, DESPUÉS de que el tracker se actualice.
+     *
+     * No lleva el uso dentro a propósito: quien escucha tiene el tracker —es él quien lo
+     * pasó— y dos fuentes para el mismo número son dos números que divergen.
+     */
+    alContarTokens?: () => void;
+    /**
+     * Los subagentes, ya leídos de disco (`agent/subagentes/agentesEnDisco.ts`). Entran por parámetro y
+     * no se leen aquí por la misma razón que todo lo demás: quien construye el agente no
+     * toca el disco, y así un test puede montar los que quiera sin escribir ficheros.
+     *
+     * Puede venir VACÍO, y entonces el orquestador se queda sin nadie a quien delegar. No se
+     * rellena con los de serie a espaldas de nadie: si el usuario borró los cuatro, la
+     * consola tiene que decírselo, no fingir que siguen ahí.
+     */
+    agentes: readonly Agente[];
+    /**
+     * Quien lanza los agentes de otro producto (Claude Code). Puerto por lo de siempre:
+     * `npm test` no puede necesitar un binario instalado, y ni este fichero ni `turnoReal`
+     * pueden saber que Claude Code existe — la misma regla que con las tools de CloudStudio.
+     */
+    subagenteExterno: SubagenteExternoPort;
+    modelos: ModelosPort;
+    skills: SkillsPort;
+    /**
+     * De dónde sale el índice de navegación XOne. Ausente = el real, leyendo el proyecto con
+     * `xone-linter`. Entra por aquí para que un test pueda doblarlo sin proyecto en disco.
+     */
+    navegacion?: CargarIndice;
+    /** El resolvedor de estilos. Ausente, el de disco sobre `raiz`. Doblable como el índice. */
+    estilos?: CargarEstilos;
+    /**
+     * De dónde salen los iconos (IXCODE-18). Ausente = `buscar_icono` no se monta: una tool que
+     * siempre contestara «no hay red» sería un botón muerto en el prompt. Entra por parámetro porque
+     * toca la red (`core/ports.ts#IconosPort`).
+     */
+    iconos?: IconosPort;
+    /**
+     * Quién juzga si lo hecho cumple la rúbrica del encargo, si es que hay rúbrica.
+     *
+     * Ausente = no se monta el bucle, y ese es el caso normal. El middleware además no hace nada
+     * sin rúbrica en el estado, así que hay dos puertas y las dos son datos: quien no lo use no
+     * paga ni una llamada. Entra por parámetro porque llama a un modelo, y el invariante de
+     * `npm test` es que nada de eso haga falta para probar el harness.
+     */
+    calificador?: Calificador;
+    /** `BaseCheckpointSaver` y no `MemorySaver`: desde que hay uno persistente
+     *  (`agent/sesiones/checkpointer.ts`) el tipo tiene que ser el de la interfaz, no el del doble. */
+    checkpointer?: BaseCheckpointSaver;
+    /** Opcional porque no siempre se viene a contar gasto; sin él la barra de estado enseña 0. */
+    tracker?: TokenTracker;
+    /** Registro local opt-in de llamadas y uso; nunca llega al modelo. */
+    diagnostico?: DiagnosticoDeTools;
+    /**
+     * Dónde caen los artefactos de la sesión (`/artefactos/` para el agente). Es una carpeta
+     * de `.xonecode/`, o sea FUERA del proyecto: ver `core/artefactos.ts`. Ausente = no se
+     * monta la carpeta, y entonces un `write_file` a `/artefactos/…` es un fichero más del
+     * proyecto — que es lo que pasaba antes de que esto existiera.
+     */
+    artefactos?: {
+        carpeta: string;
+        alEscribir: (a: Artefacto) => void;
+    };
+    /**
+     * La carpeta de los ADJUNTOS de una tarea (`/adjuntos/` para el agente), de solo lectura.
+     * Es de `~/.xonecode/tareas/<id>/`, o sea fuera del proyecto: ver `core/adjuntos.ts`.
+     *
+     * Ausente = no se monta, que es el caso de toda sesión de persona y de toda tarea sin
+     * adjuntos. Entonces esa ruta no es nada, y lo que evita que un `write_file` a
+     * `/adjuntos/x` acabe siendo un fichero del proyecto es la denegación incondicional de
+     * `permisosDe` (medido: sin ella lo era).
+     */
+    adjuntos?: string;
+}
+/**
+ * El prompt del orquestador, GENERADO a partir de los subagentes que hay.
+ *
+ * Era una constante que nombraba a `docs`, `planner`, `dev` y `mockup` a pelo. Desde que los
+ * subagentes son ficheros que el usuario escribe y borra, eso se queda mintiendo el primer
+ * día: mandarle delegar en `mockup` cuando `mockup` no existe es la misma clase de botón
+ * muerto que este repo lleva semanas quitando de la interfaz.
+ *
+ * Lo que se conserva es lo GENERAL —no tienes tools, delega, encadena con handoff, no
+ * afirmes lo que no te han confirmado—, y lo específico sale de la propia lista. La línea
+ * del encadenado para diagramas solo se escribe si existen los dos agentes de los que
+ * habla: una instrucción sobre un especialista que no está no la puede seguir nadie.
+ */
+/**
+ * Quién es el orquestador a efectos de permisos: SOLO LECTURA.
+ *
+ * Es un `QuienDecidePermisos` y no un `Agente` porque el orquestador no es un especialista
+ * —no se puede dar de alta, ni borrar, ni editar desde Ajustes—, pero sus tools de fichero
+ * son las mismas y tienen que pasar por la misma función. Ver dónde se usa, en
+ * `construirAgente`, para el agujero que esto cierra.
+ */
+export declare const PERFIL_DEL_ORQUESTADOR: QuienDecidePermisos;
+export declare function promptOrquestador(agentes: readonly Agente[]): string;
+/**
+ * Indicaciones que el modelo recibe junto a las tools reales de fichero.
+ *
+ * No crean herramientas ni rebajan permisos: hacen explícito el destino correcto
+ * para que una skill no confunda su propia carpeta de instrucciones con la salida.
+ */
+/**
+ * **`read_file` NO está aquí, y es deliberado.**
+ *
+ * Una descripción propia REEMPLAZA la de la librería, no se suma a ella, así que la nuestra
+ * —que solo hablaba de coste— borraba tres cosas que deepagents ya dice y que no son nuestras
+ * de decir: que la salida lleva una cabecera de formato **que no hay que reinyectar al
+ * editar** (eso es CORRECCIÓN, no ahorro), que conviene pedir varias lecturas en una misma
+ * respuesta, y que un resultado grande se descarga a `/large_tool_results/` y se pagina desde
+ * ahí. Medido al comparar dos parches suyos: entre `1.13.2` y `1.13.5` ese formato CAMBIÓ
+ * —de prefijos de número de línea a una cabecera `@@ … @@`— y con él la advertencia. Una copia
+ * nuestra habría quedado describiendo un formato que ya no existe, sin un error que leer.
+ *
+ * La regla: lo que describe la TOOL es de la librería y se actualiza con ella; lo que decimos
+ * nosotros es cómo QUEREMOS usarla, y eso vive en el prompt del especialista
+ * (`core/agentes.ts#promptDeAgente`), donde no compite con nada.
+ */
+export declare const DESCRIPCIONES_FICHEROS: {
+    write_file: string;
+    edit_file: string;
+    grep: string;
+};
+export { OPCIONES_BUSQUEDA_FICHEROS } from "./opcionesDeFicheros.js";
+export declare function construirAgente(opciones: OpcionesDelAgente): Promise<unknown>;
+/**
+ * Rutas virtuales que SkillsMiddleware carga de forma progresiva para un agente.
+ *
+ * Recibe el AGENTE y no su nombre: antes buscaba el perfil en `PERFILES`, y con subagentes
+ * escritos por el usuario ese `Record` no tiene su entrada — `perfil.skills` habría
+ * reventado con «cannot read properties of undefined» en cuanto alguien creara el primero.
+ *
+ * Solo las que EXISTEN. Una ruta a una skill que no está haría que el middleware fallara al
+ * montarla; que falte se dice en el prompt (`promptDeAgente`), que es donde se puede leer.
+ */
+export declare function rutasDeSkills(agente: Agente, disponibles: ReadonlySet<string>): string[];
+/**
+ * Lo que se hace cada vez que el tracker cuenta: avisar a los DOS que lo esperan.
+ *
+ * **Extraída y exportada porque uno de los dos se cayó**, y en verde: el callback nació
+ * llamando solo al diagnóstico, así que el aviso de consumo tenía un único disparador —el
+ * de un agente EXTERNO— y una sesión normal subía sus tokens en silencio. Medido en la
+ * pantalla del usuario: el contador de la web no apareció nunca. Con la composición dentro
+ * de `construirAgente`, que todos sus tests doblan, no había dónde cazarlo.
+ *
+ * `alContarTokens` no lleva el uso dentro a propósito: quien escucha tiene el tracker —es
+ * él quien lo pasó— y dos fuentes para el mismo número son dos números que divergen.
+ */
+export declare function alContarDelTracker(origen: string, diagnostico?: DiagnosticoDeTools, alContarTokens?: () => void): AlContarTokens;

package/dist/agent/motores/motoresLocales.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Los motores locales en la máquina: medir si están y con qué sesión, PROBARLOS con un encargo de
+ * verdad, e iniciar la sesión de Claude Code desde un botón. Las reglas puras están en
+ * `core/motoresLocales.ts`; aquí solo hay procesos.
+ *
+ * Tres decisiones que no se ven en el código:
+ *
+ * - **Se mide el binario que el SDK LANZA**, el de su paquete de plataforma, y no el `claude` del
+ *   PATH: pueden ser versiones distintas (medido: 2.1.263 frente a 2.1.287), y medir el otro
+ *   diría algo de un programa que los subagentes no corren. Sin respaldo al PATH, a propósito.
+ * - **La prueba sale por el MISMO puerto que un encargo real** (`crearSubagenteExterno().correr`),
+ *   no por un `query()` montado aquí: una prueba con sus propias opciones mediría otra cosa —el
+ *   patrón de fallo de siempre, una composición que solo existe donde nadie la usa—.
+ * - **`auth login` funciona sin TTY** (medido con el binario del SDK y un `CLAUDE_CONFIG_DIR`
+ *   aislado): abre el navegador él solo, imprime un enlace de respaldo y espera «Paste code here
+ *   if prompted». Así que el botón lanza el proceso y, si la web enseña un código, se le pasa
+ *   por `stdin`. **El enlace no cruza el cable** (la regla de los conectores): si el navegador
+ *   no se abrió, lo vuelve a abrir el SERVIDOR. Límite declarado: por un túnel no sirve.
+ */
+import { type ChildProcess } from "node:child_process";
+import { type CaminoDePrueba, type EstadoDeMotorLocal } from "../../core/motoresLocales.js";
+import type { MotorExterno } from "../../core/ports.js";
+/** `--version` y `auth status`: si tardan más, el binario no está bien. */
+export declare const TOPE_DE_MEDIDA_MS = 15000;
+/** Un primer arranque de Claude Code en frío tarda; dos minutos es «no contesta». */
+export declare const TOPE_DE_PRUEBA_MS = 120000;
+/** Lo que se espera a que la persona termine en el navegador. */
+export declare const TOPE_DE_LOGIN_MS: number;
+type Entorno = Readonly<Record<string, string | undefined>>;
+export interface Salida {
+    stdout: string;
+    stderr: string;
+}
+/** El proceso del login, con lo justo para doblarlo en un test. */
+export type ProcesoDeLogin = Pick<ChildProcess, "stdout" | "stderr" | "stdin" | "on" | "kill">;
+export interface DependenciasDeMotoresLocales {
+    /** Se llama tras cada cambio de la foto: quien lo monta emite el mensaje. */
+    alCambiar: () => void;
+    plataforma?: string;
+    entorno?: Entorno;
+    ahora?: () => Date;
+    binarioDeClaude?: () => string | undefined;
+    /** Un proceso corto. Rechaza con un código distinto de 0, como `execFile`. */
+    ejecutar?: (binario: string, args: readonly string[], opciones: {
+        timeout: number;
+        entorno: Entorno;
+    }) => Promise<Salida>;
+    lanzar?: (binario: string, args: readonly string[], opciones: {
+        entorno: Entorno;
+    }) => ProcesoDeLogin;
+    /** Un encargo de prueba al motor. Devuelve la respuesta; lanza si no la hay. */
+    probar?: (peticion: {
+        motor: MotorExterno;
+        camino: CaminoDePrueba;
+        entornoLimpio: Record<string, string>;
+        senal: AbortSignal;
+    }) => Promise<string>;
+    abrir?: (url: string) => void;
+    /** Abre una terminal del sistema con el comando. `false` si en este sistema no se sabe. */
+    abrirTerminal?: (binario: string, args: readonly string[], entorno: Entorno) => boolean;
+    /** El modelo elegido para un motor de `MOTORES_CON_MODELO`, leído en cada medida. */
+    leerModelo?: (motor: MotorExterno) => string | undefined;
+    /** Y guardarlo; `undefined` lo quita. Lanza si no se pudo escribir. */
+    guardarModelo?: (motor: MotorExterno, modelo: string | undefined) => void;
+}
+export interface ServicioDeMotoresLocales {
+    /** La última foto. Ausente hasta la primera medida. */
+    foto(): EstadoDeMotorLocal[] | undefined;
+    medir(): Promise<void>;
+    probar(motor: MotorExterno): Promise<void>;
+    /** `false` si no se puede (otro login en curso, o el motor no lo admite). */
+    iniciarSesion(motor: MotorExterno, modo: "claudeai" | "console"): boolean;
+    enviarCodigo(motor: MotorExterno, codigo: string): boolean;
+    cancelarSesion(motor: MotorExterno): boolean;
+    abrirNavegador(motor: MotorExterno): boolean;
+    abrirConsola(motor: MotorExterno): boolean;
+    /** `false` si el motor no admite modelo, el nombre no vale o no se pudo guardar. */
+    elegirModelo(motor: MotorExterno, modelo: string | undefined): boolean;
+}
+/**
+ * El `claude` del paquete de plataforma del SDK, con la MISMA regla con que lo busca el SDK
+ * (`sdk.mjs`): `@anthropic-ai/claude-agent-sdk-<plataforma>-<arquitectura>/claude[.exe]`, y en
+ * Linux las dos variantes de libc. Resuelto por el cargador de módulos, nunca contando `..`.
+ */
+export declare function binarioDeClaudeDelSdk(plataforma?: string, arquitectura?: string, resolver?: (id: string) => string): string | undefined;
+export declare function crearServicioDeMotoresLocales(deps: DependenciasDeMotoresLocales): ServicioDeMotoresLocales;
+export {};

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

@@ -0,0 +1,183 @@
+import type { Agente } from "../../../core/agentes.js";
+import type { DispositivoDeLaSesion } from "../../../core/dispositivoDeSesion.js";
+import { permisosDe } from "../../grafo/perfiles.js";
+import { type BackendDeFicheros, type ToolDeFichero } from "./toolsDeFichero.js";
+import { type ToolDeLangchain } from "./toolsPropias.js";
+import type { ClaseDeTool, ConectoresDeSesion } from "./toolsDeConectores.js";
+import { type EscritorDeDesalojo } from "./recortes.js";
+import { type Nota } from "./notas.js";
+import type { ControlDeDetencion } from "./detencion.js";
+/** Una pieza: la `AgentCapability` que se le da a TrueForge y las tools que añade. */
+export interface Capacidad {
+    nombre: string;
+    tools: readonly string[];
+    capability: Record<string, unknown>;
+}
+/** Las tools que NO piden aprobación: las de lectura, las propias y la shell del conductor. */
+export declare const SIN_APROBACION: {
+    enableTools: string[];
+    disableTools: never[];
+    preloadTools: never[];
+    requireApprovalForTools: never[];
+};
+/** Las que escriben PARAN el turno hasta que alguien decida, como el HITL de deepagents. */
+export declare const CON_APROBACION: {
+    enableTools: string[];
+    disableTools: never[];
+    preloadTools: never[];
+    requireApprovalForTools: ("read_file" | "ls" | "write_file" | "edit_file" | "glob" | "grep")[];
+};
+/** Las tools de FICHERO sobre nuestro backend, acotadas por `reglas`. */
+export declare function capacidadDeFicheros(opciones: {
+    backend: BackendDeFicheros;
+    reglas: ReturnType<typeof permisosDe>;
+    tools: readonly ToolDeFichero[];
+    conAprobacion: boolean;
+}): Capacidad;
+/**
+ * Las tools propias de xonecode (`xone_navegacion`, `regex_search`…), adaptadas.
+ *
+ * `conAprobacion`: las de ESTE conjunto que paran el turno como `write_file` —`incorporar_adjunto` y
+ * `traer_fuente` (`PROPIAS_QUE_ESCRIBEN`), que escriben el proyecto por su cuenta tras el «sí»—. Omitido
+ * es «ninguna», que es lo de siempre para las que solo leen.
+ */
+/** Las tools PROPIAS que escriben el proyecto por su cuenta, y por eso paran el turno a preguntar. */
+export declare const PROPIAS_QUE_ESCRIBEN: readonly string[];
+export declare function capacidadDePropias(tools: readonly ToolDeLangchain[], backend: EscritorDeDesalojo, conAprobacion?: readonly string[]): Capacidad;
+/**
+ * Las tools de los conectores MCP del proyecto, de UNA clase (`toolsDeConectores.ts`): las de
+ * lectura sin aprobación, y el resto con aprobación TODAS (`@all`), porque lo que el servidor no
+ * declara de lectura escribe en la cuenta de la persona. `tools` va vacío: sus nombres salen de la
+ * red al primer `listTools`, no al montar.
+ */
+export declare function capacidadDeConectores(conectores: ConectoresDeSesion, clase: ClaseDeTool, backend: EscritorDeDesalojo): Capacidad;
+/** `execute`: la shell del que la declara en su `.md`, y de nadie más. */
+export declare function capacidadDeEjecucion(conShell: {
+    execute(c: string): unknown;
+    write(ruta: string, contenido: string): unknown;
+}, dispositivo?: () => DispositivoDeLaSesion | undefined): Capacidad;
+/**
+ * El presupuesto de un PASO entero (`recortes.ts#recortarPaso`), que el recorte por resultado no
+ * ve: varias respuestas en paralelo que caben solas pero no juntas. No añade tools.
+ */
+export declare function capacidadDeRecortes(backend: EscritorDeDesalojo): Capacidad;
+/**
+ * Entrega lo que la sesión le deba a ESTE hilo mientras trabaja (IXCODE-4), por
+ * `preLLMProcessors` —corre antes de CADA llamada al modelo, en la raíz y en cada hijo por
+ * igual (`AgentThread.js:733-740`)—. No añade tools. `Nota`/`pendientesPara`/`marcarEntregada`
+ * viven en `notas.ts`, sin importar tipos internos de la librería: ni
+ * `PreLLMAgentContextProcessor` ni `AgentContextProcessorAppendContext` se reexportan desde su
+ * punto de entrada público.
+ *
+ * La orden de DETENER (`detencion.ts`) va por el MISMO procesador y no por otro: es la única
+ * pieza que corre antes de CADA llamada de cada hilo, y el control necesita contar las del raíz
+ * para saber de qué plan nació cada hijo.
+ */
+export declare function capacidadDeNotas(notas: Nota[], opciones?: {
+    detencion?: ControlDeDetencion;
+    /** El nombre con que el raíz conoce a un hijo, para decirle a QUIÉN se le pasó una nota. */
+    nombreDe?: (threadId: string) => string;
+    hiloRaiz?: string;
+}): Capacidad;
+/**
+ * `get_current_datetime` de la librería: la fecha en UTC, para que «hoy» o «hace tres días» no se
+ * lo invente el modelo. No da la zona horaria local, y no se le atribuye.
+ */
+export declare function capacidadDeFecha(): Capacidad;
+/**
+ * Lo que OpenUI tiene que saber de ESTE harness, y que su prompt no dice. Va en CÓDIGO —en el
+ * prompt de quien tiene la skill `openui-builder`— porque vale para cualquier usuario y el modelo
+ * no siempre abre un `SKILL.md` (la lección medida de `artifacts-builder`, ver `agentesEnDisco.ts`):
+ * el prompt de la librería le pide que emita el bloque en su RESPUESTA, y la de un especialista
+ * la lee el orquestador. Y «elige UNO» porque se midió lo contrario: un turno real escribió el
+ * mismo panel en `.html` y en `.openui`, pagando el caro además del barato. Lo demás —cuándo usarlo
+ * y cómo no fallar— vive en la skill, que el usuario puede copiar y editar como cualquier otra.
+ */
+export declare const REGLAS_DE_OPENUI: string;
+/** El nombre de la skill que TRAE OpenUI: quien la tiene recibe la tool que la skill necesita. */
+export { SKILL_DE_OPENUI } from "../../../core/agentes.js";
+/**
+ * OpenUI para quien tiene la skill `openui-builder`: la tool de la librería que carga sus
+ * instrucciones BAJO DEMANDA (unos 5.000 tokens que no viajan en cada llamada) y, al lado, las
+ * reglas del harness. **La skill explica y esto monta lo que la skill necesita**, igual que un
+ * builder del usuario: lo decide la skill que declara su `.md`, no el nombre de otra skill.
+ */
+export declare function capacidadDeOpenui(): Capacidad;
+/**
+ * Las instrucciones de un HIJO en su prompt de SISTEMA. La librería IGNORA el `instruction` de un
+ * hijo (`buildInstruction`, `!this.parent`): a su sistema solo llegan los `instructionBuilders`.
+ * En el primer mensaje, una compactación —que sustituye el contexto entero— se las llevaría.
+ */
+export declare function capacidadDeInstrucciones(texto: string): Capacidad;
+/** Las tools que suman unas piezas, en orden: de aquí sale la nota del hijo. */
+export declare function toolsDe(capacidades: readonly Capacidad[]): string[];
+/** Las `AgentCapability` que recibe TrueForge. */
+export declare function capabilitiesDe(capacidades: readonly Capacidad[]): Record<string, unknown>[];
+/**
+ * Qué CLASE de especialista es, por lo que declara su `.md` — la partición de deepagents
+ * (`perfiles.ts#toolsDe` y `montajeDeFicheros`):
+ * - quien EJECUTA: lectura + `execute`, y nada de escribir (la shell no pasa por los permisos,
+ *   así que el camino normal de tocar el proyecto sigue siendo el de la aprobación);
+ * - quien solo lee: las seis SIN aprobación, porque `permisosDe` lo confina a lo que no es el
+ *   proyecto —`/artefactos/` y `/planes/`, que es donde el analista deja su plan—: en deepagents
+ *   `hitlDe` le devuelve `{}` por lo mismo;
+ * - el resto: las seis, con `write_file`/`edit_file` pidiendo aprobación y `permisosDe` acotando
+ *   (`escribeEn` incluido).
+ */
+export declare function clasesDeTools(agente: Pick<Agente, "soloLectura" | "ejecucion">): "ejecuta" | "lee" | "escribe";
+/**
+ * `create_sub_agent` para un HIJO: la misma delegación que tiene el raíz, dada a quien su `.md` declara que puede
+ * llamar a otro (`llama`). La librería crea el nieto igual que cualquier hijo y su respuesta vuelve a quien lo
+ * llamó. El nombre no se restringe aquí —el esquema de la tool es un texto libre—: lo hace la fábrica de hijos de la
+ * sesión, que no concede a quien no está en su lista.
+ */
+export declare function capacidadDeSubagentes(): Capacidad;
+/**
+ * Avisa a quien lleva un LAZO (escribir, comprobar, corregir) de cuántas comprobaciones lleva, por
+ * `preLLMProcessors`: al llegar a cada umbral se le añade UN mensaje de usuario, y no otro más hasta el siguiente.
+ *
+ * Existe porque «tres vueltas» estaba solo en el prompt del desarrollador y una pasada real hizo seis llamadas al
+ * conductor: un texto no es un contador. Y el aviso no dice «para», dice «cambia de procedimiento»: repetir la
+ * misma familia de fallo con otra reescritura completa es lo que se vio (un control que falta, y al arreglarlo,
+ * otro), y lo que hay que hacer es aislar la causa, no cortar. No añade tools.
+ */
+export declare function capacidadDeAvisoDeVueltas(opciones: {
+    vueltasDe: (hilo: string) => number;
+    umbrales: readonly number[];
+    texto: (vueltas: number) => string;
+}): Capacidad;
+/** Lo que el backend y las tools de la sesión ponen para montar a un especialista. */
+export interface DependenciasDelEspecialista {
+    backend: BackendDeFicheros & EscritorDeDesalojo;
+    /** Las tools propias que le tocan a ESTE agente (el reparto vive en la sesión). */
+    propias: (agente: Agente) => readonly ToolDeLangchain[];
+    /** El backend CON shell, montado solo para quien ejecuta. */
+    conShell: () => {
+        execute(c: string): unknown;
+        write(ruta: string, contenido: string): unknown;
+    };
+    /** El aparato de la sesión para la guarda del `execute` (IXCODE-32). Ausente = ninguno elegido. */
+    dispositivo?: () => DispositivoDeLaSesion | undefined;
+    /** La cola de notas de la SESIÓN, ya envuelta: la misma instancia para todos los hijos. */
+    notas: Capacidad;
+    /** ¿Puede ESTE agente llamar a otros? Lo decide la sesión (su `.md` y el interruptor); ausente es que no. */
+    puedeLlamar?: (agente: Agente) => boolean;
+    /** El aviso de vueltas de ESTE agente, si lleva un lazo. Ausente es que no lo lleva. */
+    vueltas?: (agente: Agente) => Capacidad | undefined;
+    /** Lo que escribieron los hijos que ESTE agente llame (`informesDeHijos.ts`): solo para quien puede llamar. */
+    informes?: Capacidad;
+    /** Las tools de los conectores MCP que le tocan a ESTE agente (el reparto vive en la sesión). */
+    conectores?: (agente: Agente) => readonly Capacidad[];
+    /**
+     * Sin nadie a quien preguntar (una TAREA de fondo): sus escrituras LOCALES no paran el turno a pedir aprobación. Una
+     * aprobación solo se atiende cuando la librería devuelve el control, y medido en Maset las del diseñador esperaron
+     * todo lo que tardó el analista (un Claude Code de una sola llamada larga) aunque en una tarea se aprueban solas. Las
+     * guardas de ruta siguen enteras; las escrituras de los CONECTORES siguen parando (en una tarea se rechazan).
+     */
+    escribeSinPreguntar?: boolean;
+}
+/**
+ * Las piezas de un especialista —o del hijo genérico, si el nombre no es de ninguno—, sin sus
+ * instrucciones: esas se escriben con la lista de tools que salga de aquí.
+ */
+export declare function capacidadesDelEspecialista(agente: Agente | undefined, nombrePedido: string, deps: DependenciasDelEspecialista): Capacidad[];

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { NOMBRE_CONVERTIR_A_P } from "../../../core/convertirAP.js";
+import type { Agente } from "../../../core/agentes.js";
+export { NOMBRE_CONVERTIR_A_P };
+/**
+ * `convertir_a_p`: las medidas de una maqueta (px CSS) a la `p` de XOne (`core/convertirAP.ts` tiene el porqué y la
+ * cuenta). **Pura, de LECTURA y sin red**, solo en TrueForge, y a quien escribe el proyecto (la regla de dato de
+ * `buscar_icono`: el desarrollador y el diseñador).
+ *
+ * Los dos datos de la cuenta NO entran por parámetro salvo el ancho de la maqueta cuando su imagen no lo deja claro:
+ * el `resolution-width` se lee del `app.xml` de la RAÍZ, fijada al construir —como `xone_navegacion`, nunca una ruta
+ * que elija el modelo—, y el ancho de la maqueta, de la misma maqueta que mide el harness (`buscarMaqueta`). Un
+ * rechazo se DEVUELVE como texto, nunca se lanza.
+ */
+export declare const recibeConvertirAP: (agente: Agente) => boolean;
+export declare function crearConvertirAP(opciones: {
+    raiz: string;
+    artefactos?: string;
+    adjuntos?: string;
+}): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    medidas: z.ZodArray<z.ZodObject<{
+        nombre: z.ZodString;
+        px: z.ZodCoercedNumber<unknown>;
+    }, z.core.$strip>>;
+    ancho_maqueta: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>, {
+    medidas: {
+        nombre: string;
+        px: number;
+    }[];
+    ancho_maqueta?: number | undefined;
+}, {
+    medidas: {
+        nombre: string;
+        px: unknown;
+    }[];
+    ancho_maqueta?: unknown;
+}, string, unknown, "convertir_a_p">;