@hoilab/ada-cli 0.84.22 → 0.85.1

package/dist/core/hooks/contract.js

@@ -0,0 +1,140 @@
+/**
+ * Contrato de los hooks: qué se dispara, y qué puede decidir.
+ *
+ * Este fichero es PURO a propósito — no lanza procesos ni toca disco. Aquí vive
+ * la parte que hay que poder probar sin montar nada: qué hooks casan con un
+ * evento, y cómo se combinan sus respuestas.
+ *
+ * La regla que nos separa del contrato que copiamos: **un hook solo puede
+ * estrechar permisos, nunca ampliarlos**. Si un hook pudiera responder "allow"
+ * y saltarse el modo activo, instalar un plugin de terceros equivaldría a
+ * desactivar la gobernanza del producto — que es justo lo que vendemos. Un
+ * "deny" siempre vale; un "allow" solo vale donde el modo ya permitía.
+ */
+/** Los 7 momentos en los que se puede enganchar algo. */
+export const EVENTOS_HOOK = [
+    "session_start",
+    "user_prompt_submit",
+    "pre_tool_use",
+    "post_tool_use",
+    "notification",
+    "stop",
+    "subagent_stop",
+];
+/**
+ * Qué hooks corren para un evento.
+ *
+ * El matcher se prueba contra `objetivo` — el nombre de la herramienta en
+ * `pre_tool_use`/`post_tool_use`, y el propio evento en los demás. Un matcher
+ * ausente casa con todo.
+ *
+ * Un matcher con una expresión regular inválida NO casa y no revienta: un
+ * `settings.json` con una errata no puede tumbar la sesión, y tampoco puede
+ * convertirse en un comodín silencioso que dispare hooks de más.
+ */
+export function planificarHooks(config, evento, objetivo) {
+    if (!config || config.enabled === false)
+        return [];
+    const definidos = config.events?.[evento] ?? [];
+    return definidos.filter((hook) => {
+        if (!hook.command)
+            return false;
+        if (!hook.matcher)
+            return true;
+        try {
+            return new RegExp(hook.matcher).test(objetivo);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/**
+ * Lee la decisión que un hook escribe en stdout.
+ *
+ * Devuelve `null` si no dijo nada legible, que es el caso normal: la mayoría de
+ * los hooks solo quieren correr y salir con 0.
+ */
+export function leerDecision(respuesta) {
+    const texto = (respuesta.stdout ?? "").trim();
+    if (!texto)
+        return null;
+    try {
+        const dato = JSON.parse(texto);
+        const decision = dato.permissionDecision;
+        if (decision !== "allow" && decision !== "deny" && decision !== "ask") {
+            return typeof dato.reason === "string" ? { reason: dato.reason } : null;
+        }
+        return {
+            permissionDecision: decision,
+            reason: typeof dato.reason === "string" ? dato.reason : undefined,
+        };
+    }
+    catch {
+        // stdout que no es JSON es solo registro del hook, no una decisión.
+        return null;
+    }
+}
+/** Lo que el modo activo concede por sí solo, sin hooks de por medio. */
+function techoDelModo(nivel) {
+    switch (nivel) {
+        case "plan":
+            return "deny";
+        case "manual":
+            return "ask";
+        default:
+            return "allow";
+    }
+}
+const ORDEN = { allow: 0, ask: 1, deny: 2 };
+/**
+ * Combina las respuestas de todos los hooks de un evento con el modo activo.
+ *
+ * Gana siempre la más restrictiva, incluido el techo del modo. Por eso un hook
+ * que responde "allow" en modo manual acaba en "ask", y en modo plan en "deny":
+ * puede apretar, no aflojar.
+ *
+ * Salir con 2 equivale a "deny" aunque el hook no escriba JSON — es el atajo
+ * del contrato para un script de una línea. Salir con cualquier otro código
+ * distinto de 0 es un hook roto: bloquea si `failClosed`, y si no se ignora
+ * (pero el motivo se devuelve para poder registrarlo).
+ */
+export function resolverDecision(respuestas, nivel, failClosed) {
+    let peor = techoDelModo(nivel);
+    const motivos = [];
+    for (const respuesta of respuestas) {
+        const leida = leerDecision(respuesta);
+        if (leida?.reason)
+            motivos.push(leida.reason);
+        let candidata = null;
+        if (respuesta.exitCode === 2) {
+            candidata = "deny";
+            if (!leida?.reason && respuesta.stderr?.trim())
+                motivos.push(respuesta.stderr.trim());
+        }
+        else if (respuesta.exitCode !== 0) {
+            if (failClosed) {
+                candidata = "deny";
+                motivos.push(`hook falló con código ${respuesta.exitCode}`);
+            }
+        }
+        else if (leida?.permissionDecision) {
+            candidata = leida.permissionDecision;
+        }
+        if (candidata && ORDEN[candidata] > ORDEN[peor])
+            peor = candidata;
+    }
+    return { decision: peor, motivos };
+}
+/** Cuántas veces seguidas puede un hook `stop` impedir que el turno termine. */
+export const MAX_BLOQUEOS_STOP = 3;
+/**
+ * ¿Se honra este bloqueo de `stop`?
+ *
+ * Con tope, porque sin él un hook mal escrito deja al agente dando vueltas para
+ * siempre y consumiendo dinero. A la cuarta se ignora y el turno termina.
+ */
+export function permiteBloquearParada(bloqueosPrevios) {
+    return bloqueosPrevios < MAX_BLOQUEOS_STOP;
+}
+//# sourceMappingURL=contract.js.map

package/dist/core/hooks/contract.js.map

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

package/dist/core/hooks/runner.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Ejecuta los hooks. Todo lo que decide vive en `contract.ts`; aquí solo se
+ * lanzan procesos y se recogen sus respuestas.
+ *
+ * El contrato con el proceso es deliberadamente pobre, para que escribir un
+ * hook sea cosa de tres líneas de shell: recibe un JSON por stdin, y contesta
+ * con su código de salida (0 sigue, 2 bloquea) y, si quiere afinar, un JSON por
+ * stdout.
+ */
+import type { EventoHook, HookDefinido, RespuestaHook } from "./contract.ts";
+export interface ContextoHook {
+    evento: EventoHook;
+    sessionId: string;
+    cwd: string;
+    toolName?: string;
+    toolInput?: unknown;
+    toolResult?: unknown;
+    prompt?: string;
+    message?: string;
+}
+/**
+ * Lanza un hook y espera su respuesta.
+ *
+ * Nunca lanza excepción: un hook que no existe, que peta o que se cuelga se
+ * traduce a un `exitCode` distinto de 0, y es `resolverDecision` quien decide
+ * si eso bloquea o se ignora. Si esto lanzara, un hook roto tumbaría el turno
+ * saltándose la política de `failClosed`.
+ */
+export declare function ejecutarHook(hook: HookDefinido, contexto: ContextoHook, opciones?: {
+    env?: NodeJS.ProcessEnv;
+}): Promise<RespuestaHook>;
+/**
+ * Ejecuta varios hooks en serie.
+ *
+ * En serie y no en paralelo a propósito: los hooks de `pre_tool_use` existen
+ * para vetar, y dos vetos concurrentes sobre el mismo fichero se pisan. El
+ * coste es aceptable porque cada uno tiene su propio tope de tiempo.
+ */
+export declare function ejecutarHooks(hooks: HookDefinido[], contexto: ContextoHook, opciones?: {
+    env?: NodeJS.ProcessEnv;
+}): Promise<RespuestaHook[]>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/core/hooks/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAM7E,MAAM,WAAW,YAAY;IAC5B,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CACjC,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,YAAY,EACtB,QAAQ,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;CAAO,GACxC,OAAO,CAAC,aAAa,CAAC,CAiDxB;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CAClC,KAAK,EAAE,YAAY,EAAE,EACrB,QAAQ,EAAE,YAAY,EACtB,QAAQ,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;CAAO,GACxC,OAAO,CAAC,aAAa,EAAE,CAAC,CAM1B"}

package/dist/core/hooks/runner.js

@@ -0,0 +1,85 @@
+/**
+ * Ejecuta los hooks. Todo lo que decide vive en `contract.ts`; aquí solo se
+ * lanzan procesos y se recogen sus respuestas.
+ *
+ * El contrato con el proceso es deliberadamente pobre, para que escribir un
+ * hook sea cosa de tres líneas de shell: recibe un JSON por stdin, y contesta
+ * con su código de salida (0 sigue, 2 bloquea) y, si quiere afinar, un JSON por
+ * stdout.
+ */
+import { spawn } from "node:child_process";
+/** Un hook que escupe sin parar no puede tumbar el proceso del agente. */
+const MAX_SALIDA = 64 * 1024;
+const TIMEOUT_POR_DEFECTO_MS = 10_000;
+/**
+ * Lanza un hook y espera su respuesta.
+ *
+ * Nunca lanza excepción: un hook que no existe, que peta o que se cuelga se
+ * traduce a un `exitCode` distinto de 0, y es `resolverDecision` quien decide
+ * si eso bloquea o se ignora. Si esto lanzara, un hook roto tumbaría el turno
+ * saltándose la política de `failClosed`.
+ */
+export async function ejecutarHook(hook, contexto, opciones = {}) {
+    const entrada = JSON.stringify(contexto);
+    const timeoutMs = hook.timeoutMs && hook.timeoutMs > 0 ? hook.timeoutMs : TIMEOUT_POR_DEFECTO_MS;
+    return new Promise((resolve) => {
+        let hijo;
+        try {
+            hijo = spawn(hook.command, {
+                shell: true,
+                cwd: contexto.cwd,
+                // El evento va también por entorno: un hook de una línea puede
+                // ramificar con `$ADA_HOOK_EVENT` sin parsear el JSON.
+                env: { ...process.env, ...opciones.env, ADA_HOOK_EVENT: contexto.evento },
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            resolve({ exitCode: 127, stderr: error instanceof Error ? error.message : String(error) });
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        let resuelto = false;
+        const terminar = (respuesta) => {
+            if (resuelto)
+                return;
+            resuelto = true;
+            clearTimeout(reloj);
+            resolve(respuesta);
+        };
+        const reloj = setTimeout(() => {
+            hijo.kill("SIGKILL");
+            terminar({ exitCode: 124, stdout, stderr: `${stderr}\nhook agotó su tiempo (${timeoutMs} ms)` });
+        }, timeoutMs);
+        hijo.stdout?.on("data", (trozo) => {
+            if (stdout.length < MAX_SALIDA)
+                stdout += trozo.toString("utf8");
+        });
+        hijo.stderr?.on("data", (trozo) => {
+            if (stderr.length < MAX_SALIDA)
+                stderr += trozo.toString("utf8");
+        });
+        hijo.on("error", (error) => terminar({ exitCode: 127, stdout, stderr: error.message }));
+        hijo.on("close", (codigo) => terminar({ exitCode: codigo ?? 0, stdout, stderr }));
+        // Cerrar stdin siempre: sin esto, un hook que lea hasta EOF se cuelga
+        // hasta agotar el temporizador y todo el turno espera con él.
+        hijo.stdin?.on("error", () => { });
+        hijo.stdin?.end(entrada);
+    });
+}
+/**
+ * Ejecuta varios hooks en serie.
+ *
+ * En serie y no en paralelo a propósito: los hooks de `pre_tool_use` existen
+ * para vetar, y dos vetos concurrentes sobre el mismo fichero se pisan. El
+ * coste es aceptable porque cada uno tiene su propio tope de tiempo.
+ */
+export async function ejecutarHooks(hooks, contexto, opciones = {}) {
+    const respuestas = [];
+    for (const hook of hooks) {
+        respuestas.push(await ejecutarHook(hook, contexto, opciones));
+    }
+    return respuestas;
+}
+//# sourceMappingURL=runner.js.map

package/dist/core/hooks/runner.js.map

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

package/dist/core/hooks/session-hooks.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Pegamento entre la sesión y los hooks.
+ *
+ * Vive aparte de `agent-session.ts` a propósito: ese fichero es de upstream y
+ * cada línea que le añadimos se paga en cada sincronización. Aquí cabe toda la
+ * lógica y allí queda una llamada.
+ *
+ * Regla de oro del enganche: **si no hay hooks configurados para este evento,
+ * esto no debe cambiar absolutamente nada**. `resolverDecision` devuelve el
+ * techo del modo cuando no hay respuestas, y aplicar ese techo aquí bloquearía
+ * cada herramienta en modo manual aunque el usuario no haya configurado un solo
+ * hook. Por eso se sale antes de consultar nada.
+ */
+import type { EventoHook, NivelPermiso } from "./contract.ts";
+import { type ContextoHook } from "./runner.ts";
+interface ConfigDelMotor {
+    hooks?: {
+        enabled?: boolean;
+        failClosedHeadless?: boolean;
+        events?: Record<string, Array<{
+            matcher?: string;
+            command: string;
+            timeoutMs?: number;
+        }>>;
+    };
+    permissions?: {
+        level?: string;
+    };
+    goalEngine?: {
+        planOnly?: boolean;
+    };
+}
+/**
+ * El nivel de permisos efectivo.
+ *
+ * UN VALOR DESCONOCIDO NO SE LEE COMO EL POR DEFECTO. Antes, cualquier cosa que
+ * no fuera `manual` ni `yolo` caía a `auto` en silencio: una errata como
+ * `"manaul"` dejaba al usuario con más permisos de los que pidió y sin ningún
+ * aviso. En una configuración de permisos, «no te he entendido» y «has elegido
+ * el valor por defecto» son cosas distintas, y confundirlas es la familia de
+ * fallos que más cara nos ha salido.
+ *
+ * Se avisa por `stderr` y se cae al MÁS RESTRICTIVO de los dos —`manual`, no
+ * `auto`—: ante la duda, preguntar antes de escribir.
+ */
+export declare function nivelDesdeConfig(config: ConfigDelMotor): NivelPermiso;
+export interface ResultadoHooks {
+    /** `true` si hay que impedir la acción. */
+    bloquea: boolean;
+    motivo: string;
+}
+/**
+ * Dispara los hooks de un evento y dice si hay que parar.
+ *
+ * `ask` se trata como bloqueo: aquí no hay a quién preguntar —el enganche corre
+ * dentro de la llamada a la herramienta, no en el bucle de la interfaz—, y ante
+ * la duda se cierra. El motivo lo explica al usuario, que puede reintentar tras
+ * ajustar el hook o el modo.
+ */
+export declare function dispararHooks(config: ConfigDelMotor, evento: EventoHook, objetivo: string, contexto: Omit<ContextoHook, "evento">): Promise<ResultadoHooks>;
+export {};
+//# sourceMappingURL=session-hooks.d.ts.map

package/dist/core/hooks/session-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-hooks.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/session-hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE9D,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,aAAa,CAAC;AAE/D,UAAU,cAAc;IACvB,KAAK,CAAC,EAAE;QACP,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC,CAAC;KAC1F,CAAC;IACF,WAAW,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,UAAU,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACpC;AAiBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,YAAY,CAarE;AAED,MAAM,WAAW,cAAc;IAC9B,2CAA2C;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CACf;AAID;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAClC,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,GACpC,OAAO,CAAC,cAAc,CAAC,CAqBzB"}

package/dist/core/hooks/session-hooks.js

@@ -0,0 +1,84 @@
+/**
+ * Pegamento entre la sesión y los hooks.
+ *
+ * Vive aparte de `agent-session.ts` a propósito: ese fichero es de upstream y
+ * cada línea que le añadimos se paga en cada sincronización. Aquí cabe toda la
+ * lógica y allí queda una llamada.
+ *
+ * Regla de oro del enganche: **si no hay hooks configurados para este evento,
+ * esto no debe cambiar absolutamente nada**. `resolverDecision` devuelve el
+ * techo del modo cuando no hay respuestas, y aplicar ese techo aquí bloquearía
+ * cada herramienta en modo manual aunque el usuario no haya configurado un solo
+ * hook. Por eso se sale antes de consultar nada.
+ */
+import { planificarHooks, resolverDecision } from "./contract.js";
+import { ejecutarHooks } from "./runner.js";
+/** Los cuatro que existen de verdad. Si esta lista crece, crece el tipo. */
+const NIVELES = ["plan", "manual", "auto", "yolo"];
+/**
+ * Nombres que la gente escribe esperando otra cosa, con su equivalente real.
+ *
+ * `ask` y `full` estaban en nuestro README y NO existen en el código. Un
+ * comprador que ponía `level: "full"` esperando plena autonomía se quedaba en
+ * `auto` —que aún pregunta en `bash`— y uno que ponía `"ask"` esperando
+ * confirmación por acción también. Se traducen en vez de rechazarlos porque el
+ * README los prometió: romperle la configuración a quien nos creyó sería
+ * cobrarle nuestro error.
+ */
+const SINONIMOS = { ask: "manual", full: "yolo" };
+/**
+ * El nivel de permisos efectivo.
+ *
+ * UN VALOR DESCONOCIDO NO SE LEE COMO EL POR DEFECTO. Antes, cualquier cosa que
+ * no fuera `manual` ni `yolo` caía a `auto` en silencio: una errata como
+ * `"manaul"` dejaba al usuario con más permisos de los que pidió y sin ningún
+ * aviso. En una configuración de permisos, «no te he entendido» y «has elegido
+ * el valor por defecto» son cosas distintas, y confundirlas es la familia de
+ * fallos que más cara nos ha salido.
+ *
+ * Se avisa por `stderr` y se cae al MÁS RESTRICTIVO de los dos —`manual`, no
+ * `auto`—: ante la duda, preguntar antes de escribir.
+ */
+export function nivelDesdeConfig(config) {
+    if (config.goalEngine?.planOnly === true)
+        return "plan";
+    const nivel = config.permissions?.level;
+    if (nivel === undefined || nivel === "")
+        return "auto";
+    if (NIVELES.includes(nivel))
+        return nivel;
+    const sinonimo = SINONIMOS[nivel];
+    if (sinonimo)
+        return sinonimo;
+    console.error(`Ada: "permissions.level" vale "${nivel}", que no es ninguno de ${NIVELES.join(", ")}. ` +
+        'Se usa "manual" (pregunta antes de cada escritura) por ser el más restrictivo: un valor que no ' +
+        "se entiende no puede dar más permisos de los que pediste.");
+    return "manual";
+}
+const SIN_HOOKS = { bloquea: false, motivo: "" };
+/**
+ * Dispara los hooks de un evento y dice si hay que parar.
+ *
+ * `ask` se trata como bloqueo: aquí no hay a quién preguntar —el enganche corre
+ * dentro de la llamada a la herramienta, no en el bucle de la interfaz—, y ante
+ * la duda se cierra. El motivo lo explica al usuario, que puede reintentar tras
+ * ajustar el hook o el modo.
+ */
+export async function dispararHooks(config, evento, objetivo, contexto) {
+    const hooks = planificarHooks(config.hooks, evento, objetivo);
+    // Salida temprana: sin hooks configurados, ni se mira el modo. Ver cabecera.
+    if (hooks.length === 0)
+        return SIN_HOOKS;
+    const respuestas = await ejecutarHooks(hooks, { ...contexto, evento });
+    const { decision, motivos } = resolverDecision(respuestas, nivelDesdeConfig(config), config.hooks?.failClosedHeadless ?? true);
+    if (decision === "allow")
+        return SIN_HOOKS;
+    const explicacion = motivos.filter(Boolean).join("; ");
+    return {
+        bloquea: true,
+        motivo: decision === "deny"
+            ? `Bloqueado por un hook${explicacion ? `: ${explicacion}` : ""}`
+            : `Un hook pide aprobación explícita${explicacion ? `: ${explicacion}` : ""}`,
+    };
+}
+//# sourceMappingURL=session-hooks.js.map

package/dist/core/hooks/session-hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-hooks.js","sourceRoot":"","sources":["../../../src/core/hooks/session-hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,EAAqB,aAAa,EAAE,MAAM,aAAa,CAAC;AAY/D,4EAA4E;AAC5E,MAAM,OAAO,GAA4B,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5E;;;;;;;;;GASG;AACH,MAAM,SAAS,GAA2C,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;AAE1F;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAsB;IACtD,IAAI,MAAM,CAAC,UAAU,EAAE,QAAQ,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC;IACxD,MAAM,KAAK,GAAG,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC;IACxC,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE;QAAE,OAAO,MAAM,CAAC;IACvD,IAAK,OAA6B,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,KAAqB,CAAC;IACjF,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IAClC,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC9B,OAAO,CAAC,KAAK,CACZ,kCAAkC,KAAK,2BAA2B,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;QACvF,iGAAiG;QACjG,2DAA2D,CAC5D,CAAC;IACF,OAAO,QAAQ,CAAC;AACjB,CAAC;AAQD,MAAM,SAAS,GAAmB,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;AAEjE;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAClC,MAAsB,EACtB,MAAkB,EAClB,QAAgB,EAChB,QAAsC;IAEtC,MAAM,KAAK,GAAG,eAAe,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC9D,6EAA6E;IAC7E,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAEzC,MAAM,UAAU,GAAG,MAAM,aAAa,CAAC,KAAK,EAAE,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;IACvE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,gBAAgB,CAC7C,UAAU,EACV,gBAAgB,CAAC,MAAM,CAAC,EACxB,MAAM,CAAC,KAAK,EAAE,kBAAkB,IAAI,IAAI,CACxC,CAAC;IACF,IAAI,QAAQ,KAAK,OAAO;QAAE,OAAO,SAAS,CAAC;IAE3C,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvD,OAAO;QACN,OAAO,EAAE,IAAI;QACb,MAAM,EACL,QAAQ,KAAK,MAAM;YAClB,CAAC,CAAC,wBAAwB,WAAW,CAAC,CAAC,CAAC,KAAK,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE;YACjE,CAAC,CAAC,oCAAoC,WAAW,CAAC,CAAC,CAAC,KAAK,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE;KAC/E,CAAC;AACH,CAAC"}

package/dist/core/hooks-ts/cargador.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Cargador de hooks TypeScript in-process — B05.
+ *
+ * Usa jiti, el mismo cargador que las extensions: un hook es un fichero .ts
+ * que se compila al vuelo y se importa como módulo. La diferencia con una
+ * extensión es el contrato: aquí no hay factory con API, solo un objeto
+ * `{matcher?, onToolCall}` validado con `esModuloHookTs` ANTES de usarse.
+ *
+ * Fail-closed: este módulo nunca lanza. Un hook que no existe, que no
+ * compila o que exporta otra cosa se traduce en `null` (o en el error
+ * legible del resultado), y es cosa del runner decidir qué hacer con él.
+ */
+import { type HookTsCargado } from "./tipos.ts";
+/** Timeout por defecto por hook; igual que el runner de hooks de shell. */
+export declare const TIMEOUT_HOOK_TS_POR_DEFECTO_MS = 10000;
+export interface ResultadoCargaHook {
+    hook: HookTsCargado | null;
+    /** Motivo legible cuando `hook` es null: compilación, forma o export vacío. */
+    error: string | null;
+}
+/**
+ * Carga un hook TS desde disco y valida su forma.
+ *
+ * Acepta default export y named export (`hook`): ambos son cómodos de
+ * escribir a mano y ninguno puede confundirse con otra cosa, porque después
+ * pasa el mismo `esModuloHookTs`.
+ */
+export declare function cargarHookTs(rutaAbsoluta: string): Promise<ResultadoCargaHook>;
+//# sourceMappingURL=cargador.d.ts.map

package/dist/core/hooks-ts/cargador.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cargador.d.ts","sourceRoot":"","sources":["../../../src/core/hooks-ts/cargador.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhE,2EAA2E;AAC3E,eAAO,MAAM,8BAA8B,QAAS,CAAC;AAErD,MAAM,WAAW,kBAAkB;IAClC,IAAI,EAAE,aAAa,GAAG,IAAI,CAAC;IAC3B,+EAA+E;IAC/E,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB;AAaD;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAiBpF"}

package/dist/core/hooks-ts/cargador.js

@@ -0,0 +1,51 @@
+/**
+ * Cargador de hooks TypeScript in-process — B05.
+ *
+ * Usa jiti, el mismo cargador que las extensions: un hook es un fichero .ts
+ * que se compila al vuelo y se importa como módulo. La diferencia con una
+ * extensión es el contrato: aquí no hay factory con API, solo un objeto
+ * `{matcher?, onToolCall}` validado con `esModuloHookTs` ANTES de usarse.
+ *
+ * Fail-closed: este módulo nunca lanza. Un hook que no existe, que no
+ * compila o que exporta otra cosa se traduce en `null` (o en el error
+ * legible del resultado), y es cosa del runner decidir qué hacer con él.
+ */
+import { createJiti } from "jiti/static";
+import { esModuloHookTs } from "./tipos.js";
+/** Timeout por defecto por hook; igual que el runner de hooks de shell. */
+export const TIMEOUT_HOOK_TS_POR_DEFECTO_MS = 10_000;
+let _jiti = null;
+function jitiDelCargador() {
+    if (!_jiti) {
+        // moduleCache: false — editar el .ts del hook debe surtir efecto sin
+        // reiniciar, igual que las extensions.
+        _jiti = createJiti(import.meta.url, { moduleCache: false });
+    }
+    return _jiti;
+}
+/**
+ * Carga un hook TS desde disco y valida su forma.
+ *
+ * Acepta default export y named export (`hook`): ambos son cómodos de
+ * escribir a mano y ninguno puede confundirse con otra cosa, porque después
+ * pasa el mismo `esModuloHookTs`.
+ */
+export async function cargarHookTs(rutaAbsoluta) {
+    let modulo;
+    try {
+        modulo = await jitiDelCargador().import(rutaAbsoluta);
+    }
+    catch (err) {
+        return { hook: null, error: `No se pudo cargar el hook ${rutaAbsoluta}: ${String(err)}` };
+    }
+    const candidatos = typeof modulo === "object" && modulo !== null
+        ? [modulo.default, modulo.hook, modulo]
+        : [modulo];
+    for (const candidato of candidatos) {
+        if (esModuloHookTs(candidato)) {
+            return { hook: { origen: rutaAbsoluta, hook: candidato }, error: null };
+        }
+    }
+    return { hook: null, error: `${rutaAbsoluta} no exporta un hook TS válido ({matcher?, onToolCall})` };
+}
+//# sourceMappingURL=cargador.js.map

package/dist/core/hooks-ts/cargador.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cargador.js","sourceRoot":"","sources":["../../../src/core/hooks-ts/cargador.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,cAAc,EAAsB,MAAM,YAAY,CAAC;AAEhE,2EAA2E;AAC3E,MAAM,CAAC,MAAM,8BAA8B,GAAG,MAAM,CAAC;AAQrD,IAAI,KAAK,GAAyC,IAAI,CAAC;AAEvD,SAAS,eAAe;IACvB,IAAI,CAAC,KAAK,EAAE,CAAC;QACZ,qEAAqE;QACrE,uCAAuC;QACvC,KAAK,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;IAC7D,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,YAAoB;IACtD,IAAI,MAAe,CAAC;IACpB,IAAI,CAAC;QACJ,MAAM,GAAG,MAAM,eAAe,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IACvD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACd,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,6BAA6B,YAAY,KAAK,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;IAC3F,CAAC;IACD,MAAM,UAAU,GACf,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI;QAC5C,CAAC,CAAC,CAAE,MAAkC,CAAC,OAAO,EAAG,MAAkC,CAAC,IAAI,EAAE,MAAM,CAAC;QACjG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IACb,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACpC,IAAI,cAAc,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/B,OAAO,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACzE,CAAC;IACF,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,YAAY,wDAAwD,EAAE,CAAC;AACvG,CAAC"}

package/dist/core/hooks-ts/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Hooks TypeScript in-process — B05.
+ *
+ * Complementa (no sustituye) los hooks de shell de `core/hooks/`: mismos
+ * reflejos — matcher con la semántica de `planificarHooks`, fail-closed por
+ * defecto, nunca lanzar desde el runner — pero recibiendo objetos tipados y
+ * pudiendo REESCRIBIR el input de una tool.
+ *
+ * Contrato del consumidor (invariante de seguridad, ver runner.ts):
+ *
+ *   const r = await ejecutarHooksTs(hooks, entrada);
+ *   if (r.bloquea) return bloquear(r.motivo);
+ *   let input = entrada.input;
+ *   if (r.requiereAprobacion) {
+ *     // «approve one thing, run another»: re-aprobar SIEMPRE sobre
+ *     // effectiveParams, nunca sobre el input original que se aprobó antes.
+ *     input = await reaprobar(entrada.toolName, r.effectiveParams!);
+ *   }
+ *   // ejecutar con `input`
+ *
+ */
+export { cargarHookTs, TIMEOUT_HOOK_TS_POR_DEFECTO_MS } from "./cargador.ts";
+export { ejecutarHooksTs, type OpcionesRunnerHooksTs, type ResultadoHooksTs } from "./runner.ts";
+export { casaMatcher, type EntradaToolCall, esModuloHookTs, esVeredictoHookTs, type HookTsCargado, type ModuloHookTs, VEREDICTOS_HOOK_TS, type Veredicto, type VeredictoHookTs, } from "./tipos.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/hooks-ts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/hooks-ts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,YAAY,EAAE,8BAA8B,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,KAAK,qBAAqB,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACjG,OAAO,EACN,WAAW,EACX,KAAK,eAAe,EACpB,cAAc,EACd,iBAAiB,EACjB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,kBAAkB,EAClB,KAAK,SAAS,EACd,KAAK,eAAe,GACpB,MAAM,YAAY,CAAC"}

package/dist/core/hooks-ts/index.js

@@ -0,0 +1,25 @@
+/**
+ * Hooks TypeScript in-process — B05.
+ *
+ * Complementa (no sustituye) los hooks de shell de `core/hooks/`: mismos
+ * reflejos — matcher con la semántica de `planificarHooks`, fail-closed por
+ * defecto, nunca lanzar desde el runner — pero recibiendo objetos tipados y
+ * pudiendo REESCRIBIR el input de una tool.
+ *
+ * Contrato del consumidor (invariante de seguridad, ver runner.ts):
+ *
+ *   const r = await ejecutarHooksTs(hooks, entrada);
+ *   if (r.bloquea) return bloquear(r.motivo);
+ *   let input = entrada.input;
+ *   if (r.requiereAprobacion) {
+ *     // «approve one thing, run another»: re-aprobar SIEMPRE sobre
+ *     // effectiveParams, nunca sobre el input original que se aprobó antes.
+ *     input = await reaprobar(entrada.toolName, r.effectiveParams!);
+ *   }
+ *   // ejecutar con `input`
+ *
+ */
+export { cargarHookTs, TIMEOUT_HOOK_TS_POR_DEFECTO_MS } from "./cargador.js";
+export { ejecutarHooksTs } from "./runner.js";
+export { casaMatcher, esModuloHookTs, esVeredictoHookTs, VEREDICTOS_HOOK_TS, } from "./tipos.js";
+//# sourceMappingURL=index.js.map

package/dist/core/hooks-ts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/hooks-ts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,YAAY,EAAE,8BAA8B,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAqD,MAAM,aAAa,CAAC;AACjG,OAAO,EACN,WAAW,EAEX,cAAc,EACd,iBAAiB,EAGjB,kBAAkB,GAGlB,MAAM,YAAY,CAAC"}

package/dist/core/hooks-ts/runner.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Runner de los hooks TypeScript in-process — B05.
+ *
+ * Ejecuta los hooks en orden determinista (ordenados por `origen`, el primer
+ * veredicto que bloquea gana) y compite cada `onToolCall` contra un timer con
+ * `raceHandlerWithTimeout` del kit de higiene: un hook colgado o que revienta
+ * queda aislado y se resuelve según `failClosed` (por defecto, cerrar).
+ *
+ * El invariante que da nombre a la brecha que cierra («approve one thing,
+ * run another»): una reescritura NUNCA sale de aquí lista para aplicar. Si
+ * `effectiveParams` difiere del input recibido, el resultado lleva
+ * `requiereAprobacion: true` y el consumidor está obligado a re-aprobar SOBRE
+ * LOS PARÁMETROS EFECTIVOS antes de ejecutar nada. No existe camino por el
+ * que este runner devuelva `effectiveParams` sin esa marca.
+ */
+import { type EntradaToolCall, type HookTsCargado } from "./tipos.ts";
+export interface ResultadoHooksTs {
+    /** true = no ejecutar la herramienta. */
+    bloquea: boolean;
+    motivo: string;
+    /**
+     * Invariante de seguridad B05. true ⇔ algún hook propuso `effectiveParams`
+     * distinto del input con el que entró la llamada. El consumidor debe
+     * re-aprobar sobre esos parámetros antes de usarlos; aplicarlos directo
+     * ejecutaría algo que nadie aprobó.
+     */
+    requiereAprobacion: boolean;
+    effectiveParams?: Record<string, unknown>;
+}
+export interface OpcionesRunnerHooksTs {
+    timeoutMs?: number;
+    /** Un hook que se cuelga o revienta cierra el paso. Por defecto true. */
+    failClosed?: boolean;
+}
+/**
+ * Ejecuta los hooks TS sobre una llamada a tool y devuelve la decisión
+ * agregada. Nunca lanza: un módulo dinámico no puede tumbar el turno.
+ */
+export declare function ejecutarHooksTs(hooks: readonly HookTsCargado[], entrada: EntradaToolCall, opciones?: OpcionesRunnerHooksTs): Promise<ResultadoHooksTs>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/core/hooks-ts/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/core/hooks-ts/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,EAEN,KAAK,eAAe,EAEpB,KAAK,aAAa,EAGlB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,gBAAgB;IAChC,yCAAyC;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,UAAU,CAAC,EAAE,OAAO,CAAC;CACrB;AAWD;;;GAGG;AACH,wBAAsB,eAAe,CACpC,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,OAAO,EAAE,eAAe,EACxB,QAAQ,GAAE,qBAA0B,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAqE3B"}