@hoilab/ada-cli 0.84.22 → 0.85.0

package/dist/core/interactivo/sesion.js

@@ -0,0 +1,156 @@
+/**
+ * Un proceso interactivo vivo, entre llamadas a tool.
+ *
+ * `bash` normal lanza y espera a que termine: una sola llamada, un solo
+ * resultado. Aquí el proceso sobrevive a la llamada que lo lanzó, para que
+ * una segunda llamada (`bash_enviar`) pueda escribirle más entrada — el
+ * "sí" a la confirmación, la contraseña, el siguiente comando del REPL.
+ *
+ * Reutiliza el MISMO seguimiento de huérfanos que ya usa `bash` normal
+ * (`trackDetachedChildPid` / `killTrackedDetachedChildren` en
+ * `utils/shell.ts`), que los tres modos del CLI —print, interactive, rpc—
+ * ya llaman al apagarse. No hace falta cablear un gancho de cierre nuevo:
+ * una sesión viva entra en el mismo Set que un `bash` colgado, y muere con
+ * él. Verificado en `sesion.test.ts` y con `ps` en el informe de la tarea.
+ */
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { getShellConfig, getShellEnv, killProcessTree, trackDetachedChildPid, untrackDetachedChildPid, } from "../../utils/shell.js";
+import { detectarEsperaEntrada } from "./deteccion.js";
+/** Cuánta salida sin consumir se retiene por sesión. Un REPL ruidoso no debe reventar memoria. */
+const MAX_PENDIENTE_BYTES = 200_000;
+const AVISO_RECORTE = "[…salida antigua descartada, sesión demasiado ruidosa…]\n";
+const sesiones = new Map();
+function normalizarChunk(buf) {
+    return buf.toString("utf8").replace(/\r\n/gu, "\n");
+}
+function acumular(s, texto) {
+    s.pendiente += texto;
+    s.ultimaActividad = Date.now();
+    if (s.pendiente.length > MAX_PENDIENTE_BYTES) {
+        s.pendiente = AVISO_RECORTE + s.pendiente.slice(-MAX_PENDIENTE_BYTES);
+    }
+}
+function limpiar(s) {
+    if (s.pid !== undefined)
+        untrackDetachedChildPid(s.pid);
+}
+/**
+ * Espera a que la sesión dé una señal (prompt detectado o proceso muerto) o
+ * agote el tiempo. Sondea cada 80ms: es rápido de sobra frente a lo que
+ * tarda un humano en leer un prompt, y no quema CPU con un intervalo menor.
+ */
+async function esperarSenal(s, timeoutMs, umbralInactividadMs) {
+    const limite = Date.now() + timeoutMs;
+    for (;;) {
+        const estado = detectarEsperaEntrada({
+            salidaReciente: s.pendiente,
+            msDesdeUltimaSalida: Date.now() - s.ultimaActividad,
+            vivo: s.vivo,
+            umbralInactividadMs,
+        });
+        if (estado.esperando || !s.vivo || Date.now() >= limite)
+            return estado;
+        await new Promise((resolve) => setTimeout(resolve, 80));
+    }
+}
+function consumir(s) {
+    const salida = s.pendiente;
+    s.pendiente = "";
+    return salida;
+}
+function aResultado(s, estado) {
+    return {
+        id: s.id,
+        comando: s.comando,
+        salida: consumir(s),
+        esperando: estado.esperando,
+        motivo: estado.motivo,
+        vivo: s.vivo,
+        codigoSalida: s.codigoSalida,
+    };
+}
+/** Lanza un proceso interactivo y espera hasta el primer prompt (o a que termine, o al timeout). */
+export async function lanzarSesionInteractiva(comando, opciones) {
+    const shellConfig = getShellConfig(opciones.shellPath);
+    const comandoDesdeStdin = shellConfig.commandTransport === "stdin";
+    const proceso = spawn(shellConfig.shell, comandoDesdeStdin ? shellConfig.args : [...shellConfig.args, comando], {
+        cwd: opciones.cwd,
+        detached: process.platform !== "win32",
+        env: getShellEnv(),
+        stdio: "pipe",
+        windowsHide: true,
+    });
+    const s = {
+        id: randomUUID(),
+        comando,
+        pid: proceso.pid,
+        proceso,
+        pendiente: "",
+        ultimaActividad: Date.now(),
+        vivo: true,
+        codigoSalida: null,
+    };
+    sesiones.set(s.id, s);
+    if (proceso.pid)
+        trackDetachedChildPid(proceso.pid);
+    proceso.stdout.on("data", (chunk) => acumular(s, normalizarChunk(chunk)));
+    proceso.stderr.on("data", (chunk) => acumular(s, normalizarChunk(chunk)));
+    proceso.stdin.on("error", () => {
+        // Escribir tras la muerte del proceso no debe tirar la sesión abajo:
+        // `bash_enviar` ya distingue "sesión muerta" por `vivo`.
+    });
+    proceso.on("exit", (code) => {
+        s.vivo = false;
+        s.codigoSalida = code;
+        limpiar(s);
+    });
+    // El comando en sí es la primera "entrada": en modo `-s` (bash de WSL legacy)
+    // se escribe por stdin en vez de pasar por argv, y el fd es el mismo tanto
+    // para el resto del script como para lo que el propio comando pida leer
+    // luego — es idéntico a teclearlo a mano.
+    if (comandoDesdeStdin) {
+        proceso.stdin.write(`${comando}\n`);
+    }
+    const estado = await esperarSenal(s, opciones.timeoutMs ?? 10_000, opciones.umbralInactividadMs ?? 1200);
+    return aResultado(s, estado);
+}
+/**
+ * Manda una línea a una sesión viva y espera la siguiente señal.
+ *
+ * `null` cuando la sesión no existe: NO es lo mismo que una sesión que
+ * existe pero no tiene nada nuevo que decir (eso es `salida: ""`).
+ */
+export async function enviarASesion(id, texto, opciones = {}) {
+    const s = sesiones.get(id);
+    if (!s)
+        return null;
+    if (!s.vivo)
+        return aResultado(s, { esperando: false, motivo: null });
+    s.proceso.stdin.write(`${texto}\n`);
+    const estado = await esperarSenal(s, opciones.timeoutMs ?? 10_000, opciones.umbralInactividadMs ?? 1200);
+    return aResultado(s, estado);
+}
+/** `null` si la sesión no existe; `true`/`false` según si había algo vivo que matar. */
+export function cerrarSesion(id) {
+    const s = sesiones.get(id);
+    if (!s)
+        return null;
+    const estabaViva = s.vivo;
+    if (s.pid !== undefined)
+        killProcessTree(s.pid);
+    s.vivo = false;
+    limpiar(s);
+    sesiones.delete(id);
+    return estabaViva;
+}
+/** Para pruebas y para el apagado del CLI: no debe sobrevivir ninguna. */
+export function cerrarTodasLasSesiones() {
+    for (const id of [...sesiones.keys()])
+        cerrarSesion(id);
+}
+/** Solo para pruebas: cuántas sesiones quedan registradas. */
+export function contarSesiones() {
+    return sesiones.size;
+}
+//# sourceMappingURL=sesion.js.map

package/dist/core/interactivo/sesion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sesion.js","sourceRoot":"","sources":["../../../src/core/interactivo/sesion.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Un proceso interactivo vivo, entre llamadas a tool.\n *\n * `bash` normal lanza y espera a que termine: una sola llamada, un solo\n * resultado. Aquí el proceso sobrevive a la llamada que lo lanzó, para que\n * una segunda llamada (`bash_enviar`) pueda escribirle más entrada — el\n * \"sí\" a la confirmación, la contraseña, el siguiente comando del REPL.\n *\n * Reutiliza el MISMO seguimiento de huérfanos que ya usa `bash` normal\n * (`trackDetachedChildPid` / `killTrackedDetachedChildren` en\n * `utils/shell.ts`), que los tres modos del CLI —print, interactive, rpc—\n * ya llaman al apagarse. No hace falta cablear un gancho de cierre nuevo:\n * una sesión viva entra en el mismo Set que un `bash` colgado, y muere con\n * él. Verificado en `sesion.test.ts` y con `ps` en el informe de la tarea.\n */\n\nimport { spawn } from \"node:child_process\";\nimport { randomUUID } from \"node:crypto\";\nimport {\n\tgetShellConfig,\n\tgetShellEnv,\n\tkillProcessTree,\n\ttrackDetachedChildPid,\n\tuntrackDetachedChildPid,\n} from \"../../utils/shell.ts\";\nimport { detectarEsperaEntrada } from \"./deteccion.ts\";\n\n/** Cuánta salida sin consumir se retiene por sesión. Un REPL ruidoso no debe reventar memoria. */\nconst MAX_PENDIENTE_BYTES = 200_000;\nconst AVISO_RECORTE = \"[…salida antigua descartada, sesión demasiado ruidosa…]\\n\";\n\ninterface SesionInteractiva {\n\tid: string;\n\tcomando: string;\n\tpid: number | undefined;\n\tproceso: import(\"node:child_process\").ChildProcessWithoutNullStreams;\n\t/** Lo que no se le ha devuelto todavía al agente. */\n\tpendiente: string;\n\tultimaActividad: number;\n\tvivo: boolean;\n\tcodigoSalida: number | null;\n}\n\nexport interface ResultadoSesion {\n\tid: string;\n\tcomando: string;\n\tsalida: string;\n\tesperando: boolean;\n\tmotivo: string | null;\n\tvivo: boolean;\n\tcodigoSalida: number | null;\n}\n\nconst sesiones = new Map<string, SesionInteractiva>();\n\nfunction normalizarChunk(buf: Buffer): string {\n\treturn buf.toString(\"utf8\").replace(/\\r\\n/gu, \"\\n\");\n}\n\nfunction acumular(s: SesionInteractiva, texto: string): void {\n\ts.pendiente += texto;\n\ts.ultimaActividad = Date.now();\n\tif (s.pendiente.length > MAX_PENDIENTE_BYTES) {\n\t\ts.pendiente = AVISO_RECORTE + s.pendiente.slice(-MAX_PENDIENTE_BYTES);\n\t}\n}\n\nfunction limpiar(s: SesionInteractiva): void {\n\tif (s.pid !== undefined) untrackDetachedChildPid(s.pid);\n}\n\n/**\n * Espera a que la sesión dé una señal (prompt detectado o proceso muerto) o\n * agote el tiempo. Sondea cada 80ms: es rápido de sobra frente a lo que\n * tarda un humano en leer un prompt, y no quema CPU con un intervalo menor.\n */\nasync function esperarSenal(\n\ts: SesionInteractiva,\n\ttimeoutMs: number,\n\tumbralInactividadMs: number,\n): Promise<ReturnType<typeof detectarEsperaEntrada>> {\n\tconst limite = Date.now() + timeoutMs;\n\tfor (;;) {\n\t\tconst estado = detectarEsperaEntrada({\n\t\t\tsalidaReciente: s.pendiente,\n\t\t\tmsDesdeUltimaSalida: Date.now() - s.ultimaActividad,\n\t\t\tvivo: s.vivo,\n\t\t\tumbralInactividadMs,\n\t\t});\n\t\tif (estado.esperando || !s.vivo || Date.now() >= limite) return estado;\n\t\tawait new Promise((resolve) => setTimeout(resolve, 80));\n\t}\n}\n\nfunction consumir(s: SesionInteractiva): string {\n\tconst salida = s.pendiente;\n\ts.pendiente = \"\";\n\treturn salida;\n}\n\nfunction aResultado(s: SesionInteractiva, estado: ReturnType<typeof detectarEsperaEntrada>): ResultadoSesion {\n\treturn {\n\t\tid: s.id,\n\t\tcomando: s.comando,\n\t\tsalida: consumir(s),\n\t\tesperando: estado.esperando,\n\t\tmotivo: estado.motivo,\n\t\tvivo: s.vivo,\n\t\tcodigoSalida: s.codigoSalida,\n\t};\n}\n\nexport interface OpcionesLanzar {\n\tcwd: string;\n\ttimeoutMs?: number;\n\tumbralInactividadMs?: number;\n\tshellPath?: string;\n}\n\n/** Lanza un proceso interactivo y espera hasta el primer prompt (o a que termine, o al timeout). */\nexport async function lanzarSesionInteractiva(comando: string, opciones: OpcionesLanzar): Promise<ResultadoSesion> {\n\tconst shellConfig = getShellConfig(opciones.shellPath);\n\tconst comandoDesdeStdin = shellConfig.commandTransport === \"stdin\";\n\tconst proceso = spawn(shellConfig.shell, comandoDesdeStdin ? shellConfig.args : [...shellConfig.args, comando], {\n\t\tcwd: opciones.cwd,\n\t\tdetached: process.platform !== \"win32\",\n\t\tenv: getShellEnv(),\n\t\tstdio: \"pipe\",\n\t\twindowsHide: true,\n\t});\n\n\tconst s: SesionInteractiva = {\n\t\tid: randomUUID(),\n\t\tcomando,\n\t\tpid: proceso.pid,\n\t\tproceso,\n\t\tpendiente: \"\",\n\t\tultimaActividad: Date.now(),\n\t\tvivo: true,\n\t\tcodigoSalida: null,\n\t};\n\tsesiones.set(s.id, s);\n\tif (proceso.pid) trackDetachedChildPid(proceso.pid);\n\n\tproceso.stdout.on(\"data\", (chunk: Buffer) => acumular(s, normalizarChunk(chunk)));\n\tproceso.stderr.on(\"data\", (chunk: Buffer) => acumular(s, normalizarChunk(chunk)));\n\tproceso.stdin.on(\"error\", () => {\n\t\t// Escribir tras la muerte del proceso no debe tirar la sesión abajo:\n\t\t// `bash_enviar` ya distingue \"sesión muerta\" por `vivo`.\n\t});\n\tproceso.on(\"exit\", (code) => {\n\t\ts.vivo = false;\n\t\ts.codigoSalida = code;\n\t\tlimpiar(s);\n\t});\n\n\t// El comando en sí es la primera \"entrada\": en modo `-s` (bash de WSL legacy)\n\t// se escribe por stdin en vez de pasar por argv, y el fd es el mismo tanto\n\t// para el resto del script como para lo que el propio comando pida leer\n\t// luego — es idéntico a teclearlo a mano.\n\tif (comandoDesdeStdin) {\n\t\tproceso.stdin.write(`${comando}\\n`);\n\t}\n\n\tconst estado = await esperarSenal(s, opciones.timeoutMs ?? 10_000, opciones.umbralInactividadMs ?? 1200);\n\treturn aResultado(s, estado);\n}\n\nexport interface OpcionesEnviar {\n\ttimeoutMs?: number;\n\tumbralInactividadMs?: number;\n}\n\n/**\n * Manda una línea a una sesión viva y espera la siguiente señal.\n *\n * `null` cuando la sesión no existe: NO es lo mismo que una sesión que\n * existe pero no tiene nada nuevo que decir (eso es `salida: \"\"`).\n */\nexport async function enviarASesion(\n\tid: string,\n\ttexto: string,\n\topciones: OpcionesEnviar = {},\n): Promise<ResultadoSesion | null> {\n\tconst s = sesiones.get(id);\n\tif (!s) return null;\n\tif (!s.vivo) return aResultado(s, { esperando: false, motivo: null });\n\n\ts.proceso.stdin.write(`${texto}\\n`);\n\tconst estado = await esperarSenal(s, opciones.timeoutMs ?? 10_000, opciones.umbralInactividadMs ?? 1200);\n\treturn aResultado(s, estado);\n}\n\n/** `null` si la sesión no existe; `true`/`false` según si había algo vivo que matar. */\nexport function cerrarSesion(id: string): boolean | null {\n\tconst s = sesiones.get(id);\n\tif (!s) return null;\n\tconst estabaViva = s.vivo;\n\tif (s.pid !== undefined) killProcessTree(s.pid);\n\ts.vivo = false;\n\tlimpiar(s);\n\tsesiones.delete(id);\n\treturn estabaViva;\n}\n\n/** Para pruebas y para el apagado del CLI: no debe sobrevivir ninguna. */\nexport function cerrarTodasLasSesiones(): void {\n\tfor (const id of [...sesiones.keys()]) cerrarSesion(id);\n}\n\n/** Solo para pruebas: cuántas sesiones quedan registradas. */\nexport function contarSesiones(): number {\n\treturn sesiones.size;\n}\n"]}

package/dist/core/interactivo/tools.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Tools de bash interactivo: `bash_interactivo`, `bash_enviar`, `bash_cerrar`.
+ *
+ * `bash` normal se queda colgado ante un comando que pregunta algo — una
+ * confirmación, una contraseña, un REPL— hasta que salta el timeout, y el
+ * agente lo lee como "el comando no responde". Estas tres tools abren un
+ * proceso que sobrevive entre llamadas: `bash_interactivo` lo lanza y
+ * devuelve lo que haya hasta el primer prompt (o hasta que termine, o hasta
+ * el timeout); `bash_enviar` le manda una línea más; `bash_cerrar` lo mata.
+ *
+ * Ninguna de las tres está en `LECTURA` ni `ESCRITURA` en
+ * `aprobacion/politica.ts`, así que `nivelDe()` las clasifica como
+ * `ejecucion` por su regla de "lo desconocido cuenta como ejecución" — la
+ * misma puerta que ya pasa `bash`, sin tocar ese fichero.
+ */
+import type { ToolDefinition } from "../extensions/types.ts";
+export declare const NOMBRES_INTERACTIVO_TOOLS: readonly ["bash_interactivo", "bash_enviar", "bash_cerrar"];
+export declare function crearInteractivoTools(opciones: {
+    cwd: string;
+}): Record<string, ToolDefinition>;
+//# sourceMappingURL=tools.d.ts.map

package/dist/core/interactivo/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/core/interactivo/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAmB,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAkC9E,eAAO,MAAM,yBAAyB,6DAA8D,CAAC;AAErG,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CA8E/F","sourcesContent":["/**\n * Tools de bash interactivo: `bash_interactivo`, `bash_enviar`, `bash_cerrar`.\n *\n * `bash` normal se queda colgado ante un comando que pregunta algo — una\n * confirmación, una contraseña, un REPL— hasta que salta el timeout, y el\n * agente lo lee como \"el comando no responde\". Estas tres tools abren un\n * proceso que sobrevive entre llamadas: `bash_interactivo` lo lanza y\n * devuelve lo que haya hasta el primer prompt (o hasta que termine, o hasta\n * el timeout); `bash_enviar` le manda una línea más; `bash_cerrar` lo mata.\n *\n * Ninguna de las tres está en `LECTURA` ni `ESCRITURA` en\n * `aprobacion/politica.ts`, así que `nivelDe()` las clasifica como\n * `ejecucion` por su regla de \"lo desconocido cuenta como ejecución\" — la\n * misma puerta que ya pasa `bash`, sin tocar ese fichero.\n */\n\nimport { Type } from \"typebox\";\nimport type { AgentToolResult, ToolDefinition } from \"../extensions/types.ts\";\nimport { cerrarSesion, enviarASesion, lanzarSesionInteractiva, type ResultadoSesion } from \"./sesion.ts\";\n\nconst GUIA = [\n\t\"Para un comando normal que termina solo, usa bash. Usa bash_interactivo solo cuando esperes que el comando pregunte algo: una confirmación, una contraseña, un REPL.\",\n\t\"bash_interactivo devuelve un id de sesión. Si sigue vivo, respóndele con bash_enviar pasando ese id y una línea de texto (puede ser vacía, para solo esperar más).\",\n\t\"Cierra la sesión con bash_cerrar en cuanto termines con ella: una sesión olvidada sigue consumiendo un proceso real.\",\n];\n\nfunction texto(t: string): AgentToolResult<unknown> {\n\treturn { content: [{ type: \"text\" as const, text: t }], details: undefined };\n}\n\nfunction fallo(error: unknown): AgentToolResult<unknown> {\n\treturn texto(`Error: ${error instanceof Error ? error.message : String(error)}`);\n}\n\n/** Frase de estado + qué hacer a continuación, para que el modelo no tenga que adivinar. */\nfunction narrarEstado(r: ResultadoSesion): string {\n\tif (!r.vivo) return `[sesión ${r.id}] terminó con código ${r.codigoSalida ?? \"desconocido\"}.`;\n\tif (r.esperando) {\n\t\treturn `[sesión ${r.id}] esperando entrada (${r.motivo}). Responde con bash_enviar (session=\"${r.id}\") o mátala con bash_cerrar.`;\n\t}\n\treturn `[sesión ${r.id}] sigue en marcha, sin señal reconocible de que esté esperando algo todavía. Puedes esperar más con bash_enviar (session=\"${r.id}\", texto=\"\") o cerrarla con bash_cerrar.`;\n}\n\nfunction conSalida(r: ResultadoSesion): string {\n\treturn `${narrarEstado(r)}\\n\\n${r.salida || \"(sin salida nueva)\"}`;\n}\n\nfunction segundosAMs(segundos: number | undefined): number | undefined {\n\treturn segundos === undefined ? undefined : segundos * 1000;\n}\n\nexport const NOMBRES_INTERACTIVO_TOOLS = [\"bash_interactivo\", \"bash_enviar\", \"bash_cerrar\"] as const;\n\nexport function crearInteractivoTools(opciones: { cwd: string }): Record<string, ToolDefinition> {\n\tconst lanzar: ToolDefinition<ReturnType<typeof Type.Object>> = {\n\t\tname: \"bash_interactivo\",\n\t\tlabel: \"Bash interactivo\",\n\t\tdescription:\n\t\t\t\"Lanza un comando de shell que puede pedir entrada (confirmación, contraseña, REPL) y devuelve \" +\n\t\t\t\"lo que haya escrito hasta el primer prompt reconocido, hasta que termine, o hasta el timeout. \" +\n\t\t\t\"El proceso queda vivo entre llamadas: sigue con bash_enviar.\",\n\t\tpromptSnippet: \"ejecutar un comando que puede preguntar algo y seguir hablando con él\",\n\t\tpromptGuidelines: GUIA,\n\t\tparameters: Type.Object({\n\t\t\tcommand: Type.String({ description: \"Comando de shell a ejecutar\" }),\n\t\t\ttimeout: Type.Optional(\n\t\t\t\tType.Number({\n\t\t\t\t\tdescription: \"Segundos a esperar por un prompt antes de devolver el control (por defecto 10)\",\n\t\t\t\t}),\n\t\t\t),\n\t\t}),\n\t\tasync execute(_id, input): Promise<AgentToolResult<unknown>> {\n\t\t\tconst comando = String(input.command ?? \"\").trim();\n\t\t\tif (!comando) return texto(\"Falta el comando.\");\n\t\t\ttry {\n\t\t\t\tconst r = await lanzarSesionInteractiva(comando, {\n\t\t\t\t\tcwd: opciones.cwd,\n\t\t\t\t\ttimeoutMs: segundosAMs(input.timeout as number | undefined),\n\t\t\t\t});\n\t\t\t\treturn texto(conSalida(r));\n\t\t\t} catch (error) {\n\t\t\t\treturn fallo(error);\n\t\t\t}\n\t\t},\n\t};\n\n\tconst enviar: ToolDefinition<ReturnType<typeof Type.Object>> = {\n\t\tname: \"bash_enviar\",\n\t\tlabel: \"Enviar a sesión interactiva\",\n\t\tdescription:\n\t\t\t\"Manda una línea de texto a una sesión abierta con bash_interactivo (por ejemplo la respuesta a una \" +\n\t\t\t\"confirmación o una contraseña) y espera la siguiente señal: otro prompt, más salida, o que termine.\",\n\t\tpromptSnippet: \"responder a una sesión de bash interactivo abierta\",\n\t\tpromptGuidelines: GUIA,\n\t\tparameters: Type.Object({\n\t\t\tsession: Type.String({ description: \"El id de sesión que devolvió bash_interactivo\" }),\n\t\t\ttexto: Type.String({ description: \"Línea a enviar (se añade un salto de línea). Puede ser vacía.\" }),\n\t\t\ttimeout: Type.Optional(Type.Number({ description: \"Segundos a esperar la siguiente señal (por defecto 10)\" })),\n\t\t}),\n\t\tasync execute(_id, input): Promise<AgentToolResult<unknown>> {\n\t\t\tconst id = String(input.session ?? \"\");\n\t\t\ttry {\n\t\t\t\tconst r = await enviarASesion(id, String(input.texto ?? \"\"), {\n\t\t\t\t\ttimeoutMs: segundosAMs(input.timeout as number | undefined),\n\t\t\t\t});\n\t\t\t\tif (r === null) return texto(`No hay ninguna sesión interactiva abierta con id \"${id}\".`);\n\t\t\t\treturn texto(conSalida(r));\n\t\t\t} catch (error) {\n\t\t\t\treturn fallo(error);\n\t\t\t}\n\t\t},\n\t};\n\n\tconst cerrar: ToolDefinition<ReturnType<typeof Type.Object>> = {\n\t\tname: \"bash_cerrar\",\n\t\tlabel: \"Cerrar sesión interactiva\",\n\t\tdescription: \"Mata una sesión abierta con bash_interactivo y libera el proceso.\",\n\t\tpromptSnippet: \"cerrar una sesión de bash interactivo abierta\",\n\t\tpromptGuidelines: GUIA,\n\t\tparameters: Type.Object({\n\t\t\tsession: Type.String({ description: \"El id de sesión a cerrar\" }),\n\t\t}),\n\t\tasync execute(_id, input): Promise<AgentToolResult<unknown>> {\n\t\t\tconst id = String(input.session ?? \"\");\n\t\t\tconst habiaAlgoVivo = cerrarSesion(id);\n\t\t\tif (habiaAlgoVivo === null) return texto(`No hay ninguna sesión interactiva abierta con id \"${id}\".`);\n\t\t\treturn texto(habiaAlgoVivo ? `Sesión ${id} cerrada.` : `La sesión ${id} ya había terminado; limpiada.`);\n\t\t},\n\t};\n\n\treturn { bash_interactivo: lanzar, bash_enviar: enviar, bash_cerrar: cerrar };\n}\n"]}

package/dist/core/interactivo/tools.js

@@ -0,0 +1,122 @@
+/**
+ * Tools de bash interactivo: `bash_interactivo`, `bash_enviar`, `bash_cerrar`.
+ *
+ * `bash` normal se queda colgado ante un comando que pregunta algo — una
+ * confirmación, una contraseña, un REPL— hasta que salta el timeout, y el
+ * agente lo lee como "el comando no responde". Estas tres tools abren un
+ * proceso que sobrevive entre llamadas: `bash_interactivo` lo lanza y
+ * devuelve lo que haya hasta el primer prompt (o hasta que termine, o hasta
+ * el timeout); `bash_enviar` le manda una línea más; `bash_cerrar` lo mata.
+ *
+ * Ninguna de las tres está en `LECTURA` ni `ESCRITURA` en
+ * `aprobacion/politica.ts`, así que `nivelDe()` las clasifica como
+ * `ejecucion` por su regla de "lo desconocido cuenta como ejecución" — la
+ * misma puerta que ya pasa `bash`, sin tocar ese fichero.
+ */
+import { Type } from "typebox";
+import { cerrarSesion, enviarASesion, lanzarSesionInteractiva } from "./sesion.js";
+const GUIA = [
+    "Para un comando normal que termina solo, usa bash. Usa bash_interactivo solo cuando esperes que el comando pregunte algo: una confirmación, una contraseña, un REPL.",
+    "bash_interactivo devuelve un id de sesión. Si sigue vivo, respóndele con bash_enviar pasando ese id y una línea de texto (puede ser vacía, para solo esperar más).",
+    "Cierra la sesión con bash_cerrar en cuanto termines con ella: una sesión olvidada sigue consumiendo un proceso real.",
+];
+function texto(t) {
+    return { content: [{ type: "text", text: t }], details: undefined };
+}
+function fallo(error) {
+    return texto(`Error: ${error instanceof Error ? error.message : String(error)}`);
+}
+/** Frase de estado + qué hacer a continuación, para que el modelo no tenga que adivinar. */
+function narrarEstado(r) {
+    if (!r.vivo)
+        return `[sesión ${r.id}] terminó con código ${r.codigoSalida ?? "desconocido"}.`;
+    if (r.esperando) {
+        return `[sesión ${r.id}] esperando entrada (${r.motivo}). Responde con bash_enviar (session="${r.id}") o mátala con bash_cerrar.`;
+    }
+    return `[sesión ${r.id}] sigue en marcha, sin señal reconocible de que esté esperando algo todavía. Puedes esperar más con bash_enviar (session="${r.id}", texto="") o cerrarla con bash_cerrar.`;
+}
+function conSalida(r) {
+    return `${narrarEstado(r)}\n\n${r.salida || "(sin salida nueva)"}`;
+}
+function segundosAMs(segundos) {
+    return segundos === undefined ? undefined : segundos * 1000;
+}
+export const NOMBRES_INTERACTIVO_TOOLS = ["bash_interactivo", "bash_enviar", "bash_cerrar"];
+export function crearInteractivoTools(opciones) {
+    const lanzar = {
+        name: "bash_interactivo",
+        label: "Bash interactivo",
+        description: "Lanza un comando de shell que puede pedir entrada (confirmación, contraseña, REPL) y devuelve " +
+            "lo que haya escrito hasta el primer prompt reconocido, hasta que termine, o hasta el timeout. " +
+            "El proceso queda vivo entre llamadas: sigue con bash_enviar.",
+        promptSnippet: "ejecutar un comando que puede preguntar algo y seguir hablando con él",
+        promptGuidelines: GUIA,
+        parameters: Type.Object({
+            command: Type.String({ description: "Comando de shell a ejecutar" }),
+            timeout: Type.Optional(Type.Number({
+                description: "Segundos a esperar por un prompt antes de devolver el control (por defecto 10)",
+            })),
+        }),
+        async execute(_id, input) {
+            const comando = String(input.command ?? "").trim();
+            if (!comando)
+                return texto("Falta el comando.");
+            try {
+                const r = await lanzarSesionInteractiva(comando, {
+                    cwd: opciones.cwd,
+                    timeoutMs: segundosAMs(input.timeout),
+                });
+                return texto(conSalida(r));
+            }
+            catch (error) {
+                return fallo(error);
+            }
+        },
+    };
+    const enviar = {
+        name: "bash_enviar",
+        label: "Enviar a sesión interactiva",
+        description: "Manda una línea de texto a una sesión abierta con bash_interactivo (por ejemplo la respuesta a una " +
+            "confirmación o una contraseña) y espera la siguiente señal: otro prompt, más salida, o que termine.",
+        promptSnippet: "responder a una sesión de bash interactivo abierta",
+        promptGuidelines: GUIA,
+        parameters: Type.Object({
+            session: Type.String({ description: "El id de sesión que devolvió bash_interactivo" }),
+            texto: Type.String({ description: "Línea a enviar (se añade un salto de línea). Puede ser vacía." }),
+            timeout: Type.Optional(Type.Number({ description: "Segundos a esperar la siguiente señal (por defecto 10)" })),
+        }),
+        async execute(_id, input) {
+            const id = String(input.session ?? "");
+            try {
+                const r = await enviarASesion(id, String(input.texto ?? ""), {
+                    timeoutMs: segundosAMs(input.timeout),
+                });
+                if (r === null)
+                    return texto(`No hay ninguna sesión interactiva abierta con id "${id}".`);
+                return texto(conSalida(r));
+            }
+            catch (error) {
+                return fallo(error);
+            }
+        },
+    };
+    const cerrar = {
+        name: "bash_cerrar",
+        label: "Cerrar sesión interactiva",
+        description: "Mata una sesión abierta con bash_interactivo y libera el proceso.",
+        promptSnippet: "cerrar una sesión de bash interactivo abierta",
+        promptGuidelines: GUIA,
+        parameters: Type.Object({
+            session: Type.String({ description: "El id de sesión a cerrar" }),
+        }),
+        async execute(_id, input) {
+            const id = String(input.session ?? "");
+            const habiaAlgoVivo = cerrarSesion(id);
+            if (habiaAlgoVivo === null)
+                return texto(`No hay ninguna sesión interactiva abierta con id "${id}".`);
+            return texto(habiaAlgoVivo ? `Sesión ${id} cerrada.` : `La sesión ${id} ya había terminado; limpiada.`);
+        },
+    };
+    return { bash_interactivo: lanzar, bash_enviar: enviar, bash_cerrar: cerrar };
+}
+//# sourceMappingURL=tools.js.map

package/dist/core/interactivo/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../../src/core/interactivo/tools.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Tools de bash interactivo: `bash_interactivo`, `bash_enviar`, `bash_cerrar`.\n *\n * `bash` normal se queda colgado ante un comando que pregunta algo — una\n * confirmación, una contraseña, un REPL— hasta que salta el timeout, y el\n * agente lo lee como \"el comando no responde\". Estas tres tools abren un\n * proceso que sobrevive entre llamadas: `bash_interactivo` lo lanza y\n * devuelve lo que haya hasta el primer prompt (o hasta que termine, o hasta\n * el timeout); `bash_enviar` le manda una línea más; `bash_cerrar` lo mata.\n *\n * Ninguna de las tres está en `LECTURA` ni `ESCRITURA` en\n * `aprobacion/politica.ts`, así que `nivelDe()` las clasifica como\n * `ejecucion` por su regla de \"lo desconocido cuenta como ejecución\" — la\n * misma puerta que ya pasa `bash`, sin tocar ese fichero.\n */\n\nimport { Type } from \"typebox\";\nimport type { AgentToolResult, ToolDefinition } from \"../extensions/types.ts\";\nimport { cerrarSesion, enviarASesion, lanzarSesionInteractiva, type ResultadoSesion } from \"./sesion.ts\";\n\nconst GUIA = [\n\t\"Para un comando normal que termina solo, usa bash. Usa bash_interactivo solo cuando esperes que el comando pregunte algo: una confirmación, una contraseña, un REPL.\",\n\t\"bash_interactivo devuelve un id de sesión. Si sigue vivo, respóndele con bash_enviar pasando ese id y una línea de texto (puede ser vacía, para solo esperar más).\",\n\t\"Cierra la sesión con bash_cerrar en cuanto termines con ella: una sesión olvidada sigue consumiendo un proceso real.\",\n];\n\nfunction texto(t: string): AgentToolResult<unknown> {\n\treturn { content: [{ type: \"text\" as const, text: t }], details: undefined };\n}\n\nfunction fallo(error: unknown): AgentToolResult<unknown> {\n\treturn texto(`Error: ${error instanceof Error ? error.message : String(error)}`);\n}\n\n/** Frase de estado + qué hacer a continuación, para que el modelo no tenga que adivinar. */\nfunction narrarEstado(r: ResultadoSesion): string {\n\tif (!r.vivo) return `[sesión ${r.id}] terminó con código ${r.codigoSalida ?? \"desconocido\"}.`;\n\tif (r.esperando) {\n\t\treturn `[sesión ${r.id}] esperando entrada (${r.motivo}). Responde con bash_enviar (session=\"${r.id}\") o mátala con bash_cerrar.`;\n\t}\n\treturn `[sesión ${r.id}] sigue en marcha, sin señal reconocible de que esté esperando algo todavía. Puedes esperar más con bash_enviar (session=\"${r.id}\", texto=\"\") o cerrarla con bash_cerrar.`;\n}\n\nfunction conSalida(r: ResultadoSesion): string {\n\treturn `${narrarEstado(r)}\\n\\n${r.salida || \"(sin salida nueva)\"}`;\n}\n\nfunction segundosAMs(segundos: number | undefined): number | undefined {\n\treturn segundos === undefined ? undefined : segundos * 1000;\n}\n\nexport const NOMBRES_INTERACTIVO_TOOLS = [\"bash_interactivo\", \"bash_enviar\", \"bash_cerrar\"] as const;\n\nexport function crearInteractivoTools(opciones: { cwd: string }): Record<string, ToolDefinition> {\n\tconst lanzar: ToolDefinition<ReturnType<typeof Type.Object>> = {\n\t\tname: \"bash_interactivo\",\n\t\tlabel: \"Bash interactivo\",\n\t\tdescription:\n\t\t\t\"Lanza un comando de shell que puede pedir entrada (confirmación, contraseña, REPL) y devuelve \" +\n\t\t\t\"lo que haya escrito hasta el primer prompt reconocido, hasta que termine, o hasta el timeout. \" +\n\t\t\t\"El proceso queda vivo entre llamadas: sigue con bash_enviar.\",\n\t\tpromptSnippet: \"ejecutar un comando que puede preguntar algo y seguir hablando con él\",\n\t\tpromptGuidelines: GUIA,\n\t\tparameters: Type.Object({\n\t\t\tcommand: Type.String({ description: \"Comando de shell a ejecutar\" }),\n\t\t\ttimeout: Type.Optional(\n\t\t\t\tType.Number({\n\t\t\t\t\tdescription: \"Segundos a esperar por un prompt antes de devolver el control (por defecto 10)\",\n\t\t\t\t}),\n\t\t\t),\n\t\t}),\n\t\tasync execute(_id, input): Promise<AgentToolResult<unknown>> {\n\t\t\tconst comando = String(input.command ?? \"\").trim();\n\t\t\tif (!comando) return texto(\"Falta el comando.\");\n\t\t\ttry {\n\t\t\t\tconst r = await lanzarSesionInteractiva(comando, {\n\t\t\t\t\tcwd: opciones.cwd,\n\t\t\t\t\ttimeoutMs: segundosAMs(input.timeout as number | undefined),\n\t\t\t\t});\n\t\t\t\treturn texto(conSalida(r));\n\t\t\t} catch (error) {\n\t\t\t\treturn fallo(error);\n\t\t\t}\n\t\t},\n\t};\n\n\tconst enviar: ToolDefinition<ReturnType<typeof Type.Object>> = {\n\t\tname: \"bash_enviar\",\n\t\tlabel: \"Enviar a sesión interactiva\",\n\t\tdescription:\n\t\t\t\"Manda una línea de texto a una sesión abierta con bash_interactivo (por ejemplo la respuesta a una \" +\n\t\t\t\"confirmación o una contraseña) y espera la siguiente señal: otro prompt, más salida, o que termine.\",\n\t\tpromptSnippet: \"responder a una sesión de bash interactivo abierta\",\n\t\tpromptGuidelines: GUIA,\n\t\tparameters: Type.Object({\n\t\t\tsession: Type.String({ description: \"El id de sesión que devolvió bash_interactivo\" }),\n\t\t\ttexto: Type.String({ description: \"Línea a enviar (se añade un salto de línea). Puede ser vacía.\" }),\n\t\t\ttimeout: Type.Optional(Type.Number({ description: \"Segundos a esperar la siguiente señal (por defecto 10)\" })),\n\t\t}),\n\t\tasync execute(_id, input): Promise<AgentToolResult<unknown>> {\n\t\t\tconst id = String(input.session ?? \"\");\n\t\t\ttry {\n\t\t\t\tconst r = await enviarASesion(id, String(input.texto ?? \"\"), {\n\t\t\t\t\ttimeoutMs: segundosAMs(input.timeout as number | undefined),\n\t\t\t\t});\n\t\t\t\tif (r === null) return texto(`No hay ninguna sesión interactiva abierta con id \"${id}\".`);\n\t\t\t\treturn texto(conSalida(r));\n\t\t\t} catch (error) {\n\t\t\t\treturn fallo(error);\n\t\t\t}\n\t\t},\n\t};\n\n\tconst cerrar: ToolDefinition<ReturnType<typeof Type.Object>> = {\n\t\tname: \"bash_cerrar\",\n\t\tlabel: \"Cerrar sesión interactiva\",\n\t\tdescription: \"Mata una sesión abierta con bash_interactivo y libera el proceso.\",\n\t\tpromptSnippet: \"cerrar una sesión de bash interactivo abierta\",\n\t\tpromptGuidelines: GUIA,\n\t\tparameters: Type.Object({\n\t\t\tsession: Type.String({ description: \"El id de sesión a cerrar\" }),\n\t\t}),\n\t\tasync execute(_id, input): Promise<AgentToolResult<unknown>> {\n\t\t\tconst id = String(input.session ?? \"\");\n\t\t\tconst habiaAlgoVivo = cerrarSesion(id);\n\t\t\tif (habiaAlgoVivo === null) return texto(`No hay ninguna sesión interactiva abierta con id \"${id}\".`);\n\t\t\treturn texto(habiaAlgoVivo ? `Sesión ${id} cerrada.` : `La sesión ${id} ya había terminado; limpiada.`);\n\t\t},\n\t};\n\n\treturn { bash_interactivo: lanzar, bash_enviar: enviar, bash_cerrar: cerrar };\n}\n"]}

package/dist/core/lectura/mapa.d.ts

@@ -0,0 +1,70 @@
+/**
+ * El mapa de lo que un `read` truncado NO enseñó.
+ *
+ * EL CASO, medido sobre este repositorio. `core/agent-session.ts` tiene 4.546
+ * líneas y 162 KB. El límite de 50 KB salta antes que el de 2.000 líneas, así
+ * que el agente ve las primeras **1.415 líneas (31%)** y nada más. Un bug en la
+ * línea 3.000 es invisible.
+ *
+ * Lo que hay hoy para eso son `offset` y `limit`, y sirven — si sabes a qué
+ * línea ir. El agente no lo sabe: le hemos cortado el fichero sin decirle qué
+ * había detrás. Su única salida es paginar a ciegas, que gasta turnos, o
+ * rendirse y editar lo que sí vio, que es peor.
+ *
+ * Es la misma familia de siempre. Un corte silencioso se lee como «esto es el
+ * fichero», igual que un `[]` se lee como «no hay». La diferencia entre «no
+ * está» y «no te lo he enseñado» tiene que ser visible, y aquí no lo era: el
+ * aviso decía cuántas líneas faltaban, nunca QUÉ faltaba.
+ *
+ * QUÉ HACE. Sobre la parte que NO cupo, lista las declaraciones de primer nivel
+ * con su línea: funciones, clases, interfaces, tipos y constantes exportadas.
+ * El agente pasa de «me faltan 3.131 líneas» a «`_rebuildSystemPrompt` está en
+ * la 1537», que es un `read offset=1530` en vez de seis intentos.
+ *
+ * NO es un resumen del contenido y a propósito. Un resumen lo escribe un modelo
+ * y puede inventarse lo que no leyó; esto son nombres y números sacados del
+ * árbol de sintaxis. En un registro que se vende como auditable, un mapa que
+ * miente es peor que no tener mapa.
+ *
+ * LÍMITES, dichos antes de que los descubra nadie:
+ *   · Solo TypeScript y JavaScript. Para el resto se dice que no se pudo mapear,
+ *     que no es lo mismo que decir que no hay nada — tres estados, no dos.
+ *   · Se baja UN nivel dentro de clases, y esa decisión está medida. La primera
+ *     versión solo miraba el primer nivel y sobre `agent-session.ts` —el fichero
+ *     que motivó todo esto— devolvió CERO declaraciones: sus 4.546 líneas son
+ *     una sola clase con 106 métodos. Un mapa que se queda en «hay una clase
+ *     AgentSession en la línea 368» no le dice nada a quien busca dónde está
+ *     `_rebuildSystemPrompt`. Más adentro no se baja: una función dentro de un
+ *     método es detalle, no ancla.
+ */
+/** Una declaración que el agente no llegó a ver. */
+export interface Declaracion {
+    /** `funcion`, `clase`, `interfaz`, `tipo`, `constante`. */
+    que: string;
+    nombre: string;
+    /** Línea 1-indexada, para poder pasarla a `read offset=`. */
+    linea: number;
+    exportada: boolean;
+}
+/** Por qué no hay mapa, cuando no lo hay. */
+export type SinMapa = "extension-no-soportada" | "no-parsea" | "nada-que-mapear";
+export interface Mapa {
+    declaraciones: Declaracion[];
+    /** `null` si sí hay mapa. Un motivo, nunca una lista vacía silenciosa. */
+    sinMapa: SinMapa | null;
+}
+/**
+ * Mapea las declaraciones que caen DESPUÉS de `desdeLinea`.
+ *
+ * `desdeLinea` es 1-indexada y exclusiva: se pasa el número de la última línea
+ * que el agente sí vio, y se devuelve lo que hay a partir de la siguiente.
+ */
+export declare function mapearNoVisto(ruta: string, contenido: string, desdeLinea: number): Mapa;
+/**
+ * El mapa, escrito para que el modelo pueda usarlo directamente.
+ *
+ * Devuelve `null` cuando no hay nada que decir, para que quien llame no tenga
+ * que decidir si una cadena vacía significa «sin mapa» o «error».
+ */
+export declare function textoDelMapa(mapa: Mapa, ruta: string): string | null;
+//# sourceMappingURL=mapa.d.ts.map

package/dist/core/lectura/mapa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapa.d.ts","sourceRoot":"","sources":["../../../src/core/lectura/mapa.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAIH,sDAAoD;AACpD,MAAM,WAAW,WAAW;IAC3B,2DAA2D;IAC3D,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,8DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;CACnB;AAED,8CAA6C;AAC7C,MAAM,MAAM,OAAO,GAAG,wBAAwB,GAAG,WAAW,GAAG,iBAAiB,CAAC;AAEjF,MAAM,WAAW,IAAI;IACpB,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,4EAA0E;IAC1E,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CACxB;AA8BD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAyDvF;AAKD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA+BpE","sourcesContent":["/**\n * El mapa de lo que un `read` truncado NO enseñó.\n *\n * EL CASO, medido sobre este repositorio. `core/agent-session.ts` tiene 4.546\n * líneas y 162 KB. El límite de 50 KB salta antes que el de 2.000 líneas, así\n * que el agente ve las primeras **1.415 líneas (31%)** y nada más. Un bug en la\n * línea 3.000 es invisible.\n *\n * Lo que hay hoy para eso son `offset` y `limit`, y sirven — si sabes a qué\n * línea ir. El agente no lo sabe: le hemos cortado el fichero sin decirle qué\n * había detrás. Su única salida es paginar a ciegas, que gasta turnos, o\n * rendirse y editar lo que sí vio, que es peor.\n *\n * Es la misma familia de siempre. Un corte silencioso se lee como «esto es el\n * fichero», igual que un `[]` se lee como «no hay». La diferencia entre «no\n * está» y «no te lo he enseñado» tiene que ser visible, y aquí no lo era: el\n * aviso decía cuántas líneas faltaban, nunca QUÉ faltaba.\n *\n * QUÉ HACE. Sobre la parte que NO cupo, lista las declaraciones de primer nivel\n * con su línea: funciones, clases, interfaces, tipos y constantes exportadas.\n * El agente pasa de «me faltan 3.131 líneas» a «`_rebuildSystemPrompt` está en\n * la 1537», que es un `read offset=1530` en vez de seis intentos.\n *\n * NO es un resumen del contenido y a propósito. Un resumen lo escribe un modelo\n * y puede inventarse lo que no leyó; esto son nombres y números sacados del\n * árbol de sintaxis. En un registro que se vende como auditable, un mapa que\n * miente es peor que no tener mapa.\n *\n * LÍMITES, dichos antes de que los descubra nadie:\n *   · Solo TypeScript y JavaScript. Para el resto se dice que no se pudo mapear,\n *     que no es lo mismo que decir que no hay nada — tres estados, no dos.\n *   · Se baja UN nivel dentro de clases, y esa decisión está medida. La primera\n *     versión solo miraba el primer nivel y sobre `agent-session.ts` —el fichero\n *     que motivó todo esto— devolvió CERO declaraciones: sus 4.546 líneas son\n *     una sola clase con 106 métodos. Un mapa que se queda en «hay una clase\n *     AgentSession en la línea 368» no le dice nada a quien busca dónde está\n *     `_rebuildSystemPrompt`. Más adentro no se baja: una función dentro de un\n *     método es detalle, no ancla.\n */\n\nimport ts from \"typescript\";\n\n/** Una declaración que el agente no llegó a ver. */\nexport interface Declaracion {\n\t/** `funcion`, `clase`, `interfaz`, `tipo`, `constante`. */\n\tque: string;\n\tnombre: string;\n\t/** Línea 1-indexada, para poder pasarla a `read offset=`. */\n\tlinea: number;\n\texportada: boolean;\n}\n\n/** Por qué no hay mapa, cuando no lo hay. */\nexport type SinMapa = \"extension-no-soportada\" | \"no-parsea\" | \"nada-que-mapear\";\n\nexport interface Mapa {\n\tdeclaraciones: Declaracion[];\n\t/** `null` si sí hay mapa. Un motivo, nunca una lista vacía silenciosa. */\n\tsinMapa: SinMapa | null;\n}\n\nconst EXTENSIONES = new Set([\".ts\", \".tsx\", \".mts\", \".cts\", \".js\", \".jsx\", \".mjs\", \".cjs\"]);\n\nfunction tipoDe(nodo: ts.Node): string | null {\n\tif (ts.isFunctionDeclaration(nodo)) return \"funcion\";\n\tif (ts.isClassDeclaration(nodo)) return \"clase\";\n\tif (ts.isInterfaceDeclaration(nodo)) return \"interfaz\";\n\tif (ts.isTypeAliasDeclaration(nodo)) return \"tipo\";\n\tif (ts.isEnumDeclaration(nodo)) return \"enum\";\n\tif (ts.isVariableStatement(nodo)) return \"constante\";\n\treturn null;\n}\n\nfunction esExportada(nodo: ts.Node): boolean {\n\tconst mods = ts.canHaveModifiers(nodo) ? ts.getModifiers(nodo) : undefined;\n\treturn mods?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;\n}\n\nfunction nombreDe(nodo: ts.Node): string | null {\n\tif (ts.isVariableStatement(nodo)) {\n\t\tconst d = nodo.declarationList.declarations[0];\n\t\treturn d && ts.isIdentifier(d.name) ? d.name.text : null;\n\t}\n\tconst conNombre = nodo as ts.Node & { name?: ts.Node };\n\treturn conNombre.name && ts.isIdentifier(conNombre.name as ts.Identifier)\n\t\t? (conNombre.name as ts.Identifier).text\n\t\t: null;\n}\n\n/**\n * Mapea las declaraciones que caen DESPUÉS de `desdeLinea`.\n *\n * `desdeLinea` es 1-indexada y exclusiva: se pasa el número de la última línea\n * que el agente sí vio, y se devuelve lo que hay a partir de la siguiente.\n */\nexport function mapearNoVisto(ruta: string, contenido: string, desdeLinea: number): Mapa {\n\tconst punto = ruta.lastIndexOf(\".\");\n\tif (punto < 0 || !EXTENSIONES.has(ruta.slice(punto))) {\n\t\treturn { declaraciones: [], sinMapa: \"extension-no-soportada\" };\n\t}\n\n\tlet fuente: ts.SourceFile;\n\ttry {\n\t\tfuente = ts.createSourceFile(ruta, contenido, ts.ScriptTarget.Latest, true);\n\t} catch {\n\t\treturn { declaraciones: [], sinMapa: \"no-parsea\" };\n\t}\n\t// «No parsea» hay que preguntárselo a `parseDiagnostics`, no deducirlo.\n\t//\n\t// `createSourceFile` no lanza y es MUY permisivo: sobre\n\t// `esto ( no { es ] typescript` devuelve sentencias igualmente, así que mirar\n\t// si el árbol está vacío daba «nada-que-mapear» sobre un fichero roto — otra\n\t// vez «no puedo» leído como «no hay». Es el mismo mecanismo que ya se midió\n\t// en `core/edicion/parseo.ts` (10 de 10 frente a 7 de 10 con otras vías).\n\t//\n\t// `parseDiagnostics` no está en el tipo público, y aun así es lo correcto:\n\t// contiene SOLO errores de sintaxis, no los del comprobador de tipos, que\n\t// aquí serían ruido.\n\tconst diagnosticos = (fuente as ts.SourceFile & { parseDiagnostics?: unknown }).parseDiagnostics;\n\tif (Array.isArray(diagnosticos) && diagnosticos.length > 0) {\n\t\treturn { declaraciones: [], sinMapa: \"no-parsea\" };\n\t}\n\n\tconst declaraciones: Declaracion[] = [];\n\tfor (const nodo of fuente.statements) {\n\t\tconst que = tipoDe(nodo);\n\t\tif (!que) continue;\n\t\tconst nombre = nombreDe(nodo);\n\t\tif (!nombre) continue;\n\t\tconst linea = fuente.getLineAndCharacterOfPosition(nodo.getStart(fuente)).line + 1;\n\t\tif (linea > desdeLinea) declaraciones.push({ que, nombre, linea, exportada: esExportada(nodo) });\n\n\t\t// Un nivel más, dentro de clases. Sin esto el mapa era inútil justo donde\n\t\t// hacía falta: un fichero de 4.500 líneas que es una sola clase.\n\t\tif (!ts.isClassDeclaration(nodo)) continue;\n\t\tfor (const miembro of nodo.members) {\n\t\t\tif (!ts.isMethodDeclaration(miembro) && !ts.isGetAccessorDeclaration(miembro)) continue;\n\t\t\tif (!ts.isIdentifier(miembro.name) && !ts.isPrivateIdentifier(miembro.name)) continue;\n\t\t\tconst lineaM = fuente.getLineAndCharacterOfPosition(miembro.getStart(fuente)).line + 1;\n\t\t\tif (lineaM <= desdeLinea) continue;\n\t\t\tdeclaraciones.push({\n\t\t\t\tque: ts.isGetAccessorDeclaration(miembro) ? \"getter\" : \"metodo\",\n\t\t\t\t// Con la clase delante: `AgentSession.prompt` se busca mejor que `prompt`.\n\t\t\t\tnombre: `${nombre}.${miembro.name.text}`,\n\t\t\t\tlinea: lineaM,\n\t\t\t\texportada: false,\n\t\t\t});\n\t\t}\n\t}\n\n\tif (declaraciones.length === 0) return { declaraciones: [], sinMapa: \"nada-que-mapear\" };\n\treturn { declaraciones, sinMapa: null };\n}\n\n/** Cuántas declaraciones se enseñan como mucho, para no cambiar un muro por otro. */\nconst TOPE = 40;\n\n/**\n * El mapa, escrito para que el modelo pueda usarlo directamente.\n *\n * Devuelve `null` cuando no hay nada que decir, para que quien llame no tenga\n * que decidir si una cadena vacía significa «sin mapa» o «error».\n */\nexport function textoDelMapa(mapa: Mapa, ruta: string): string | null {\n\tif (mapa.sinMapa === \"nada-que-mapear\") return null;\n\tif (mapa.sinMapa === \"extension-no-soportada\") return null;\n\tif (mapa.sinMapa === \"no-parsea\") {\n\t\t// Se dice, en vez de callar: «no se pudo mapear» y «no hay nada» son\n\t\t// distintos, y confundirlos le haría creer al agente que el resto del\n\t\t// fichero está vacío.\n\t\treturn \"No se ha podido mapear el resto del fichero (no parsea). Usa offset/limit para recorrerlo.\";\n\t}\n\n\tconst orden = [\"clase\", \"interfaz\", \"funcion\", \"metodo\", \"getter\", \"tipo\", \"enum\", \"constante\"];\n\tconst lista = [...mapa.declaraciones].sort((a, b) => a.linea - b.linea);\n\tconst mostradas = lista.slice(0, TOPE);\n\tconst lineas = mostradas.map(\n\t\t(d) => `  ${String(d.linea).padStart(5)}  ${d.que.padEnd(10)} ${d.exportada ? \"export \" : \"\"}${d.nombre}`,\n\t);\n\n\tlet texto =\n\t\t`Lo que NO se ha mostrado de ${ruta} contiene estas declaraciones. ` +\n\t\t`Usa \\`read\\` con \\`offset\\` para ir directo a la que necesites:\\n${lineas.join(\"\\n\")}`;\n\tif (lista.length > mostradas.length) {\n\t\t// Se dice cuántas quedan: un mapa truncado en silencio repetiría el mismo\n\t\t// fallo que este módulo existe para arreglar.\n\t\tconst porTipo = orden\n\t\t\t.map((t) => [t, lista.slice(TOPE).filter((d) => d.que === t).length] as const)\n\t\t\t.filter(([, n]) => n > 0)\n\t\t\t.map(([t, n]) => `${n} ${t}${n > 1 ? \"s\" : \"\"}`)\n\t\t\t.join(\", \");\n\t\ttexto += `\\n  …y ${lista.length - mostradas.length} más (${porTipo}).`;\n\t}\n\treturn texto;\n}\n"]}

package/dist/core/lectura/mapa.js

@@ -0,0 +1,177 @@
+/**
+ * El mapa de lo que un `read` truncado NO enseñó.
+ *
+ * EL CASO, medido sobre este repositorio. `core/agent-session.ts` tiene 4.546
+ * líneas y 162 KB. El límite de 50 KB salta antes que el de 2.000 líneas, así
+ * que el agente ve las primeras **1.415 líneas (31%)** y nada más. Un bug en la
+ * línea 3.000 es invisible.
+ *
+ * Lo que hay hoy para eso son `offset` y `limit`, y sirven — si sabes a qué
+ * línea ir. El agente no lo sabe: le hemos cortado el fichero sin decirle qué
+ * había detrás. Su única salida es paginar a ciegas, que gasta turnos, o
+ * rendirse y editar lo que sí vio, que es peor.
+ *
+ * Es la misma familia de siempre. Un corte silencioso se lee como «esto es el
+ * fichero», igual que un `[]` se lee como «no hay». La diferencia entre «no
+ * está» y «no te lo he enseñado» tiene que ser visible, y aquí no lo era: el
+ * aviso decía cuántas líneas faltaban, nunca QUÉ faltaba.
+ *
+ * QUÉ HACE. Sobre la parte que NO cupo, lista las declaraciones de primer nivel
+ * con su línea: funciones, clases, interfaces, tipos y constantes exportadas.
+ * El agente pasa de «me faltan 3.131 líneas» a «`_rebuildSystemPrompt` está en
+ * la 1537», que es un `read offset=1530` en vez de seis intentos.
+ *
+ * NO es un resumen del contenido y a propósito. Un resumen lo escribe un modelo
+ * y puede inventarse lo que no leyó; esto son nombres y números sacados del
+ * árbol de sintaxis. En un registro que se vende como auditable, un mapa que
+ * miente es peor que no tener mapa.
+ *
+ * LÍMITES, dichos antes de que los descubra nadie:
+ *   · Solo TypeScript y JavaScript. Para el resto se dice que no se pudo mapear,
+ *     que no es lo mismo que decir que no hay nada — tres estados, no dos.
+ *   · Se baja UN nivel dentro de clases, y esa decisión está medida. La primera
+ *     versión solo miraba el primer nivel y sobre `agent-session.ts` —el fichero
+ *     que motivó todo esto— devolvió CERO declaraciones: sus 4.546 líneas son
+ *     una sola clase con 106 métodos. Un mapa que se queda en «hay una clase
+ *     AgentSession en la línea 368» no le dice nada a quien busca dónde está
+ *     `_rebuildSystemPrompt`. Más adentro no se baja: una función dentro de un
+ *     método es detalle, no ancla.
+ */
+import ts from "typescript";
+const EXTENSIONES = new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
+function tipoDe(nodo) {
+    if (ts.isFunctionDeclaration(nodo))
+        return "funcion";
+    if (ts.isClassDeclaration(nodo))
+        return "clase";
+    if (ts.isInterfaceDeclaration(nodo))
+        return "interfaz";
+    if (ts.isTypeAliasDeclaration(nodo))
+        return "tipo";
+    if (ts.isEnumDeclaration(nodo))
+        return "enum";
+    if (ts.isVariableStatement(nodo))
+        return "constante";
+    return null;
+}
+function esExportada(nodo) {
+    const mods = ts.canHaveModifiers(nodo) ? ts.getModifiers(nodo) : undefined;
+    return mods?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function nombreDe(nodo) {
+    if (ts.isVariableStatement(nodo)) {
+        const d = nodo.declarationList.declarations[0];
+        return d && ts.isIdentifier(d.name) ? d.name.text : null;
+    }
+    const conNombre = nodo;
+    return conNombre.name && ts.isIdentifier(conNombre.name)
+        ? conNombre.name.text
+        : null;
+}
+/**
+ * Mapea las declaraciones que caen DESPUÉS de `desdeLinea`.
+ *
+ * `desdeLinea` es 1-indexada y exclusiva: se pasa el número de la última línea
+ * que el agente sí vio, y se devuelve lo que hay a partir de la siguiente.
+ */
+export function mapearNoVisto(ruta, contenido, desdeLinea) {
+    const punto = ruta.lastIndexOf(".");
+    if (punto < 0 || !EXTENSIONES.has(ruta.slice(punto))) {
+        return { declaraciones: [], sinMapa: "extension-no-soportada" };
+    }
+    let fuente;
+    try {
+        fuente = ts.createSourceFile(ruta, contenido, ts.ScriptTarget.Latest, true);
+    }
+    catch {
+        return { declaraciones: [], sinMapa: "no-parsea" };
+    }
+    // «No parsea» hay que preguntárselo a `parseDiagnostics`, no deducirlo.
+    //
+    // `createSourceFile` no lanza y es MUY permisivo: sobre
+    // `esto ( no { es ] typescript` devuelve sentencias igualmente, así que mirar
+    // si el árbol está vacío daba «nada-que-mapear» sobre un fichero roto — otra
+    // vez «no puedo» leído como «no hay». Es el mismo mecanismo que ya se midió
+    // en `core/edicion/parseo.ts` (10 de 10 frente a 7 de 10 con otras vías).
+    //
+    // `parseDiagnostics` no está en el tipo público, y aun así es lo correcto:
+    // contiene SOLO errores de sintaxis, no los del comprobador de tipos, que
+    // aquí serían ruido.
+    const diagnosticos = fuente.parseDiagnostics;
+    if (Array.isArray(diagnosticos) && diagnosticos.length > 0) {
+        return { declaraciones: [], sinMapa: "no-parsea" };
+    }
+    const declaraciones = [];
+    for (const nodo of fuente.statements) {
+        const que = tipoDe(nodo);
+        if (!que)
+            continue;
+        const nombre = nombreDe(nodo);
+        if (!nombre)
+            continue;
+        const linea = fuente.getLineAndCharacterOfPosition(nodo.getStart(fuente)).line + 1;
+        if (linea > desdeLinea)
+            declaraciones.push({ que, nombre, linea, exportada: esExportada(nodo) });
+        // Un nivel más, dentro de clases. Sin esto el mapa era inútil justo donde
+        // hacía falta: un fichero de 4.500 líneas que es una sola clase.
+        if (!ts.isClassDeclaration(nodo))
+            continue;
+        for (const miembro of nodo.members) {
+            if (!ts.isMethodDeclaration(miembro) && !ts.isGetAccessorDeclaration(miembro))
+                continue;
+            if (!ts.isIdentifier(miembro.name) && !ts.isPrivateIdentifier(miembro.name))
+                continue;
+            const lineaM = fuente.getLineAndCharacterOfPosition(miembro.getStart(fuente)).line + 1;
+            if (lineaM <= desdeLinea)
+                continue;
+            declaraciones.push({
+                que: ts.isGetAccessorDeclaration(miembro) ? "getter" : "metodo",
+                // Con la clase delante: `AgentSession.prompt` se busca mejor que `prompt`.
+                nombre: `${nombre}.${miembro.name.text}`,
+                linea: lineaM,
+                exportada: false,
+            });
+        }
+    }
+    if (declaraciones.length === 0)
+        return { declaraciones: [], sinMapa: "nada-que-mapear" };
+    return { declaraciones, sinMapa: null };
+}
+/** Cuántas declaraciones se enseñan como mucho, para no cambiar un muro por otro. */
+const TOPE = 40;
+/**
+ * El mapa, escrito para que el modelo pueda usarlo directamente.
+ *
+ * Devuelve `null` cuando no hay nada que decir, para que quien llame no tenga
+ * que decidir si una cadena vacía significa «sin mapa» o «error».
+ */
+export function textoDelMapa(mapa, ruta) {
+    if (mapa.sinMapa === "nada-que-mapear")
+        return null;
+    if (mapa.sinMapa === "extension-no-soportada")
+        return null;
+    if (mapa.sinMapa === "no-parsea") {
+        // Se dice, en vez de callar: «no se pudo mapear» y «no hay nada» son
+        // distintos, y confundirlos le haría creer al agente que el resto del
+        // fichero está vacío.
+        return "No se ha podido mapear el resto del fichero (no parsea). Usa offset/limit para recorrerlo.";
+    }
+    const orden = ["clase", "interfaz", "funcion", "metodo", "getter", "tipo", "enum", "constante"];
+    const lista = [...mapa.declaraciones].sort((a, b) => a.linea - b.linea);
+    const mostradas = lista.slice(0, TOPE);
+    const lineas = mostradas.map((d) => `  ${String(d.linea).padStart(5)}  ${d.que.padEnd(10)} ${d.exportada ? "export " : ""}${d.nombre}`);
+    let texto = `Lo que NO se ha mostrado de ${ruta} contiene estas declaraciones. ` +
+        `Usa \`read\` con \`offset\` para ir directo a la que necesites:\n${lineas.join("\n")}`;
+    if (lista.length > mostradas.length) {
+        // Se dice cuántas quedan: un mapa truncado en silencio repetiría el mismo
+        // fallo que este módulo existe para arreglar.
+        const porTipo = orden
+            .map((t) => [t, lista.slice(TOPE).filter((d) => d.que === t).length])
+            .filter(([, n]) => n > 0)
+            .map(([t, n]) => `${n} ${t}${n > 1 ? "s" : ""}`)
+            .join(", ");
+        texto += `\n  …y ${lista.length - mostradas.length} más (${porTipo}).`;
+    }
+    return texto;
+}
+//# sourceMappingURL=mapa.js.map