morpheus-cli 0.5.0 → 0.5.2

package/README.md

@@ -18,6 +18,7 @@ It runs as a daemon and orchestrates LLMs, MCP tools, DevKit tools, memory, and
 - `Neo`: MCP and internal operational tools (config, diagnostics, analytics).
 - `Apoc`: DevTools/browser execution (filesystem, shell, git, network, packages, processes, system, browser automation).
 - `Sati`: long-term memory retrieval/evaluation.
+- `Trinity`: database specialist. Executes queries, introspects schemas, and manages registered databases (PostgreSQL, MySQL, SQLite, MongoDB).
 
 ## Installation
 
@@ -68,10 +69,10 @@ morpheus session status
 Morpheus uses asynchronous delegation by default:
 
 1. Oracle receives user request.
-2. If execution is needed, Oracle calls `neo_delegate` or `apoc_delegate`.
+2. If execution is needed, Oracle calls `neo_delegate`, `apoc_delegate`, or `trinity_delegate`.
 3. Delegate tool creates a row in `tasks` table with origin metadata (`channel`, `session`, `message`, `user`).
 4. Oracle immediately acknowledges task creation.
-5. `TaskWorker` executes pending tasks.
+5. `TaskWorker` executes pending tasks (routes `trinit` tasks to Trinity agent).
 6. `TaskNotifier` sends completion/failure through `TaskDispatcher`.
 
 Important behavior:
@@ -94,11 +95,13 @@ Task results are delivered proactively with metadata (task id, agent, status) an
 The dashboard includes:
 - Chat with session management
 - Tasks page (stats, filters, details, retry)
-- Agent settings (Oracle/Sati/Neo/Apoc)
-- MCP manager
-- Sati memories
+- Agent settings (Oracle/Sati/Neo/Apoc/Trinity)
+- MCP manager (add/edit/delete/toggle/reload)
+- Sati memories (search, bulk delete)
 - Usage stats and model pricing
+- Trinity databases (register/test/refresh schema)
 - Webhooks and notification inbox
+- Logs viewer
 
 Chat-specific rendering:
 - AI messages rendered as markdown
@@ -140,6 +143,11 @@ apoc:
   working_dir: /home/user/projects
   timeout_ms: 30000
 
+trinity:
+  provider: openai
+  model: gpt-4o-mini
+  temperature: 0.2
+
 runtime:
   async_tasks:
     enabled: true
@@ -178,6 +186,9 @@ Provider-specific keys:
 - `TELEGRAM_BOT_TOKEN`
 - `THE_ARCHITECT_PASS`
 
+Security:
+- `MORPHEUS_SECRET` — AES-256-GCM key for encrypting Trinity database passwords (required when using Trinity)
+
 Generic Morpheus overrides (selected):
 
 | Variable | Target |
@@ -213,6 +224,10 @@ Generic Morpheus overrides (selected):
 | `MORPHEUS_APOC_API_KEY` | `apoc.api_key` |
 | `MORPHEUS_APOC_WORKING_DIR` | `apoc.working_dir` |
 | `MORPHEUS_APOC_TIMEOUT_MS` | `apoc.timeout_ms` |
+| `MORPHEUS_TRINITY_PROVIDER` | `trinity.provider` |
+| `MORPHEUS_TRINITY_MODEL` | `trinity.model` |
+| `MORPHEUS_TRINITY_TEMPERATURE` | `trinity.temperature` |
+| `MORPHEUS_TRINITY_API_KEY` | `trinity.api_key` |
 | `MORPHEUS_AUDIO_PROVIDER` | `audio.provider` |
 | `MORPHEUS_AUDIO_MODEL` | `audio.model` |
 | `MORPHEUS_AUDIO_ENABLED` | `audio.enabled` |
@@ -262,9 +277,10 @@ Authenticated endpoints (`x-architect-pass`):
 - Sessions: `/api/sessions*`
 - Chat: `POST /api/chat`
 - Tasks: `GET /api/tasks`, `GET /api/tasks/stats`, `GET /api/tasks/:id`, `POST /api/tasks/:id/retry`
-- Config: `/api/config`, `/api/config/sati`, `/api/config/neo`, `/api/config/apoc`
-- MCP: `/api/mcp/*`
+- Config: `/api/config`, `/api/config/sati`, `/api/config/neo`, `/api/config/apoc`, `/api/config/trinity`
+- MCP: `/api/mcp/*` (servers CRUD + reload + status)
 - Sati memories: `/api/sati/memories*`
+- Trinity databases: `GET/POST/PUT/DELETE /api/trinity/databases`, `POST /api/trinity/databases/:id/test`, `POST /api/trinity/databases/:id/refresh-schema`
 - Usage/model pricing/logs/restart
 - Webhook management and webhook notifications
 
@@ -368,6 +384,9 @@ src/
     apoc.ts
     neo.ts
     oracle.ts
+    trinity.ts
+    trinity-connector.ts  # PostgreSQL/MySQL/SQLite/MongoDB drivers
+    trinity-crypto.ts     # AES-256-GCM encryption for DB passwords
     memory/
     tasks/
     tools/

package/dist/channels/telegram.js

@@ -150,6 +150,7 @@ export class TelegramAdapter {
 /help \\- Show available commands
 /zaion \\- Show system configurations
 /sati qnt \\- Show specific memories
+/trinity \\- List registered Trinity databases
 /newsession \\- Archive current session and start fresh
 /sessions \\- List all sessions with titles and switch between them
 /restart \\- Restart the Morpheus agent
@@ -466,6 +467,125 @@ export class TelegramAdapter {
                     await ctx.reply(`❌ Failed to ${enable ? 'enable' : 'disable'} MCP '${serverName}': ${error.message}`);
                 }
             });
+            // --- Trinity DB Test Connection ---
+            this.bot.action(/^test_trinity_db_/, async (ctx) => {
+                const data = ctx.callbackQuery.data;
+                const id = parseInt(data.replace('test_trinity_db_', ''), 10);
+                if (isNaN(id)) {
+                    await ctx.answerCbQuery('Invalid ID');
+                    return;
+                }
+                await ctx.answerCbQuery('Testing connection…');
+                try {
+                    const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+                    const { testConnection } = await import('../runtime/trinity-connector.js');
+                    const db = DatabaseRegistry.getInstance().getDatabase(id);
+                    if (!db) {
+                        await ctx.reply('❌ Database not found.');
+                        return;
+                    }
+                    const ok = await testConnection(db);
+                    await ctx.reply(ok
+                        ? `✅ <b>${escapeHtml(db.name)}</b>: connection successful.`
+                        : `❌ <b>${escapeHtml(db.name)}</b>: connection failed.`, { parse_mode: 'HTML' });
+                }
+                catch (e) {
+                    await ctx.reply(`❌ Error testing connection: ${escapeHtml(e.message)}`, { parse_mode: 'HTML' });
+                }
+            });
+            // --- Trinity DB Refresh Schema ---
+            this.bot.action(/^refresh_trinity_db_schema_/, async (ctx) => {
+                const data = ctx.callbackQuery.data;
+                const id = parseInt(data.replace('refresh_trinity_db_schema_', ''), 10);
+                if (isNaN(id)) {
+                    await ctx.answerCbQuery('Invalid ID');
+                    return;
+                }
+                await ctx.answerCbQuery('Refreshing schema…');
+                try {
+                    const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+                    const { introspectSchema } = await import('../runtime/trinity-connector.js');
+                    const { Trinity } = await import('../runtime/trinity.js');
+                    const registry = DatabaseRegistry.getInstance();
+                    const db = registry.getDatabase(id);
+                    if (!db) {
+                        await ctx.reply('❌ Database not found.');
+                        return;
+                    }
+                    const schema = await introspectSchema(db);
+                    registry.updateSchema(id, JSON.stringify(schema, null, 2));
+                    await Trinity.refreshDelegateCatalog().catch(() => { });
+                    const tableNames = schema.databases
+                        ? schema.databases.flatMap((d) => d.tables.map((t) => `${d.name}.${t.name}`))
+                        : schema.tables.map((t) => t.name);
+                    const count = tableNames.length;
+                    await ctx.reply(`🔄 <b>${escapeHtml(db.name)}</b>: schema refreshed — ${count} ${count === 1 ? 'table' : 'tables'}.`, { parse_mode: 'HTML' });
+                }
+                catch (e) {
+                    await ctx.reply(`❌ Error refreshing schema: ${escapeHtml(e.message)}`, { parse_mode: 'HTML' });
+                }
+            });
+            // --- Trinity DB Delete Flow ---
+            this.bot.action(/^ask_trinity_db_delete_/, async (ctx) => {
+                const data = ctx.callbackQuery.data;
+                const id = parseInt(data.replace('ask_trinity_db_delete_', ''), 10);
+                if (isNaN(id)) {
+                    await ctx.answerCbQuery('Invalid ID');
+                    return;
+                }
+                try {
+                    const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+                    const db = DatabaseRegistry.getInstance().getDatabase(id);
+                    if (!db) {
+                        await ctx.answerCbQuery('Database not found');
+                        return;
+                    }
+                    await ctx.answerCbQuery();
+                    await ctx.reply(`⚠️ Delete <b>${escapeHtml(db.name)}</b> (${escapeHtml(db.type)}) from Trinity?\n\nThe actual database won't be affected — only this registration will be removed.`, {
+                        parse_mode: 'HTML',
+                        reply_markup: {
+                            inline_keyboard: [
+                                [
+                                    { text: '🗑️ Yes, delete', callback_data: `confirm_trinity_db_delete_${id}` },
+                                    { text: 'Cancel', callback_data: 'cancel_trinity_db_delete' },
+                                ],
+                            ],
+                        },
+                    });
+                }
+                catch (e) {
+                    await ctx.answerCbQuery(`Error: ${e.message}`, { show_alert: true });
+                }
+            });
+            this.bot.action(/^confirm_trinity_db_delete_/, async (ctx) => {
+                const data = ctx.callbackQuery.data;
+                const id = parseInt(data.replace('confirm_trinity_db_delete_', ''), 10);
+                if (isNaN(id)) {
+                    await ctx.answerCbQuery('Invalid ID');
+                    return;
+                }
+                try {
+                    const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+                    const registry = DatabaseRegistry.getInstance();
+                    const db = registry.getDatabase(id);
+                    const name = db?.name ?? `#${id}`;
+                    const deleted = registry.deleteDatabase(id);
+                    await ctx.answerCbQuery(deleted ? '🗑️ Deleted' : 'Not found');
+                    if (ctx.updateType === 'callback_query')
+                        ctx.deleteMessage().catch(() => { });
+                    const user = ctx.from?.username || ctx.from?.first_name || 'unknown';
+                    this.display.log(`Trinity DB '${name}' deleted by @${user}`, { source: 'Telegram', level: 'info' });
+                    await ctx.reply(deleted ? `🗑️ <b>${escapeHtml(name)}</b> removed from Trinity.` : `❌ Database #${id} not found.`, { parse_mode: 'HTML' });
+                }
+                catch (e) {
+                    await ctx.answerCbQuery(`Error: ${e.message}`, { show_alert: true });
+                }
+            });
+            this.bot.action('cancel_trinity_db_delete', async (ctx) => {
+                await ctx.answerCbQuery('Cancelled');
+                if (ctx.updateType === 'callback_query')
+                    ctx.deleteMessage().catch(() => { });
+            });
             this.bot.launch().catch((err) => {
                 if (this.isConnected) {
                     this.display.log(`Telegram bot error: ${err}`, { source: 'Telegram', level: 'error' });
@@ -596,6 +716,9 @@ export class TelegramAdapter {
             case '/sati':
                 await this.handleSatiCommand(ctx, user, args);
                 break;
+            case '/trinity':
+                await this.handleTrinityCommand(ctx, user);
+                break;
             case '/restart':
                 await this.handleRestartCommand(ctx, user);
                 break;
@@ -954,6 +1077,56 @@ How can I assist you today?`;
         response += `\\- Max Duration: ${escMd(config.audio.maxDurationSeconds)}s\n`;
         await ctx.reply(response, { parse_mode: 'MarkdownV2' });
     }
+    async handleTrinityCommand(ctx, user) {
+        try {
+            const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+            const registry = DatabaseRegistry.getInstance();
+            const databases = registry.listDatabases();
+            if (databases.length === 0) {
+                await ctx.reply('No databases registered in Trinity. Use the web UI to register databases.');
+                return;
+            }
+            let html = `<b>Trinity Databases (${databases.length}):</b>\n\n`;
+            const keyboard = [];
+            for (const db of databases) {
+                const schema = db.schema_json ? JSON.parse(db.schema_json) : null;
+                const tables = schema?.tables?.map((t) => t.name).filter(Boolean) ?? [];
+                const updatedAt = db.schema_updated_at
+                    ? new Date(db.schema_updated_at).toLocaleDateString()
+                    : 'never';
+                html += `🗄️ <b>${escapeHtml(db.name)}</b> (${escapeHtml(db.type)})\n`;
+                if (db.host)
+                    html += `  Host: ${escapeHtml(db.host)}:${db.port}\n`;
+                if (db.database_name && !db.host)
+                    html += `  File: ${escapeHtml(db.database_name)}\n`;
+                if (tables.length > 0) {
+                    const tableList = tables.slice(0, 20).join(', ');
+                    const extra = tables.length > 20 ? ` (+${tables.length - 20} more)` : '';
+                    html += `  Tables: ${escapeHtml(tableList)}${escapeHtml(extra)}\n`;
+                }
+                else {
+                    html += `  Tables: (schema not loaded)\n`;
+                }
+                html += `  Schema updated: ${escapeHtml(updatedAt)}\n\n`;
+                keyboard.push([
+                    { text: `🔌 Test ${db.name}`, callback_data: `test_trinity_db_${db.id}` },
+                    { text: `🔄 Schema`, callback_data: `refresh_trinity_db_schema_${db.id}` },
+                    { text: `🗑️ Delete`, callback_data: `ask_trinity_db_delete_${db.id}` },
+                ]);
+            }
+            const chunks = splitHtmlChunks(html.trim());
+            for (let i = 0; i < chunks.length; i++) {
+                const isLast = i === chunks.length - 1;
+                await ctx.reply(chunks[i], {
+                    parse_mode: 'HTML',
+                    ...(isLast && keyboard.length > 0 ? { reply_markup: { inline_keyboard: keyboard } } : {}),
+                });
+            }
+        }
+        catch (e) {
+            await ctx.reply(`Error listing Trinity databases: ${e.message}`);
+        }
+    }
     async handleSatiCommand(ctx, user, args) {
         let limit = null;
         if (args.length > 0) {

package/dist/cli/commands/restart.js

@@ -66,10 +66,10 @@ export const restartCommand = new Command('restart')
         const config = await configManager.load();
         // Initialize persistent logging
         await display.initialize(config.logging);
-        display.log(chalk.green(`Morpheus Agent (${config.agent.name}) starting...`));
-        display.log(chalk.gray(`PID: ${process.pid}`));
+        display.log(chalk.green(`Morpheus Agent (${config.agent.name}) starting...`), { source: 'Zaion' });
+        display.log(chalk.gray(`PID: ${process.pid}`), { source: 'Zaion' });
         if (options.ui) {
-            display.log(chalk.blue(`Web UI enabled to port ${options.port}`));
+            display.log(chalk.blue(`Web UI enabled to port ${options.port}`), { source: 'Zaion' });
         }
         // Initialize Oracle
         const oracle = new Oracle(config);
@@ -82,17 +82,17 @@ export const restartCommand = new Command('restart')
         catch (err) {
             display.stopSpinner();
             if (err instanceof ProviderError) {
-                display.log(chalk.red(`\nProvider Error (${err.provider}):`));
-                display.log(chalk.white(err.message));
+                display.log(chalk.red(`\nProvider Error (${err.provider}):`), { source: 'Oracle' });
+                display.log(chalk.white(err.message), { source: 'Oracle' });
                 if (err.suggestion) {
-                    display.log(chalk.yellow(`Tip: ${err.suggestion}`));
+                    display.log(chalk.yellow(`Tip: ${err.suggestion}`), { source: 'Oracle' });
                 }
             }
             else {
-                display.log(chalk.red('\nOracle initialization failed:'));
-                display.log(chalk.white(err.message));
+                display.log(chalk.red('\nOracle initialization failed:'), { source: 'Oracle' });
+                display.log(chalk.white(err.message), { source: 'Oracle' });
                 if (err.message.includes('API Key')) {
-                    display.log(chalk.yellow('Tip: Check your API key in configuration or environment variables.'));
+                    display.log(chalk.yellow('Tip: Check your API key in configuration or environment variables.'), { source: 'Oracle' });
                 }
             }
             await clearPid();
@@ -112,7 +112,7 @@ export const restartCommand = new Command('restart')
                 httpServer.start(port);
             }
             catch (e) {
-                display.log(chalk.red(`Failed to start Web UI: ${e.message}`));
+                display.log(chalk.red(`Failed to start Web UI: ${e.message}`), { source: 'Zaion' });
             }
         }
         // Initialize Telegram
@@ -126,11 +126,11 @@ export const restartCommand = new Command('restart')
                     adapters.push(telegram);
                 }
                 catch (e) {
-                    display.log(chalk.red('Failed to initialize Telegram adapter. Continuing...'));
+                    display.log(chalk.red('Failed to initialize Telegram adapter. Continuing...'), { source: 'Zaion' });
                 }
             }
             else {
-                display.log(chalk.yellow('Telegram enabled but no token provided. Skipping.'));
+                display.log(chalk.yellow('Telegram enabled but no token provided. Skipping.'), { source: 'Zaion' });
             }
         }
         if (asyncTasksEnabled) {
@@ -140,7 +140,7 @@ export const restartCommand = new Command('restart')
         // Handle graceful shutdown
         const shutdown = async (signal) => {
             display.stopSpinner();
-            display.log(`\n${signal} received. Shutting down...`);
+            display.log(`\n${signal} received. Shutting down...`, { source: 'Zaion' });
             if (httpServer) {
                 httpServer.stop();
             }
@@ -177,7 +177,8 @@ export const restartCommand = new Command('restart')
     }
     catch (error) {
         display.stopSpinner();
-        console.error(chalk.red('Failed to restart Morpheus:'), error.message);
+        display.log(chalk.red('Failed to restart Morpheus:'), { source: 'Zaion' });
+        display.log(chalk.white(error.message), { source: 'Zaion' });
         await clearPid();
         process.exit(1);
     }

package/dist/cli/commands/start.js

@@ -91,7 +91,7 @@ export const startCommand = new Command('start')
         display.log(chalk.green(`Morpheus Agent (${config.agent.name}) starting...`));
         display.log(chalk.gray(`PID: ${process.pid}`));
         if (options.ui) {
-            display.log(chalk.blue(`Web UI enabled to port ${options.port}`));
+            display.log(chalk.blue(`Web UI enabled to port ${options.port}`), { source: 'Zaion' });
         }
         // Initialize Oracle
         const oracle = new Oracle(config);
@@ -104,17 +104,17 @@ export const startCommand = new Command('start')
         catch (err) {
             display.stopSpinner();
             if (err instanceof ProviderError) {
-                display.log(chalk.red(`\nProvider Error (${err.provider}):`));
-                display.log(chalk.white(err.message));
+                display.log(chalk.red(`\nProvider Error (${err.provider}):`), { source: 'Oracle' });
+                display.log(chalk.white(err.message), { source: 'Oracle' });
                 if (err.suggestion) {
-                    display.log(chalk.yellow(`Tip: ${err.suggestion}`));
+                    display.log(chalk.yellow(`Tip: ${err.suggestion}`), { source: 'Oracle' });
                 }
             }
             else {
-                display.log(chalk.red('\nOracle initialization failed:'));
-                display.log(chalk.white(err.message));
+                display.log(chalk.red('\nOracle initialization failed:'), { source: 'Oracle' });
+                display.log(chalk.white(err.message), { source: 'Oracle' });
                 if (err.message.includes('API Key')) {
-                    display.log(chalk.yellow('Tip: Check your API key in configuration or environment variables.'));
+                    display.log(chalk.yellow('Tip: Check your API key in configuration or environment variables.'), { source: 'Oracle' });
                 }
             }
             await clearPid();
@@ -134,7 +134,7 @@ export const startCommand = new Command('start')
                 httpServer.start(port);
             }
             catch (e) {
-                display.log(chalk.red(`Failed to start Web UI: ${e.message}`));
+                display.log(chalk.red(`Failed to start Web UI: ${e.message}`), { source: 'Zaion' });
             }
         }
         // Initialize Telegram
@@ -149,11 +149,11 @@ export const startCommand = new Command('start')
                     adapters.push(telegram);
                 }
                 catch (e) {
-                    display.log(chalk.red('Failed to initialize Telegram adapter. Continuing...'));
+                    display.log(chalk.red('Failed to initialize Telegram adapter. Continuing...'), { source: 'Zaion' });
                 }
             }
             else {
-                display.log(chalk.yellow('Telegram enabled but no token provided. Skipping.'));
+                display.log(chalk.yellow('Telegram enabled but no token provided. Skipping.'), { source: 'Zaion' });
             }
         }
         // Start Background Services
@@ -162,10 +162,14 @@ export const startCommand = new Command('start')
             taskWorker.start();
             taskNotifier.start();
         }
+        // Recover webhook notifications stuck in 'pending' from previous runs
+        WebhookDispatcher.recoverStale().catch((err) => {
+            display.log(`Webhook recovery error: ${err.message}`, { source: 'Webhooks', level: 'error' });
+        });
         // Handle graceful shutdown
         const shutdown = async (signal) => {
             display.stopSpinner();
-            display.log(`\n${signal} received. Shutting down...`);
+            display.log(`\n${signal} received. Shutting down...`, { source: 'Zaion' });
             if (httpServer) {
                 httpServer.stop();
             }
@@ -202,7 +206,8 @@ export const startCommand = new Command('start')
     }
     catch (error) {
         display.stopSpinner();
-        console.error(chalk.red('Failed to start Morpheus:'), error.message);
+        display.log(chalk.red('Failed to start Morpheus:'), { source: 'Zaion' });
+        display.log(chalk.white(error.message), { source: 'Zaion' });
         await clearPid();
         process.exit(1);
     }

package/dist/config/manager.js

@@ -124,6 +124,29 @@ export class ConfigManager {
                 context_window: resolveOptionalNumeric('MORPHEUS_NEO_CONTEXT_WINDOW', config.neo?.context_window, neoContextWindowFallback),
             };
         }
+        // Apply precedence to Trinity config
+        const trinityEnvVars = [
+            'MORPHEUS_TRINITY_PROVIDER',
+            'MORPHEUS_TRINITY_MODEL',
+            'MORPHEUS_TRINITY_TEMPERATURE',
+            'MORPHEUS_TRINITY_API_KEY',
+        ];
+        const hasTrinityEnvOverrides = trinityEnvVars.some((envVar) => process.env[envVar] !== undefined);
+        let trinityConfig;
+        if (config.trinity || hasTrinityEnvOverrides) {
+            const trinityProvider = resolveProvider('MORPHEUS_TRINITY_PROVIDER', config.trinity?.provider, llmConfig.provider);
+            const trinityMaxTokensFallback = config.trinity?.max_tokens ?? llmConfig.max_tokens;
+            const trinityContextWindowFallback = config.trinity?.context_window ?? llmConfig.context_window;
+            trinityConfig = {
+                provider: trinityProvider,
+                model: resolveModel(trinityProvider, 'MORPHEUS_TRINITY_MODEL', config.trinity?.model || llmConfig.model),
+                temperature: resolveNumeric('MORPHEUS_TRINITY_TEMPERATURE', config.trinity?.temperature, llmConfig.temperature),
+                max_tokens: resolveOptionalNumeric('MORPHEUS_TRINITY_MAX_TOKENS', config.trinity?.max_tokens, trinityMaxTokensFallback),
+                api_key: resolveApiKey(trinityProvider, 'MORPHEUS_TRINITY_API_KEY', config.trinity?.api_key || llmConfig.api_key),
+                base_url: config.trinity?.base_url || config.llm.base_url,
+                context_window: resolveOptionalNumeric('MORPHEUS_TRINITY_CONTEXT_WINDOW', config.trinity?.context_window, trinityContextWindowFallback),
+            };
+        }
         // Apply precedence to audio config
         const audioProvider = resolveString('MORPHEUS_AUDIO_PROVIDER', config.audio.provider, DEFAULT_CONFIG.audio.provider);
         // AudioProvider uses 'google' but resolveApiKey expects LLMProvider which uses 'gemini'
@@ -169,6 +192,7 @@ export class ConfigManager {
             sati: satiConfig,
             neo: neoConfig,
             apoc: apocConfig,
+            trinity: trinityConfig,
             audio: audioConfig,
             channels: channelsConfig,
             ui: uiConfig,
@@ -236,4 +260,11 @@ export class ConfigManager {
             ...this.config.llm,
         };
     }
+    getTrinityConfig() {
+        if (this.config.trinity) {
+            return { ...this.config.trinity };
+        }
+        // Fallback to main LLM config
+        return { ...this.config.llm };
+    }
 }

package/dist/config/mcp-manager.js

@@ -21,8 +21,11 @@ const readConfigFile = async () => {
 };
 const writeConfigFile = async (config) => {
     const configPath = path.join(MORPHEUS_ROOT, MCP_FILE_NAME);
+    const tmpPath = configPath + '.tmp';
     const serialized = JSON.stringify(config, null, 2) + '\n';
-    await fs.writeFile(configPath, serialized, 'utf-8');
+    // Atomic write: write to temp file first, then rename — prevents partial writes from corrupting the live file
+    await fs.writeFile(tmpPath, serialized, 'utf-8');
+    await fs.rename(tmpPath, configPath);
 };
 const isMetadataKey = (key) => key.startsWith('_') || RESERVED_KEYS.has(key);
 const normalizeName = (rawName) => rawName.replace(/^\$/, '');
@@ -44,6 +47,21 @@ const ensureValidName = (name) => {
     }
 };
 export class MCPManager {
+    static reloadCallback = null;
+    /** Called by Oracle after initialization so MCPManager can trigger a full agent reload. */
+    static registerReloadCallback(fn) {
+        MCPManager.reloadCallback = fn;
+    }
+    /**
+     * Reloads MCP tools across all agents (Oracle provider, Neo catalog, Trinity catalog).
+     * Requires Oracle to have been initialized (and thus have registered its callback).
+     */
+    static async reloadAgents() {
+        if (!MCPManager.reloadCallback) {
+            throw new Error('Reload callback not registered — Oracle must be initialized before calling reloadAgents().');
+        }
+        await MCPManager.reloadCallback();
+    }
     static async listServers() {
         const config = await readConfigFile();
         const servers = [];

package/dist/config/schemas.js

@@ -27,6 +27,7 @@ export const ApocConfigSchema = LLMConfigSchema.extend({
     timeout_ms: z.number().int().positive().optional(),
 });
 export const NeoConfigSchema = LLMConfigSchema;
+export const TrinityConfigSchema = LLMConfigSchema;
 export const WebhookConfigSchema = z.object({
     telegram_notify_all: z.boolean().optional(),
 }).optional();
@@ -40,6 +41,7 @@ export const ConfigSchema = z.object({
     sati: SatiConfigSchema.optional(),
     neo: NeoConfigSchema.optional(),
     apoc: ApocConfigSchema.optional(),
+    trinity: TrinityConfigSchema.optional(),
     webhooks: WebhookConfigSchema,
     audio: AudioConfigSchema.default(DEFAULT_CONFIG.audio),
     memory: z.object({