chocolatito-code 1.0.0 → 1.1.0

package/dist/index.js

@@ -10,36 +10,42 @@ 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";
 /**
  * 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 +82,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 +132,81 @@ 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)))
+    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
@@ -165,7 +243,31 @@ async function main() {
         }
         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;
+        // Se escribe solo si hay algo que decir y el usuario no esta a mitad de
+        // frase: el prompt se redibuja entero en la siguiente tecla, asi que una
+        // linea de mas aqui no rompe el marco.
+        if (aviso)
+            console.log(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 +275,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 +316,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 +353,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 +368,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 +406,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 +582,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 +613,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 +654,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[];

package/dist/mcp/client.js

@@ -37,6 +37,96 @@ function expandDeep(value) {
     }
     return value;
 }
+/**
+ * Trocea un cuerpo SSE en la carga util de cada evento.
+ *
+ * Se sigue la especificacion: los comentarios (`:` inicial) se ignoran, las
+ * lineas `data:` de un mismo evento se concatenan con salto de linea y el
+ * evento termina en la linea en blanco. El espacio opcional tras los dos puntos
+ * no forma parte del dato.
+ */
+function eventosSse(text) {
+    const eventos = [];
+    let buffer = [];
+    const cerrar = () => {
+        if (buffer.length)
+            eventos.push(buffer.join("\n"));
+        buffer = [];
+    };
+    for (const line of text.split(/\r?\n/)) {
+        if (line === "") {
+            cerrar();
+            continue;
+        }
+        if (line.startsWith(":"))
+            continue;
+        if (line.startsWith("data:"))
+            buffer.push(line.slice(5).replace(/^ /, ""));
+    }
+    cerrar();
+    return eventos;
+}
+/**
+ * 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 function parseHttpBody(text, contentType, id) {
+    const cuerpo = text.trim();
+    if (!cuerpo)
+        throw new Error("el servidor MCP devolvio un cuerpo vacio");
+    const declaraSse = /text\/event-stream/i.test(contentType || "");
+    if (!declaraSse) {
+        // JSON directo. Si el servidor miente en el Content-Type pero manda SSE,
+        // el parse falla y se reintenta abajo como flujo de eventos.
+        try {
+            return JSON.parse(cuerpo);
+        }
+        catch (err) {
+            if (!/^data:/m.test(cuerpo))
+                throw err;
+        }
+    }
+    const mensajes = [];
+    for (const evento of eventosSse(cuerpo)) {
+        try {
+            mensajes.push(JSON.parse(evento));
+        }
+        catch {
+            // Keepalives y eventos que no son JSON-RPC: se ignoran.
+        }
+    }
+    if (!mensajes.length)
+        throw new Error("el flujo SSE del servidor MCP no traia ningun mensaje JSON-RPC");
+    if (id !== undefined) {
+        const propio = mensajes.find((m) => m && m.id !== undefined && String(m.id) === String(id));
+        if (propio)
+            return propio;
+    }
+    // Sin coincidencia de id nos quedamos con la ultima respuesta de verdad, no
+    // con una notificacion del servidor (que no lleva ni result ni error).
+    const respuestas = mensajes.filter((m) => m && ("result" in m || "error" in m));
+    const elegido = respuestas.length ? respuestas[respuestas.length - 1] : null;
+    if (!elegido)
+        throw new Error("el flujo SSE del servidor MCP no traia respuesta a la peticion");
+    return elegido;
+}
 export class McpClient {
     name;
     tools = [];
@@ -193,6 +283,7 @@ export class McpClient {
     async httpRequest(method, params, timeoutMs) {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeoutMs);
+        const id = this.nextId++;
         try {
             const res = await fetch(this.config.url, {
                 method: "POST",
@@ -201,22 +292,13 @@ export class McpClient {
                     Accept: "application/json, text/event-stream",
                     ...(this.config.headers || {}),
                 },
-                body: JSON.stringify({ jsonrpc: "2.0", id: this.nextId++, method, params }),
+                body: JSON.stringify({ jsonrpc: "2.0", id, method, params }),
                 signal: controller.signal,
             });
             if (!res.ok)
                 throw new Error(`HTTP ${res.status}`);
             const text = await res.text();
-            // El transporte HTTP puede responder JSON directo o un flujo SSE.
-            const body = text.includes("data:")
-                ? text
-                    .split("\n")
-                    .filter((l) => l.startsWith("data:"))
-                    .map((l) => l.slice(5).trim())
-                    .filter(Boolean)
-                    .pop() || "{}"
-                : text;
-            const parsed = JSON.parse(body);
+            const parsed = parseHttpBody(text, res.headers.get("content-type"), id);
             if (parsed.error)
                 throw new Error(parsed.error.message || JSON.stringify(parsed.error));
             return parsed.result;

package/dist/prompts/systemPrompt.js

@@ -20,6 +20,17 @@ export function buildSystemPrompt(context, model, skillManager, memoryManager, i
     const rulesSection = context.rulesContent
         ? `\n\n--- REGLAS DEL PROYECTO (CHOCOLATITO.md) ---\n${context.rulesContent}\n------------------------------------------`
         : "";
+    // El mapa del repositorio va aqui, antes de las reglas de conducta, porque es
+    // lo que le dice al agente que existe en el proyecto. Sin el, para saber que
+    // hay una funcion tiene que buscarla, y para buscarla tiene que sospechar que
+    // existe: de ahi los turnos gastados en grep_search antes de tocar nada.
+    const mapaSection = context.repoMap
+        ? `--- BLOQUE 3b: MAPA DEL REPOSITORIO ---\n` +
+            `Indice de los simbolos mas relevantes del proyecto, ordenado por cuanto los usa el resto\n` +
+            `del codigo. Son NOMBRES Y LINEAS, no contenido: sirve para saber que existe y donde mirar,\n` +
+            `no para editar a ciegas. Antes de tocar cualquiera de estos archivos, leelo con 'view_file'.\n` +
+            `Puede estar desactualizado respecto al disco; manda siempre lo que leas.\n\n${context.repoMap}\n\n`
+        : "";
     const planModeNotice = isPlanMode
         ? `\n\n⚠️ MODO PLAN ACTIVO (SOLO LECTURA): No intentes escribir ni modificar archivos. Investiga el código con herramientas de lectura y genera un plan arquitectónico estructurado para que el usuario lo apruebe.`
         : "";
@@ -44,7 +55,7 @@ ${memoryIndex}
 Tienes acceso a skills especializados. Usa la herramienta 'use_skill' para cargar las instrucciones completas de un skill cuando lo necesites:
 ${skillsListing}
 
---- BLOQUE 4: SUBAGENTES DISPONIBLES ---
+${mapaSection}--- BLOQUE 4: SUBAGENTES DISPONIBLES ---
 Puedes delegar tareas aisladas con 'spawn_agent':
 - 'explore': Investigación y búsqueda de código de solo lectura sin saturar el contexto principal.
 - 'plan': Generación de planes arquitectónicos.

package/dist/sessions/manager.d.ts

@@ -13,6 +13,18 @@ export declare class SessionManager {
     saveSession(session: SessionData): void;
     loadLatestSession(): SessionData | null;
     loadSession(id: string): SessionData | null;
+    /**
+     * Sesiones guardadas, de la mas reciente a la mas antigua.
+     *
+     * El try/catch envolvia el map ENTERO, asi que un solo archivo corrupto
+     * -una sesion que se estaba escribiendo cuando se cerro el portatil, o un
+     * JSON truncado- hacia saltar la excepcion y devolver la lista vacia. El
+     * usuario con treinta sesiones guardadas abria /resume y no veia ninguna, y
+     * no habia forma de saber por que: sus sesiones seguian en el disco.
+     *
+     * Ahora cada archivo se lee por su cuenta. Uno malo se salta; los demas se
+     * listan.
+     */
     listSessions(): Array<{
         id: string;
         updatedAt: string;

package/dist/sessions/manager.js

@@ -37,18 +37,46 @@ export class SessionManager {
         }
         return null;
     }
+    /**
+     * Sesiones guardadas, de la mas reciente a la mas antigua.
+     *
+     * El try/catch envolvia el map ENTERO, asi que un solo archivo corrupto
+     * -una sesion que se estaba escribiendo cuando se cerro el portatil, o un
+     * JSON truncado- hacia saltar la excepcion y devolver la lista vacia. El
+     * usuario con treinta sesiones guardadas abria /resume y no veia ninguna, y
+     * no habia forma de saber por que: sus sesiones seguian en el disco.
+     *
+     * Ahora cada archivo se lee por su cuenta. Uno malo se salta; los demas se
+     * listan.
+     */
     listSessions() {
         if (!fs.existsSync(this.sessionsDir))
             return [];
+        let files;
         try {
-            const files = fs.readdirSync(this.sessionsDir).filter((f) => f.endsWith(".json") && f !== "latest.json");
-            return files.map((f) => {
-                const data = JSON.parse(fs.readFileSync(path.join(this.sessionsDir, f), "utf-8"));
-                return { id: data.id, updatedAt: data.updatedAt, cwd: data.cwd };
-            });
+            files = fs.readdirSync(this.sessionsDir).filter((f) => f.endsWith(".json") && f !== "latest.json");
         }
         catch {
             return [];
         }
+        const sesiones = [];
+        for (const f of files) {
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join(this.sessionsDir, f), "utf-8"));
+                // Sin id no se puede reanudar, asi que listarla solo seria ofrecer algo
+                // que no funciona.
+                if (!data || typeof data.id !== "string")
+                    continue;
+                sesiones.push({
+                    id: data.id,
+                    updatedAt: typeof data.updatedAt === "string" ? data.updatedAt : "",
+                    cwd: typeof data.cwd === "string" ? data.cwd : "",
+                });
+            }
+            catch {
+                // Archivo ilegible: se salta este, no la lista.
+            }
+        }
+        return sesiones.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
 }