atena-cli 0.1.0

package/dist/core/agent.js

@@ -0,0 +1,1280 @@
+import pc from 'picocolors';
+import wrapAnsi from 'wrap-ansi';
+import { OllamaClient } from './ollama-client.js';
+import { edenAISDK } from './eden-ai-sdk.js';
+import { providerManager } from './providers.js';
+import { tools, toolMap } from './tools/index.js';
+import { dynamicToolRegistry } from './tools/dynamic/registry.js';
+import { eventHub } from './events.js';
+import readline from 'node:readline';
+import { SpinnerManager, renderHeader, renderStatusBar, 
+// renderWelcome removed, using renderHeader instead
+renderUserMessage, renderAssistantMessage, renderToolCall, renderToolResult, renderSystemMessage, colors, icons, boxify, getActiveThemeName, listThemes as getThemeList, setTheme as applyTheme, saveThemePreference, progressBar, } from '../cli/ui.js';
+import { ContextManager } from './context.js';
+import { sessionManager } from './sessions.js';
+import { parseSlashCommand, parseMentions } from './commands.js';
+import { realtimeInput } from '../cli/realtime-input.js';
+import { detectSkills, getActiveSkillsInfo, buildEnhancedPrompt } from './skills.js';
+import { AgentManager, formatAgentName } from './agents.js';
+import { SessionManager } from './sessions.js';
+import { PermissionManager, parsePermissionsFromEnv } from './permissions.js';
+import { statsTracker } from './stats.js';
+import { MCPManager } from './mcp.js';
+import { TaskManager } from './tasks.js';
+import { NotificationManager } from './notifications.js';
+import { WorkflowManager } from './workflows.js';
+import { TelegramBotManager } from './telegram.js';
+import { SandboxManager } from './sandbox.js';
+import { CodeIndexer } from './code_indexer.js';
+import { analyticsEngine } from './analytics.js';
+import { SwarmManager } from './swarm_manager.js';
+import { consensusManager } from './consensus.js';
+import { PredictiveHealingEngine } from './nexus.js';
+import { sageMemory } from './memory.js';
+import { TaskOrchestrator } from './orchestrator.js';
+export class EdenAgent {
+    client;
+    options;
+    messages = [];
+    transcript = [];
+    ollamaTools;
+    spinner;
+    context;
+    agentManager;
+    sessionManager;
+    permissionManager;
+    statsTracker;
+    mcpManager;
+    taskManager;
+    notificationManager;
+    workflowManager;
+    telegramManager;
+    sandboxManager;
+    swarmManager;
+    nexus;
+    codeIndexer;
+    orchestrator;
+    heartbeatInterval = null;
+    pendingApprovals = new Map();
+    shouldExit = false;
+    totalTasks = 0;
+    completedTasks = 0;
+    isProcessingPlan = false;
+    currentAbortController = null;
+    constructor(options) {
+        this.options = options;
+        this.client = new OllamaClient(options.ollamaUrl);
+        this.ollamaTools = this.client.toOllamaTools(tools.map(t => t.definition));
+        this.spinner = new SpinnerManager();
+        this.context = new ContextManager();
+        this.agentManager = new AgentManager('build');
+        this.sessionManager = new SessionManager();
+        // Initialize PermissionManager with agent permissions (override env vars)
+        const envPermissions = parsePermissionsFromEnv();
+        const agentPermissions = this.agentManager.getCurrentAgent().permissions;
+        const mergedPermissions = { ...envPermissions, ...agentPermissions };
+        this.permissionManager = new PermissionManager(mergedPermissions);
+        this.statsTracker = statsTracker;
+        this.statsTracker.startSession(`session_${Date.now()}`, options.model);
+        this.mcpManager = new MCPManager();
+        this.taskManager = new TaskManager();
+        this.notificationManager = new NotificationManager();
+        this.workflowManager = new WorkflowManager();
+        this.telegramManager = new TelegramBotManager(this);
+        this.sandboxManager = new SandboxManager({ dryRun: false, useDocker: false });
+        this.swarmManager = new SwarmManager(this.sandboxManager);
+        this.codeIndexer = new CodeIndexer(options.cwd);
+        this.nexus = new PredictiveHealingEngine(this.codeIndexer, sageMemory);
+        this.orchestrator = new TaskOrchestrator(this, options.cwd);
+        this.orchestrator.initialize().catch(e => console.error('Orchestrator init error:', e));
+        // Set quiet mode on registry and event hub if specified
+        if (options.quiet) {
+            dynamicToolRegistry.setQuiet(true);
+            eventHub.setQuiet(true);
+        }
+        // Background index
+        this.codeIndexer.indexWorkspace().catch(e => console.error('Indexing error:', e));
+        if (options.systemPrompt) {
+            const base = `ATENA ORCHESTRATOR | v3.0
+- ORQUESTA especialistas (Build, Plan, Debug, Explore).
+- SEGURIDAD: Sandbox total; gating preventivo obligatorio.
+- PRECISIÓN: Acceso absoluto al repo. Prohibido alucinar.
+${options.systemPrompt}`;
+            const effectivePrompt = this.agentManager.getEffectiveSystemPrompt(base);
+            this.messages.push({ role: 'system', content: effectivePrompt });
+        }
+        if (options.telegramToken) {
+            this.telegramManager.start(options.telegramToken);
+        }
+        this.startHeartbeat();
+        this.initSession();
+        this.setupInterruptHandler();
+    }
+    setupInterruptHandler() {
+        process.on('SIGINT', () => {
+            if (this.currentAbortController) {
+                this.currentAbortController.abort();
+                this.currentAbortController = null;
+                console.log(`\n  ${colors.warning(icons.warning)} Respuesta cancelada por el usuario.\n`);
+            }
+        });
+    }
+    async initSession() {
+        try {
+            const session = await sessionManager.createSession(this.messages, this.options.model, 'Eden', this.options.cwd);
+            this.sessionManager.setCurrentSessionId(session.id);
+        }
+        catch (err) {
+            // Non-critical
+        }
+    }
+    async persistSession() {
+        try {
+            await sessionManager.updateCurrentSession(this.messages);
+        }
+        catch (err) {
+            // Non-critical
+        }
+    }
+    startHeartbeat() {
+        if (this.heartbeatInterval)
+            return;
+        this.heartbeatInterval = setInterval(() => this.onHeartbeat(), 30000); // Every 30s
+    }
+    onHeartbeat() {
+        // Check for stale tasks, cleanup, or notify pending approvals
+        const runningTasks = this.taskManager.listTasks().filter(t => t.status === 'running');
+        if (runningTasks.length > 0) {
+            this.notificationManager.notify('Heartbeat Check', `Hay ${runningTasks.length} tareas activas ejecutándose.`, 'info');
+        }
+    }
+    stop() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+        this.telegramManager.stop();
+    }
+    getCodeIndexer() {
+        return this.codeIndexer;
+    }
+    getSandboxManager() {
+        return this.sandboxManager;
+    }
+    getAgentManager() {
+        return this.agentManager;
+    }
+    getTelegramManager() {
+        return this.telegramManager;
+    }
+    renderAgentStatus() {
+        const agent = this.agentManager.getCurrentAgent();
+        console.log(); // Space above
+        console.log(colors.muted(`  ${icons.agent} Agente: ${formatAgentName(agent)} | Tab para cambiar`));
+        console.log(); // Space below
+    }
+    switchAgent(agentId) {
+        const success = this.agentManager.switchAgent(agentId);
+        if (success) {
+            const agent = this.agentManager.getCurrentAgent();
+            console.log(colors.success(`  [OK] Cambiado a agente: ${formatAgentName(agent)}`));
+            eventHub.emitEvent({ type: 'agent_switched', data: { agentId: agent.id } });
+            // Update PermissionManager with new agent permissions
+            this.permissionManager.setPermissions(agent.permissions);
+            if (this.messages.length > 0 && this.messages[0].role === 'system') {
+                const basePrompt = this.options.systemPrompt || '';
+                this.messages[0].content = this.agentManager.getEffectiveSystemPrompt(basePrompt, this.options.cwd);
+            }
+        }
+        return success;
+    }
+    listAgents() {
+        console.log(colors.primary('\n  Agentes disponibles:'));
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        for (const agent of this.agentManager.listAgents()) {
+            const isCurrent = agent.id === this.agentManager.getCurrentAgent().id;
+            const marker = isCurrent ? colors.success('● ') : '  ';
+            console.log(`${marker}${formatAgentName(agent)} - ${colors.muted(agent.description)}`);
+        }
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        console.log(colors.muted('  Usa: /agent <nombre> para cambiar\n'));
+    }
+    // Orchestrator methods
+    async executeOrchestratedTask(prompt) {
+        const task = await this.orchestrator.planTask(prompt);
+        await this.orchestrator.executeAll();
+    }
+    getOrchestratorProgress() {
+        return this.orchestrator.getProgress();
+    }
+    shouldUseOrchestrator(prompt) {
+        const lowerPrompt = prompt.toLowerCase();
+        // Verbos de acción directa que disparan ejecución
+        const actionVerbs = [
+            'haz', 'hazme', 'crea', 'creame', 'pon', 'instala', 'configura',
+            'arregla', 'fix', 'crear', 'hacer', 'build', 'setup', 'inicializar',
+            'genera', 'generame'
+        ];
+        const complexityIndicators = [
+            'portfolio', 'web', 'website', 'landing', 'application', 'app',
+            'componente', 'seccion', 'interfaz', 'ui', 'bot', 'script',
+            'sistema', 'dashboard', 'lista', 'backend', 'frontend'
+        ];
+        const hasAction = actionVerbs.some(verb => lowerPrompt.includes(verb));
+        const hasComplexity = complexityIndicators.some(ind => lowerPrompt.includes(ind));
+        // Si tiene un verbo de acción o es algo complejo, orquestamos de una.
+        return hasAction || hasComplexity || lowerPrompt.length > 800;
+    }
+    // Session management methods
+    async listSessions() {
+        const sessions = await this.sessionManager.listSessions(10);
+        if (sessions.length === 0) {
+            console.log(colors.muted('\n  No hay sesiones guardadas.\n'));
+            return;
+        }
+        console.log(colors.primary('\n  Sesiones recientes:'));
+        console.log(colors.muted('  ' + '─'.repeat(60)));
+        for (let i = 0; i < sessions.length; i++) {
+            const session = sessions[i];
+            const date = new Date(session.updatedAt).toLocaleString('es-ES', {
+                day: '2-digit',
+                month: 'short',
+                hour: '2-digit',
+                minute: '2-digit',
+            });
+            console.log(`  ${i + 1}. ${colors.cyan(session.title)}`);
+            console.log(`     ${colors.muted(`Modelo: ${session.model} | Mensajes: ${session.messageCount} | ${date}`)}`);
+            if (session.preview) {
+                console.log(`     ${colors.dim(session.preview)}`);
+            }
+        }
+        console.log(colors.muted('  ' + '─'.repeat(60)));
+        console.log(colors.muted('  Usa: /session load <número> para cargar\n'));
+    }
+    async saveSession(name) {
+        const currentId = this.sessionManager.getCurrentSessionId();
+        if (currentId) {
+            // Update existing session
+            await this.sessionManager.updateCurrentSession(this.messages);
+            console.log(colors.success(`  [OK] Sesion actualizada: ${colors.cyan(currentId)}`));
+        }
+        else {
+            // Create new session
+            const session = await this.sessionManager.createSession(this.messages, this.options.model, this.agentManager.getCurrentAgent().id, process.cwd());
+            this.sessionManager.setCurrentSessionId(session.id);
+            console.log(colors.success(`  [OK] Sesion guardada: ${colors.cyan(session.title)}`));
+        }
+    }
+    async loadSession(indexOrId) {
+        let session = null;
+        // Check if it's a number (index from list)
+        const index = parseInt(indexOrId, 10);
+        if (!isNaN(index) && index > 0) {
+            const sessions = await this.sessionManager.listSessions(10);
+            if (index <= sessions.length) {
+                session = await this.sessionManager.loadSession(sessions[index - 1].id);
+            }
+        }
+        else {
+            // Treat as ID
+            session = await this.sessionManager.loadSession(indexOrId);
+        }
+        if (!session) {
+            console.log(colors.error(`  XX No se encontro la sesion: ${indexOrId}`));
+            return;
+        }
+        // Load session data
+        this.messages = session.messages;
+        this.options.model = session.model;
+        this.sessionManager.setCurrentSessionId(session.id);
+        // Switch to the agent used in the session
+        if (session.metadata.agent) {
+            this.agentManager.switchAgent(session.metadata.agent);
+        }
+        console.log(colors.success(`  [OK] Sesion cargada: ${colors.cyan(session.title)}`));
+        console.log(colors.muted(`     Modelo: ${session.model} | Mensajes: ${session.messages.length}`));
+    }
+    async exportSession(sessionId) {
+        const id = sessionId || this.sessionManager.getCurrentSessionId();
+        if (!id) {
+            console.log(colors.error('  XX No hay sesion activa para exportar'));
+            return;
+        }
+        const exportPath = await this.sessionManager.exportSession(id);
+        if (exportPath) {
+            console.log(colors.success(`  [OK] Sesion exportada a: ${colors.cyan(exportPath)}`));
+        }
+        else {
+            console.log(colors.error('  XX Error al exportar sesion'));
+        }
+    }
+    setCwd(newCwd) {
+        this.options.cwd = newCwd;
+        console.log(colors.muted(`  ${icons.folder} Directorio de trabajo cambiado a: ${newCwd}`));
+    }
+    getCwd() {
+        return this.options.cwd;
+    }
+    async deleteSession(sessionId) {
+        const success = await this.sessionManager.deleteSession(sessionId);
+        if (success) {
+            console.log(colors.success(`  [OK] Sesion eliminada: ${colors.cyan(sessionId)}`));
+        }
+        else {
+            console.log(colors.error(`  XX No se pudo eliminar la sesion: ${sessionId}`));
+        }
+    }
+    // MCP management methods
+    async listMCPServers() {
+        const servers = this.mcpManager.listServers();
+        const connections = this.mcpManager.listConnections();
+        if (servers.length === 0) {
+            console.log(colors.muted('\n  No hay servidores MCP configurados.\n'));
+            console.log(colors.muted('  Usa: /mcp add para agregar uno\n'));
+            return;
+        }
+        console.log(colors.primary('\n  Servidores MCP:'));
+        console.log(colors.muted('  ' + '─'.repeat(60)));
+        for (const server of servers) {
+            const connection = connections.find(c => c.name === server.name);
+            const authStatus = this.mcpManager.getAuthStatus(server.name);
+            let statusIcon = '○';
+            let statusColor = colors.muted;
+            if (connection?.status === 'connected') {
+                statusIcon = '*';
+                statusColor = colors.success;
+            }
+            else if (connection?.status === 'error') {
+                statusIcon = 'XX';
+                statusColor = colors.error;
+            }
+            console.log(`  ${statusColor(statusIcon)} ${colors.cyan(server.name)} (${server.type})`);
+            console.log(`     ${colors.muted(`Habilitado: ${server.enabled ? 'sí' : 'no'}`)}`);
+            if (authStatus.hasOAuth) {
+                console.log(`     ${colors.muted(`Auth: ${authStatus.authenticated ? 'OK' : '-'}`)}`);
+            }
+            if (connection?.tools.length) {
+                console.log(`     ${colors.muted(`Tools: ${connection.tools.join(', ')}`)}`);
+            }
+        }
+        console.log(colors.muted('  ' + '─'.repeat(60)));
+    }
+    async addMCPServer() {
+        await this.mcpManager.setupWizard();
+        console.log(colors.success('\n  [OK] MCP setup wizard started'));
+        console.log(colors.muted('  (Full implementation requires manual configuration)\n'));
+    }
+    async authenticateMCP(serverName) {
+        const success = await this.mcpManager.authenticate(serverName);
+        if (success) {
+            console.log(colors.success(`  [OK] Authenticated with: ${colors.cyan(serverName)}`));
+        }
+        else {
+            console.log(colors.error(`  XX Authentication failed with: ${serverName}`));
+        }
+    }
+    async removeMCPServer(serverName) {
+        const success = await this.mcpManager.removeServer(serverName);
+        if (success) {
+            console.log(colors.success(`  [OK] MCP server removed: ${colors.cyan(serverName)}`));
+        }
+        else {
+            console.log(colors.error(`  XX Server not found: ${serverName}`));
+        }
+    }
+    // Permission management methods
+    async setPermission(type, level) {
+        const validLevels = ['ask', 'auto', 'deny'];
+        if (!validLevels.includes(level)) {
+            console.log(colors.error(`  XX Invalid level. Use: ask, auto, deny`));
+            return;
+        }
+        this.permissionManager.setPermissions({ [type]: level });
+        console.log(colors.success(`  [OK] Permission ${type} set to: ${level}`));
+    }
+    showPermissions() {
+        const perms = this.permissionManager.getPermissions();
+        console.log(colors.primary('\n  Current permissions:'));
+        console.log(colors.muted('  ' + '-'.repeat(40)));
+        console.log(colors.muted('  ' + '─'.repeat(40)));
+        console.log(`  fileWrite: ${perms.fileWrite}`);
+        console.log(`  fileDelete: ${perms.fileDelete}`);
+        console.log(`  bash: ${perms.bash}`);
+        console.log(`  network: ${perms.network}`);
+        console.log(colors.muted('  ' + '─'.repeat(40)));
+        console.log(colors.muted('  Usa: /permission <tipo> <nivel>\n'));
+    }
+    async showStats() {
+        const stats = await this.statsTracker.getStats(7);
+        console.log(colors.primary('\n  Stats uso (ultimos 7 dias):'));
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        console.log(`  Sesiones: ${colors.cyan(stats.totalSessions.toString())}`);
+        console.log(`  Tokens totales: ${colors.cyan(this.statsTracker.formatTokens(stats.totalTokens))}`);
+        console.log(`  Costo estimado: ${colors.cyan(this.statsTracker.formatCurrency(stats.totalCost))}`);
+        if (Object.keys(stats.modelBreakdown).length > 0) {
+            console.log(colors.muted('  ' + '─'.repeat(50)));
+            console.log(colors.primary('  Por modelo:'));
+            for (const [model, data] of Object.entries(stats.modelBreakdown)) {
+                console.log(`    ${colors.cyan(model)}: ${this.statsTracker.formatTokens(data.tokens)} tokens, ${this.statsTracker.formatCurrency(data.cost)}`);
+            }
+        }
+        if (Object.keys(stats.toolBreakdown).length > 0) {
+            console.log(colors.muted('  ' + '─'.repeat(50)));
+            console.log(colors.primary('  Tools más usados:'));
+            const sortedTools = Object.entries(stats.toolBreakdown).sort((a, b) => b[1] - a[1]).slice(0, 5);
+            for (const [tool, count] of sortedTools) {
+                console.log(`    ${colors.cyan(tool)}: ${count} usos`);
+            }
+        }
+        // Current session stats
+        const currentStats = this.statsTracker.getCurrentSessionStats();
+        if (currentStats) {
+            console.log(colors.muted('  ' + '─'.repeat(50)));
+            console.log(colors.primary('  Sesión actual:'));
+            console.log(`    Tokens: ${this.statsTracker.formatTokens(currentStats.tokenUsage.totalTokens)}`);
+            console.log(`    Costo: ${this.statsTracker.formatCurrency(currentStats.tokenUsage.cost)}`);
+            console.log(`    Mensajes: ${currentStats.messages}`);
+        }
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        console.log();
+    }
+    showStatus() {
+        const agent = this.agentManager.getCurrentAgent();
+        const perms = this.permissionManager.getPermissions();
+        const currentStats = this.statsTracker.getCurrentSessionStats();
+        const fileCount = this.context.getAttachmentCount();
+        console.log(colors.primary('\n  Estado actual de Eden CLI'));
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        console.log(`  Modelo:    ${colors.cyan(this.options.model)}`);
+        console.log(`  Agente:    ${formatAgentName(agent)}`);
+        console.log(`  CWD:       ${colors.muted(this.options.cwd)}`);
+        console.log(`  Archivos:  ${fileCount > 0 ? colors.cyan(String(fileCount)) : colors.muted('0')}`);
+        if (currentStats) {
+            console.log(`  Mensajes:  ${colors.cyan(String(currentStats.messages))}`);
+            console.log(`  Tokens:    ${colors.cyan(this.statsTracker.formatTokens(currentStats.tokenUsage.totalTokens))}`);
+        }
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        console.log(`  Permisos:  write=${perms.fileWrite} | delete=${perms.fileDelete} | bash=${perms.bash} | net=${perms.network}`);
+        console.log(colors.muted('  ' + '─'.repeat(50)));
+        console.log();
+    }
+    listThemes() {
+        const current = getActiveThemeName();
+        console.log(colors.primary('\n  Temas disponibles:'));
+        console.log(colors.muted('  ' + '─'.repeat(40)));
+        for (const name of getThemeList()) {
+            const marker = name === current ? colors.success('> ') : '  ';
+            console.log(`  ${marker}${colors.accent(name)}`);
+        }
+        console.log(colors.muted('  ' + '─'.repeat(40)));
+        console.log(colors.muted(`  Actual: ${colors.accent(current)}`));
+        console.log(colors.muted(`  Usa: /theme <nombre>\n`));
+    }
+    async changeTheme(name) {
+        const ok = applyTheme(name);
+        if (!ok) {
+            console.log(colors.error(`  XX Tema no encontrado: ${name}`));
+            this.listThemes();
+            return;
+        }
+        await saveThemePreference(name);
+        console.log(colors.success(`  [OK] Tema cambiado a: ${colors.accent(name)}`));
+    }
+    isHighRisk(toolName) {
+        const highRiskTools = ['delete_file', 'bash_command', 'craft_tool'];
+        return highRiskTools.includes(toolName);
+    }
+    async initiateConsensus(entry) {
+        const agents = this.agentManager.listAgents().map(a => a.id);
+        const proposal = consensusManager.createProposal(`Ejecutar ${entry.name}`, `El agente ${entry.agentId} solicita ejecutar ${entry.name} con argumentos ${JSON.stringify(entry.args)}`, 'high', agents);
+        eventHub.emitEvent({ type: 'notification', data: {
+                title: 'Consenso Requerido',
+                message: `Propuesta ${proposal.id}: ${proposal.title}`,
+                type: 'permission'
+            } });
+        // In v7.0, sub-agents will autonomously vote based on logic.
+        // For now, we'll demonstrate the engine by auto-voting "approved" for non-destructive tests.
+    }
+    async log(entry) {
+        const currentAgent = this.agentManager.getCurrentAgent();
+        // Inject agent identity if not present
+        if (entry.kind === 'assistant' || entry.kind === 'thinking' || entry.kind === 'tool_call' || entry.kind === 'tool_result') {
+            if (!entry.agentId)
+                entry.agentId = currentAgent.id;
+            if (entry.kind === 'assistant' && !entry.agentName)
+                entry.agentName = currentAgent.name;
+        }
+        this.transcript.push(entry);
+        this.renderEntry(entry);
+        // Emit real-time event for streaming
+        eventHub.emitEvent({ type: 'transcript_entry', data: entry });
+        // Check for high-risk actions that require consensus
+        if (entry.kind === 'tool_call' && this.isHighRisk(entry.name)) {
+            await this.initiateConsensus(entry);
+        }
+        if (entry.kind === 'tool_call') {
+            const task = await this.taskManager.createTask(`Tool: ${entry.name}`, entry.agentId || 'orchestrator');
+            eventHub.emitEvent({ type: 'task_started', data: { id: task.id, name: `Tool: ${entry.name}`, agentId: entry.agentId || 'orchestrator' } });
+        }
+        else if (entry.kind === 'tool_result') {
+            const tasks = this.taskManager.listTasks().filter(t => t.status === 'running');
+            const task = tasks[tasks.length - 1];
+            if (task) {
+                this.taskManager.updateTask(task.id, {
+                    status: entry.isError ? 'failed' : 'completed',
+                    error: entry.isError ? entry.content : undefined
+                });
+                eventHub.emitEvent({ type: 'task_updated', data: { id: task.id, status: entry.isError ? 'failed' : 'completed' } });
+            }
+        }
+    }
+    emitNotification(notif) {
+        this.notificationManager.notify(notif.title, notif.message, notif.type === 'permission' ? 'warning' : 'info');
+    }
+    getNotifications() {
+        return this.notificationManager.getNotifications();
+    }
+    resolveApproval(id, approved) {
+        const resolve = this.pendingApprovals.get(id);
+        if (resolve) {
+            resolve(approved);
+            this.pendingApprovals.delete(id);
+            return true;
+        }
+        return false;
+    }
+    renderEntry(entry) {
+        switch (entry.kind) {
+            case 'assistant':
+                this.spinner.stop();
+                // In interactive mode, we already streamed the message, so we don't render it again
+                // unless it's a message being loaded from a session history
+                if (!this.options.interactive || entry.metadata?.isFromHistory) {
+                    renderAssistantMessage(entry.agentName || 'eden', entry.text);
+                }
+                break;
+            case 'thinking':
+                this.spinner.update(entry.text);
+                break;
+            case 'user':
+                renderUserMessage(entry.text);
+                break;
+            case 'tool_call':
+                this.spinner.stop();
+                renderToolCall(entry.name, (entry.input || {}));
+                break;
+            case 'tool_result':
+                this.spinner.stop();
+                renderToolResult({
+                    status: entry.isError ? 'error' : 'success',
+                    output: entry.content,
+                    error: entry.isError ? entry.content : undefined
+                });
+                break;
+            case 'system':
+                renderSystemMessage(entry.text);
+                break;
+            case 'stderr':
+                console.log(colors.error(`${icons.error} ${entry.text}`));
+                break;
+            case 'stdout':
+                if (this.options.debug) {
+                    console.log(colors.muted(`${entry.text}`));
+                }
+                break;
+        }
+    }
+    async executeTool(call) {
+        const toolName = call.function.name;
+        const toolArgs = call.function.arguments;
+        const tool = toolMap.get(toolName);
+        if (!tool) {
+            return {
+                status: 'error',
+                error: `Unknown tool: ${toolName}`,
+            };
+        }
+        // Check permissions for sensitive operations
+        let permissionType = null;
+        let permissionDesc = '';
+        let permissionDetails = '';
+        switch (toolName) {
+            case 'write_file':
+                permissionType = 'fileWrite';
+                permissionDesc = 'Escribir archivo';
+                permissionDetails = toolArgs.file_path;
+                break;
+            case 'edit_file':
+                permissionType = 'fileWrite';
+                permissionDesc = 'Editar archivo';
+                permissionDetails = toolArgs.file_path;
+                break;
+            case 'run_command':
+                permissionType = 'bash';
+                permissionDesc = 'Ejecutar comando shell';
+                permissionDetails = toolArgs.command;
+                break;
+            case 'view_url':
+            case 'web_search':
+            case 'browser':
+                permissionType = 'network';
+                permissionDesc = `Tool: ${toolName}`;
+                break;
+        }
+        if (permissionType) {
+            const allowed = await this.permissionManager.checkPermission({
+                type: permissionType,
+                tool: toolName,
+                description: permissionDesc,
+                details: permissionDetails,
+            });
+            if (!allowed) {
+                // Emit notification for manual approval if level is 'ask'
+                const level = this.permissionManager.getPermissions()[permissionType];
+                if (level === 'ask') {
+                    const approvalId = `approve_${Date.now()}`;
+                    this.emitNotification({
+                        id: approvalId,
+                        type: 'permission',
+                        title: 'Permiso requerido',
+                        message: `El agente está solicitando ejecutar: ${permissionDesc}`,
+                        data: { tool: toolName, details: permissionDetails },
+                        ts: new Date().toISOString()
+                    });
+                    const approved = await new Promise((resolve) => {
+                        this.pendingApprovals.set(approvalId, resolve);
+                    });
+                    if (!approved) {
+                        return { status: 'error', error: `Permiso rechazado por el usuario: ${permissionDesc}` };
+                    }
+                }
+                else {
+                    return {
+                        status: 'error',
+                        error: `Permiso denegado: ${permissionDesc}`,
+                    };
+                }
+            }
+        }
+        try {
+            // Record tool usage for stats
+            this.statsTracker.recordToolUsage(toolName);
+            let result;
+            if (toolName === 'run_command') {
+                result = await this.sandboxManager.execute(toolArgs.command);
+            }
+            else {
+                result = await Promise.resolve(tool.handler(toolArgs, this));
+            }
+            analyticsEngine.trackCall(this.agentManager.getCurrentAgent().id, result.status === 'success');
+            return result;
+        }
+        catch (err) {
+            analyticsEngine.trackCall(this.agentManager.getCurrentAgent().id, false);
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    renderContextStatus() {
+        if (this.context.hasAttachments()) {
+            const files = this.context.getAttachedFiles();
+            const fileList = files.map(f => colors.yellow(`@${f.path.split('/').pop()}`)).join(' ');
+            console.log(colors.muted(`  ${icons.file} Contexto: ${fileList} (${this.context.getTotalSize() / 1024}KB)`));
+        }
+    }
+    renderActiveSkills(prompt) {
+        const { names, count } = getActiveSkillsInfo(prompt);
+        if (count > 0) {
+            const skillsList = names.map(n => colors.primary(n)).join(', ');
+            console.log(colors.muted(`  ${icons.sparkle} Skills activas: ${skillsList}`));
+        }
+    }
+    async processInput(userInput) {
+        // Check for slash commands
+        const slashCmd = parseSlashCommand(userInput);
+        if (slashCmd && slashCmd.command) {
+            const result = await slashCmd.command.execute(slashCmd.args, this.context);
+            // Handle special commands
+            if (result === 'CLEAR_SCREEN') {
+                console.clear();
+                renderHeader({
+                    sessionId: this.sessionManager.getCurrentSessionId() || 'new-session',
+                    workDir: this.options.cwd,
+                    model: this.options.model
+                });
+                renderStatusBar(this.options.model, this.agentManager.getCurrentAgent().name);
+                return null;
+            }
+            if (result.startsWith('CHANGE_MODEL:')) {
+                const newModel = result.split(':')[1];
+                this.options.model = newModel;
+                console.log(colors.success(`${icons.success} Modelo cambiado a: ${newModel}`));
+                renderStatusBar(this.options.model, this.agentManager.getCurrentAgent().name);
+                return null;
+            }
+            if (result === 'AGENT_LIST') {
+                this.listAgents();
+                return null;
+            }
+            if (result.startsWith('CHANGE_AGENT:')) {
+                const agentId = result.split(':')[1];
+                this.switchAgent(agentId);
+                return null;
+            }
+            // Session commands
+            if (result === 'SESSION_LIST') {
+                await this.listSessions();
+                return null;
+            }
+            if (result === 'SESSION_SAVE') {
+                await this.saveSession();
+                return null;
+            }
+            if (result.startsWith('SESSION_LOAD:')) {
+                const sessionId = result.split(':')[1];
+                await this.loadSession(sessionId);
+                return null;
+            }
+            if (result.startsWith('SESSION_EXPORT:')) {
+                const sessionId = result.split(':')[1];
+                await this.exportSession(sessionId || undefined);
+                return null;
+            }
+            if (result.startsWith('SESSION_DELETE:')) {
+                const sessionId = result.split(':')[1];
+                await this.deleteSession(sessionId);
+                return null;
+            }
+            // Permission commands
+            if (result === 'PERMISSION_SHOW') {
+                this.showPermissions();
+                return null;
+            }
+            if (result.startsWith('PERMISSION_SET:')) {
+                const parts = result.split(':');
+                const type = parts[1];
+                const level = parts[2];
+                await this.setPermission(type, level);
+                return null;
+            }
+            if (result === 'STATS_SHOW') {
+                await this.showStats();
+                return null;
+            }
+            if (result === 'STATUS_SHOW') {
+                this.showStatus();
+                return null;
+            }
+            if (result === 'THEME_LIST') {
+                this.listThemes();
+                return null;
+            }
+            if (result.startsWith('THEME_SET:')) {
+                const themeName = result.split(':')[1];
+                this.changeTheme(themeName);
+                return null;
+            }
+            // MCP commands
+            if (result === 'MCP_LIST') {
+                await this.listMCPServers();
+                return null;
+            }
+            if (result === 'MCP_ADD') {
+                await this.addMCPServer();
+                return null;
+            }
+            if (result.startsWith('MCP_AUTH:')) {
+                const serverName = result.split(':')[1];
+                await this.authenticateMCP(serverName);
+                return null;
+            }
+            if (result.startsWith('MCP_REMOVE:')) {
+                const serverName = result.split(':')[1];
+                await this.removeMCPServer(serverName);
+                return null;
+            }
+            // Workflow commands
+            if (result === 'WORKFLOW_LIST') {
+                const path = await import('node:path');
+                const fs = await import('node:fs/promises');
+                const wfDir = path.join(this.options.cwd, '.eden', 'workflows');
+                try {
+                    const files = await fs.readdir(wfDir);
+                    const mds = files.filter(f => f.endsWith('.md') || f.endsWith('.yaml'));
+                    console.log(colors.primary('\n  Flujos de trabajo disponibles en .eden/workflows/:'));
+                    if (mds.length === 0)
+                        console.log(colors.muted('  No hay flujos. Crea archivos .md en este directorio.'));
+                    for (const f of mds) {
+                        console.log(`  • ${f.replace(/\.(md|yaml)$/, '')}`);
+                    }
+                }
+                catch {
+                    console.log(colors.muted('\n  No hay flujos. Crea la carpeta .eden/workflows/ y añade archivos .md'));
+                }
+                return null;
+            }
+            if (result.startsWith('WORKFLOW_RUN:')) {
+                const flowName = result.split(':')[1];
+                await this.runWorkflow(flowName);
+                return null;
+            }
+            if (result === 'SESSION_CLEAR') {
+                this.messages = [];
+                this.transcript = [];
+                await this.persistSession();
+                return null;
+            }
+            // Display command result
+            console.log(boxify(result, { style: 'round', color: colors.info, title: ' Comando ' }));
+            return null;
+        }
+        // Parse @ mentions
+        const { cleanedInput, mentions } = parseMentions(userInput);
+        // Attach mentioned files
+        if (mentions.length > 0) {
+            for (const mention of mentions) {
+                const result = await this.context.attachFile(mention);
+                if (result.success) {
+                    console.log(colors.success(`  ${icons.success} ${result.message}`));
+                }
+                else {
+                    console.log(colors.error(`  ${icons.error} ${result.message}`));
+                }
+            }
+        }
+        // Build modular prompt
+        let finalPrompt = `<user_request>\n${cleanedInput}\n</user_request>`;
+        if (this.context.hasAttachments()) {
+            finalPrompt = `${this.context.getContextString()}\n\n${finalPrompt}`;
+        }
+        return finalPrompt || null;
+    }
+    async runWorkflow(name) {
+        const path = await import('node:path');
+        const fs = await import('node:fs/promises');
+        const wfPath = path.join(this.options.cwd, '.eden', 'workflows', `${name}.md`);
+        let content;
+        try {
+            content = await fs.readFile(wfPath, 'utf8');
+        }
+        catch {
+            console.log(colors.error(`  XX No se encontro el flujo: ${name}.md (en .eden/workflows/)`));
+            return;
+        }
+        const lines = content.split('\n')
+            .map(l => l.trim())
+            .filter(l => l && !l.startsWith('#') && !l.startsWith('//'));
+        console.log(colors.success(`\n  >> Iniciando flujo: ${name} (${lines.length} pasos)`));
+        for (let i = 0; i < lines.length; i++) {
+            const step = lines[i];
+            console.log(colors.system(`\n  -> [Paso ${i + 1}/${lines.length}] Iniciando...`));
+            // Re-trigger the input directly
+            await this.runSingleTurn(step);
+        }
+        console.log(colors.success(`\n  [OK] Flujo completado exitosamente: ${name}\n`));
+    }
+    async runSingleTurn(userInput) {
+        let finalPrompt = '';
+        let messagesToSend = [...this.messages];
+        // Empty input means continuation after tool call - skip processing but still call Ollama
+        if (!userInput.trim()) {
+            // Display current agent
+            this.renderAgentStatus();
+        }
+        else {
+            const processed = await this.processInput(userInput);
+            if (!processed)
+                return;
+            finalPrompt = processed;
+            // Display current agent and active skills
+            this.renderAgentStatus();
+            this.renderActiveSkills(userInput);
+            const now = new Date().toISOString();
+            this.log({
+                kind: 'user',
+                ts: now,
+                text: userInput,
+            });
+            // Build messages array with skill-enhanced system prompt if needed
+            const detectedSkills = detectSkills(userInput);
+            const baseSystemPrompt = this.options.systemPrompt || '';
+            const agentSystemPrompt = this.agentManager.getEffectiveSystemPrompt(baseSystemPrompt, this.options.cwd);
+            const enhancedPrompt = buildEnhancedPrompt(agentSystemPrompt, userInput);
+            messagesToSend = [
+                { role: 'system', content: enhancedPrompt },
+                ...this.messages.filter(m => m.role !== 'system')
+            ];
+            this.messages.push({
+                role: 'user',
+                content: finalPrompt,
+            });
+            messagesToSend.push({
+                role: 'user',
+                content: finalPrompt,
+            });
+        }
+        // Always call Ollama, even with empty input (for tool continuation)
+        let assistantContent = '';
+        const toolCalls = [];
+        const streamId = `stream_${Date.now()}`;
+        try {
+            if (this.options.debug) {
+                console.log(colors.muted('Calling Ollama API...'));
+            }
+            this.spinner.start('Pensando...');
+            // Emit initial streaming event
+            eventHub.emitEvent({
+                type: 'stream_start',
+                data: { streamId, agentId: this.agentManager.getCurrentAgent().id }
+            });
+            const abortController = new AbortController();
+            let streamAction = null;
+            // Raw-mode stdin to intercept Ctrl+C (cancel) and Ctrl+D (exit) during streaming
+            // All other keys/paste are silently ignored so nothing appears on screen
+            const onRawData = (data) => {
+                for (const byte of data) {
+                    if (byte === 0x03) {
+                        streamAction = 'cancel';
+                        abortController.abort();
+                        return;
+                    }
+                    if (byte === 0x04) {
+                        streamAction = 'exit';
+                        abortController.abort();
+                        return;
+                    }
+                }
+            };
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.on('data', onRawData);
+            this.currentAbortController = new AbortController();
+            const activeProvider = await providerManager.getActiveProvider();
+            const activeModel = await providerManager.getActiveModel();
+            const request = {
+                model: activeModel,
+                messages: messagesToSend,
+                tools: this.ollamaTools,
+                stream: true,
+            };
+            let stream;
+            try {
+                if (activeProvider.id === 'nvidia') {
+                    stream = edenAISDK.chatStream(request, this.currentAbortController.signal);
+                }
+                else {
+                    // Ollama fallback
+                    stream = this.client.chatStream(request, this.currentAbortController.signal);
+                }
+                let firstChunk = true;
+                const { symbols, renderMarkdown } = await import('../cli/ui.js');
+                const readline = await import('node:readline');
+                // Accurate line-by-line streaming renderer
+                let currentBuffer = '';
+                let lastLinesCount = 0;
+                for await (const chunk of stream) {
+                    if (streamAction)
+                        break;
+                    if (chunk.message?.content) {
+                        assistantContent += chunk.message.content;
+                        currentBuffer += chunk.message.content;
+                        if (this.options.interactive) {
+                            if (firstChunk) {
+                                this.spinner.stop();
+                                process.stdout.write(`  ${pc.dim(symbols.frame)}  `);
+                                firstChunk = false;
+                            }
+                            // Simple heuristic: if we have a newline or a significant amount of text, 
+                            // we re-render the "current" streaming block.
+                            // We move cursor up only for the current assistant message.
+                            if (lastLinesCount > 0) {
+                                readline.moveCursor(process.stdout, 0, -lastLinesCount);
+                            }
+                            const maxWidth = (process.stdout.columns || 80) - 10;
+                            // Render current accumulated content with Markdown
+                            const rendered = renderMarkdown(assistantContent).trim();
+                            const wrapped = wrapAnsi(rendered, maxWidth, { hard: true });
+                            const lines = wrapped.split('\n');
+                            // Print lines with frame
+                            for (let i = 0; i < lines.length; i++) {
+                                if (i > 0)
+                                    process.stdout.write('\n');
+                                readline.clearLine(process.stdout, 0);
+                                readline.cursorTo(process.stdout, 0);
+                                process.stdout.write(`  ${pc.dim(symbols.frame)}  ${lines[i]}`);
+                            }
+                            lastLinesCount = lines.length - 1;
+                        }
+                        else {
+                            process.stdout.write(chunk.message.content);
+                        }
+                        // Emit real-time chunk to web
+                        eventHub.emitEvent({
+                            type: 'stream_chunk',
+                            data: { streamId, content: chunk.message.content, agentId: this.agentManager.getCurrentAgent().id }
+                        });
+                    }
+                    if (chunk.message?.tool_calls) {
+                        for (const call of chunk.message.tool_calls) {
+                            toolCalls.push(call);
+                        }
+                    }
+                }
+                if (this.options.interactive && !firstChunk) {
+                    process.stdout.write(`\n  ${pc.dim(symbols.frame)}\n`);
+                }
+                else if (!this.options.interactive) {
+                    process.stdout.write('\n');
+                }
+            }
+            catch (err) {
+                if (streamAction === 'cancel' || streamAction === 'exit' || err.name === 'AbortError') {
+                    if (streamAction !== 'exit') {
+                        console.log(colors.warning('  [Cancelado] Generacion interrumpida.'));
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+            finally {
+                process.stdin.off('data', onRawData);
+                process.stdin.setRawMode(false);
+                process.stdin.pause();
+                this.spinner.stop();
+                eventHub.emitEvent({
+                    type: 'stream_end',
+                    data: { streamId, fullContent: assistantContent }
+                });
+            }
+            if (streamAction === 'exit') {
+                this.shouldExit = true;
+                return;
+            }
+            if (assistantContent.trim()) {
+                this.log({
+                    kind: 'assistant',
+                    ts: new Date().toISOString(),
+                    text: assistantContent,
+                });
+                // Estimate and record token usage
+                // Rough estimate: ~4 chars per token for input, ~4 for output
+                const inputTokens = Math.ceil((finalPrompt || userInput).length / 4);
+                const outputTokens = Math.ceil(assistantContent.length / 4);
+                this.statsTracker.recordMessage(inputTokens, outputTokens, this.options.model);
+            }
+            if (toolCalls.length > 0) {
+                for (const call of toolCalls) {
+                    const toolCallId = call.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+                    const args = typeof call.function.arguments === 'string'
+                        ? JSON.parse(call.function.arguments)
+                        : call.function.arguments;
+                    // Update the call object with parsed arguments for executeTool and handlers
+                    call.function.arguments = args;
+                    // If delegating tasks, initialize progress tracking
+                    if (call.function.name === 'DELEGATE_TASKS' && args.tasks) {
+                        this.isProcessingPlan = true;
+                        this.totalTasks = args.tasks.length;
+                        this.completedTasks = 0;
+                    }
+                    // In interactive mode, we don't call log({kind: 'tool_call'}) because it triggers 
+                    // a second renderToolCall. We just render once and push to transcript.
+                    if (this.options.interactive) {
+                        renderToolCall(call.function.name, args);
+                        if (this.isProcessingPlan) {
+                            console.log(`  ${progressBar(this.completedTasks, this.totalTasks)}`);
+                        }
+                        this.transcript.push({
+                            kind: 'tool_call',
+                            ts: new Date().toISOString(),
+                            name: call.function.name,
+                            input: args,
+                            toolUseId: toolCallId,
+                            metadata: {}
+                        });
+                    }
+                    else {
+                        this.log({
+                            kind: 'tool_call',
+                            ts: new Date().toISOString(),
+                            name: call.function.name,
+                            input: args,
+                            toolUseId: toolCallId,
+                        });
+                    }
+                    this.spinner.start(`Ejecutando ${call.function.name}...`);
+                    const result = await this.executeTool(call);
+                    this.spinner.stop();
+                    this.log({
+                        kind: 'tool_result',
+                        ts: new Date().toISOString(),
+                        toolUseId: toolCallId,
+                        toolName: call.function.name,
+                        content: result.output || result.error || '',
+                        isError: result.status === 'error',
+                    });
+                    this.messages.push({
+                        role: 'assistant',
+                        content: '',
+                        tool_calls: [{
+                                ...call,
+                                function: {
+                                    ...call.function,
+                                    arguments: typeof args === 'string' ? args : JSON.stringify(args)
+                                }
+                            }],
+                    });
+                    const rawOutput = result.output || result.error || '';
+                    const maxOutputLength = 32000; // Limit context per tool result
+                    let finalOutput = typeof rawOutput === 'string' ? rawOutput : JSON.stringify(rawOutput);
+                    if (finalOutput.length > maxOutputLength) {
+                        finalOutput = finalOutput.slice(0, maxOutputLength) +
+                            `... \n\n[RESULTADO TRUNCADO: ${finalOutput.length - maxOutputLength} caracteres omitidos por brevedad y límites de contexto]`;
+                    }
+                    this.messages.push({
+                        role: 'tool',
+                        content: finalOutput,
+                        tool_call_id: toolCallId,
+                    });
+                    // Update progress if in a plan
+                    if (this.isProcessingPlan && result.status === 'success') {
+                        this.completedTasks++;
+                        if (this.completedTasks >= this.totalTasks) {
+                            // Plan finished (or at least all delegated tasks are done)
+                            // We'll keep isProcessingPlan true until the final response
+                        }
+                    }
+                }
+                // Continue with another turn to let the AI respond to tool results
+                try {
+                    await this.runSingleTurn('');
+                }
+                catch (continueErr) {
+                    this.log({
+                        kind: 'system',
+                        ts: new Date().toISOString(),
+                        text: `Error continuing after tool: ${continueErr instanceof Error ? continueErr.message : String(continueErr)}`,
+                    });
+                }
+            }
+            else {
+                this.messages.push({
+                    role: 'assistant',
+                    content: assistantContent,
+                });
+            }
+        }
+        catch (err) {
+            this.spinner.stop();
+            this.log({
+                kind: 'system',
+                ts: new Date().toISOString(),
+                text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    async runInteractive() {
+        // Resume previous session prompt
+        const sessions = await this.sessionManager.listSessions(5);
+        const cwdSessions = sessions.filter(s => s.metadata?.cwd === this.options.cwd);
+        if (cwdSessions.length > 0 && !this.sessionManager.getCurrentSessionId()) {
+            const last = cwdSessions[0];
+            const date = new Date(last.updatedAt).toLocaleString('es-ES');
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await new Promise(resolve => {
+                rl.question(`  ${colors.muted('Resumir sesion:')} ${colors.accent(last.title)} ${colors.dim(`(${last.messageCount} msgs, ${date})`)} [Y/n/list] `, resolve);
+            });
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            if (a === '' || a.startsWith('y')) {
+                await this.loadSession(last.id);
+                console.log(colors.success(`  [OK] Sesion resumida`));
+            }
+            else if (a.startsWith('l')) {
+                console.log();
+                cwdSessions.forEach((s, i) => {
+                    const d = new Date(s.updatedAt).toLocaleString('es-ES');
+                    console.log(`  ${colors.emerald(`${i + 1}.`)} ${colors.cyan(s.title)} ${colors.muted(`(${s.messageCount} msgs) ${d}`)}`);
+                });
+                console.log();
+                const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+                const ans2 = await new Promise(resolve => {
+                    rl2.question(`  ${colors.muted('Numero para cargar (o Enter para nueva):')} `, resolve);
+                });
+                rl2.close();
+                const idx = parseInt(ans2.trim(), 10);
+                if (!isNaN(idx) && idx > 0 && idx <= cwdSessions.length) {
+                    await this.loadSession(cwdSessions[idx - 1].id);
+                    console.log(colors.success(`  [OK] Sesion resumida`));
+                }
+            }
+        }
+        const activeProvider = await providerManager.getActiveProvider();
+        const activeModel = await providerManager.getActiveModel();
+        // Render modern header
+        renderHeader({
+            sessionId: this.sessionManager.getCurrentSessionId() || 'new-session',
+            workDir: this.options.cwd,
+            model: `${activeProvider.id} / ${activeModel}`
+        });
+        renderStatusBar(activeModel, this.agentManager.getCurrentAgent().name);
+        // Catch Ctrl+C outside raw mode and show hint
+        process.on('SIGINT', () => {
+            console.log(`\n  ${colors.dim('Tip:')} ${colors.accent('Ctrl+D')} ${colors.dim('para salir de Eden')}`);
+        });
+        while (true) {
+            console.log();
+            // Use the symbols from ui.js
+            const { symbols } = await import('../cli/ui.js');
+            const input = await realtimeInput(`  ${pc.dim(symbols.frame)}  `);
+            if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
+                await this.saveSession();
+                console.log();
+                console.log(boxify(`${colors.success('Gracias por usar Eden')}\n\n` +
+                    `${colors.muted('Sesion guardada. Puedes retomarla mas tarde.')}`, { style: 'round', color: colors.success }));
+                console.log();
+                break;
+            }
+            if (input.trim()) {
+                const cmd = input.trim().toLowerCase();
+                if (cmd === '/models' || cmd === '/tags') {
+                    console.log(pc.cyan(`\n  📦 Consultando modelos disponibles...`));
+                    try {
+                        const list = await this.client.listModels();
+                        console.log();
+                        list.models.sort((a, b) => a.name.localeCompare(b.name)).forEach(m => {
+                            const sizeGB = (m.size / 1e9).toFixed(2);
+                            console.log(`     • ${pc.bold(m.name)} ${pc.dim(`(${sizeGB} GB)`)}`);
+                        });
+                    }
+                    catch (err) {
+                        console.log(pc.red(`  ❌ Error: ${err instanceof Error ? err.message : String(err)}`));
+                    }
+                    continue;
+                }
+                await this.runSingleTurn(input);
+                if (this.shouldExit) {
+                    await this.saveSession();
+                    console.log();
+                    console.log(boxify(`${colors.success('Gracias por usar Eden')}\n\n` +
+                        `${colors.muted('Sesion guardada. Puedes retomarla mas tarde.')}`, { style: 'round', color: colors.success }));
+                    console.log();
+                    break;
+                }
+                this.renderContextStatus();
+            }
+        }
+    }
+    getTranscript() {
+        return [...this.transcript];
+    }
+    getActiveTasks() {
+        return this.taskManager.listTasks();
+    }
+    async listPersistentSessions() {
+        return await this.sessionManager.listSessions(50);
+    }
+}
+//# sourceMappingURL=agent.js.map