morpheus-cli 0.2.8 → 0.3.1

package/README.md

@@ -97,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.
 
@@ -125,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 |
@@ -214,7 +224,7 @@ The Morpheus Telegram bot supports several commands for interacting with the age
 - `/zaion` - Show system configurations
 - `/sati <qnt>` - Show specific memories
 - `/newsession` - Archive current session and start fresh
-- `/sessions` - List all sessions and switch between them
+- `/sessions` - List all sessions with options to switch, archive, or delete
 - `/restart` - Restart the Morpheus agent
 - `/mcp` or `/mcps` - List registered MCP servers
 

package/dist/channels/telegram.js

@@ -187,9 +187,84 @@ export class TelegramAdapter {
                     ctx.reply(`✅ Switched to session ID: ${sessionId}`);
                 }
                 catch (error) {
-                    await ctx.answerCbQuery(`Error switching session: ${error.message}`);
+                    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' });
@@ -331,12 +406,22 @@ export class TelegramAdapter {
                 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') {
-                    keyboard.push([{
-                            text: `Switch to: ${title}`,
-                            callback_data: `switch_session_${session.id}`
-                        }]);
+                    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',
@@ -535,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 {
@@ -545,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
@@ -564,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;
                 }
             }

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

package/dist/cli/commands/start.js

@@ -79,7 +79,7 @@ export const startCommand = new Command('start')
         // 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);

package/dist/config/manager.js

@@ -54,18 +54,19 @@ export class ConfigManager {
             context_window: config.llm.context_window !== undefined ? resolveNumeric('MORPHEUS_LLM_CONTEXT_WINDOW', config.llm.context_window, DEFAULT_CONFIG.llm.context_window) : undefined
         };
         // Apply precedence to Sati config
-        let santiConfig;
-        if (config.santi) {
-            const santiProvider = resolveProvider('MORPHEUS_SANTI_PROVIDER', config.santi.provider, llmConfig.provider);
-            santiConfig = {
-                provider: santiProvider,
-                model: resolveModel(santiProvider, 'MORPHEUS_SANTI_MODEL', config.santi.model || llmConfig.model),
-                temperature: resolveNumeric('MORPHEUS_SANTI_TEMPERATURE', config.santi.temperature, llmConfig.temperature),
-                max_tokens: config.santi.max_tokens !== undefined ? resolveNumeric('MORPHEUS_SANTI_MAX_TOKENS', config.santi.max_tokens, config.santi.max_tokens) : llmConfig.max_tokens,
-                api_key: resolveApiKey(santiProvider, 'MORPHEUS_SANTI_API_KEY', config.santi.api_key || llmConfig.api_key),
-                base_url: config.santi.base_url || config.llm.base_url,
-                context_window: config.santi.context_window !== undefined ? resolveNumeric('MORPHEUS_SANTI_CONTEXT_WINDOW', config.santi.context_window, config.santi.context_window) : llmConfig.context_window,
-                memory_limit: config.santi.memory_limit !== undefined ? resolveNumeric('MORPHEUS_SANTI_MEMORY_LIMIT', config.santi.memory_limit, config.santi.memory_limit) : undefined
+        let satiConfig;
+        if (config.sati) {
+            const satiProvider = resolveProvider('MORPHEUS_SATI_PROVIDER', config.sati.provider, llmConfig.provider);
+            satiConfig = {
+                provider: satiProvider,
+                model: resolveModel(satiProvider, 'MORPHEUS_SATI_MODEL', config.sati.model || llmConfig.model),
+                temperature: resolveNumeric('MORPHEUS_SATI_TEMPERATURE', config.sati.temperature, llmConfig.temperature),
+                max_tokens: config.sati.max_tokens !== undefined ? resolveNumeric('MORPHEUS_SATI_MAX_TOKENS', config.sati.max_tokens, config.sati.max_tokens) : llmConfig.max_tokens,
+                api_key: resolveApiKey(satiProvider, 'MORPHEUS_SATI_API_KEY', config.sati.api_key || llmConfig.api_key),
+                base_url: config.sati.base_url || config.llm.base_url,
+                context_window: config.sati.context_window !== undefined ? resolveNumeric('MORPHEUS_SATI_CONTEXT_WINDOW', config.sati.context_window, config.sati.context_window) : llmConfig.context_window,
+                memory_limit: config.sati.memory_limit !== undefined ? resolveNumeric('MORPHEUS_SATI_MEMORY_LIMIT', config.sati.memory_limit, config.sati.memory_limit) : undefined,
+                enabled_archived_sessions: resolveBoolean('MORPHEUS_SATI_ENABLED_ARCHIVED_SESSIONS', config.sati.enabled_archived_sessions, true)
             };
         }
         // Apply precedence to audio config
@@ -107,7 +108,7 @@ export class ConfigManager {
         return {
             agent: agentConfig,
             llm: llmConfig,
-            santi: santiConfig,
+            sati: satiConfig,
             audio: audioConfig,
             channels: channelsConfig,
             ui: uiConfig,
@@ -137,10 +138,10 @@ export class ConfigManager {
         return this.config.llm;
     }
     getSatiConfig() {
-        if (this.config.santi) {
+        if (this.config.sati) {
             return {
                 memory_limit: 10, // Default if undefined
-                ...this.config.santi
+                ...this.config.sati
             };
         }
         // Fallback to main LLM config

package/dist/config/schemas.js

@@ -19,6 +19,7 @@ export const LLMConfigSchema = z.object({
 });
 export const SatiConfigSchema = LLMConfigSchema.extend({
     memory_limit: z.number().int().positive().optional(),
+    enabled_archived_sessions: z.boolean().default(true),
 });
 // Zod Schema matching MorpheusConfig interface
 export const ConfigSchema = z.object({
@@ -27,7 +28,7 @@ export const ConfigSchema = z.object({
         personality: z.string().default(DEFAULT_CONFIG.agent.personality),
     }).default(DEFAULT_CONFIG.agent),
     llm: LLMConfigSchema.default(DEFAULT_CONFIG.llm),
-    santi: SatiConfigSchema.optional(),
+    sati: SatiConfigSchema.optional(),
     audio: AudioConfigSchema.default(DEFAULT_CONFIG.audio),
     memory: z.object({
         limit: z.number().int().positive().optional(),

package/dist/http/__tests__/config_api.test.js

@@ -27,10 +27,15 @@ describe('Config API', () => {
             log: vi.fn(),
         };
         DisplayManager.getInstance.mockReturnValue(mockDisplayManager);
+        // Mock Oracle instance
+        const mockOracle = {
+            think: vi.fn(),
+            getMemory: vi.fn(),
+        };
         // Setup App
         app = express();
         app.use(bodyParser.json());
-        app.use('/api', createApiRouter());
+        app.use('/api', createApiRouter(mockOracle));
     });
     afterEach(() => {
         vi.restoreAllMocks();

package/dist/http/api.js

@@ -20,14 +20,146 @@ async function readLastLines(filePath, n) {
         return [];
     }
 }
-export function createApiRouter() {
+export function createApiRouter(oracle) {
     const router = Router();
     const configManager = ConfigManager.getInstance();
     const history = new SQLiteChatMessageHistory({ sessionId: 'api-reader' });
+    // --- Session Management ---
+    router.get('/sessions', async (req, res) => {
+        try {
+            const allSessions = await history.listSessions();
+            res.json(allSessions);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.post('/sessions', async (req, res) => {
+        try {
+            await history.createNewSession();
+            const newSessionId = await history.getCurrentSessionOrCreate(); // Should be the new one
+            res.json({ success: true, id: newSessionId, message: 'New session started' });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.delete('/sessions/:id', async (req, res) => {
+        try {
+            const { id } = req.params;
+            await history.deleteSession(id);
+            res.json({ success: true, message: 'Session deleted' });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.post('/sessions/:id/archive', async (req, res) => {
+        try {
+            const { id } = req.params;
+            await history.archiveSession(id);
+            res.json({ success: true, message: 'Session archived' });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.patch('/sessions/:id/title', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const { title } = req.body;
+            if (!title) {
+                return res.status(400).json({ error: 'Title is required' });
+            }
+            await history.renameSession(id, title);
+            res.json({ success: true, message: 'Session renamed' });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.get('/sessions/:id/messages', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const sessionHistory = new SQLiteChatMessageHistory({ sessionId: id, limit: 100 });
+            const messages = await sessionHistory.getMessages();
+            // Normalize messages for UI
+            const key = (msg) => msg._getType(); // Access internal type if available, or infer
+            const normalizedMessages = messages.map((msg) => {
+                const type = msg._getType ? msg._getType() : 'unknown';
+                return {
+                    type,
+                    content: msg.content,
+                    tool_calls: msg.tool_calls,
+                    usage_metadata: msg.usage_metadata
+                };
+            });
+            // Reverse to chronological order for UI
+            res.json(normalizedMessages.reverse());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // --- Chat Interaction ---
+    router.post('/chat', async (req, res) => {
+        try {
+            const { message, sessionId } = req.body;
+            if (!message || !sessionId) {
+                return res.status(400).json({ error: 'Message and Session ID are required' });
+            }
+            // We need to ensure the Oracle uses the correct session history.
+            // The Oracle class uses its own internal history instance.
+            // We might need to refactor Oracle to accept a session ID per request or 
+            // instantiate a temporary Oracle wrapper/context?
+            //
+            // ACTUALLY: The Oracle class uses `this.history`. 
+            // `SQLiteChatMessageHistory` takes `sessionId` in constructor.
+            // To support multi-session chat via API, we should probably allow passing sessionId to `chat()` 
+            // OR (cleaner for now) we can rely on the fact that `Oracle` might not support swapping sessions easily without
+            // re-initialization or we extend `oracle.chat` to support overriding session.
+            //
+            // Let's look at `Oracle.chat`: it uses `this.history`.
+            // And `SQLiteChatMessageHistory` is tied to a sessionId.
+            //
+            // Quick fix for this feature:
+            // We can use a trick: `Oracle` allows `overrides` in constructor but that's for db path.
+            // `Oracle` initializes `this.history` in `initialize`.
+            // Better approach:
+            // We can temporarily switch the session of the Oracle's history if it exposes it,
+            // OR we just instantiate a fresh history for the chat request and use the provider?
+            // No, `oracle.chat` encapsulates the provider invocation.
+            // Let's check `Oracle` class again. (I viewed it earlier).
+            // It has `private history`.
+            // SOLUTION:
+            // I will add a `setSessionId(id: string)` method to `Oracle` interface and class.
+            // OR pass `sessionId` to `chat`.
+            // For now, I will assume I can update `Oracle` to support dynamic sessions.
+            // I'll modify `Oracle.chat` signature in a separate step if needed. 
+            // Wait, `Oracle` is a singleton-ish in `start.ts`.
+            // Let's modify `Oracle` to accept `sessionId` in `chat`?
+            // `chat(message: string, extraUsage?: UsageMetadata, isTelephonist?: boolean)`
+            //
+            // Adding `sessionId` to `chat` seems invasive if not threaded fast.
+            //
+            // Alternative:
+            // `router.post('/chat')` instantiates a *new* Oracle? No, expensive (provider factory).
+            //
+            // Ideally `Oracle` should be stateless regarding session, or easily switchable.
+            // `SQLiteChatMessageHistory` is cheap to instantiate.
+            //
+            // Let's update `Oracle` to allow switching session.
+            // `oracle.switchSession(sessionId)`
+            await oracle.setSessionId(sessionId); // Type cast for now, will implement next
+            const response = await oracle.chat(message);
+            res.json({ response });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // Legacy /session/reset (keep for backward compat or redirect to POST /sessions)
     router.post('/session/reset', async (req, res) => {
-        // if (!oracle) {
-        //   return res.status(503).json({ error: 'Oracle unavailable' });
-        // }
         try {
             await history.createNewSession();
             res.json({ success: true, message: 'New session started' });
@@ -179,7 +311,7 @@ export function createApiRouter() {
     router.post('/config/sati', async (req, res) => {
         try {
             const config = configManager.get();
-            await configManager.save({ ...config, santi: req.body });
+            await configManager.save({ ...config, sati: req.body });
             const display = DisplayManager.getInstance();
             display.log('Sati configuration updated via UI', {
                 source: 'Zaion',
@@ -199,7 +331,7 @@ export function createApiRouter() {
     router.delete('/config/sati', async (req, res) => {
         try {
             const config = configManager.get();
-            const { santi, ...restConfig } = config;
+            const { sati: sati, ...restConfig } = config;
             await configManager.save(restConfig);
             const display = DisplayManager.getInstance();
             display.log('Sati configuration removed via UI (falling back to Oracle config)', {