@hoilab/ada-cli 0.84.22 → 0.85.0

package/dist/core/scheduler/scheduler.js

@@ -0,0 +1,178 @@
+/**
+ * Scheduler: trabajo recurrente o diferido.
+ *
+ * Copiado del competidor SOLO en los dos detalles que separan un scheduler de
+ * un pie de plomo:
+ *
+ * 1. **Reclamar antes de entregar.** Un job cuya ejecución anterior sigue en
+ *    vuelo se SALTA, no se encola. Sin esto, un job más lento que su intervalo
+ *    acumula ejecuciones hasta ahogar la sesión.
+ * 2. **`nextRunAt` avanza al reclamar**, no al terminar. Así una ejecución lenta
+ *    no arrastra el horario.
+ *
+ * Y tres frenos que a ellos les faltan, cada uno por un riesgo real:
+ *
+ * - **Nunca hace steer.** Su modo por defecto inyecta el prompt recurrente
+ *   DENTRO de un turno activo, que es un vector de inyección: lo que diga el
+ *   texto programado entra a mitad de un razonamiento. Aquí siempre se entrega
+ *   como turno nuevo, y no es configurable.
+ * - **Techo de ejecuciones y caducidad obligatorios.** Un heartbeat desatendido
+ *   gasta tokens para siempre; ellos no tienen tope alguno.
+ * - **Se desactiva solo tras fallos seguidos**, para que un job roto no siga
+ *   quemando presupuesto indefinidamente.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+/** Tope duro: ningún job puede programarse sin límite de ejecuciones. */
+const MAX_RUNS_CEILING = 1000;
+const FAILURES_BEFORE_DISABLE = 3;
+export class Scheduler {
+    path;
+    data = { version: 1, jobs: [], inFlight: [] };
+    loaded = false;
+    counter = 0;
+    constructor(agentDir) {
+        this.path = join(agentDir, "scheduler.json");
+    }
+    load() {
+        if (this.loaded)
+            return;
+        try {
+            const parsed = JSON.parse(readFileSync(this.path, "utf-8"));
+            if (parsed.version === 1 && Array.isArray(parsed.jobs)) {
+                this.data = { version: 1, jobs: parsed.jobs, inFlight: parsed.inFlight ?? [] };
+            }
+        }
+        catch {
+            // primer arranque o fichero corrupto
+        }
+        this.loaded = true;
+    }
+    save() {
+        mkdirSync(dirname(this.path), { recursive: true });
+        const tmp = `${this.path}.tmp`;
+        writeFileSync(tmp, JSON.stringify(this.data, null, 1), "utf-8");
+        renameSync(tmp, this.path);
+    }
+    list() {
+        this.load();
+        return this.data.jobs;
+    }
+    /**
+     * Programa un job. `maxRuns` y `expiresAt` son obligatorios a propósito: un
+     * scheduler sin techo es una fuga de presupuesto con sintaxis bonita.
+     */
+    add(input) {
+        this.load();
+        if (!input.prompt.trim())
+            return { ok: false, error: "El prompt no puede estar vacío." };
+        if (!Number.isFinite(input.maxRuns) || input.maxRuns < 1) {
+            return { ok: false, error: "maxRuns es obligatorio y debe ser >= 1." };
+        }
+        if (input.maxRuns > MAX_RUNS_CEILING) {
+            return { ok: false, error: `maxRuns no puede superar ${MAX_RUNS_CEILING}.` };
+        }
+        if (Number.isNaN(Date.parse(input.expiresAt))) {
+            return { ok: false, error: "expiresAt es obligatorio y debe ser una fecha ISO." };
+        }
+        if (this.data.jobs.some((job) => job.id === input.id)) {
+            return { ok: false, error: `Ya existe un job con id '${input.id}'.` };
+        }
+        this.data.jobs.push({
+            id: input.id,
+            prompt: input.prompt,
+            intervalMs: input.intervalMs,
+            nextRunAt: input.firstRunAt,
+            runsUsed: 0,
+            maxRuns: input.maxRuns,
+            expiresAt: input.expiresAt,
+            enabled: true,
+            consecutiveFailures: 0,
+            createdAt: input.now ?? new Date().toISOString(),
+        });
+        this.save();
+        return { ok: true };
+    }
+    remove(id) {
+        this.load();
+        const before = this.data.jobs.length;
+        this.data.jobs = this.data.jobs.filter((job) => job.id !== id);
+        if (this.data.jobs.length === before)
+            return false;
+        this.save();
+        return true;
+    }
+    /**
+     * Reclama los jobs vencidos.
+     *
+     * Un job con una ejecución en vuelo se salta: avanza su horario pero no se
+     * entrega. Es lo que impide que un job lento se acumule sobre sí mismo.
+     */
+    claimDue(nowIso) {
+        this.load();
+        const now = Date.parse(nowIso);
+        const inFlightJobs = new Set(this.data.inFlight.map((entry) => entry.jobId));
+        const dispatches = [];
+        for (const job of this.data.jobs) {
+            if (!job.enabled)
+                continue;
+            if (Date.parse(job.expiresAt) <= now) {
+                job.enabled = false;
+                continue;
+            }
+            if (job.runsUsed >= job.maxRuns) {
+                job.enabled = false;
+                continue;
+            }
+            if (Date.parse(job.nextRunAt) > now)
+                continue;
+            // El horario avanza SIEMPRE al reclamar, incluso si se salta: una
+            // ejecución lenta no debe arrastrar el calendario.
+            job.nextRunAt = job.intervalMs
+                ? new Date(now + job.intervalMs).toISOString()
+                : new Date(now + 1).toISOString();
+            if (!job.intervalMs)
+                job.enabled = false; // ejecución única
+            if (inFlightJobs.has(job.id))
+                continue; // ya hay una en vuelo: se salta
+            const dispatchId = `d-${job.id}-${++this.counter}`;
+            this.data.inFlight.push({ dispatchId, jobId: job.id, claimedAt: nowIso });
+            job.runsUsed += 1;
+            dispatches.push({ dispatchId, job: { ...job } });
+        }
+        this.save();
+        return dispatches;
+    }
+    /** Cierra una ejecución. Tras varios fallos seguidos el job se desactiva. */
+    complete(dispatchId, ok) {
+        this.load();
+        const index = this.data.inFlight.findIndex((entry) => entry.dispatchId === dispatchId);
+        if (index === -1)
+            return;
+        const [entry] = this.data.inFlight.splice(index, 1);
+        const job = this.data.jobs.find((candidate) => candidate.id === entry.jobId);
+        if (job) {
+            job.consecutiveFailures = ok ? 0 : job.consecutiveFailures + 1;
+            if (job.consecutiveFailures >= FAILURES_BEFORE_DISABLE)
+                job.enabled = false;
+        }
+        this.save();
+    }
+    /**
+     * Libera ejecuciones que murieron con el proceso.
+     *
+     * Sin esto un crash deja el job marcado como "en vuelo" para siempre y no
+     * vuelve a entregarse nunca — el mismo fallo que teníamos en los workflows.
+     */
+    reconcile(nowIso, staleAfterMs = 30 * 60 * 1000) {
+        this.load();
+        const now = Date.parse(nowIso);
+        const before = this.data.inFlight.length;
+        this.data.inFlight = this.data.inFlight.filter((entry) => now - Date.parse(entry.claimedAt) < staleAfterMs);
+        const reclaimed = before - this.data.inFlight.length;
+        if (reclaimed > 0)
+            this.save();
+        return reclaimed;
+    }
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/core/scheduler/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../../../src/core/scheduler/scheduler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Scheduler: trabajo recurrente o diferido.\n *\n * Copiado del competidor SOLO en los dos detalles que separan un scheduler de\n * un pie de plomo:\n *\n * 1. **Reclamar antes de entregar.** Un job cuya ejecución anterior sigue en\n *    vuelo se SALTA, no se encola. Sin esto, un job más lento que su intervalo\n *    acumula ejecuciones hasta ahogar la sesión.\n * 2. **`nextRunAt` avanza al reclamar**, no al terminar. Así una ejecución lenta\n *    no arrastra el horario.\n *\n * Y tres frenos que a ellos les faltan, cada uno por un riesgo real:\n *\n * - **Nunca hace steer.** Su modo por defecto inyecta el prompt recurrente\n *   DENTRO de un turno activo, que es un vector de inyección: lo que diga el\n *   texto programado entra a mitad de un razonamiento. Aquí siempre se entrega\n *   como turno nuevo, y no es configurable.\n * - **Techo de ejecuciones y caducidad obligatorios.** Un heartbeat desatendido\n *   gasta tokens para siempre; ellos no tienen tope alguno.\n * - **Se desactiva solo tras fallos seguidos**, para que un job roto no siga\n *   quemando presupuesto indefinidamente.\n */\n\nimport { mkdirSync, readFileSync, renameSync, writeFileSync } from \"node:fs\";\nimport { dirname, join } from \"node:path\";\n\n/** Tope duro: ningún job puede programarse sin límite de ejecuciones. */\nconst MAX_RUNS_CEILING = 1000;\nconst FAILURES_BEFORE_DISABLE = 3;\n\nexport interface ScheduledJob {\n\tid: string;\n\t/** Texto que se entrega como turno nuevo. */\n\tprompt: string;\n\t/** Repetición en ms. Ausente = ejecución única. */\n\tintervalMs?: number;\n\tnextRunAt: string;\n\trunsUsed: number;\n\t/** Obligatorio: sin techo no se crea el job. */\n\tmaxRuns: number;\n\t/** ISO. Pasada esta fecha el job no vuelve a correr. */\n\texpiresAt: string;\n\tenabled: boolean;\n\tconsecutiveFailures: number;\n\tcreatedAt: string;\n}\n\nexport interface Dispatch {\n\tdispatchId: string;\n\tjob: ScheduledJob;\n}\n\ninterface SchedulerFile {\n\tversion: 1;\n\tjobs: ScheduledJob[];\n\t/** Ejecuciones reclamadas y aún sin cerrar. */\n\tinFlight: Array<{ dispatchId: string; jobId: string; claimedAt: string }>;\n}\n\nexport class Scheduler {\n\tprivate path: string;\n\tprivate data: SchedulerFile = { version: 1, jobs: [], inFlight: [] };\n\tprivate loaded = false;\n\tprivate counter = 0;\n\n\tconstructor(agentDir: string) {\n\t\tthis.path = join(agentDir, \"scheduler.json\");\n\t}\n\n\tprivate load(): void {\n\t\tif (this.loaded) return;\n\t\ttry {\n\t\t\tconst parsed = JSON.parse(readFileSync(this.path, \"utf-8\")) as SchedulerFile;\n\t\t\tif (parsed.version === 1 && Array.isArray(parsed.jobs)) {\n\t\t\t\tthis.data = { version: 1, jobs: parsed.jobs, inFlight: parsed.inFlight ?? [] };\n\t\t\t}\n\t\t} catch {\n\t\t\t// primer arranque o fichero corrupto\n\t\t}\n\t\tthis.loaded = true;\n\t}\n\n\tprivate save(): void {\n\t\tmkdirSync(dirname(this.path), { recursive: true });\n\t\tconst tmp = `${this.path}.tmp`;\n\t\twriteFileSync(tmp, JSON.stringify(this.data, null, 1), \"utf-8\");\n\t\trenameSync(tmp, this.path);\n\t}\n\n\tlist(): ScheduledJob[] {\n\t\tthis.load();\n\t\treturn this.data.jobs;\n\t}\n\n\t/**\n\t * Programa un job. `maxRuns` y `expiresAt` son obligatorios a propósito: un\n\t * scheduler sin techo es una fuga de presupuesto con sintaxis bonita.\n\t */\n\tadd(input: {\n\t\tid: string;\n\t\tprompt: string;\n\t\tfirstRunAt: string;\n\t\tintervalMs?: number;\n\t\tmaxRuns: number;\n\t\texpiresAt: string;\n\t\tnow?: string;\n\t}): { ok: boolean; error?: string } {\n\t\tthis.load();\n\t\tif (!input.prompt.trim()) return { ok: false, error: \"El prompt no puede estar vacío.\" };\n\t\tif (!Number.isFinite(input.maxRuns) || input.maxRuns < 1) {\n\t\t\treturn { ok: false, error: \"maxRuns es obligatorio y debe ser >= 1.\" };\n\t\t}\n\t\tif (input.maxRuns > MAX_RUNS_CEILING) {\n\t\t\treturn { ok: false, error: `maxRuns no puede superar ${MAX_RUNS_CEILING}.` };\n\t\t}\n\t\tif (Number.isNaN(Date.parse(input.expiresAt))) {\n\t\t\treturn { ok: false, error: \"expiresAt es obligatorio y debe ser una fecha ISO.\" };\n\t\t}\n\t\tif (this.data.jobs.some((job) => job.id === input.id)) {\n\t\t\treturn { ok: false, error: `Ya existe un job con id '${input.id}'.` };\n\t\t}\n\t\tthis.data.jobs.push({\n\t\t\tid: input.id,\n\t\t\tprompt: input.prompt,\n\t\t\tintervalMs: input.intervalMs,\n\t\t\tnextRunAt: input.firstRunAt,\n\t\t\trunsUsed: 0,\n\t\t\tmaxRuns: input.maxRuns,\n\t\t\texpiresAt: input.expiresAt,\n\t\t\tenabled: true,\n\t\t\tconsecutiveFailures: 0,\n\t\t\tcreatedAt: input.now ?? new Date().toISOString(),\n\t\t});\n\t\tthis.save();\n\t\treturn { ok: true };\n\t}\n\n\tremove(id: string): boolean {\n\t\tthis.load();\n\t\tconst before = this.data.jobs.length;\n\t\tthis.data.jobs = this.data.jobs.filter((job) => job.id !== id);\n\t\tif (this.data.jobs.length === before) return false;\n\t\tthis.save();\n\t\treturn true;\n\t}\n\n\t/**\n\t * Reclama los jobs vencidos.\n\t *\n\t * Un job con una ejecución en vuelo se salta: avanza su horario pero no se\n\t * entrega. Es lo que impide que un job lento se acumule sobre sí mismo.\n\t */\n\tclaimDue(nowIso: string): Dispatch[] {\n\t\tthis.load();\n\t\tconst now = Date.parse(nowIso);\n\t\tconst inFlightJobs = new Set(this.data.inFlight.map((entry) => entry.jobId));\n\t\tconst dispatches: Dispatch[] = [];\n\n\t\tfor (const job of this.data.jobs) {\n\t\t\tif (!job.enabled) continue;\n\t\t\tif (Date.parse(job.expiresAt) <= now) {\n\t\t\t\tjob.enabled = false;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (job.runsUsed >= job.maxRuns) {\n\t\t\t\tjob.enabled = false;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (Date.parse(job.nextRunAt) > now) continue;\n\n\t\t\t// El horario avanza SIEMPRE al reclamar, incluso si se salta: una\n\t\t\t// ejecución lenta no debe arrastrar el calendario.\n\t\t\tjob.nextRunAt = job.intervalMs\n\t\t\t\t? new Date(now + job.intervalMs).toISOString()\n\t\t\t\t: new Date(now + 1).toISOString();\n\t\t\tif (!job.intervalMs) job.enabled = false; // ejecución única\n\n\t\t\tif (inFlightJobs.has(job.id)) continue; // ya hay una en vuelo: se salta\n\n\t\t\tconst dispatchId = `d-${job.id}-${++this.counter}`;\n\t\t\tthis.data.inFlight.push({ dispatchId, jobId: job.id, claimedAt: nowIso });\n\t\t\tjob.runsUsed += 1;\n\t\t\tdispatches.push({ dispatchId, job: { ...job } });\n\t\t}\n\t\tthis.save();\n\t\treturn dispatches;\n\t}\n\n\t/** Cierra una ejecución. Tras varios fallos seguidos el job se desactiva. */\n\tcomplete(dispatchId: string, ok: boolean): void {\n\t\tthis.load();\n\t\tconst index = this.data.inFlight.findIndex((entry) => entry.dispatchId === dispatchId);\n\t\tif (index === -1) return;\n\t\tconst [entry] = this.data.inFlight.splice(index, 1);\n\t\tconst job = this.data.jobs.find((candidate) => candidate.id === entry.jobId);\n\t\tif (job) {\n\t\t\tjob.consecutiveFailures = ok ? 0 : job.consecutiveFailures + 1;\n\t\t\tif (job.consecutiveFailures >= FAILURES_BEFORE_DISABLE) job.enabled = false;\n\t\t}\n\t\tthis.save();\n\t}\n\n\t/**\n\t * Libera ejecuciones que murieron con el proceso.\n\t *\n\t * Sin esto un crash deja el job marcado como \"en vuelo\" para siempre y no\n\t * vuelve a entregarse nunca — el mismo fallo que teníamos en los workflows.\n\t */\n\treconcile(nowIso: string, staleAfterMs = 30 * 60 * 1000): number {\n\t\tthis.load();\n\t\tconst now = Date.parse(nowIso);\n\t\tconst before = this.data.inFlight.length;\n\t\tthis.data.inFlight = this.data.inFlight.filter((entry) => now - Date.parse(entry.claimedAt) < staleAfterMs);\n\t\tconst reclaimed = before - this.data.inFlight.length;\n\t\tif (reclaimed > 0) this.save();\n\t\treturn reclaimed;\n\t}\n}\n"]}

package/dist/core/sesion/cerrar-llamadas-abiertas.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Cerrar las llamadas que un turno abortado deja a medias — desde el paquete
+ * que sí llega al cliente.
+ *
+ * EL FALLO. Los proveedores rechazan un historial donde un `tool_use` no tiene
+ * su `tool_result`. Si al abortar el par queda a medias, la conversación entera
+ * deja de poder reanudarse: un Ctrl-C en el momento equivocado no estropea el
+ * turno, estropea la sesión.
+ *
+ * Medido sobre el historial real, antes de arreglarlo:
+ *
+ *     user:text | assistant:toolCall            <- huérfana
+ *
+ * y después:
+ *
+ *     user:text | assistant:toolCall | toolResult:text
+ *
+ * POR QUÉ AQUÍ Y NO SOLO EN EL BUCLE. El arreglo existe también en
+ * `packages/agent/src/agent-loop.ts`, pero ESE PAQUETE NO VIAJA: el tarball de
+ * `@hoilab/ada-cli` resuelve `@earendil-works/pi-agent-core` del registro de
+ * npm, así que quien instala recibe el de upstream, sin el arreglo. Medido con
+ * `npm pack --dry-run`: cero ficheros de esos paquetes en el tarball.
+ *
+ * ES IDEMPOTENTE POR CONSTRUCCIÓN, que es lo que permite tener las dos. Solo
+ * cierra lo que sigue abierto: si el bucle ya lo hizo —al ejecutar desde el
+ * árbol de fuentes— no encuentra huérfanas y no añade nada. Nunca duplica.
+ */
+interface LlamadaAbierta {
+    id: string;
+    nombre: string;
+}
+/**
+ * Las llamadas de `mensaje` que el historial no ha cerrado todavía.
+ *
+ * OJO CON LA FORMA, porque la primera versión de esta comprobación miró la
+ * equivocada y no medía nada: una llamada es un BLOQUE dentro del contenido de
+ * un mensaje `assistant`, pero un resultado es un MENSAJE entero con
+ * `role: "toolResult"` y su `toolCallId` al nivel del mensaje, no un bloque.
+ */
+export declare function llamadasSinCerrar(historial: readonly unknown[], mensaje: unknown): LlamadaAbierta[];
+/**
+ * Cierra en `historial` las llamadas que `mensaje` dejó abiertas.
+ *
+ * Devuelve cuántas cerró: cero es la respuesta normal y significa que no había
+ * nada que cerrar, no que no se haya mirado.
+ */
+export declare function cerrarLlamadasAbiertas(historial: unknown[], mensaje: unknown): number;
+export {};
+//# sourceMappingURL=cerrar-llamadas-abiertas.d.ts.map

package/dist/core/sesion/cerrar-llamadas-abiertas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cerrar-llamadas-abiertas.d.ts","sourceRoot":"","sources":["../../../src/core/sesion/cerrar-llamadas-abiertas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AASH,UAAU,cAAc;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,cAAc,EAAE,CAgBnG;AAcD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAIrF","sourcesContent":["/**\n * Cerrar las llamadas que un turno abortado deja a medias — desde el paquete\n * que sí llega al cliente.\n *\n * EL FALLO. Los proveedores rechazan un historial donde un `tool_use` no tiene\n * su `tool_result`. Si al abortar el par queda a medias, la conversación entera\n * deja de poder reanudarse: un Ctrl-C en el momento equivocado no estropea el\n * turno, estropea la sesión.\n *\n * Medido sobre el historial real, antes de arreglarlo:\n *\n *     user:text | assistant:toolCall            <- huérfana\n *\n * y después:\n *\n *     user:text | assistant:toolCall | toolResult:text\n *\n * POR QUÉ AQUÍ Y NO SOLO EN EL BUCLE. El arreglo existe también en\n * `packages/agent/src/agent-loop.ts`, pero ESE PAQUETE NO VIAJA: el tarball de\n * `@hoilab/ada-cli` resuelve `@earendil-works/pi-agent-core` del registro de\n * npm, así que quien instala recibe el de upstream, sin el arreglo. Medido con\n * `npm pack --dry-run`: cero ficheros de esos paquetes en el tarball.\n *\n * ES IDEMPOTENTE POR CONSTRUCCIÓN, que es lo que permite tener las dos. Solo\n * cierra lo que sigue abierto: si el bucle ya lo hizo —al ejecutar desde el\n * árbol de fuentes— no encuentra huérfanas y no añade nada. Nunca duplica.\n */\n\n/** Lo mínimo que hace falta de un mensaje para decidir. */\ninterface MensajeMinimo {\n\trole?: string;\n\ttoolCallId?: unknown;\n\tcontent?: unknown;\n}\n\ninterface LlamadaAbierta {\n\tid: string;\n\tnombre: string;\n}\n\n/**\n * Las llamadas de `mensaje` que el historial no ha cerrado todavía.\n *\n * OJO CON LA FORMA, porque la primera versión de esta comprobación miró la\n * equivocada y no medía nada: una llamada es un BLOQUE dentro del contenido de\n * un mensaje `assistant`, pero un resultado es un MENSAJE entero con\n * `role: \"toolResult\"` y su `toolCallId` al nivel del mensaje, no un bloque.\n */\nexport function llamadasSinCerrar(historial: readonly unknown[], mensaje: unknown): LlamadaAbierta[] {\n\tconst m = mensaje as MensajeMinimo;\n\tconst bloques = Array.isArray(m?.content) ? (m.content as Array<Record<string, unknown>>) : [];\n\tconst abiertas: LlamadaAbierta[] = [];\n\tfor (const b of bloques) {\n\t\tif (b.type === \"toolCall\" && typeof b.id === \"string\") {\n\t\t\tabiertas.push({ id: b.id, nombre: typeof b.name === \"string\" ? b.name : \"desconocida\" });\n\t\t}\n\t}\n\tif (abiertas.length === 0) return [];\n\n\tconst cerradas = new Set<string>();\n\tfor (const entrada of historial as MensajeMinimo[]) {\n\t\tif (entrada?.role === \"toolResult\" && typeof entrada.toolCallId === \"string\") cerradas.add(entrada.toolCallId);\n\t}\n\treturn abiertas.filter((l) => !cerradas.has(l.id));\n}\n\n/** El resultado sintético que habría producido la ejecución al ver la señal. */\nfunction resultadoDeAborto(llamada: LlamadaAbierta): Record<string, unknown> {\n\treturn {\n\t\trole: \"toolResult\",\n\t\ttoolCallId: llamada.id,\n\t\ttoolName: llamada.nombre,\n\t\tcontent: [{ type: \"text\", text: \"Operation aborted\" }],\n\t\tisError: true,\n\t\ttimestamp: Date.now(),\n\t};\n}\n\n/**\n * Cierra en `historial` las llamadas que `mensaje` dejó abiertas.\n *\n * Devuelve cuántas cerró: cero es la respuesta normal y significa que no había\n * nada que cerrar, no que no se haya mirado.\n */\nexport function cerrarLlamadasAbiertas(historial: unknown[], mensaje: unknown): number {\n\tconst abiertas = llamadasSinCerrar(historial, mensaje);\n\tfor (const llamada of abiertas) historial.push(resultadoDeAborto(llamada));\n\treturn abiertas.length;\n}\n"]}

package/dist/core/sesion/cerrar-llamadas-abiertas.js

@@ -0,0 +1,77 @@
+/**
+ * Cerrar las llamadas que un turno abortado deja a medias — desde el paquete
+ * que sí llega al cliente.
+ *
+ * EL FALLO. Los proveedores rechazan un historial donde un `tool_use` no tiene
+ * su `tool_result`. Si al abortar el par queda a medias, la conversación entera
+ * deja de poder reanudarse: un Ctrl-C en el momento equivocado no estropea el
+ * turno, estropea la sesión.
+ *
+ * Medido sobre el historial real, antes de arreglarlo:
+ *
+ *     user:text | assistant:toolCall            <- huérfana
+ *
+ * y después:
+ *
+ *     user:text | assistant:toolCall | toolResult:text
+ *
+ * POR QUÉ AQUÍ Y NO SOLO EN EL BUCLE. El arreglo existe también en
+ * `packages/agent/src/agent-loop.ts`, pero ESE PAQUETE NO VIAJA: el tarball de
+ * `@hoilab/ada-cli` resuelve `@earendil-works/pi-agent-core` del registro de
+ * npm, así que quien instala recibe el de upstream, sin el arreglo. Medido con
+ * `npm pack --dry-run`: cero ficheros de esos paquetes en el tarball.
+ *
+ * ES IDEMPOTENTE POR CONSTRUCCIÓN, que es lo que permite tener las dos. Solo
+ * cierra lo que sigue abierto: si el bucle ya lo hizo —al ejecutar desde el
+ * árbol de fuentes— no encuentra huérfanas y no añade nada. Nunca duplica.
+ */
+/**
+ * Las llamadas de `mensaje` que el historial no ha cerrado todavía.
+ *
+ * OJO CON LA FORMA, porque la primera versión de esta comprobación miró la
+ * equivocada y no medía nada: una llamada es un BLOQUE dentro del contenido de
+ * un mensaje `assistant`, pero un resultado es un MENSAJE entero con
+ * `role: "toolResult"` y su `toolCallId` al nivel del mensaje, no un bloque.
+ */
+export function llamadasSinCerrar(historial, mensaje) {
+    const m = mensaje;
+    const bloques = Array.isArray(m?.content) ? m.content : [];
+    const abiertas = [];
+    for (const b of bloques) {
+        if (b.type === "toolCall" && typeof b.id === "string") {
+            abiertas.push({ id: b.id, nombre: typeof b.name === "string" ? b.name : "desconocida" });
+        }
+    }
+    if (abiertas.length === 0)
+        return [];
+    const cerradas = new Set();
+    for (const entrada of historial) {
+        if (entrada?.role === "toolResult" && typeof entrada.toolCallId === "string")
+            cerradas.add(entrada.toolCallId);
+    }
+    return abiertas.filter((l) => !cerradas.has(l.id));
+}
+/** El resultado sintético que habría producido la ejecución al ver la señal. */
+function resultadoDeAborto(llamada) {
+    return {
+        role: "toolResult",
+        toolCallId: llamada.id,
+        toolName: llamada.nombre,
+        content: [{ type: "text", text: "Operation aborted" }],
+        isError: true,
+        timestamp: Date.now(),
+    };
+}
+/**
+ * Cierra en `historial` las llamadas que `mensaje` dejó abiertas.
+ *
+ * Devuelve cuántas cerró: cero es la respuesta normal y significa que no había
+ * nada que cerrar, no que no se haya mirado.
+ */
+export function cerrarLlamadasAbiertas(historial, mensaje) {
+    const abiertas = llamadasSinCerrar(historial, mensaje);
+    for (const llamada of abiertas)
+        historial.push(resultadoDeAborto(llamada));
+    return abiertas.length;
+}
+//# sourceMappingURL=cerrar-llamadas-abiertas.js.map

package/dist/core/sesion/cerrar-llamadas-abiertas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cerrar-llamadas-abiertas.js","sourceRoot":"","sources":["../../../src/core/sesion/cerrar-llamadas-abiertas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAcH;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,SAA6B,EAAE,OAAgB,EAAoB;IACpG,MAAM,CAAC,GAAG,OAAwB,CAAC;IACnC,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAE,CAAC,CAAC,OAA0C,CAAC,CAAC,CAAC,EAAE,CAAC;IAC/F,MAAM,QAAQ,GAAqB,EAAE,CAAC;IACtC,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACzB,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,QAAQ,EAAE,CAAC;YACvD,QAAQ,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC,CAAC;QAC1F,CAAC;IACF,CAAC;IACD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAErC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IACnC,KAAK,MAAM,OAAO,IAAI,SAA4B,EAAE,CAAC;QACpD,IAAI,OAAO,EAAE,IAAI,KAAK,YAAY,IAAI,OAAO,OAAO,CAAC,UAAU,KAAK,QAAQ;YAAE,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAChH,CAAC;IACD,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAAA,CACnD;AAED,oFAAgF;AAChF,SAAS,iBAAiB,CAAC,OAAuB,EAA2B;IAC5E,OAAO;QACN,IAAI,EAAE,YAAY;QAClB,UAAU,EAAE,OAAO,CAAC,EAAE;QACtB,QAAQ,EAAE,OAAO,CAAC,MAAM;QACxB,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;QACtD,OAAO,EAAE,IAAI;QACb,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;KACrB,CAAC;AAAA,CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CAAC,SAAoB,EAAE,OAAgB,EAAU;IACtF,MAAM,QAAQ,GAAG,iBAAiB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IACvD,KAAK,MAAM,OAAO,IAAI,QAAQ;QAAE,SAAS,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3E,OAAO,QAAQ,CAAC,MAAM,CAAC;AAAA,CACvB","sourcesContent":["/**\n * Cerrar las llamadas que un turno abortado deja a medias — desde el paquete\n * que sí llega al cliente.\n *\n * EL FALLO. Los proveedores rechazan un historial donde un `tool_use` no tiene\n * su `tool_result`. Si al abortar el par queda a medias, la conversación entera\n * deja de poder reanudarse: un Ctrl-C en el momento equivocado no estropea el\n * turno, estropea la sesión.\n *\n * Medido sobre el historial real, antes de arreglarlo:\n *\n *     user:text | assistant:toolCall            <- huérfana\n *\n * y después:\n *\n *     user:text | assistant:toolCall | toolResult:text\n *\n * POR QUÉ AQUÍ Y NO SOLO EN EL BUCLE. El arreglo existe también en\n * `packages/agent/src/agent-loop.ts`, pero ESE PAQUETE NO VIAJA: el tarball de\n * `@hoilab/ada-cli` resuelve `@earendil-works/pi-agent-core` del registro de\n * npm, así que quien instala recibe el de upstream, sin el arreglo. Medido con\n * `npm pack --dry-run`: cero ficheros de esos paquetes en el tarball.\n *\n * ES IDEMPOTENTE POR CONSTRUCCIÓN, que es lo que permite tener las dos. Solo\n * cierra lo que sigue abierto: si el bucle ya lo hizo —al ejecutar desde el\n * árbol de fuentes— no encuentra huérfanas y no añade nada. Nunca duplica.\n */\n\n/** Lo mínimo que hace falta de un mensaje para decidir. */\ninterface MensajeMinimo {\n\trole?: string;\n\ttoolCallId?: unknown;\n\tcontent?: unknown;\n}\n\ninterface LlamadaAbierta {\n\tid: string;\n\tnombre: string;\n}\n\n/**\n * Las llamadas de `mensaje` que el historial no ha cerrado todavía.\n *\n * OJO CON LA FORMA, porque la primera versión de esta comprobación miró la\n * equivocada y no medía nada: una llamada es un BLOQUE dentro del contenido de\n * un mensaje `assistant`, pero un resultado es un MENSAJE entero con\n * `role: \"toolResult\"` y su `toolCallId` al nivel del mensaje, no un bloque.\n */\nexport function llamadasSinCerrar(historial: readonly unknown[], mensaje: unknown): LlamadaAbierta[] {\n\tconst m = mensaje as MensajeMinimo;\n\tconst bloques = Array.isArray(m?.content) ? (m.content as Array<Record<string, unknown>>) : [];\n\tconst abiertas: LlamadaAbierta[] = [];\n\tfor (const b of bloques) {\n\t\tif (b.type === \"toolCall\" && typeof b.id === \"string\") {\n\t\t\tabiertas.push({ id: b.id, nombre: typeof b.name === \"string\" ? b.name : \"desconocida\" });\n\t\t}\n\t}\n\tif (abiertas.length === 0) return [];\n\n\tconst cerradas = new Set<string>();\n\tfor (const entrada of historial as MensajeMinimo[]) {\n\t\tif (entrada?.role === \"toolResult\" && typeof entrada.toolCallId === \"string\") cerradas.add(entrada.toolCallId);\n\t}\n\treturn abiertas.filter((l) => !cerradas.has(l.id));\n}\n\n/** El resultado sintético que habría producido la ejecución al ver la señal. */\nfunction resultadoDeAborto(llamada: LlamadaAbierta): Record<string, unknown> {\n\treturn {\n\t\trole: \"toolResult\",\n\t\ttoolCallId: llamada.id,\n\t\ttoolName: llamada.nombre,\n\t\tcontent: [{ type: \"text\", text: \"Operation aborted\" }],\n\t\tisError: true,\n\t\ttimestamp: Date.now(),\n\t};\n}\n\n/**\n * Cierra en `historial` las llamadas que `mensaje` dejó abiertas.\n *\n * Devuelve cuántas cerró: cero es la respuesta normal y significa que no había\n * nada que cerrar, no que no se haya mirado.\n */\nexport function cerrarLlamadasAbiertas(historial: unknown[], mensaje: unknown): number {\n\tconst abiertas = llamadasSinCerrar(historial, mensaje);\n\tfor (const llamada of abiertas) historial.push(resultadoDeAborto(llamada));\n\treturn abiertas.length;\n}\n"]}

package/dist/core/settings-manager.d.ts

@@ -85,6 +85,19 @@ export interface Settings {
     shellCommandPrefix?: string;
     npmCommand?: string[];
     collapseChangelog?: boolean;
+    /**
+     * INERTE desde que se quitaron las dos cosas que gobernaba.
+     *
+     * Eran el aviso de instalación a `https://pi.dev/api/report-install` y las
+     * cabeceras de atribución por defecto (`HTTP-Referer: https://ada.dev` y
+     * compañía). Las dos salían activadas y las dos contaban a un tercero algo
+     * que nadie había pedido contar, así que se fueron.
+     *
+     * El campo se conserva porque es superficie pública del SDK y quitarlo
+     * rompería a quien lo escriba; ponerlo a `true` o a `false` ya no cambia
+     * nada. Se dice aquí en vez de dejar un interruptor que finge gobernar algo:
+     * una casilla que no hace nada es peor que una casilla que no existe.
+     */
     enableInstallTelemetry?: boolean;
     enableAnalytics?: boolean;
     trackingId?: string;
@@ -107,6 +120,7 @@ export interface Settings {
     permissions?: Record<string, unknown>;
     graph?: Record<string, unknown>;
     computerUse?: Record<string, unknown>;
+    advisor?: Record<string, unknown>;
     memoryMode?: "policy" | "inject";
     memoryPrivacyLevel?: "strict" | "balanced" | "permissive";
     memoryAuditEnabled?: boolean;
@@ -316,6 +330,13 @@ export declare class SettingsManager {
     setFullscreenScrollbar(mode: ScrollViewScrollbar): void;
     getImageAutoResize(): boolean;
     getProjectMemoryEnabled(): boolean;
+    /** Servidores MCP declarados por el usuario (`mcpServers` en settings). */
+    getMcpServers(): Record<string, import("./mcp/manager.ts").McpServerConfig> | undefined;
+    /**
+     * Optimizador de caché de prompt (activo por defecto). Reordena el prefijo
+     * estable y rellena las claves de caché; ver core/prompt-cache/.
+     */
+    getPromptCacheEnabled(): boolean;
     setProjectMemoryEnabled(enabled: boolean): void;
     getMemoryMode(): "policy" | "inject";
     setMemoryMode(mode: "policy" | "inject"): void;
@@ -357,13 +378,96 @@ export declare class SettingsManager {
         failureInjectMaxEntries: number;
     };
     /** Config completa del Ada Intelligence Engine (bloques con defaults). */
+    /**
+     * Configuración del engine con los defaults ya aplicados.
+     *
+     * El tipo de retorno se INFIERE a propósito. La anotación anterior era
+     * `Record<string, unknown>` por bloque, que tiraba toda la forma: quien
+     * llamaba veía `cfg.workflows.budget` como `unknown` y tenía que castear
+     * para leer un valor que este mismo método acababa de construir. Un tipo
+     * que obliga a castear no está documentando nada.
+     */
     getEngineConfig(): {
-        workflows: Record<string, unknown>;
-        goalEngine: Record<string, unknown>;
-        hooks: Record<string, unknown>;
-        permissions: Record<string, unknown>;
-        graph: Record<string, unknown>;
-        computerUse: Record<string, unknown>;
+        workflows: {
+            enabled: boolean;
+            concurrency: number;
+            maxAgentsPerRun: number;
+            budget: {
+                perRun: {
+                    tokens: number;
+                    usd: number;
+                };
+                perAgent: {
+                    tokens: number;
+                };
+                perPhase: {} | null;
+            };
+            timeouts: {
+                agentMs: number;
+                scriptMs: number;
+                drainMs: number;
+            };
+            judge: {
+                model: string;
+                crossModel: boolean;
+                cheapForIntermediate: boolean;
+            };
+            models: {
+                cheap: string | null;
+                main: string | null;
+                judge: string | null;
+                cheapCandidates: string[];
+                cheapThinking: string | null;
+                mainThinking: string | null;
+                judgeThinking: string | null;
+            };
+            autoResume: boolean;
+            web: {
+                searchProvider: string;
+                fetch: string;
+            };
+        };
+        goalEngine: {
+            enabled: boolean;
+            maxTurns: number;
+            repeatDetector: number;
+            stopFile: string;
+            budgetTokens: number;
+            autopilot: boolean;
+            allowShipThrough: boolean;
+            askBefore: {};
+            workTier: string;
+            planOnly: boolean;
+        };
+        hooks: {
+            enabled: boolean;
+            failClosedHeadless: boolean;
+            events: Record<string, {
+                matcher?: string | undefined;
+                command: string;
+                timeoutMs?: number | undefined;
+            }[]>;
+        };
+        permissions: {
+            level: string;
+            destructiveGuards: boolean;
+            envGuards: boolean;
+            denied: unknown;
+        };
+        graph: {
+            enabled: boolean;
+            minConfidence: number;
+            gates: boolean;
+        };
+        computerUse: {
+            enabled: boolean;
+            backend: string;
+            browser: boolean;
+        };
+        advisor: {
+            enabled: boolean;
+            cadaCuantosTurnos: number;
+        };
     };
     getWorkflowsEnabled(): boolean;
     setWorkflowsEnabled(v: boolean): void;