chocolatito-code 1.0.0 → 1.2.0

package/dist/index.js

@@ -10,36 +10,44 @@ import { getEngineBaseUrl, DEFAULT_ESPECTRO, ESPECTRO_MODELS, RULES_FILE_NAME }
 import { getProjectContext } from "./agent/context.js";
 import { buildSystemPrompt } from "./prompts/systemPrompt.js";
 import { AgentLoop } from "./agent/loop.js";
+import { codigoDeSalida, EXIT_OK, EXIT_FALLO, EXIT_USO, EXIT_LICENCIA } from "./agent/result.js";
 import { showBanner, animateStartupBanner, showHelp, showEffortMenu } from "./ui/banner.js";
 import { askInteractivePrompt, SLASH_COMMANDS } from "./ui/prompt.js";
 import { changeDir } from "./tools/changeDir.js";
 import { gitDiff, gitCommit } from "./tools/gitTools.js";
 import { renderUserPrompt } from "./ui/renderer.js";
-import { parseFileMentions, buildPromptWithMentions } from "./agent/mentions.js";
+import { parseFileMentions, buildPromptWithMentions, notaDeMencionesImplicitas } from "./agent/mentions.js";
 import { SkillManager } from "./skills/manager.js";
 import { MemoryManager } from "./memory/manager.js";
 import { HookManager } from "./hooks/manager.js";
 import { SessionManager } from "./sessions/manager.js";
+import { prepararRestauracion } from "./sessions/resume.js";
 import { globalUndoManager } from "./agent/undoManager.js";
 import { setAutoApprove } from "./ui/permissionPrompt.js";
 import { onModeChange, getMode, modeAnnouncement } from "./ui/modes.js";
 import { releaseKeyboard } from "./ui/interrupt.js";
 import { takeQueued, resetTypeAhead } from "./ui/typeAhead.js";
 import { mcpManager } from "./mcp/manager.js";
+import { comprobarActualizacion } from "./config/updater.js";
+import { comprobarNode } from "./config/nodeVersion.js";
+import { imprimirSobreElPrompt } from "./ui/prompt.js";
 /**
  * Version leida del package.json instalado, no escrita a mano: una constante
  * duplicada aqui se queda vieja en cuanto se publica una version nueva.
  */
 function readVersion() {
     try {
-        const here = path.dirname(fileURLToPath(import.meta.url));
-        const pkg = JSON.parse(fs.readFileSync(path.resolve(here, "..", "package.json"), "utf-8"));
+        const pkg = JSON.parse(fs.readFileSync(path.join(raizDelPaquete(), "package.json"), "utf-8"));
         return String(pkg.version || "desconocida");
     }
     catch {
         return "desconocida";
     }
 }
+/** La carpeta que contiene el `dist`. El actualizador la necesita para saber si esto es el repositorio. */
+function raizDelPaquete() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+}
 /**
  * Banderas que se resuelven sin arrancar el agente.
  *
@@ -76,6 +84,14 @@ function handleFlags(argv) {
             "  API key: variable CHOCOLATITO_API_KEY, un .env del proyecto o ~/.chocolatitorc.",
             "  Reglas del proyecto: CHOCOLATITO.md. Permisos y hooks: .chocolatito/settings.json.",
             "",
+            "CODIGOS DE SALIDA (modo orden unica)",
+            "  0   La tarea se completo.",
+            "  1   El agente no pudo terminar (fallo del motor o limite de iteraciones).",
+            "  2   Error de uso: falta la orden o no hay terminal para pedirla.",
+            "  3   Cuota agotada.",
+            "  4   Licencia o API key no valida.",
+            "  130 Interrumpido con Esc.",
+            "",
         ].join("\n"));
         return true;
     }
@@ -118,17 +134,90 @@ function instalarRedDeSeguridad() {
         restaurarTerminal();
         console.log(chalk.red(`\n✖ Error inesperado: ${err?.message || String(err)}\n`) +
             chalk.gray(`${(err?.stack || "").split("\n").slice(1, 4).join("\n")}\n`));
-        process.exit(1);
+        process.exit(EXIT_FALLO);
     });
 }
+/**
+ * UserPromptSubmit: se dispara con lo que el usuario acaba de escribir, antes de
+ * mandarlo al modelo. Sirve para vetar un prompt (un secreto pegado sin querer,
+ * una politica de la empresa) o para inyectarle contexto.
+ *
+ * Estaba declarado en HookEvent y /hooks lo listaba tan tranquilo, pero no lo
+ * disparaba nadie: se configuraba y no pasaba absolutamente nada. Un hook puesto
+ * para bloquear prompts con credenciales los dejaba pasar todos.
+ *
+ * Devuelve null si el prompt queda vetado.
+ */
+async function pasarPorUserPromptSubmit(hooks, prompt) {
+    const d = await hooks.run("UserPromptSubmit", { prompt }, prompt);
+    if (d.systemMessage)
+        console.log(chalk.yellow(`\n⚑ ${d.systemMessage}`));
+    if (d.permissionDecision === "deny") {
+        console.log(chalk.red(`\n✖ Un hook rechazo este prompt: ${d.permissionDecisionReason || "sin motivo"}\n`));
+        return null;
+    }
+    if (d.additionalContext) {
+        return `${prompt}\n\n[Contexto anadido por un hook UserPromptSubmit]\n${d.additionalContext}`;
+    }
+    return prompt;
+}
+/**
+ * Stop: fin de turno, el sitio donde el usuario engancha su linter o sus tests.
+ * Mismo caso que el anterior: declarado, listado y jamas disparado.
+ *
+ * Un "deny" (codigo 2) significa "no pares todavia" y devuelve el motivo para
+ * reinyectarlo como siguiente orden; quien llama decide si lo hace, porque un
+ * hook que siempre diga que no dejaria al agente dando vueltas para siempre.
+ */
+async function dispararStop(hooks, datos) {
+    const d = await hooks.run("Stop", datos);
+    const aviso = d.systemMessage || d.additionalContext;
+    if (aviso)
+        console.log(chalk.yellow(`\n⚑ ${aviso}`));
+    if (d.permissionDecision === "deny") {
+        return d.permissionDecisionReason || "Un hook Stop pidio seguir trabajando.";
+    }
+    return null;
+}
 async function main() {
-    if (handleFlags(process.argv.slice(2)))
+    // Lo primero de todo: un Node viejo se dice claro, no se descubre a base de
+    // errores raros dentro de una dependencia. Ver config/nodeVersion.ts.
+    const nodeViejo = comprobarNode();
+    if (nodeViejo) {
+        console.error(chalk.red(`
+${nodeViejo}
+`));
+        process.exit(EXIT_USO);
+    }
+    const rawArgs = process.argv.slice(2);
+    if (handleFlags(rawArgs))
         return;
     instalarRedDeSeguridad();
+    // --yes / -y aprueba las acciones sin preguntar. Util en modo comando unico y CI.
+    const autoYes = rawArgs.includes("--yes") || rawArgs.includes("-y");
+    const args = rawArgs.filter((a) => a !== "--yes" && a !== "-y");
+    const singlePrompt = args.join(" ").trim();
+    // Los errores de uso se resuelven ANTES de la licencia y de la API key: no
+    // dependen de estar suscrito, y en CI hay que poder distinguir "lo has
+    // invocado mal" de "el agente no pudo".
+    if (args.length > 0 && !singlePrompt) {
+        console.error(chalk.red("\n✖ No hay ninguna orden que ejecutar.") +
+            chalk.gray('\n  Uso: chocolatito "haz X". Con --help tienes el resto.\n'));
+        process.exit(EXIT_USO);
+    }
+    // Sin orden y sin terminal no hay a quien preguntar: el REPL moria en el
+    // primer prompt y salia con 0, que en CI se lee como "todo bien".
+    if (!singlePrompt && !process.stdin.isTTY) {
+        console.error(chalk.red("\n✖ La entrada no es una terminal y no se dio ninguna orden.") +
+            chalk.gray('\n  En scripts y CI usa: chocolatito --yes "haz X".\n'));
+        process.exit(EXIT_USO);
+    }
+    if (autoYes)
+        setAutoApprove(true);
     // La licencia va ANTES de la API key: no tiene sentido pedirle a alguien que
     // configure DeepSeek si despues le vamos a decir que no ha comprado.
     if (!(await ensureLicense())) {
-        process.exit(1);
+        process.exit(EXIT_LICENCIA);
     }
     // En suscripcion el motor lo paga Chocolatito: el cliente NO tiene ni necesita
     // clave de DeepSeek, y su credencial es la propia licencia. Preguntarsela era
@@ -159,13 +248,41 @@ async function main() {
     // Si tardan, el primer turno los espera; el usuario ya puede escribir.
     const mcpReady = mcpManager.loadAll().then((resumen) => {
         if (resumen) {
-            console.log(chalk.hex("#D97757")("\n🔌 Servidores MCP:"));
-            console.log(resumen);
-            console.log(chalk.gray(`   ${mcpManager.toolCount} herramientas MCP disponibles.\n`));
+            // Con `console.log` esto se escribia ENCIMA del marco del prompt y lo
+            // destrozaba: los servidores tardan, y para cuando contestan el prompt ya
+            // esta dibujado. Se vio asi en una sesion real del usuario:
+            //     ✔ ide (http): 4 herramientasb modo · esc cancelar
+            imprimirSobreElPrompt(chalk.hex("#D97757")("\n🔌 Servidores MCP:") +
+                `\n${resumen}\n` +
+                chalk.gray(`   ${mcpManager.toolCount} herramientas MCP disponibles.\n`));
         }
         return resumen;
     });
+    // Actualizacion sola, en segundo plano.
+    //
+    // No se espera: si el registro tarda, la sesion ya esta lista y el aviso
+    // aparece cuando llegue. Se guarda la promesa en vez de soltarla para que
+    // /actualizar pueda ensenar el resultado si el usuario pregunta antes.
+    let avisoDeActualizacion = "";
+    const actualizacionEnCurso = comprobarActualizacion({
+        versionActual: readVersion(),
+        raizDelPaquete: raizDelPaquete(),
+        ahora: Date.now(),
+    })
+        .then((aviso) => {
+        avisoDeActualizacion = aviso;
+        // Llega tarde a proposito, y para entonces el prompt ya suele estar
+        // dibujado: por eso NO se usa console.log, que lo pisaria. Ver
+        // imprimirSobreElPrompt en ui/prompt.ts.
+        if (aviso)
+            imprimirSobreElPrompt(chalk.gray(`\n  ⬆ ${aviso}\n`));
+        return aviso;
+    })
+        .catch(() => "");
     // Add /resume to slash commands
+    if (!SLASH_COMMANDS.some((c) => c.name === "/actualizar")) {
+        SLASH_COMMANDS.push({ name: "/actualizar", description: "Buscar e instalar la última versión de Chocolatito Code" });
+    }
     if (!SLASH_COMMANDS.some((c) => c.name === "/licencia")) {
         SLASH_COMMANDS.push({ name: "/licencia", description: "Ver la licencia activa o liberar este equipo", args: "[liberar]" });
     }
@@ -173,21 +290,37 @@ async function main() {
         SLASH_COMMANDS.splice(1, 0, { name: "/resume", description: "Reanudar una sesión anterior guardada", args: "[id]" });
     }
     // Single-command mode: chocolatito "crea index.html"
-    const rawArgs = process.argv.slice(2);
-    // --yes / -y aprueba las acciones sin preguntar. Util en modo comando unico y CI.
-    const autoYes = rawArgs.includes("--yes") || rawArgs.includes("-y");
-    if (autoYes)
-        setAutoApprove(true);
-    const args = rawArgs.filter((a) => a !== "--yes" && a !== "-y");
-    if (args.length > 0) {
-        const singlePrompt = args.join(" ");
+    if (singlePrompt) {
         showBanner(context.cwd, currentModel, "idle");
         renderUserPrompt(singlePrompt);
-        const { attachedFiles } = parseFileMentions(singlePrompt, context.cwd);
-        const enrichedPrompt = buildPromptWithMentions(singlePrompt, attachedFiles);
+        // El modo no interactivo pasa por los mismos hooks que el REPL: un veto que
+        // solo valiera cuando hay alguien mirando no es una politica.
+        const revisado = await pasarPorUserPromptSubmit(hookManager, singlePrompt);
+        if (revisado === null) {
+            await hookManager.triggerHook("SessionEnd", { sessionId, cwd: agent.currentCwd });
+            process.exit(EXIT_FALLO);
+        }
+        const { attachedFiles } = parseFileMentions(revisado, context.cwd);
+        const enrichedPrompt = buildPromptWithMentions(revisado, attachedFiles) +
+            notaDeMencionesImplicitas(revisado, context.cwd, attachedFiles.map((f) => f.relativePath));
         await mcpReady;
-        await agent.runTask(enrichedPrompt);
-        process.exit(0);
+        // Aqui estaba el fallo: process.exit(0) incondicional. Una cuota agotada,
+        // una licencia caida o el limite de iteraciones salian con 0 y el pipeline
+        // seguia como si el trabajo estuviera hecho.
+        const resultado = await agent.runTask(enrichedPrompt);
+        // Aqui tampoco se disparaba nada: el modo de una sola orden salia por
+        // process.exit() sin pasar por Stop ni por SessionEnd, asi que el linter del
+        // final del turno y el cierre de sesion solo existian en la sesion
+        // interactiva. Su "deny" no reinyecta nada: no hay turno siguiente al que
+        // devolverle el trabajo, se avisa y se sale.
+        await dispararStop(hookManager, { session_id: sessionId, cwd: agent.currentCwd, stop_hook_active: false });
+        await hookManager.triggerHook("SessionEnd", { sessionId, cwd: agent.currentCwd });
+        if (!resultado.exito) {
+            console.error(chalk.red(`✖ La tarea no se completo (${resultado.motivo})`) +
+                (resultado.detalle ? chalk.gray(`: ${resultado.detalle}`) : "") +
+                "\n");
+        }
+        process.exit(codigoDeSalida(resultado));
     }
     // Interactive REPL Mode with lively startup walking animation
     await animateStartupBanner(context.cwd, currentModel);
@@ -198,21 +331,34 @@ async function main() {
     // Lo que el usuario escribio mientras el agente trabajaba entra como siguiente
     // orden, sin tener que volver a teclearlo.
     let pendiente = null;
+    // Lo que un hook Stop pide seguir haciendo va aparte de `pendiente`: hay que
+    // distinguir "sigue tu" de "el usuario escribio algo", porque el permiso para
+    // reinyectar se gasta una sola vez por orden del usuario. Sin ese limite, un
+    // Stop que siempre deniega deja al agente en bucle infinito quemando cuota.
+    let continuacionDeStop = null;
+    let stopYaForzado = false;
     while (true) {
         let userInput = "";
-        if (pendiente) {
+        if (continuacionDeStop) {
+            userInput = continuacionDeStop;
+            continuacionDeStop = null;
+            renderUserPrompt(userInput);
+        }
+        else if (pendiente) {
             userInput = pendiente;
             pendiente = null;
+            stopYaForzado = false;
             renderUserPrompt(userInput);
         }
         else {
             try {
                 userInput = await askInteractivePrompt(isPlanMode ? chalk.cyan("plan ❯") : "❯", agent.currentCwd);
+                stopYaForzado = false;
             }
             catch {
                 console.log(chalk.gray("\n👋 Sesión finalizada."));
                 await hookManager.triggerHook("SessionEnd", { sessionId, cwd: agent.currentCwd });
-                process.exit(0);
+                process.exit(EXIT_OK);
             }
         }
         const trimmed = userInput.trim();
@@ -222,7 +368,7 @@ async function main() {
         if (trimmed === "/exit" || trimmed === "exit" || trimmed === "quit") {
             console.log(chalk.gray("\n👋 Sesión finalizada."));
             await hookManager.triggerHook("SessionEnd", { sessionId, cwd: agent.currentCwd });
-            process.exit(0);
+            process.exit(EXIT_OK);
         }
         if (trimmed === "/licencia" || trimmed.startsWith("/licencia ")) {
             const sub = trimmed.slice("/licencia".length).trim();
@@ -237,14 +383,13 @@ async function main() {
         }
         if (trimmed === "/undo") {
             const undoRes = globalUndoManager.undoLast();
-            if (undoRes.success) {
-                console.log(chalk.green(`\n${undoRes.message}`));
-                undoRes.restoredFiles.forEach((f) => console.log(`  ${chalk.gray("•")} ${chalk.white(f)}`));
-                console.log("");
-            }
-            else {
-                console.log(chalk.yellow(`\n⚠ ${undoRes.message}\n`));
-            }
+            // Lo que no se pudo deshacer se imprime siempre, tambien cuando algo si se
+            // restauro. Antes solo se veia la lista de exitos bajo un "Deshecho con
+            // exito" fijo, asi que un borrado irreversible pasaba por reparado.
+            console.log(undoRes.success ? chalk.green(`\n${undoRes.message}`) : chalk.yellow(`\n${undoRes.message}`));
+            undoRes.restoredFiles.forEach((f) => console.log(`  ${chalk.gray("•")} ${chalk.white(f)}`));
+            undoRes.failures.forEach((f) => console.log(`  ${chalk.red("✗")} ${chalk.yellow(f)}`));
+            console.log("");
             continue;
         }
         if (trimmed.startsWith("/export")) {
@@ -276,8 +421,26 @@ ${sessionData}
             const targetId = trimmed.slice(7).trim();
             const loaded = targetId ? sessionManager.loadSession(targetId) : sessionManager.loadLatestSession();
             if (loaded) {
-                agent.messages = loaded.messages;
-                console.log(chalk.green(`\n✔ Sesión "${loaded.id}" restaurada con éxito (${loaded.messages.length} mensajes cargados).\n`));
+                // Se restaura la conversacion, no el entorno. El array guardado trae en
+                // su primer mensaje el prompt de sistema de aquel dia; asignarlo entero
+                // dejaba al modelo anunciando otro directorio, otra fecha y otras reglas
+                // mientras las herramientas trabajaban contra el cwd real.
+                const restauracion = prepararRestauracion(loaded, { cwd: agent.currentCwd, modelId: currentModel.id });
+                agent.currentCwd = restauracion.cwd;
+                currentModel = ESPECTRO_MODELS[restauracion.modelId] || currentModel;
+                const refreshedContext = await getProjectContext(agent.currentCwd);
+                systemPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
+                agent.messages = [{ role: "system", content: systemPrompt }, ...restauracion.conversacion];
+                // Sincroniza el motor del bucle con el de la sesion: el prompt ya
+                // anuncia ese nivel de esfuerzo, y anunciar uno y correr otro es el
+                // mismo desfase que se acaba de arreglar.
+                agent.setEspectroModel(currentModel);
+                console.log(chalk.green(`\n✔ Sesión "${loaded.id}" restaurada con éxito (${restauracion.conversacion.length} mensajes cargados).`));
+                console.log(chalk.gray(`  Directorio: ${agent.currentCwd} · Motor: ${currentModel.name}`));
+                if (restauracion.directorioPerdido && loaded.cwd) {
+                    console.log(chalk.yellow(`  ⚠ El directorio guardado (${loaded.cwd}) ya no existe; se sigue aquí.`));
+                }
+                console.log("");
             }
             else {
                 const available = sessionManager.listSessions();
@@ -434,6 +597,25 @@ Directivas de ejecución:
             console.log(chalk.green("✔ Historial reiniciado.\n"));
             continue;
         }
+        if (trimmed === "/actualizar") {
+            // Si la comprobacion del arranque ya trajo algo que decir, se dice eso en
+            // vez de volver a la red: preguntar dos veces lo mismo no cambia la
+            // respuesta y hace esperar al usuario para nada.
+            await actualizacionEnCurso;
+            if (avisoDeActualizacion) {
+                console.log(chalk.gray(`\n  ⬆ ${avisoDeActualizacion}\n`));
+                continue;
+            }
+            console.log(chalk.gray("\n  Buscando una version mas nueva…"));
+            const aviso = await comprobarActualizacion({
+                versionActual: readVersion(),
+                raizDelPaquete: raizDelPaquete(),
+                ahora: Date.now(),
+                forzar: true,
+            });
+            console.log(chalk.gray(`  ${aviso || "Sin novedades."}\n`));
+            continue;
+        }
         if (trimmed === "/init") {
             const rulesPath = path.join(agent.currentCwd, RULES_FILE_NAME);
             if (!fs.existsSync(rulesPath)) {
@@ -446,13 +628,34 @@ Directivas de ejecución:
             }
             continue;
         }
+        // UserPromptSubmit: el hook ve el prompt antes que el modelo y puede vetarlo
+        // o anadirle contexto. Va aqui, despues de los comandos de barra, porque
+        // "/clear" o "/hooks" no son prompts para el modelo.
+        const revisado = await pasarPorUserPromptSubmit(hookManager, trimmed);
+        if (revisado === null)
+            continue;
         // Parse and auto-attach @file mentions
-        const { attachedFiles } = parseFileMentions(trimmed, agent.currentCwd);
-        const enrichedPrompt = buildPromptWithMentions(trimmed, attachedFiles);
+        const { attachedFiles } = parseFileMentions(revisado, agent.currentCwd);
+        // Y los que nombra sin la @ ("arregla el fileTracker"): solo la ruta, para
+        // que no tenga que buscar a ciegas un archivo que el usuario acaba de decir.
+        const enrichedPrompt = buildPromptWithMentions(revisado, attachedFiles) +
+            notaDeMencionesImplicitas(revisado, agent.currentCwd, attachedFiles.map((f) => f.relativePath));
         // Execute task with agent loop
         await agent.runTask(enrichedPrompt);
         // Lo que se escribio mientras trabajaba pasa a ser la siguiente orden.
         pendiente = takeQueued();
+        // Stop: fin de turno. Si deniega, pide seguir trabajando; solo se le hace
+        // caso una vez por orden del usuario y nunca por delante de lo que el
+        // usuario haya escrito mientras tanto.
+        const motivoSeguir = await dispararStop(hookManager, {
+            session_id: sessionId,
+            cwd: agent.currentCwd,
+            stop_hook_active: stopYaForzado,
+        });
+        if (motivoSeguir && !stopYaForzado && !pendiente) {
+            stopYaForzado = true;
+            continuacionDeStop = `[Hook Stop] ${motivoSeguir}`;
+        }
         // Persist session state
         sessionManager.saveSession({
             id: sessionId,
@@ -466,5 +669,5 @@ Directivas de ejecución:
 }
 main().catch((err) => {
     console.error(chalk.red(`\nError: ${err?.message || String(err)}`));
-    process.exit(1);
+    process.exit(EXIT_FALLO);
 });

package/dist/mcp/client.d.ts

@@ -17,6 +17,28 @@ export interface McpServerConfig {
  * guardar la configuracion en el repositorio sin meter secretos dentro.
  */
 export declare function expandVars(value: string): string;
+/**
+ * Extrae el mensaje JSON-RPC de una respuesta HTTP, sea JSON directo o SSE.
+ *
+ * Antes esto se decidia con `text.includes("data:")` sobre el cuerpo entero, y
+ * eso rompia por dos sitios a la vez:
+ *
+ * 1. Cualquier respuesta JSON normal que mencionara `data:` en su contenido (un
+ *    data URI, una cabecera, un trozo de CSS, la descripcion de una herramienta
+ *    de captura o de fetch web) entraba por la rama SSE. Ninguna linea empezaba
+ *    por `data:`, el `.pop()` daba undefined y el `|| "{}"` convertia la
+ *    respuesta en un objeto vacio. Como `httpRequest` es la unica via de todo el
+ *    protocolo HTTP, eso no solo devolvia «(sin contenido)» en `tools/call`:
+ *    tambien vaciaba `tools/list`, y el servidor quedaba «conectado» con cero
+ *    herramientas sin un solo mensaje de error.
+ * 2. En SSE de verdad, `.pop()` se quedaba con el ULTIMO evento en vez de con el
+ *    que responde a nuestro `id`. Un ping o una notificacion posterior tapaban
+ *    el resultado.
+ *
+ * Ahora manda el Content-Type, la forma del cuerpo desempata cuando el servidor
+ * no lo declara bien, y entre los eventos se elige el que lleva el `id` pedido.
+ */
+export declare function parseHttpBody(text: string, contentType: string | null, id?: number | string): any;
 export declare class McpClient {
     readonly name: string;
     tools: McpTool[];
@@ -46,7 +68,35 @@ export declare class McpClient {
     private spawnServer;
     private onMessage;
     private request;
+    /**
+     * Identificador de sesion que asigna el servidor HTTP.
+     *
+     * El transporte "streamable HTTP" del protocolo permite que el servidor
+     * devuelva una cabecera `Mcp-Session-Id` al responder al `initialize`, y a
+     * partir de ahi EXIGE que el cliente la mande en todas las peticiones
+     * siguientes. Sin esto, un servidor con sesion acepta el saludo y luego
+     * rechaza absolutamente todo lo demas: la conexion parece buena, la lista de
+     * herramientas llega vacia o con un 400, y desde fuera solo se ve un servidor
+     * que "no funciona" sin decir por que.
+     */
+    private sessionId;
+    /** Las mismas cabeceras para peticiones y notificaciones, sesion incluida. */
+    private cabecerasHttp;
     private notify;
+    /**
+     * Una notificacion por HTTP.
+     *
+     * Antes esto no existia y `notify()` se iba de vacio en cuanto habia una URL,
+     * asi que `notifications/initialized` solo viajaba por stdio. El protocolo la
+     * exige despues del `initialize`, y hay servidores que no atienden nada mas
+     * hasta recibirla: quedaban colgados en el saludo.
+     *
+     * No lleva id y no espera resultado -el servidor contesta 202 con el cuerpo
+     * vacio-, asi que no se parsea nada. Un fallo aqui tampoco se propaga: si el
+     * servidor no la queria, se vera en la peticion siguiente, que si tiene a
+     * quien quejarse.
+     */
+    private httpNotify;
     private httpRequest;
     private initialize;
     private listTools;