morpheus-cli 0.2.7 → 0.3.1

package/README.md

@@ -52,6 +52,10 @@ morpheus restart
 
 # Diagnose issues
 morpheus doctor
+
+# Manage sessions
+morpheus session new     # Archive current and start new
+morpheus session status  # Check current session info
 ```
 
 ## Troubleshooting
@@ -93,6 +97,14 @@ Morpheus is built with **Node.js** and **TypeScript**, using **LangChain** as th
 ### 🖥️ Web Dashboard
 Local React-based UI to manage recordings, chat history, and system status across your agent instances.
 
+**New: Interactive Web Chat**
+- Full-featured chat interface accessible from the browser
+- Session management: create, archive, delete, and rename sessions
+- Cross-channel visibility: view and interact with sessions started on any channel (Telegram, Web, etc.)
+- Real-time messaging with the Oracle agent
+- Responsive design with collapsible sidebar
+- Full support for Light and Dark (Matrix) themes
+
 #### 🔒 UI Authentication
 To protect your Web UI, use the `THE_ARCHITECT_PASS` environment variable. This ensures only authorized users can access the dashboard and API.
 
@@ -121,13 +133,15 @@ The system also supports generic environment variables that apply to all provide
 | `MORPHEUS_LLM_MAX_TOKENS` | Maximum tokens for LLM | llm.max_tokens |
 | `MORPHEUS_LLM_CONTEXT_WINDOW` | Context window size for LLM | llm.context_window |
 | `MORPHEUS_LLM_API_KEY` | Generic API key for LLM (lower precedence than provider-specific keys) | llm.api_key |
-| `MORPHEUS_SANTI_PROVIDER` | Sati provider to use | santi.provider |
-| `MORPHEUS_SANTI_MODEL` | Model name for Sati | santi.model |
-| `MORPHEUS_SANTI_TEMPERATURE` | Temperature setting for Sati | santi.temperature |
-| `MORPHEUS_SANTI_MAX_TOKENS` | Maximum tokens for Sati | santi.max_tokens |
-| `MORPHEUS_SANTI_CONTEXT_WINDOW` | Context window size for Sati | santi.context_window |
-| `MORPHEUS_SANTI_API_KEY` | Generic API key for Sati (lower precedence than provider-specific keys) | santi.api_key |
-| `MORPHEUS_SANTI_MEMORY_LIMIT` | Memory retrieval limit for Sati | santi.memory_limit |
+| `MORPHEUS_SATI_PROVIDER` | Sati provider to use | santi.provider |
+| `MORPHEUS_SATI_MODEL` | Model name for Sati | santi.model |
+| `MORPHEUS_SATI_TEMPERATURE` | Temperature setting for Sati | santi.temperature |
+| `MORPHEUS_SATI_MAX_TOKENS` | Maximum tokens for Sati | santi.max_tokens |
+| `MORPHEUS_SATI_CONTEXT_WINDOW` | Context window size for Sati | santi.context_window |
+| `MORPHEUS_SATI_API_KEY` | Generic API key for Sati (lower precedence than provider-specific keys) | santi.api_key |
+| `MORPHEUS_SATI_MEMORY_LIMIT` | Memory retrieval limit for Sati | santi.memory_limit |
+| `MORPHEUS_SATI_MEMORY_LIMIT` | Memory retrieval limit for Sati | santi.memory_limit |
+| `MORPHEUS_SATI_ENABLED_ARCHIVED_SESSIONS`| Enable/disable retrieval of archived sessions in Sati | santi.enableArchivedSessions |
 | `MORPHEUS_AUDIO_MODEL` | Model name for audio processing | audio.model |
 | `MORPHEUS_AUDIO_ENABLED` | Enable/disable audio processing | audio.enabled |
 | `MORPHEUS_AUDIO_API_KEY` | Generic API key for audio (lower precedence than provider-specific keys) | audio.apiKey |
@@ -209,6 +223,8 @@ The Morpheus Telegram bot supports several commands for interacting with the age
 - `/help` - Show available commands
 - `/zaion` - Show system configurations
 - `/sati <qnt>` - Show specific memories
+- `/newsession` - Archive current session and start fresh
+- `/sessions` - List all sessions with options to switch, archive, or delete
 - `/restart` - Restart the Morpheus agent
 - `/mcp` or `/mcps` - List registered MCP servers
 
@@ -364,6 +380,33 @@ Get the current status of the Morpheus agent.
     }
     ```
 
+### Session Endpoints
+
+#### POST `/api/session/reset`
+Archive the current session and start a new one.
+
+*   **Authentication:** Requires `Authorization` header with the password set in `THE_ARCHITECT_PASS`.
+*   **Response:**
+    ```json
+    {
+      "success": true,
+      "message": "New session started"
+    }
+    ```
+
+#### POST `/api/session/status`
+Get the status of the current session.
+
+*   **Authentication:** Requires `Authorization` header with the password set in `THE_ARCHITECT_PASS`.
+*   **Response:**
+    ```json
+    {
+      "id": "uuid-...",
+      "messageCount": 42,
+      "embedding_status": "pending"
+    }
+    ```
+
 ### Configuration Endpoints
 
 #### GET `/api/config`
@@ -848,7 +891,7 @@ version: '3.8'
 
 services:
   morpheus:
-    image: morpheus/morpheus-agent:latest
+    image: marcosnunesmbs/morpheus:latest
     container_name: morpheus-agent
     ports:
       - "3333:3333"

package/dist/channels/telegram.js

@@ -19,6 +19,18 @@ export class TelegramAdapter {
     config = ConfigManager.getInstance();
     oracle;
     telephonist = new Telephonist();
+    history = new SQLiteChatMessageHistory({ sessionId: '' });
+    HELP_MESSAGE = `/start - Show this welcome message and available commands
+/status - Check the status of the Morpheus agent
+/doctor - Diagnose environment and configuration issues
+/stats - Show token usage statistics
+/help - Show available commands
+/zaion - Show system configurations
+/sati <qnt> - Show specific memories
+/newsession - Archive current session and start fresh
+/sessions - List all sessions with titles and switch between them
+/restart - Restart the Morpheus agent
+/mcp or /mcps - List registered MCP servers`;
     constructor(oracle) {
         this.oracle = oracle;
     }
@@ -139,6 +151,120 @@ export class TelegramAdapter {
                     }
                 }
             });
+            this.bot.action('confirm_new_session', async (ctx) => {
+                await this.handleApproveNewSessionCommand(ctx, ctx.from.username || ctx.from.first_name);
+                if (ctx.updateType === 'callback_query') {
+                    ctx.answerCbQuery();
+                    ctx.deleteMessage().catch(() => { });
+                }
+                ctx.reply("New session created.");
+            });
+            this.bot.action('cancel_new_session', async (ctx) => {
+                if (ctx.updateType === 'callback_query') {
+                    ctx.answerCbQuery();
+                    ctx.deleteMessage().catch(() => { });
+                }
+                ctx.reply("New session cancelled.");
+            });
+            this.bot.action(/^switch_session_/, async (ctx) => {
+                const callbackQuery = ctx.callbackQuery;
+                const data = callbackQuery && 'data' in callbackQuery ? callbackQuery.data : undefined;
+                const sessionId = typeof data === 'string' ? data.replace('switch_session_', '') : '';
+                if (!sessionId || sessionId === '') {
+                    await ctx.answerCbQuery('Invalid session ID');
+                    return;
+                }
+                try {
+                    // Obter a sessão atual antes de alternar
+                    const history = new SQLiteChatMessageHistory({ sessionId: "" });
+                    // Alternar para a nova sessão
+                    await history.switchSession(sessionId);
+                    await ctx.answerCbQuery();
+                    // Remover a mensagem anterior e enviar confirmação
+                    if (ctx.updateType === 'callback_query') {
+                        ctx.deleteMessage().catch(() => { });
+                    }
+                    ctx.reply(`✅ Switched to session ID: ${sessionId}`);
+                }
+                catch (error) {
+                    await ctx.answerCbQuery(`Error switching session: ${error.message}`, { show_alert: true });
+                }
+            });
+            // --- Archive Flow ---
+            this.bot.action(/^ask_archive_session_/, async (ctx) => {
+                const data = ctx.callbackQuery.data;
+                const sessionId = data.replace('ask_archive_session_', '');
+                // Fetch session title for better UX (optional, but nice) - for now just use ID
+                await ctx.reply(`⚠️ **ARCHIVE SESSION?**\n\nAre you sure you want to archive session \`${sessionId}\`?\n\nIt will be moved to long-term memory (SATI) and removed from the active list. This action cannot be easily undone via Telegram.`, {
+                    parse_mode: 'Markdown',
+                    reply_markup: {
+                        inline_keyboard: [
+                            [
+                                { text: '✅ Yes, Archive', callback_data: `confirm_archive_session_${sessionId}` },
+                                { text: '❌ Cancel', callback_data: 'cancel_session_action' }
+                            ]
+                        ]
+                    }
+                });
+                await ctx.answerCbQuery();
+            });
+            this.bot.action(/^confirm_archive_session_/, async (ctx) => {
+                const data = ctx.callbackQuery.data;
+                const sessionId = data.replace('confirm_archive_session_', '');
+                try {
+                    const history = new SQLiteChatMessageHistory({ sessionId: "" });
+                    await history.archiveSession(sessionId);
+                    await ctx.answerCbQuery('Session archived successfully');
+                    if (ctx.updateType === 'callback_query') {
+                        ctx.deleteMessage().catch(() => { });
+                    }
+                    await ctx.reply(`✅ Session \`${sessionId}\` has been archived and moved to long-term memory.`, { parse_mode: 'Markdown' });
+                }
+                catch (error) {
+                    await ctx.answerCbQuery(`Error archiving: ${error.message}`, { show_alert: true });
+                }
+            });
+            // --- Delete Flow ---
+            this.bot.action(/^ask_delete_session_/, async (ctx) => {
+                const data = ctx.callbackQuery.data;
+                const sessionId = data.replace('ask_delete_session_', '');
+                await ctx.reply(`🚫 **DELETE SESSION?**\n\nAre you sure you want to PERMANENTLY DELETE session \`${sessionId}\`?\n\nThis action is **IRREVERSIBLE**. All data will be lost.`, {
+                    parse_mode: 'Markdown',
+                    reply_markup: {
+                        inline_keyboard: [
+                            [
+                                { text: '🗑️ Yes, DELETE PERMANENTLY', callback_data: `confirm_delete_session_${sessionId}` },
+                                { text: '❌ Cancel', callback_data: 'cancel_session_action' }
+                            ]
+                        ]
+                    }
+                });
+                await ctx.answerCbQuery();
+            });
+            this.bot.action(/^confirm_delete_session_/, async (ctx) => {
+                const data = ctx.callbackQuery.data;
+                const sessionId = data.replace('confirm_delete_session_', '');
+                try {
+                    const history = new SQLiteChatMessageHistory({ sessionId: "" });
+                    await history.deleteSession(sessionId);
+                    await ctx.answerCbQuery('Session deleted successfully');
+                    if (ctx.updateType === 'callback_query') {
+                        ctx.deleteMessage().catch(() => { });
+                    }
+                    await ctx.reply(`🗑️ Session \`${sessionId}\` has been permanently deleted.`, { parse_mode: 'Markdown' });
+                }
+                catch (error) {
+                    await ctx.answerCbQuery(`Error deleting: ${error.message}`, { show_alert: true });
+                }
+            });
+            // --- Cancel Action ---
+            this.bot.action('cancel_session_action', async (ctx) => {
+                await ctx.answerCbQuery('Action cancelled');
+                if (ctx.updateType === 'callback_query') {
+                    ctx.deleteMessage().catch(() => { });
+                }
+                await ctx.reply('Action cancelled.');
+            });
             this.bot.launch().catch((err) => {
                 if (this.isConnected) {
                     this.display.log(`Telegram bot error: ${err}`, { source: 'Telegram', level: 'error' });
@@ -188,6 +314,11 @@ export class TelegramAdapter {
         this.bot = null;
         this.display.log(chalk.gray('Telegram disconnected.'), { source: 'Telegram' });
     }
+    /**
+    ** =========================
+    **     Commands Handlers
+    ** =========================
+    */
     async handleSystemCommand(ctx, text, user) {
         const command = text.split(' ')[0];
         const args = text.split(' ').slice(1);
@@ -220,24 +351,97 @@ export class TelegramAdapter {
             case '/mcps':
                 await this.handleMcpListCommand(ctx, user);
                 break;
+            case '/newsession':
+            case '/reset':
+                await this.handleNewSessionCommand(ctx, user);
+                break;
+            case '/sessionstatus':
+            case '/session':
+            case '/sessions':
+                await this.handleSessionStatusCommand(ctx, user);
+                break;
             default:
                 await this.handleDefaultCommand(ctx, user, command);
         }
     }
+    async handleNewSessionCommand(ctx, user) {
+        try {
+            await ctx.reply("Are you ready to start a new session? Please confirm.", {
+                parse_mode: 'Markdown', reply_markup: {
+                    inline_keyboard: [
+                        [{ text: 'Yes, start new session', callback_data: 'confirm_new_session' }, { text: 'No, cancel', callback_data: 'cancel_new_session' }]
+                    ]
+                }
+            });
+        }
+        catch (e) {
+            await ctx.reply(`Error starting new session: ${e.message}`);
+        }
+    }
+    async handleApproveNewSessionCommand(ctx, user) {
+        try {
+            const history = new SQLiteChatMessageHistory({ sessionId: "" });
+            await history.createNewSession();
+        }
+        catch (e) {
+            await ctx.reply(`Error creating new session: ${e.message}`);
+        }
+    }
+    async handleSessionStatusCommand(ctx, user) {
+        try {
+            // Obter todas as sessões ativas e pausadas usando a nova função
+            const history = new SQLiteChatMessageHistory({ sessionId: "" });
+            const sessions = await history.listSessions();
+            if (sessions.length === 0) {
+                await ctx.reply('No active or paused sessions found.', { parse_mode: 'Markdown' });
+                return;
+            }
+            let response = '*Sessions:*\n\n';
+            const keyboard = [];
+            for (const session of sessions) {
+                const title = session.title || 'Untitled Session';
+                const statusEmoji = session.status === 'active' ? '🟢' : '🟡';
+                response += `${statusEmoji} *${title}*\n`;
+                response += `- ID: ${session.id}\n`;
+                response += `- Status: ${session.status}\n`;
+                response += `- Started: ${new Date(session.started_at).toLocaleString()}\n\n`;
+                // Adicionar botão inline para alternar para esta sessão
+                const sessionButtons = [];
+                if (session.status !== 'active') {
+                    sessionButtons.push({
+                        text: `➡️ Switch`,
+                        callback_data: `switch_session_${session.id}`
+                    });
+                }
+                sessionButtons.push({
+                    text: `📂 Archive`,
+                    callback_data: `ask_archive_session_${session.id}`
+                });
+                sessionButtons.push({
+                    text: `🗑️ Delete`,
+                    callback_data: `ask_delete_session_${session.id}`
+                });
+                keyboard.push(sessionButtons);
+            }
+            await ctx.reply(response, {
+                parse_mode: 'Markdown',
+                reply_markup: {
+                    inline_keyboard: keyboard
+                }
+            });
+            history.close();
+        }
+        catch (e) {
+            await ctx.reply(`Error retrieving session status: ${e.message}`);
+        }
+    }
     async handleStartCommand(ctx, user) {
         const welcomeMessage = `
 Hello, @${user}! I am ${this.config.get().agent.name}, ${this.config.get().agent.personality}.
 
 I am your local AI operator/agent. Here are the commands you can use:
 
-/start - Show this welcome message and available commands
-/status - Check the status of the Morpheus agent
-/doctor - Diagnose environment and configuration issues
-/stats - Show token usage statistics
-/help - Show available commands
-/zaion - Show system configurations
-/sati <qnt> - Show specific memories
-/restart - Restart the Morpheus agent
+  ${this.HELP_MESSAGE}
 
 How can I assist you today?`;
         await ctx.reply(welcomeMessage);
@@ -321,7 +525,7 @@ How can I assist you today?`;
             if (groupedStats.length > 0) {
                 response += '*Breakdown by Provider and Model:*\n';
                 for (const stat of groupedStats) {
-                    response += `- ${stat.provider}/${stat.model}: ${stat.totalTokens} tokens (${stat.messageCount} messages)\n`;
+                    response += `- ${stat.provider}/${stat.model}:\n ${stat.totalTokens} tokens\n(${stat.messageCount} messages)\n\n`;
                 }
             }
             else {
@@ -336,9 +540,10 @@ How can I assist you today?`;
         }
     }
     async handleDefaultCommand(ctx, user, command) {
-        const prompt = `O usuário envio o comando: ${command},
+        const prompt = `O usuário enviou o comando: ${command},
     Não entendemos o comando
-    temos os seguintes comandos disponíveis: /start, /status, /doctor, /stats, /help, /zaion, /sati <qnt>, /restart, /mcp, /mcps
+    temos os seguintes comandos disponíveis:
+    ${this.HELP_MESSAGE}
     Identifique se ele talvez tenha errado o comando e pergunte se ele não quis executar outro comando.
     Só faça isso agora.`;
         let response = await this.oracle.chat(prompt);
@@ -351,17 +556,9 @@ How can I assist you today?`;
         const helpMessage = `
 *Available Commands:*
 
-/start - Show welcome message and available commands
-/status - Check the status of the Morpheus agent
-/doctor - Diagnose environment and configuration issues
-/stats - Show token usage statistics
-/help - Show this help message
-/zaion - Show system configurations
-/sati <qnt> - Show specific memories
-/restart - Restart the Morpheus agent
-/mcp or /mcps - List registered MCP servers
+${this.HELP_MESSAGE}
 
-How can I assist you today?  `;
+How can I assist you today?`;
         await ctx.reply(helpMessage, { parse_mode: 'Markdown' });
     }
     async handleZaionCommand(ctx, user) {
@@ -423,6 +620,7 @@ How can I assist you today?  `;
     async handleRestartCommand(ctx, user) {
         // Store the user ID who requested the restart
         const userId = ctx.from.id;
+        const updateId = ctx.update.update_id;
         // Save the user ID to a temporary file so the restarted process can notify them
         const restartNotificationFile = path.join(os.tmpdir(), 'morpheus_restart_notification.json');
         try {
@@ -433,6 +631,15 @@ How can I assist you today?  `;
         }
         // Respond to the user first
         await ctx.reply('🔄 Restart initiated. The Morpheus agent will restart shortly.');
+        // Acknowledge this update to Telegram by advancing the offset past it.
+        // Without this, Telegraf's in-memory offset is lost on process.exit() and the
+        // /restart message gets re-delivered on the next startup, causing an infinite loop.
+        try {
+            await ctx.telegram.callApi('getUpdates', { offset: updateId + 1, limit: 1, timeout: 0 });
+        }
+        catch (e) {
+            // Best-effort — proceed with restart regardless
+        }
         // Schedule the restart after a short delay to ensure the response is sent
         setTimeout(() => {
             // Stop the bot to prevent processing more messages
@@ -452,7 +659,7 @@ How can I assist you today?  `;
             restartProcess.unref();
             // Exit the current process
             process.exit(0);
-        }, 500); // Shorter delay to minimize chance of processing more messages
+        }, 500);
     }
     async checkAndSendRestartNotification() {
         const restartNotificationFile = path.join(os.tmpdir(), 'morpheus_restart_notification.json');

package/dist/cli/commands/doctor.js

@@ -49,7 +49,7 @@ export const doctorCommand = new Command('doctor')
             }
             // Check API keys availability for active providers
             const llmProvider = config.llm?.provider;
-            const santiProvider = config.santi?.provider;
+            const satiProvider = config.sati?.provider;
             // Check LLM provider API key
             if (llmProvider && llmProvider !== 'ollama') {
                 const hasLlmApiKey = config.llm?.api_key ||
@@ -65,18 +65,18 @@ export const doctorCommand = new Command('doctor')
                     allPassed = false;
                 }
             }
-            // Check Santi provider API key
-            if (santiProvider && santiProvider !== 'ollama') {
-                const hasSantiApiKey = config.santi?.api_key ||
-                    (santiProvider === 'openai' && process.env.OPENAI_API_KEY) ||
-                    (santiProvider === 'anthropic' && process.env.ANTHROPIC_API_KEY) ||
-                    (santiProvider === 'gemini' && process.env.GOOGLE_API_KEY) ||
-                    (santiProvider === 'openrouter' && process.env.OPENROUTER_API_KEY);
+            // Check Sati provider API key
+            if (satiProvider && satiProvider !== 'ollama') {
+                const hasSantiApiKey = config.sati?.api_key ||
+                    (satiProvider === 'openai' && process.env.OPENAI_API_KEY) ||
+                    (satiProvider === 'anthropic' && process.env.ANTHROPIC_API_KEY) ||
+                    (satiProvider === 'gemini' && process.env.GOOGLE_API_KEY) ||
+                    (satiProvider === 'openrouter' && process.env.OPENROUTER_API_KEY);
                 if (hasSantiApiKey) {
-                    console.log(chalk.green('✓') + ` Santi API key available for ${santiProvider}`);
+                    console.log(chalk.green('✓') + ` Sati API key available for ${satiProvider}`);
                 }
                 else {
-                    console.log(chalk.red('✗') + ` Santi API key missing for ${santiProvider}. Either set in config or define environment variable.`);
+                    console.log(chalk.red('✗') + ` Sati API key missing for ${satiProvider}. Either set in config or define environment variable.`);
                     allPassed = false;
                 }
             }
@@ -144,7 +144,7 @@ export const doctorCommand = new Command('doctor')
     }
     // 5. Check Sati Memory DB
     try {
-        const satiDbPath = path.join(PATHS.memory, 'santi-memory.db');
+        const satiDbPath = path.join(PATHS.memory, 'sati-memory.db');
         if (await fs.pathExists(satiDbPath)) {
             console.log(chalk.green('✓') + ' Sati Memory: Database exists');
         }

package/dist/cli/commands/init.js

@@ -117,15 +117,15 @@ export const initCommand = new Command('init')
             ],
             default: 'no',
         });
-        let santiProvider = provider;
-        let santiModel = model;
-        let santiApiKey = apiKey;
+        let satiProvider = provider;
+        let satiModel = model;
+        let satiApiKey = apiKey;
         // If using main settings and no new key provided, use existing if available
-        if (configureSati === 'no' && !santiApiKey && hasExistingKey) {
-            santiApiKey = currentConfig.llm.api_key;
+        if (configureSati === 'no' && !satiApiKey && hasExistingKey) {
+            satiApiKey = currentConfig.llm.api_key;
         }
         if (configureSati === 'yes') {
-            santiProvider = await select({
+            satiProvider = await select({
                 message: 'Select Sati LLM Provider:',
                 choices: [
                     { name: 'OpenAI', value: 'openai' },
@@ -134,10 +134,10 @@ export const initCommand = new Command('init')
                     { name: 'Ollama', value: 'ollama' },
                     { name: 'Google Gemini', value: 'gemini' },
                 ],
-                default: currentConfig.santi?.provider || provider,
+                default: currentConfig.sati?.provider || provider,
             });
             let defaultSatiModel = 'gpt-3.5-turbo';
-            switch (santiProvider) {
+            switch (satiProvider) {
                 case 'openai':
                     defaultSatiModel = 'gpt-4o';
                     break;
@@ -154,59 +154,59 @@ export const initCommand = new Command('init')
                     defaultSatiModel = 'gemini-pro';
                     break;
             }
-            if (santiProvider === currentConfig.santi?.provider) {
-                defaultSatiModel = currentConfig.santi?.model || defaultSatiModel;
+            if (satiProvider === currentConfig.sati?.provider) {
+                defaultSatiModel = currentConfig.sati?.model || defaultSatiModel;
             }
-            santiModel = await input({
+            satiModel = await input({
                 message: 'Enter Sati Model Name:',
                 default: defaultSatiModel,
             });
-            const hasExistingSatiKey = !!currentConfig.santi?.api_key;
-            let santiKeyMsg = hasExistingSatiKey
+            const hasExistingSatiKey = !!currentConfig.sati?.api_key;
+            let satiKeyMsg = hasExistingSatiKey
                 ? 'Enter Sati API Key (leave empty to preserve existing, or if using env vars):'
                 : 'Enter Sati API Key (leave empty if using env vars):';
             // Add info about environment variables to the message
-            if (santiProvider === 'openai') {
-                santiKeyMsg = `${santiKeyMsg} (Env var: OPENAI_API_KEY)`;
+            if (satiProvider === 'openai') {
+                satiKeyMsg = `${satiKeyMsg} (Env var: OPENAI_API_KEY)`;
             }
-            else if (santiProvider === 'anthropic') {
-                santiKeyMsg = `${santiKeyMsg} (Env var: ANTHROPIC_API_KEY)`;
+            else if (satiProvider === 'anthropic') {
+                satiKeyMsg = `${satiKeyMsg} (Env var: ANTHROPIC_API_KEY)`;
             }
-            else if (santiProvider === 'gemini') {
-                santiKeyMsg = `${santiKeyMsg} (Env var: GOOGLE_API_KEY)`;
+            else if (satiProvider === 'gemini') {
+                satiKeyMsg = `${satiKeyMsg} (Env var: GOOGLE_API_KEY)`;
             }
-            else if (santiProvider === 'openrouter') {
-                santiKeyMsg = `${santiKeyMsg} (Env var: OPENROUTER_API_KEY)`;
+            else if (satiProvider === 'openrouter') {
+                satiKeyMsg = `${satiKeyMsg} (Env var: OPENROUTER_API_KEY)`;
             }
-            const keyInput = await password({ message: santiKeyMsg });
+            const keyInput = await password({ message: satiKeyMsg });
             if (keyInput) {
-                santiApiKey = keyInput;
+                satiApiKey = keyInput;
             }
             else if (hasExistingSatiKey) {
-                santiApiKey = currentConfig.santi?.api_key;
+                satiApiKey = currentConfig.sati?.api_key;
             }
             else {
-                santiApiKey = undefined; // Ensure we don't accidentally carry over invalid state
+                satiApiKey = undefined; // Ensure we don't accidentally carry over invalid state
             }
             // Base URL Configuration for Sati OpenRouter
-            if (santiProvider === 'openrouter') {
+            if (satiProvider === 'openrouter') {
                 const satiBaseUrl = await input({
                     message: 'Enter Sati OpenRouter Base URL:',
-                    default: currentConfig.santi?.base_url || 'https://openrouter.ai/api/v1',
+                    default: currentConfig.sati?.base_url || 'https://openrouter.ai/api/v1',
                 });
-                await configManager.set('santi.base_url', satiBaseUrl);
+                await configManager.set('sati.base_url', satiBaseUrl);
             }
         }
         const memoryLimit = await input({
             message: 'Sati Memory Retrieval Limit (messages):',
-            default: currentConfig.santi?.memory_limit?.toString() || '1000',
+            default: currentConfig.sati?.memory_limit?.toString() || '1000',
             validate: (val) => !isNaN(Number(val)) && Number(val) > 0 || 'Must be a positive number'
         });
-        await configManager.set('santi.provider', santiProvider);
-        await configManager.set('santi.model', santiModel);
-        await configManager.set('santi.memory_limit', Number(memoryLimit));
-        if (santiApiKey) {
-            await configManager.set('santi.api_key', santiApiKey);
+        await configManager.set('sati.provider', satiProvider);
+        await configManager.set('sati.model', satiModel);
+        await configManager.set('sati.memory_limit', Number(memoryLimit));
+        if (satiApiKey) {
+            await configManager.set('sati.api_key', satiApiKey);
         }
         // Audio Configuration
         const audioEnabled = await confirm({

package/dist/cli/commands/restart.js

@@ -99,7 +99,7 @@ export const restartCommand = new Command('restart')
         // Initialize Web UI
         if (options.ui && config.ui.enabled) {
             try {
-                httpServer = new HttpServer();
+                httpServer = new HttpServer(oracle);
                 // Use CLI port if provided and valid, otherwise fallback to config or default
                 const port = parseInt(options.port) || config.ui.port || 3333;
                 httpServer.start(port);