morpheus-cli 0.4.14 → 0.5.0

package/dist/channels/telegram.js

@@ -13,30 +13,101 @@ import { SQLiteChatMessageHistory } from '../runtime/memory/sqlite.js';
 import { SatiRepository } from '../runtime/memory/sati/repository.js';
 import { MCPManager } from '../config/mcp-manager.js';
 import { Construtor } from '../runtime/tools/factory.js';
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+/** Strips HTML tags and unescapes entities for plain-text Telegram fallback. */
+function stripHtmlTags(html) {
+    return html
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<\/?(p|div|li|tr)[^>]*>/gi, '\n')
+        .replace(/<[^>]+>/g, '')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .trim();
+}
 /**
- * Converts standard Markdown (as produced by LLMs) to Telegram MarkdownV2.
- * Unsupported tags (e.g. tables) have their special chars escaped so they
- * render as plain text instead of breaking the parse.
- * Truncates to Telegram's 4096-char hard limit.
- * Use for dynamic LLM/Oracle output.
+ * Splits an HTML string into chunks ≤ maxLen that never break inside an HTML tag.
+ * Prefers splitting at paragraph (double newline) or line boundaries.
  */
-// Cached dynamic import of telegram-markdown-v2 (ESM-safe, loaded once on first use)
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let _convertFn = null;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function getConvert() {
-    if (!_convertFn) {
-        const mod = await import('telegram-markdown-v2');
-        _convertFn = mod.convert;
+function splitHtmlChunks(html, maxLen = 4096) {
+    if (html.length <= maxLen)
+        return [html];
+    const chunks = [];
+    let remaining = html.trim();
+    while (remaining.length > maxLen) {
+        let splitAt = -1;
+        for (const sep of ['\n\n', '\n', ' ']) {
+            const pos = remaining.lastIndexOf(sep, maxLen - 1);
+            if (pos < maxLen / 4)
+                continue; // avoid tiny first chunks
+            // Confirm position is not inside an HTML tag
+            const before = remaining.slice(0, pos);
+            const lastOpen = before.lastIndexOf('<');
+            const lastClose = before.lastIndexOf('>');
+            if (lastOpen > lastClose)
+                continue; // inside a tag — try next separator
+            splitAt = pos + sep.length;
+            break;
+        }
+        if (splitAt <= 0) {
+            // Fallback: split right after the last closing '>' before maxLen
+            const closing = remaining.lastIndexOf('>', maxLen - 1);
+            splitAt = closing > 0 ? closing + 1 : maxLen;
+        }
+        const chunk = remaining.slice(0, splitAt).trim();
+        if (chunk)
+            chunks.push(chunk);
+        remaining = remaining.slice(splitAt).trim();
     }
-    return _convertFn;
+    if (remaining)
+        chunks.push(remaining);
+    return chunks.filter(Boolean);
 }
-async function toMd(text) {
-    const MAX = 4096;
-    const convert = await getConvert();
-    const converted = convert(text, 'escape');
-    const safe = converted.length > MAX ? converted.slice(0, MAX - 3) + '\\.\\.\\.' : converted;
-    return { text: safe, parse_mode: 'MarkdownV2' };
+async function toTelegramRichText(text) {
+    let source = String(text ?? '').replace(/\r\n/g, '\n');
+    const uuidRegex = /\b([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})\b/g;
+    const codeBlocks = [];
+    source = source.replace(/```([a-zA-Z0-9_-]+)?\n?([\s\S]*?)```/g, (_m, _lang, code) => {
+        const idx = codeBlocks.push(`<pre><code>${escapeHtml(String(code).trimEnd())}</code></pre>`) - 1;
+        return `@@CODEBLOCK_${idx}@@`;
+    });
+    const inlineCodes = [];
+    source = source.replace(/`([^`\n]+)`/g, (_m, code) => {
+        const idx = inlineCodes.push(`<code>${escapeHtml(code)}</code>`) - 1;
+        return `@@INLINECODE_${idx}@@`;
+    });
+    const links = [];
+    source = source.replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g, (_m, label, url) => {
+        const safeUrl = String(url).replace(/"/g, '&quot;');
+        const idx = links.push(`<a href="${safeUrl}">${escapeHtml(label)}</a>`) - 1;
+        return `@@LINK_${idx}@@`;
+    });
+    // Markdown bullets become visible bullets in Telegram HTML mode.
+    source = source.replace(/^(\s*)[-*]\s+/gm, '$1• ');
+    // Escape user/model content before reinserting HTML tags.
+    source = escapeHtml(source);
+    // Headings -> bold lines
+    source = source.replace(/^#{1,6}\s+(.+)$/gm, (_m, title) => `<b>${title.trim()}</b>`);
+    // Bold
+    source = source.replace(/\*\*([\s\S]+?)\*\*/g, '<b>$1</b>');
+    source = source.replace(/__([\s\S]+?)__/g, '<b>$1</b>');
+    // Italic (conservative)
+    source = source.replace(/(^|[\s(])\*([^*\n]+)\*(?=[$\s).,!?:;])/gm, '$1<i>$2</i>');
+    source = source.replace(/(^|[\s(])_([^_\n]+)_(?=[$\s).,!?:;])/gm, '$1<i>$2</i>');
+    // Make task/session IDs easier to copy in Telegram.
+    source = source.replace(uuidRegex, '<code>$1</code>');
+    // Restore placeholders
+    source = source.replace(/@@CODEBLOCK_(\d+)@@/g, (_m, idx) => codeBlocks[Number(idx)] || '');
+    source = source.replace(/@@INLINECODE_(\d+)@@/g, (_m, idx) => inlineCodes[Number(idx)] || '');
+    source = source.replace(/@@LINK_(\d+)@@/g, (_m, idx) => links[Number(idx)] || '');
+    return { chunks: splitHtmlChunks(source.trim()), parse_mode: 'HTML' };
 }
 /**
  * Escapes special characters in a plain string segment so it's safe to embed
@@ -78,7 +149,7 @@ export class TelegramAdapter {
 /stats \\- Show token usage statistics
 /help \\- Show available commands
 /zaion \\- Show system configurations
-/sati <qnt> \\- Show specific memories
+/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
@@ -123,14 +194,26 @@ export class TelegramAdapter {
                 try {
                     // Send "typing" status
                     await ctx.sendChatAction('typing');
+                    const sessionId = await this.history.getCurrentSessionOrCreate();
+                    await this.oracle.setSessionId(sessionId);
                     // Process with Agent
-                    const response = await this.oracle.chat(text);
+                    const response = await this.oracle.chat(text, undefined, false, {
+                        origin_channel: 'telegram',
+                        session_id: sessionId,
+                        origin_message_id: String(ctx.message.message_id),
+                        origin_user_id: userId,
+                    });
                     if (response) {
-                        try {
-                            await ctx.reply((await toMd(response)).text, { parse_mode: 'MarkdownV2' });
-                        }
-                        catch {
-                            await ctx.reply(response);
+                        const rich = await toTelegramRichText(response);
+                        for (const chunk of rich.chunks) {
+                            try {
+                                await ctx.reply(chunk, { parse_mode: rich.parse_mode });
+                            }
+                            catch {
+                                const plain = stripHtmlTags(chunk).slice(0, 4096);
+                                if (plain)
+                                    await ctx.reply(plain);
+                            }
                         }
                         this.display.log(`Responded to @${user}: ${response}`, { source: 'Telegram' });
                     }
@@ -200,8 +283,15 @@ export class TelegramAdapter {
                     // So I should treat 'text' as if it was a text message.
                     await ctx.reply(`🎤 Transcription: "${text}"`);
                     await ctx.sendChatAction('typing');
+                    const sessionId = await this.history.getCurrentSessionOrCreate();
+                    await this.oracle.setSessionId(sessionId);
                     // Process with Agent
-                    const response = await this.oracle.chat(text, usage, true);
+                    const response = await this.oracle.chat(text, usage, true, {
+                        origin_channel: 'telegram',
+                        session_id: sessionId,
+                        origin_message_id: String(ctx.message.message_id),
+                        origin_user_id: userId,
+                    });
                     // if (listeningMsg) {
                     //   try {
                     //     await ctx.telegram.deleteMessage(ctx.chat.id, listeningMsg.message_id);
@@ -210,11 +300,16 @@ export class TelegramAdapter {
                     //   }
                     // }
                     if (response) {
-                        try {
-                            await ctx.reply((await toMd(response)).text, { parse_mode: 'MarkdownV2' });
-                        }
-                        catch {
-                            await ctx.reply(response);
+                        const rich = await toTelegramRichText(response);
+                        for (const chunk of rich.chunks) {
+                            try {
+                                await ctx.reply(chunk, { parse_mode: rich.parse_mode });
+                            }
+                            catch {
+                                const plain = stripHtmlTags(chunk).slice(0, 4096);
+                                if (plain)
+                                    await ctx.reply(plain);
+                            }
                         }
                         this.display.log(`Responded to @${user} (via audio)`, { source: 'Telegram' });
                     }
@@ -405,18 +500,10 @@ export class TelegramAdapter {
         await fs.writeFile(filePath, buffer);
         return filePath;
     }
-    /**
-     * Escapes a string for Telegram MarkdownV2 format.
-     * All special characters outside code spans must be escaped with a backslash.
-     */
-    escapeMarkdownV2(text) {
-        // Characters that must be escaped in MarkdownV2 outside of code/pre blocks
-        return text.replace(/([_*[\]()~`>#+\-=|{}.!\\])/g, '\\$1');
-    }
     /**
      * Sends a proactive message to all allowed Telegram users.
      * Used by the webhook notification system to push results.
-     * Tries plain text first to avoid Markdown parse errors from LLM output.
+     * Uses Telegram HTML parse mode for richer formatting, with plain-text fallback.
      */
     async sendMessage(text) {
         if (!this.isConnected || !this.bot) {
@@ -428,22 +515,39 @@ export class TelegramAdapter {
             this.display.log('No allowed Telegram users configured — skipping notification.', { source: 'Telegram', level: 'warning' });
             return;
         }
-        // toMd() already truncates to 4096 chars (Telegram's hard limit)
-        const { text: mdText, parse_mode } = await toMd(text);
+        const rich = await toTelegramRichText(text);
         for (const userId of allowedUsers) {
+            for (const chunk of rich.chunks) {
+                try {
+                    await this.bot.telegram.sendMessage(userId, chunk, { parse_mode: rich.parse_mode });
+                }
+                catch {
+                    try {
+                        const plain = stripHtmlTags(chunk).slice(0, 4096);
+                        if (plain)
+                            await this.bot.telegram.sendMessage(userId, plain);
+                    }
+                    catch (err) {
+                        this.display.log(`Failed to send message chunk to Telegram user ${userId}: ${err.message}`, { source: 'Telegram', level: 'error' });
+                    }
+                }
+            }
+        }
+    }
+    async sendMessageToUser(userId, text) {
+        if (!this.isConnected || !this.bot) {
+            this.display.log('Cannot send direct message: Telegram bot not connected.', { source: 'Telegram', level: 'warning' });
+            return;
+        }
+        const rich = await toTelegramRichText(text);
+        for (const chunk of rich.chunks) {
             try {
-                await this.bot.telegram.sendMessage(userId, mdText, { parse_mode });
+                await this.bot.telegram.sendMessage(userId, chunk, { parse_mode: rich.parse_mode });
             }
             catch {
-                // Fallback to plain text if MarkdownV2 conversion still fails
-                try {
-                    const MAX_LEN = 4096;
-                    const plain = text.length > MAX_LEN ? text.slice(0, MAX_LEN - 3) + '...' : text;
+                const plain = stripHtmlTags(chunk).slice(0, 4096);
+                if (plain)
                     await this.bot.telegram.sendMessage(userId, plain);
-                }
-                catch (err) {
-                    this.display.log(`Failed to send message to Telegram user ${userId}: ${err.message}`, { source: 'Telegram', level: 'error' });
-                }
             }
         }
     }
@@ -622,7 +726,7 @@ How can I assist you today?`;
             response += `✅ Node\\.js: ${escMd(nodeVersion)}\n`;
         }
         else {
-            response += `❌ Node\\.js: ${escMd(nodeVersion)} \\(Required: >=18\\)\n`;
+            response += `❌ Node\\.js: ${escMd(nodeVersion)} \\(Required: \\>\\=18\\)\n`;
         }
         if (config) {
             response += '✅ Configuration: Valid\n';
@@ -672,6 +776,17 @@ How can I assist you today?`;
                     response += `❌ Apoc API key missing \\(${escMd(apocProvider)}\\)\n`;
                 }
             }
+            // Neo
+            const neo = config.neo;
+            const neoProvider = neo?.provider || llmProvider;
+            if (neoProvider && neoProvider !== 'ollama') {
+                if (hasApiKey(neoProvider, neo?.api_key ?? config.llm?.api_key)) {
+                    response += `✅ Neo API key \\(${escMd(neoProvider)}\\)\n`;
+                }
+                else {
+                    response += `❌ Neo API key missing \\(${escMd(neoProvider)}\\)\n`;
+                }
+            }
             // Telegram token
             if (config.channels?.telegram?.enabled) {
                 const hasTelegramToken = config.channels.telegram?.token || process.env.TELEGRAM_BOT_TOKEN;
@@ -755,11 +870,16 @@ How can I assist you today?`;
     Só faça isso agora.`;
         let response = await this.oracle.chat(prompt);
         if (response) {
-            try {
-                await ctx.reply((await toMd(response)).text, { parse_mode: 'MarkdownV2' });
-            }
-            catch {
-                await ctx.reply(response);
+            const rich = await toTelegramRichText(response);
+            for (const chunk of rich.chunks) {
+                try {
+                    await ctx.reply(chunk, { parse_mode: rich.parse_mode });
+                }
+                catch {
+                    const plain = stripHtmlTags(chunk).slice(0, 4096);
+                    if (plain)
+                        await ctx.reply(plain);
+                }
             }
         }
         // await ctx.reply(`Command not recognized. Type /help to see available commands.`);
@@ -807,6 +927,22 @@ How can I assist you today?`;
             response += `\\- Inherits Oracle config\n`;
         }
         response += '\n';
+        // Neo config (falls back to llm if not set)
+        const neo = config.neo;
+        response += `*Neo \\(MCP \\+ Internal Tools\\):*\n`;
+        if (neo?.provider) {
+            response += `\\- Provider: ${escMd(neo.provider)}\n`;
+            response += `\\- Model: ${escMd(neo.model || config.llm.model)}\n`;
+            response += `\\- Temperature: ${escMd(neo.temperature ?? 0.2)}\n`;
+            response += `\\- Context Window: ${escMd(neo.context_window ?? config.llm.context_window ?? 100)}\n`;
+            if (neo.max_tokens !== undefined) {
+                response += `\\- Max Tokens: ${escMd(neo.max_tokens)}\n`;
+            }
+        }
+        else {
+            response += `\\- Inherits Oracle config\n`;
+        }
+        response += '\n';
         response += `*Channels:*\n`;
         response += `\\- Telegram Enabled: ${escMd(config.channels.telegram.enabled)}\n`;
         response += `\\- Discord Enabled: ${escMd(config.channels.discord.enabled)}\n\n`;
@@ -828,28 +964,29 @@ How can I assist you today?`;
             }
         }
         try {
-            // Usar o repositório SATI para obter memórias de longo prazo
             const repository = SatiRepository.getInstance();
             const memories = repository.getAllMemories();
             if (memories.length === 0) {
-                await ctx.reply(`No memories found.`);
+                await ctx.reply('No memories found.');
                 return;
             }
-            // Se nenhum limite for especificado, usar todas as memórias
-            let selectedMemories = memories;
-            if (limit !== null) {
-                selectedMemories = memories.slice(0, Math.min(limit, memories.length));
-            }
+            const selectedMemories = limit !== null
+                ? memories.slice(0, Math.min(limit, memories.length))
+                : memories;
             const countLabel = limit !== null
-                ? `${escMd(selectedMemories.length)} SATI Memories \\(Showing first ${escMd(selectedMemories.length)}\\)`
-                : `${escMd(selectedMemories.length)} SATI Memories`;
-            let response = `*${countLabel}:*\n\n`;
+                ? `${selectedMemories.length} SATI Memories (showing first ${selectedMemories.length})`
+                : `${selectedMemories.length} SATI Memories`;
+            let html = `<b>${escapeHtml(countLabel)}:</b>\n\n`;
             for (const memory of selectedMemories) {
-                // Limitar o tamanho do resumo para evitar mensagens muito longas
-                const truncatedSummary = memory.summary.length > 200 ? memory.summary.substring(0, 200) + '...' : memory.summary;
-                response += `*${escMd(memory.category)} \\(${escMd(memory.importance)}\\):* ${escMd(truncatedSummary)}\n\n`;
+                const summary = memory.summary.length > 200
+                    ? memory.summary.substring(0, 200) + '...'
+                    : memory.summary;
+                html += `<b>${escapeHtml(memory.category)} (${escapeHtml(memory.importance)}):</b> ${escapeHtml(summary)}\n\n`;
+            }
+            const chunks = splitHtmlChunks(html.trim());
+            for (const chunk of chunks) {
+                await ctx.reply(chunk, { parse_mode: 'HTML' });
             }
-            await ctx.reply(response, { parse_mode: 'MarkdownV2' });
         }
         catch (error) {
             await ctx.reply(`Failed to retrieve memories: ${error.message}`);

package/dist/cli/commands/doctor.js

@@ -50,6 +50,8 @@ export const doctorCommand = new Command('doctor')
             // Check API keys availability for active providers
             const llmProvider = config.llm?.provider;
             const satiProvider = config.sati?.provider;
+            const apocProvider = config.apoc?.provider || llmProvider;
+            const neoProvider = config.neo?.provider || llmProvider;
             // Check LLM provider API key
             if (llmProvider && llmProvider !== 'ollama') {
                 const hasLlmApiKey = config.llm?.api_key ||
@@ -80,6 +82,38 @@ export const doctorCommand = new Command('doctor')
                     allPassed = false;
                 }
             }
+            // Check Apoc provider API key
+            if (apocProvider && apocProvider !== 'ollama') {
+                const hasApocApiKey = config.apoc?.api_key ||
+                    config.llm?.api_key ||
+                    (apocProvider === 'openai' && process.env.OPENAI_API_KEY) ||
+                    (apocProvider === 'anthropic' && process.env.ANTHROPIC_API_KEY) ||
+                    (apocProvider === 'gemini' && process.env.GOOGLE_API_KEY) ||
+                    (apocProvider === 'openrouter' && process.env.OPENROUTER_API_KEY);
+                if (hasApocApiKey) {
+                    console.log(chalk.green('✓') + ` Apoc API key available for ${apocProvider}`);
+                }
+                else {
+                    console.log(chalk.red('✗') + ` Apoc API key missing for ${apocProvider}. Either set in config or define environment variable.`);
+                    allPassed = false;
+                }
+            }
+            // Check Neo provider API key
+            if (neoProvider && neoProvider !== 'ollama') {
+                const hasNeoApiKey = config.neo?.api_key ||
+                    config.llm?.api_key ||
+                    (neoProvider === 'openai' && process.env.OPENAI_API_KEY) ||
+                    (neoProvider === 'anthropic' && process.env.ANTHROPIC_API_KEY) ||
+                    (neoProvider === 'gemini' && process.env.GOOGLE_API_KEY) ||
+                    (neoProvider === 'openrouter' && process.env.OPENROUTER_API_KEY);
+                if (hasNeoApiKey) {
+                    console.log(chalk.green('✓') + ` Neo API key available for ${neoProvider}`);
+                }
+                else {
+                    console.log(chalk.red('✗') + ` Neo API key missing for ${neoProvider}. Either set in config or define environment variable.`);
+                    allPassed = false;
+                }
+            }
             // Check audio API key if enabled
             if (config.audio?.enabled && config.llm?.provider !== 'gemini') {
                 const hasAudioApiKey = config.audio?.apiKey || process.env.GOOGLE_API_KEY;

package/dist/cli/commands/init.js

@@ -208,6 +208,134 @@ export const initCommand = new Command('init')
         if (satiApiKey) {
             await configManager.set('sati.api_key', satiApiKey);
         }
+        // Neo (MCP + Internal Tools Agent) Configuration
+        display.log(chalk.blue('\nNeo (MCP + Internal Tools Agent) Configuration'));
+        const configureNeo = await select({
+            message: 'Configure Neo separately?',
+            choices: [
+                { name: 'No (Use Oracle provider/model defaults)', value: 'no' },
+                { name: 'Yes', value: 'yes' },
+            ],
+            default: currentConfig.neo ? 'yes' : 'no',
+        });
+        let neoProvider = provider;
+        let neoModel = model;
+        let neoTemperature = currentConfig.neo?.temperature ?? 0.2;
+        let neoContextWindow = currentConfig.neo?.context_window ?? Number(contextWindow);
+        let neoMaxTokens = currentConfig.neo?.max_tokens;
+        let neoApiKey = currentConfig.neo?.api_key || apiKey || currentConfig.llm.api_key;
+        let neoBaseUrl = provider === 'openrouter'
+            ? (currentConfig.neo?.base_url || currentConfig.llm.base_url || 'https://openrouter.ai/api/v1')
+            : undefined;
+        if (configureNeo === 'yes') {
+            neoProvider = await select({
+                message: 'Select Neo LLM Provider:',
+                choices: [
+                    { name: 'OpenAI', value: 'openai' },
+                    { name: 'Anthropic', value: 'anthropic' },
+                    { name: 'OpenRouter', value: 'openrouter' },
+                    { name: 'Ollama', value: 'ollama' },
+                    { name: 'Google Gemini', value: 'gemini' },
+                ],
+                default: currentConfig.neo?.provider || provider,
+            });
+            let defaultNeoModel = 'gpt-3.5-turbo';
+            switch (neoProvider) {
+                case 'openai':
+                    defaultNeoModel = 'gpt-4o';
+                    break;
+                case 'anthropic':
+                    defaultNeoModel = 'claude-3-5-sonnet-20240620';
+                    break;
+                case 'openrouter':
+                    defaultNeoModel = 'openrouter/auto';
+                    break;
+                case 'ollama':
+                    defaultNeoModel = 'llama3';
+                    break;
+                case 'gemini':
+                    defaultNeoModel = 'gemini-pro';
+                    break;
+            }
+            if (neoProvider === currentConfig.neo?.provider) {
+                defaultNeoModel = currentConfig.neo?.model || defaultNeoModel;
+            }
+            neoModel = await input({
+                message: 'Enter Neo Model Name:',
+                default: defaultNeoModel,
+            });
+            const neoTemperatureInput = await input({
+                message: 'Neo Temperature (0-1):',
+                default: (currentConfig.neo?.temperature ?? 0.2).toString(),
+                validate: (val) => {
+                    const n = Number(val);
+                    return (!isNaN(n) && n >= 0 && n <= 1) || 'Must be a number between 0 and 1';
+                },
+            });
+            neoTemperature = Number(neoTemperatureInput);
+            const neoContextWindowInput = await input({
+                message: 'Neo Context Window (messages):',
+                default: (currentConfig.neo?.context_window ?? Number(contextWindow)).toString(),
+                validate: (val) => (!isNaN(Number(val)) && Number(val) > 0) || 'Must be a positive number',
+            });
+            neoContextWindow = Number(neoContextWindowInput);
+            const neoMaxTokensInput = await input({
+                message: 'Neo Max Tokens (optional, leave empty for model default):',
+                default: currentConfig.neo?.max_tokens?.toString() || '',
+                validate: (val) => {
+                    if (val.trim() === '')
+                        return true;
+                    return (!isNaN(Number(val)) && Number(val) > 0) || 'Must be a positive number';
+                },
+            });
+            neoMaxTokens = neoMaxTokensInput.trim() === '' ? undefined : Number(neoMaxTokensInput);
+            if (neoProvider !== 'ollama') {
+                const hasExistingNeoKey = !!currentConfig.neo?.api_key || !!currentConfig.llm?.api_key;
+                let neoKeyMsg = hasExistingNeoKey
+                    ? 'Enter Neo API Key (leave empty to preserve existing, or if using env vars):'
+                    : 'Enter Neo API Key (leave empty if using env vars):';
+                if (neoProvider === 'openai') {
+                    neoKeyMsg = `${neoKeyMsg} (Env vars: MORPHEUS_NEO_API_KEY / OPENAI_API_KEY)`;
+                }
+                else if (neoProvider === 'anthropic') {
+                    neoKeyMsg = `${neoKeyMsg} (Env vars: MORPHEUS_NEO_API_KEY / ANTHROPIC_API_KEY)`;
+                }
+                else if (neoProvider === 'gemini') {
+                    neoKeyMsg = `${neoKeyMsg} (Env vars: MORPHEUS_NEO_API_KEY / GOOGLE_API_KEY)`;
+                }
+                else if (neoProvider === 'openrouter') {
+                    neoKeyMsg = `${neoKeyMsg} (Env vars: MORPHEUS_NEO_API_KEY / OPENROUTER_API_KEY)`;
+                }
+                const neoKeyInput = await password({ message: neoKeyMsg });
+                if (neoKeyInput) {
+                    neoApiKey = neoKeyInput;
+                }
+                else {
+                    neoApiKey = currentConfig.neo?.api_key || currentConfig.llm?.api_key;
+                }
+            }
+            if (neoProvider === 'openrouter') {
+                neoBaseUrl = await input({
+                    message: 'Enter Neo OpenRouter Base URL:',
+                    default: currentConfig.neo?.base_url || currentConfig.llm.base_url || 'https://openrouter.ai/api/v1',
+                });
+            }
+            else {
+                neoBaseUrl = undefined;
+            }
+        }
+        await configManager.save({
+            ...configManager.get(),
+            neo: {
+                provider: neoProvider,
+                model: neoModel,
+                temperature: neoTemperature,
+                context_window: neoContextWindow,
+                max_tokens: neoMaxTokens,
+                api_key: neoApiKey,
+                base_url: neoBaseUrl,
+            },
+        });
         // Audio Configuration
         const audioEnabled = await confirm({
             message: 'Enable Audio Transcription? (Requires Gemini)',

package/dist/cli/commands/restart.js

@@ -12,6 +12,10 @@ import { Oracle } from '../../runtime/oracle.js';
 import { ProviderError } from '../../runtime/errors.js';
 import { HttpServer } from '../../http/server.js';
 import { getVersion } from '../utils/version.js';
+import { TaskWorker } from '../../runtime/tasks/worker.js';
+import { TaskNotifier } from '../../runtime/tasks/notifier.js';
+import { TaskDispatcher } from '../../runtime/tasks/dispatcher.js';
+import { WebhookDispatcher } from '../../runtime/webhooks/dispatcher.js';
 export const restartCommand = new Command('restart')
     .description('Restart the Morpheus agent')
     .option('--ui', 'Enable web UI', true)
@@ -96,6 +100,9 @@ export const restartCommand = new Command('restart')
         }
         const adapters = [];
         let httpServer;
+        const taskWorker = new TaskWorker();
+        const taskNotifier = new TaskNotifier();
+        const asyncTasksEnabled = config.runtime?.async_tasks?.enabled !== false;
         // Initialize Web UI
         if (options.ui && config.ui.enabled) {
             try {
@@ -114,6 +121,8 @@ export const restartCommand = new Command('restart')
                 const telegram = new TelegramAdapter(oracle);
                 try {
                     await telegram.connect(config.channels.telegram.token, config.channels.telegram.allowedUsers || []);
+                    WebhookDispatcher.setTelegramAdapter(telegram);
+                    TaskDispatcher.setTelegramAdapter(telegram);
                     adapters.push(telegram);
                 }
                 catch (e) {
@@ -124,6 +133,10 @@ export const restartCommand = new Command('restart')
                 display.log(chalk.yellow('Telegram enabled but no token provided. Skipping.'));
             }
         }
+        if (asyncTasksEnabled) {
+            taskWorker.start();
+            taskNotifier.start();
+        }
         // Handle graceful shutdown
         const shutdown = async (signal) => {
             display.stopSpinner();
@@ -134,6 +147,10 @@ export const restartCommand = new Command('restart')
             for (const adapter of adapters) {
                 await adapter.disconnect();
             }
+            if (asyncTasksEnabled) {
+                taskWorker.stop();
+                taskNotifier.stop();
+            }
             await clearPid();
             process.exit(0);
         };