@hoilab/ada-cli 0.84.22 → 0.85.1

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

@@ -0,0 +1,32 @@
+/**
+ * Esquema de salida de un subagente.
+ *
+ * Se declara en el frontmatter de su definición (`~/.ada/agents/<n>.md`,
+ * campo `outputSchema`) o se pasa por el script del workflow
+ * (`agent({ schema })`). El host valida la salida contra él — ver
+ * `validador.ts` para el reintento cuando no valida.
+ *
+ * typebox 1.x serializa `Type.Object(...)` como JSON Schema plano (sin
+ * símbolos ni funciones), así que un `outputSchema:` escrito a mano en YAML
+ * es intercambiable con un `Type.Object(...)` del script sin ningún paso de
+ * conversión — YAML anidado y JSON Schema son la misma forma.
+ */
+import type { TSchema } from "typebox";
+export interface ResultadoComprobacion {
+    valida: boolean;
+    /** Un mensaje por error, con su ruta dentro del valor. Vacío si `valida`. */
+    errores: string[];
+}
+/**
+ * Comprueba que `valor` TIENE PINTA de JSON Schema antes de usarlo para
+ * validar nada.
+ *
+ * Un esquema vacío (`{}`) o sin ninguna de estas claves acepta CUALQUIER
+ * valor sin restricción — eso no es "sin esquema" (que el caller distingue
+ * con `undefined`/ausencia del campo), es un esquema declarado pero roto, y
+ * dejarlo pasar haría que todo "validara" en silencio.
+ */
+export declare function esEsquemaValido(valor: unknown): valor is TSchema;
+/** Comprueba `valor` contra `esquema`. Errores concretos: ruta + motivo. */
+export declare function comprobar(esquema: TSchema, valor: unknown): ResultadoComprobacion;
+//# sourceMappingURL=esquema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"esquema.d.ts","sourceRoot":"","sources":["../../../../src/core/workflows/contrato/esquema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGvC,MAAM,WAAW,qBAAqB;IACrC,MAAM,EAAE,OAAO,CAAC;IAChB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAID;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAIhE;AAED,4EAA4E;AAC5E,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,qBAAqB,CAIjF"}

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

@@ -0,0 +1,25 @@
+import { Value } from "typebox/value";
+const CLAVES_DE_FORMA = ["type", "properties", "anyOf", "oneOf", "allOf", "$ref", "enum", "const"];
+/**
+ * Comprueba que `valor` TIENE PINTA de JSON Schema antes de usarlo para
+ * validar nada.
+ *
+ * Un esquema vacío (`{}`) o sin ninguna de estas claves acepta CUALQUIER
+ * valor sin restricción — eso no es "sin esquema" (que el caller distingue
+ * con `undefined`/ausencia del campo), es un esquema declarado pero roto, y
+ * dejarlo pasar haría que todo "validara" en silencio.
+ */
+export function esEsquemaValido(valor) {
+    if (valor === null || typeof valor !== "object" || Array.isArray(valor))
+        return false;
+    const claves = Object.keys(valor);
+    return claves.some((c) => CLAVES_DE_FORMA.includes(c));
+}
+/** Comprueba `valor` contra `esquema`. Errores concretos: ruta + motivo. */
+export function comprobar(esquema, valor) {
+    if (Value.Check(esquema, valor))
+        return { valida: true, errores: [] };
+    const errores = [...Value.Errors(esquema, valor)].map((e) => `${e.instancePath || "(raíz)"}: ${e.message}`);
+    return { valida: false, errores };
+}
+//# sourceMappingURL=esquema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"esquema.js","sourceRoot":"","sources":["../../../../src/core/workflows/contrato/esquema.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAQtC,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAU,CAAC;AAE5G;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAAC,KAAc;IAC7C,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACtF,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,KAAgC,CAAC,CAAC;IAC7D,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAE,eAAqC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/E,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,SAAS,CAAC,OAAgB,EAAE,KAAc;IACzD,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IACtE,MAAM,OAAO,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,YAAY,IAAI,QAAQ,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAC5G,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AACnC,CAAC"}

package/dist/core/workflows/contrato/reparar-argumentos.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Reparación de argumentos de tool mal formados, ANTES de gastar un turno en
+ * un error de validación.
+ *
+ * Dos capas, deliberadamente separadas porque arreglan cosas distintas:
+ *
+ * 1. `repararJSON` — un campo de texto que debería ser un objeto/array llega
+ *    con una coma colgante o doblemente serializado (fallos típicos de LLM).
+ *    Parseo tolerante con UN solo intento de arreglo; nunca reescribe
+ *    comillas simples ni añade comillas a claves sueltas — eso puede corromper
+ *    contenido legítimo (código, texto con comillas), y aquí perder el atajo
+ *    es barato, pero corromper datos no lo es.
+ *
+ * 2. `repararConEsquema` — campo de más (`additionalProperties: false`) y
+ *    número/booleano-como-cadena, en las propiedades del NIVEL SUPERIOR del
+ *    objeto. Lee `type`/`properties`/`additionalProperties` directamente del
+ *    esquema en vez de delegar en `Value.Clean`/`Value.Convert` de
+ *    `typebox/value`: esas dos SOLO reconocen esquemas construidos con
+ *    `Type.Object(...)` (llevan una marca interna de "tipo de nodo" que
+ *    `JSON.stringify` no serializa); un esquema declarado a mano en YAML
+ *    (`outputSchema:` del frontmatter de un agente, parseado a un objeto
+ *    plano) NO la lleva, y Clean/Convert se quedan calladas sin tocar nada —
+ *    un "no pude" disfrazado de éxito, descubierto ejecutándolo de verdad, no
+ *    leyendo la documentación. Leer la forma JSON a pelo funciona igual para
+ *    los dos orígenes, porque ambos SON JSON Schema plano una vez
+ *    serializados.
+ *
+ *    Nunca inventa un valor para un campo que no se puede convertir de
+ *    verdad (una cadena "abc" en un campo number se queda "abc", no se
+ *    convierte en `0`) — un valor inventado en silencio es peor que el error
+ *    que reemplaza, exactamente el defecto que la regla del proyecto prohíbe
+ *    (que "no pude" se lea como éxito).
+ */
+import type { TSchema } from "typebox";
+export interface JSONReparado {
+    valor: unknown;
+    /** true si hizo falta el arreglo de coma colgante (el parseo directo falló). */
+    reparado: boolean;
+}
+/**
+ * Parseo tolerante de JSON: intento directo y, si falla, un único intento
+ * tras quitar comas colgantes. `undefined` si ninguno de los dos vale —
+ * "no pude repararlo", no "el valor es nulo".
+ */
+export declare function repararJSON(texto: string): JSONReparado | undefined;
+export interface ValorReparado {
+    valor: unknown;
+    /** true si se quitó algún campo de más o se convirtió algún tipo. */
+    reparado: boolean;
+}
+/**
+ * Repara `valor` contra `esquema`: quita campos de más del nivel superior
+ * cuando el esquema es cerrado (`additionalProperties: false`) y convierte
+ * número-como-cadena / booleano-como-cadena en las propiedades declaradas,
+ * SOLO cuando la conversión es real. Sin recursión: opera en el objeto de
+ * argumentos de una tool, que es plano por construcción.
+ */
+export declare function repararConEsquema(esquema: TSchema, valor: unknown): ValorReparado;
+/**
+ * `prepareArguments` genérico para un `ToolDefinition`: aplica `repararJSON`
+ * a los campos de texto indicados (los que un modelo puede mandar doblemente
+ * serializados) y luego `repararConEsquema` al objeto entero. Solo sustituye
+ * un campo de texto cuando el JSON reparado es un objeto o array — un valor
+ * de texto que por casualidad parsea como número o booleano ("42", "true") se
+ * deja tal cual: ahí el texto original es casi siempre lo que el modelo quiso
+ * decir, no un valor doblemente serializado.
+ */
+export declare function repararArgumentos<T = unknown>(esquema: TSchema, camposTexto?: string[]): (args: unknown) => T;
+//# sourceMappingURL=reparar-argumentos.d.ts.map

package/dist/core/workflows/contrato/reparar-argumentos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reparar-argumentos.d.ts","sourceRoot":"","sources":["../../../../src/core/workflows/contrato/reparar-argumentos.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAOvC,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,OAAO,CAAC;IACf,gFAAgF;IAChF,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAanE;AAED,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,qEAAqE;IACrE,QAAQ,EAAE,OAAO,CAAC;CAClB;AAoBD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,aAAa,CAuCjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,GAAE,MAAM,EAAO,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK,CAAC,CAiBjH"}

package/dist/core/workflows/contrato/reparar-argumentos.js

@@ -0,0 +1,117 @@
+/** Quita una coma colgante antes de `}`/`]` — el error de JSON más común de un LLM. */
+function quitarComaColgante(texto) {
+    return texto.replace(/,(\s*[}\]])/g, "$1");
+}
+/**
+ * Parseo tolerante de JSON: intento directo y, si falla, un único intento
+ * tras quitar comas colgantes. `undefined` si ninguno de los dos vale —
+ * "no pude repararlo", no "el valor es nulo".
+ */
+export function repararJSON(texto) {
+    try {
+        return { valor: JSON.parse(texto), reparado: false };
+    }
+    catch {
+        // sigue con el intento de arreglo
+    }
+    const sinComa = quitarComaColgante(texto);
+    if (sinComa === texto)
+        return undefined;
+    try {
+        return { valor: JSON.parse(sinComa), reparado: true };
+    }
+    catch {
+        return undefined;
+    }
+}
+function comoNumero(texto) {
+    if (texto.trim() === "")
+        return undefined;
+    const n = Number(texto);
+    return Number.isFinite(n) ? n : undefined;
+}
+function comoBooleano(texto) {
+    if (texto === "true")
+        return true;
+    if (texto === "false")
+        return false;
+    return undefined;
+}
+/**
+ * Repara `valor` contra `esquema`: quita campos de más del nivel superior
+ * cuando el esquema es cerrado (`additionalProperties: false`) y convierte
+ * número-como-cadena / booleano-como-cadena en las propiedades declaradas,
+ * SOLO cuando la conversión es real. Sin recursión: opera en el objeto de
+ * argumentos de una tool, que es plano por construcción.
+ */
+export function repararConEsquema(esquema, valor) {
+    if (valor === null || typeof valor !== "object" || Array.isArray(valor))
+        return { valor, reparado: false };
+    const forma = esquema;
+    if (forma.type !== "object" || forma.properties === null || typeof forma.properties !== "object") {
+        return { valor, reparado: false };
+    }
+    const propiedades = forma.properties;
+    const cerrado = forma.additionalProperties === false;
+    let reparado = false;
+    const salida = {};
+    for (const [clave, actual] of Object.entries(valor)) {
+        const propEsquema = propiedades[clave];
+        if (!propEsquema) {
+            if (cerrado) {
+                reparado = true; // campo de más: se quita
+                continue;
+            }
+            salida[clave] = actual;
+            continue;
+        }
+        if (typeof actual === "string" && propEsquema.type === "number") {
+            const convertido = comoNumero(actual);
+            if (convertido !== undefined) {
+                salida[clave] = convertido;
+                reparado = true;
+                continue;
+            }
+        }
+        if (typeof actual === "string" && propEsquema.type === "boolean") {
+            const convertido = comoBooleano(actual);
+            if (convertido !== undefined) {
+                salida[clave] = convertido;
+                reparado = true;
+                continue;
+            }
+        }
+        salida[clave] = actual;
+    }
+    return { valor: salida, reparado };
+}
+/**
+ * `prepareArguments` genérico para un `ToolDefinition`: aplica `repararJSON`
+ * a los campos de texto indicados (los que un modelo puede mandar doblemente
+ * serializados) y luego `repararConEsquema` al objeto entero. Solo sustituye
+ * un campo de texto cuando el JSON reparado es un objeto o array — un valor
+ * de texto que por casualidad parsea como número o booleano ("42", "true") se
+ * deja tal cual: ahí el texto original es casi siempre lo que el modelo quiso
+ * decir, no un valor doblemente serializado.
+ */
+export function repararArgumentos(esquema, camposTexto = []) {
+    return (args) => {
+        if (args === null || typeof args !== "object")
+            return args;
+        let objeto = args;
+        let huboReparoDeTexto = false;
+        for (const campo of camposTexto) {
+            const bruto = objeto[campo];
+            if (typeof bruto !== "string")
+                continue;
+            const parseado = repararJSON(bruto);
+            if (parseado && parseado.valor !== null && typeof parseado.valor === "object") {
+                objeto = { ...objeto, [campo]: parseado.valor };
+                huboReparoDeTexto = true;
+            }
+        }
+        const { valor, reparado } = repararConEsquema(esquema, objeto);
+        return (huboReparoDeTexto || reparado ? valor : args);
+    };
+}
+//# sourceMappingURL=reparar-argumentos.js.map

package/dist/core/workflows/contrato/reparar-argumentos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reparar-argumentos.js","sourceRoot":"","sources":["../../../../src/core/workflows/contrato/reparar-argumentos.ts"],"names":[],"mappings":"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"}

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,kFAAkF;IAClF,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAChB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAC;IAClB,uDAAuD;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,qGAAqG;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"}

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;IACxC,OAAO;QACN,wCAAwC;QACxC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/B,mFAAmF;KACnF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACd,CAAC;AAQD,SAAS,QAAQ,CAAI,OAAgB,EAAE,KAAa,EAAE,OAA+C;IACpG,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,2DAA2D,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;AAC9D,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAI,QAA4B;IACzE,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACxC,oEAAoE;QACpE,uEAAuE;QACvE,yDAAyD;QACzD,OAAO;YACN,MAAM,EAAE,KAAK;YACb,KAAK,EAAE,IAAI;YACX,QAAQ,EAAE,CAAC;YACX,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,CAAC,kDAAkD,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;AACH,CAAC"}

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,gGAAgG;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;IAMlF,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,KAAK,IAAI,eAAe,EAAE;CAG1B;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"}

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;QAC/D,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;IACjB,CAAC;IAED,IAAI,QAAQ;QACX,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;IAC9B,CAAC;IAED,KAAK;QACJ,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;IAC5B,CAAC;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,2EAA2E,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;IACA,OAAO;QACN,IAAI,EAAE,OAAO;QACb,KAAK,EAAE,mBAAmB;QAC1B,WAAW,EACV,6SAA6S;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;YACjD,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;QACH,CAAC;KACD,CAAC;AACH,CAAC;AAQD,gGAAgG;AAChG,MAAM,UAAU,6BAA6B,CAAC,MAAyB;IACtE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC;AACrD,CAAC"}

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

@@ -48,6 +48,8 @@ export declare class GoalEngine {
     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?;
@@ -111,6 +113,11 @@ export declare class GoalEngine {
      * y arranca la iteración N+1. Sin replanFn → error suave (GoalError).
      */
     replan(goalId: string): Promise<GoalState>;
+    /**
+     * P1: re-planificación automática tras veredicto continue del juez.
+     * Respeta el freno maxReplans; si se agota o no hay replanFn, hace el
+     * reintento simple (comportamiento actual).
+     */
     private autoReplanAfterContinue;
     pause(goalId: string, reason?: string): Promise<GoalState>;
     resume(goalId: string): Promise<GoalState>;
@@ -128,6 +135,21 @@ export declare class GoalEngine {
     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;