xonecode 0.17.2 → 0.20.1

package/dist/agent/motores/trueforge/sesionTrueforge.js

@@ -23,7 +23,9 @@
  *   (`modeloExterno.ts`).
  * - NO: un presupuesto GLOBAL por turno (la suma de todos los hilos), que deepagents tampoco tiene.
  */
-import { readFileSync } from "node:fs";
+import { TOPE_DE_PREGUNTAS_CONTESTADAS_SOLAS, opcionRecomendada } from "../../../core/modoDeEscritura.js";
+import { claseDeTrabajo } from "../../../core/esfuerzo.js";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import winston from "winston";
 import { AgentThread, AgentThreadOrchestrator, EventType, NOOP_AGENT_TRACING, askUserQuestion, contextCompaction, dynamicSubAgents } from "./trueforge.js";
@@ -51,7 +53,9 @@ import { modeloParaTrueforge } from "./modeloLangchain.js";
 import { TOOLS_DE_LECTURA } from "./toolsDeFichero.js";
 import { topeAgotadoDe, traducirEvento } from "./eventosTrueforge.js";
 import { anuncioDeSkills } from "./skillsTrueforge.js";
-import { capabilitiesDe, capacidadDeFecha, capacidadDeFicheros, capacidadDeInstrucciones, capacidadDeNotas, capacidadDePropias, capacidadDeRecortes, capacidadesDelEspecialista, clasesDeTools, toolsDe, } from "./capacidades.js";
+import { capabilitiesDe, capacidadDeFecha, capacidadDeFicheros, capacidadDeAvisoDeVueltas, capacidadDeInstrucciones, capacidadDeNotas, capacidadDePropias, capacidadDeRecortes, capacidadesDelEspecialista, clasesDeTools, toolsDe, } from "./capacidades.js";
+import { buscarMaqueta, medirContraMaqueta, resumenDeMedida, textoDeMedidaAutomatica, ultimaCaptura } from "./medidaAutomatica.js";
+import { anotarEscritura, capacidadDeInformesDeHijos, escrituraConExito, textoDelInforme } from "./informesDeHijos.js";
 import { crearDiagnosticoDeTools } from "../../turno/diagnosticoDeTools.js";
 import { encenderTrazaDeErrores } from "../../trazaDeErroresEnDisco.js";
 import { anotarPaso } from "../../../core/trazaDeErrores.js";
@@ -59,28 +63,213 @@ import { entornoConDepuracion } from "../../turno/depuracion.js";
 import { detalleDe, parametrosDe } from "../../turno/resumenDeTool.js";
 import { apartarMemoria, cargarMemoria, fotoSaneada, guardarMemoria, textoDeMemoriaDescartada } from "./memoriaTrueforge.js";
 import { crearNota, sobrantes } from "./notas.js";
+import { crearMemoriaDeEspecialistas } from "./memoriaDeEspecialistas.js";
+import { crearEsperas } from "./esperas.js";
+import { conResumenSeguro } from "./resumenSeguro.js";
 import { crearControlDeDetencion, RESUMEN_DE_RELLENO } from "./detencion.js";
 import { crearNavegacionXone } from "../../grafo/navegacionXone.js";
 import { hechosDelProyectoDe } from "../../navegacion/hechosEnDisco.js";
 import { conHechosDelProyecto } from "../../../core/hechosDelProyecto.js";
 import { crearBusquedaRegex } from "../../grafo/busquedaRegex.js";
+import { crearBuscarIcono, recibeBuscarIcono } from "../../grafo/buscarIcono.js";
+import { crearGenerarFondoSvg, recibeGenerarFondo } from "../../grafo/generarFondoSvg.js";
 import { crearCopiarArtefacto } from "../../grafo/copiarArtefacto.js";
 import { crearMarcarCriteriosDelPlan } from "../../grafo/marcarCriteriosDelPlan.js";
 import { crearUnirSecciones } from "../../grafo/unirSecciones.js";
 import { crearIncorporarAdjunto, recibeIncorporarAdjunto } from "../../grafo/incorporarAdjunto.js";
 import { crearCriticaVisual } from "../../grafo/criticaVisual.js";
+import { crearCompararCapturas } from "../../grafo/compararCapturas.js";
+import { crearAtributosXone, NOMBRE_ATRIBUTOS_XONE } from "../../grafo/atributosXone.js";
+import { crearDiferenciaDeCapturas } from "../../grafo/diferenciaDeCapturas.js";
+import { crearLectorDeReferencias } from "../../grafo/lectorDeReferencias.js";
 import { crearTraerDeLaMaquina } from "../../grafo/traerDeLaMaquina.js";
 import { invocarVisualConModelos } from "../../dispositivos/juezVisual.js";
 import { estilosDeDisco, indiceEnDisco } from "../../navegacion/indiceEnDisco.js";
 /** El hilo raíz de TrueForge. Se llama así en la librería y no se elige. */
 const HILO_RAIZ = "main";
+/**
+ * **Ser fiel a un diseño es parte del encargo, y se comprueba con números Y con ojos.**
+ *
+ * Rehaciendo una calculadora de Stitch, el orquestador dio la pantalla por buena una y otra vez con
+ * el crítico en verde, porque corría SIN la maqueta: su verde significaba «nada roto» y no veía que
+ * faltaba la barra superior. Con la maqueta a mano (`/diseno/`, `/adjuntos/`), el bucle es este, y
+ * termina: una condición de parada de estructura y un tope de vueltas, porque sin tope un crítico
+ * y un agente pueden retocar para siempre.
+ */
+const BUCLE_DE_CALIDAD = [
+    "SI EL ENCARGO TRAE UN DISEÑO (una imagen en /diseno/, /adjuntos/ o /artefactos/), SER FIEL A ÉL es parte del",
+    "encargo, y se comprueba con números y con ojos. Tras cada cambio visual: pide al conductor una captura NATIVA",
+    "nueva y contrástala con `comparar_capturas` y con `xone_critica_visual`, pasando el diseño como `referencia` en las",
+    "dos. Sin referencia el crítico solo dice «nada roto», que no es «se parece». Si la estructura o el crítico señalan",
+    "diferencias con el diseño —piezas que faltan, tamaños, formas—, delega el arreglo en quien MAQUETA la pantalla (el que escribe su `.xne`, no el de los recursos) con esas diferencias concretas y",
+    "repite. Para cuando la distancia estructural baje del 10 % en vertical y en horizontal y el crítico no señale diferencias de forma con el diseño, o tras TRES vueltas, y",
+    "di lo que sigue faltando en vez de darlo por hecho.",
+].join("\n");
 /**
  * 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.
  */
-export function notaDeDelegacion(agentes) {
+/**
+ * **El idioma, dicho desde código**, al raíz y a cada especialista. Visto en la consola web (MyAllXOne): el texto entre
+ * herramientas y el razonamiento salían en inglés («Let me call…», «I'll start by reconnoitering…») con la persona
+ * escribiendo en español. Nuestros prompts están en español pero ninguno lo decía, y encima hay piezas internas en inglés
+ * que tiran de él: la identidad que añade TrueForge («You are the Agent…»), las descripciones de las tools y la costumbre
+ * de DeepSeek de razonar en inglés.
+ */
+export const IDIOMA_DE_LA_RESPUESTA = "IDIOMA: escribe SIEMPRE en español —lo que dices entre herramientas, tu razonamiento, tus encargos y tus respuestas—, " +
+    "aunque algunas instrucciones internas y las descripciones de las herramientas estén en inglés. El código, los nombres de " +
+    "ficheros, atributos y funciones, y las citas literales se quedan como son.";
+/** Lo que recibe el agente en modo autónomo cuando pregunta sin marcar ninguna opción como recomendada. */
+export const RESPUESTA_AUTONOMA_SIN_RECOMENDADA = "Modo autónomo: no hay nadie a quien preguntar. Decide tú con lo que dicen el encargo y el plan, sigue, y di en tu respuesta final qué elegiste y por qué.";
+/** Un comando que saca una captura de pantalla del aparato. */
+export const COMANDO_DE_CAPTURA = /xone-captura-android|xone-hotswap\s+shot\b|\bscreencap\b/;
+/** Con cuántas capturas de UN encargo se le avisa a quien ejecuta. */
+export const UMBRALES_DE_CAPTURAS = [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 function textoDeCapturas(capturas) {
+    return [
+        `LLEVAS ${String(capturas)} CAPTURAS en este encargo.`,
+        "Para un VALOR, un estado o una excepción no hace falta ninguna: `xone-log-android --app` (lo que la app escribió con",
+        "`console.log`), `getFields`, `elements` acotado y el log de errores lo dicen sin mirar la pantalla. Una captura es para lo VISUAL (algo cortado, tapado, del color o tamaño equivocado) y una por",
+        "cosa que compruebes, con `shot name=<qué pruebas>`. Si solo quieres saber si algo cambió, `diferencia_de_capturas`.",
+        "No repitas la misma pantalla: si la anterior ya lo decía, no hay nada nuevo que sacar.",
+    ].join("\n");
+}
+/** Con cuántas comprobaciones seguidas se le avisa a quien lleva un lazo. El primero es el «tres vueltas» del prompt. */
+export const UMBRALES_DE_VUELTAS = [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 function textoDeVueltas(vueltas) {
+    return [
+        `LLEVAS ${String(vueltas)} COMPROBACIONES SEGUIDAS con el aparato.`,
+        "Si el fallo de la última es de la MISMA FAMILIA que el anterior (la misma excepción, el mismo tipo de control), NO hagas otra",
+        "reescritura: (1) di la hipótesis en una frase, (2) pide al de pruebas UN experimento mínimo —un control, un evento— y lee",
+        "el resultado BRUTO del aparato, (3) con la causa confirmada, aplica el arreglo a TODOS los sitios parecidos de una vez.",
+        "Si tras eso el fallo sigue igual, devuelve el trabajo diciendo qué falta y qué mediste, en vez de otra vuelta.",
+    ].join("\n");
+}
+/**
+ * El hilo de un especialista que NO arrancó porque espera a otros: nace ya terminado, con la respuesta al orquestador
+ * ya escrita (`preComputedCompletion`), y la librería lo trata como cualquier hijo que acaba. No llama al modelo ni tiene
+ * tools: lo único que hace es contestar al que lo pidió.
+ */
+function hiloQueNoArranca(nombre, esperados, params, modelo, logger) {
+    const padre = params.parent;
+    const texto = `${nombre} NO HA ARRANCADO: espera a que termine ${esperados.join(", ")}, que sigue trabajando y produce lo que ${nombre} necesita. ` +
+        `Cuando ${esperados.join(", ")} te devuelva su informe, vuelve a llamar a ${nombre} con ese informe dentro del encargo.`;
+    return new AgentThread({
+        definition: { modelClient: modelo, iterationLimit: 1 },
+        threadId: params.threadId,
+        title: params.request.name,
+        parent: params.parent,
+        agentInfo: { type: "dynamic", ...params.request },
+        preComputedCompletion: {
+            type: "done",
+            output: { role: "assistant", content: texto },
+            send_to_parent: { role: "tool", tool_call_id: padre.tool_call_id ?? "", content: texto },
+        },
+        tracing: NOOP_AGENT_TRACING,
+        logger: logger,
+    });
+}
+/**
+ * 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 function textoDeLoQueDejaronLosEsperados(raiz, esperadas) {
+    let recursos = [];
+    try {
+        recursos = readdirSync(join(raiz, "icons")).filter((f) => /\.(svg|png|jpg|jpeg)$/i.test(f)).sort();
+    }
+    catch {
+        recursos = [];
+    }
+    let notas = [];
+    try {
+        notas = readdirSync(join(raiz, ".xonecode", "planes"))
+            .flatMap((p) => ["ASSETS.md"].filter((f) => existsSync(join(raiz, ".xonecode", "planes", p, f))).map((f) => `/planes/${p}/${f}`))
+            .sort();
+    }
+    catch {
+        notas = [];
+    }
+    return [
+        `Antes de ti han terminado ${esperadas.join(", ")}, que trabajaban a la vez o antes que tú.`,
+        ...(recursos.length === 0 ? [] : [`Lo que hay ahora en icons/ (${String(recursos.length)}): ${recursos.join(", ")}.`]),
+        ...(notas.length === 0 ? [] : [`Lo que dejó escrito para ti: ${notas.join(", ")}. Léelo antes de escribir.`]),
+        "USA los recursos que te sirvan por su nombre exacto, y si no vas a usar alguno, dilo al devolver el trabajo.",
+    ].join("\n");
+}
+/**
+ * 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 function textoDelBucle(llama, opciones = {}) {
+    const puedeDiseñar = llama.includes("designer-xone");
+    return [
+        `PUEDES LLAMAR A: ${llama.join(", ")}, con \`create_sub_agent\` (\`name\` exacto y \`input\` autosuficiente).`,
+        "Tu bucle es: escribe, llama al de pruebas para desplegar y comprobar, lee lo que te devuelve y corrige.",
+        "Dile QUÉ comprobar y qué esperas ver. No lo llames por cada línea que cambies: junta los cambios.",
+        "",
+        "PRUEBAS FUNCIONALES Y VISUALES, SEPARADAS Y EN ESTE ORDEN:",
+        "- Instrumenta tu código con `console.log(\"CALC tecla 8\")`, `console.log(\"CALC resultado \" + r)` en los puntos",
+        "  que deciden (tecla, expresión, resultado, error). Nunca `ui.showToast` ni `appData.writeConsoleString` para depurar:",
+        "  el aviso no deja rastro y el segundo es legacy y no llega al log de Android.",
+        "- FUNCIONAL: UN encargo con TODOS los casos, como acciones y lo que esperas («teclea 2 + 3 × 4 = → log `CALC resultado",
+        "  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.",
+        "- 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",
+        "—el arranque, el display y UN botón—, y pídele al de pruebas que la arranque y la toque. Solo cuando eso funcione, amplía",
+        "(el teclado, las funciones, el historial). Un fallo de arranque descubierto con la pantalla entera escrita cuesta reescribirla.",
+        ...(puedeDiseñar
+            ? [
+                "El LAYOUT y el CSS son TUYOS: si la pantalla se ve mal, lo arreglas tú, no se lo pasas a nadie ni lo devuelves al que te",
+                "encargó. `designer-xone` solo hace RECURSOS —iconos de una biblioteca y fondos SVG en `icons/`—: pídeselos juntos, con para",
+                "qué control, tamaño en píxeles y colores, y usa los nombres que te devuelva. No le pidas que toque el `.xne` ni el CSS: no puede.",
+                "Los recursos te llegan con una TABLA (fichero → control → atributo → tamaño → si lleva el símbolo dentro): úsala y no abras",
+                "los SVG para enterarte de lo que ya dice.",
+            ]
+            : []),
+        ...(opciones.conCritica === true
+            ? [
+                "",
+                "PARA JUZGAR UNA PANTALLA tienes `xone_critica_visual` (un modelo aparte mira la captura) y `comparar_capturas` (mide la",
+                "estructura contra la maqueta con números). Pídele al de pruebas una captura y que te diga su nombre; pásala con `pantalla` y,",
+                "si hay diseño (/diseno/ o un adjunto), como `referencia`. Lo que digan esas dos herramientas manda sobre tu impresión: no",
+                "lo descartes como «no fiable»; si no estás de acuerdo, dilo con el dato.",
+                "Cada vez que vuelva el de pruebas con una captura, el HARNESS te trae su medida contra la maqueta: no hace falta que",
+                "la pidas tú. El juicio es tuyo: con esa cifra y el crítico decides si sigues; no se lo devuelvas al que te encargó para que juzgue.",
+            ]
+            : []),
+        "",
+        "NO TERMINAS hasta que se cumpla el CRITERIO DE ACEPTACIÓN de tu encargo. Si el encargo no lo trae, es: (1) todas las casillas",
+        "de la tarea en el `TASKS.md` comprobadas, (2) la app arranca y hace lo que pide, y (3) con diseño, la distancia que mide",
+        "`comparar_capturas` por debajo del 10 % en vertical y en horizontal, que ENCAJE en la pantalla (cada borde del contenido a",
+        "un 3 % o menos del de la maqueta: que llegue a los lados y abajo como ella), y el crítico sin diferencias de forma ni de estructura.",
+        "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",
+        "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",
+        "porque «ya funciona» es dejar el trabajo a medias. Al devolver cuenta lo que se midió: el juicio final no es tuyo, y el arnés",
+        "lo revisa igual.",
+    ].join("\n");
+}
+export function notaDeDelegacion(agentes, opciones = {}) {
     if (agentes.length === 0)
         return "";
     return [
@@ -88,7 +277,38 @@ export function notaDeDelegacion(agentes) {
         "`name` es EXACTAMENTE el nombre del especialista y `input` el encargo, autosuficiente —el",
         "especialista no ve esta conversación—. Donde estas instrucciones dicen `task` o `subagent_type`,",
         "entiende `create_sub_agent` y `name`. Las fichas de los especialistas:",
-        ...agentes.map((a) => `- ${a.nombre}: ${fichaDeAgente(a)}`),
+        ...agentes.map((a) => `- ${a.nombre}: ${fichaDeAgente(a, opciones)}`),
+        ...(opciones.conComparacion === true ? ["", BUCLE_DE_CALIDAD] : []),
+        ...(opciones.conEsperas === true
+            ? [
+                "",
+                "ESPERAS ENTRE ESPECIALISTAS: developer-xone NO arranca mientras designer-xone esté trabajando (lo que el diseñador produce",
+                "—los recursos de `icons/`— lo necesita el `.xne`). Si los lanzas a la vez, la llamada al desarrollador te vuelve AL INSTANTE",
+                "diciendo que no ha arrancado; cuando el diseñador te devuelva su informe, llama de nuevo al desarrollador con ESE INFORME dentro",
+                "del encargo: su TABLA de recursos (fichero → control → atributo → tamaño) TAL CUAL, no un resumen, y no revises tú los SVG. Lo más simple es lanzar primero al diseñador y, con su informe, al desarrollador.",
+            ]
+            : []),
+        ...(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",
+                "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",
+                "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.",
+            ]
+            : []),
+        ...(opciones.conMemoria === true
+            ? [
+                "",
+                "MEMORIA DE LOS ESPECIALISTAS: en esta sesión cada especialista RECUERDA sus encargos anteriores (lo que leyó,",
+                "lo que descubrió y lo que hizo). Al volver a llamar a uno, dale solo lo NUEVO: no repitas lo que ya sabe.",
+            ]
+            : []),
     ].join("\n");
 }
 /** Lo que cada clase NO puede hacer, que la lista de tools no dice sola. */
@@ -101,6 +321,14 @@ const LIMITES_DE = {
  * 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 const USO_DE_XONE_ATRIBUTOS = "Para saber si un atributo XML existe en un nodo (coll, group, frame, prop) y qué hace, pregunta PRIMERO a `xone_atributos`: " +
+    "contesta en una línea desde las tablas de la skill. Lee la referencia de la skill solo si no lo encuentra, o si necesitas ejemplos o matices.";
 export function notaDeTools(nombres, limite) {
     return `NOTA DEL HARNESS: aunque tu identidad diga lo contrario, NO tienes las mismas tools que quien te delega. Tienes ${nombres
         .map((n) => `\`${n}\``)
@@ -175,7 +403,9 @@ export async function abrirSesionTrueforge(opciones) {
      * parámetro solo sirve para doblarla—, que es lo que evita dejarla escrita y sin montar.
      */
     const entornoDeDiagnostico = entornoConDepuracion(opciones.depurar === true);
-    const diagnostico = opciones.diagnostico ?? crearDiagnosticoDeTools(raiz, entornoDeDiagnostico);
+    // El CHAT es la sesión con la que se abrió (`opciones.hilo`, el id del índice), no el `hilo` de
+    // ahora: `/nuevo` abre otro hilo huérfano pero los actos siguen yendo a la misma sesión.
+    const diagnostico = opciones.diagnostico ?? crearDiagnosticoDeTools(raiz, entornoDeDiagnostico, opciones.hilo);
     /**
      * La traza de EXCEPCIONES e HITOS, la MISMA de deepagents (`turnoReal.ts`) y que aquí
      * faltaba por completo: TrueForge nunca la encendía, ni siquiera con la variable de entorno
@@ -201,6 +431,36 @@ export async function abrirSesionTrueforge(opciones) {
      * viaja por el cable como nombre de un especialista tiene que serlo de verdad.
      */
     const especialistaDeHilo = new Map();
+    const conMemoriaDeEspecialistas = opciones.memoriaDeEspecialistas ?? process.env.XONECODE_SIN_MEMORIA_DE_ESPECIALISTAS !== "1";
+    // Encendido por omisión desde que se midió (calc9-calc15); `XONECODE_BUCLE_DEL_DEVELOPER=0` lo apaga para comparar.
+    const conBucleDelDesarrollador = opciones.bucleDelDesarrollador ?? process.env.XONECODE_BUCLE_DEL_DEVELOPER !== "0";
+    const conEsperas = opciones.esperasEntreHijos ?? true;
+    /** Cuántas comprobaciones (llamadas a quien EJECUTA) lleva cada hilo que lleva un lazo. */
+    const vueltasDeCadaHilo = new Map();
+    /** Cuántas CAPTURAS ha sacado cada hilo que ejecuta comandos (`xone-captura-android`, `xone-hotswap shot`). */
+    const capturasDeCadaHilo = new Map();
+    /** Lo que escribió cada hijo en su encargo, quién lo llamó, y los informes que esperan a ese padre (`informesDeHijos.ts`). */
+    const escritosDeCadaHilo = new Map();
+    const padreDeHilo = new Map();
+    const informesPendientes = new Map();
+    /** Las escrituras pedidas y aún sin respuesta, por hilo e id: la respuesta de una aprobada llega en OTRO `paso`. */
+    const escriturasEnVuelo = new Map();
+    /** Para la medida automática (`medidaAutomatica.ts`): cuándo nació cada hilo, su última escritura, su última crítica y la última medida que recibió. */
+    const nacimientoDeHilo = new Map();
+    const ultimaEscrituraDeHilo = new Map();
+    const ultimaCriticaDeHilo = new Map();
+    const ultimaMedidaDeHilo = new Map();
+    /** Cuántas rondas VISUALES lleva cada hilo: una por medida automática recibida (`RONDAS_VISUALES`). */
+    const rondasVisualesDeHilo = new Map();
+    const capacidadDeInformes = capacidadDeInformesDeHijos((hiloPadre) => {
+        const textos = informesPendientes.get(hiloPadre) ?? [];
+        informesPendientes.delete(hiloPadre);
+        return textos;
+    });
+    const esperas = crearEsperas();
+    const memoriaDeEspecialistas = crearMemoriaDeEspecialistas();
+    /** Los hijos con memoria que corren ahora: su hilo, para leer su historial al terminar. */
+    const hijosConMemoria = new Map();
     /** Lo que el agente dejó en `/artefactos/` y aún no se ha anunciado: un artefacto se escribe
      *  SIN aprobación, así que tiene que ANUNCIARSE, como en deepagents. */
     const artefactosPorAnunciar = [];
@@ -302,21 +562,36 @@ export async function abrirSesionTrueforge(opciones) {
     const cargarEstilos = estilosDeDisco(raiz);
     const navegacion = () => crearNavegacionXone(cargarIndice, ficheros, cargarEstilos);
     const carpeta = opciones.artefactos;
+    const lectorDeReferencias = crearLectorDeReferencias({
+        raiz,
+        ...(carpeta === undefined ? {} : { artefactos: carpeta }),
+        ...(opciones.adjuntos === undefined ? {} : { adjuntos: opciones.adjuntos }),
+    });
+    /** El crítico y la medida, con las MISMAS piezas para quien las tenga: el raíz, y con el bucle encendido el desarrollador. */
+    const herramientasDeJuicio = () => carpeta === undefined
+        ? []
+        : [
+            crearCriticaVisual({
+                leerArtefacto: async (nombre) => readFileSync(join(carpeta, nombre)),
+                invocar: invocarVisualConModelos({ paraPapel: (p) => modelos.paraPapel(p) }),
+                // La maqueta casi nunca está en /artefactos/: la trae la persona (/adjuntos/) o vive en /diseno/.
+                leerReferencia: lectorDeReferencias,
+            }),
+            // Medir la estructura contra la maqueta: la otra mitad del crítico, con el raíz como él.
+            crearCompararCapturas({ leerArtefacto: async (nombre) => readFileSync(join(carpeta, nombre)), leerReferencia: lectorDeReferencias }),
+        ];
+    // ¿Existe este atributo en este nodo? A todos, como la navegación: es de lectura y contesta desde la skill del paquete.
+    const atributos = crearAtributosXone();
     const propiasDelRaiz = [
         navegacion(),
-        ...(carpeta === undefined
-            ? []
-            : [
-                crearCriticaVisual({
-                    leerArtefacto: async (nombre) => readFileSync(join(carpeta, nombre)),
-                    invocar: invocarVisualConModelos({ paraPapel: (p) => modelos.paraPapel(p) }),
-                }),
-                crearTraerDeLaMaquina({ carpeta, alEscribir: anotarArtefacto }),
-            ]),
+        atributos,
+        ...herramientasDeJuicio(),
+        ...(carpeta === undefined ? [] : [crearTraerDeLaMaquina({ carpeta, alEscribir: anotarArtefacto })]),
     ];
     const propiasDe = (agente) => [
         crearBusquedaRegex(backend),
         navegacion(),
+        atributos,
         ...(carpeta !== undefined && (agente.escribeEn ?? []).length > 0
             ? [crearCopiarArtefacto({ raiz, carpetaDeArtefactos: carpeta, perfil: agente })]
             : []),
@@ -328,8 +603,24 @@ export async function abrirSesionTrueforge(opciones) {
         ...(opciones.adjuntos !== undefined && recibeIncorporarAdjunto(agente)
             ? [crearIncorporarAdjunto({ raiz, carpetaDeAdjuntos: opciones.adjuntos, perfil: agente })]
             : []),
+        // Buscar un icono cuando faltan los assets (IXCODE-18), con el reparto de deepagents: a quien
+        // escribe el proyecto y solo con el puerto. Es de LECTURA: no entra en `requireApprovalForTools`.
+        ...(opciones.iconos !== undefined && recibeBuscarIcono(agente)
+            ? [crearBuscarIcono(opciones.iconos)]
+            : []),
+        // Fondos SVG: pura y sin red, sin puerto; a quien escribe el proyecto, como deepagents.
+        ...(recibeGenerarFondo(agente) ? [crearGenerarFondoSvg()] : []),
+        // ¿Cambió la zona tras el toque? Al conductor, que es quien saca las capturas: comprueba una
+        // ACCIÓN suya, no juzga la pantalla (eso sigue siendo del crítico y de `comparar_capturas`).
+        ...(carpeta !== undefined && agente.ejecucion === true
+            ? [crearDiferenciaDeCapturas({ leerArtefacto: async (nombre) => readFileSync(join(carpeta, nombre)) })]
+            : []),
         // Y marcar en el plan lo comprobado en el aparato, con el reparto de deepagents: a quien ejecuta.
         ...(agente.ejecucion === true ? [crearMarcarCriteriosDelPlan({ raiz })] : []),
+        // El BUCLE del desarrollador: quien puede llamar al de pruebas también tiene el crítico y la medida, para
+        // juzgar la pantalla con lo que el otro capture. El veredicto sigue siendo de un modelo aparte, no suyo, y el
+        // juez final del arnés revisa igual (`textoDelBucle`).
+        ...(conBucleDelDesarrollador && (agente.llama?.length ?? 0) > 0 ? herramientasDeJuicio() : []),
     ];
     /**
      * **Un cliente de modelo por papel, modelo y esfuerzo, que dura la SESIÓN** —hasta `/modelo`—, y
@@ -353,7 +644,13 @@ export async function abrirSesionTrueforge(opciones) {
         }
         return cliente;
     };
-    const llm = modeloParaTrueforge({ modelo: () => clienteDe("papel:trabajo:", () => modelos.paraPapel("trabajo")), senal: () => aborto?.signal });
+    // Lo que la librería pierde: el razonamiento de cada llamada, por tokens de salida, hasta que su evento llega.
+    const razonamientoPendiente = new Map();
+    const alRazonar = (salida, razonamiento) => {
+        razonamientoPendiente.set(salida, [...(razonamientoPendiente.get(salida) ?? []), razonamiento]);
+    };
+    const razonamientoDeSalida = (salida) => razonamientoPendiente.get(salida)?.shift();
+    const llm = modeloParaTrueforge({ modelo: () => clienteDe("papel:trabajo:", () => modelos.paraPapel("trabajo")), senal: () => aborto?.signal, alRazonar });
     /**
      * El hilo de un hijo EXTERNO: un `AgentThread` normal con UNA llamada, cuyo «modelo» es el
      * producto (`modeloExterno.ts`). Sin tools, sin capabilities y sin compactación: el bucle vive
@@ -400,8 +697,37 @@ export async function abrirSesionTrueforge(opciones) {
      * LECTURA y sin shell: un nombre inventado no tumba el turno ni se lleva la escritura.
      */
     const crearHijo = async (params) => {
-        const agente = especialistas().find((a) => a.nombre === params.request.name);
+        // Quién lo pide: el raíz, o un especialista que llama a otro. Un especialista solo puede llamar a los que su
+        // `.md` declara en `llama` y con el interruptor puesto; lo demás cae al ayudante genérico de solo lectura,
+        // el mismo de un nombre inventado, y se anota en la traza.
+        const quienPide = params.parent === undefined ? undefined : especialistaDeHilo.get(params.parent.thread_id ?? "");
+        const permitidos = quienPide === undefined ? undefined : (especialistas().find((a) => a.nombre === quienPide)?.llama ?? []);
+        const concedido = permitidos === undefined || (conBucleDelDesarrollador && permitidos.includes(params.request.name));
+        if (!concedido)
+            anotarPaso("trueforge.llamada", `${quienPide ?? "?"} pidió a ${params.request.name}: no está en su lista`)();
+        const agente = concedido ? especialistas().find((a) => a.nombre === params.request.name) : undefined;
+        // Cuenta una COMPROBACIÓN: quien lleva un lazo llamó a quien ejecuta. Es lo que dispara el aviso de vueltas.
+        if (concedido && agente?.ejecucion === true && params.parent !== undefined) {
+            const padre = params.parent.thread_id ?? "";
+            if (padre !== "")
+                vueltasDeCadaHilo.set(padre, (vueltasDeCadaHilo.get(padre) ?? 0) + 1);
+        }
+        // ¿Arranca? Un especialista que declara `espera` NO arranca mientras haya vivo —o anunciado por el mismo mensaje del
+        // orquestador— uno de esos: se le devuelve al instante diciéndolo, y el orquestador lo llama de nuevo con el informe del
+        // otro. No se espera bloqueando: bloqueaba a la librería, que no devuelve el control mientras un hilo no termine su
+        // paso, y una aprobación del otro hilo no se atendía (`esperas.ts`).
+        const debeEsperar = conEsperas && agente !== undefined ? esperas.vivos(agente.espera ?? [], params.threadId) : [];
+        if (agente !== undefined && debeEsperar.length > 0) {
+            anotarPaso("trueforge.espera", `${agente.nombre} no arranca: espera a ${debeEsperar.join(", ")}`)();
+            diagnostico?.memoria?.(agente.nombre, "arranca-sin", `espera a ${debeEsperar.join(", ")}`);
+            return hiloQueNoArranca(agente.nombre, debeEsperar, params, llm, logger);
+        }
         detencion.nacio(params.threadId);
+        esperas.nacio(agente?.nombre ?? params.request.name, params.threadId);
+        const hiloDelPadre = params.parent?.thread_id;
+        if (hiloDelPadre !== undefined && hiloDelPadre !== "")
+            padreDeHilo.set(params.threadId, hiloDelPadre);
+        nacimientoDeHilo.set(params.threadId, Date.now());
         quienEs.set(params.threadId, agente?.nombre ?? params.request.name);
         if (agente !== undefined)
             especialistaDeHilo.set(params.threadId, agente.nombre);
@@ -413,6 +739,13 @@ export async function abrirSesionTrueforge(opciones) {
             backend: backend,
             propias: propiasDe,
             notas: capacidadDeNotasDeLaSesion,
+            puedeLlamar: (a) => conBucleDelDesarrollador && (a.llama?.length ?? 0) > 0,
+            informes: capacidadDeInformes,
+            vueltas: (a) => a.ejecucion === true
+                ? capacidadDeAvisoDeVueltas({ vueltasDe: (hilo) => capturasDeCadaHilo.get(hilo) ?? 0, umbrales: UMBRALES_DE_CAPTURAS, texto: textoDeCapturas })
+                : conBucleDelDesarrollador && (a.llama?.length ?? 0) > 0
+                    ? capacidadDeAvisoDeVueltas({ vueltasDe: (hilo) => vueltasDeCadaHilo.get(hilo) ?? 0, umbrales: UMBRALES_DE_VUELTAS, texto: textoDeVueltas })
+                    : undefined,
             conShell: () => montarBackend({
                 entorno: entornoDeLaShellDelProyecto(raiz, opciones.artefactos),
                 // El MISMO patrón que ya usa `modeloParaTrueforge` un poco más arriba en este
@@ -422,20 +755,56 @@ export async function abrirSesionTrueforge(opciones) {
             }),
         });
         const nombres = toolsDe(piezas);
-        const nota = notaDeTools(nombres, agente === undefined ? LIMITE_DEL_GENERICO : LIMITES_DE[clase]);
+        const nota = [
+            notaDeTools(nombres, agente === undefined ? LIMITE_DEL_GENERICO : LIMITES_DE[clase]),
+            ...(nombres.includes(NOMBRE_ATRIBUTOS_XONE) ? [USO_DE_XONE_ATRIBUTOS] : []),
+        ].join("\n");
         const instrucciones = agente === undefined
-            ? `${nota} Contesta con lo que encuentres y dónde.`
-            : [promptDeAgente(agente, repartirSkills(agente, disponibles)), "", nota, anuncioDeSkills(agente, catalogo)]
+            ? `${IDIOMA_DE_LA_RESPUESTA}\n\n${nota} Contesta con lo que encuentres y dónde.`
+            : [
+                IDIOMA_DE_LA_RESPUESTA,
+                "",
+                promptDeAgente(agente, repartirSkills(agente, disponibles)),
+                "",
+                nota,
+                anuncioDeSkills(agente, catalogo),
+                ...(conBucleDelDesarrollador && (agente.llama?.length ?? 0) > 0 ? ["", textoDelBucle(agente.llama ?? [], { conCritica: carpeta !== undefined })] : []),
+            ]
                 .filter((l) => l !== undefined)
                 .join("\n")
                 .trimEnd();
         const papel = agente?.soloLectura === true ? "rapido" : "trabajo";
+        const claseDeEsfuerzo = agente === undefined ? undefined : claseDeTrabajo(agente);
+        // La memoria del especialista: su conversación anterior de ESTA sesión, si la hay y se puede usar.
+        const apertura = conMemoriaDeEspecialistas && agente !== undefined ? memoriaDeEspecialistas.abrir(agente.nombre, params.threadId) : undefined;
+        const previa = apertura !== undefined && "previa" in apertura ? apertura.previa : undefined;
+        if (agente !== undefined && apertura !== undefined) {
+            if (previa !== undefined)
+                diagnostico?.memoria?.(agente.nombre, "arranca-con", "historial de la sesión", previa.tokens);
+            else
+                diagnostico?.memoria?.(agente.nombre, "arranca-sin", "sin" in apertura ? apertura.sin : "primera");
+        }
+        // Si lo que esperaba ya terminó en esta conversación, sabe qué dejó (solo nombres, nunca contenido).
+        const esperado = conEsperas && agente !== undefined ? esperas.terminados(agente.espera ?? []) : [];
+        const avisoDeLoEsperado = esperado.length > 0 ? `${textoDeLoQueDejaronLosEsperados(raiz, esperado)}\n\n` : "";
+        const mensajesIniciales = previa === undefined
+            ? [{ role: "user", content: `${avisoDeLoEsperado}${params.request.input}` }]
+            : [
+                ...previa.mensajes,
+                {
+                    role: "user",
+                    content: "NUEVO ENCARGO. Ya trabajaste antes en esta sesión: lo de arriba es tu conversación anterior, con lo que leíste y decidiste. " +
+                        "No repitas lecturas de ficheros que no hayan cambiado.\n\n" +
+                        `${avisoDeLoEsperado}${params.request.input}`,
+                },
+            ];
         const definicionDelHijo = {
             modelClient: modeloParaTrueforge({
                 modelo: () => agente?.modelo === undefined
-                    ? clienteDe(`papel:${papel}:${agente?.esfuerzo ?? ""}`, () => modelos.paraPapel(papel, agente?.esfuerzo))
-                    : clienteDe(`modelo:${agente.modelo}:${agente.esfuerzo ?? ""}`, () => modelos.paraModelo(agente.modelo, agente.esfuerzo)),
+                    ? clienteDe(`papel:${papel}:${agente?.esfuerzo ?? ""}:${claseDeEsfuerzo ?? ""}:${agente?.pensamiento ?? ""}`, () => modelos.paraPapel(papel, agente?.esfuerzo, claseDeEsfuerzo, agente?.pensamiento))
+                    : clienteDe(`modelo:${agente.modelo}:${agente.esfuerzo ?? ""}:${claseDeEsfuerzo ?? ""}:${agente.pensamiento ?? ""}`, () => modelos.paraModelo(agente.modelo, agente.esfuerzo, claseDeEsfuerzo, agente.pensamiento)),
                 senal: () => aborto?.signal,
+                alRazonar,
                 soloTexto: () => (detencion.soloTexto(params.threadId) ? RESUMEN_DE_RELLENO : undefined),
                 corte: () => detencion.corte(params.threadId),
                 alTirarLlamadas: (n) => {
@@ -444,11 +813,11 @@ export async function abrirSesionTrueforge(opciones) {
                     anotarPaso("trueforge.detener", `${quienEs.get(params.threadId) ?? params.threadId}: ${n} tool call(s) tiradas`)();
                 },
             }),
-            messages: [{ role: "user", content: params.request.input }],
+            messages: mensajesIniciales,
             // Los topes MEDIDOS de deepagents: el conductor más, porque cada paso suyo es un comando.
             iterationLimit: agente?.ejecucion === true ? TOPE_DE_LLAMADAS_DEL_CONDUCTOR : TOPE_DE_LLAMADAS_DEL_ESPECIALISTA,
         };
-        return new AgentThread({
+        const hijo = new AgentThread({
             definition: definicionDelHijo,
             threadId: params.threadId,
             title: params.request.name,
@@ -473,6 +842,9 @@ export async function abrirSesionTrueforge(opciones) {
             tracing: NOOP_AGENT_TRACING,
             logger,
         });
+        if (agente !== undefined && apertura !== undefined)
+            hijosConMemoria.set(params.threadId, { nombre: agente.nombre, hilo: hijo, iniciales: mensajesIniciales });
+        return hijo;
     };
     /**
      * El árbol de hilos de UNA conversación. Se rehace con `nuevoHilo`, al reabrir una sesión
@@ -484,9 +856,13 @@ export async function abrirSesionTrueforge(opciones) {
     /** La pregunta del orquestador que espera respuesta: el siguiente mensaje la contesta. */
     let preguntaEnEspera;
     const nuevoOrquestador = (foto) => {
+        // Los hijos que corrían no pueden seguir; lo que aprendieron sí se queda.
+        memoriaDeEspecialistas.darPorMuertos();
+        esperas.darPorMuertos();
+        hijosConMemoria.clear();
         const definicion = {
             modelClient: llm,
-            instruction: [promptOrquestador(especialistas()), notaDeDelegacion(especialistas())].filter((l) => l !== "").join("\n\n"),
+            instruction: [IDIOMA_DE_LA_RESPUESTA, promptOrquestador(especialistas()), notaDeDelegacion(especialistas(), { conIconos: opciones.iconos !== undefined, conComparacion: carpeta !== undefined, conMemoria: conMemoriaDeEspecialistas, conBucle: conBucleDelDesarrollador, conEsperas })].filter((l) => l !== "").join("\n\n"),
             // Por TURNO, porque el raíz se rehace desde su foto al final de cada uno (ver `turno`).
             iterationLimit: LIMITE_DE_LLAMADAS_DEL_RAIZ,
         };
@@ -503,6 +879,7 @@ export async function abrirSesionTrueforge(opciones) {
                     capacidadDeRecortes(backend),
                     capacidadDeFecha(),
                     capacidadDeNotasDeLaSesion,
+                    capacidadDeInformes,
                 ]),
                 /**
                  * **La conversación se RESUME al mismo umbral que deepagents** (`UMBRAL_RESUMEN_TOKENS`):
@@ -511,7 +888,10 @@ export async function abrirSesionTrueforge(opciones) {
                  * instrucciones van en el prompt de sistema —aquí `instruction`, en un hijo su
                  * capability—, que no se compacta.
                  */
-                contextCompaction({ definition: definicion, compactionThresholdTokens: UMBRAL_RESUMEN_TOKENS }),
+                contextCompaction({
+                    definition: { ...definicion, modelClient: conResumenSeguro(definicion.modelClient, (t) => anotarPaso("trueforge.compactacion", t)()) },
+                    compactionThresholdTokens: UMBRAL_RESUMEN_TOKENS,
+                }),
                 // `ask_user_question`, SOLO en el raíz —la librería tampoco se la da a un hijo—: es el
                 // único que tiene a una persona delante.
                 askUserQuestion(),
@@ -572,6 +952,39 @@ export async function abrirSesionTrueforge(opciones) {
      * `thread_id`: mandarla al raíz no la contestaría —o la rechazaría por hilo desconocido—.
      * Por eso las tool calls se apuntan por hilo Y por id: dos hijos pueden repetir id.
      */
+    /**
+     * Cuando vuelve quien EJECUTA, la medida de su última captura contra la maqueta, para quien lo llamó
+     * (`medidaAutomatica.ts`). Sin carpeta de artefactos, sin maqueta o sin captura nueva, nada. Un fallo al abrir o
+     * decodificar se anota y no tumba el turno.
+     */
+    function medidaTrasProbar(deHilo, hiloPadre, quien) {
+        if (carpeta === undefined || quien?.ejecucion !== true)
+            return undefined;
+        const maqueta = buscarMaqueta(raiz, opciones.adjuntos);
+        const captura = ultimaCaptura(carpeta, nacimientoDeHilo.get(deHilo) ?? Date.now());
+        if (maqueta === undefined || captura === undefined)
+            return undefined;
+        try {
+            const comparacion = medirContraMaqueta(join(carpeta, captura), maqueta.disco);
+            ultimaMedidaDeHilo.set(hiloPadre, resumenDeMedida(comparacion, captura));
+            const ronda = (rondasVisualesDeHilo.get(hiloPadre) ?? 0) + 1;
+            rondasVisualesDeHilo.set(hiloPadre, ronda);
+            const escribio = ultimaEscrituraDeHilo.get(hiloPadre);
+            const critico = ultimaCriticaDeHilo.get(hiloPadre);
+            return textoDeMedidaAutomatica({
+                quien: quien.nombre,
+                captura,
+                maqueta: maqueta.virtual,
+                comparacion,
+                pedirCritica: critico === undefined || (escribio !== undefined && escribio > critico),
+                ronda,
+            });
+        }
+        catch (e) {
+            anotarPaso("trueforge.medida", `no se pudo medir ${captura}: ${e instanceof Error ? e.message : String(e)}`)();
+            return undefined;
+        }
+    }
     async function* paso(lote, senal, pendientes, preguntas = []) {
         for await (const _ of orquestador.send(lote))
             void _;
@@ -594,9 +1007,23 @@ export async function abrirSesionTrueforge(opciones) {
                             args = {};
                         }
                         llamadas.set(claveDe(deHilo, t.id), { nombre: t.function.name, args });
+                        if (t.function.name === "write_file" || t.function.name === "edit_file")
+                            escriturasEnVuelo.set(claveDe(deHilo, t.id), { nombre: t.function.name, args });
+                        if (t.function.name === "xone_critica_visual")
+                            ultimaCriticaDeHilo.set(deHilo, Date.now());
                         // La traza: la MISMA lista blanca que el evento (`detalleDe`, `parametrosDe`), nunca
                         // los argumentos crudos.
-                        diagnostico?.herramienta(t.function.name, detalleDe(t.function.name, args), parametrosDe(t.function.name, args), tracker, deHilo === HILO_RAIZ ? "orquestador" : "especialista");
+                        const quien = quienEs.get(deHilo) ?? deHilo;
+                        diagnostico?.herramienta(t.function.name, detalleDe(t.function.name, args), parametrosDe(t.function.name, args), tracker, deHilo === HILO_RAIZ ? "orquestador" : "especialista", undefined, quien);
+                        // Una CAPTURA más de quien ejecuta: es lo que dispara el aviso de capturas (`textoDeCapturas`).
+                        if (t.function.name === "execute" && typeof args["command"] === "string" && COMANDO_DE_CAPTURA.test(args["command"])) {
+                            capturasDeCadaHilo.set(deHilo, (capturasDeCadaHilo.get(deHilo) ?? 0) + 1);
+                        }
+                        // Qué le pide el orquestador a quién: el encargo, acotado (ver `DiagnosticoDeTools.delegacion`).
+                        if (t.function.name === "create_sub_agent" && typeof args["name"] === "string" && typeof args["input"] === "string") {
+                            diagnostico?.delegacion?.(quien, args["name"], args["input"]);
+                            esperas.anunciar(args["name"]);
+                        }
                     }
                 }
             }
@@ -605,8 +1032,52 @@ export async function abrirSesionTrueforge(opciones) {
                 const llamada = llamadas.get(claveDe(deHilo, evento.tool_call_id));
                 const chars = typeof evento.content === "string" ? evento.content.length : 0;
                 diagnostico?.resultado?.(llamada?.nombre, llamada === undefined ? undefined : detalleDe(llamada.nombre, llamada.args), chars);
+                // Lo que ESCRIBIÓ este hilo, para decírselo a quien lo llamó al terminar (`informesDeHijos.ts`).
+                const escritura = escriturasEnVuelo.get(claveDe(deHilo, evento.tool_call_id));
+                if (escritura !== undefined) {
+                    escriturasEnVuelo.delete(claveDe(deHilo, evento.tool_call_id));
+                    if (deHilo !== HILO_RAIZ && escrituraConExito(evento.content)) {
+                        const cambios = escritosDeCadaHilo.get(deHilo) ?? new Map();
+                        anotarEscritura(cambios, escritura.nombre, escritura.args);
+                        escritosDeCadaHilo.set(deHilo, cambios);
+                        ultimaEscrituraDeHilo.set(deHilo, Date.now());
+                    }
+                }
             }
             // Un hilo que agotó su tope se ANOTA en la traza, con quién era: el raíz y cualquier hijo.
+            if (evento.type === "internal.agent.done") {
+                esperas.murio(deHilo);
+                const hiloPadre = padreDeHilo.get(deHilo);
+                // Lo que devolvió a quien lo llamó, a la traza (`DiagnosticoDeTools.devolucion`): la otra mitad del encargo.
+                const devuelto = evento.send_to_parent?.content;
+                if (hiloPadre !== undefined && devuelto !== undefined) {
+                    const texto = typeof devuelto === "string" ? devuelto : JSON.stringify(devuelto);
+                    diagnostico?.devolucion?.(quienEs.get(deHilo) ?? deHilo, quienEs.get(hiloPadre) ?? (hiloPadre === HILO_RAIZ ? "orquestador" : hiloPadre), texto);
+                }
+                if (hiloPadre !== undefined) {
+                    padreDeHilo.delete(deHilo);
+                    const nombre = especialistaDeHilo.get(deHilo);
+                    const quien = especialistas().find((a) => a.nombre === nombre);
+                    const medida = medidaTrasProbar(deHilo, hiloPadre, quien);
+                    const texto = medida ??
+                        textoDelInforme(quienEs.get(deHilo) ?? deHilo, escritosDeCadaHilo.get(deHilo) ?? new Map(), quien !== undefined && quien.motor === "modelo" && clasesDeTools(quien) === "escribe", ultimaMedidaDeHilo.get(deHilo));
+                    escritosDeCadaHilo.delete(deHilo);
+                    nacimientoDeHilo.delete(deHilo);
+                    if (texto !== undefined)
+                        informesPendientes.set(hiloPadre, [...(informesPendientes.get(hiloPadre) ?? []), texto]);
+                }
+                const h = hijosConMemoria.get(deHilo);
+                if (h !== undefined) {
+                    hijosConMemoria.delete(deHilo);
+                    const foto = h.hilo.toSnapshot();
+                    const tokens = (foto.current_context_usage?.prompt_tokens ?? 0) + (foto.current_context_usage?.completion_tokens ?? 0);
+                    const destino = memoriaDeEspecialistas.cerrar(deHilo, {
+                        // sin que nadie se lo haya pedido, así que no deja memoria (como uno que falló).
+                        bien: evento.status !== "error" && !detencion.soloTexto(deHilo), mensajes: [...h.iniciales, ...foto.context], tokens
+                    });
+                    diagnostico?.memoria?.(h.nombre, "cierra", destino, tokens);
+                }
+            }
             const tope = topeAgotadoDe(evento);
             if (tope !== undefined)
                 diagnostico?.corte?.(quienEs.get(deHilo) ?? deHilo, tope);
@@ -625,12 +1096,14 @@ export async function abrirSesionTrueforge(opciones) {
                 if (deHilo === HILO_RAIZ && evento.type === "internal.agent.context.append")
                     tracker.contexto = uso.input;
                 // Por ORIGEN, como deepagents: el orquestador y cada especialista por su nombre.
+                const razonado = uso.razonamiento ?? razonamientoDeSalida(uso.output);
                 diagnostico?.modelo(quienEs.get(deHilo) ?? deHilo, {
                     input: uso.input,
                     output: uso.output,
                     cache: uso.cache,
                     llamadas: tracker.calls,
                     contexto: uso.input,
+                    ...(razonado === undefined ? {} : { razonamiento: razonado }),
                 });
                 avisar();
             }
@@ -684,6 +1157,7 @@ export async function abrirSesionTrueforge(opciones) {
             const memoriaDescartada = avisoDeMemoria;
             avisoDeMemoria = undefined;
             let cortadoPorTope = false;
+            let preguntasSolas = 0;
             let sinResolver = 0;
             // El veredicto del turno, con las MISMAS reglas que deepagents (`verificacion.ts`).
             let veredicto = "no-corrio";
@@ -709,6 +1183,36 @@ export async function abrirSesionTrueforge(opciones) {
                     const preguntas = [];
                     yield* paso(lote, senal, pendientes, preguntas);
                     if (pendientes.length === 0) {
+                        /**
+                         * **En modo autónomo no se le pregunta a nadie**, y se dice en el chat. Una pregunta con una opción
+                         * `(Recommended)` se contesta con ella; una sin recomendada vuelve al agente pidiéndole que decida él y diga
+                         * qué eligió. Era «todas o ninguna»: medido en MyAllXOne, el orquestador hizo DOS a la vez —una con
+                         * recomendada, la otra no— y no se contestó ninguna, se enseñó solo la primera y la segunda se perdió. Con
+                         * tope, para que no dé vueltas.
+                         */
+                        if (preguntas.length > 0 && opciones.sinAprobacion?.() === true && preguntasSolas + preguntas.length <= TOPE_DE_PREGUNTAS_CONTESTADAS_SOLAS) {
+                            preguntasSolas += preguntas.length;
+                            const respuestas = [];
+                            for (const q of preguntas) {
+                                const { pregunta, opciones: posibles } = consultaDe(q.args);
+                                const elegida = opcionRecomendada(posibles);
+                                yield {
+                                    tipo: "aviso",
+                                    texto: elegida !== undefined
+                                        ? `modo autónomo: a «${pregunta}» contesto la recomendada: ${elegida}`
+                                        : `modo autónomo: «${pregunta}» no se pregunta; lo decide el agente y lo dirá`,
+                                    severidad: "aviso",
+                                };
+                                respuestas.push({
+                                    type: "user.tool_response",
+                                    thread_id: q.hilo,
+                                    tool_call_id: q.id,
+                                    content: elegida ?? RESPUESTA_AUTONOMA_SIN_RECOMENDADA,
+                                });
+                            }
+                            lote = respuestas;
+                            continue;
+                        }
                         // El orquestador PREGUNTA: el turno acaba aquí con la pregunta a la vista, y lo que la
                         // persona escriba después vuelve como la respuesta de esa tool (`turno`, arriba).
                         const pregunta = preguntas[0];
@@ -1102,6 +1606,21 @@ export async function abrirSesionTrueforge(opciones) {
         },
         nuevoHilo(id) {
             hilo = id ?? `tf-${Date.now()}`;
+            // Otra conversación: lo que los especialistas recordaban era de la anterior.
+            memoriaDeEspecialistas.olvidar();
+            esperas.olvidar();
+            vueltasDeCadaHilo.clear();
+            capturasDeCadaHilo.clear();
+            escritosDeCadaHilo.clear();
+            escriturasEnVuelo.clear();
+            nacimientoDeHilo.clear();
+            ultimaEscrituraDeHilo.clear();
+            ultimaCriticaDeHilo.clear();
+            ultimaMedidaDeHilo.clear();
+            rondasVisualesDeHilo.clear();
+            padreDeHilo.clear();
+            informesPendientes.clear();
+            hijosConMemoria.clear();
             // Un hilo NUEVO: lo que hubiera guardado con ese id no se pisa ni se carga a medias. Y una
             // pregunta de la conversación de antes no la contesta el primer mensaje de la nueva.
             const foto = fotoDeLaSesion(hilo);