chocolatito-code 1.6.6 → 1.6.8

package/dist/index.js

@@ -15,8 +15,11 @@ import { codigoDeSalida, EXIT_OK, EXIT_FALLO, EXIT_USO, EXIT_LICENCIA } from "./
 import { showBanner, animateStartupBanner, showHelp, showEffortMenu } from "./ui/banner.js";
 import { fijarMotor } from "./ui/motorActual.js";
 import { elegirDeLista } from "./ui/selector.js";
-import { entrarEnPantallaFija, pantallaFijaPedida } from "./ui/pantalla.js";
-import { montarArbol } from "./ui/ink/montarApp.js";
+import { entrarEnPantallaFija, pantallaFijaPedida, salirDePantallaFija } from "./ui/pantalla.js";
+import { iniciarServidorWeb } from "./servidor/servidor.js";
+import { iniciarCaptura } from "./servidor/captura.js";
+import { entregarEntrada, esperarEntradaWeb, marcarServirActivo } from "./servidor/puente.js";
+import { montarArbol, desmontarArbol } from "./ui/ink/montarApp.js";
 import { reafirmarModoCrudo } from "./ui/keyboardGuard.js";
 import { askInteractivePrompt, SLASH_COMMANDS } from "./ui/prompt.js";
 import { changeDir } from "./tools/changeDir.js";
@@ -27,7 +30,8 @@ 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 { prepararRestauracion, formatearOpcionesDeSesion } from "./sessions/resume.js";
+import { auditGitDiff, formatAuditReport } from "./tools/gitAudit.js";
 import { globalUndoManager } from "./agent/undoManager.js";
 import { setAutoApprove } from "./ui/permissionPrompt.js";
 import { onModeChange, getMode, modeAnnouncement } from "./ui/modes.js";
@@ -76,6 +80,9 @@ function handleFlags(argv) {
             "",
             "OPCIONES",
             "  -y, --yes         Aprueba las acciones sin preguntar (util en CI).",
+            "  --servir          Abre la sesion en el navegador (solo esta maquina).",
+            "  --servir-red      Igual, pero accesible desde tu red local (movil, tablet).",
+            "  --puerto N        Puerto para --servir (por defecto 4700).",
             "  -v, --version     Muestra la version instalada.",
             "  -h, --help        Muestra esta ayuda.",
             "",
@@ -89,6 +96,7 @@ function handleFlags(argv) {
             "CONFIGURACION",
             "  API key: variable CHOCOLATITO_API_KEY, un .env del proyecto o ~/.chocolatitorc.",
             "  Reglas del proyecto: CHOCOLATITO.md. Permisos y hooks: .chocolatito/settings.json.",
+            "  Interfaz clasica (sin la caja pegada abajo): variable CHOCOLATITO_PANTALLA=normal.",
             "",
             "CODIGOS DE SALIDA (modo orden unica)",
             "  0   La tarea se completo.",
@@ -136,9 +144,29 @@ function instalarRedDeSeguridad() {
     });
     // Una excepcion no capturada si es terminal, pero al menos se sale con la
     // terminal usable y con un mensaje legible en vez de una traza cruda.
+    //
+    // NO SE USA `console.log` AQUI, Y ES A PROPOSITO
+    //
+    // Con el arbol montado la consola esta interceptada: un `console.log` va a la
+    // transcripcion, que la pinta el arbol... en el proximo dibujado, que ya no
+    // llega porque la linea siguiente cierra el proceso. El mensaje se escribe en
+    // un sitio que nadie va a leer nunca.
+    //
+    // Es exactamente el fallo que impidio diagnosticar la pantalla en negro dos
+    // veces: el programa se cerraba "sin decir nada" y si lo decia, pero a una
+    // pantalla que se iba con el. Aqui se suelta el arbol primero -que devuelve la
+    // consola de verdad- y se escribe directo a stderr, que no lo intercepta nadie.
     process.on("uncaughtException", (err) => {
         restaurarTerminal();
-        console.log(chalk.red(`\n✖ Error inesperado: ${err?.message || String(err)}\n`) +
+        try {
+            desmontarArbol();
+        }
+        catch { }
+        try {
+            salirDePantallaFija();
+        }
+        catch { }
+        process.stderr.write(chalk.red(`\n✖ Error inesperado: ${err?.message || String(err)}\n`) +
             chalk.gray(`${(err?.stack || "").split("\n").slice(1, 4).join("\n")}\n`));
         process.exit(EXIT_FALLO);
     });
@@ -190,8 +218,8 @@ async function main() {
     // errores raros dentro de una dependencia. Ver config/nodeVersion.ts.
     const nodeViejo = comprobarNode();
     if (nodeViejo) {
-        console.error(chalk.red(`
-${nodeViejo}
+        console.error(chalk.red(`
+${nodeViejo}
 `));
         process.exit(EXIT_USO);
     }
@@ -201,7 +229,16 @@ ${nodeViejo}
     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");
+    // --servir abre la sesion en el navegador; --servir-red ademas la saca a la
+    // red local, que es lo que hace falta para entrar desde el movil.
+    const enRed = rawArgs.includes("--servir-red");
+    const quiereServir = enRed || rawArgs.includes("--servir");
+    const posPuerto = rawArgs.indexOf("--puerto");
+    const puertoWeb = posPuerto >= 0 ? Number(rawArgs[posPuerto + 1]) || 0 : 0;
+    // Ojo: lo que sobra de argv se convierte en la orden a ejecutar. Una bandera
+    // que no se filtre aqui no es una bandera ignorada, es una orden al modelo.
+    const banderas = new Set(["--yes", "-y", "--servir", "--servir-red", "--puerto"]);
+    const args = rawArgs.filter((a, i) => !banderas.has(a) && !(posPuerto >= 0 && i === posPuerto + 1 && puertoWeb > 0));
     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
@@ -213,7 +250,7 @@ ${nodeViejo}
     }
     // 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) {
+    if (!singlePrompt && !process.stdin.isTTY && !quiereServir) {
         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);
@@ -233,20 +270,10 @@ ${nodeViejo}
         : await ensureApiKey();
     const context = await getProjectContext(process.cwd());
     const skillManager = new SkillManager(context.cwd);
-    const memoryManager = new MemoryManager();
+    const memoryManager = new MemoryManager(context.cwd);
     const hookManager = new HookManager(context.cwd);
     const sessionManager = new SessionManager();
     const sessionId = `session_${Date.now()}`;
-    // La barra de abajo solo puede quedarse clavada si el programa toma la
-    // pantalla entera. Se pide con CHOCOLATITO_PANTALLA=fija y se paga con el
-    // historial del terminal: ver ui/pantalla.ts.
-    if (pantallaFijaPedida()) {
-        entrarEnPantallaFija();
-        // Entrar y empezar a dibujar son la misma decision: entrar sin montar el
-        // arbol deja una consola en blanco de la que solo se sale cerrando la
-        // ventana.
-        montarArbol();
-    }
     let currentModel = DEFAULT_ESPECTRO;
     // La barra de estado lo lee de aqui. Fijarlo al arrancar y no solo al
     // cambiarlo: si no, hasta el primer /effort la barra no dice nada.
@@ -309,7 +336,9 @@ ${nodeViejo}
         SLASH_COMMANDS.splice(1, 0, { name: "/resume", description: "Reanudar una sesión anterior guardada", args: "[id]" });
     }
     // Single-command mode: chocolatito "crea index.html"
-    if (singlePrompt) {
+    // Con --servir no: ahi la orden es solo la PRIMERA de una sesion que sigue
+    // viva esperando al navegador, no una tarea suelta que termina y cierra.
+    if (singlePrompt && !quiereServir) {
         showBanner(context.cwd, currentModel, "idle");
         renderUserPrompt(singlePrompt);
         // El modo no interactivo pasa por los mismos hooks que el REPL: un veto que
@@ -350,6 +379,67 @@ ${nodeViejo}
     chalk.gray("  shift+tab cambia el modo de permisos · puedes escribir mientras trabaja y se encola\n\n"));
     if (getMode() !== "default")
         console.log(`  ${modeAnnouncement()}\n`);
+    // EL ARBOL SE MONTA AQUI Y NO ANTES
+    //
+    // Va de serie. CHOCOLATITO_PANTALLA=normal devuelve la clasica. Ver ui/pantalla.ts.
+    //
+    // Estaba montado mucho mas arriba, antes del zorro. Y el zorro se dibuja con
+    // animacion: mueve el cursor y repinta. Dos cosas moviendo el cursor a la vez
+    // descuadran la cuenta de filas de Ink desde el primer fotograma, y lo que se
+    // ve es "sale una barra y lo demas negro".
+    //
+    // Aqui no queda nada por animar: el zorro ya salio, y lo que venga sale por el
+    // arbol o por el parche de console de Ink.
+    //
+    // Y el arbol solo se monta si se entro de VERDAD: sin terminal -salida a un
+    // archivo, un script, CI- no se entra, e Ink sin terminal escribe su marco
+    // como texto suelto. La salida del programa saldria con la caja de escribir
+    // metida dentro.
+    if (pantallaFijaPedida() && entrarEnPantallaFija()) {
+        // Entrar y empezar a dibujar son la misma decision: desviar el dibujo sin
+        // que haya nadie pintandolo deja la consola muda.
+        montarArbol();
+    }
+    // EL SERVIDOR WEB, SI SE PIDIO
+    //
+    // Va DESPUES de montar el arbol, y el orden no es casual: ui/pantalla.ts ya
+    // reemplazo los cuatro canales de console para mandarlos a la transcripcion, y
+    // la captura tiene que envolver ESA version. Al reves, pantalla envolveria a la
+    // captura y al navegador no llegaria nada. Ver servidor/captura.ts.
+    if (quiereServir) {
+        try {
+            iniciarCaptura();
+            const web = await iniciarServidorWeb({ puerto: puertoWeb || undefined, enRed });
+            marcarServirActivo(true);
+            console.log(chalk.hex("#e8833a")("\n  🦊 Sesión abierta en el navegador\n"));
+            console.log(`  ${chalk.bold("Aquí:")}     ${chalk.cyan(web.url)}`);
+            for (const dir of web.urlsDeRed) {
+                console.log(`  ${chalk.bold("Del móvil:")} ${chalk.cyan(dir)}`);
+            }
+            if (!enRed) {
+                console.log(chalk.gray("\n  Solo desde esta máquina. Para entrar desde el móvil: --servir-red"));
+            }
+            else {
+                console.log(chalk.yellow("\n  ⚠ Abierto a tu red local.") +
+                    chalk.gray(" Cualquiera que tenga el enlace COMPLETO (con el token)" +
+                        "\n    puede usar esta sesión. No lo pegues en ningún sitio compartido."));
+            }
+            console.log(chalk.gray("\n  Lo que escribas aquí ya no se lee: manda el navegador y este terminal es el monitor.\n"));
+            // Una orden en la linea de comandos con --servir es la PRIMERA del turno,
+            // no una tarea suelta: entra por la misma puerta que lo que llegue del movil.
+            if (singlePrompt)
+                entregarEntrada(singlePrompt);
+        }
+        catch (err) {
+            const ocupado = err?.code === "EADDRINUSE";
+            const motivo = ocupado ? "el puerto ya está ocupado" : err?.message || String(err);
+            console.error(chalk.red("\n✖ No se pudo abrir la sesión web: " + motivo));
+            if (ocupado)
+                console.error(chalk.gray("  Prueba con otro: chocolatito --servir --puerto 4701"));
+            console.error("");
+            process.exit(EXIT_USO);
+        }
+    }
     // Lo que el usuario escribio mientras el agente trabajaba entra como siguiente
     // orden, sin tener que volver a teclearlo.
     let pendiente = null;
@@ -372,6 +462,15 @@ ${nodeViejo}
             stopYaForzado = false;
             renderUserPrompt(userInput);
         }
+        else if (quiereServir) {
+            // Manda el navegador. No se corre tambien el prompt del teclado a ver cual
+            // contesta primero: askInteractivePrompt se queda con el TTY prestado y no
+            // sabe cancelarse a medias, y dos entradas peleando por el mismo terminal
+            // es exactamente lo que dejo la pantalla en negro dos veces.
+            userInput = await esperarEntradaWeb();
+            stopYaForzado = false;
+            renderUserPrompt(userInput);
+        }
         else {
             try {
                 userInput = await askInteractivePrompt(isPlanMode ? chalk.cyan("plan ❯") : "❯", agent.currentCwd);
@@ -421,15 +520,15 @@ ${nodeViejo}
                 .filter((m) => m.role === "user" || m.role === "assistant")
                 .map((m) => `### 👤 ${m.role === "user" ? "Usuario" : "Chocolatito"}\n\n${typeof m.content === "string" ? m.content : JSON.stringify(m.content, null, 2)}\n`)
                 .join("\n---\n\n");
-            const mdContent = `# 🦊 Bitácora de Sesión — Chocolatito Code
-**Fecha:** ${new Date().toLocaleString()}  
-**Directorio:** \`${agent.currentCwd}\`  
-**Motor:** ${currentModel.name}  
-**Inversión Total:** ${agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel).formattedCost}  
-
----
-
-${sessionData}
+            const mdContent = `# 🦊 Bitácora de Sesión — Chocolatito Code
+**Fecha:** ${new Date().toLocaleString()}  
+**Directorio:** \`${agent.currentCwd}\`  
+**Motor:** ${currentModel.name}  
+**Inversión Total:** ${agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel).formattedCost}  
+
+---
+
+${sessionData}
 `;
             fs.writeFileSync(exportPath, mdContent, "utf-8");
             console.log(chalk.green(`\n✔ Bitácora exportada exitosamente en: ${chalk.bold.white(exportPath)}\n`));
@@ -440,7 +539,27 @@ ${sessionData}
             continue;
         }
         if (trimmed.startsWith("/resume")) {
-            const targetId = trimmed.slice(7).trim();
+            let targetId = trimmed.slice(7).trim();
+            if (!targetId) {
+                const detailedSessions = sessionManager.listSessionsDetailed();
+                if (detailedSessions.length === 0) {
+                    console.log(chalk.yellow("\n⚠ No hay sesiones guardadas previas.\n"));
+                    continue;
+                }
+                if (process.stdin.isTTY) {
+                    const opciones = formatearOpcionesDeSesion(detailedSessions);
+                    const elegido = await elegirDeLista("REANUDAR SESIÓN — CHOCOLATITO CODE", opciones);
+                    if (elegido === null) {
+                        continue;
+                    }
+                    targetId = elegido;
+                }
+                else {
+                    const latest = sessionManager.loadLatestSession();
+                    if (latest)
+                        targetId = latest.id;
+                }
+            }
             const loaded = targetId ? sessionManager.loadSession(targetId) : sessionManager.loadLatestSession();
             if (loaded) {
                 // Se restaura la conversacion, no el entorno. El array guardado trae en
@@ -523,12 +642,12 @@ ${sessionData}
             }
             console.log(chalk.bold.hex("#A855F7")("\n🎯 INICIANDO MODO META AUTÓNOMA (GOAL MODE):"));
             console.log(chalk.gray(`  Objetivo: "${goalText}"\n`));
-            const autonomousPrompt = `[MODO META AUTÓNOMA ACTIVADO]
-Tu objetivo principal es: "${goalText}"
-Directivas de ejecución:
-1. Formula un plan de ejecución mental paso a paso.
-2. Ejecuta cada paso utilizando las herramientas correspondientes (creación, edición, ejecución, verificación).
-3. Si algo falla o hay errores, autocorregir inmediatamente y volver a probar.
+            const autonomousPrompt = `[MODO META AUTÓNOMA ACTIVADO]
+Tu objetivo principal es: "${goalText}"
+Directivas de ejecución:
+1. Formula un plan de ejecución mental paso a paso.
+2. Ejecuta cada paso utilizando las herramientas correspondientes (creación, edición, ejecución, verificación).
+3. Si algo falla o hay errores, autocorregir inmediatamente y volver a probar.
 4. No te detengas hasta verificar que el objetivo esté 100% completado con éxito.`;
             renderUserPrompt(`/goal ${goalText}`);
             await agent.runTask(autonomousPrompt);
@@ -554,6 +673,11 @@ Directivas de ejecución:
             console.log(diffOut ? chalk.gray(diffOut) : chalk.green("✔ Sin cambios pendientes.") + "\n");
             continue;
         }
+        if (trimmed === "/audit" || trimmed === "/review" || trimmed.startsWith("/audit ") || trimmed.startsWith("/review ")) {
+            const report = await auditGitDiff(agent.currentCwd);
+            console.log(formatAuditReport(report));
+            continue;
+        }
         if (trimmed.startsWith("/commit")) {
             const msg = trimmed.slice(7).trim();
             if (!msg) {
@@ -570,6 +694,7 @@ Directivas de ejecución:
             const res = await changeDir(target, agent.currentCwd);
             if (res.success) {
                 agent.currentCwd = res.newCwd;
+                memoryManager.setCwd(agent.currentCwd);
                 const refreshedContext = await getProjectContext(agent.currentCwd);
                 systemPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
                 agent.clearHistory(systemPrompt);
@@ -632,12 +757,12 @@ Directivas de ejecución:
             const refreshedContext = await getProjectContext(agent.currentCwd);
             const updatedPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
             agent.setEspectroModel(currentModel, updatedPrompt);
-            console.log(chalk.green(`
+            console.log(chalk.green(`
 ✔ Nivel actualizado a `) +
                 chalk.bold.hex("#A855F7")(currentModel.name) +
                 chalk.gray(` (${currentModel.effortLevel})`) +
-                `
-  ${chalk.italic.gray(currentModel.description)}
+                `
+  ${chalk.italic.gray(currentModel.description)}
 `);
             // EL TECLADO SE QUEDABA TRABADO AL CAMBIAR DE MOTOR
             //

package/dist/memory/manager.d.ts

@@ -1,9 +1,19 @@
+export type MemoryScope = "project" | "global";
 export declare class MemoryManager {
-    private memoryDir;
-    private memoryIndexPath;
-    constructor();
+    private cwd;
+    constructor(cwd?: string);
+    setCwd(cwd: string): void;
+    getCwd(): string;
+    private getGlobalDir;
+    private getProjectDir;
+    private isSamePath;
+    private isProjectCwdValid;
+    private resolveScope;
+    private getDirForScope;
     private ensureDirectory;
+    private sanitizeTopic;
+    private readIndexEntries;
     getMemoryIndex(): string;
-    saveMemory(topic: string, fact: string): string;
-    readMemory(topic: string): string;
+    saveMemory(topic: string, fact: string, scope?: MemoryScope): string;
+    readMemory(topic: string, scope?: MemoryScope): string;
 }

package/dist/memory/manager.js

@@ -2,35 +2,118 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 export class MemoryManager {
-    memoryDir;
-    memoryIndexPath;
-    constructor() {
-        this.memoryDir = path.join(os.homedir(), ".chocolatito", "memory");
-        this.memoryIndexPath = path.join(this.memoryDir, "MEMORY.md");
-        this.ensureDirectory();
+    cwd;
+    constructor(cwd = process.cwd()) {
+        this.cwd = path.resolve(cwd || process.cwd());
     }
-    ensureDirectory() {
-        if (!fs.existsSync(this.memoryDir)) {
-            fs.mkdirSync(this.memoryDir, { recursive: true });
-        }
-        if (!fs.existsSync(this.memoryIndexPath)) {
-            const defaultIndex = `# 🧠 Memoria Persistente de Chocolatito Code\n\nEste archivo indexa hechos, preferencias del usuario y aprendizajes clave entre proyectos.\n\n- [Preferencias Generales](./preferences.md): Preferencias de desarrollo y estilo.\n`;
-            fs.writeFileSync(this.memoryIndexPath, defaultIndex, "utf-8");
+    setCwd(cwd) {
+        this.cwd = path.resolve(cwd || process.cwd());
+    }
+    getCwd() {
+        return this.cwd;
+    }
+    getGlobalDir() {
+        return path.join(os.homedir(), ".chocolatito", "memory");
+    }
+    getProjectDir() {
+        return path.join(this.cwd, ".chocolatito", "memory");
+    }
+    isSamePath(p1, p2) {
+        const r1 = path.resolve(p1);
+        const r2 = path.resolve(p2);
+        if (process.platform === "win32") {
+            return r1.toLowerCase() === r2.toLowerCase();
         }
+        return r1 === r2;
     }
-    getMemoryIndex() {
-        this.ensureDirectory();
+    isProjectCwdValid() {
+        if (!this.cwd || typeof this.cwd !== "string")
+            return false;
         try {
-            return fs.readFileSync(this.memoryIndexPath, "utf-8");
+            if (this.isSamePath(this.cwd, os.homedir())) {
+                return false;
+            }
+            return true;
         }
         catch {
+            return false;
+        }
+    }
+    resolveScope(scope) {
+        if (scope === "project" || scope === "global") {
+            return scope;
+        }
+        return this.isProjectCwdValid() ? "project" : "global";
+    }
+    getDirForScope(scope) {
+        return scope === "project" ? this.getProjectDir() : this.getGlobalDir();
+    }
+    ensureDirectory(scope) {
+        const dir = this.getDirForScope(scope);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        return dir;
+    }
+    sanitizeTopic(topic) {
+        return topic.toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+    }
+    readIndexEntries(dir) {
+        if (!fs.existsSync(dir))
+            return null;
+        const indexPath = path.join(dir, "MEMORY.md");
+        if (fs.existsSync(indexPath)) {
+            const content = fs.readFileSync(indexPath, "utf-8").trim();
+            const lines = content
+                .split("\n")
+                .map((l) => l.trim())
+                .filter((l) => l.length > 0 && (l.startsWith("-") || l.startsWith("*")));
+            if (lines.length > 0) {
+                return lines.join("\n");
+            }
+            if (content.length > 0) {
+                return content;
+            }
+        }
+        try {
+            const files = fs
+                .readdirSync(dir)
+                .filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
+            if (files.length > 0) {
+                return files
+                    .map((f) => {
+                    const topic = f.replace(/\.md$/, "");
+                    return `- [${topic}](./${f}): Registro de ${topic}.`;
+                })
+                    .join("\n");
+            }
+        }
+        catch { }
+        return null;
+    }
+    getMemoryIndex() {
+        const isProjectValid = this.isProjectCwdValid();
+        const projectEntries = isProjectValid ? this.readIndexEntries(this.getProjectDir()) : null;
+        const globalEntries = this.readIndexEntries(this.getGlobalDir());
+        const hasProject = Boolean(projectEntries);
+        const hasGlobal = Boolean(globalEntries);
+        if (!hasProject && !hasGlobal) {
             return "Sin memoria previa.";
         }
+        const projectSection = hasProject
+            ? projectEntries
+            : "Sin notas locales para este proyecto.";
+        const globalSection = hasGlobal
+            ? globalEntries
+            : "Sin preferencias globales.";
+        return `Memoria del Proyecto (.chocolatito/memory/):\n${projectSection}\n\nPreferencias Globales (~/.chocolatito/memory/):\n${globalSection}`;
     }
-    saveMemory(topic, fact) {
-        this.ensureDirectory();
-        const sanitized = topic.toLowerCase().replace(/[^a-z0-9_-]/g, "_");
-        const filePath = path.join(this.memoryDir, `${sanitized}.md`);
+    saveMemory(topic, fact, scope) {
+        const resolvedScope = this.resolveScope(scope);
+        const dir = this.ensureDirectory(resolvedScope);
+        const sanitized = this.sanitizeTopic(topic);
+        const filePath = path.join(dir, `${sanitized}.md`);
+        const indexPath = path.join(dir, "MEMORY.md");
         const timestamp = new Date().toISOString().split("T")[0];
         const entry = `\n- [${timestamp}] ${fact}`;
         if (fs.existsSync(filePath)) {
@@ -40,19 +123,53 @@ export class MemoryManager {
             fs.writeFileSync(filePath, `# Memoria: ${topic}\n${entry}\n`, "utf-8");
         }
         // Update MEMORY.md index if not already present
-        const indexContent = fs.readFileSync(this.memoryIndexPath, "utf-8");
+        let indexContent = "";
+        if (fs.existsSync(indexPath)) {
+            indexContent = fs.readFileSync(indexPath, "utf-8");
+        }
         if (!indexContent.includes(`${sanitized}.md`)) {
             const link = `- [${topic}](./${sanitized}.md): Registro de ${topic}.\n`;
-            fs.appendFileSync(this.memoryIndexPath, link, "utf-8");
+            fs.appendFileSync(indexPath, link, "utf-8");
+        }
+        if (resolvedScope === "project") {
+            return `✔ Hecho guardado en memoria local de proyecto (.chocolatito/memory/${sanitized}.md).`;
+        }
+        else {
+            return `✔ Hecho guardado en memoria global (~/.chocolatito/memory/${sanitized}.md).`;
         }
-        return `✔ Hecho guardado en memoria persistente (~/.chocolatito/memory/${sanitized}.md).`;
     }
-    readMemory(topic) {
-        this.ensureDirectory();
-        const sanitized = topic.toLowerCase().replace(/[^a-z0-9_-]/g, "_");
-        const filePath = path.join(this.memoryDir, `${sanitized}.md`);
-        if (fs.existsSync(filePath)) {
-            return fs.readFileSync(filePath, "utf-8");
+    readMemory(topic, scope) {
+        const sanitized = this.sanitizeTopic(topic);
+        if (scope === "project") {
+            const pPath = path.join(this.getProjectDir(), `${sanitized}.md`);
+            if (fs.existsSync(pPath)) {
+                return fs.readFileSync(pPath, "utf-8");
+            }
+            return `No hay memoria registrada para el tema "${topic}" en el proyecto.`;
+        }
+        if (scope === "global") {
+            const gPath = path.join(this.getGlobalDir(), `${sanitized}.md`);
+            if (fs.existsSync(gPath)) {
+                return fs.readFileSync(gPath, "utf-8");
+            }
+            return `No hay memoria registrada para el tema "${topic}" en la memoria global.`;
+        }
+        // Sin scope especificado: buscar primero en proyecto, luego en global
+        const sameDir = this.isSamePath(this.getProjectDir(), this.getGlobalDir());
+        const pPath = path.join(this.getProjectDir(), `${sanitized}.md`);
+        const gPath = path.join(this.getGlobalDir(), `${sanitized}.md`);
+        const pExists = this.isProjectCwdValid() && fs.existsSync(pPath);
+        const gExists = !sameDir && fs.existsSync(gPath);
+        if (pExists && gExists) {
+            const pContent = fs.readFileSync(pPath, "utf-8").trim();
+            const gContent = fs.readFileSync(gPath, "utf-8").trim();
+            return `[Memoria de Proyecto]\n${pContent}\n\n[Memoria Global]\n${gContent}`;
+        }
+        if (pExists) {
+            return fs.readFileSync(pPath, "utf-8");
+        }
+        if (gExists || (sameDir && fs.existsSync(gPath))) {
+            return fs.readFileSync(gPath, "utf-8");
         }
         return `No hay memoria registrada para el tema "${topic}".`;
     }

package/dist/servidor/captura.d.ts

@@ -0,0 +1,36 @@
+/**
+ * LO QUE SE ESCRIBE, COPIADO PARA EL NAVEGADOR
+ *
+ * No se redirige nada: se COPIA. El terminal sigue recibiendo exactamente lo
+ * mismo que antes, porque quien arranca `--servir` normalmente lo deja abierto
+ * en su PC y lo mira desde ahi tambien. Si esto desviara la salida, el que esta
+ * delante de la maquina se quedaria sin ver su propia sesion.
+ *
+ * POR QUE SE ENVUELVE `console` Y NO `process.stdout`
+ *
+ * Ya esta decidido en ui/salida.ts y ui/pantalla.ts, y por las razones buenas:
+ * sustituir process.stdout hace desaparecer pruebas del informe de `node --test`
+ * sin que fallen. Aqui se envuelve console, que es otro objeto y no tiene ese
+ * problema.
+ *
+ * EL ORDEN IMPORTA, Y ES LA UNICA TRAMPA DE ESTE ARCHIVO
+ *
+ * ui/pantalla.ts:144 ya reemplaza los cuatro canales para mandarlos a la
+ * transcripcion de Ink. Esto tiene que envolverse DESPUES de eso: asi lo que se
+ * llama es la version de pantalla (el terminal sigue pintando) y de paso se
+ * copia. Al reves, pantalla envolveria a esto y la copia no se enteraria de
+ * nada. Por eso en index.ts la captura arranca despues de entrarEnPantallaFija.
+ */
+export interface LineaWeb {
+    /** Estable y creciente. El navegador lo usa para no repetir lineas al reconectar. */
+    id: number;
+    texto: string;
+}
+/** Mete una linea propia (avisos del servidor, eco de lo que llega del movil). */
+export declare function anotarWeb(texto: string): void;
+export declare function iniciarCaptura(): void;
+export declare function detenerCaptura(): void;
+export declare function historialWeb(desde?: number): LineaWeb[];
+export declare function alEscribirWeb(cb: (linea: LineaWeb) => void): () => void;
+/** Solo para pruebas: deja el modulo como recien cargado. */
+export declare function vaciarCaptura(): void;

package/dist/servidor/captura.js

@@ -0,0 +1,74 @@
+import { format } from "node:util";
+const CANALES = ["log", "error", "warn", "info"];
+/**
+ * Tope del historial. Es para el que abre el movil a mitad de sesion y quiere
+ * contexto, no un registro completo: eso ya lo tiene el terminal de verdad.
+ */
+const MAX_LINEAS = 1_000;
+let lineas = [];
+let siguienteId = 1;
+const oyentes = new Set();
+const previos = new Map();
+/** Reentrada: si un oyente escribe por consola, no se vuelve a capturar. */
+let dentro = false;
+function guardar(texto) {
+    for (const trozo of texto.replace(/\r\n/g, "\n").split("\n")) {
+        const linea = { id: siguienteId++, texto: trozo };
+        lineas.push(linea);
+        if (lineas.length > MAX_LINEAS)
+            lineas = lineas.slice(-MAX_LINEAS);
+        for (const cb of oyentes) {
+            try {
+                cb(linea);
+            }
+            catch {
+                // Un cliente que se cae no puede tumbar la salida de la sesion.
+            }
+        }
+    }
+}
+/** Mete una linea propia (avisos del servidor, eco de lo que llega del movil). */
+export function anotarWeb(texto) {
+    guardar(texto);
+}
+export function iniciarCaptura() {
+    if (previos.size)
+        return;
+    for (const nombre of CANALES) {
+        const previo = console[nombre].bind(console);
+        previos.set(nombre, previo);
+        console[nombre] = (...args) => {
+            previo(...args);
+            if (dentro)
+                return;
+            dentro = true;
+            try {
+                guardar(format(...args));
+            }
+            finally {
+                dentro = false;
+            }
+        };
+    }
+}
+export function detenerCaptura() {
+    for (const nombre of CANALES) {
+        const previo = previos.get(nombre);
+        if (previo)
+            console[nombre] = previo;
+    }
+    previos.clear();
+}
+export function historialWeb(desde = 0) {
+    return desde ? lineas.filter((l) => l.id > desde) : lineas.slice();
+}
+export function alEscribirWeb(cb) {
+    oyentes.add(cb);
+    return () => oyentes.delete(cb);
+}
+/** Solo para pruebas: deja el modulo como recien cargado. */
+export function vaciarCaptura() {
+    lineas = [];
+    siguienteId = 1;
+    oyentes.clear();
+}