xonecode 0.38.41 → 0.39.2

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

@@ -0,0 +1,48 @@
+/**
+ * Una nota escrita mientras el agente trabaja (IXCODE-4), con UN dueño.
+ *
+ * Se entregaba a CADA hilo como encargo, y eso se midió con una prueba real (MyAllXOne): «y créame
+ * un diagrama» llegó al analista, que lo dibujó, y al volver el orquestador la recibió igual de
+ * nueva y se lo encargó otra vez a `designer-xone` — el diagrama, dos veces. La regla ahora:
+ *
+ * - **Si trabaja UN solo hijo, la nota es suya**: la incorpora si le cabe en el encargo, y si no, la
+ *   devuelve como pendiente (`textoDeNotaParaHijo`).
+ * - **Con VARIOS en paralelo no es de ninguno**: dársela a uno sería una carrera, y a todos es el
+ *   bug de arriba. La decide el raíz al volver, como encargo.
+ * - **Sin hijos trabajando, es del raíz**, que es quien planifica.
+ * - **El raíz la ve SIEMPRE**, y si ya tenía dueño la ve como INFORMACIÓN: a quién se le pasó y que
+ *   no la vuelva a encargar (`textoDeNotaYaEntregada`).
+ * - Un hijo nacido cuando la nota ya tiene dueño —o ya la vio el raíz— no la recibe: el raíz la
+ *   tiene en cuenta al delegar.
+ *
+ * «Trabajan a la vez» = los hijos nacidos de la última llamada del raíz: mientras un hijo vive, el
+ * raíz espera su resultado y no llama al modelo (`detencion.ts#hijosVivos`). Un hijo EXTERNO no
+ * pasa por los procesadores, así que nunca se la queda: la recoge el raíz.
+ */
+export interface Nota {
+    texto: string;
+    /** `thread_id` de quien se la quedó como encargo. Ausente: todavía de nadie. */
+    duenio?: string;
+    vistaPorElRaiz: boolean;
+}
+export declare function crearNota(texto: string): Nota;
+/** Lo que hace falta saber del árbol en el momento de entregar. */
+export interface ContextoDeEntrega {
+    hiloRaiz: string;
+    /** Cuántos hijos trabajan a la vez ahora mismo. */
+    hijosVivos: number;
+    /** El nombre con que el raíz conoce a un hilo hijo (su especialista). */
+    nombreDe: (threadId: string) => string;
+}
+/** Para el raíz: lo que la persona le dijo. */
+export declare function textoDeNota(texto: string): string;
+/** Para un hijo: su interlocutor normal es quien le delegó, así que se dice que viene de fuera, y
+ *  se le da la salida si no es de su encargo. */
+export declare function textoDeNotaParaHijo(texto: string): string;
+/** Para el raíz, cuando la nota ya se la quedó un hijo. */
+export declare function textoDeNotaYaEntregada(texto: string, quien: string): string;
+/** Los textos que se le meten a ESE hilo antes de su llamada, marcando lo entregado. */
+export declare function entregarNotas(notas: readonly Nota[], threadId: string, ctx: ContextoDeEntrega): string[];
+/** Lo que NADIE se quedó, para mandarlo como el turno siguiente. `undefined` si no queda ninguna —
+ *  así el llamador no confunde "sin sobrantes" con una cadena vacía. */
+export declare function sobrantes(notas: readonly Nota[]): string | undefined;

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { NOMBRE_PROPONER_TAREAS, type PropuestaDeTareas } from "../../../core/repartoDeEncargo.js";
+export { NOMBRE_PROPONER_TAREAS };
+export declare function crearProponerTareas(proponer: (p: PropuestaDeTareas) => void): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    motivo: z.ZodString;
+    tareas: z.ZodArray<z.ZodObject<{
+        titulo: z.ZodString;
+        peticion: z.ZodString;
+        adjuntos: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, {
+    motivo: string;
+    tareas: {
+        titulo: string;
+        peticion: string;
+        adjuntos?: string[] | undefined;
+    }[];
+}, {
+    motivo: string;
+    tareas: {
+        titulo: string;
+        peticion: string;
+        adjuntos?: string[] | undefined;
+    }[];
+}, string, unknown, "proponer_tareas">;
+/**
+ * Lo que el raíz sabe de `proponer_tareas`, solo cuando la tiene. Preguntar ANTES es petición de la persona: la tarea no
+ * verá esta conversación, así que lo que falte en su encargo lo adivinaría.
+ */
+export declare const REPARTIR_EN_TAREAS: string;

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/sesionTrueforge.js

@@ -69,7 +69,7 @@ import { leerTareasDelPlan, RUTA_DE_TASKS } from "../../../core/tareasDelPlan.js
 import { casanConTitulo, esDeLaMaqueta } from "../../../core/stitch.js";
 import { recibeConectores } from "../../../core/conectores.js";
 import { crearConvertirAP, NOMBRE_CONVERTIR_A_P, recibeConvertirAP } from "./convertirAP.js";
-import { buscarMaqueta, medirContraMaqueta, resumenDeMedida, textoDeMedidaAutomatica, ultimaCaptura } from "./medidaAutomatica.js";
+import { buscarMaqueta, medirContraMaqueta, RONDAS_VISUALES, resumenDeMedida, textoDeMedidaAutomatica, ultimaCaptura } from "./medidaAutomatica.js";
 import { anotarEscritura, capacidadDeInformesDeHijos, esEscrituraBinaria, escrituraConExito, textoDelInforme } from "./informesDeHijos.js";
 import { crearDiagnosticoDeTools } from "../../turno/diagnosticoDeTools.js";
 import { encenderTrazaDeErrores } from "../../trazaDeErroresEnDisco.js";
@@ -145,6 +145,10 @@ export function textoDeMaquetadorExterno(nombres) {
         "diferencias de detalle van en tu resumen final, no en otra vuelta: cada vuelta suya empieza de cero. Si un recurso del",
         "diseñador está mal (proporción, color, un icono equivocado), díselo a él y que lo corrija en esa misma vuelta: puede escribir en",
         "`icons/`, y otra ronda diseñador → desarrollador cuesta dos arranques.",
+        "En su encargo NO nombres herramientas de xonecode (`comparar_capturas`, `xone_critica_visual`, `describe_image`,",
+        "`device-controller`…): corre en otro proceso y no las tiene, así que las busca o te devuelve que no pudo usarlas. El criterio",
+        "visual se lo das como QUÉ tiene que coincidir con la maqueta (su ruta), que él compara mirando la maqueta y su captura; esas",
+        "herramientas las pasas TÚ a su vuelta.",
     ].join("\n");
 }
 /**
@@ -325,7 +329,7 @@ export function textoDelBucle(llama, opciones = {}) {
         "  14`, display 14»). El de pruebas los hace, lee el log con `xone-log-android --app` y te devuelve cada caso: pasa o falla",
         "  con lo que salió. SIN capturas. Corrige todos los fallos juntos y repite solo los que fallaron.",
         "- VISUAL, solo cuando lo funcional pasa: UNA captura por ronda. Con ella el harness te trae la medida contra la maqueta;",
-        "  pasa el crítico, arregla TODAS las diferencias en la misma ronda y solo entonces pide otra captura. Tres rondas como mucho.",
+        `  pasa el crítico, arregla TODAS las diferencias en la misma ronda y solo entonces pide otra captura. ${String(RONDAS_VISUALES)} rondas como mucho.`,
         "- Una pantalla que se parece a la maqueta con datos de ejemplo fijos NO está terminada: la lógica tiene que funcionar.",
         "Lo que te devuelva es lo que ha visto, no un permiso para dar el trabajo por bueno: si dice que la app se cae, se cae.",
         "EMPIEZA POR LO MÍNIMO: no escribas la pantalla entera de una vez. Primero la versión más pequeña que se pueda VER y PULSAR",
@@ -362,11 +366,11 @@ export function textoDelBucle(llama, opciones = {}) {
                 "Lo que XOne NO puede reproducir no cuenta y no lo persigas: el desenfoque de fondo y las animaciones; una sombra o un",
                 "degradado se aproximan con un SVG. La TIPOGRAFÍA del diseño sí: si la maqueta declara una fuente, sus .ttf van a `fonts/`",
                 "(pídeselos a designer-xone con los recursos, o tráelos tú con `buscar_fuente`/`traer_fuente`) y se usa con `fontname`;",
-                "para verla en el aparato hay que DESPLEGAR entero. Tienes TRES vueltas de corregir y volver a comprobar para",
+                `para verla en el aparato hay que DESPLEGAR entero. Tienes ${String(RONDAS_VISUALES)} vueltas de corregir y volver a comprobar para`,
             ]
             : [
                 "Lo que XOne NO puede reproducir no cuenta y no lo persigas: las tipografías del diseño (no hay .ttf), el desenfoque de fondo y",
-                "las animaciones; una sombra o un degradado se aproximan con un SVG. Tienes TRES vueltas de corregir y volver a comprobar para",
+                `las animaciones; una sombra o un degradado se aproximan con un SVG. Tienes ${String(RONDAS_VISUALES)} vueltas de corregir y volver a comprobar para`,
             ]),
         "llegar; si al agotarlas algo",
         "sigue sin cumplirse, devuelve el trabajo diciendo QUÉ falta, con lo que midieron el crítico y la medida tal cual. Devolver antes",
@@ -377,6 +381,10 @@ export function textoDelBucle(llama, opciones = {}) {
 export function notaDeDelegacion(agentes, opciones = {}) {
     if (agentes.length === 0)
         return "";
+    const externos = agentes.filter((a) => a.motor === "claude-code" && a.ejecucion === true && !a.soloLectura).map((a) => a.nombre);
+    // Medido en Maset: con el desarrollador en Claude Code, el orquestador copiaba `comparar_capturas` y el crítico en el
+    // criterio de su encargo, y el hijo, que no los tiene, volvía diciendo que no pudo usarlos. Su criterio va sin tools.
+    const desarrolladorExterno = externos.includes("developer-xone");
     return [
         "NOTA DEL HARNESS: en este entorno NO existe la tool `task`. Se delega con `create_sub_agent`:",
         "`name` es EXACTAMENTE el nombre del especialista y `input` el encargo, autosuficiente —el",
@@ -385,10 +393,7 @@ export function notaDeDelegacion(agentes, opciones = {}) {
         ...agentes.map((a) => `- ${a.nombre}: ${fichaDeAgente(a, opciones)}`),
         ...(opciones.conComparacion === true ? ["", BUCLE_DE_CALIDAD] : []),
         // Si quien maqueta corre en Claude Code con su shell, el bucle es SUYO: el orquestador no lo repite encima.
-        ...(() => {
-            const externos = agentes.filter((a) => a.motor === "claude-code" && a.ejecucion === true && !a.soloLectura).map((a) => a.nombre);
-            return opciones.conComparacion === true && externos.length > 0 ? ["", textoDeMaquetadorExterno(externos)] : [];
-        })(),
+        ...(opciones.conComparacion === true && externos.length > 0 ? ["", textoDeMaquetadorExterno(externos)] : []),
         ...(opciones.conEsperas === true
             ? [
                 "",
@@ -401,16 +406,28 @@ export function notaDeDelegacion(agentes, opciones = {}) {
         ...(opciones.conBucle === true
             ? [
                 "",
-                "BUCLE DEL DESARROLLADOR: developer-xone prueba lo que escribe él mismo, llamando a device-controller (despliega, toca y lee",
-                "el log), maqueta y arregla lo visual él mismo —designer-xone solo le hace iconos y fondos SVG—, y corrige hasta cumplir el CRITERIO DE ACEPTACIÓN que le des. Por eso",
-                "cada encargo a developer-xone lleva el CRITERIO ESCRITO y MEDIBLE: qué casillas del plan tiene que dejar comprobadas, qué",
-                "tiene que hacer la app, y, si hay diseño, que la distancia de `comparar_capturas` quede por debajo del 10 % en vertical y en",
-                "horizontal, que ENCAJE en la pantalla (cada borde a un 3 % o menos del de la maqueta) y que el crítico no señale diferencias de forma o de estructura (di dónde está la maqueta). No se puede pedir",
+                ...(desarrolladorExterno
+                    ? [
+                        "BUCLE DEL DESARROLLADOR: developer-xone prueba lo que escribe él mismo con su shell (despliega, toca, captura y lee el",
+                        "log), maqueta y arregla lo visual él mismo —designer-xone solo le hace iconos y fondos SVG—, y corrige hasta cumplir el CRITERIO DE ACEPTACIÓN que le des. Por eso",
+                        "cada encargo a developer-xone lleva el CRITERIO ESCRITO y COMPROBABLE: qué casillas del plan tiene que dejar comprobadas, qué",
+                        "tiene que hacer la app, y, si hay diseño, que su captura coincida con la maqueta (di su ruta): ninguna pieza que falte,",
+                        "el mismo encaje en la pantalla, y sin diferencias de forma ni de estructura. Escrito así, sin nombres de herramientas. No se puede pedir",
+                    ]
+                    : [
+                        "BUCLE DEL DESARROLLADOR: developer-xone prueba lo que escribe él mismo, llamando a device-controller (despliega, toca y lee",
+                        "el log), maqueta y arregla lo visual él mismo —designer-xone solo le hace iconos y fondos SVG—, y corrige hasta cumplir el CRITERIO DE ACEPTACIÓN que le des. Por eso",
+                        "cada encargo a developer-xone lleva el CRITERIO ESCRITO y MEDIBLE: qué casillas del plan tiene que dejar comprobadas, qué",
+                        "tiene que hacer la app, y, si hay diseño, que la distancia de `comparar_capturas` quede por debajo del 10 % en vertical y en",
+                        "horizontal, que ENCAJE en la pantalla (cada borde a un 3 % o menos del de la maqueta) y que el crítico no señale diferencias de forma o de estructura (di dónde está la maqueta). No se puede pedir",
+                    ]),
                 opciones.conFuentes === true
                     ? "lo que XOne no reproduce —el desenfoque de fondo, las animaciones—; la tipografía del diseño sí (sus .ttf a `fonts/`). Sin criterio, devolverá el"
                     : "lo que XOne no reproduce —las tipografías del diseño, el desenfoque de fondo, las animaciones—. Sin criterio, devolverá el",
-                "trabajo en cuanto funcione. No le encargues a device-controller comprobar SU",
-                "trabajo, ni a designer-xone lo visual de su pantalla (designer-xone no puede tocar un `.xne` ni el CSS): llama tú al diseñador",
+                desarrolladorExterno ? "trabajo en cuanto funcione." : "trabajo en cuanto funcione. No le encargues a device-controller comprobar SU",
+                desarrolladorExterno
+                    ? "No le encargues a designer-xone lo visual de su pantalla (designer-xone no puede tocar un `.xne` ni el CSS): llama tú al diseñador"
+                    : "trabajo, ni a designer-xone lo visual de su pantalla (designer-xone no puede tocar un `.xne` ni el CSS): llama tú al diseñador",
                 "para los RECURSOS que la pantalla necesite, antes del desarrollador. Lo que developer-xone te devuelva es lo que él vio y midió, no un veredicto: el juicio final es tuyo y del arnés.",
             ]
             : []),