@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/agent-session.js

@@ -21,10 +21,11 @@ import { stripFrontmatter } from "../utils/frontmatter.js";
 import { resolvePath } from "../utils/paths.js";
 import { sleep } from "../utils/sleep.js";
 import { normalizeToolResultImages } from "../utils/tool-result-images.js";
+import { abrirTurno, ajustarPresupuestoDeRazonamiento, anadirRegistroDenso, buildEnginePersonalityBlock, buscarConElModelo, cerrarLlamadasAbiertas, construirAdvisorDeSesion, construirDesglose, crearBrowserTools, crearComputerTools, crearEstructuralTools, crearInteractivoTools, crearObtenerClave, createGraphTool, createMcpTools, createMemoryEngineTools, createWebTools, createWorkflowTool, dispararHooks, envolverReadConPdf, envolverReadConUrlsInternas, estadoDelTurno, expandVaultRefs, GraphSync, goalSessionTools, leerDenegadas, loadProjectMemorySync, mensajeDeTurnoVacio, nivelDesdeConfig, optimizeUserPrompt, RegistroDeSesion, redactSensitive, saveProjectMemory, soportaBusquedaNativa, transcriptParaAdvisor, } from "./ada.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
-import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
+import { DEFAULT_THINKING_LEVEL, THINKING_LEVEL_OPTIONS } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
@@ -32,16 +33,13 @@ import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { ModelRegistry } from "./model-registry.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
-import { loadProjectMemorySync, saveProjectMemory } from "./project-memory.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { createLocalBashOperations } from "./tools/bash.js";
 import { createAllToolDefinitions } from "./tools/index.js";
-import { createMemoryEngineTools } from "./memory-engine/tools.js";
-import { redactSensitive } from "./memory-engine/security.js";
-import { expandVaultRefs } from "./memory-engine/vault.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
 import { addUsageToTotals, createUsageTotals } from "./usage-totals.js";
+import { publicarAnotarRed } from "./web/registro-red.js";
 /**
  * Parse a skill block from message text.
  * Returns null if the text doesn't contain a skill block.
@@ -75,8 +73,6 @@ function estimateMessagesTokens(messages) {
 // ============================================================================
 // Constants
 // ============================================================================
-/** Standard thinking levels */
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high"];
 // ============================================================================
 // AgentSession Class
 // ============================================================================
@@ -130,6 +126,50 @@ export class AgentSession {
     _extensionErrorListener;
     _extensionErrorUnsubscriber;
     _modelRuntime;
+    // ── Campos de Ada ────────────────────────────────────────────────────────
+    // Juntos y no repartidos por la clase a propósito: cada bloque separado en
+    // este fichero de upstream es un hunk más que reaplicar en cada sync.
+    _isSubagentSession = false;
+    _graphSync;
+    _advisor;
+    /** Una vuelta del advisor sobre la sesión. Nunca espera ni lanza. */
+    _mirarConAdvisor() {
+        this._advisor ??= construirAdvisorDeSesion({
+            settings: this.settingsManager,
+            modelo: () => this.model,
+            runtime: this._modelRuntime,
+            entregar: (texto, severidad) => {
+                void this.sendCustomMessage({
+                    customType: "advisor",
+                    content: [{ type: "text", text: texto }],
+                    display: true,
+                    details: { severidad },
+                }, { deliverAs: "steer" });
+            },
+            libro: this._registro.libro(),
+        });
+        this._advisor.trasTurno(transcriptParaAdvisor(this.agent.state.messages));
+    }
+    _registro = new RegistroDeSesion(() => this._resourceLoader.getAgentDir(), () => this.sessionId, () => this._cwd, async (texto) => {
+        // Sin modelo elegido, ni lo intentamos: que `intentarReparar` lo lea
+        // como "no-aplicable", no como una llamada al modelo que devolvió vacío.
+        const modelo = this.model;
+        if (!modelo)
+            return null;
+        try {
+            const respuesta = await this._modelRuntime.completeSimple(modelo, {
+                messages: [{ role: "user", content: texto }],
+            });
+            return contentText(respuesta.content, "").trim();
+        }
+        catch {
+            return null;
+        }
+    });
+    /** Optimizador autónomo de prompts: "off" | "auto" | "clarify". */
+    _promptOptimizerMode = "off";
+    /** Clarificación pendiente (modo "clarify"): original + preguntas ya emitidas. */
+    _pendingClarification;
     // Tool registry for extension getTools/setTools
     _toolRegistry = new Map();
     _toolDefinitions = new Map();
@@ -146,6 +186,11 @@ export class AgentSession {
         this._scopedModels = config.scopedModels ?? [];
         this._resourceLoader = config.resourceLoader;
         this._customTools = config.customTools ?? [];
+        // ANTES de `_buildRuntime()`, que consulta este campo para decidir qué
+        // tools recibe un subagente. Moverlo más abajo para ahorrar un hunk hizo
+        // que se leyera `false` y los subagentes recibieran memory_add/search —
+        // justo lo que la anti-recursión existe para impedir.
+        this._isSubagentSession = config.isSubagent === true;
         this._cwd = config.cwd;
         this._modelRuntime = config.modelRuntime;
         this._extensionRunnerRef = config.extensionRunnerRef;
@@ -163,6 +208,23 @@ export class AgentSession {
             activeToolNames: this._initialActiveToolNames,
             includeAllExtensionTools: true,
         });
+        // Los subagentes (goals/workflows) HEREDAN el modelo de la sesión principal:
+        // misma provider/modelId → misma auth → misma API key del chat.
+        this._resourceLoader.setSessionModelGetter?.(() => {
+            const m = this.model;
+            return m
+                ? {
+                    provider: m.provider,
+                    modelId: m.modelId ?? m.id ?? "",
+                }
+                : undefined;
+        });
+        // Cuando un run de workflow arranca (tool del agente o sub-tarea del
+        // goal), la sesión emite workflow_started — el desktop lo usa para
+        // abrir el panel Engine automáticamente.
+        this._resourceLoader.setOnWorkflowRunStarted?.((runId, name) => {
+            this._emit({ type: "workflow_started", runId, name });
+        });
         // Ada Memory Engine: lazy-initialize (stores, migration, session index)
         // and wire the LLM callback used by review/correction/flush. Best-effort
         // and never blocks startup.
@@ -190,8 +252,7 @@ export class AgentSession {
                     content: [
                         {
                             type: "text",
-                            text: "Has introducido un dato sensible que no se almacenará en memoria. " +
-                                reason,
+                            text: `Has introducido un dato sensible que no se almacenará en memoria. ${reason}`,
                         },
                     ],
                     display: true,
@@ -265,6 +326,30 @@ export class AgentSession {
      */
     _installAgentToolHooks() {
         this.agent.beforeToolCall = async ({ toolCall, args }) => {
+            // Política de aprobación por herramienta.
+            //
+            // Va ANTES que los hooks del usuario a propósito: las rutas
+            // protegidas y el `deny` explícito no son negociables, y dejar que un
+            // hook se ejecute primero le daría ocasión de ver los argumentos de
+            // una llamada que nunca debió llegar a considerarse.
+            //
+            // Se bloquea con `{block, reason}` y no lanzando: el modelo recibe un
+            // resultado de error legible que le dice qué hacer en su lugar, en vez
+            // de una excepción.
+            const decisionAprobacion = await this._registro.antesDeLlamada(toolCall.id, toolCall.name, args, this.settingsManager.getEngineConfig());
+            if (decisionAprobacion.veredicto === "denegada") {
+                return { block: true, reason: decisionAprobacion.motivo };
+            }
+            // Hooks del usuario (`settings.hooks.events.pre_tool_use`). Sale sin
+            // tocar nada si no hay ninguno configurado — ver core/hooks/.
+            const vetoPrevio = await dispararHooks(this.settingsManager.getEngineConfig(), "pre_tool_use", toolCall.name, {
+                sessionId: this.sessionId,
+                cwd: this._cwd,
+                toolName: toolCall.name,
+                toolInput: args,
+            });
+            if (vetoPrevio.bloquea)
+                throw new Error(vetoPrevio.motivo);
             const runner = this._extensionRunner;
             if (!runner.hasHandlers("tool_call")) {
                 return undefined;
@@ -285,6 +370,44 @@ export class AgentSession {
             }
         };
         this.agent.afterToolCall = async ({ toolCall, args, result, isError }) => {
+            // `post_tool_use` es informativo: la herramienta YA corrió, así que su
+            // veredicto no puede vetar nada y solo se dispara para que el hook se
+            // entere. Bloquear aquí daría falsa sensación de control.
+            void dispararHooks(this.settingsManager.getEngineConfig(), "post_tool_use", toolCall.name, {
+                sessionId: this.sessionId,
+                cwd: this._cwd,
+                toolName: toolCall.name,
+                toolInput: args,
+                toolResult: result.content,
+            }).catch(() => { });
+            // Auto-registro del grafo (best-effort, nunca bloquea el agente).
+            try {
+                if (!this._graphSync) {
+                    this._graphSync = new GraphSync({
+                        graph: () => this._resourceLoader.getGraph?.(),
+                        cwd: this._cwd,
+                        activeGoal: () => null, // resuelto en agent_settled vía syncGoal
+                    });
+                }
+                void this._graphSync.onToolResult(toolCall.name, args, result, isError);
+            }
+            catch {
+                // best-effort
+            }
+            // Libro de sesión: qué HIZO el agente, encadenado y verificable.
+            //
+            // Este es el punto por el que pasan TODAS las tools, que es lo que
+            // hace que el registro sea completo por construcción en vez de por
+            // haberse acordado de instrumentar cada una.
+            //
+            // De momento anota la ejecución y, para `bash`, el comando. Los
+            // hashes de fichero antes/después llegan con el observador de
+            // ediciones, que ya tiene que leer las dos versiones: hacerlo aquí
+            // obligaría a leer el fichero por segundo vez.
+            const avisoEdicion = await this._registro.trasLlamada(toolCall.id, toolCall.name, args, isError);
+            if (avisoEdicion !== null && Array.isArray(result.content)) {
+                result.content.push({ type: "text", text: avisoEdicion });
+            }
             const runner = this._extensionRunner;
             const hookResult = runner.hasHandlers("tool_result")
                 ? await runner.emitToolResult({
@@ -350,6 +473,11 @@ export class AgentSession {
             followUp: [...this._followUpMessages],
         });
     }
+    async _emitSessionCompactFailed(event) {
+        if (this._extensionRunner.hasHandlers("session_compact_failed")) {
+            await this._extensionRunner.emit({ type: "session_compact_failed", ...event });
+        }
+    }
     _getIdleWaitPromise() {
         if (!this._idleWaitPromise) {
             this._idleWaitPromise = new Promise((resolve) => {
@@ -372,11 +500,101 @@ export class AgentSession {
         try {
             await this._extensionRunner.emit({ type: "agent_settled" });
             this._emit({ type: "agent_settled" });
+            // El advisor mira cuando el turno se ha ASENTADO.
+            //
+            // Aquí y no en el manejador de eventos por dos motivos, los dos
+            // aprendidos rompiendo cosas: `agent_settled` NO pasa por ese
+            // manejador —su unión de tipos no lo incluye, así que el gancho era
+            // código muerto que ninguna prueba veía—, y `agent_end`, que sí pasa,
+            // salta una vez por INTENTO: meter entonces un mensaje `steer` se cuela
+            // dentro del reintento y convierte uno que acaba bien en uno que acaba
+            // mal (tres pruebas de `agent-session-retry-events`).
+            //
+            // Y es además lo que hay que observar: lo que el agente acabó
+            // haciendo, no cada tentativa.
+            this._mirarConAdvisor();
+            // Ada Intelligence Engine: el GoalEngine es el ÚNICO dueño de la
+            // continuación automática del goal (pi-goal). No compite con retry/
+            // compaction/steer. Fire-and-forget; nunca bloquea ni rompe el chat.
+            try {
+                const goalEngine = this._isSubagentSession ? null : this._resourceLoader.getGoalEngine?.();
+                if (goalEngine) {
+                    void this._maybeContinueGoal(goalEngine);
+                    // Spine del grafo: sync automático del goal activo.
+                    if (this._graphSync) {
+                        void (async () => {
+                            const goals = await goalEngine.list().catch(() => []);
+                            const active = goals.find((g) => g.status === "active");
+                            if (active) {
+                                const full = await goalEngine.get(active.id).catch(() => null);
+                                if (full) {
+                                    await this._graphSync?.syncGoal({
+                                        id: full.id,
+                                        goal: full.goal,
+                                        phase: full.phase,
+                                        tasks: full.tasks ?? [],
+                                        doneCriteria: full.doneCriteria ?? [],
+                                    });
+                                }
+                            }
+                        })();
+                    }
+                }
+            }
+            catch {
+                // best-effort
+            }
         }
         finally {
             this._resolveIdleWaitIfIdle();
         }
     }
+    /**
+     * Confirmación fail-closed del lanzamiento de workflows: emite un evento y
+     * espera respuesta humana hasta 15s; sin respuesta → NO lanzar.
+     */
+    _confirmWorkflowLaunch(prompt) {
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                this._confirmResolvers.delete(prompt);
+                resolve(false);
+            }, 15_000);
+            this._confirmResolvers.set(prompt, (ok) => {
+                clearTimeout(timeout);
+                this._confirmResolvers.delete(prompt);
+                resolve(ok);
+            });
+            this._emit({ type: "notification", message: `[workflow] ${prompt}`, level: "warning" });
+        });
+    }
+    /** Respuesta a una confirmación pendiente (la UI la llama). */
+    resolveWorkflowConfirmation(prompt, ok) {
+        const resolver = this._confirmResolvers.get(prompt);
+        if (!resolver)
+            return false;
+        resolver(ok);
+        return true;
+    }
+    /** Si hay un goal activo aprobado, avanza un turno del bucle. */
+    async _maybeContinueGoal(goalEngine) {
+        const goals = await goalEngine.list().catch(() => []);
+        const active = goals.find((g) => g.status === "active");
+        if (!active)
+            return;
+        // Freno por defecto del engine: si está desactivado no continúa.
+        if (!this.settingsManager.getGoalEngineEnabled())
+            return;
+        // markers anti-duplicados: solo avanzar si no hay un turno ya en curso.
+        if (this._isAgentRunActive)
+            return;
+        this._isAgentRunActive = true;
+        try {
+            await goalEngine.tick(active.id).catch(() => { });
+        }
+        finally {
+            this._isAgentRunActive = false;
+        }
+    }
     // =========================================================================
     // Automatic project memory (claude-mem style)
     // =========================================================================
@@ -488,6 +706,7 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
     // Track last assistant message for auto-compaction check
     _lastAssistantMessage = undefined;
     _lastAutoMemorizeAt = 0;
+    _confirmResolvers = new Map();
     /** Vault expansion redactions by user-message id (frontend + persistence). */
     _vaultRedactions = new Map();
     _userMessageSeq = 0;
@@ -533,6 +752,34 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
                 void memoryEngine.onTurnEnd({ message: event.message });
             }
         }
+        // Libro de sesión: la llamada al modelo.
+        //
+        // Va en `message_end` y no en `agent_end` porque un turno puede gastar
+        // varias llamadas, y "qué modelo se usó y cuánto costó" hay que poder
+        // responderlo por llamada, no por turno.
+        //
+        // Se anotan también las que fallan: `motivoParada: "error"` es
+        // justamente lo que hay que poder enseñar.
+        if (event.type === "message_end" && event.message.role === "assistant") {
+            const asistente = event.message;
+            this._registro.anotarModelo(asistente);
+            // Un turno abortado puede dejar `toolCall` sin su `tool_result`, y un
+            // historial así lo rechazan los proveedores: la conversación entera deja
+            // de poder reanudarse. El bucle del agente ya lo cierra, pero ESE PAQUETE
+            // NO VIAJA en el tarball —se resuelve del registro, con la versión de
+            // upstream—, así que se cierra también aquí, donde sí llega al cliente.
+            // Es idempotente: si el bucle ya lo hizo, no encuentra nada que cerrar.
+            if (asistente.stopReason === "aborted" || asistente.stopReason === "error") {
+                cerrarLlamadasAbiertas(this.agent.state.messages, asistente);
+            }
+            // Un turno VACÍO no es un turno terminado. Sin este aviso el usuario
+            // ve silencio y lo lee como «el modelo decidió no hacer nada»: el
+            // caso real fue `x-preview-f-free` devolviendo respuestas vacías.
+            // El error y el abort NO entran aquí — ya se ven por su vía.
+            if (estadoDelTurno(asistente) === "vacio") {
+                this._emit({ type: "notification", message: mensajeDeTurnoVacio(asistente), level: "warning" });
+            }
+        }
         // Automatic project memory (claude-mem style): after each completed
         // agent turn with real user interaction, distill durable facts into
         // the shared project memory. Fire-and-forget; never blocks the turn.
@@ -922,10 +1169,32 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
         }
         const loaderSystemPrompt = this._resourceLoader.getSystemPrompt();
         const loaderAppendSystemPrompt = this._resourceLoader.getAppendSystemPrompt();
-        const appendSystemPrompt = loaderAppendSystemPrompt.length > 0 ? loaderAppendSystemPrompt.join("\n\n") : undefined;
+        // Ada Intelligence Engine: PERSONALIDAD SIEMPRE presente (sesión principal).
+        // No depende de que el modelo lea la skill: el árbol de decisión y los
+        // procedimientos van inline en el prompt, cada turno.
+        let enginePrompt;
+        if (!this._isSubagentSession &&
+            (this.settingsManager.getGoalEngineEnabled() || this.settingsManager.getWorkflowsEnabled())) {
+            enginePrompt = buildEnginePersonalityBlock();
+        }
+        const appendSystemPrompt = enginePrompt
+            ? [enginePrompt, ...(loaderAppendSystemPrompt.length > 0 ? [loaderAppendSystemPrompt.join("\n\n")] : [])].join("\n\n")
+            : loaderAppendSystemPrompt.length > 0
+                ? loaderAppendSystemPrompt.join("\n\n")
+                : undefined;
         const loadedSkills = this._resourceLoader.getSkills().skills;
         const loadedContextFiles = this._resourceLoader.getAgentsFiles().agentsFiles;
         this._baseSystemPromptOptions = {
+            // Modo plan: el prompt gana la sección que dice que el árbol es de solo
+            // lectura. Se deriva con la MISMA función que usa el guardián
+            // (`RegistroDeSesion.antesDeLlamada` → `decidir({ modo: nivelDesdeConfig(…) })`)
+            // y no leyendo `planOnly` a mano, para que el prompt no pueda decir una
+            // cosa y la política otra el día que `nivelDesdeConfig` cambie de
+            // criterio. Va como primer campo a propósito: así este cambio cae dentro
+            // del hunk de sincronización que ya había justo arriba en vez de abrir
+            // uno nuevo (el presupuesto de fork está a 118/118, medido).
+            modoPlan: nivelDesdeConfig(this.settingsManager.getEngineConfig()) === "plan",
+            toolsDenegadas: leerDenegadas(this.settingsManager.getEngineConfig()),
             cwd: this._cwd,
             skills: loadedSkills,
             contextFiles: loadedContextFiles,
@@ -989,6 +1258,31 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
      * @throws Error if no model selected or no API key available (when not streaming)
      */
     async prompt(text, options) {
+        // Frontera de turno: agrupa las escrituras de este prompt para `undo`, y
+        // dispara el hook `user_prompt_submit`. Las dos cosas necesitan el mismo
+        // momento exacto, así que comparten sitio.
+        abrirTurno(this._resourceLoader.getAgentDir(), this._cwd, Date.now());
+        void dispararHooks(this.settingsManager.getEngineConfig(), "user_prompt_submit", "user_prompt_submit", {
+            sessionId: this.sessionId,
+            cwd: this._cwd,
+            prompt: text,
+        }).catch(() => { });
+        // Presupuesto de razonamiento por dificultad del turno. Aquí y no más
+        // abajo porque tiene que decidirse ANTES de construir la petición, y con
+        // el texto tal cual lo escribió el usuario. No llama al modelo.
+        // Solo fuera de streaming: un mensaje de dirección corto («no, para»)
+        // no debe bajar el presupuesto de la tarea larga que ya está en marcha.
+        if (!this.isStreaming) {
+            ajustarPresupuestoDeRazonamiento(this, text, {
+                nivelActual: this.thinkingLevel,
+                disponibles: this.getAvailableThinkingLevels(),
+                fijar: (nivel) => {
+                    this.setThinkingLevel(nivel);
+                    return this.thinkingLevel;
+                },
+                avisar: (mensaje) => this._emit({ type: "notification", message: mensaje, level: "info" }),
+            });
+        }
         const expandPromptTemplates = options?.expandPromptTemplates ?? true;
         const preflightResult = options?.preflightResult;
         let messages;
@@ -1382,13 +1676,135 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
             if (images.length === 0)
                 images = undefined;
         }
-        await this.prompt(text, {
+        // ── Optimizador autónomo de prompt ───────────────────────────────────
+        // Mejora la petición del usuario (claridad, contexto, formato, criterios,
+        // alcance) ANTES de que llegue al modelo. Fail-open: cualquier error o
+        // timeout usa el prompt original — nunca degrada la experiencia.
+        let finalText = text;
+        if (this._promptOptimizerMode !== "off" && typeof text === "string" && !text.startsWith("/")) {
+            try {
+                const result = await this._runPromptOptimizer(text);
+                if (result) {
+                    if (result.decision === "clarify" && this._promptOptimizerMode === "clarify") {
+                        // Preguntar primero y esperar respuesta; no enviamos aún.
+                        this._pendingClarification = { original: text, questions: result.questions };
+                        this._emit({
+                            type: "prompt_optimization",
+                            decision: "clarify",
+                            original: text,
+                            questions: result.questions,
+                            summary: result.summary,
+                        });
+                        const questions = result.questions.map((q, i) => `${i + 1}. ${q}`).join("\n");
+                        await this.sendCustomMessage({
+                            customType: "clarify-questions",
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `🔎 Para dejar tu petición sin huecos, necesito aclarar:\n${questions}\n\nResponde a las preguntas y continuaré.`,
+                                },
+                            ],
+                            display: true,
+                            details: { q: result.questions },
+                        }, { triggerTurn: false });
+                        return;
+                    }
+                    if (result.enhanced && result.enhanced !== text) {
+                        finalText = result.enhanced;
+                        this._emit({
+                            type: "prompt_optimization",
+                            decision: "enhance",
+                            original: text,
+                            enhanced: result.enhanced,
+                            summary: result.summary,
+                        });
+                        // Mensaje persistente en el chat (CLI + desktop): muestra el
+                        // antes → después para que el usuario vea la mejora.
+                        void this.sendCustomMessage({
+                            customType: "prompt-optimization",
+                            content: [{ type: "text", text: result.enhanced }],
+                            display: true,
+                            details: { original: text, summary: result.summary },
+                        }, { triggerTurn: false });
+                    }
+                }
+            }
+            catch {
+                // fail-open: continuamos con el prompt original
+            }
+        }
+        await this.prompt(finalText, {
             expandPromptTemplates: options?.expandPromptTemplates ?? false,
             streamingBehavior: options?.deliverAs,
             images,
             source: "extension",
         });
     }
+    /**
+     * Ejecuta el optimizador con el modelo de la sesión. Timeout de 12s,
+     * nunca lanza (devuelve undefined → fail-open).
+     */
+    async _runPromptOptimizer(text) {
+        const model = this.model;
+        if (!model)
+            return undefined;
+        try {
+            const answers = this._pendingClarification?.answers;
+            const result = await Promise.race([
+                optimizeUserPrompt({
+                    text,
+                    // En modo auto nunca bloqueamos al usuario: si el LLM pide
+                    // clarificar, forzamos una mejora con supuestos razonables.
+                    forceEnhance: this._promptOptimizerMode === "auto",
+                    context: {
+                        projectDir: this._cwd,
+                        // Si el usuario ya respondió a las preguntas de la ronda
+                        // anterior, se las pasamos al optimizador como contexto.
+                        recentMessages: answers?.length
+                            ? [...answers, ...(this._recentUserPrompts(3) ?? [])]
+                            : this._recentUserPrompts(3),
+                    },
+                }, async (systemPrompt, userContent) => {
+                    const completed = await this._modelRuntime.completeSimple(model, {
+                        systemPrompt,
+                        messages: [{ role: "user", content: userContent }],
+                        signal: AbortSignal.timeout(20_000),
+                    });
+                    return contentText(completed.content, "").trim();
+                }),
+                new Promise((resolve) => setTimeout(() => resolve(undefined), 25_000)),
+            ]);
+            if (!result)
+                return undefined;
+            this._pendingClarification = undefined;
+            return result;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Últimos prompts de usuario (para dar contexto al optimizador). */
+    _recentUserPrompts(max) {
+        const out = [];
+        const messages = this.agent.state.messages;
+        for (let i = messages.length - 1; i >= 0 && out.length < max; i--) {
+            const m = messages[i];
+            if (m.role === "user") {
+                const t = contentText(m.content, "");
+                if (t.trim())
+                    out.unshift(t.slice(0, 500));
+            }
+        }
+        return out;
+    }
+    /** Ajusta el modo del optimizador autónomo de prompts. */
+    setPromptOptimizerMode(mode) {
+        this._promptOptimizerMode = mode;
+    }
+    /** Modo actual del optimizador autónomo de prompts. */
+    getPromptOptimizerMode() {
+        return this._promptOptimizerMode;
+    }
     /**
      * Clear all queued messages and return them.
      * Useful for restoring to editor when user aborts.
@@ -1447,19 +1863,24 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
     }
     /**
      * Set model directly.
-     * Validates that auth is configured, saves to session and settings.
+     * Validates that auth is configured and saves to the session transcript.
+     * Persists to global defaults only when options.persist is true.
      * @throws Error if no auth is configured for the model
      */
-    async setModel(model) {
+    async setModel(model, options = {}) {
         if (!(await this._modelRuntime.checkAuth(model.provider))) {
             throw new Error(`No API key for ${model.provider}/${model.id}`);
         }
         const previousModel = this.model;
-        const thinkingLevel = this._getThinkingLevelForModelSwitch();
+        const thinkingLevel = this._getThinkingLevelForModelSwitch(model);
         this.agent.state.model = model;
         this.sessionManager.appendModelChange(model.provider, model.id);
-        this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
-        // Re-clamp thinking level for new model's capabilities
+        if (options.persist) {
+            this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+        }
+        // Apply thinking level for the new model.
+        // Per-model thinking level overrides take priority over the global default.
+        // Model persistence does not implicitly rewrite the global thinking default.
         this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(model, previousModel, "set");
     }
@@ -1469,13 +1890,13 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
      * @param direction - "forward" (default) or "backward"
      * @returns The new model info, or undefined if only one model available
      */
-    async cycleModel(direction = "forward") {
+    async cycleModel(direction = "forward", options = {}) {
         if (this._scopedModels.length > 0) {
-            return this._cycleScopedModel(direction);
+            return this._cycleScopedModel(direction, options);
         }
-        return this._cycleAvailableModel(direction);
+        return this._cycleAvailableModel(direction, options);
     }
-    async _cycleScopedModel(direction) {
+    async _cycleScopedModel(direction, options) {
         const availableIds = new Set(this._modelRuntime.getAvailableSnapshot().map((model) => `${model.provider}\0${model.id}`));
         const scopedModels = this._scopedModels.filter((scoped) => availableIds.has(`${scoped.model.provider}\0${scoped.model.id}`));
         if (scopedModels.length <= 1)
@@ -1487,20 +1908,23 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
         const len = scopedModels.length;
         const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
         const next = scopedModels[nextIndex];
-        const thinkingLevel = this._getThinkingLevelForModelSwitch(next.thinkingLevel);
+        const thinkingLevel = this._getThinkingLevelForModelSwitch(next.model, next.thinkingLevel);
         // Apply model
         this.agent.state.model = next.model;
         this.sessionManager.appendModelChange(next.model.provider, next.model.id);
-        this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
-        // Apply thinking level.
-        // - Explicit scoped model thinking level overrides current session level
-        // - Undefined scoped model thinking level inherits the current session preference
+        if (options.persist) {
+            this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
+        }
+        // Apply thinking level for the new model.
+        // - Explicit scoped model thinking level overrides defaults
+        // - Per-model thinking level overrides take priority over the global default
         // setThinkingLevel clamps to model capabilities.
+        // Model persistence does not implicitly rewrite the global thinking default.
         this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(next.model, currentModel, "cycle");
         return { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
     }
-    async _cycleAvailableModel(direction) {
+    async _cycleAvailableModel(direction, options) {
         const availableModels = this._modelRuntime.getAvailableSnapshot();
         if (availableModels.length <= 1)
             return undefined;
@@ -1511,11 +1935,14 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
         const len = availableModels.length;
         const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
         const nextModel = availableModels[nextIndex];
-        const thinkingLevel = this._getThinkingLevelForModelSwitch();
+        const thinkingLevel = this._getThinkingLevelForModelSwitch(nextModel);
         this.agent.state.model = nextModel;
         this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
-        this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
-        // Re-clamp thinking level for new model's capabilities
+        if (options.persist) {
+            this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
+        }
+        // Apply thinking level for the new model.
+        // Model persistence does not implicitly rewrite the global thinking default.
         this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(nextModel, currentModel, "cycle");
         return { model: nextModel, thinkingLevel: this.thinkingLevel, isScoped: false };
@@ -1526,20 +1953,21 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
     /**
      * Set thinking level.
      * Clamps to model capabilities based on available thinking levels.
-     * Saves to session and settings only if the level actually changes.
+     * Saves the clamped level to the session transcript only if the level actually changes.
+     * Persists the requested level to global defaults only when options.persist is true.
      */
-    setThinkingLevel(level) {
+    setThinkingLevel(level, options = {}) {
         const availableLevels = this.getAvailableThinkingLevels();
         const effectiveLevel = availableLevels.includes(level) ? level : this._clampThinkingLevel(level, availableLevels);
         // Only persist if actually changing
         const previousLevel = this.agent.state.thinkingLevel;
         const isChanging = effectiveLevel !== previousLevel;
         this.agent.state.thinkingLevel = effectiveLevel;
+        if (options.persist) {
+            this.settingsManager.setDefaultThinkingLevel(level);
+        }
         if (isChanging) {
             this.sessionManager.appendThinkingLevelChange(effectiveLevel);
-            if (this.supportsThinking() || effectiveLevel !== "off") {
-                this.settingsManager.setDefaultThinkingLevel(effectiveLevel);
-            }
             this._emit({ type: "thinking_level_changed", level: effectiveLevel });
             void this._extensionRunner.emit({
                 type: "thinking_level_select",
@@ -1552,14 +1980,14 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
      * Cycle to next thinking level.
      * @returns New level, or undefined if model doesn't support thinking
      */
-    cycleThinkingLevel() {
+    cycleThinkingLevel(options = {}) {
         if (!this.supportsThinking())
             return undefined;
         const levels = this.getAvailableThinkingLevels();
         const currentIndex = levels.indexOf(this.thinkingLevel);
         const nextIndex = (currentIndex + 1) % levels.length;
         const nextLevel = levels[nextIndex];
-        this.setThinkingLevel(nextLevel);
+        this.setThinkingLevel(nextLevel, options);
         return nextLevel;
     }
     /**
@@ -1568,7 +1996,7 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
      */
     getAvailableThinkingLevels() {
         if (!this.model)
-            return THINKING_LEVELS;
+            return [...THINKING_LEVEL_OPTIONS];
         return getSupportedThinkingLevels(this.model);
     }
     /**
@@ -1577,14 +2005,18 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
     supportsThinking() {
         return !!this.model?.reasoning;
     }
-    _getThinkingLevelForModelSwitch(explicitLevel) {
+    _getThinkingLevelForModelSwitch(targetModel, explicitLevel) {
         if (explicitLevel !== undefined) {
             return explicitLevel;
         }
-        if (!this.supportsThinking()) {
-            return this.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+        // Per-model default takes priority when switching to a model that has one
+        if (targetModel) {
+            const perModel = this.settingsManager.getModelThinkingLevel(targetModel.provider, targetModel.id);
+            if (perModel !== undefined) {
+                return perModel;
+            }
         }
-        return this.thinkingLevel;
+        return this.settingsManager.getDefaultThinkingLevel() ?? this.thinkingLevel ?? DEFAULT_THINKING_LEVEL;
     }
     _clampThinkingLevel(level, _availableLevels) {
         return this.model ? clampThinkingLevel(this.model, level) : "off";
@@ -1615,15 +2047,36 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
     // =========================================================================
     // Compaction
     // =========================================================================
+    /** Generate Pi's built-in compaction summary for manual and automatic compaction. */
+    async _runDefaultCompaction(preparation, requestModel, apiKey, headers, customInstructions, signal, env, reason) {
+        // Ada: al resumen en prosa se le añade un REGISTRO DENSO de hechos
+        // (rutas, comandos, errores) extraídos literalmente de los turnos. Este
+        // es el ÚNICO punto por el que pasan las dos compactaciones de pi (la
+        // manual de `/compact`, RPC y extensiones, y la automática por
+        // umbral/desbordamiento), así que un solo hunk cubre la ruta entera.
+        // Ver core/compactar/ para el porqué de sumar en vez de sustituir.
+        return anadirRegistroDenso(await compact(preparation, requestModel, apiKey, headers, customInstructions, signal, this.thinkingLevel, this.agent.streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }), undefined), preparation);
+    }
     /**
      * Manually compact the session context.
-     * Aborts current agent operation first.
+     *
+     * This is the manual entry point used by `/compact`, RPC, and extensions. It is
+     * separate from automatic threshold/overflow compaction, which enters through
+     * `_checkCompaction()` and `_runAutoCompaction()`. After preparation and the
+     * `session_before_compact` hook, both paths call the lower-level `compact()`
+     * function imported from `./compaction/index.ts`, unless the hook cancels or
+     * supplies a custom result.
+     *
+     * Aborts the current agent operation first. Manual compaction never retries or
+     * continues the interrupted agent turn.
+     *
      * @param customInstructions Optional instructions for the compaction summary
      */
     async compact(customInstructions) {
         await this.abort();
         this._compactionAbortController = new AbortController();
         this._emit({ type: "compaction_start", reason: "manual" });
+        let fromExtension = false;
         try {
             if (!this.model) {
                 throw new Error(formatNoModelSelectedMessage());
@@ -1641,7 +2094,6 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
                 throw new Error("Nothing to compact (session too small)");
             }
             let extensionCompaction;
-            let fromExtension = false;
             if (this._extensionRunner.hasHandlers("session_before_compact")) {
                 const result = (await this._extensionRunner.emit({
                     type: "session_before_compact",
@@ -1674,8 +2126,8 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
                 details = extensionCompaction.details;
             }
             else {
-                // Generate compaction result
-                const result = await compact(preparation, requestModel, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel, this.agent.streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason: "manual" }));
+                // Shared default summary generator, also used by automatic compaction.
+                const result = await this._runDefaultCompaction(preparation, requestModel, apiKey, headers, customInstructions, this._compactionAbortController.signal, env, "manual");
                 summary = result.summary;
                 firstKeptEntryId = result.firstKeptEntryId;
                 tokensBefore = result.tokensBefore;
@@ -1723,6 +2175,7 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+            const errorMessage = aborted ? undefined : `Compaction failed: ${message}`;
             this._compactionAbortController = undefined;
             this._emit({
                 type: "compaction_end",
@@ -1730,7 +2183,14 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
                 result: undefined,
                 aborted,
                 willRetry: false,
-                errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
+                errorMessage,
+            });
+            await this._emitSessionCompactFailed({
+                reason: "manual",
+                errorMessage,
+                aborted,
+                willRetry: false,
+                fromExtension,
             });
             throw error;
         }
@@ -1752,16 +2212,25 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
         this._branchSummaryAbortController?.abort();
     }
     /**
-     * Check if compaction is needed and run it.
-     * Called after agent_end and before prompt submission.
+     * Dispatch automatic compaction after `agent_end` or before prompt submission.
+     * Manual compaction does not call this method; it enters through `compact()`.
+     *
+     * Automatic cases:
+     * 1. Overflow with retry: a context-overflow error or recoverable length stop;
+     *    remove the failed assistant message, compact, and retry the turn once.
+     * 2. Overflow without retry: a successful response exceeded the configured
+     *    context window; compact but preserve the completed response.
+     * 3. Threshold without retry: valid or estimated context usage crossed the
+     *    configured threshold; compact without retrying the completed response.
      *
-     * Two cases:
-     * 1. Recoverable failure: LLM returned context overflow or stopped below its desired output limit;
-     *    remove the assistant message, compact, and auto-retry once
-     * 2. Threshold: Context over threshold, compact, NO auto-retry (user continues manually)
+     * Each case calls `_runAutoCompaction()`. After preparation and the
+     * `session_before_compact` hook, that method calls the lower-level `compact()`
+     * function imported from `./compaction/index.ts`, unless the hook cancels or
+     * supplies a custom result.
      *
      * @param assistantMessage The assistant message to check
      * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
+     * @returns Whether the post-run loop should call `agent.continue()` for overflow recovery or queued messages
      */
     async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
         const settings = this.settingsManager.getCompactionSettings();
@@ -1784,38 +2253,49 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
         if (assistantIsFromBeforeCompaction) {
             return false;
         }
-        // Case 1: Recoverable failure. Explicit/silent context overflow still uses context metadata.
+        // Automatic cases 1 and 2: context overflow.
         // A length stop is recoverable when output ended below the model's original desired limit,
         // independent of the configured context size or any context-clamped provider request limit.
-        // A successful response over the configured window should compact but must not retry: the
-        // assistant answer already completed and agent.continue() cannot continue from an assistant.
+        const contextOverflow = sameModel && isContextOverflow(assistantMessage, contextWindow);
         const recoverableLength = sameModel && isRecoverableLength(assistantMessage, this.model?.maxTokens ?? 0);
-        if (sameModel && (isContextOverflow(assistantMessage, contextWindow) || recoverableLength)) {
+        if (contextOverflow || recoverableLength) {
             const willRetry = assistantMessage.stopReason !== "stop";
+            // Case 2: the response completed successfully. Compact, but do not retry because
+            // agent.continue() cannot continue from a completed assistant response.
             if (!willRetry) {
                 return await this._runAutoCompaction("overflow", false);
             }
             if (this._overflowRecoveryAttempted) {
+                const errorMessage = contextOverflow
+                    ? "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model."
+                    : "Truncated response recovery failed after one compact-and-retry attempt.";
                 this._emit({
                     type: "compaction_end",
                     reason: "overflow",
                     result: undefined,
                     aborted: false,
                     willRetry: false,
-                    errorMessage: "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.",
+                    errorMessage,
+                });
+                await this._emitSessionCompactFailed({
+                    reason: "overflow",
+                    errorMessage,
+                    aborted: false,
+                    willRetry: false,
+                    fromExtension: false,
                 });
                 return false;
             }
+            // Case 1: remove the failed or truncated message from agent state, compact, and
+            // retry once. The message remains in session history but is excluded from retry context.
             this._overflowRecoveryAttempted = true;
-            // Remove the failed or truncated message from agent state. It remains in session history,
-            // but must not be included in the compact-and-retry context.
             const messages = this.agent.state.messages;
             if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
                 this.agent.state.messages = messages.slice(0, -1);
             }
             return await this._runAutoCompaction("overflow", willRetry);
         }
-        // Case 2: Threshold - context is getting large
+        // Case 3: threshold compaction without retry.
         // For error messages or all-zero usage messages, estimate from the last valid response.
         // This ensures sessions that hit persistent API errors (e.g. 529) or malformed zero-usage
         // responses can still compact and do not reset context accounting.
@@ -1824,16 +2304,18 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
         if (assistantMessage.stopReason === "error" || directContextTokens === 0) {
             const messages = this.agent.state.messages;
             const estimate = estimateContextTokens(messages);
-            if (estimate.lastUsageIndex === null)
-                return false; // No usage data at all
-            // Verify the usage source is post-compaction. Kept pre-compaction messages
-            // have stale usage reflecting the old (larger) context and would falsely
-            // trigger compaction right after one just finished.
-            const usageMsg = messages[estimate.lastUsageIndex];
-            if (compactionEntry &&
-                usageMsg.role === "assistant" &&
-                usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
-                return false;
+            // Without provider usage, estimate.tokens is the pure message-size estimate.
+            // Only usage-backed estimates need the stale pre-compaction check.
+            if (estimate.lastUsageIndex !== null) {
+                // Verify the usage source is post-compaction. Kept pre-compaction messages
+                // have stale usage reflecting the old (larger) context and would falsely
+                // trigger compaction right after one just finished.
+                const usageMsg = messages[estimate.lastUsageIndex];
+                if (compactionEntry &&
+                    usageMsg.role === "assistant" &&
+                    usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
+                    return false;
+                }
             }
             contextTokens = estimate.tokens;
         }
@@ -1846,11 +2328,19 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
         return false;
     }
     /**
-     * Internal: Run auto-compaction with events.
+     * Execute threshold or overflow compaction. Manual compaction uses
+     * `AgentSession.compact()` instead. Both paths call the lower-level `compact()`
+     * function imported from `./compaction/index.ts` after preparation and extension
+     * interception.
+     *
+     * @param reason Automatic trigger selected by `_checkCompaction()`
+     * @param willRetry Whether to continue the interrupted turn after overflow compaction
+     * @returns Whether the post-run loop should call `agent.continue()`
      */
     async _runAutoCompaction(reason, willRetry) {
         const settings = this.settingsManager.getCompactionSettings();
         let started = false;
+        let fromExtension = false;
         try {
             if (!this.model) {
                 return false;
@@ -1865,7 +2355,6 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
             this._autoCompactionAbortController = new AbortController();
             started = true;
             let extensionCompaction;
-            let fromExtension = false;
             if (this._extensionRunner.hasHandlers("session_before_compact")) {
                 const extensionResult = (await this._extensionRunner.emit({
                     type: "session_before_compact",
@@ -1884,6 +2373,12 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
                         aborted: true,
                         willRetry: false,
                     });
+                    await this._emitSessionCompactFailed({
+                        reason,
+                        aborted: true,
+                        willRetry: false,
+                        fromExtension: false,
+                    });
                     return false;
                 }
                 if (extensionResult?.compaction) {
@@ -1905,8 +2400,8 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
                 details = extensionCompaction.details;
             }
             else {
-                // Generate compaction result
-                const compactResult = await compact(preparation, requestModel, apiKey, headers, undefined, this._autoCompactionAbortController.signal, this.thinkingLevel, this.agent.streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }));
+                // Shared default summary generator, also used by manual compaction.
+                const compactResult = await this._runDefaultCompaction(preparation, requestModel, apiKey, headers, undefined, this._autoCompactionAbortController.signal, env, reason);
                 summary = compactResult.summary;
                 firstKeptEntryId = compactResult.firstKeptEntryId;
                 tokensBefore = compactResult.tokensBefore;
@@ -1921,6 +2416,12 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
                     aborted: true,
                     willRetry: false,
                 });
+                await this._emitSessionCompactFailed({
+                    reason,
+                    aborted: true,
+                    willRetry: false,
+                    fromExtension,
+                });
                 return false;
             }
             this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension, usage);
@@ -1967,15 +2468,23 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
             if (started) {
+                const formattedErrorMessage = reason === "overflow"
+                    ? `Context overflow recovery failed: ${errorMessage}`
+                    : `Auto-compaction failed: ${errorMessage}`;
                 this._emit({
                     type: "compaction_end",
                     reason,
                     result: undefined,
                     aborted: false,
                     willRetry: false,
-                    errorMessage: reason === "overflow"
-                        ? `Context overflow recovery failed: ${errorMessage}`
-                        : `Auto-compaction failed: ${errorMessage}`,
+                    errorMessage: formattedErrorMessage,
+                });
+                await this._emitSessionCompactFailed({
+                    reason,
+                    errorMessage: formattedErrorMessage,
+                    aborted: false,
+                    willRetry: false,
+                    fromExtension,
                 });
             }
             return false;
@@ -2268,6 +2777,74 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
                 }
             }
         }
+        // Lo que el PROMPT promete tiene que estar ACTIVO, no solo registrado.
+        //
+        // `sdk.ts` pasa una lista explícita de cuatro tools (read, bash, edit,
+        // write), y eso apaga la rama de arriba que activaría lo recién
+        // registrado. Consecuencia medida: 29 tools construidas e invisibles para
+        // el modelo, mientras el prompt le ordenaba usar cinco de ellas —
+        // "usa la tool goal_new", "Use memory_search when…", "→ browser_*". El
+        // agente las pedía, recibía un error opaco, y desde fuera parecía que "no
+        // usa las funciones".
+        //
+        // Se activa POR PREFIJO y no con una lista de nombres a propósito: una
+        // lista se desincroniza en cuanto alguien añade una tool a una familia, y
+        // esa desincronización silenciosa es justo el defecto que esto arregla.
+        // `_toolRegistry` ya viene filtrado por `isAllowedTool`, así que quien
+        // restrinja tools con `options.tools` sigue mandando.
+        //
+        // `find`, `grep` y `ls` se quedan FUERA deliberadamente: el prompt dice
+        // "usa bash para operaciones de ficheros (ls, grep, find)", así que sus
+        // tools serían un segundo camino para lo mismo — el problema de elección
+        // que ya nos costó trabajo con computer_* y browser_*.
+        // PERO solo cuando nadie ha elegido. Esto es un DEFECTO, no un override:
+        // si el usuario configuró `defaultTools`, o el llamante pasó `tools` o
+        // `noTools`, esa decisión manda y aquí no se toca nada. La primera versión
+        // de este bloque no lo distinguía y rompía cuatro contratos ya probados,
+        // entre ellos "defaultTools se respeta tal cual".
+        //
+        // La señal de "nadie ha elegido" es que la lista entrante sea exactamente
+        // el núcleo que `sdk.ts` usa como valor por defecto. Cualquier otra cosa
+        // —una lista propia, `noTools`, o una selección ya expandida— significa
+        // que alguien decidió, y se respeta.
+        //
+        // Solo hace falta en la PRIMERA construcción: en refrescos posteriores, la
+        // rama de arriba ya activa lo que se acabe de registrar, así que encender
+        // una capacidad en caliente sigue funcionando.
+        const nucleoPorDefecto = ["read", "bash", "edit", "write"].filter(isAllowedTool);
+        const entrante = options?.activeToolNames ?? previousActiveToolNames;
+        const nadieHaElegido = this._allowedToolNames === undefined &&
+            this.settingsManager.getDefaultTools() === undefined &&
+            entrante.length === nucleoPorDefecto.length &&
+            nucleoPorDefecto.every((nombre) => entrante.includes(nombre));
+        const cfg = this.settingsManager.getEngineConfig();
+        const capacidades = [
+            // Sin condición: el prompt las ordena siempre.
+            { prefijo: "memory_", disponible: true },
+            { prefijo: "session_search", disponible: true },
+            { prefijo: "web_", disponible: true },
+            { prefijo: "ast_", disponible: true },
+            { prefijo: "update_project_memory", disponible: true },
+            { prefijo: "scratchpad", disponible: true },
+            { prefijo: "todo", disponible: true },
+            // Preguntar en vez de adivinar: sin esto el modelo solo puede suponer.
+            { prefijo: "ask_user_question", disponible: true },
+            // Con condición: cada una tiene su interruptor y su panel.
+            { prefijo: "browser_", disponible: cfg.computerUse.browser },
+            { prefijo: "computer_", disponible: cfg.computerUse.enabled },
+            { prefijo: "goal_", disponible: cfg.goalEngine.enabled },
+            { prefijo: "workflow", disponible: cfg.workflows.enabled },
+            { prefijo: "graph_", disponible: cfg.graph.enabled },
+            { prefijo: "bash_", disponible: true },
+        ];
+        for (const { prefijo, disponible } of nadieHaElegido ? capacidades : []) {
+            if (!disponible)
+                continue;
+            for (const nombre of this._toolRegistry.keys()) {
+                if (nombre.startsWith(prefijo))
+                    nextActiveToolNames.push(nombre);
+            }
+        }
         this.setActiveToolsByName([...new Set(nextActiveToolNames)]);
     }
     _buildRuntime(options) {
@@ -2290,13 +2867,164 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
         }
         // Ada Memory Engine tools (memory_add/replace/remove/search,
         // session_search, scratchpad, memory_status). Exposed when enabled.
+        // Solo en la sesión principal: un subagente no debe poder mutar la
+        // memoria durable del usuario (anti-recursión, igual que goal_* y
+        // workflow abajo). Hasta ahora la propiedad se sostenía solo por la
+        // allowlist de tools del call site, no por una guardia aquí.
         const memoryEngine = this._resourceLoader.getMemoryEngine();
-        if (memoryEngine && this.settingsManager.getProjectMemoryEnabled()) {
+        if (memoryEngine && !this._isSubagentSession && this.settingsManager.getProjectMemoryEnabled()) {
             const engineTools = createMemoryEngineTools(memoryEngine);
             for (const [name, tool] of Object.entries(engineTools)) {
                 this._baseToolDefinitions.set(name, tool);
             }
         }
+        // URLs internas de `read`: memory://, vault://, rule://, audit:// — un
+        // solo `read` en vez de veinte tools (ver core/urls-internas/lector.ts).
+        // `read.ts` es de upstream y el presupuesto de sync está al tope, así que
+        // esto envuelve la definición ya construida en vez de tocar ese fichero.
+        //
+        // memory:// nunca se pasa a un subagente: es la misma anti-recursión que
+        // bloquea memory_* dos bloques más arriba. Sin esto, `read` (que SÍ está
+        // en la allowlist por defecto de todo subagente) sería una puerta trasera
+        // a la memoria durable que ese bloque ya decidió cerrar.
+        const readBase = this._baseToolDefinitions.get("read");
+        if (readBase) {
+            this._baseToolDefinitions.set("read", envolverReadConUrlsInternas(envolverReadConPdf(readBase, this._cwd), {
+                memoryEngine: this._isSubagentSession ? null : memoryEngine,
+                vaultManager: this._resourceLoader.getVaultManager?.() ?? null,
+                cwd: this._cwd,
+                libro: () => this._registro.libro(),
+            }));
+        }
+        // Tools MCP: EXACTAMENTE DOS (mcp_list_tools, mcp_call_tool), nunca una por
+        // herramienta remota — un servidor con 40 tools inflaría el system prompt y
+        // desplazaría el prefijo cacheable. Solo sesión principal: un subagente no
+        // debe poder alcanzar el Jira de la empresa.
+        const mcpManager = this._isSubagentSession ? null : this._resourceLoader.getMcpManager?.();
+        if (mcpManager) {
+            for (const [name, tool] of Object.entries(createMcpTools(mcpManager))) {
+                this._baseToolDefinitions.set(name, tool);
+            }
+        }
+        // El registro de salidas se publica ANTES de crear las tools web, para que
+        // también lo vean los caminos que no nacen aquí — hoy el cliente MCP, que
+        // crea `resource-loader` y no tiene el libro a mano. Sin esto, el informe
+        // para el DPO afirmaba «No hubo transferencias» sobre una sesión que había
+        // hablado con un servidor de terceros. Ver `core/web/registro-red.ts`.
+        publicarAnotarRed((dominio, permitido, motivo) => {
+            void this._registro.libro().anotar({ tipo: "red", dominio, permitido, motivo });
+        });
+        // Tools web. SÍ se registran en subagentes: `deep_research` delega la
+        // búsqueda en ellos, y sin esto ese workflow pedía tools inexistentes.
+        // El acceso no queda abierto: la allowlist del subagente solo las incluye
+        // cuando el script pide `web: true` (ver workflows/agent-runner.ts).
+        for (const [name, tool] of Object.entries(createWebTools({
+            // Vault primero; si está bloqueado o no trae el proveedor cae a la
+            // variable de entorno, que es lo que usa CI. Un `nombreProveedor` por
+            // llamada porque el registro prueba varios (brave, tavily, exa,
+            // searxng, serper), no solo Serper.
+            obtenerClave: crearObtenerClave(() => this._resourceLoader.getVaultManager?.()),
+            // Libro de sesión: qué salió de la máquina y hacia dónde (art. 44 RGPD).
+            // Solo el dominio; la ruta y la query pueden llevar tokens.
+            // Se publica ademas para los caminos de salida que NO nacen aqui: el
+            // cliente MCP lo crea `resource-loader`, que no tiene el libro a mano.
+            // Ver `core/web/registro-red.ts`.
+            anotarRed: (dominio, permitido, motivo) => {
+                void this._registro.libro().anotar({ tipo: "red", dominio, permitido, motivo });
+            },
+            // Búsqueda con la credencial del modelo cuando el proveedor la trae.
+            // Es lo que hace que `web_search` funcione sin configurar nada.
+            buscarNativo: async (consulta, maximo) => {
+                const modelo = this.model;
+                // `null`, no `[]`: no es lo mismo no poder buscar que no encontrar.
+                if (!modelo || !soportaBusquedaNativa(modelo.provider))
+                    return null;
+                return buscarConElModelo(consulta, {
+                    maxResultados: maximo,
+                    completar: async (texto, opciones) => {
+                        await this._modelRuntime.completeSimple(modelo, {
+                            systemPrompt: "Busca en la web lo que te pidan. Responde en una línea.",
+                            messages: [{ role: "user", content: texto }],
+                        }, opciones);
+                    },
+                });
+            },
+        }))) {
+            this._baseToolDefinitions.set(name, tool);
+        }
+        // Búsqueda y edición estructural (`ast_search`/`ast_edit`). Sin condición,
+        // como las tools web: no dependen de ningún subsistema externo, solo del
+        // compilador de TypeScript que ya está en el bundle. Se registran también
+        // en subagentes: un subagente de refactor necesita la misma precisión.
+        for (const [name, tool] of Object.entries(crearEstructuralTools(this._cwd))) {
+            this._baseToolDefinitions.set(name, tool);
+        }
+        // Tools de navegador. Detrás de `computerUse.enabled`, que hasta ahora era
+        // otro bloque de configuración con panel en el escritorio y nada detrás.
+        // Registrarlas no arranca Chrome: el navegador se abre en la primera tool
+        // que lo necesita. Para subagentes, además hay que pedir `browser: true`.
+        // El navegador NO depende del control del ordenador, y antes sí: se pedía
+        // `computerUse.enabled && computerUse.browser`. Eso dejaba la capacidad más
+        // segura que tenemos —un Chrome con perfil vacío, sin sesiones iniciadas—
+        // detrás del interruptor de la más peligrosa, que viene apagado. Resultado:
+        // en una instalación recién hecha las tools de navegador ni siquiera se
+        // registraban, y la regla del prompt "interactuar con una web → browser_*"
+        // apuntaba al vacío.
+        // La clave sigue viviendo bajo `computerUse` por compatibilidad con las
+        // configuraciones que ya existen; lo que cambia es de qué depende.
+        const configMotor = this.settingsManager.getEngineConfig();
+        if (configMotor.computerUse.browser) {
+            for (const [name, tool] of Object.entries(crearBrowserTools({
+                agentDir: this._resourceLoader.getAgentDir(),
+                // Para que la regla de elección solo nombre lo que existe.
+                ordenador: configMotor.computerUse.enabled,
+            }))) {
+                this._baseToolDefinitions.set(name, tool);
+            }
+        }
+        // Control del ordenador. El motor es nuestro fork, y corre EN PROCESO: no
+        // hay servidor MCP que registrar. El agente habla con NUESTRAS tools, que
+        // aplican el techo por categoría y las prohibiciones antes de mover nada.
+        // Es un interruptor, sin lista de aplicaciones que mantener: lo que
+        // limita cada aplicación es su categoría, y se calcula sola.
+        if (configMotor.computerUse.enabled) {
+            for (const [name, tool] of Object.entries(crearComputerTools({ navegador: configMotor.computerUse.browser }))) {
+                this._baseToolDefinitions.set(name, tool);
+            }
+        }
+        // Bash interactivo (bash_interactivo/bash_enviar/bash_cerrar). Sin
+        // interruptor de settings a propósito: es la misma categoría de riesgo
+        // que `bash` —pasa por la misma política de aprobación como `ejecucion`—
+        // y ocultarla detrás de una opción solo dejaría al agente sin forma de
+        // responder a un `sudo` o a un `rm -i` en las instalaciones por defecto.
+        for (const [name, tool] of Object.entries(crearInteractivoTools({ cwd: this._cwd }))) {
+            this._baseToolDefinitions.set(name, tool);
+        }
+        // Ada Intelligence Engine: tools del GoalEngine (resuelven el goal
+        // activo por llamada). Registradas si el GoalEngine está habilitado.
+        // Los subagentes NO reciben goal_*/workflow tools: solo el agente
+        // principal orquesta el engine (anti-recursión y control de presupuesto).
+        const goalEngine = this._isSubagentSession ? null : this._resourceLoader.getGoalEngine?.();
+        if (goalEngine && this.settingsManager.getGoalEngineEnabled()) {
+            for (const tool of goalSessionTools(goalEngine, () => this.sessionManager.getSessionId())) {
+                this._baseToolDefinitions.set(tool.name, tool);
+            }
+            // graph_add_nodes: registros puntuales (QA_FINDING/RISK/DECISION).
+            // El spine se auto-registra vía GraphSync — esto es complemento.
+            if (this.settingsManager.getGraphEnabled()) {
+                this._baseToolDefinitions.set("graph_add_nodes", createGraphTool(() => this._resourceLoader.getGraph?.()));
+            }
+        }
+        // Tool `workflow` SOLO en la sesión principal: los subagentes no
+        // orquestan workflows (anti-anidamiento y control de presupuesto).
+        if (!this._isSubagentSession) {
+            this._baseToolDefinitions.set("workflow", createWorkflowTool({
+                getManager: () => this._resourceLoader.getWorkflowManager?.(),
+                confirm: (prompt) => this._confirmWorkflowLaunch(prompt),
+                agentDir: this._resourceLoader.getAgentDir(),
+                sessionId: () => this.sessionManager.getSessionId(),
+            }));
+        }
         const extensionsResult = this._resourceLoader.getExtensions();
         if (options.flagValues) {
             for (const [name, value] of options.flagValues) {
@@ -2790,6 +3518,7 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
             }
         }
         return {
+            contextBreakdown: this.getContextBreakdown(),
             sessionFile: this.sessionFile,
             sessionId: this.sessionId,
             userMessages,
@@ -2808,6 +3537,61 @@ Task: given the CURRENT MEMORY and the LATEST CONVERSATION TURN, produce the COM
             contextUsage: this.getContextUsage(),
         };
     }
+    /**
+     * Desglose de qué llena la ventana de contexto.
+     *
+     * `getContextUsage()` da un único número; esto dice de dónde sale. Con caché
+     * por prefijo eso no es curiosidad: el coste de tocar algo depende de su
+     * posición, así que saber que las definiciones de tools ocupan 11 K y van
+     * delante te dice que cambiarlas invalida todo lo de detrás.
+     *
+     * El total lo aporta el proveedor y es exacto; el reparto se estima. La
+     * distinción viaja en `totalExacto` para que la interfaz no presente
+     * estimaciones como medidas.
+     */
+    getContextBreakdown() {
+        const model = this.model;
+        if (!model?.contextWindow)
+            return undefined;
+        const usage = this.getContextUsage();
+        const opciones = this._baseSystemPromptOptions;
+        // Los bloques de memoria y del harness llegan como ficheros de contexto con
+        // una ruta marcada; se separan porque son las dos palancas que el usuario
+        // puede apagar desde ajustes.
+        const esMemoria = (ruta) => ruta.startsWith("<ada-") || ruta.includes("memory");
+        const rutas = opciones?.contextFiles ?? [];
+        const definiciones = [];
+        const mcp = [];
+        for (const [nombre, { definition }] of this._toolDefinitions) {
+            // Nombre + descripción + esquema es lo que de verdad viaja al modelo.
+            const texto = `${nombre}${definition.description ?? ""}${JSON.stringify(definition.parameters ?? {})}`;
+            if (nombre.startsWith("mcp_"))
+                mcp.push(texto);
+            else
+                definiciones.push(texto);
+        }
+        const skills = this._resourceLoader.getSkills().skills.map((skill) => `${skill.name}${skill.description ?? ""}`);
+        return construirDesglose({
+            contextWindow: model.contextWindow,
+            tokensReales: usage?.tokens ?? null,
+            systemPrompt: this.systemPrompt ?? "",
+            toolDefinitions: definiciones,
+            skills,
+            mcpTools: mcp,
+            contextFiles: rutas.filter((f) => !esMemoria(f.path)).map((f) => f.content),
+            memory: rutas.filter((f) => esMemoria(f.path)).map((f) => f.content),
+            conversationTokens: this._estimarTokensConversacion(),
+        });
+    }
+    /** Tokens de los mensajes del hilo activo, con el mismo estimador que compacta. */
+    _estimarTokensConversacion() {
+        let total = 0;
+        for (const entrada of this.sessionManager.getBranch()) {
+            if (entrada.type === "message")
+                total += estimateTokens(entrada.message);
+        }
+        return total;
+    }
     getContextUsage() {
         const model = this.model;
         if (!model)