@hoilab/ada-cli 0.84.22 → 0.85.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../../src/core/hooks/contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,yDAAyD;AACzD,MAAM,CAAC,MAAM,YAAY,GAAG;IAC3B,eAAe;IACf,oBAAoB;IACpB,cAAc;IACd,eAAe;IACf,cAAc;IACd,MAAM;IACN,eAAe;CACN,CAAC;AAkCX;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAAC,MAA+B,EAAE,MAAkB,EAAE,QAAgB,EAAkB;IACtH,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,OAAO,KAAK,KAAK;QAAE,OAAO,EAAE,CAAC;IACnD,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IAChD,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO,KAAK,CAAC;QAChC,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC;QAC/B,IAAI,CAAC;YACJ,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAChD,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,KAAK,CAAC;QACd,CAAC;IAAA,CACD,CAAC,CAAC;AAAA,CACH;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,SAAwB,EAAuB;IAC3E,MAAM,KAAK,GAAG,CAAC,SAAS,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IAC9C,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,IAAI,CAAC;QACJ,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAA4B,CAAC;QAC1D,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC;QACzC,IAAI,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,MAAM,IAAI,QAAQ,KAAK,KAAK,EAAE,CAAC;YACvE,OAAO,OAAO,IAAI,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QACzE,CAAC;QACD,OAAO;YACN,kBAAkB,EAAE,QAAQ;YAC5B,MAAM,EAAE,OAAO,IAAI,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;SACjE,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACR,qEAAoE;QACpE,OAAO,IAAI,CAAC;IACb,CAAC;AAAA,CACD;AAED,0EAAyE;AACzE,SAAS,YAAY,CAAC,KAAmB,EAAmB;IAC3D,QAAQ,KAAK,EAAE,CAAC;QACf,KAAK,MAAM;YACV,OAAO,MAAM,CAAC;QACf,KAAK,QAAQ;YACZ,OAAO,KAAK,CAAC;QACd;YACC,OAAO,OAAO,CAAC;IACjB,CAAC;AAAA,CACD;AAED,MAAM,KAAK,GAAoC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;AAE7E;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAC/B,UAA2B,EAC3B,KAAmB,EACnB,UAAmB,EACgC;IACnD,IAAI,IAAI,GAAoB,YAAY,CAAC,KAAK,CAAC,CAAC;IAChD,MAAM,OAAO,GAAa,EAAE,CAAC;IAE7B,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACpC,MAAM,KAAK,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;QACtC,IAAI,KAAK,EAAE,MAAM;YAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAE9C,IAAI,SAAS,GAA2B,IAAI,CAAC;QAC7C,IAAI,SAAS,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;YAC9B,SAAS,GAAG,MAAM,CAAC;YACnB,IAAI,CAAC,KAAK,EAAE,MAAM,IAAI,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE;gBAAE,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;QACvF,CAAC;aAAM,IAAI,SAAS,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;YACrC,IAAI,UAAU,EAAE,CAAC;gBAChB,SAAS,GAAG,MAAM,CAAC;gBACnB,OAAO,CAAC,IAAI,CAAC,2BAAyB,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC;YAC7D,CAAC;QACF,CAAC;aAAM,IAAI,KAAK,EAAE,kBAAkB,EAAE,CAAC;YACtC,SAAS,GAAG,KAAK,CAAC,kBAAkB,CAAC;QACtC,CAAC;QAED,IAAI,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC;YAAE,IAAI,GAAG,SAAS,CAAC;IACnE,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,CACnC;AAED,iFAAgF;AAChF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAEnC;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,eAAuB,EAAW;IACvE,OAAO,eAAe,GAAG,iBAAiB,CAAC;AAAA,CAC3C","sourcesContent":["/**\n * Contrato de los hooks: qué se dispara, y qué puede decidir.\n *\n * Este fichero es PURO a propósito — no lanza procesos ni toca disco. Aquí vive\n * la parte que hay que poder probar sin montar nada: qué hooks casan con un\n * evento, y cómo se combinan sus respuestas.\n *\n * La regla que nos separa del contrato que copiamos: **un hook solo puede\n * estrechar permisos, nunca ampliarlos**. Si un hook pudiera responder \"allow\"\n * y saltarse el modo activo, instalar un plugin de terceros equivaldría a\n * desactivar la gobernanza del producto — que es justo lo que vendemos. Un\n * \"deny\" siempre vale; un \"allow\" solo vale donde el modo ya permitía.\n */\n\n/** Los 7 momentos en los que se puede enganchar algo. */\nexport const EVENTOS_HOOK = [\n\t\"session_start\",\n\t\"user_prompt_submit\",\n\t\"pre_tool_use\",\n\t\"post_tool_use\",\n\t\"notification\",\n\t\"stop\",\n\t\"subagent_stop\",\n] as const;\n\nexport type EventoHook = (typeof EVENTOS_HOOK)[number];\n\nexport type NivelPermiso = \"plan\" | \"manual\" | \"auto\" | \"yolo\";\n\nexport type DecisionPermiso = \"allow\" | \"deny\" | \"ask\";\n\nexport interface HookDefinido {\n\t/** Expresión regular contra el nombre de la herramienta (o el evento). */\n\tmatcher?: string;\n\tcommand: string;\n\ttimeoutMs?: number;\n}\n\nexport interface ConfigHooks {\n\tenabled?: boolean;\n\t/** Sin terminal donde preguntar, un hook que falla debe bloquear, no colar. */\n\tfailClosedHeadless?: boolean;\n\tevents?: Partial<Record<EventoHook, HookDefinido[]>>;\n}\n\nexport interface RespuestaHook {\n\t/** 0 = siguió; 2 = bloquea; cualquier otro = el hook falló. */\n\texitCode: number;\n\tstdout?: string;\n\tstderr?: string;\n}\n\nexport interface DecisionHook {\n\tpermissionDecision?: DecisionPermiso;\n\treason?: string;\n}\n\n/**\n * Qué hooks corren para un evento.\n *\n * El matcher se prueba contra `objetivo` — el nombre de la herramienta en\n * `pre_tool_use`/`post_tool_use`, y el propio evento en los demás. Un matcher\n * ausente casa con todo.\n *\n * Un matcher con una expresión regular inválida NO casa y no revienta: un\n * `settings.json` con una errata no puede tumbar la sesión, y tampoco puede\n * convertirse en un comodín silencioso que dispare hooks de más.\n */\nexport function planificarHooks(config: ConfigHooks | undefined, evento: EventoHook, objetivo: string): HookDefinido[] {\n\tif (!config || config.enabled === false) return [];\n\tconst definidos = config.events?.[evento] ?? [];\n\treturn definidos.filter((hook) => {\n\t\tif (!hook.command) return false;\n\t\tif (!hook.matcher) return true;\n\t\ttry {\n\t\t\treturn new RegExp(hook.matcher).test(objetivo);\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t});\n}\n\n/**\n * Lee la decisión que un hook escribe en stdout.\n *\n * Devuelve `null` si no dijo nada legible, que es el caso normal: la mayoría de\n * los hooks solo quieren correr y salir con 0.\n */\nexport function leerDecision(respuesta: RespuestaHook): DecisionHook | null {\n\tconst texto = (respuesta.stdout ?? \"\").trim();\n\tif (!texto) return null;\n\ttry {\n\t\tconst dato = JSON.parse(texto) as Record<string, unknown>;\n\t\tconst decision = dato.permissionDecision;\n\t\tif (decision !== \"allow\" && decision !== \"deny\" && decision !== \"ask\") {\n\t\t\treturn typeof dato.reason === \"string\" ? { reason: dato.reason } : null;\n\t\t}\n\t\treturn {\n\t\t\tpermissionDecision: decision,\n\t\t\treason: typeof dato.reason === \"string\" ? dato.reason : undefined,\n\t\t};\n\t} catch {\n\t\t// stdout que no es JSON es solo registro del hook, no una decisión.\n\t\treturn null;\n\t}\n}\n\n/** Lo que el modo activo concede por sí solo, sin hooks de por medio. */\nfunction techoDelModo(nivel: NivelPermiso): DecisionPermiso {\n\tswitch (nivel) {\n\t\tcase \"plan\":\n\t\t\treturn \"deny\";\n\t\tcase \"manual\":\n\t\t\treturn \"ask\";\n\t\tdefault:\n\t\t\treturn \"allow\";\n\t}\n}\n\nconst ORDEN: Record<DecisionPermiso, number> = { allow: 0, ask: 1, deny: 2 };\n\n/**\n * Combina las respuestas de todos los hooks de un evento con el modo activo.\n *\n * Gana siempre la más restrictiva, incluido el techo del modo. Por eso un hook\n * que responde \"allow\" en modo manual acaba en \"ask\", y en modo plan en \"deny\":\n * puede apretar, no aflojar.\n *\n * Salir con 2 equivale a \"deny\" aunque el hook no escriba JSON — es el atajo\n * del contrato para un script de una línea. Salir con cualquier otro código\n * distinto de 0 es un hook roto: bloquea si `failClosed`, y si no se ignora\n * (pero el motivo se devuelve para poder registrarlo).\n */\nexport function resolverDecision(\n\trespuestas: RespuestaHook[],\n\tnivel: NivelPermiso,\n\tfailClosed: boolean,\n): { decision: DecisionPermiso; motivos: string[] } {\n\tlet peor: DecisionPermiso = techoDelModo(nivel);\n\tconst motivos: string[] = [];\n\n\tfor (const respuesta of respuestas) {\n\t\tconst leida = leerDecision(respuesta);\n\t\tif (leida?.reason) motivos.push(leida.reason);\n\n\t\tlet candidata: DecisionPermiso | null = null;\n\t\tif (respuesta.exitCode === 2) {\n\t\t\tcandidata = \"deny\";\n\t\t\tif (!leida?.reason && respuesta.stderr?.trim()) motivos.push(respuesta.stderr.trim());\n\t\t} else if (respuesta.exitCode !== 0) {\n\t\t\tif (failClosed) {\n\t\t\t\tcandidata = \"deny\";\n\t\t\t\tmotivos.push(`hook falló con código ${respuesta.exitCode}`);\n\t\t\t}\n\t\t} else if (leida?.permissionDecision) {\n\t\t\tcandidata = leida.permissionDecision;\n\t\t}\n\n\t\tif (candidata && ORDEN[candidata] > ORDEN[peor]) peor = candidata;\n\t}\n\n\treturn { decision: peor, motivos };\n}\n\n/** Cuántas veces seguidas puede un hook `stop` impedir que el turno termine. */\nexport const MAX_BLOQUEOS_STOP = 3;\n\n/**\n * ¿Se honra este bloqueo de `stop`?\n *\n * Con tope, porque sin él un hook mal escrito deja al agente dando vueltas para\n * siempre y consumiendo dinero. A la cuarta se ignora y el turno termina.\n */\nexport function permiteBloquearParada(bloqueosPrevios: number): boolean {\n\treturn bloqueosPrevios < MAX_BLOQUEOS_STOP;\n}\n"]}

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","sourcesContent":["/**\n * Ejecuta los hooks. Todo lo que decide vive en `contract.ts`; aquí solo se\n * lanzan procesos y se recogen sus respuestas.\n *\n * El contrato con el proceso es deliberadamente pobre, para que escribir un\n * hook sea cosa de tres líneas de shell: recibe un JSON por stdin, y contesta\n * con su código de salida (0 sigue, 2 bloquea) y, si quiere afinar, un JSON por\n * stdout.\n */\n\nimport { spawn } from \"node:child_process\";\nimport type { EventoHook, HookDefinido, RespuestaHook } from \"./contract.ts\";\n\n/** Un hook que escupe sin parar no puede tumbar el proceso del agente. */\nconst MAX_SALIDA = 64 * 1024;\nconst TIMEOUT_POR_DEFECTO_MS = 10_000;\n\nexport interface ContextoHook {\n\tevento: EventoHook;\n\tsessionId: string;\n\tcwd: string;\n\ttoolName?: string;\n\ttoolInput?: unknown;\n\ttoolResult?: unknown;\n\tprompt?: string;\n\tmessage?: string;\n}\n\n/**\n * Lanza un hook y espera su respuesta.\n *\n * Nunca lanza excepción: un hook que no existe, que peta o que se cuelga se\n * traduce a un `exitCode` distinto de 0, y es `resolverDecision` quien decide\n * si eso bloquea o se ignora. Si esto lanzara, un hook roto tumbaría el turno\n * saltándose la política de `failClosed`.\n */\nexport async function ejecutarHook(\n\thook: HookDefinido,\n\tcontexto: ContextoHook,\n\topciones: { env?: NodeJS.ProcessEnv } = {},\n): Promise<RespuestaHook> {\n\tconst entrada = JSON.stringify(contexto);\n\tconst timeoutMs = hook.timeoutMs && hook.timeoutMs > 0 ? hook.timeoutMs : TIMEOUT_POR_DEFECTO_MS;\n\n\treturn new Promise<RespuestaHook>((resolve) => {\n\t\tlet hijo: ReturnType<typeof spawn>;\n\t\ttry {\n\t\t\thijo = spawn(hook.command, {\n\t\t\t\tshell: true,\n\t\t\t\tcwd: contexto.cwd,\n\t\t\t\t// El evento va también por entorno: un hook de una línea puede\n\t\t\t\t// ramificar con `$ADA_HOOK_EVENT` sin parsear el JSON.\n\t\t\t\tenv: { ...process.env, ...opciones.env, ADA_HOOK_EVENT: contexto.evento },\n\t\t\t\tstdio: [\"pipe\", \"pipe\", \"pipe\"],\n\t\t\t});\n\t\t} catch (error) {\n\t\t\tresolve({ exitCode: 127, stderr: error instanceof Error ? error.message : String(error) });\n\t\t\treturn;\n\t\t}\n\n\t\tlet stdout = \"\";\n\t\tlet stderr = \"\";\n\t\tlet resuelto = false;\n\t\tconst terminar = (respuesta: RespuestaHook) => {\n\t\t\tif (resuelto) return;\n\t\t\tresuelto = true;\n\t\t\tclearTimeout(reloj);\n\t\t\tresolve(respuesta);\n\t\t};\n\n\t\tconst reloj = setTimeout(() => {\n\t\t\thijo.kill(\"SIGKILL\");\n\t\t\tterminar({ exitCode: 124, stdout, stderr: `${stderr}\\nhook agotó su tiempo (${timeoutMs} ms)` });\n\t\t}, timeoutMs);\n\n\t\thijo.stdout?.on(\"data\", (trozo: Buffer) => {\n\t\t\tif (stdout.length < MAX_SALIDA) stdout += trozo.toString(\"utf8\");\n\t\t});\n\t\thijo.stderr?.on(\"data\", (trozo: Buffer) => {\n\t\t\tif (stderr.length < MAX_SALIDA) stderr += trozo.toString(\"utf8\");\n\t\t});\n\t\thijo.on(\"error\", (error) => terminar({ exitCode: 127, stdout, stderr: error.message }));\n\t\thijo.on(\"close\", (codigo) => terminar({ exitCode: codigo ?? 0, stdout, stderr }));\n\n\t\t// Cerrar stdin siempre: sin esto, un hook que lea hasta EOF se cuelga\n\t\t// hasta agotar el temporizador y todo el turno espera con él.\n\t\thijo.stdin?.on(\"error\", () => {});\n\t\thijo.stdin?.end(entrada);\n\t});\n}\n\n/**\n * Ejecuta varios hooks en serie.\n *\n * En serie y no en paralelo a propósito: los hooks de `pre_tool_use` existen\n * para vetar, y dos vetos concurrentes sobre el mismo fichero se pisan. El\n * coste es aceptable porque cada uno tiene su propio tope de tiempo.\n */\nexport async function ejecutarHooks(\n\thooks: HookDefinido[],\n\tcontexto: ContextoHook,\n\topciones: { env?: NodeJS.ProcessEnv } = {},\n): Promise<RespuestaHook[]> {\n\tconst respuestas: RespuestaHook[] = [];\n\tfor (const hook of hooks) {\n\t\trespuestas.push(await ejecutarHook(hook, contexto, opciones));\n\t}\n\treturn respuestas;\n}\n"]}

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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","sourcesContent":["/**\n * Ejecuta los hooks. Todo lo que decide vive en `contract.ts`; aquí solo se\n * lanzan procesos y se recogen sus respuestas.\n *\n * El contrato con el proceso es deliberadamente pobre, para que escribir un\n * hook sea cosa de tres líneas de shell: recibe un JSON por stdin, y contesta\n * con su código de salida (0 sigue, 2 bloquea) y, si quiere afinar, un JSON por\n * stdout.\n */\n\nimport { spawn } from \"node:child_process\";\nimport type { EventoHook, HookDefinido, RespuestaHook } from \"./contract.ts\";\n\n/** Un hook que escupe sin parar no puede tumbar el proceso del agente. */\nconst MAX_SALIDA = 64 * 1024;\nconst TIMEOUT_POR_DEFECTO_MS = 10_000;\n\nexport interface ContextoHook {\n\tevento: EventoHook;\n\tsessionId: string;\n\tcwd: string;\n\ttoolName?: string;\n\ttoolInput?: unknown;\n\ttoolResult?: unknown;\n\tprompt?: string;\n\tmessage?: string;\n}\n\n/**\n * Lanza un hook y espera su respuesta.\n *\n * Nunca lanza excepción: un hook que no existe, que peta o que se cuelga se\n * traduce a un `exitCode` distinto de 0, y es `resolverDecision` quien decide\n * si eso bloquea o se ignora. Si esto lanzara, un hook roto tumbaría el turno\n * saltándose la política de `failClosed`.\n */\nexport async function ejecutarHook(\n\thook: HookDefinido,\n\tcontexto: ContextoHook,\n\topciones: { env?: NodeJS.ProcessEnv } = {},\n): Promise<RespuestaHook> {\n\tconst entrada = JSON.stringify(contexto);\n\tconst timeoutMs = hook.timeoutMs && hook.timeoutMs > 0 ? hook.timeoutMs : TIMEOUT_POR_DEFECTO_MS;\n\n\treturn new Promise<RespuestaHook>((resolve) => {\n\t\tlet hijo: ReturnType<typeof spawn>;\n\t\ttry {\n\t\t\thijo = spawn(hook.command, {\n\t\t\t\tshell: true,\n\t\t\t\tcwd: contexto.cwd,\n\t\t\t\t// El evento va también por entorno: un hook de una línea puede\n\t\t\t\t// ramificar con `$ADA_HOOK_EVENT` sin parsear el JSON.\n\t\t\t\tenv: { ...process.env, ...opciones.env, ADA_HOOK_EVENT: contexto.evento },\n\t\t\t\tstdio: [\"pipe\", \"pipe\", \"pipe\"],\n\t\t\t});\n\t\t} catch (error) {\n\t\t\tresolve({ exitCode: 127, stderr: error instanceof Error ? error.message : String(error) });\n\t\t\treturn;\n\t\t}\n\n\t\tlet stdout = \"\";\n\t\tlet stderr = \"\";\n\t\tlet resuelto = false;\n\t\tconst terminar = (respuesta: RespuestaHook) => {\n\t\t\tif (resuelto) return;\n\t\t\tresuelto = true;\n\t\t\tclearTimeout(reloj);\n\t\t\tresolve(respuesta);\n\t\t};\n\n\t\tconst reloj = setTimeout(() => {\n\t\t\thijo.kill(\"SIGKILL\");\n\t\t\tterminar({ exitCode: 124, stdout, stderr: `${stderr}\\nhook agotó su tiempo (${timeoutMs} ms)` });\n\t\t}, timeoutMs);\n\n\t\thijo.stdout?.on(\"data\", (trozo: Buffer) => {\n\t\t\tif (stdout.length < MAX_SALIDA) stdout += trozo.toString(\"utf8\");\n\t\t});\n\t\thijo.stderr?.on(\"data\", (trozo: Buffer) => {\n\t\t\tif (stderr.length < MAX_SALIDA) stderr += trozo.toString(\"utf8\");\n\t\t});\n\t\thijo.on(\"error\", (error) => terminar({ exitCode: 127, stdout, stderr: error.message }));\n\t\thijo.on(\"close\", (codigo) => terminar({ exitCode: codigo ?? 0, stdout, stderr }));\n\n\t\t// Cerrar stdin siempre: sin esto, un hook que lea hasta EOF se cuelga\n\t\t// hasta agotar el temporizador y todo el turno espera con él.\n\t\thijo.stdin?.on(\"error\", () => {});\n\t\thijo.stdin?.end(entrada);\n\t});\n}\n\n/**\n * Ejecuta varios hooks en serie.\n *\n * En serie y no en paralelo a propósito: los hooks de `pre_tool_use` existen\n * para vetar, y dos vetos concurrentes sobre el mismo fichero se pisan. El\n * coste es aceptable porque cada uno tiene su propio tope de tiempo.\n */\nexport async function ejecutarHooks(\n\thooks: HookDefinido[],\n\tcontexto: ContextoHook,\n\topciones: { env?: NodeJS.ProcessEnv } = {},\n): Promise<RespuestaHook[]> {\n\tconst respuestas: RespuestaHook[] = [];\n\tfor (const hook of hooks) {\n\t\trespuestas.push(await ejecutarHook(hook, contexto, opciones));\n\t}\n\treturn respuestas;\n}\n"]}

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

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,EAAgB;IACtE,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,kGAAiG;QACjG,4DAA2D,CAC5D,CAAC;IACF,OAAO,QAAQ,CAAC;AAAA,CAChB;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,EACZ;IAC1B,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,sCAAoC,WAAW,CAAC,CAAC,CAAC,KAAK,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE;KAC/E,CAAC;AAAA,CACF","sourcesContent":["/**\n * Pegamento entre la sesión y los hooks.\n *\n * Vive aparte de `agent-session.ts` a propósito: ese fichero es de upstream y\n * cada línea que le añadimos se paga en cada sincronización. Aquí cabe toda la\n * lógica y allí queda una llamada.\n *\n * Regla de oro del enganche: **si no hay hooks configurados para este evento,\n * esto no debe cambiar absolutamente nada**. `resolverDecision` devuelve el\n * techo del modo cuando no hay respuestas, y aplicar ese techo aquí bloquearía\n * cada herramienta en modo manual aunque el usuario no haya configurado un solo\n * hook. Por eso se sale antes de consultar nada.\n */\n\nimport type { EventoHook, NivelPermiso } from \"./contract.ts\";\nimport { planificarHooks, resolverDecision } from \"./contract.ts\";\nimport { type ContextoHook, ejecutarHooks } from \"./runner.ts\";\n\ninterface ConfigDelMotor {\n\thooks?: {\n\t\tenabled?: boolean;\n\t\tfailClosedHeadless?: boolean;\n\t\tevents?: Record<string, Array<{ matcher?: string; command: string; timeoutMs?: number }>>;\n\t};\n\tpermissions?: { level?: string };\n\tgoalEngine?: { planOnly?: boolean };\n}\n\n/** Los cuatro que existen de verdad. Si esta lista crece, crece el tipo. */\nconst NIVELES: readonly NivelPermiso[] = [\"plan\", \"manual\", \"auto\", \"yolo\"];\n\n/**\n * Nombres que la gente escribe esperando otra cosa, con su equivalente real.\n *\n * `ask` y `full` estaban en nuestro README y NO existen en el código. Un\n * comprador que ponía `level: \"full\"` esperando plena autonomía se quedaba en\n * `auto` —que aún pregunta en `bash`— y uno que ponía `\"ask\"` esperando\n * confirmación por acción también. Se traducen en vez de rechazarlos porque el\n * README los prometió: romperle la configuración a quien nos creyó sería\n * cobrarle nuestro error.\n */\nconst SINONIMOS: Readonly<Record<string, NivelPermiso>> = { ask: \"manual\", full: \"yolo\" };\n\n/**\n * El nivel de permisos efectivo.\n *\n * UN VALOR DESCONOCIDO NO SE LEE COMO EL POR DEFECTO. Antes, cualquier cosa que\n * no fuera `manual` ni `yolo` caía a `auto` en silencio: una errata como\n * `\"manaul\"` dejaba al usuario con más permisos de los que pidió y sin ningún\n * aviso. En una configuración de permisos, «no te he entendido» y «has elegido\n * el valor por defecto» son cosas distintas, y confundirlas es la familia de\n * fallos que más cara nos ha salido.\n *\n * Se avisa por `stderr` y se cae al MÁS RESTRICTIVO de los dos —`manual`, no\n * `auto`—: ante la duda, preguntar antes de escribir.\n */\nexport function nivelDesdeConfig(config: ConfigDelMotor): NivelPermiso {\n\tif (config.goalEngine?.planOnly === true) return \"plan\";\n\tconst nivel = config.permissions?.level;\n\tif (nivel === undefined || nivel === \"\") return \"auto\";\n\tif ((NIVELES as readonly string[]).includes(nivel)) return nivel as NivelPermiso;\n\tconst sinonimo = SINONIMOS[nivel];\n\tif (sinonimo) return sinonimo;\n\tconsole.error(\n\t\t`Ada: \"permissions.level\" vale \"${nivel}\", que no es ninguno de ${NIVELES.join(\", \")}. ` +\n\t\t\t'Se usa \"manual\" (pregunta antes de cada escritura) por ser el más restrictivo: un valor que no ' +\n\t\t\t\"se entiende no puede dar más permisos de los que pediste.\",\n\t);\n\treturn \"manual\";\n}\n\nexport interface ResultadoHooks {\n\t/** `true` si hay que impedir la acción. */\n\tbloquea: boolean;\n\tmotivo: string;\n}\n\nconst SIN_HOOKS: ResultadoHooks = { bloquea: false, motivo: \"\" };\n\n/**\n * Dispara los hooks de un evento y dice si hay que parar.\n *\n * `ask` se trata como bloqueo: aquí no hay a quién preguntar —el enganche corre\n * dentro de la llamada a la herramienta, no en el bucle de la interfaz—, y ante\n * la duda se cierra. El motivo lo explica al usuario, que puede reintentar tras\n * ajustar el hook o el modo.\n */\nexport async function dispararHooks(\n\tconfig: ConfigDelMotor,\n\tevento: EventoHook,\n\tobjetivo: string,\n\tcontexto: Omit<ContextoHook, \"evento\">,\n): Promise<ResultadoHooks> {\n\tconst hooks = planificarHooks(config.hooks, evento, objetivo);\n\t// Salida temprana: sin hooks configurados, ni se mira el modo. Ver cabecera.\n\tif (hooks.length === 0) return SIN_HOOKS;\n\n\tconst respuestas = await ejecutarHooks(hooks, { ...contexto, evento });\n\tconst { decision, motivos } = resolverDecision(\n\t\trespuestas,\n\t\tnivelDesdeConfig(config),\n\t\tconfig.hooks?.failClosedHeadless ?? true,\n\t);\n\tif (decision === \"allow\") return SIN_HOOKS;\n\n\tconst explicacion = motivos.filter(Boolean).join(\"; \");\n\treturn {\n\t\tbloquea: true,\n\t\tmotivo:\n\t\t\tdecision === \"deny\"\n\t\t\t\t? `Bloqueado por un hook${explicacion ? `: ${explicacion}` : \"\"}`\n\t\t\t\t: `Un hook pide aprobación explícita${explicacion ? `: ${explicacion}` : \"\"}`,\n\t};\n}\n"]}

package/dist/core/importar/formatos.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Importar sesiones de Claude Code y de Codex.
+ *
+ * Es coste de cambio. Quien lleva meses trabajando con otra herramienta tiene
+ * ahí su historial: lo que decidió, por qué, y las conversaciones que busca
+ * cuando vuelve a un proyecto. Pedirle que lo deje atrás es pedirle que empiece
+ * de cero, y eso pesa más que cualquier comparativa de capacidades.
+ *
+ * QUÉ SE IMPORTA Y QUÉ NO, dicho antes de que alguien lo descubra por su
+ * cuenta: se importa la CONVERSACIÓN —lo que se dijo, en orden y con su
+ * estructura de padres— y no el ESTADO. Las llamadas a herramientas y sus
+ * resultados se aplanan a texto legible, porque no se pueden reproducir: los
+ * ficheros han cambiado, los procesos murieron y los identificadores de
+ * herramienta no significan nada aquí. Una sesión importada sirve para leerla,
+ * buscarla y continuarla con contexto; no para rebobinarla.
+ *
+ * Fingir lo contrario sería peor que no importar: el usuario haría `undo` sobre
+ * una sesión importada y no pasaría nada.
+ */
+/** Una entrada del fichero de sesión de Ada. */
+export interface EntradaAda {
+    type: "session" | "message";
+    id: string;
+    parentId?: string;
+    timestamp: number;
+    cwd?: string;
+    version?: number;
+    message?: {
+        role: string;
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+        timestamp: number;
+    };
+}
+export type Formato = "claude-code" | "codex";
+/** Resumen de una sesión importable, para poder elegir sin abrirla. */
+export interface ResumenSesion {
+    formato: Formato;
+    ruta: string;
+    cwd: string;
+    mensajes: number;
+    primerPrompt: string;
+    cuando: number;
+}
+/**
+ * Claude Code: un JSONL con entradas `user` y `assistant` encadenadas por
+ * `parentUuid`. El resto de tipos (`attachment`, `queue-operation`, `mode`…) es
+ * estado interno suyo y no tiene sentido aquí.
+ */
+export declare function convertirClaudeCode(lineas: string[], idSesion: string): EntradaAda[];
+/**
+ * Codex: un «rollout» con `session_meta` y `response_item`.
+ *
+ * No trae cadena de padres, así que se encadena por orden de aparición, que es
+ * como se leyó la conversación. Los mensajes de rol `developer` son la
+ * inyección de sistema de su harness y no forman parte de lo que dijo nadie.
+ */
+export declare function convertirCodex(lineas: string[], idSesion: string): EntradaAda[];
+/** Reconoce el formato por la forma de sus líneas, no por la extensión. */
+export declare function detectarFormato(lineas: string[]): Formato | null;
+export declare function convertir(lineas: string[], idSesion: string): {
+    formato: Formato;
+    entradas: EntradaAda[];
+} | null;
+/** Lo que hace falta para elegir una sesión de una lista. */
+export declare function resumir(entradas: EntradaAda[], formato: Formato, ruta: string): ResumenSesion;
+//# sourceMappingURL=formatos.d.ts.map

package/dist/core/importar/formatos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatos.d.ts","sourceRoot":"","sources":["../../../src/core/importar/formatos.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,iDAAgD;AAChD,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9F;AAED,MAAM,MAAM,OAAO,GAAG,aAAa,GAAG,OAAO,CAAC;AAE9C,wEAAuE;AACvE,MAAM,WAAW,aAAa;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;CACf;AAkED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,EAAE,CA8BpF;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,EAAE,CAmC/E;AAED,6EAA2E;AAC3E,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,GAAG,IAAI,CAWhE;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,UAAU,EAAE,CAAA;CAAE,GAAG,IAAI,CAKjH;AAwBD,8DAA6D;AAC7D,wBAAgB,OAAO,CAAC,QAAQ,EAAE,UAAU,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAa7F","sourcesContent":["/**\n * Importar sesiones de Claude Code y de Codex.\n *\n * Es coste de cambio. Quien lleva meses trabajando con otra herramienta tiene\n * ahí su historial: lo que decidió, por qué, y las conversaciones que busca\n * cuando vuelve a un proyecto. Pedirle que lo deje atrás es pedirle que empiece\n * de cero, y eso pesa más que cualquier comparativa de capacidades.\n *\n * QUÉ SE IMPORTA Y QUÉ NO, dicho antes de que alguien lo descubra por su\n * cuenta: se importa la CONVERSACIÓN —lo que se dijo, en orden y con su\n * estructura de padres— y no el ESTADO. Las llamadas a herramientas y sus\n * resultados se aplanan a texto legible, porque no se pueden reproducir: los\n * ficheros han cambiado, los procesos murieron y los identificadores de\n * herramienta no significan nada aquí. Una sesión importada sirve para leerla,\n * buscarla y continuarla con contexto; no para rebobinarla.\n *\n * Fingir lo contrario sería peor que no importar: el usuario haría `undo` sobre\n * una sesión importada y no pasaría nada.\n */\n\n/** Una entrada del fichero de sesión de Ada. */\nexport interface EntradaAda {\n\ttype: \"session\" | \"message\";\n\tid: string;\n\tparentId?: string;\n\ttimestamp: number;\n\tcwd?: string;\n\tversion?: number;\n\tmessage?: { role: string; content: Array<{ type: string; text: string }>; timestamp: number };\n}\n\nexport type Formato = \"claude-code\" | \"codex\";\n\n/** Resumen de una sesión importable, para poder elegir sin abrirla. */\nexport interface ResumenSesion {\n\tformato: Formato;\n\truta: string;\n\tcwd: string;\n\tmensajes: number;\n\tprimerPrompt: string;\n\tcuando: number;\n}\n\nfunction aMilisegundos(valor: unknown): number {\n\tif (typeof valor === \"number\") return valor;\n\tif (typeof valor === \"string\") {\n\t\tconst t = Date.parse(valor);\n\t\tif (!Number.isNaN(t)) return t;\n\t}\n\treturn 0;\n}\n\n/**\n * Aplana el contenido de un mensaje a bloques de texto.\n *\n * Las llamadas a herramienta se convierten en una línea legible en vez de\n * desaparecer: leer «⚙ bash: npm test» explica el hilo de la conversación,\n * mientras que quitarlo deja saltos que no se entienden.\n */\nfunction aTexto(contenido: unknown): Array<{ type: string; text: string }> {\n\tif (typeof contenido === \"string\") return contenido.trim() ? [{ type: \"text\", text: contenido }] : [];\n\tif (!Array.isArray(contenido)) return [];\n\tconst bloques: Array<{ type: string; text: string }> = [];\n\tfor (const bruto of contenido) {\n\t\tif (typeof bruto === \"string\") {\n\t\t\tif (bruto.trim()) bloques.push({ type: \"text\", text: bruto });\n\t\t\tcontinue;\n\t\t}\n\t\tif (!bruto || typeof bruto !== \"object\") continue;\n\t\tconst b = bruto as Record<string, unknown>;\n\t\tswitch (b.type) {\n\t\t\tcase \"text\":\n\t\t\tcase \"input_text\":\n\t\t\tcase \"output_text\":\n\t\t\t\tif (typeof b.text === \"string\" && b.text.trim()) bloques.push({ type: \"text\", text: b.text });\n\t\t\t\tbreak;\n\t\t\tcase \"thinking\":\n\t\t\tcase \"reasoning\":\n\t\t\t\tif (typeof b.thinking === \"string\" && b.thinking.trim()) bloques.push({ type: \"text\", text: b.thinking });\n\t\t\t\tbreak;\n\t\t\tcase \"tool_use\":\n\t\t\tcase \"function_call\":\n\t\t\t\tbloques.push({\n\t\t\t\t\ttype: \"text\",\n\t\t\t\t\ttext: `⚙ ${String(b.name ?? \"herramienta\")}: ${JSON.stringify(b.input ?? b.arguments ?? {}).slice(0, 400)}`,\n\t\t\t\t});\n\t\t\t\tbreak;\n\t\t\tcase \"tool_result\":\n\t\t\tcase \"function_call_output\": {\n\t\t\t\tconst salida = aTexto(b.content ?? b.output)\n\t\t\t\t\t.map((x) => x.text)\n\t\t\t\t\t.join(\"\\n\");\n\t\t\t\tif (salida.trim()) bloques.push({ type: \"text\", text: `↩ ${salida.slice(0, 800)}` });\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tdefault:\n\t\t\t\tbreak;\n\t\t}\n\t}\n\treturn bloques;\n}\n\n/** La cabecera que abre un fichero de sesión de Ada. */\nfunction cabecera(id: string, cwd: string, cuando: number): EntradaAda {\n\treturn { type: \"session\", id, cwd, timestamp: cuando, version: 1 };\n}\n\n/**\n * Claude Code: un JSONL con entradas `user` y `assistant` encadenadas por\n * `parentUuid`. El resto de tipos (`attachment`, `queue-operation`, `mode`…) es\n * estado interno suyo y no tiene sentido aquí.\n */\nexport function convertirClaudeCode(lineas: string[], idSesion: string): EntradaAda[] {\n\tconst salida: EntradaAda[] = [];\n\tlet cwd = \"\";\n\tlet primero = 0;\n\tfor (const linea of lineas) {\n\t\tlet d: Record<string, unknown>;\n\t\ttry {\n\t\t\td = JSON.parse(linea) as Record<string, unknown>;\n\t\t} catch {\n\t\t\tcontinue;\n\t\t}\n\t\tif (d.type !== \"user\" && d.type !== \"assistant\") continue;\n\t\tconst mensaje = d.message as { role?: string; content?: unknown } | undefined;\n\t\tif (!mensaje) continue;\n\t\tconst bloques = aTexto(mensaje.content);\n\t\tif (bloques.length === 0) continue;\n\t\tconst cuando = aMilisegundos(d.timestamp);\n\t\tif (!cwd && typeof d.cwd === \"string\") cwd = d.cwd;\n\t\tif (!primero) primero = cuando;\n\t\tsalida.push({\n\t\t\ttype: \"message\",\n\t\t\tid: String(d.uuid ?? `${salida.length}`),\n\t\t\t// Se conserva la cadena de padres del origen: es lo que permite que\n\t\t\t// las ramas de la conversación sigan siendo ramas al importarlas.\n\t\t\t...(typeof d.parentUuid === \"string\" ? { parentId: d.parentUuid } : {}),\n\t\t\ttimestamp: cuando,\n\t\t\tmessage: { role: String(mensaje.role ?? d.type), content: bloques, timestamp: cuando },\n\t\t});\n\t}\n\treturn salida.length === 0 ? [] : [cabecera(idSesion, cwd, primero), ...salida];\n}\n\n/**\n * Codex: un «rollout» con `session_meta` y `response_item`.\n *\n * No trae cadena de padres, así que se encadena por orden de aparición, que es\n * como se leyó la conversación. Los mensajes de rol `developer` son la\n * inyección de sistema de su harness y no forman parte de lo que dijo nadie.\n */\nexport function convertirCodex(lineas: string[], idSesion: string): EntradaAda[] {\n\tconst salida: EntradaAda[] = [];\n\tlet cwd = \"\";\n\tlet primero = 0;\n\tlet anterior: string | undefined;\n\tfor (const linea of lineas) {\n\t\tlet d: Record<string, unknown>;\n\t\ttry {\n\t\t\td = JSON.parse(linea) as Record<string, unknown>;\n\t\t} catch {\n\t\t\tcontinue;\n\t\t}\n\t\tconst carga = d.payload as Record<string, unknown> | undefined;\n\t\tif (d.type === \"session_meta\" && carga && typeof carga.cwd === \"string\") {\n\t\t\tcwd = carga.cwd;\n\t\t\tcontinue;\n\t\t}\n\t\tif (d.type !== \"response_item\" || !carga || carga.type !== \"message\") continue;\n\t\tconst rol = String(carga.role ?? \"\");\n\t\tif (rol === \"developer\" || rol === \"system\") continue;\n\t\tconst bloques = aTexto(carga.content);\n\t\tif (bloques.length === 0) continue;\n\t\tconst cuando = aMilisegundos(d.timestamp);\n\t\tif (!primero) primero = cuando;\n\t\tconst id = String(carga.id ?? `${salida.length}`);\n\t\tsalida.push({\n\t\t\ttype: \"message\",\n\t\t\tid,\n\t\t\t...(anterior ? { parentId: anterior } : {}),\n\t\t\ttimestamp: cuando,\n\t\t\tmessage: { role: rol, content: bloques, timestamp: cuando },\n\t\t});\n\t\tanterior = id;\n\t}\n\treturn salida.length === 0 ? [] : [cabecera(idSesion, cwd, primero), ...salida];\n}\n\n/** Reconoce el formato por la forma de sus líneas, no por la extensión. */\nexport function detectarFormato(lineas: string[]): Formato | null {\n\tfor (const linea of lineas.slice(0, 40)) {\n\t\ttry {\n\t\t\tconst d = JSON.parse(linea) as Record<string, unknown>;\n\t\t\tif (d.type === \"session_meta\" || (d.type === \"response_item\" && d.payload)) return \"codex\";\n\t\t\tif ((d.type === \"user\" || d.type === \"assistant\") && d.message && d.sessionId) return \"claude-code\";\n\t\t} catch {\n\t\t\t// Una línea ilegible no dice nada del formato del fichero.\n\t\t}\n\t}\n\treturn null;\n}\n\nexport function convertir(lineas: string[], idSesion: string): { formato: Formato; entradas: EntradaAda[] } | null {\n\tconst formato = detectarFormato(lineas);\n\tif (!formato) return null;\n\tconst entradas = formato === \"codex\" ? convertirCodex(lineas, idSesion) : convertirClaudeCode(lineas, idSesion);\n\treturn entradas.length === 0 ? null : { formato, entradas };\n}\n\n/**\n * ¿Este mensaje de usuario lo escribió una persona, o lo inyectó el harness?\n *\n * Codex mete su `<environment_context>` y el AGENTS.md del proyecto como\n * mensajes de rol `user`, así que el \"primer prompt\" de media sesión importada\n * salía siendo un volcado de configuración. Se importan igual —formaban parte\n * del contexto— pero no sirven para que alguien reconozca su sesión en una\n * lista, que es para lo que existe el resumen.\n *\n * Se descubrió convirtiendo ficheros reales, no las muestras.\n */\nfunction pareceInyeccion(texto: string): boolean {\n\tconst inicio = texto.trimStart().slice(0, 120);\n\treturn (\n\t\tinicio.startsWith(\"<environment_context>\") ||\n\t\tinicio.startsWith(\"<INSTRUCTIONS>\") ||\n\t\tinicio.startsWith(\"# AGENTS.md\") ||\n\t\tinicio.startsWith(\"<skills_instructions>\") ||\n\t\tinicio.startsWith(\"<system-reminder>\")\n\t);\n}\n\n/** Lo que hace falta para elegir una sesión de una lista. */\nexport function resumir(entradas: EntradaAda[], formato: Formato, ruta: string): ResumenSesion {\n\tconst mensajes = entradas.filter((e) => e.type === \"message\");\n\tconst primerUsuario = mensajes.find(\n\t\t(e) => e.message?.role === \"user\" && !pareceInyeccion(e.message.content[0]?.text ?? \"\"),\n\t);\n\treturn {\n\t\tformato,\n\t\truta,\n\t\tcwd: entradas[0]?.cwd ?? \"\",\n\t\tmensajes: mensajes.length,\n\t\tprimerPrompt: (primerUsuario?.message?.content[0]?.text ?? \"\").replace(/\\s+/g, \" \").slice(0, 80),\n\t\tcuando: entradas[0]?.timestamp ?? 0,\n\t};\n}\n"]}