morpheus-cli 0.6.1 → 0.6.3

package/dist/cli/commands/start.js

@@ -8,6 +8,8 @@ import { writePid, readPid, isProcessRunning, clearPid, checkStalePid, killProce
 import { ConfigManager } from '../../config/manager.js';
 import { renderBanner } from '../utils/render.js';
 import { TelegramAdapter } from '../../channels/telegram.js';
+import { DiscordAdapter } from '../../channels/discord.js';
+import { ChannelRegistry } from '../../channels/registry.js';
 import { WebhookDispatcher } from '../../runtime/webhooks/dispatcher.js';
 import { PATHS } from '../../config/paths.js';
 import { Oracle } from '../../runtime/oracle.js';
@@ -17,7 +19,6 @@ 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';
 import { ChronosWorker } from '../../runtime/chronos/worker.js';
 import { ChronosRepository } from '../../runtime/chronos/repository.js';
 export const startCommand = new Command('start')
@@ -148,10 +149,7 @@ export const startCommand = new Command('start')
                 const telegram = new TelegramAdapter(oracle);
                 try {
                     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);
-                    ChronosWorker.setNotifyFn((text) => telegram.sendMessage(text));
+                    ChannelRegistry.register(telegram);
                     adapters.push(telegram);
                 }
                 catch (e) {
@@ -162,6 +160,23 @@ export const startCommand = new Command('start')
                 display.log(chalk.yellow('Telegram enabled but no token provided. Skipping.'), { source: 'Zaion' });
             }
         }
+        // Initialize Discord
+        if (config.channels.discord.enabled) {
+            if (config.channels.discord.token) {
+                const discord = new DiscordAdapter(oracle);
+                try {
+                    await discord.connect(config.channels.discord.token, config.channels.discord.allowedUsers || []);
+                    ChannelRegistry.register(discord);
+                    adapters.push(discord);
+                }
+                catch (e) {
+                    display.log(chalk.red(`Failed to initialize Discord adapter: ${e.message}`), { source: 'Zaion' });
+                }
+            }
+            else {
+                display.log(chalk.yellow('Discord enabled but no token provided. Skipping.'), { source: 'Zaion' });
+            }
+        }
         // Start Background Services
         startSessionEmbeddingScheduler();
         chronosWorker.start();

package/dist/config/manager.js

@@ -167,8 +167,9 @@ export class ConfigManager {
                 allowedUsers: resolveStringArray('MORPHEUS_TELEGRAM_ALLOWED_USERS', config.channels.telegram.allowedUsers, DEFAULT_CONFIG.channels.telegram.allowedUsers)
             },
             discord: {
-                enabled: config.channels.discord.enabled, // Discord doesn't have env var precedence for now
-                token: config.channels.discord.token
+                enabled: config.channels.discord.enabled,
+                token: config.channels.discord.token,
+                allowedUsers: config.channels.discord.allowedUsers ?? []
             }
         };
         // Apply precedence to UI config

package/dist/config/schemas.js

@@ -67,6 +67,7 @@ export const ConfigSchema = z.object({
         discord: z.object({
             enabled: z.boolean().default(false),
             token: z.string().optional(),
+            allowedUsers: z.array(z.string()).default([]),
         }).default(DEFAULT_CONFIG.channels.discord),
     }).default(DEFAULT_CONFIG.channels),
     ui: z.object({

package/dist/http/routers/chronos.js

@@ -11,12 +11,14 @@ const CreateJobSchema = z.object({
     schedule_type: ScheduleTypeSchema,
     schedule_expression: z.string().min(1),
     timezone: z.string().optional(),
+    notify_channels: z.array(z.string()).optional(),
 });
 const UpdateJobSchema = z.object({
     prompt: z.string().min(1).max(10000).optional(),
     schedule_expression: z.string().min(1).optional(),
     timezone: z.string().optional(),
     enabled: z.boolean().optional(),
+    notify_channels: z.array(z.string()).optional(),
 });
 const PreviewSchema = z.object({
     expression: z.string().min(1),
@@ -83,7 +85,7 @@ export function createChronosJobRouter(repo, _worker) {
         if (!parsed.success) {
             return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
         }
-        const { prompt, schedule_type, schedule_expression, timezone } = parsed.data;
+        const { prompt, schedule_type, schedule_expression, timezone, notify_channels } = parsed.data;
         const globalTz = configManager.getChronosConfig().timezone;
         const tz = timezone ?? globalTz;
         const opts = { timezone: tz };
@@ -97,6 +99,7 @@ export function createChronosJobRouter(repo, _worker) {
                 timezone: tz,
                 next_run_at: schedule.next_run_at,
                 created_by: 'ui',
+                notify_channels: notify_channels ?? [],
             });
             const display = DisplayManager.getInstance();
             display.log(`Job ${job.id} created — ${schedule.human_readable}`, { source: 'Chronos' });
@@ -154,6 +157,7 @@ export function createChronosJobRouter(repo, _worker) {
                 timezone: patch.timezone,
                 next_run_at: updatedSchedule?.next_run_at,
                 enabled: patch.enabled,
+                notify_channels: patch.notify_channels,
             });
             res.json(job);
         }

package/dist/runtime/__tests__/manual_start_verify.js

@@ -7,7 +7,7 @@ const mockConfig = {
     llm: { provider: 'openai', model: 'gpt-3.5-turbo', temperature: 0.1, api_key: 'sk-mock-key' },
     channels: {
         telegram: { enabled: false, allowedUsers: [] },
-        discord: { enabled: false }
+        discord: { enabled: false, allowedUsers: [] }
     },
     ui: { enabled: false, port: 3333 },
     logging: { enabled: false, level: 'info', retention: '1d' },

package/dist/runtime/chronos/repository.js

@@ -61,6 +61,7 @@ export class ChronosRepository {
         addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN created_at INTEGER NOT NULL DEFAULT 0`, 'created_at');
         addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN updated_at INTEGER NOT NULL DEFAULT 0`, 'updated_at');
         addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN created_by TEXT NOT NULL DEFAULT 'api'`, 'created_by');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN notify_channels TEXT NOT NULL DEFAULT '[]'`, 'notify_channels');
         const execInfo = this.db.pragma('table_info(chronos_executions)');
         const execCols = new Set(execInfo.map((c) => c.name));
         const addExecCol = (sql, col) => {
@@ -87,6 +88,11 @@ export class ChronosRepository {
     `);
     }
     deserializeJob(row) {
+        let notify_channels = [];
+        try {
+            notify_channels = JSON.parse(row.notify_channels || '[]');
+        }
+        catch { /* keep [] */ }
         return {
             id: row.id,
             prompt: row.prompt,
@@ -100,6 +106,7 @@ export class ChronosRepository {
             created_at: row.created_at,
             updated_at: row.updated_at,
             created_by: row.created_by,
+            notify_channels,
         };
     }
     deserializeExecution(row) {
@@ -125,9 +132,9 @@ export class ChronosRepository {
         this.db.prepare(`
       INSERT INTO chronos_jobs (
         id, prompt, schedule_type, schedule_expression, cron_normalized,
-        timezone, next_run_at, last_run_at, enabled, created_at, updated_at, created_by
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 1, ?, ?, ?)
-    `).run(id, input.prompt, input.schedule_type, input.schedule_expression, input.cron_normalized ?? null, input.timezone, input.next_run_at, now, now, input.created_by);
+        timezone, next_run_at, last_run_at, enabled, created_at, updated_at, created_by, notify_channels
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 1, ?, ?, ?, ?)
+    `).run(id, input.prompt, input.schedule_type, input.schedule_expression, input.cron_normalized ?? null, input.timezone, input.next_run_at, now, now, input.created_by, JSON.stringify(input.notify_channels ?? []));
         return this.getJob(id);
     }
     getJob(id) {
@@ -181,6 +188,10 @@ export class ChronosRepository {
             sets.push('enabled = ?');
             params.push(patch.enabled ? 1 : 0);
         }
+        if (patch.notify_channels !== undefined) {
+            sets.push('notify_channels = ?');
+            params.push(JSON.stringify(patch.notify_channels));
+        }
         params.push(id);
         this.db.prepare(`UPDATE chronos_jobs SET ${sets.join(', ')} WHERE id = ?`).run(...params);
         return this.getJob(id);

package/dist/runtime/chronos/worker.js

@@ -2,11 +2,11 @@ import { randomUUID } from 'crypto';
 import { ConfigManager } from '../../config/manager.js';
 import { DisplayManager } from '../display.js';
 import { parseNextRun } from './parser.js';
+import { ChannelRegistry } from '../../channels/registry.js';
 export class ChronosWorker {
     repo;
     oracle;
     static instance = null;
-    static notifyFn = null;
     /**
      * True while a Chronos job is being executed. Chronos management tools
      * (chronos_cancel, chronos_schedule) check this flag and refuse to operate
@@ -28,10 +28,6 @@ export class ChronosWorker {
     static setInstance(worker) {
         ChronosWorker.instance = worker;
     }
-    /** Register a function that will deliver Oracle responses to users (e.g. Telegram). */
-    static setNotifyFn(fn) {
-        ChronosWorker.notifyFn = fn;
-    }
     start() {
         if (this.timer)
             return;
@@ -88,20 +84,21 @@ export class ChronosWorker {
             session_id: activeSessionId,
         });
         try {
-            // Inject execution context as an AI message so it appears naturally in the
-            // conversation history without triggering an extra LLM response.
-            const contextMessage = `[CHRONOS EXECUTION — job_id: ${job.id}]\n` +
-                `Executing scheduled job. Do NOT call chronos_cancel, chronos_schedule, ` +
-                `or any Chronos management tools during this execution.`;
-            await this.oracle.injectAIMessage(contextMessage);
-            // If a Telegram notify function is registered, tag delegated tasks with
-            // origin_channel: 'telegram' so the TaskDispatcher broadcasts their result.
-            const taskContext = ChronosWorker.notifyFn
-                ? { origin_channel: 'telegram', session_id: activeSessionId }
-                : undefined;
+            // Prefix the job prompt with the Chronos execution context marker so the
+            // Oracle system prompt can detect it in the current HumanMessage.
+            // This avoids persisting an AIMessage with the marker in conversation history,
+            // which would cause the LLM to reproduce the format in future scheduling responses.
+            const promptWithContext = `[CHRONOS EXECUTION — job_id: ${job.id}]\n${job.prompt}`;
+            // Determine which channel to tag delegated tasks with.
+            // Single notify_channel → use it so TaskDispatcher routes back correctly.
+            // Multiple or empty → 'chronos' means broadcast to all registered adapters.
+            const taskOriginChannel = job.notify_channels.length === 1
+                ? job.notify_channels[0]
+                : 'chronos';
+            const taskContext = { origin_channel: taskOriginChannel, session_id: activeSessionId };
             // Hard-block Chronos management tools during execution.
             ChronosWorker.isExecuting = true;
-            const response = await this.oracle.chat(job.prompt, undefined, false, taskContext);
+            const response = await this.oracle.chat(promptWithContext, undefined, false, taskContext);
             this.repo.completeExecution(execId, 'success');
             display.log(`Job ${job.id} completed — status: success`, { source: 'Chronos' });
             // Deliver Oracle response to notification channels.
@@ -127,15 +124,26 @@ export class ChronosWorker {
         }
     }
     async notify(job, response) {
-        if (!ChronosWorker.notifyFn)
+        if (ChannelRegistry.getAll().length === 0)
             return;
-        const display = DisplayManager.getInstance();
         const header = `⏰ *Chronos* — _${job.prompt.slice(0, 80)}${job.prompt.length > 80 ? '…' : ''}_\n\n`;
-        try {
-            await ChronosWorker.notifyFn(header + response);
+        const text = header + response;
+        if (job.notify_channels.length === 0) {
+            // No specific channels → broadcast to all registered adapters
+            await ChannelRegistry.broadcast(text);
         }
-        catch (err) {
-            display.log(`Job ${job.id} notification failed — ${err.message}`, { source: 'Chronos', level: 'error' });
+        else {
+            for (const ch of job.notify_channels) {
+                const adapter = ChannelRegistry.get(ch);
+                if (adapter) {
+                    await adapter.sendMessage(text).catch((err) => {
+                        DisplayManager.getInstance().log(`Job ${job.id} notification failed on channel "${ch}": ${err.message}`, { source: 'Chronos', level: 'error' });
+                    });
+                }
+                else {
+                    DisplayManager.getInstance().log(`Job ${job.id}: no adapter registered for channel "${ch}" — notification skipped.`, { source: 'Chronos', level: 'warning' });
+                }
+            }
         }
     }
 }

package/dist/runtime/chronos/worker.test.js

@@ -29,6 +29,7 @@ function makeJob(overrides = {}) {
         created_at: Date.now() - 5000,
         updated_at: Date.now() - 5000,
         created_by: 'ui',
+        notify_channels: [],
         ...overrides,
     };
 }

package/dist/runtime/oracle.js

@@ -114,6 +114,20 @@ export class Oracle {
         }
         return false;
     }
+    hasChronosToolCall(messages) {
+        const chronosToolNames = new Set(["chronos_schedule", "chronos_list", "chronos_cancel", "chronos_preview"]);
+        for (const msg of messages) {
+            if (!(msg instanceof AIMessage))
+                continue;
+            const toolCalls = msg.tool_calls ?? [];
+            if (!Array.isArray(toolCalls))
+                continue;
+            if (toolCalls.some((tc) => chronosToolNames.has(tc?.name))) {
+                return true;
+            }
+        }
+        return false;
+    }
     async initialize() {
         if (!this.config.llm) {
             throw new Error("LLM configuration missing in config object.");
@@ -198,6 +212,28 @@ Rules:
 10. After enqueuing all required delegated tasks for the current message, stop calling tools and return a concise acknowledgement.
 11. If a delegation is rejected as "not atomic", immediately split into smaller delegations and retry.
 
+## Chronos Channel Routing
+When calling chronos_schedule, set notify_channels based on the user's message:
+- User mentions a specific channel (e.g., "no Discord", "no Telegram", "on Discord", "me avise pelo Discord"): set notify_channels to that channel — e.g. ["discord"] or ["telegram"].
+- User says "all channels", "todos os canais", "em todos os canais": set notify_channels to [] (empty = broadcast to all active channels).
+- User does NOT mention any channel: omit notify_channels entirely (auto-detect uses the current conversation channel).
+
+Examples:
+- "me lembre daqui 5 minutos pelo Discord" → notify_channels: ["discord"]
+- "lembre em todos os canais" → notify_channels: []
+- "lembre em 1 hora" (sem canal) → omit notify_channels
+
+## Chronos Scheduled Execution
+When the current user message starts with [CHRONOS EXECUTION], it means a Chronos scheduled job has just fired. The content after the prefix is the **job's saved prompt**, not a new live request from the user.
+
+Behavior rules for Chronos execution context:
+- **Reminder / notification prompts** (e.g., "me lembre de beber água", "lembre de tomar remédio", "avise que é hora de X", "lembrete: reunião às 15h"): respond with ONLY a short, direct notification message. Keep it to 1–2 sentences max. Do NOT use any tools. Do NOT delegate. Do NOT create tasks. Do NOT add motivational commentary or ask follow-up questions.
+  - Good: "Hora de beber água! 💧"
+  - Good: "Lembrete: reunião em 5 minutos."
+  - Bad: "Combinado! Vou beber agora. Você também deveria se hidratar!" (adds unnecessary commentary)
+- **Action / task prompts** (e.g., "executar npm build", "verificar se o servidor está online", "enviar relatório"): execute normally using the appropriate tools.
+- NEVER re-schedule or create new Chronos jobs from within a Chronos execution.
+
 Delegation quality:
 - Write delegation input in the same language requested by the user.
 - Include clear objective and constraints.
@@ -294,6 +330,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
             let responseContent;
             const toolDelegationAcks = this.extractDelegationAcksFromMessages(newGeneratedMessages);
             const hadDelegationToolCall = this.hasDelegationToolCall(newGeneratedMessages);
+            const hadChronosToolCall = this.hasChronosToolCall(newGeneratedMessages);
             const mergedDelegationAcks = [
                 ...contextDelegationAcks.map((ack) => ({ task_id: ack.task_id, agent: ack.agent })),
                 ...toolDelegationAcks,
@@ -336,7 +373,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
             else {
                 const lastMessage = response.messages[response.messages.length - 1];
                 responseContent = (typeof lastMessage.content === 'string') ? lastMessage.content : JSON.stringify(lastMessage.content);
-                if (this.looksLikeSyntheticDelegationAck(responseContent)) {
+                if (!hadChronosToolCall && this.looksLikeSyntheticDelegationAck(responseContent)) {
                     blockedSyntheticDelegationAck = true;
                     this.display.log("Blocked synthetic delegation acknowledgement without validated task creation.", { source: "Oracle", level: "error", meta: { preview: responseContent.slice(0, 200) } });
                     const usage = lastMessage.usage_metadata

package/dist/runtime/tasks/dispatcher.js

@@ -2,12 +2,9 @@ import { DisplayManager } from '../display.js';
 import { WebhookRepository } from '../webhooks/repository.js';
 import { AIMessage } from '@langchain/core/messages';
 import { SQLiteChatMessageHistory } from '../memory/sqlite.js';
+import { ChannelRegistry } from '../../channels/registry.js';
 export class TaskDispatcher {
-    static telegramAdapter = null;
     static display = DisplayManager.getInstance();
-    static setTelegramAdapter(adapter) {
-        TaskDispatcher.telegramAdapter = adapter;
-    }
     static async notifyTaskResult(task) {
         if (task.origin_channel === 'webhook') {
             if (!task.origin_message_id) {
@@ -19,25 +16,25 @@ export class TaskDispatcher {
                 ? (task.output && task.output.trim().length > 0 ? task.output : 'Task completed without output.')
                 : (task.error && task.error.trim().length > 0 ? task.error : 'Task failed with unknown error.');
             repo.updateNotificationResult(task.origin_message_id, status, result);
-            // Send Telegram notification if the webhook has 'telegram' in notification_channels
+            // Notify channels configured on the webhook
             const notification = repo.getNotificationById(task.origin_message_id);
             if (notification) {
                 const webhook = repo.getWebhookById(notification.webhook_id);
-                if (webhook?.notification_channels.includes('telegram')) {
-                    const adapter = TaskDispatcher.telegramAdapter;
-                    if (adapter) {
-                        try {
-                            const icon = status === 'completed' ? '✅' : '❌';
-                            const truncated = result.length > 3500 ? result.slice(0, 3500) + '…' : result;
-                            await adapter.sendMessage(`${icon} Webhook: ${webhook.name}\n\n${truncated}`);
+                if (webhook) {
+                    const icon = status === 'completed' ? '✅' : '❌';
+                    const truncated = result.length > 3500 ? result.slice(0, 3500) + '…' : result;
+                    const message = `${icon} Webhook: ${webhook.name}\n\n${truncated}`;
+                    for (const ch of webhook.notification_channels) {
+                        const adapter = ChannelRegistry.get(ch);
+                        if (adapter) {
+                            await adapter.sendMessage(message).catch((err) => {
+                                TaskDispatcher.display.log(`Failed to send notification via ${ch} for webhook "${webhook.name}": ${err.message}`, { source: 'TaskDispatcher', level: 'error' });
+                            });
                         }
-                        catch (err) {
-                            TaskDispatcher.display.log(`Failed to send Telegram notification for webhook "${webhook.name}": ${err.message}`, { source: 'TaskDispatcher', level: 'error' });
+                        else {
+                            TaskDispatcher.display.log(`Notification skipped for channel "${ch}" — adapter not registered.`, { source: 'TaskDispatcher', level: 'warning' });
                         }
                     }
-                    else {
-                        TaskDispatcher.display.log(`Telegram notification skipped for webhook "${webhook.name}" — adapter not connected.`, { source: 'TaskDispatcher', level: 'warning' });
-                    }
                 }
             }
             return;
@@ -65,13 +62,21 @@ export class TaskDispatcher {
             }
             return;
         }
-        if (task.origin_channel !== 'telegram') {
+        // 'chronos' origin — broadcast to all registered channels
+        if (task.origin_channel === 'chronos') {
+            const statusIcon = task.status === 'completed' ? '✅' : task.status === 'cancelled' ? '🚫' : '❌';
+            const body = task.status === 'completed'
+                ? (task.output && task.output.trim().length > 0 ? task.output : 'Task completed without output.')
+                : task.status === 'cancelled'
+                    ? 'Task was cancelled.'
+                    : (task.error && task.error.trim().length > 0 ? task.error : 'Task failed with unknown error.');
+            const message = `${statusIcon} Task \`${task.id.toUpperCase()}\`\n` +
+                `Agent: \`${task.agent.toUpperCase()}\`\n` +
+                `Status: \`${task.status.toUpperCase()}\`\n\n${body}`;
+            await ChannelRegistry.broadcast(message);
             return;
         }
-        const adapter = TaskDispatcher.telegramAdapter;
-        if (!adapter) {
-            throw new Error('Telegram adapter not connected');
-        }
+        // Channel-specific routing (telegram, discord, etc.)
         const statusIcon = task.status === 'completed' ? '✅' : task.status === 'cancelled' ? '🚫' : '❌';
         const body = task.status === 'completed'
             ? (task.output && task.output.trim().length > 0 ? task.output : 'Task completed without output.')
@@ -83,10 +88,15 @@ export class TaskDispatcher {
             `Status: \`${task.status.toUpperCase()}\``;
         const message = `${header}\n\n${body}`;
         if (task.origin_user_id) {
-            await adapter.sendMessageToUser(task.origin_user_id, message);
+            await ChannelRegistry.sendToUser(task.origin_channel, task.origin_user_id, message);
+            return;
+        }
+        // No specific user — broadcast on the originating channel
+        const adapter = ChannelRegistry.get(task.origin_channel);
+        if (!adapter) {
+            TaskDispatcher.display.log(`Task ${task.id}: no adapter for channel "${task.origin_channel}" — notification skipped.`, { source: 'TaskDispatcher', level: 'warning' });
             return;
         }
-        TaskDispatcher.display.log(`Task ${task.id} has telegram origin but no origin_user_id; broadcasting to allowed users.`, { source: 'TaskDispatcher', level: 'warning' });
         await adapter.sendMessage(message);
     }
     static async onTaskFinished(task) {

package/dist/runtime/tools/chronos-tools.js

@@ -4,8 +4,11 @@ import { ChronosRepository } from '../chronos/repository.js';
 import { parseScheduleExpression, getNextOccurrences } from '../chronos/parser.js';
 import { ConfigManager } from '../../config/manager.js';
 import { ChronosWorker } from '../chronos/worker.js';
+import { TaskRequestContext } from '../tasks/context.js';
 // ─── chronos_schedule ────────────────────────────────────────────────────────
-export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule_expression, timezone }) => {
+// Channels that can be used as notify_channels on Chronos jobs
+const NON_CHANNEL_ORIGINS = new Set(['ui', 'api', 'cli', 'chronos', 'webhook']);
+export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule_expression, timezone, notify_channels }) => {
     if (ChronosWorker.isExecuting) {
         return JSON.stringify({ success: false, error: 'Cannot create a new Chronos job from within an active Chronos execution.' });
     }
@@ -13,6 +16,20 @@ export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule
         const cfg = ConfigManager.getInstance().getChronosConfig();
         const tz = timezone ?? cfg.timezone;
         const parsed = parseScheduleExpression(schedule_expression, schedule_type, { timezone: tz });
+        // Resolve notify_channels:
+        // - Explicitly provided → use as-is
+        // - Not provided → auto-detect from current conversation origin channel
+        // - If origin channel is not a real user-facing channel (ui/api/cli) → empty = broadcast all
+        let channels;
+        if (notify_channels !== undefined) {
+            channels = notify_channels;
+        }
+        else {
+            const originChannel = TaskRequestContext.get()?.origin_channel;
+            channels = originChannel && !NON_CHANNEL_ORIGINS.has(originChannel)
+                ? [originChannel]
+                : [];
+        }
         const repo = ChronosRepository.getInstance();
         const job = repo.createJob({
             prompt,
@@ -22,6 +39,7 @@ export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule
             next_run_at: parsed.next_run_at,
             cron_normalized: parsed.cron_normalized,
             created_by: 'oracle',
+            notify_channels: channels,
         });
         return JSON.stringify({
             success: true,
@@ -31,6 +49,7 @@ export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule
             human_readable: parsed.human_readable,
             next_run_at: job.next_run_at != null ? new Date(job.next_run_at).toISOString() : null,
             timezone: job.timezone,
+            notify_channels: job.notify_channels,
         });
     }
     catch (err) {
@@ -42,7 +61,9 @@ export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule
         'Use schedule_type "once" for a single execution (e.g. "tomorrow at 9am", "in 2 hours", "2026-03-01T09:00:00"), ' +
         '"cron" for a recurring cron expression (e.g. "0 9 * * 1-5" = every weekday at 9am), ' +
         '"interval" for natural interval phrases (e.g. "every 30 minutes", "every 2 hours", "every day"). ' +
-        'Returns the created job ID and the human-readable schedule confirmation.',
+        'Returns the created job ID and the human-readable schedule confirmation. ' +
+        'Use notify_channels to control where the result is delivered: omit to auto-detect from current channel, ' +
+        'pass ["discord"] or ["telegram"] for a specific channel, or [] for all active channels.',
     schema: z.object({
         prompt: z.string().describe('The prompt text to send to Oracle at the scheduled time.'),
         schedule_type: z
@@ -57,6 +78,13 @@ export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule
             .string()
             .optional()
             .describe('IANA timezone (e.g. "America/Sao_Paulo"). Defaults to the global Chronos timezone config.'),
+        notify_channels: z
+            .array(z.string())
+            .optional()
+            .describe('Channels to notify when this job fires. ' +
+            'Omit to auto-use the current conversation channel. ' +
+            'Pass [] to broadcast to all active channels. ' +
+            'Pass ["discord"], ["telegram"], or ["discord","telegram"] for specific channels.'),
     }),
 });
 // ─── chronos_list ────────────────────────────────────────────────────────────

package/dist/runtime/tools/neo-tool.js

@@ -11,8 +11,7 @@ Neo built-in capabilities (always available — no MCP required):
 • Analytics: message_count, token_usage, provider_model_usage — message counts and token/cost usage stats
 • Tasks: task_query — look up task status by id or session
 • MCP Management: mcp_list, mcp_manage — list/add/update/delete/enable/disable MCP servers; use action "reload" to reload tools across all agents after config changes
-• Webhooks: webhook_list, webhook_manage — create/update/delete webhooks; create returns api_key
-• Trinity DB: trinity_db_list, trinity_db_manage — register/update/delete/test connection/refresh schema for databases`.trim();
+• Webhooks: webhook_list, webhook_manage — create/update/delete webhooks; create returns api_key`.trim();
 const NEO_BASE_DESCRIPTION = `Delegate execution to Neo asynchronously.
 
 This tool creates a background task and returns an acknowledgement with task id.
@@ -29,7 +28,7 @@ function buildCatalogSection(mcpTools) {
     if (mcpTools.length === 0) {
         return "\n\nRuntime MCP tools: none currently loaded.";
     }
-    const maxItems = 32;
+    const maxItems = 500;
     const lines = mcpTools.slice(0, maxItems).map((t) => {
         const desc = normalizeDescription(t.description).slice(0, 120);
         return `- ${t.name}: ${desc}`;

package/dist/runtime/webhooks/dispatcher.js

@@ -1,18 +1,11 @@
 import { WebhookRepository } from './repository.js';
 import { TaskRepository } from '../tasks/repository.js';
 import { DisplayManager } from '../display.js';
+import { ChannelRegistry } from '../../channels/registry.js';
 const STALE_NOTIFICATION_THRESHOLD_MS = 2 * 60 * 1000; // 2 minutes
 export class WebhookDispatcher {
-    static telegramAdapter = null;
     static oracle = null;
     display = DisplayManager.getInstance();
-    /**
-     * Called at boot time after TelegramAdapter.connect() succeeds,
-     * so Telegram notifications can be dispatched from any trigger.
-     */
-    static setTelegramAdapter(adapter) {
-        WebhookDispatcher.telegramAdapter = adapter;
-    }
     /**
      * Called at boot time with the Oracle instance so webhooks can use
      * the full Oracle (MCPs, apoc_delegate, memory, etc.).
@@ -54,18 +47,14 @@ export class WebhookDispatcher {
             else {
                 repo.updateNotificationResult(notificationId, 'completed', response);
                 this.display.log(`Webhook "${webhook.name}" completed with direct response (notification: ${notificationId})`, { source: 'Webhooks', level: 'success' });
-                if (webhook.notification_channels.includes('telegram')) {
-                    await this.sendTelegram(webhook.name, response, 'completed');
-                }
+                await this.notifyChannels(webhook, response, 'completed');
             }
         }
         catch (err) {
             const result = `Execution error: ${err.message}`;
             this.display.log(`Webhook "${webhook.name}" failed: ${err.message}`, { source: 'Webhooks', level: 'error' });
             repo.updateNotificationResult(notificationId, 'failed', result);
-            if (webhook.notification_channels.includes('telegram')) {
-                await this.sendTelegram(webhook.name, result, 'failed');
-            }
+            await this.notifyChannels(webhook, result, 'failed');
         }
     }
     /**
@@ -140,23 +129,23 @@ Analyze the payload above and follow the instructions provided. Be concise and a
         }
     }
     /**
-     * Sends a formatted Telegram message to all allowed users.
-     * Silently skips if the adapter is not connected.
+     * Sends a notification to all channels configured on the webhook.
+     * Uses ChannelRegistry — no adapter references needed here.
      */
-    async sendTelegram(webhookName, result, status) {
-        const adapter = WebhookDispatcher.telegramAdapter;
-        if (!adapter) {
-            this.display.log('Telegram notification skipped — adapter not connected.', { source: 'Webhooks', level: 'warning' });
-            return;
-        }
-        try {
-            const icon = status === 'completed' ? '✅' : '❌';
-            const truncated = result.length > 3500 ? result.slice(0, 3500) + '…' : result;
-            const message = `${icon} Webhook: ${webhookName}\n\n${truncated}`;
-            await adapter.sendMessage(message);
-        }
-        catch (err) {
-            this.display.log(`Failed to send Telegram notification for webhook "${webhookName}": ${err.message}`, { source: 'Webhooks', level: 'error' });
+    async notifyChannels(webhook, result, status) {
+        const icon = status === 'completed' ? '✅' : '❌';
+        const truncated = result.length > 3500 ? result.slice(0, 3500) + '…' : result;
+        const message = `${icon} Webhook: ${webhook.name}\n\n${truncated}`;
+        for (const ch of webhook.notification_channels) {
+            const adapter = ChannelRegistry.get(ch);
+            if (adapter) {
+                await adapter.sendMessage(message).catch((err) => {
+                    this.display.log(`Failed to send notification via "${ch}" for webhook "${webhook.name}": ${err.message}`, { source: 'Webhooks', level: 'error' });
+                });
+            }
+            else {
+                this.display.log(`Notification skipped for channel "${ch}" — adapter not registered.`, { source: 'Webhooks', level: 'warning' });
+            }
         }
     }
 }

package/dist/types/config.js

@@ -31,7 +31,7 @@ export const DEFAULT_CONFIG = {
     },
     channels: {
         telegram: { enabled: false, allowedUsers: [] },
-        discord: { enabled: false },
+        discord: { enabled: false, allowedUsers: [] },
     },
     ui: {
         enabled: true,