@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/workflows/contrato/validador.d.ts

@@ -0,0 +1,30 @@
+export interface ResultadoValidacion<T> {
+    valido: boolean;
+    /** El valor final, ya reparado si hizo falta. `null` si nunca llegó a validar. */
+    datos: T | null;
+    /** Reintentos GASTADOS pidiendo corrección (0 = valida a la primera). */
+    intentos: number;
+    /** true si Clean/Convert tuvieron que tocar algo en la ronda que validó. */
+    reparado: boolean;
+    /** Errores de la ÚLTIMA ronda. Ausente si `valido`. */
+    errores?: string[];
+}
+export interface OpcionesValidacion {
+    /** JSON Schema (typebox u objeto plano equivalente) declarado por el agente o la llamada. */
+    esquema: unknown;
+    textoInicial: string;
+    /** Reintentos ADICIONALES tras el primer intento (que no cuenta como reintento). */
+    maxReintentos: number;
+    /** Extrae el valor candidato de un texto de respuesta (JSON en prosa, fences...). */
+    extraer: (texto: string) => unknown | undefined;
+    /** Manda `mensaje` (el error concreto) a la sesión y devuelve el texto de la siguiente respuesta. */
+    pedirCorreccion: (mensaje: string) => Promise<string>;
+}
+/**
+ * Valida `textoInicial` contra `esquema`; si no valida, pide corrección hasta
+ * `maxReintentos` veces con el error CONCRETO de la ronda anterior. Devuelve
+ * el resultado de la última ronda — `valido: false` tras agotar los
+ * reintentos, nunca datos fabricados a partir de una salida rota.
+ */
+export declare function validarConReintentos<T>(opciones: OpcionesValidacion): Promise<ResultadoValidacion<T>>;
+//# sourceMappingURL=validador.d.ts.map

package/dist/core/workflows/contrato/validador.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validador.d.ts","sourceRoot":"","sources":["../../../../src/core/workflows/contrato/validador.ts"],"names":[],"mappings":"AAeA,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACrC,MAAM,EAAE,OAAO,CAAC;IAChB,mFAAkF;IAClF,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAChB,0EAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC;IACjB,6EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAC;IAClB,wDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IAClC,6FAA6F;IAC7F,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,oFAAoF;IACpF,aAAa,EAAE,MAAM,CAAC;IACtB,qFAAqF;IACrF,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAAC;IAChD,sGAAqG;IACrG,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACtD;AA2BD;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,CAAC,EAAE,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CA4B3G","sourcesContent":["/**\n * Si la salida de un subagente no valida contra su esquema, se REINTENTA con\n * el error concreto — nunca se devuelve la salida rota como si fuera buena\n * (esa es la garantía; ver la regla del proyecto sobre \"no pude\" vs \"no hay\").\n *\n * El bucle vive aquí, fuera de agent-runner.ts, para poder probarlo con\n * dobles puros (sin sesión real ni typebox real necesariamente): `extraer` y\n * `pedirCorreccion` son las únicas piezas inyectadas, y son justo las dos que\n * agent-runner.ts sustituye por la extracción real y por reenviar un mensaje\n * a la sesión del subagente.\n */\nimport type { TSchema } from \"typebox\";\nimport { comprobar, esEsquemaValido } from \"./esquema.ts\";\nimport { repararConEsquema } from \"./reparar-argumentos.ts\";\n\nexport interface ResultadoValidacion<T> {\n\tvalido: boolean;\n\t/** El valor final, ya reparado si hizo falta. `null` si nunca llegó a validar. */\n\tdatos: T | null;\n\t/** Reintentos GASTADOS pidiendo corrección (0 = valida a la primera). */\n\tintentos: number;\n\t/** true si Clean/Convert tuvieron que tocar algo en la ronda que validó. */\n\treparado: boolean;\n\t/** Errores de la ÚLTIMA ronda. Ausente si `valido`. */\n\terrores?: string[];\n}\n\nexport interface OpcionesValidacion {\n\t/** JSON Schema (typebox u objeto plano equivalente) declarado por el agente o la llamada. */\n\tesquema: unknown;\n\ttextoInicial: string;\n\t/** Reintentos ADICIONALES tras el primer intento (que no cuenta como reintento). */\n\tmaxReintentos: number;\n\t/** Extrae el valor candidato de un texto de respuesta (JSON en prosa, fences...). */\n\textraer: (texto: string) => unknown | undefined;\n\t/** Manda `mensaje` (el error concreto) a la sesión y devuelve el texto de la siguiente respuesta. */\n\tpedirCorreccion: (mensaje: string) => Promise<string>;\n}\n\nfunction mensajeDeError(errores: string[]): string {\n\treturn [\n\t\t\"La salida no cumple el formato pedido:\",\n\t\t...errores.map((e) => `- ${e}`),\n\t\t\"Corrígela y responde SOLO con la salida corregida en el formato pedido, nada más.\",\n\t].join(\"\\n\");\n}\n\ninterface Intento<T> {\n\tdatos: T | null;\n\treparado: boolean;\n\terrores: string[];\n}\n\nfunction intentar<T>(esquema: TSchema, texto: string, extraer: (texto: string) => unknown | undefined): Intento<T> {\n\tconst extraido = extraer(texto);\n\tif (extraido === undefined) {\n\t\treturn { datos: null, reparado: false, errores: [\"no se encontró una salida en formato JSON en la respuesta\"] };\n\t}\n\tconst { valor, reparado } = repararConEsquema(esquema, extraido);\n\tconst resultado = comprobar(esquema, valor);\n\tif (resultado.valida) return { datos: valor as T, reparado, errores: [] };\n\treturn { datos: null, reparado, errores: resultado.errores };\n}\n\n/**\n * Valida `textoInicial` contra `esquema`; si no valida, pide corrección hasta\n * `maxReintentos` veces con el error CONCRETO de la ronda anterior. Devuelve\n * el resultado de la última ronda — `valido: false` tras agotar los\n * reintentos, nunca datos fabricados a partir de una salida rota.\n */\nexport async function validarConReintentos<T>(opciones: OpcionesValidacion): Promise<ResultadoValidacion<T>> {\n\tif (!esEsquemaValido(opciones.esquema)) {\n\t\t// Un esquema declarado pero mal formado no es \"sin esquema\" (eso lo\n\t\t// decide el caller no llamando a esta función): es un contrato roto, y\n\t\t// fingir que valida sería peor que decir que no se pudo.\n\t\treturn {\n\t\t\tvalido: false,\n\t\t\tdatos: null,\n\t\t\tintentos: 0,\n\t\t\treparado: false,\n\t\t\terrores: [\"el esquema declarado no es un JSON Schema válido\"],\n\t\t};\n\t}\n\tconst esquema = opciones.esquema;\n\tlet intento = intentar<T>(esquema, opciones.textoInicial, opciones.extraer);\n\tlet intentos = 0;\n\twhile (intento.errores.length > 0 && intentos < opciones.maxReintentos) {\n\t\tintentos++;\n\t\tconst texto = await opciones.pedirCorreccion(mensajeDeError(intento.errores));\n\t\tintento = intentar<T>(esquema, texto, opciones.extraer);\n\t}\n\treturn {\n\t\tvalido: intento.errores.length === 0,\n\t\tdatos: intento.datos,\n\t\tintentos,\n\t\treparado: intento.reparado,\n\t\terrores: intento.errores.length > 0 ? intento.errores : undefined,\n\t};\n}\n"]}

package/dist/core/workflows/contrato/validador.js

@@ -0,0 +1,56 @@
+import { comprobar, esEsquemaValido } from "./esquema.js";
+import { repararConEsquema } from "./reparar-argumentos.js";
+function mensajeDeError(errores) {
+    return [
+        "La salida no cumple el formato pedido:",
+        ...errores.map((e) => `- ${e}`),
+        "Corrígela y responde SOLO con la salida corregida en el formato pedido, nada más.",
+    ].join("\n");
+}
+function intentar(esquema, texto, extraer) {
+    const extraido = extraer(texto);
+    if (extraido === undefined) {
+        return { datos: null, reparado: false, errores: ["no se encontró una salida en formato JSON en la respuesta"] };
+    }
+    const { valor, reparado } = repararConEsquema(esquema, extraido);
+    const resultado = comprobar(esquema, valor);
+    if (resultado.valida)
+        return { datos: valor, reparado, errores: [] };
+    return { datos: null, reparado, errores: resultado.errores };
+}
+/**
+ * Valida `textoInicial` contra `esquema`; si no valida, pide corrección hasta
+ * `maxReintentos` veces con el error CONCRETO de la ronda anterior. Devuelve
+ * el resultado de la última ronda — `valido: false` tras agotar los
+ * reintentos, nunca datos fabricados a partir de una salida rota.
+ */
+export async function validarConReintentos(opciones) {
+    if (!esEsquemaValido(opciones.esquema)) {
+        // Un esquema declarado pero mal formado no es "sin esquema" (eso lo
+        // decide el caller no llamando a esta función): es un contrato roto, y
+        // fingir que valida sería peor que decir que no se pudo.
+        return {
+            valido: false,
+            datos: null,
+            intentos: 0,
+            reparado: false,
+            errores: ["el esquema declarado no es un JSON Schema válido"],
+        };
+    }
+    const esquema = opciones.esquema;
+    let intento = intentar(esquema, opciones.textoInicial, opciones.extraer);
+    let intentos = 0;
+    while (intento.errores.length > 0 && intentos < opciones.maxReintentos) {
+        intentos++;
+        const texto = await opciones.pedirCorreccion(mensajeDeError(intento.errores));
+        intento = intentar(esquema, texto, opciones.extraer);
+    }
+    return {
+        valido: intento.errores.length === 0,
+        datos: intento.datos,
+        intentos,
+        reparado: intento.reparado,
+        errores: intento.errores.length > 0 ? intento.errores : undefined,
+    };
+}
+//# sourceMappingURL=validador.js.map

package/dist/core/workflows/contrato/validador.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validador.js","sourceRoot":"","sources":["../../../../src/core/workflows/contrato/validador.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AA0B5D,SAAS,cAAc,CAAC,OAAiB,EAAU;IAClD,OAAO;QACN,wCAAwC;QACxC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/B,qFAAmF;KACnF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAAA,CACb;AAQD,SAAS,QAAQ,CAAI,OAAgB,EAAE,KAAa,EAAE,OAA+C,EAAc;IAClH,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAChC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,4DAA2D,CAAC,EAAE,CAAC;IACjH,CAAC;IACD,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,iBAAiB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACjE,MAAM,SAAS,GAAG,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC5C,IAAI,SAAS,CAAC,MAAM;QAAE,OAAO,EAAE,KAAK,EAAE,KAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IAC1E,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,CAAC,OAAO,EAAE,CAAC;AAAA,CAC7D;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAI,QAA4B,EAAmC;IAC5G,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACxC,oEAAoE;QACpE,wEAAuE;QACvE,0DAAyD;QACzD,OAAO;YACN,MAAM,EAAE,KAAK;YACb,KAAK,EAAE,IAAI;YACX,QAAQ,EAAE,CAAC;YACX,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,CAAC,mDAAkD,CAAC;SAC7D,CAAC;IACH,CAAC;IACD,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;IACjC,IAAI,OAAO,GAAG,QAAQ,CAAI,OAAO,EAAE,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC5E,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,GAAG,QAAQ,CAAC,aAAa,EAAE,CAAC;QACxE,QAAQ,EAAE,CAAC;QACX,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,eAAe,CAAC,cAAc,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QAC9E,OAAO,GAAG,QAAQ,CAAI,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IACzD,CAAC;IACD,OAAO;QACN,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;QACpC,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,QAAQ;QACR,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;KACjE,CAAC;AAAA,CACF","sourcesContent":["/**\n * Si la salida de un subagente no valida contra su esquema, se REINTENTA con\n * el error concreto — nunca se devuelve la salida rota como si fuera buena\n * (esa es la garantía; ver la regla del proyecto sobre \"no pude\" vs \"no hay\").\n *\n * El bucle vive aquí, fuera de agent-runner.ts, para poder probarlo con\n * dobles puros (sin sesión real ni typebox real necesariamente): `extraer` y\n * `pedirCorreccion` son las únicas piezas inyectadas, y son justo las dos que\n * agent-runner.ts sustituye por la extracción real y por reenviar un mensaje\n * a la sesión del subagente.\n */\nimport type { TSchema } from \"typebox\";\nimport { comprobar, esEsquemaValido } from \"./esquema.ts\";\nimport { repararConEsquema } from \"./reparar-argumentos.ts\";\n\nexport interface ResultadoValidacion<T> {\n\tvalido: boolean;\n\t/** El valor final, ya reparado si hizo falta. `null` si nunca llegó a validar. */\n\tdatos: T | null;\n\t/** Reintentos GASTADOS pidiendo corrección (0 = valida a la primera). */\n\tintentos: number;\n\t/** true si Clean/Convert tuvieron que tocar algo en la ronda que validó. */\n\treparado: boolean;\n\t/** Errores de la ÚLTIMA ronda. Ausente si `valido`. */\n\terrores?: string[];\n}\n\nexport interface OpcionesValidacion {\n\t/** JSON Schema (typebox u objeto plano equivalente) declarado por el agente o la llamada. */\n\tesquema: unknown;\n\ttextoInicial: string;\n\t/** Reintentos ADICIONALES tras el primer intento (que no cuenta como reintento). */\n\tmaxReintentos: number;\n\t/** Extrae el valor candidato de un texto de respuesta (JSON en prosa, fences...). */\n\textraer: (texto: string) => unknown | undefined;\n\t/** Manda `mensaje` (el error concreto) a la sesión y devuelve el texto de la siguiente respuesta. */\n\tpedirCorreccion: (mensaje: string) => Promise<string>;\n}\n\nfunction mensajeDeError(errores: string[]): string {\n\treturn [\n\t\t\"La salida no cumple el formato pedido:\",\n\t\t...errores.map((e) => `- ${e}`),\n\t\t\"Corrígela y responde SOLO con la salida corregida en el formato pedido, nada más.\",\n\t].join(\"\\n\");\n}\n\ninterface Intento<T> {\n\tdatos: T | null;\n\treparado: boolean;\n\terrores: string[];\n}\n\nfunction intentar<T>(esquema: TSchema, texto: string, extraer: (texto: string) => unknown | undefined): Intento<T> {\n\tconst extraido = extraer(texto);\n\tif (extraido === undefined) {\n\t\treturn { datos: null, reparado: false, errores: [\"no se encontró una salida en formato JSON en la respuesta\"] };\n\t}\n\tconst { valor, reparado } = repararConEsquema(esquema, extraido);\n\tconst resultado = comprobar(esquema, valor);\n\tif (resultado.valida) return { datos: valor as T, reparado, errores: [] };\n\treturn { datos: null, reparado, errores: resultado.errores };\n}\n\n/**\n * Valida `textoInicial` contra `esquema`; si no valida, pide corrección hasta\n * `maxReintentos` veces con el error CONCRETO de la ronda anterior. Devuelve\n * el resultado de la última ronda — `valido: false` tras agotar los\n * reintentos, nunca datos fabricados a partir de una salida rota.\n */\nexport async function validarConReintentos<T>(opciones: OpcionesValidacion): Promise<ResultadoValidacion<T>> {\n\tif (!esEsquemaValido(opciones.esquema)) {\n\t\t// Un esquema declarado pero mal formado no es \"sin esquema\" (eso lo\n\t\t// decide el caller no llamando a esta función): es un contrato roto, y\n\t\t// fingir que valida sería peor que decir que no se pudo.\n\t\treturn {\n\t\t\tvalido: false,\n\t\t\tdatos: null,\n\t\t\tintentos: 0,\n\t\t\treparado: false,\n\t\t\terrores: [\"el esquema declarado no es un JSON Schema válido\"],\n\t\t};\n\t}\n\tconst esquema = opciones.esquema;\n\tlet intento = intentar<T>(esquema, opciones.textoInicial, opciones.extraer);\n\tlet intentos = 0;\n\twhile (intento.errores.length > 0 && intentos < opciones.maxReintentos) {\n\t\tintentos++;\n\t\tconst texto = await opciones.pedirCorreccion(mensajeDeError(intento.errores));\n\t\tintento = intentar<T>(esquema, texto, opciones.extraer);\n\t}\n\treturn {\n\t\tvalido: intento.errores.length === 0,\n\t\tdatos: intento.datos,\n\t\tintentos,\n\t\treparado: intento.reparado,\n\t\terrores: intento.errores.length > 0 ? intento.errores : undefined,\n\t};\n}\n"]}

package/dist/core/workflows/contrato/yield.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Entrega incremental de resultados de un subagente.
+ *
+ * La tool `yield` que un subagente puede llamar varias veces durante su turno
+ * — cada llamada entrega UN hallazgo, en cuanto se produce, en vez de que el
+ * llamador tenga que esperar a que el subagente termine del todo.
+ *
+ * Y el YIELD FINAL FORZADO: si el subagente se descarrila (error o timeout)
+ * DESPUÉS de haber entregado algo, ese algo se devuelve en vez de perderse.
+ * Lo conecta agent-runner.ts, en el catch de `runOnce` — ver la cabecera de
+ * ese fichero para el porqué de dónde vive el enganche.
+ *
+ * NO cubre el abort (`signal.aborted`): una cancelación explícita del caller
+ * sigue devolviendo `null` sin hallazgos, igual que hacía antes de este
+ * contrato para un run completo y válido — cancelar significa "para del
+ * todo", no "dame lo que tengas". Ver el guard en agent-runner.ts.
+ */
+import type { Static } from "typebox";
+import { Type } from "typebox";
+import type { ToolDefinition } from "../../extensions/types.ts";
+export interface HallazgoParcial {
+    /** Orden de entrega dentro del run (0-based). */
+    indice: number;
+    /** `Date.now()` en el momento EXACTO de la llamada — es lo que demuestra "según se produce". */
+    timestampMs: number;
+    etiqueta: string;
+    datos: unknown;
+    confianza?: number;
+}
+/** Buffer mutable de hallazgos de UN run de subagente. Vive en el closure de `runOnce`. */
+export declare class BufferDeHallazgos {
+    private hallazgos;
+    empujar(entrada: Omit<HallazgoParcial, "indice" | "timestampMs">): HallazgoParcial;
+    get longitud(): number;
+    todos(): HallazgoParcial[];
+}
+export declare const PARAMETROS_YIELD: Type.TObject<{
+    etiqueta: Type.TString;
+    datos: Type.TAny;
+    confianza: Type.TOptional<Type.TNumber>;
+}>;
+export type ParametrosYield = Static<typeof PARAMETROS_YIELD>;
+/**
+ * Crea la tool `yield` de un subagente.
+ *
+ * `onEntrega` se llama de forma SÍNCRONA, en cuanto el subagente hace la
+ * llamada — es lo que permite que el llamador reciba cada hallazgo EN CUANTO
+ * se produce, no todos juntos al terminar.
+ *
+ * `prepareArguments` repara argumentos mal formados (campo de más,
+ * `confianza` como cadena, `datos` doblemente serializado) antes de que la
+ * validación de la tool los rechace y le cueste un turno al subagente.
+ */
+export declare function crearHerramientaYield(opciones: {
+    buffer: BufferDeHallazgos;
+    onEntrega?: (hallazgo: HallazgoParcial) => void;
+}): ToolDefinition<typeof PARAMETROS_YIELD>;
+export interface ResultadoIncremental {
+    /** Marca que este resultado viene de un YIELD FINAL FORZADO, no de una respuesta final normal. */
+    parcial: true;
+    hallazgos: HallazgoParcial[];
+}
+/** Empaqueta el buffer como el resultado de un YIELD FINAL FORZADO (subagente descarrilado). */
+export declare function ensamblarResultadoIncremental(buffer: BufferDeHallazgos): ResultadoIncremental;
+//# sourceMappingURL=yield.d.ts.map

package/dist/core/workflows/contrato/yield.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yield.d.ts","sourceRoot":"","sources":["../../../../src/core/workflows/contrato/yield.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,KAAK,EAAmB,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAGjF,MAAM,WAAW,eAAe;IAC/B,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,mGAAgG;IAChG,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,2FAA2F;AAC3F,qBAAa,iBAAiB;IAC7B,OAAO,CAAC,SAAS,CAAyB;IAE1C,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,aAAa,CAAC,GAAG,eAAe,CAIjF;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,KAAK,IAAI,eAAe,EAAE,CAEzB;CACD;AAED,eAAO,MAAM,gBAAgB;;;;EAS5B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE9D;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE;IAC/C,MAAM,EAAE,iBAAiB,CAAC;IAC1B,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,CAAC;CAChD,GAAG,cAAc,CAAC,OAAO,gBAAgB,CAAC,CAyB1C;AAED,MAAM,WAAW,oBAAoB;IACpC,kGAAkG;IAClG,OAAO,EAAE,IAAI,CAAC;IACd,SAAS,EAAE,eAAe,EAAE,CAAC;CAC7B;AAED,gGAAgG;AAChG,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,iBAAiB,GAAG,oBAAoB,CAE7F","sourcesContent":["/**\n * Entrega incremental de resultados de un subagente.\n *\n * La tool `yield` que un subagente puede llamar varias veces durante su turno\n * — cada llamada entrega UN hallazgo, en cuanto se produce, en vez de que el\n * llamador tenga que esperar a que el subagente termine del todo.\n *\n * Y el YIELD FINAL FORZADO: si el subagente se descarrila (error o timeout)\n * DESPUÉS de haber entregado algo, ese algo se devuelve en vez de perderse.\n * Lo conecta agent-runner.ts, en el catch de `runOnce` — ver la cabecera de\n * ese fichero para el porqué de dónde vive el enganche.\n *\n * NO cubre el abort (`signal.aborted`): una cancelación explícita del caller\n * sigue devolviendo `null` sin hallazgos, igual que hacía antes de este\n * contrato para un run completo y válido — cancelar significa \"para del\n * todo\", no \"dame lo que tengas\". Ver el guard en agent-runner.ts.\n */\n\nimport type { Static } from \"typebox\";\nimport { Type } from \"typebox\";\nimport type { AgentToolResult, ToolDefinition } from \"../../extensions/types.ts\";\nimport { repararArgumentos } from \"./reparar-argumentos.ts\";\n\nexport interface HallazgoParcial {\n\t/** Orden de entrega dentro del run (0-based). */\n\tindice: number;\n\t/** `Date.now()` en el momento EXACTO de la llamada — es lo que demuestra \"según se produce\". */\n\ttimestampMs: number;\n\tetiqueta: string;\n\tdatos: unknown;\n\tconfianza?: number;\n}\n\n/** Buffer mutable de hallazgos de UN run de subagente. Vive en el closure de `runOnce`. */\nexport class BufferDeHallazgos {\n\tprivate hallazgos: HallazgoParcial[] = [];\n\n\tempujar(entrada: Omit<HallazgoParcial, \"indice\" | \"timestampMs\">): HallazgoParcial {\n\t\tconst hallazgo: HallazgoParcial = { ...entrada, indice: this.hallazgos.length, timestampMs: Date.now() };\n\t\tthis.hallazgos.push(hallazgo);\n\t\treturn hallazgo;\n\t}\n\n\tget longitud(): number {\n\t\treturn this.hallazgos.length;\n\t}\n\n\ttodos(): HallazgoParcial[] {\n\t\treturn [...this.hallazgos];\n\t}\n}\n\nexport const PARAMETROS_YIELD = Type.Object(\n\t{\n\t\tetiqueta: Type.String({ description: \"Nombre corto del hallazgo, p.ej. 'sql-injection-login.ts'.\" }),\n\t\tdatos: Type.Any({ description: \"El hallazgo en sí: cualquier JSON serializable (objeto, texto, lista...).\" }),\n\t\tconfianza: Type.Optional(\n\t\t\tType.Number({ minimum: 0, maximum: 1, description: \"Confianza del hallazgo, de 0 a 1. Opcional.\" }),\n\t\t),\n\t},\n\t{ additionalProperties: false },\n);\n\nexport type ParametrosYield = Static<typeof PARAMETROS_YIELD>;\n\n/**\n * Crea la tool `yield` de un subagente.\n *\n * `onEntrega` se llama de forma SÍNCRONA, en cuanto el subagente hace la\n * llamada — es lo que permite que el llamador reciba cada hallazgo EN CUANTO\n * se produce, no todos juntos al terminar.\n *\n * `prepareArguments` repara argumentos mal formados (campo de más,\n * `confianza` como cadena, `datos` doblemente serializado) antes de que la\n * validación de la tool los rechace y le cueste un turno al subagente.\n */\nexport function crearHerramientaYield(opciones: {\n\tbuffer: BufferDeHallazgos;\n\tonEntrega?: (hallazgo: HallazgoParcial) => void;\n}): ToolDefinition<typeof PARAMETROS_YIELD> {\n\treturn {\n\t\tname: \"yield\",\n\t\tlabel: \"Entregar hallazgo\",\n\t\tdescription:\n\t\t\t\"Entrega un resultado parcial EN CUANTO lo produces, sin esperar a terminar la tarea entera. Llámala una vez por cada hallazgo — el llamador los va recibiendo según los produces, no todos juntos al final. Si te quedas sin turnos o algo falla a mitad, lo que ya hayas entregado con yield no se pierde.\",\n\t\tpromptSnippet: \"yield: entrega un hallazgo parcial ahora mismo, sin esperar al final de la tarea\",\n\t\tpromptGuidelines: [\n\t\t\t\"Llama a yield en cuanto tengas UN hallazgo listo, no acumules varios para entregarlos de golpe al final.\",\n\t\t],\n\t\tparameters: PARAMETROS_YIELD,\n\t\tprepareArguments: repararArgumentos<ParametrosYield>(PARAMETROS_YIELD, [\"datos\"]),\n\t\tasync execute(_toolCallId, params: ParametrosYield): Promise<AgentToolResult<undefined>> {\n\t\t\tconst hallazgo = opciones.buffer.empujar({\n\t\t\t\tetiqueta: params.etiqueta,\n\t\t\t\tdatos: params.datos,\n\t\t\t\tconfianza: params.confianza,\n\t\t\t});\n\t\t\topciones.onEntrega?.(hallazgo);\n\t\t\treturn {\n\t\t\t\tdetails: undefined,\n\t\t\t\tcontent: [{ type: \"text\", text: `Hallazgo #${hallazgo.indice} (\"${hallazgo.etiqueta}\") entregado.` }],\n\t\t\t};\n\t\t},\n\t};\n}\n\nexport interface ResultadoIncremental {\n\t/** Marca que este resultado viene de un YIELD FINAL FORZADO, no de una respuesta final normal. */\n\tparcial: true;\n\thallazgos: HallazgoParcial[];\n}\n\n/** Empaqueta el buffer como el resultado de un YIELD FINAL FORZADO (subagente descarrilado). */\nexport function ensamblarResultadoIncremental(buffer: BufferDeHallazgos): ResultadoIncremental {\n\treturn { parcial: true, hallazgos: buffer.todos() };\n}\n"]}

package/dist/core/workflows/contrato/yield.js

@@ -0,0 +1,80 @@
+/**
+ * Entrega incremental de resultados de un subagente.
+ *
+ * La tool `yield` que un subagente puede llamar varias veces durante su turno
+ * — cada llamada entrega UN hallazgo, en cuanto se produce, en vez de que el
+ * llamador tenga que esperar a que el subagente termine del todo.
+ *
+ * Y el YIELD FINAL FORZADO: si el subagente se descarrila (error o timeout)
+ * DESPUÉS de haber entregado algo, ese algo se devuelve en vez de perderse.
+ * Lo conecta agent-runner.ts, en el catch de `runOnce` — ver la cabecera de
+ * ese fichero para el porqué de dónde vive el enganche.
+ *
+ * NO cubre el abort (`signal.aborted`): una cancelación explícita del caller
+ * sigue devolviendo `null` sin hallazgos, igual que hacía antes de este
+ * contrato para un run completo y válido — cancelar significa "para del
+ * todo", no "dame lo que tengas". Ver el guard en agent-runner.ts.
+ */
+import { Type } from "typebox";
+import { repararArgumentos } from "./reparar-argumentos.js";
+/** Buffer mutable de hallazgos de UN run de subagente. Vive en el closure de `runOnce`. */
+export class BufferDeHallazgos {
+    hallazgos = [];
+    empujar(entrada) {
+        const hallazgo = { ...entrada, indice: this.hallazgos.length, timestampMs: Date.now() };
+        this.hallazgos.push(hallazgo);
+        return hallazgo;
+    }
+    get longitud() {
+        return this.hallazgos.length;
+    }
+    todos() {
+        return [...this.hallazgos];
+    }
+}
+export const PARAMETROS_YIELD = Type.Object({
+    etiqueta: Type.String({ description: "Nombre corto del hallazgo, p.ej. 'sql-injection-login.ts'." }),
+    datos: Type.Any({ description: "El hallazgo en sí: cualquier JSON serializable (objeto, texto, lista...)." }),
+    confianza: Type.Optional(Type.Number({ minimum: 0, maximum: 1, description: "Confianza del hallazgo, de 0 a 1. Opcional." })),
+}, { additionalProperties: false });
+/**
+ * Crea la tool `yield` de un subagente.
+ *
+ * `onEntrega` se llama de forma SÍNCRONA, en cuanto el subagente hace la
+ * llamada — es lo que permite que el llamador reciba cada hallazgo EN CUANTO
+ * se produce, no todos juntos al terminar.
+ *
+ * `prepareArguments` repara argumentos mal formados (campo de más,
+ * `confianza` como cadena, `datos` doblemente serializado) antes de que la
+ * validación de la tool los rechace y le cueste un turno al subagente.
+ */
+export function crearHerramientaYield(opciones) {
+    return {
+        name: "yield",
+        label: "Entregar hallazgo",
+        description: "Entrega un resultado parcial EN CUANTO lo produces, sin esperar a terminar la tarea entera. Llámala una vez por cada hallazgo — el llamador los va recibiendo según los produces, no todos juntos al final. Si te quedas sin turnos o algo falla a mitad, lo que ya hayas entregado con yield no se pierde.",
+        promptSnippet: "yield: entrega un hallazgo parcial ahora mismo, sin esperar al final de la tarea",
+        promptGuidelines: [
+            "Llama a yield en cuanto tengas UN hallazgo listo, no acumules varios para entregarlos de golpe al final.",
+        ],
+        parameters: PARAMETROS_YIELD,
+        prepareArguments: repararArgumentos(PARAMETROS_YIELD, ["datos"]),
+        async execute(_toolCallId, params) {
+            const hallazgo = opciones.buffer.empujar({
+                etiqueta: params.etiqueta,
+                datos: params.datos,
+                confianza: params.confianza,
+            });
+            opciones.onEntrega?.(hallazgo);
+            return {
+                details: undefined,
+                content: [{ type: "text", text: `Hallazgo #${hallazgo.indice} ("${hallazgo.etiqueta}") entregado.` }],
+            };
+        },
+    };
+}
+/** Empaqueta el buffer como el resultado de un YIELD FINAL FORZADO (subagente descarrilado). */
+export function ensamblarResultadoIncremental(buffer) {
+    return { parcial: true, hallazgos: buffer.todos() };
+}
+//# sourceMappingURL=yield.js.map

package/dist/core/workflows/contrato/yield.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yield.js","sourceRoot":"","sources":["../../../../src/core/workflows/contrato/yield.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAY5D,2FAA2F;AAC3F,MAAM,OAAO,iBAAiB;IACrB,SAAS,GAAsB,EAAE,CAAC;IAE1C,OAAO,CAAC,OAAwD,EAAmB;QAClF,MAAM,QAAQ,GAAoB,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;QACzG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9B,OAAO,QAAQ,CAAC;IAAA,CAChB;IAED,IAAI,QAAQ,GAAW;QACtB,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;IAAA,CAC7B;IAED,KAAK,GAAsB;QAC1B,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;IAAA,CAC3B;CACD;AAED,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,CAAC,MAAM,CAC1C;IACC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,4DAA4D,EAAE,CAAC;IACpG,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,4EAA2E,EAAE,CAAC;IAC7G,SAAS,EAAE,IAAI,CAAC,QAAQ,CACvB,IAAI,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,6CAA6C,EAAE,CAAC,CACnG;CACD,EACD,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAC/B,CAAC;AAIF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAGrC,EAA2C;IAC3C,OAAO;QACN,IAAI,EAAE,OAAO;QACb,KAAK,EAAE,mBAAmB;QAC1B,WAAW,EACV,iTAA6S;QAC9S,aAAa,EAAE,kFAAkF;QACjG,gBAAgB,EAAE;YACjB,0GAA0G;SAC1G;QACD,UAAU,EAAE,gBAAgB;QAC5B,gBAAgB,EAAE,iBAAiB,CAAkB,gBAAgB,EAAE,CAAC,OAAO,CAAC,CAAC;QACjF,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,MAAuB,EAAuC;YACxF,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC;gBACxC,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,SAAS,EAAE,MAAM,CAAC,SAAS;aAC3B,CAAC,CAAC;YACH,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,CAAC,CAAC;YAC/B,OAAO;gBACN,OAAO,EAAE,SAAS;gBAClB,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,QAAQ,CAAC,MAAM,MAAM,QAAQ,CAAC,QAAQ,eAAe,EAAE,CAAC;aACrG,CAAC;QAAA,CACF;KACD,CAAC;AAAA,CACF;AAQD,gGAAgG;AAChG,MAAM,UAAU,6BAA6B,CAAC,MAAyB,EAAwB;IAC9F,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC;AAAA,CACpD","sourcesContent":["/**\n * Entrega incremental de resultados de un subagente.\n *\n * La tool `yield` que un subagente puede llamar varias veces durante su turno\n * — cada llamada entrega UN hallazgo, en cuanto se produce, en vez de que el\n * llamador tenga que esperar a que el subagente termine del todo.\n *\n * Y el YIELD FINAL FORZADO: si el subagente se descarrila (error o timeout)\n * DESPUÉS de haber entregado algo, ese algo se devuelve en vez de perderse.\n * Lo conecta agent-runner.ts, en el catch de `runOnce` — ver la cabecera de\n * ese fichero para el porqué de dónde vive el enganche.\n *\n * NO cubre el abort (`signal.aborted`): una cancelación explícita del caller\n * sigue devolviendo `null` sin hallazgos, igual que hacía antes de este\n * contrato para un run completo y válido — cancelar significa \"para del\n * todo\", no \"dame lo que tengas\". Ver el guard en agent-runner.ts.\n */\n\nimport type { Static } from \"typebox\";\nimport { Type } from \"typebox\";\nimport type { AgentToolResult, ToolDefinition } from \"../../extensions/types.ts\";\nimport { repararArgumentos } from \"./reparar-argumentos.ts\";\n\nexport interface HallazgoParcial {\n\t/** Orden de entrega dentro del run (0-based). */\n\tindice: number;\n\t/** `Date.now()` en el momento EXACTO de la llamada — es lo que demuestra \"según se produce\". */\n\ttimestampMs: number;\n\tetiqueta: string;\n\tdatos: unknown;\n\tconfianza?: number;\n}\n\n/** Buffer mutable de hallazgos de UN run de subagente. Vive en el closure de `runOnce`. */\nexport class BufferDeHallazgos {\n\tprivate hallazgos: HallazgoParcial[] = [];\n\n\tempujar(entrada: Omit<HallazgoParcial, \"indice\" | \"timestampMs\">): HallazgoParcial {\n\t\tconst hallazgo: HallazgoParcial = { ...entrada, indice: this.hallazgos.length, timestampMs: Date.now() };\n\t\tthis.hallazgos.push(hallazgo);\n\t\treturn hallazgo;\n\t}\n\n\tget longitud(): number {\n\t\treturn this.hallazgos.length;\n\t}\n\n\ttodos(): HallazgoParcial[] {\n\t\treturn [...this.hallazgos];\n\t}\n}\n\nexport const PARAMETROS_YIELD = Type.Object(\n\t{\n\t\tetiqueta: Type.String({ description: \"Nombre corto del hallazgo, p.ej. 'sql-injection-login.ts'.\" }),\n\t\tdatos: Type.Any({ description: \"El hallazgo en sí: cualquier JSON serializable (objeto, texto, lista...).\" }),\n\t\tconfianza: Type.Optional(\n\t\t\tType.Number({ minimum: 0, maximum: 1, description: \"Confianza del hallazgo, de 0 a 1. Opcional.\" }),\n\t\t),\n\t},\n\t{ additionalProperties: false },\n);\n\nexport type ParametrosYield = Static<typeof PARAMETROS_YIELD>;\n\n/**\n * Crea la tool `yield` de un subagente.\n *\n * `onEntrega` se llama de forma SÍNCRONA, en cuanto el subagente hace la\n * llamada — es lo que permite que el llamador reciba cada hallazgo EN CUANTO\n * se produce, no todos juntos al terminar.\n *\n * `prepareArguments` repara argumentos mal formados (campo de más,\n * `confianza` como cadena, `datos` doblemente serializado) antes de que la\n * validación de la tool los rechace y le cueste un turno al subagente.\n */\nexport function crearHerramientaYield(opciones: {\n\tbuffer: BufferDeHallazgos;\n\tonEntrega?: (hallazgo: HallazgoParcial) => void;\n}): ToolDefinition<typeof PARAMETROS_YIELD> {\n\treturn {\n\t\tname: \"yield\",\n\t\tlabel: \"Entregar hallazgo\",\n\t\tdescription:\n\t\t\t\"Entrega un resultado parcial EN CUANTO lo produces, sin esperar a terminar la tarea entera. Llámala una vez por cada hallazgo — el llamador los va recibiendo según los produces, no todos juntos al final. Si te quedas sin turnos o algo falla a mitad, lo que ya hayas entregado con yield no se pierde.\",\n\t\tpromptSnippet: \"yield: entrega un hallazgo parcial ahora mismo, sin esperar al final de la tarea\",\n\t\tpromptGuidelines: [\n\t\t\t\"Llama a yield en cuanto tengas UN hallazgo listo, no acumules varios para entregarlos de golpe al final.\",\n\t\t],\n\t\tparameters: PARAMETROS_YIELD,\n\t\tprepareArguments: repararArgumentos<ParametrosYield>(PARAMETROS_YIELD, [\"datos\"]),\n\t\tasync execute(_toolCallId, params: ParametrosYield): Promise<AgentToolResult<undefined>> {\n\t\t\tconst hallazgo = opciones.buffer.empujar({\n\t\t\t\tetiqueta: params.etiqueta,\n\t\t\t\tdatos: params.datos,\n\t\t\t\tconfianza: params.confianza,\n\t\t\t});\n\t\t\topciones.onEntrega?.(hallazgo);\n\t\t\treturn {\n\t\t\t\tdetails: undefined,\n\t\t\t\tcontent: [{ type: \"text\", text: `Hallazgo #${hallazgo.indice} (\"${hallazgo.etiqueta}\") entregado.` }],\n\t\t\t};\n\t\t},\n\t};\n}\n\nexport interface ResultadoIncremental {\n\t/** Marca que este resultado viene de un YIELD FINAL FORZADO, no de una respuesta final normal. */\n\tparcial: true;\n\thallazgos: HallazgoParcial[];\n}\n\n/** Empaqueta el buffer como el resultado de un YIELD FINAL FORZADO (subagente descarrilado). */\nexport function ensamblarResultadoIncremental(buffer: BufferDeHallazgos): ResultadoIncremental {\n\treturn { parcial: true, hallazgos: buffer.todos() };\n}\n"]}

package/dist/core/workflows/goal-engine/engine.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Ada Intelligence Engine — GoalEngine (modelo contenedor, estilo Claude Code).
+ *
+ * El goal es un CONTENEDOR de alto nivel: objetivo + doneCriteria + estado +
+ * frenos. NO tiene pasos propios — los pasos viven en los workflows dinámicos
+ * que desencadena. Cada sub-tarea del goal (tasks) lanza un workflow
+ * (`launchWorkflow` inyectable → WorkflowManager). Cuando todas las sub-tareas
+ * terminan, el juez verifica los doneCriteria y decide done/continue.
+ *
+ * Diseño: agnóstico del LLM — `launchWorkflow` (lanza el flujo dinámico de una
+ * sub-tarea) y `judge` (juez) son inyectables. Frenos integrados: maxTurns,
+ * repeat detector, stop-file (~/.ada-stop), budget, pausa ante decisiones
+ * irreversibles.
+ */
+import type { AskUserQuestion, EvidenceItem, GoalEventListener, GoalFrenos, GoalJudgeFn, GoalPersistence, GoalReplanFn, GoalState, Task } from "./types.ts";
+export interface GoalEngineOptions {
+    persistence: GoalPersistence;
+    /** Lanza el workflow dinámico de una sub-tarea → runId (goal-contenedor). */
+    launchWorkflow: (input: {
+        goalId: string;
+        goal: string;
+        taskId: string;
+        taskTitle: string;
+        doneCriteria: string[];
+        verifyCommand: string;
+        sessionId?: string;
+    }) => Promise<{
+        runId: string;
+    }>;
+    judge: GoalJudgeFn;
+    /** P1: re-planificación completa tras veredicto continue (opcional). */
+    replanFn?: GoalReplanFn;
+    frenos?: Partial<GoalFrenos>;
+    onEvent?: GoalEventListener;
+    /** Comprobador del stop-file (inyectable para tests). */
+    stopFileExists?: (path: string) => boolean;
+    /** P5: modo plan-only — no lanzar workflows hasta approve del plan. */
+    planOnly?: boolean;
+    /** Raíz del proyecto para la huella anti-cheat. Default: process.cwd(). */
+    cwd?: string;
+    /** Huella del árbol de trabajo (inyectable para tests). */
+    fingerprint?: (cwd: string) => Promise<string | undefined>;
+    now?: () => string;
+}
+export declare class GoalEngine {
+    private persistence;
+    /** Lock por-goal: nunca dos ticks concurrentes del mismo goal. */
+    private _tickInFlight;
+    /** Auto-continuación en vuelo tras `onWorkflowFinished` (ver `settle`). */
+    private _autoTick;
+    /** Temporizadores de `goal_wait(resumeAfterMs)`, uno por goal. */
+    private _waitTimers;
+    private launchWorkflow;
+    private judge;
+    private replanFn?;
+    private frenos;
+    private onEvent?;
+    private stopFileExists;
+    private planOnly;
+    private cwd;
+    private fingerprint;
+    private now;
+    /** cache en memoria: id → estado (el disco es la fuente de verdad). */
+    private cache;
+    constructor(options: GoalEngineOptions);
+    /** Crea un goal en estado setup (contrato). Devuelve el id para aprobar. */
+    createGoal(input: {
+        goal: string;
+        doneCriteria: string[];
+        verifyCommand: string;
+        sessionId?: string;
+    }): Promise<GoalState>;
+    /** Añade una tarea al TODO del goal sin reemplazar el plan. */
+    addTask(goalId: string, title: string): Promise<GoalState>;
+    /** Aprueba el contrato → el bucle puede arrancar. */
+    approve(goalId: string): Promise<GoalState>;
+    /**
+     * Un tick del bucle: se llama cuando el agente principal se ha settleado.
+     * Solo avanza si: status active, sin waiting, sin stop-file, bajo los
+     * límites (maxTurns, budget, repeat tolerance).
+     */
+    tick(goalId: string): Promise<{
+        advanced: boolean;
+        state: GoalState;
+        reason?: string;
+    }>;
+    private _tickInner;
+    /**
+     * Evento del WorkflowManager: una sub-tarea terminó su workflow.
+     * Marca la task done/failed, acumula tokens/coste del run en el presupuesto
+     * del goal (freno budgetTokens/costBudget), y aplica el repeat detector
+     * (sub-tareas fallidas consecutivas → pause). El siguiente tick decide.
+     */
+    onWorkflowFinished(workflowRunId: string, ok: boolean, summary?: string, usage?: {
+        tokens?: number;
+        cost?: number;
+    }): Promise<GoalState | null>;
+    /**
+     * Espera a la auto-continuación en vuelo. Pensado para tests, que necesitan
+     * un punto determinista tras `onWorkflowFinished`; en producción el tick es
+     * fire-and-forget y nadie lo espera.
+     */
+    settle(): Promise<void>;
+    /** Juez obligatorio: revisa SOLO goal + criteria + evidencia citada. */
+    runJudge(state: GoalState): Promise<GoalState>;
+    /** Completa el goal con evidencia — exige juez done y evidencia citada. */
+    complete(goalId: string, summary: string, evidence: EvidenceItem[]): Promise<GoalState>;
+    /** Reemplaza la checklist completa (tool `todo`). */
+    replaceTasks(goalId: string, tasks: Task[]): Promise<GoalState>;
+    /**
+     * P1: re-planificación completa. Genera un nuevo plan con el LLM
+     * (replanFn) aprendiendo de la evidencia y del último veredicto del juez,
+     * y arranca la iteración N+1. Sin replanFn → error suave (GoalError).
+     */
+    replan(goalId: string): Promise<GoalState>;
+    private autoReplanAfterContinue;
+    pause(goalId: string, reason?: string): Promise<GoalState>;
+    resume(goalId: string): Promise<GoalState>;
+    blocked(goalId: string, reason: string): Promise<GoalState>;
+    askUser(goalId: string, reason: string, questions: AskUserQuestion[]): Promise<GoalState>;
+    answerQuestions(goalId: string, answers: Record<string, string[]>): Promise<GoalState>;
+    get(goalId: string): Promise<GoalState | null>;
+    list(): Promise<Array<{
+        id: string;
+        goal: string;
+        status: GoalState["status"];
+        phase: GoalState["phase"];
+        updatedAt: string;
+    }>>;
+    private checkBrakes;
+    private mustLoad;
+    private commit;
+    /**
+     * Temporizador de `goal_wait(resumeAfterMs)`.
+     *
+     * Las dos mitades ya existían: la tool guarda `resumeAfterMs` en
+     * `state.waiting`, y `checkBrakes` libera el freno cuando el plazo vence.
+     * Pero nadie re-evaluaba, así que "espera 30 minutos" significaba en la
+     * práctica "espera a que el humano vuelva a escribir". Sondear un deploy o
+     * esperar a CI no funcionaba.
+     *
+     * Un despertar espurio es inofensivo: `tick` tiene su lock y `checkBrakes`
+     * vuelve a decidir.
+     */
+    private armWaitTimer;
+    /** Cancela los temporizadores pendientes (cierre de sesión, tests). */
+    dispose(): void;
+    private emit;
+}
+export declare function isBrakeRelevant(reason: string): boolean;
+//# sourceMappingURL=engine.d.ts.map

package/dist/core/workflows/goal-engine/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../../src/core/workflows/goal-engine/engine.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Ada Intelligence Engine — GoalEngine (modelo contenedor, estilo Claude Code).\n *\n * El goal es un CONTENEDOR de alto nivel: objetivo + doneCriteria + estado +\n * frenos. NO tiene pasos propios — los pasos viven en los workflows dinámicos\n * que desencadena. Cada sub-tarea del goal (tasks) lanza un workflow\n * (`launchWorkflow` inyectable → WorkflowManager). Cuando todas las sub-tareas\n * terminan, el juez verifica los doneCriteria y decide done/continue.\n *\n * Diseño: agnóstico del LLM — `launchWorkflow` (lanza el flujo dinámico de una\n * sub-tarea) y `judge` (juez) son inyectables. Frenos integrados: maxTurns,\n * repeat detector, stop-file (~/.ada-stop), budget, pausa ante decisiones\n * irreversibles.\n */\n\nimport { GoalError } from \"./errors.ts\";\nimport { createGoalState, reduceGoal } from \"./state.ts\";\nimport type {\n\tAskUserQuestion,\n\tEvidenceItem,\n\tGoalAction,\n\tGoalEventListener,\n\tGoalFrenos,\n\tGoalJudgeFn,\n\tGoalPersistence,\n\tGoalReplanFn,\n\tGoalState,\n\tTask,\n\tTaskStatus,\n} from \"./types.ts\";\nimport { DEFAULT_GOAL_FRENOS } from \"./types.ts\";\nimport { workspaceFingerprint } from \"./worktree-fingerprint.ts\";\n\nexport interface GoalEngineOptions {\n\tpersistence: GoalPersistence;\n\t/** Lanza el workflow dinámico de una sub-tarea → runId (goal-contenedor). */\n\tlaunchWorkflow: (input: {\n\t\tgoalId: string;\n\t\tgoal: string;\n\t\ttaskId: string;\n\t\ttaskTitle: string;\n\t\tdoneCriteria: string[];\n\t\tverifyCommand: string;\n\t\tsessionId?: string;\n\t}) => Promise<{ runId: string }>;\n\tjudge: GoalJudgeFn;\n\t/** P1: re-planificación completa tras veredicto continue (opcional). */\n\treplanFn?: GoalReplanFn;\n\tfrenos?: Partial<GoalFrenos>;\n\tonEvent?: GoalEventListener;\n\t/** Comprobador del stop-file (inyectable para tests). */\n\tstopFileExists?: (path: string) => boolean;\n\t/** P5: modo plan-only — no lanzar workflows hasta approve del plan. */\n\tplanOnly?: boolean;\n\t/** Raíz del proyecto para la huella anti-cheat. Default: process.cwd(). */\n\tcwd?: string;\n\t/** Huella del árbol de trabajo (inyectable para tests). */\n\tfingerprint?: (cwd: string) => Promise<string | undefined>;\n\tnow?: () => string;\n}\n\nexport class GoalEngine {\n\tprivate persistence: GoalPersistence;\n\t/** Lock por-goal: nunca dos ticks concurrentes del mismo goal. */\n\tprivate _tickInFlight = new Set<string>();\n\t/** Auto-continuación en vuelo tras `onWorkflowFinished` (ver `settle`). */\n\tprivate _autoTick: Promise<unknown> = Promise.resolve();\n\t/** Temporizadores de `goal_wait(resumeAfterMs)`, uno por goal. */\n\tprivate _waitTimers = new Map<string, ReturnType<typeof setTimeout>>();\n\tprivate launchWorkflow: GoalEngineOptions[\"launchWorkflow\"];\n\tprivate judge: GoalJudgeFn;\n\tprivate replanFn?: GoalReplanFn;\n\tprivate frenos: GoalFrenos;\n\tprivate onEvent?: GoalEventListener;\n\tprivate stopFileExists: (path: string) => boolean;\n\tprivate planOnly: boolean;\n\tprivate cwd: string;\n\tprivate fingerprint: (cwd: string) => Promise<string | undefined>;\n\tprivate now: () => string;\n\t/** cache en memoria: id → estado (el disco es la fuente de verdad). */\n\tprivate cache = new Map<string, GoalState>();\n\n\tconstructor(options: GoalEngineOptions) {\n\t\tthis.persistence = options.persistence;\n\t\tthis.launchWorkflow = options.launchWorkflow;\n\t\tthis.judge = options.judge;\n\t\tthis.replanFn = options.replanFn;\n\t\tthis.frenos = { ...DEFAULT_GOAL_FRENOS, ...options.frenos };\n\t\tthis.onEvent = options.onEvent;\n\t\tthis.stopFileExists = options.stopFileExists ?? ((p) => p !== null && p.length > 0 && fsExists(p));\n\t\tthis.planOnly = options.planOnly ?? false;\n\t\tthis.cwd = options.cwd ?? process.cwd();\n\t\tthis.fingerprint = options.fingerprint ?? workspaceFingerprint;\n\t\tthis.now = options.now ?? (() => new Date().toISOString());\n\t}\n\n\t// ─── Contrato primero ───\n\n\t/** Crea un goal en estado setup (contrato). Devuelve el id para aprobar. */\n\tasync createGoal(input: {\n\t\tgoal: string;\n\t\tdoneCriteria: string[];\n\t\tverifyCommand: string;\n\t\tsessionId?: string;\n\t}): Promise<GoalState> {\n\t\tconst state = createGoalState({ ...input, id: `goal-${Date.now().toString(36)}-${randId()}`, now: this.now() });\n\t\tthis.cache.set(state.id, state);\n\t\tawait this.persistence.save(state);\n\t\tthis.emit(\"goal_update\", { goal: state });\n\t\treturn state;\n\t}\n\n\t/** Añade una tarea al TODO del goal sin reemplazar el plan. */\n\tasync addTask(goalId: string, title: string): Promise<GoalState> {\n\t\tconst state = await this.mustLoad(goalId);\n\t\tconst { state: next } = reduceGoal(state, { type: \"goal_task_add\", title }, this.frenos);\n\t\treturn this.commit(state, next);\n\t}\n\n\t/** Aprueba el contrato → el bucle puede arrancar. */\n\tasync approve(goalId: string): Promise<GoalState> {\n\t\tconst state = await this.mustLoad(goalId);\n\t\tconst { state: next } = reduceGoal(state, { type: \"goal_approve\" }, this.frenos);\n\t\treturn this.commit(state, next);\n\t}\n\n\t// ─── Bucle ───\n\n\t/**\n\t * Un tick del bucle: se llama cuando el agente principal se ha settleado.\n\t * Solo avanza si: status active, sin waiting, sin stop-file, bajo los\n\t * límites (maxTurns, budget, repeat tolerance).\n\t */\n\tasync tick(goalId: string): Promise<{ advanced: boolean; state: GoalState; reason?: string }> {\n\t\t// Reentrancia: nunca dos ticks concurrentes del mismo goal (el\n\t\t// subagent que ejecuta el turno comparte agentDir y NO re-dispara).\n\t\tif (this._tickInFlight.has(goalId)) {\n\t\t\tconst state = await this.mustLoad(goalId);\n\t\t\treturn { advanced: false, state, reason: \"tick ya en curso\" };\n\t\t}\n\t\tthis._tickInFlight.add(goalId);\n\t\ttry {\n\t\t\treturn await this._tickInner(goalId);\n\t\t} finally {\n\t\t\tthis._tickInFlight.delete(goalId);\n\t\t}\n\t}\n\n\tprivate async _tickInner(goalId: string): Promise<{ advanced: boolean; state: GoalState; reason?: string }> {\n\t\tlet state = await this.mustLoad(goalId);\n\n\t\t// Frenos que detienen el bucle ANTES de gastar un turno.\n\t\tconst brake = this.checkBrakes(state);\n\t\tif (brake) {\n\t\t\tconst { state: next } = reduceGoal(state, brake.action, this.frenos);\n\t\t\tawait this.commit(state, next);\n\t\t\treturn { advanced: false, state: next, reason: brake.reason };\n\t\t}\n\n\t\t// Continuación solo si el bucle está activo.\n\t\tif (state.status !== \"active\") return { advanced: false, state, reason: `status=${state.status}` };\n\n\t\t// ── Modelo contenedor: el goal lanza workflows por sub-tarea ──\n\t\t// 0. ¿Hay sub-tareas con workflow EN MARCHA? → esperar (uno a la vez).\n\t\t//    El evento workflow_run_finished marcará la sub-tarea vía onWorkflowFinished.\n\t\tconst runningNow = state.tasks.filter((t) => t.status === \"running\");\n\t\tif (runningNow.length > 0) {\n\t\t\treturn { advanced: false, state, reason: `${runningNow.length} workflow(s) en curso` };\n\t\t}\n\n\t\t// 1. ¿Hay sub-tareas fallidas? → reintento (relanzar el workflow) hasta\n\t\t//    la tolerancia; al alcanzarla, el repeat detector ya pausó.\n\t\tconst failedNow = state.tasks.filter((t) => t.status === \"failed\");\n\t\tif (failedNow.length > 0) {\n\t\t\tif (state.repeatedTurns >= this.frenos.repeatTolerance) {\n\t\t\t\treturn { advanced: false, state, reason: \"repeat detector pausado\" };\n\t\t\t}\n\t\t\t// Resetear la primera fallida a pending y CONTINUAR al lanzamiento.\n\t\t\tconst first = failedNow[0];\n\t\t\tconst { state: retry } = reduceGoal(\n\t\t\t\tstate,\n\t\t\t\t{ type: \"goal_task_result\", taskId: first.id, status: \"pending\" as TaskStatus },\n\t\t\t\tthis.frenos,\n\t\t\t);\n\t\t\tstate = retry;\n\t\t\tawait this.commit(state, state);\n\t\t}\n\n\t\t// P5: modo plan-only — no se lanzan workflows automáticamente; el goal\n\t\t// espera aprobación explícita del plan (approve) para cada iteración.\n\t\tif (this.planOnly) {\n\t\t\treturn { advanced: false, state, reason: \"plan-only: esperando approve del plan\" };\n\t\t}\n\n\t\t// 2. ¿Hay sub-tareas sin workflow lanzado? → lanza la siguiente.\n\t\tconst pending = state.tasks.find((t) => t.status === \"pending\" || t.status === \"active\");\n\t\tif (pending) {\n\t\t\tthis.emit(\"goal_agent\", {\n\t\t\t\tgoalId,\n\t\t\t\tagent: { id: `${goalId}:task:${pending.id}`, label: pending.title, detail: \"workflow dinámico\" },\n\t\t\t});\n\t\t\ttry {\n\t\t\t\tconst { runId } = await this.launchWorkflow({\n\t\t\t\t\tgoalId: state.id,\n\t\t\t\t\tgoal: state.goal,\n\t\t\t\t\ttaskId: pending.id,\n\t\t\t\t\ttaskTitle: pending.title,\n\t\t\t\t\tdoneCriteria: state.doneCriteria,\n\t\t\t\t\tverifyCommand: state.verifyCommand,\n\t\t\t\t\tsessionId: state.sessionId,\n\t\t\t\t});\n\t\t\t\t// Marcar la sub-tarea running con su runId.\n\t\t\t\tconst { state: launched } = reduceGoal(\n\t\t\t\t\tstate,\n\t\t\t\t\t{ type: \"goal_task_launched\", taskId: pending.id, workflowRunId: runId },\n\t\t\t\t\tthis.frenos,\n\t\t\t\t);\n\t\t\t\tawait this.commit(state, launched);\n\t\t\t\tthis.emit(\"goal_phase\", { goalId, phase: \"working\" });\n\t\t\t\treturn { advanced: true, state: launched, reason: `workflow ${runId} lanzado para ${pending.title}` };\n\t\t\t} catch (e) {\n\t\t\t\t// El workflow no se pudo lanzar → task failed, el juez decide.\n\t\t\t\tconst { state: failed } = reduceGoal(\n\t\t\t\t\tstate,\n\t\t\t\t\t{\n\t\t\t\t\t\ttype: \"goal_task_result\",\n\t\t\t\t\t\ttaskId: pending.id,\n\t\t\t\t\t\tstatus: \"failed\",\n\t\t\t\t\t\tsummary: e instanceof Error ? e.message : String(e),\n\t\t\t\t\t},\n\t\t\t\t\tthis.frenos,\n\t\t\t\t);\n\t\t\t\tawait this.commit(state, failed);\n\t\t\t\treturn { advanced: true, state: failed, reason: \"workflow launch failed\" };\n\t\t\t}\n\t\t}\n\n\t\t// 3. Sin sub-tareas pendientes/running → todas done (o plan vacío) → juez.\n\t\tif (state.tasks.length === 0 || state.tasks.every((t) => t.status === \"done\")) {\n\t\t\tconst judged = await this.runJudge(state);\n\t\t\t// P1: veredicto continue → re-planificación completa automática\n\t\t\t// (nueva iteración con plan regenerado) si el freno maxReplans\n\t\t\t// lo permite y hay replanFn. Si no, reintento simple (behavior atual).\n\t\t\tif (judged.status === \"active\" && judged.judge.lastVerdict === \"continue\") {\n\t\t\t\tconst re = await this.autoReplanAfterContinue(judged);\n\t\t\t\tif (re.iteration > judged.iteration) {\n\t\t\t\t\treturn { advanced: true, state: re, reason: `juez continue → iteración ${re.iteration} (replan)` };\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn { advanced: true, state: judged, reason: \"todas las sub-tareas done → juez\" };\n\t\t}\n\n\t\t// 4. Plan incompleto (sub-tareas en otros estados) → esperar.\n\t\treturn { advanced: false, state, reason: \"plan en curso\" };\n\t}\n\n\t/**\n\t * Evento del WorkflowManager: una sub-tarea terminó su workflow.\n\t * Marca la task done/failed, acumula tokens/coste del run en el presupuesto\n\t * del goal (freno budgetTokens/costBudget), y aplica el repeat detector\n\t * (sub-tareas fallidas consecutivas → pause). El siguiente tick decide.\n\t */\n\tasync onWorkflowFinished(\n\t\tworkflowRunId: string,\n\t\tok: boolean,\n\t\tsummary?: string,\n\t\tusage?: { tokens?: number; cost?: number },\n\t): Promise<GoalState | null> {\n\t\t// Buscar el goal cuya sub-tarea corre ese workflow (en memoria).\n\t\tfor (const state of this.cache.values()) {\n\t\t\tconst task = state.tasks.find((t) => t.workflowRunId === workflowRunId);\n\t\t\tif (!task) continue;\n\t\t\tlet next = state;\n\t\t\t// Resultado de la sub-tarea.\n\t\t\tconst { state: afterResult } = reduceGoal(\n\t\t\t\tnext,\n\t\t\t\t{ type: \"goal_task_result\", taskId: task.id, status: ok ? \"done\" : \"failed\", summary },\n\t\t\t\tthis.frenos,\n\t\t\t);\n\t\t\tnext = afterResult;\n\t\t\t// Presupuesto: acumular tokens/coste reales del workflow.\n\t\t\tif (usage && (usage.tokens || usage.cost)) {\n\t\t\t\tnext = {\n\t\t\t\t\t...next,\n\t\t\t\t\ttokensUsed: next.tokensUsed + (usage.tokens ?? 0),\n\t\t\t\t\tcostUsed: next.costUsed + (usage.cost ?? 0),\n\t\t\t\t\tupdatedAt: this.now(),\n\t\t\t\t};\n\t\t\t}\n\t\t\t// Repeat detector: sub-tareas fallidas consecutivas → pause.\n\t\t\tif (!ok) {\n\t\t\t\t// Anti-cheat: ¿cambió algo el agente? Un fallo con el árbol de\n\t\t\t\t// trabajo idéntico al del fallo anterior no es un intento nuevo, es\n\t\t\t\t// el mismo intento. Reintentarlo gasta presupuesto sin información.\n\t\t\t\tconst fingerprint = await this.fingerprint(this.cwd);\n\t\t\t\tconst stalled = fingerprint !== undefined && fingerprint === next.lastFailureFingerprint;\n\t\t\t\tnext = {\n\t\t\t\t\t...next,\n\t\t\t\t\trepeatedTurns: next.repeatedTurns + 1,\n\t\t\t\t\tlastAgentSummary: summary ?? \"workflow fallido\",\n\t\t\t\t\tlastFailureFingerprint: fingerprint ?? next.lastFailureFingerprint,\n\t\t\t\t\tupdatedAt: this.now(),\n\t\t\t\t};\n\t\t\t\tif (stalled) {\n\t\t\t\t\t// El plan es el problema, no el intento: parar y que el replan lo\n\t\t\t\t\t// vea, en vez de agotar la tolerancia repitiendo lo mismo.\n\t\t\t\t\tconst { state: paused } = reduceGoal(\n\t\t\t\t\t\tnext,\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\ttype: \"goal_pause\",\n\t\t\t\t\t\t\treason:\n\t\t\t\t\t\t\t\t\"workspace sin cambios desde el fallo anterior — el agente no modificó nada, hace falta replantear\",\n\t\t\t\t\t\t},\n\t\t\t\t\t\tthis.frenos,\n\t\t\t\t\t);\n\t\t\t\t\tnext = paused;\n\t\t\t\t} else if (next.repeatedTurns >= this.frenos.repeatTolerance) {\n\t\t\t\t\tconst { state: paused } = reduceGoal(\n\t\t\t\t\t\tnext,\n\t\t\t\t\t\t{ type: \"goal_pause\", reason: `${this.frenos.repeatTolerance} sub-tareas fallidas seguidas` },\n\t\t\t\t\t\tthis.frenos,\n\t\t\t\t\t);\n\t\t\t\t\tnext = paused;\n\t\t\t\t}\n\t\t\t} else if (next.repeatedTurns > 0 || next.lastFailureFingerprint) {\n\t\t\t\t// Éxito resetea el contador de fallos y la huella.\n\t\t\t\tnext = { ...next, repeatedTurns: 0, lastFailureFingerprint: undefined, updatedAt: this.now() };\n\t\t\t}\n\t\t\tawait this.commit(state, next);\n\t\t\tthis.emit(\"goal_update\", { goal: next });\n\t\t\t// Auto-continuación. Sin esto el goal solo avanza cuando el humano\n\t\t\t// escribe: el único disparador de `tick` es el `agent_settled` de la\n\t\t\t// sesión principal, y el workflow de la sub-tarea corre en una sesión\n\t\t\t// de subagente que está excluida de ese camino. Es decir, un goal de\n\t\t\t// N sub-tareas exigía N mensajes del usuario.\n\t\t\t//\n\t\t\t// Se dispara desde dentro del engine a propósito: el engine solo\n\t\t\t// existe en la sesión principal, así que la propiedad anti-recursión\n\t\t\t// se conserva sin depender de agent-session.\n\t\t\t//\n\t\t\t// El bucle está acotado: `goal_task_launched` incrementa `turnsUsed`\n\t\t\t// (state.ts:133) contra `maxTurns`, los fallos consecutivos cuentan\n\t\t\t// contra `repeatTolerance` (y al alcanzarla el estado ya no es\n\t\t\t// `active`, así que no se re-tickea), y `checkBrakes` evalúa\n\t\t\t// stop-file y presupuestos antes de gastar nada.\n\t\t\tif (next.status === \"active\") {\n\t\t\t\tthis._autoTick = this.tick(next.id).catch(() => {\n\t\t\t\t\t// El tick persiste su propio estado; que falle no debe tumbar\n\t\t\t\t\t// al manejador del evento del workflow.\n\t\t\t\t});\n\t\t\t}\n\t\t\treturn next;\n\t\t}\n\t\treturn null;\n\t}\n\n\t/**\n\t * Espera a la auto-continuación en vuelo. Pensado para tests, que necesitan\n\t * un punto determinista tras `onWorkflowFinished`; en producción el tick es\n\t * fire-and-forget y nadie lo espera.\n\t */\n\tasync settle(): Promise<void> {\n\t\tawait this._autoTick;\n\t}\n\n\t/** Juez obligatorio: revisa SOLO goal + criteria + evidencia citada. */\n\tasync runJudge(state: GoalState): Promise<GoalState> {\n\t\tthis.emit(\"goal_judge\", { goalId: state.id, verdict: \"continue\", reason: \"juez iniciado\" });\n\t\tconst verdict = await this.judge({\n\t\t\tgoal: state.goal,\n\t\t\tdoneCriteria: state.doneCriteria,\n\t\t\tverifyCommand: state.verifyCommand,\n\t\t\tevidence: state.evidence,\n\t\t\tphase: state.phase,\n\t\t});\n\t\tconst { state: next } = reduceGoal(\n\t\t\tstate,\n\t\t\t{ type: \"goal_judge\", verdict: verdict.verdict, reason: verdict.reason, crossModel: verdict.crossModel },\n\t\t\tthis.frenos,\n\t\t);\n\t\tawait this.commit(state, next);\n\t\tthis.emit(\"goal_judge\", { goalId: state.id, verdict: verdict.verdict, reason: verdict.reason });\n\t\treturn next;\n\t}\n\n\t/** Completa el goal con evidencia — exige juez done y evidencia citada. */\n\tasync complete(goalId: string, summary: string, evidence: EvidenceItem[]): Promise<GoalState> {\n\t\tconst state = await this.mustLoad(goalId);\n\t\t// Añadir la evidencia nueva al estado (sin duplicar).\n\t\tlet current = state;\n\t\tif (evidence.length) {\n\t\t\tconst { state: withEv } = reduceGoal(current, { type: \"goal_agent_turn\", summary: \"\", evidence }, this.frenos);\n\t\t\tcurrent = withEv;\n\t\t}\n\t\tconst { state: next, stopLoop } = reduceGoal(current, { type: \"goal_complete\", summary, evidence }, this.frenos);\n\t\tawait this.commit(current, next);\n\t\tif (stopLoop && next.status === \"complete\") {\n\t\t\tthis.emit(\"goal_finished\", { goalId, status: \"complete\", verdict: next.judge.lastVerdict });\n\t\t}\n\t\treturn next;\n\t}\n\n\t// ─── Pausa / bloqueo / preguntas ───\n\n\t/** Reemplaza la checklist completa (tool `todo`). */\n\tasync replaceTasks(goalId: string, tasks: Task[]): Promise<GoalState> {\n\t\tconst state = await this.mustLoad(goalId);\n\t\tconst { state: next } = reduceGoal(state, { type: \"goal_tasks\", tasks }, this.frenos);\n\t\treturn this.commit(state, next);\n\t}\n\n\t/**\n\t * P1: re-planificación completa. Genera un nuevo plan con el LLM\n\t * (replanFn) aprendiendo de la evidencia y del último veredicto del juez,\n\t * y arranca la iteración N+1. Sin replanFn → error suave (GoalError).\n\t */\n\tasync replan(goalId: string): Promise<GoalState> {\n\t\tconst state = await this.mustLoad(goalId);\n\t\tif (!this.replanFn) throw new GoalError(\"replanFn no está configurado\", \"REPLAN_UNAVAILABLE\");\n\t\t// El motivo de una pausa por anti-cheat (\"el agente no cambió nada\") es\n\t\t// más accionable para replantear que el último veredicto del juez: dice\n\t\t// que el problema es el plan, no la ejecución. Si existe, manda.\n\t\tconst stalledReason = state.waiting?.reason?.includes(\"workspace sin cambios\") ? state.waiting.reason : undefined;\n\t\tconst replanned = await this.replanFn({\n\t\t\tgoal: state.goal,\n\t\t\tdoneCriteria: state.doneCriteria,\n\t\t\tverifyCommand: state.verifyCommand,\n\t\t\tevidence: state.evidence,\n\t\t\tcurrentTasks: state.tasks,\n\t\t\tlastVerdict: state.judge.lastVerdict,\n\t\t\tlastReason: stalledReason ?? state.judge.lastReason,\n\t\t});\n\t\tconst { state: next } = reduceGoal(\n\t\t\tstate,\n\t\t\t{ type: \"goal_replan\", tasks: replanned.tasks, rationale: replanned.rationale },\n\t\t\tthis.frenos,\n\t\t);\n\t\tawait this.commit(state, next);\n\t\tthis.emit(\"goal_update\", { goal: next });\n\t\treturn next;\n\t}\n\n\t/**\n\t * P1: re-planificación automática tras veredicto continue del juez.\n\t * Respeta el freno maxReplans; si se agota o no hay replanFn, hace el\n\t * reintento simple (comportamiento actual).\n\t */\n\tprivate async autoReplanAfterContinue(state: GoalState): Promise<GoalState> {\n\t\tconst maxReplans = this.frenos.maxReplans ?? 3;\n\t\t// El historial cuenta cuántas re-planificaciones ya se hicieron.\n\t\tconst replansDone = state.iterations.filter((it) => it.replanRationale).length;\n\t\tif (replansDone >= maxReplans || !this.replanFn) return state; // reintento simple\n\t\ttry {\n\t\t\treturn await this.replan(state.id);\n\t\t} catch {\n\t\t\treturn state; // fail-open: reintento simple\n\t\t}\n\t}\n\n\tasync pause(goalId: string, reason?: string): Promise<GoalState> {\n\t\tconst state = await this.mustLoad(goalId);\n\t\tconst { state: next } = reduceGoal(state, { type: \"goal_pause\", reason }, this.frenos);\n\t\treturn this.commit(state, next);\n\t}\n\n\tasync resume(goalId: string): Promise<GoalState> {\n\t\tconst state = await this.mustLoad(goalId);\n\t\tconst { state: next } = reduceGoal(state, { type: \"goal_resume\" }, this.frenos);\n\t\treturn this.commit(state, next);\n\t}\n\n\tasync blocked(goalId: string, reason: string): Promise<GoalState> {\n\t\tconst state = await this.mustLoad(goalId);\n\t\tconst { state: next } = reduceGoal(state, { type: \"goal_blocked\", reason }, this.frenos);\n\t\treturn this.commit(state, next);\n\t}\n\n\tasync askUser(goalId: string, reason: string, questions: AskUserQuestion[]): Promise<GoalState> {\n\t\tconst state = await this.mustLoad(goalId);\n\t\tconst { state: next } = reduceGoal(state, { type: \"goal_questions\", questions, reason }, this.frenos);\n\t\tawait this.commit(state, next);\n\t\tthis.emit(\"goal_question\", { goalId, questions });\n\t\treturn next;\n\t}\n\n\tasync answerQuestions(goalId: string, answers: Record<string, string[]>): Promise<GoalState> {\n\t\tconst state = await this.mustLoad(goalId);\n\t\tconst { state: next } = reduceGoal(state, { type: \"goal_answers\", answers }, this.frenos);\n\t\treturn this.commit(state, next);\n\t}\n\n\t// ─── Consultas ───\n\n\tasync get(goalId: string): Promise<GoalState | null> {\n\t\tconst cached = this.cache.get(goalId);\n\t\tif (cached) return cached;\n\t\tconst loaded = await this.persistence.load(goalId);\n\t\tif (loaded) this.cache.set(goalId, loaded);\n\t\treturn loaded;\n\t}\n\n\tasync list(): Promise<\n\t\tArray<{ id: string; goal: string; status: GoalState[\"status\"]; phase: GoalState[\"phase\"]; updatedAt: string }>\n\t> {\n\t\treturn this.persistence.list();\n\t}\n\n\t// ─── Frenos ───\n\n\tprivate checkBrakes(state: GoalState): { action: GoalAction; reason: string } | null {\n\t\t// ~/.ada-stop: freno de emergencia.\n\t\tif (this.frenos.stopFile && this.stopFileExists(this.frenos.stopFile)) {\n\t\t\treturn {\n\t\t\t\taction: { type: \"goal_pause\", reason: `stop-file presente: ${this.frenos.stopFile}` },\n\t\t\t\treason: \"stop-file\",\n\t\t\t};\n\t\t}\n\t\t// maxTurns.\n\t\tif (state.turnsUsed >= this.frenos.maxTurns) {\n\t\t\treturn {\n\t\t\t\taction: { type: \"goal_blocked\", reason: `máximo de ${this.frenos.maxTurns} turnos alcanzado` },\n\t\t\t\treason: \"maxTurns\",\n\t\t\t};\n\t\t}\n\t\t// Tokens.\n\t\tif (this.frenos.tokenBudget !== null && state.tokensUsed > this.frenos.tokenBudget) {\n\t\t\treturn { action: { type: \"goal_usage_limited\" }, reason: \"token budget\" };\n\t\t}\n\t\t// Coste.\n\t\tif (this.frenos.costBudget !== null && state.costUsed > this.frenos.costBudget) {\n\t\t\treturn { action: { type: \"goal_budget_limited\" }, reason: \"cost budget\" };\n\t\t}\n\t\t// waiting activo (resumeAfterMs: reanudar automáticamente si pasó).\n\t\tif (state.waiting) {\n\t\t\tif (\n\t\t\t\tstate.waiting.resumeAfterMs !== undefined &&\n\t\t\t\tDate.now() >= Date.parse(state.updatedAt) + state.waiting.resumeAfterMs\n\t\t\t) {\n\t\t\t\treturn null; // el tick puede continuar (el resume ocurre en commit)\n\t\t\t}\n\t\t\treturn { action: { type: \"goal_blocked\", reason: state.waiting.reason }, reason: \"waiting\" };\n\t\t}\n\t\treturn null;\n\t}\n\n\tprivate async mustLoad(goalId: string): Promise<GoalState> {\n\t\tconst state = await this.get(goalId);\n\t\tif (!state) throw new GoalError(`Goal no encontrado: ${goalId}`, \"GOAL_NOT_FOUND\");\n\t\treturn state;\n\t}\n\n\tprivate async commit(_before: GoalState, after: GoalState): Promise<GoalState> {\n\t\tthis.cache.set(after.id, after);\n\t\tawait this.persistence.save(after);\n\t\tthis.emit(\"goal_update\", { goal: after });\n\t\tthis.armWaitTimer(after);\n\t\treturn after;\n\t}\n\n\t/**\n\t * Temporizador de `goal_wait(resumeAfterMs)`.\n\t *\n\t * Las dos mitades ya existían: la tool guarda `resumeAfterMs` en\n\t * `state.waiting`, y `checkBrakes` libera el freno cuando el plazo vence.\n\t * Pero nadie re-evaluaba, así que \"espera 30 minutos\" significaba en la\n\t * práctica \"espera a que el humano vuelva a escribir\". Sondear un deploy o\n\t * esperar a CI no funcionaba.\n\t *\n\t * Un despertar espurio es inofensivo: `tick` tiene su lock y `checkBrakes`\n\t * vuelve a decidir.\n\t */\n\tprivate armWaitTimer(state: GoalState): void {\n\t\tconst previous = this._waitTimers.get(state.id);\n\t\tif (previous) {\n\t\t\tclearTimeout(previous);\n\t\t\tthis._waitTimers.delete(state.id);\n\t\t}\n\t\tif (state.status !== \"active\" && state.status !== \"blocked\") return;\n\t\tconst ms = state.waiting?.resumeAfterMs;\n\t\tif (ms === undefined) return;\n\t\tconst remaining = Date.parse(state.updatedAt) + ms - Date.now();\n\t\tconst timer = setTimeout(\n\t\t\t() => {\n\t\t\t\tthis._waitTimers.delete(state.id);\n\t\t\t\tvoid this.tick(state.id).catch(() => {});\n\t\t\t},\n\t\t\tMath.max(0, remaining),\n\t\t);\n\t\t// No mantener vivo el proceso solo por un goal dormido.\n\t\t(timer as unknown as { unref?: () => void }).unref?.();\n\t\tthis._waitTimers.set(state.id, timer);\n\t}\n\n\t/** Cancela los temporizadores pendientes (cierre de sesión, tests). */\n\tdispose(): void {\n\t\tfor (const timer of this._waitTimers.values()) clearTimeout(timer);\n\t\tthis._waitTimers.clear();\n\t}\n\n\tprivate emit<K extends keyof import(\"./types.ts\").GoalEventMap>(\n\t\ttype: K,\n\t\tpayload: import(\"./types.ts\").GoalEventMap[K],\n\t): void {\n\t\tthis.onEvent?.(type, payload);\n\t}\n}\n\n// ─── helpers ───\n\nimport { existsSync } from \"node:fs\";\n\nfunction fsExists(p: string): boolean {\n\ttry {\n\t\treturn existsSync(p);\n\t} catch {\n\t\treturn false;\n\t}\n}\n\nfunction randId(): string {\n\treturn Math.random().toString(36).slice(2, 7);\n}\n\nexport function isBrakeRelevant(reason: string): boolean {\n\treturn [\"stop-file\", \"maxTurns\", \"token budget\", \"cost budget\", \"repeat detector\", \"waiting\"].includes(reason);\n}\n"]}