chocolatito-code 1.0.0 → 1.2.0

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 = [];
@@ -182,41 +272,84 @@ export class McpClient {
             }
         });
     }
+    /**
+     * 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.
+     */
+    sessionId = null;
+    /** Las mismas cabeceras para peticiones y notificaciones, sesion incluida. */
+    cabecerasHttp() {
+        return {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            ...(this.sessionId ? { "Mcp-Session-Id": this.sessionId } : {}),
+            // Las del usuario van al final: si configura una a mano, manda la suya.
+            ...(this.config.headers || {}),
+        };
+    }
     notify(method, params) {
-        if (this.config.url || !this.proc)
-            return;
+        if (this.config.url)
+            return this.httpNotify(method, params);
+        if (!this.proc)
+            return Promise.resolve();
         try {
             this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
         }
         catch { }
+        return Promise.resolve();
+    }
+    /**
+     * 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.
+     */
+    async httpNotify(method, params) {
+        try {
+            await fetch(this.config.url, {
+                method: "POST",
+                headers: this.cabecerasHttp(),
+                body: JSON.stringify({ jsonrpc: "2.0", method, params }),
+                signal: AbortSignal.timeout(5000),
+            });
+        }
+        catch { }
     }
     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",
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json, text/event-stream",
-                    ...(this.config.headers || {}),
-                },
-                body: JSON.stringify({ jsonrpc: "2.0", id: this.nextId++, method, params }),
+                headers: this.cabecerasHttp(),
+                body: JSON.stringify({ jsonrpc: "2.0", id, method, params }),
                 signal: controller.signal,
             });
+            // La sesion se apunta ANTES de mirar si la respuesta fue buena: hay
+            // servidores que la asignan y en la misma respuesta se quejan de algo
+            // menor, y tirarla aqui condenaria todas las peticiones siguientes.
+            const sesion = res.headers.get("mcp-session-id");
+            if (sesion)
+                this.sessionId = sesion;
             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;
@@ -232,7 +365,10 @@ export class McpClient {
             capabilities: { tools: {} },
             clientInfo: { name: "chocolatito-code", version: "1.0.0" },
         }, timeoutMs);
-        this.notify("notifications/initialized", {});
+        // Se ESPERA a que salga, no se lanza y se olvida. Por HTTP la notificacion
+        // es otra peticion, y si `tools/list` sale antes de que el servidor haya
+        // visto el "ya estoy listo", hay servidores que la rechazan.
+        await this.notify("notifications/initialized", {});
     }
     async listTools(timeoutMs) {
         const out = [];

package/dist/mcp/ide.d.ts

@@ -0,0 +1,76 @@
+import type { McpServerConfig } from "./client.js";
+/**
+ * Encontrar el editor que hay delante, sin que el usuario configure nada.
+ *
+ * COMO SE HABLAN
+ *
+ * Al reves de lo que parece: la extension del editor es el SERVIDOR MCP y el
+ * agente es el cliente. La extension levanta un servidor en localhost y deja
+ * aqui una ficha con el puerto; el agente la lee al arrancar y se conecta solo.
+ * Asi el editor le presta al agente lo unico que el agente no puede tener por su
+ * cuenta: los diagnosticos del servidor de lenguaje, lo que hay seleccionado, y
+ * un sitio donde pintar los diffs de verdad.
+ *
+ * POR QUE UNA FICHA POR VENTANA Y NO UN PUERTO FIJO
+ *
+ * Porque casi nadie tiene un solo VSCode abierto. Con un puerto fijo, el segundo
+ * que arranca no puede escuchar, y el agente de un proyecto acabaria pintando
+ * sus diffs en la ventana de otro. Cada ventana deja su ficha con su carpeta, y
+ * aqui se elige la que de verdad corresponde al directorio de trabajo.
+ *
+ * SEGURIDAD
+ *
+ * El servidor escucha solo en 127.0.0.1 y la ficha lleva un token que hay que
+ * mandar en cada peticion. Sin eso, cualquier programa de la maquina podria
+ * pedirle al editor del usuario que abriera y modificara archivos. La ficha vive
+ * en el home, que es donde ya viven las credenciales.
+ */
+/** Donde deja su ficha cada ventana del editor. */
+export declare function carpetaDeFichas(): string;
+export interface FichaDeEditor {
+    /** Puerto del servidor MCP de esa ventana. */
+    puerto: number;
+    /** Secreto que hay que presentar en cada peticion. */
+    token: string;
+    /** Carpeta abierta en esa ventana. Es lo que decide cual toca. */
+    carpeta: string;
+    /** Proceso de la ventana, para saber si sigue viva. */
+    pid: number;
+    /** "Visual Studio Code", "Cursor"... solo para poder decirlo por pantalla. */
+    editor?: string;
+}
+/** Si `hijo` esta dentro de `padre` (o es el mismo). */
+export declare function estaDentro(hijo: string, padre: string): boolean;
+/**
+ * Lee las fichas que hay ahora mismo, tirando las de ventanas ya cerradas.
+ *
+ * `limpiar` borra las huerfanas del disco. Se hace de paso, no en un proceso
+ * aparte: si no, se acumulan para siempre y cada arranque tiene que descartar
+ * mas basura.
+ */
+export declare function leerFichas(dir?: string, limpiar?: boolean): FichaDeEditor[];
+/**
+ * De todas las ventanas abiertas, la que corresponde a este directorio.
+ *
+ * Nunca devuelve "la primera que haya": si ninguna contiene al directorio de
+ * trabajo, se devuelve null y el agente sigue sin editor. Conectarse a una
+ * ventana ajena seria peor que no conectarse a ninguna, porque los diffs
+ * apareceran en el proyecto equivocado y el usuario los aceptaria sin mirar.
+ *
+ * Cuando varias contienen al directorio (un monorepo abierto entero y un
+ * paquete suyo abierto aparte), gana LA MAS CERCANA: la carpeta mas larga es la
+ * mas especifica.
+ */
+export declare function elegirFicha(cwd: string, fichas: FichaDeEditor[]): FichaDeEditor | null;
+/** La configuracion de servidor MCP que representa a ese editor. */
+export declare function configDeFicha(ficha: FichaDeEditor): McpServerConfig;
+/**
+ * Lo que hay que anadir a la configuracion MCP por tener un editor delante.
+ *
+ * Devuelve un objeto vacio si no hay ninguno, que es el caso normal de quien usa
+ * solo la terminal: nadie tiene que configurar nada para que esto no le moleste.
+ */
+export declare function servidorDelEditor(cwd: string, dir?: string): {
+    config: Record<string, McpServerConfig>;
+    ficha: FichaDeEditor | null;
+};

package/dist/mcp/ide.js

@@ -0,0 +1,160 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Encontrar el editor que hay delante, sin que el usuario configure nada.
+ *
+ * COMO SE HABLAN
+ *
+ * Al reves de lo que parece: la extension del editor es el SERVIDOR MCP y el
+ * agente es el cliente. La extension levanta un servidor en localhost y deja
+ * aqui una ficha con el puerto; el agente la lee al arrancar y se conecta solo.
+ * Asi el editor le presta al agente lo unico que el agente no puede tener por su
+ * cuenta: los diagnosticos del servidor de lenguaje, lo que hay seleccionado, y
+ * un sitio donde pintar los diffs de verdad.
+ *
+ * POR QUE UNA FICHA POR VENTANA Y NO UN PUERTO FIJO
+ *
+ * Porque casi nadie tiene un solo VSCode abierto. Con un puerto fijo, el segundo
+ * que arranca no puede escuchar, y el agente de un proyecto acabaria pintando
+ * sus diffs en la ventana de otro. Cada ventana deja su ficha con su carpeta, y
+ * aqui se elige la que de verdad corresponde al directorio de trabajo.
+ *
+ * SEGURIDAD
+ *
+ * El servidor escucha solo en 127.0.0.1 y la ficha lleva un token que hay que
+ * mandar en cada peticion. Sin eso, cualquier programa de la maquina podria
+ * pedirle al editor del usuario que abriera y modificara archivos. La ficha vive
+ * en el home, que es donde ya viven las credenciales.
+ */
+/** Donde deja su ficha cada ventana del editor. */
+export function carpetaDeFichas() {
+    return path.join(os.homedir(), ".chocolatito", "ide");
+}
+function normalizar(p) {
+    const limpio = path.resolve(p).replace(/[\\/]+$/, "");
+    // Windows no distingue mayusculas en las rutas, y comparar sin normalizar
+    // hace que "C:\Users" y "c:\users" parezcan proyectos distintos.
+    return process.platform === "win32" ? limpio.toLowerCase() : limpio;
+}
+/** Si `hijo` esta dentro de `padre` (o es el mismo). */
+export function estaDentro(hijo, padre) {
+    const h = normalizar(hijo);
+    const p = normalizar(padre);
+    if (h === p)
+        return true;
+    // El separador importa: sin el, "/proyecto-viejo" pasaria por estar dentro de
+    // "/proyecto".
+    return h.startsWith(p + path.sep) || h.startsWith(p + "/");
+}
+/** Si el proceso de esa ventana sigue vivo. Una ficha huerfana no vale. */
+function sigueViva(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        // La senal 0 no manda nada: solo pregunta si existe y si se puede tocar.
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM significa que existe pero es de otro usuario: existe, que es lo que
+        // se preguntaba.
+        return err?.code === "EPERM";
+    }
+}
+function esFicha(x) {
+    return (x &&
+        Number.isInteger(x.puerto) &&
+        x.puerto > 0 &&
+        typeof x.token === "string" &&
+        x.token.length > 0 &&
+        typeof x.carpeta === "string" &&
+        x.carpeta.length > 0);
+}
+/**
+ * Lee las fichas que hay ahora mismo, tirando las de ventanas ya cerradas.
+ *
+ * `limpiar` borra las huerfanas del disco. Se hace de paso, no en un proceso
+ * aparte: si no, se acumulan para siempre y cada arranque tiene que descartar
+ * mas basura.
+ */
+export function leerFichas(dir = carpetaDeFichas(), limpiar = true) {
+    let nombres;
+    try {
+        nombres = fs.readdirSync(dir).filter((n) => n.endsWith(".json"));
+    }
+    catch {
+        return [];
+    }
+    const vivas = [];
+    for (const nombre of nombres) {
+        const completo = path.join(dir, nombre);
+        let ficha;
+        try {
+            ficha = JSON.parse(fs.readFileSync(completo, "utf-8"));
+        }
+        catch {
+            // Una ficha rota no puede impedir encontrar las buenas.
+            continue;
+        }
+        if (!esFicha(ficha))
+            continue;
+        if (!sigueViva(ficha.pid)) {
+            if (limpiar) {
+                try {
+                    fs.unlinkSync(completo);
+                }
+                catch { }
+            }
+            continue;
+        }
+        vivas.push(ficha);
+    }
+    return vivas;
+}
+/**
+ * De todas las ventanas abiertas, la que corresponde a este directorio.
+ *
+ * Nunca devuelve "la primera que haya": si ninguna contiene al directorio de
+ * trabajo, se devuelve null y el agente sigue sin editor. Conectarse a una
+ * ventana ajena seria peor que no conectarse a ninguna, porque los diffs
+ * apareceran en el proyecto equivocado y el usuario los aceptaria sin mirar.
+ *
+ * Cuando varias contienen al directorio (un monorepo abierto entero y un
+ * paquete suyo abierto aparte), gana LA MAS CERCANA: la carpeta mas larga es la
+ * mas especifica.
+ */
+export function elegirFicha(cwd, fichas) {
+    const candidatas = fichas.filter((f) => estaDentro(cwd, f.carpeta));
+    if (candidatas.length === 0)
+        return null;
+    return candidatas.sort((a, b) => normalizar(b.carpeta).length - normalizar(a.carpeta).length)[0];
+}
+/** La configuracion de servidor MCP que representa a ese editor. */
+export function configDeFicha(ficha) {
+    return {
+        type: "http",
+        // Solo el bucle local: nunca la interfaz de red, que expondria el editor
+        // del usuario a cualquiera que comparta su wifi.
+        url: `http://127.0.0.1:${ficha.puerto}/mcp`,
+        headers: { Authorization: `Bearer ${ficha.token}` },
+        // Corto a proposito: es un proceso local. Si no contesta en 5 s es que la
+        // ventana esta colgada, y esperar 20 retrasaria el arranque para nada.
+        timeout: 5000,
+    };
+}
+/**
+ * Lo que hay que anadir a la configuracion MCP por tener un editor delante.
+ *
+ * Devuelve un objeto vacio si no hay ninguno, que es el caso normal de quien usa
+ * solo la terminal: nadie tiene que configurar nada para que esto no le moleste.
+ */
+export function servidorDelEditor(cwd, dir = carpetaDeFichas()) {
+    // Puerta de salida para quien no lo quiera, y para poder reproducir fallos.
+    if (process.env.CHOCOLATITO_SIN_EDITOR === "1")
+        return { config: {}, ficha: null };
+    const ficha = elegirFicha(cwd, leerFichas(dir));
+    if (!ficha)
+        return { config: {}, ficha: null };
+    return { config: { ide: configDeFicha(ficha) }, ficha };
+}

package/dist/mcp/manager.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { McpClient } from "./client.js";
+import { servidorDelEditor } from "./ide.js";
 /**
  * Gestor de servidores MCP.
  *
@@ -49,6 +50,14 @@ export class McpManager {
                 // Un JSON roto no debe impedir arrancar el agente.
             }
         }
+        // El editor que haya delante se anade solo, sin que nadie lo configure. Va
+        // el ultimo a proposito: si el usuario define un servidor llamado "ide" a
+        // mano, gana el suyo. Ver ide.ts.
+        const { config: delEditor } = servidorDelEditor(this.cwd);
+        for (const [name, cfg] of Object.entries(delEditor)) {
+            if (!merged[name])
+                merged[name] = cfg;
+        }
         return merged;
     }
     /** Conecta todos los servidores configurados. Devuelve un resumen legible. */

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));
     }
 }

package/dist/sessions/resume.d.ts

@@ -0,0 +1,36 @@
+import OpenAI from "openai";
+import { SessionData } from "./manager.js";
+/** Lo que hay que aplicar al agente para reanudar una sesion guardada. */
+export interface RestauracionSesion {
+    /** Directorio en el que debe quedar el agente. */
+    cwd: string;
+    /** Motor que estaba activo al guardar, o el actual si aquel ya no existe. */
+    modelId: string;
+    /**
+     * Historial sin ningun mensaje de sistema. El prompt se reconstruye fuera,
+     * con el entorno de HOY, y se antepone a esta lista.
+     */
+    conversacion: OpenAI.Chat.ChatCompletionMessageParam[];
+    /** El directorio guardado ya no existe: se sigue donde se estaba. */
+    directorioPerdido: boolean;
+    /** El motor guardado ya no esta en el catalogo: se sigue con el actual. */
+    motorPerdido: boolean;
+}
+/**
+ * Separa lo que se restaura de una sesion (la conversacion) de lo que se
+ * reconstruye (el entorno).
+ *
+ * El JSON guarda el historial ENTERO y su primer mensaje es el prompt de
+ * sistema que se armo al abrir aquella sesion: fecha, directorio, reglas de
+ * CHOCOLATITO.md, indice de memoria y listado de skills de aquel dia. Volcar el
+ * array tal cual devolvia al modelo a un entorno que ya no existe —anunciaba el
+ * cwd viejo y la fecha vieja— mientras las herramientas seguian resolviendo
+ * rutas contra el cwd real: pedia un archivo creyendo estar en un proyecto y
+ * editaba el del otro. Por eso aqui se tira todo mensaje de sistema y se
+ * devuelven ademas el directorio y el motor de la sesion, que hasta ahora se
+ * escribian en el JSON y no los leia nadie.
+ */
+export declare function prepararRestauracion(sesion: SessionData, actual: {
+    cwd: string;
+    modelId: string;
+}, motores?: Record<string, unknown>): RestauracionSesion;

package/dist/sessions/resume.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import { ESPECTRO_MODELS } from "../config/constants.js";
+/**
+ * Separa lo que se restaura de una sesion (la conversacion) de lo que se
+ * reconstruye (el entorno).
+ *
+ * El JSON guarda el historial ENTERO y su primer mensaje es el prompt de
+ * sistema que se armo al abrir aquella sesion: fecha, directorio, reglas de
+ * CHOCOLATITO.md, indice de memoria y listado de skills de aquel dia. Volcar el
+ * array tal cual devolvia al modelo a un entorno que ya no existe —anunciaba el
+ * cwd viejo y la fecha vieja— mientras las herramientas seguian resolviendo
+ * rutas contra el cwd real: pedia un archivo creyendo estar en un proyecto y
+ * editaba el del otro. Por eso aqui se tira todo mensaje de sistema y se
+ * devuelven ademas el directorio y el motor de la sesion, que hasta ahora se
+ * escribian en el JSON y no los leia nadie.
+ */
+export function prepararRestauracion(sesion, actual, motores = ESPECTRO_MODELS) {
+    const mensajes = Array.isArray(sesion.messages) ? sesion.messages : [];
+    // El directorio guardado manda mientras siga existiendo; si lo borraron o
+    // esta en un disco que hoy no esta montado, quedarse en el actual es lo unico
+    // que no deja al agente apuntando a la nada.
+    const directorioPerdido = !sesion.cwd || !existeDirectorio(sesion.cwd);
+    const cwd = directorioPerdido ? actual.cwd : sesion.cwd;
+    // Igual con el motor: un id de una version vieja del catalogo no puede
+    // dejar `currentModel` en undefined.
+    const motorPerdido = !sesion.modelId || !motores[sesion.modelId];
+    const modelId = motorPerdido ? actual.modelId : sesion.modelId;
+    return {
+        cwd,
+        modelId,
+        conversacion: mensajes.filter((m) => m.role !== "system"),
+        directorioPerdido,
+        motorPerdido,
+    };
+}
+function existeDirectorio(ruta) {
+    try {
+        return fs.statSync(ruta).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/skills/manager.d.ts

@@ -6,6 +6,7 @@ export interface SkillSummary {
 export declare class SkillManager {
     private skillDirs;
     private skillsCache;
+    private scanned;
     constructor(cwd?: string);
     scanSkills(): SkillSummary[];
     getSkillPromptListing(): string;