morpheus-cli 0.4.15 → 0.5.1

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)
@@ -62,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);
@@ -78,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();
@@ -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 {
@@ -105,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
@@ -114,26 +121,36 @@ 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) {
-                    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) {
+            taskWorker.start();
+            taskNotifier.start();
+        }
         // 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();
             }
             for (const adapter of adapters) {
                 await adapter.disconnect();
             }
+            if (asyncTasksEnabled) {
+                taskWorker.stop();
+                taskNotifier.stop();
+            }
             await clearPid();
             process.exit(0);
         };
@@ -160,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

@@ -15,6 +15,9 @@ import { ProviderError } from '../../runtime/errors.js';
 import { HttpServer } from '../../http/server.js';
 import { getVersion } from '../utils/version.js';
 import { startSessionEmbeddingScheduler } from '../../runtime/session-embedding-scheduler.js';
+import { TaskWorker } from '../../runtime/tasks/worker.js';
+import { TaskNotifier } from '../../runtime/tasks/notifier.js';
+import { TaskDispatcher } from '../../runtime/tasks/dispatcher.js';
 export const startCommand = new Command('start')
     .description('Start the Morpheus agent')
     .option('--ui', 'Enable web UI', true)
@@ -88,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);
@@ -101,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();
@@ -119,6 +122,9 @@ export const startCommand = new Command('start')
         }
         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 {
@@ -128,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
@@ -139,28 +145,37 @@ export const startCommand = new Command('start')
                     await telegram.connect(config.channels.telegram.token, config.channels.telegram.allowedUsers || []);
                     // Wire Telegram adapter to webhook dispatcher for proactive notifications
                     WebhookDispatcher.setTelegramAdapter(telegram);
+                    TaskDispatcher.setTelegramAdapter(telegram);
                     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
         startSessionEmbeddingScheduler();
+        if (asyncTasksEnabled) {
+            taskWorker.start();
+            taskNotifier.start();
+        }
         // 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();
             }
             for (const adapter of adapters) {
                 await adapter.disconnect();
             }
+            if (asyncTasksEnabled) {
+                taskWorker.stop();
+                taskNotifier.stop();
+            }
             await clearPid();
             process.exit(0);
         };
@@ -187,7 +202,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

@@ -85,6 +85,68 @@ export class ConfigManager {
                 timeout_ms: config.apoc.timeout_ms !== undefined ? resolveNumeric('MORPHEUS_APOC_TIMEOUT_MS', config.apoc.timeout_ms, 30_000) : 30_000
             };
         }
+        // Apply precedence to Neo config
+        const neoEnvVars = [
+            'MORPHEUS_NEO_PROVIDER',
+            'MORPHEUS_NEO_MODEL',
+            'MORPHEUS_NEO_TEMPERATURE',
+            'MORPHEUS_NEO_MAX_TOKENS',
+            'MORPHEUS_NEO_API_KEY',
+            'MORPHEUS_NEO_BASE_URL',
+            'MORPHEUS_NEO_CONTEXT_WINDOW',
+        ];
+        const hasNeoEnvOverrides = neoEnvVars.some((envVar) => process.env[envVar] !== undefined);
+        const resolveOptionalNumeric = (envVar, configValue, fallbackValue) => {
+            if (fallbackValue !== undefined) {
+                return resolveNumeric(envVar, configValue, fallbackValue);
+            }
+            if (process.env[envVar] !== undefined && process.env[envVar] !== '') {
+                const parsed = Number(process.env[envVar]);
+                if (!Number.isNaN(parsed)) {
+                    return parsed;
+                }
+            }
+            return configValue;
+        };
+        let neoConfig;
+        if (config.neo || hasNeoEnvOverrides) {
+            const neoProvider = resolveProvider('MORPHEUS_NEO_PROVIDER', config.neo?.provider, llmConfig.provider);
+            const neoBaseUrl = resolveString('MORPHEUS_NEO_BASE_URL', config.neo?.base_url, llmConfig.base_url || '');
+            const neoMaxTokensFallback = config.neo?.max_tokens ?? llmConfig.max_tokens;
+            const neoContextWindowFallback = config.neo?.context_window ?? llmConfig.context_window;
+            neoConfig = {
+                provider: neoProvider,
+                model: resolveModel(neoProvider, 'MORPHEUS_NEO_MODEL', config.neo?.model || llmConfig.model),
+                temperature: resolveNumeric('MORPHEUS_NEO_TEMPERATURE', config.neo?.temperature, llmConfig.temperature),
+                max_tokens: resolveOptionalNumeric('MORPHEUS_NEO_MAX_TOKENS', config.neo?.max_tokens, neoMaxTokensFallback),
+                api_key: resolveApiKey(neoProvider, 'MORPHEUS_NEO_API_KEY', config.neo?.api_key || llmConfig.api_key),
+                base_url: neoBaseUrl || undefined,
+                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'
@@ -128,7 +190,9 @@ export class ConfigManager {
             agent: agentConfig,
             llm: llmConfig,
             sati: satiConfig,
+            neo: neoConfig,
             apoc: apocConfig,
+            trinity: trinityConfig,
             audio: audioConfig,
             channels: channelsConfig,
             ui: uiConfig,
@@ -185,4 +249,22 @@ export class ConfigManager {
             timeout_ms: 30_000
         };
     }
+    getNeoConfig() {
+        if (this.config.neo) {
+            return {
+                ...this.config.neo
+            };
+        }
+        // Fallback to main LLM config
+        return {
+            ...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

@@ -26,6 +26,8 @@ export const ApocConfigSchema = LLMConfigSchema.extend({
     working_dir: z.string().optional(),
     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();
@@ -37,12 +39,19 @@ export const ConfigSchema = z.object({
     }).default(DEFAULT_CONFIG.agent),
     llm: LLMConfigSchema.default(DEFAULT_CONFIG.llm),
     sati: SatiConfigSchema.optional(),
+    neo: NeoConfigSchema.optional(),
     apoc: ApocConfigSchema.optional(),
+    trinity: TrinityConfigSchema.optional(),
     webhooks: WebhookConfigSchema,
     audio: AudioConfigSchema.default(DEFAULT_CONFIG.audio),
     memory: z.object({
         limit: z.number().int().positive().optional(),
     }).default(DEFAULT_CONFIG.memory),
+    runtime: z.object({
+        async_tasks: z.object({
+            enabled: z.boolean().default(DEFAULT_CONFIG.runtime?.async_tasks.enabled ?? true),
+        }).default(DEFAULT_CONFIG.runtime?.async_tasks ?? { enabled: true }),
+    }).optional(),
     channels: z.object({
         telegram: z.object({
             enabled: z.boolean().default(false),

package/dist/devkit/tools/network.js

@@ -64,7 +64,7 @@ export function createNetworkTools(ctx) {
             });
         }, {
             name: 'ping',
-            description: 'Check if a host is reachable on a given port (TCP connect check).',
+            description: 'Preferred connectivity check tool. Verify if a host is reachable on a given port (TCP connect check). Use this instead of shell ping for routine reachability checks.',
             schema: z.object({
                 host: z.string().describe('Hostname or IP'),
                 port: z.number().int().optional().describe('Port to check, default 80'),