morpheus-cli 0.9.12 → 0.9.13

package/README.md

@@ -9,7 +9,7 @@ It runs as a daemon and orchestrates LLMs, MCP tools, DevKit tools, memory, and
 
 ## Why Morpheus
 - Local-first persistence (sessions, messages, usage, tasks).
-- Multi-agent architecture (Oracle, Neo, Apoc, Sati, Trinity, Smith).
+- Multi-agent architecture (Oracle, Neo, Apoc, Sati, Trinity, Link, Smith) with centralized SubagentRegistry.
 - Async task execution with queue + worker + notifier.
 - Chronos temporal scheduler for recurring and one-time Oracle executions.
 - Smith remote agent system for DevKit execution on isolated machines via WebSocket.

package/dist/channels/telegram.js

@@ -634,7 +634,7 @@ export class TelegramAdapter {
                     await ctx.answerCbQuery('Testing connection…').catch(() => { });
                     try {
                         const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
-                        const { testConnection } = await import('../runtime/trinity-connector.js');
+                        const { testConnection } = await import('../runtime/subagents/trinity/connector.js');
                         const db = DatabaseRegistry.getInstance().getDatabase(id);
                         if (!db) {
                             await safeReply(ctx, '❌ Database not found.');
@@ -666,8 +666,8 @@ export class TelegramAdapter {
                     await ctx.answerCbQuery('Refreshing schema…').catch(() => { });
                     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 { introspectSchema } = await import('../runtime/subagents/trinity/connector.js');
+                        const { Trinity } = await import('../runtime/subagents/trinity/trinity.js');
                         const registry = DatabaseRegistry.getInstance();
                         const db = registry.getDatabase(id);
                         if (!db) {

package/dist/cli/commands/restart.js

@@ -15,8 +15,8 @@ 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 { Link } from '../../runtime/link.js';
-import { LinkWorker } from '../../runtime/link-worker.js';
+import { Link } from '../../runtime/subagents/link/link.js';
+import { LinkWorker } from '../../runtime/subagents/link/worker.js';
 export const restartCommand = new Command('restart')
     .description('Restart the Morpheus agent')
     .option('--ui', 'Enable web UI', true)

package/dist/cli/commands/start.js

@@ -26,8 +26,8 @@ import { ChronosRepository } from '../../runtime/chronos/repository.js';
 import { SkillRegistry } from '../../runtime/skills/index.js';
 import { MCPToolCache } from '../../runtime/tools/cache.js';
 import { SmithRegistry } from '../../runtime/smiths/registry.js';
-import { Link } from '../../runtime/link.js';
-import { LinkWorker } from '../../runtime/link-worker.js';
+import { Link } from '../../runtime/subagents/link/link.js';
+import { LinkWorker } from '../../runtime/subagents/link/worker.js';
 // Load .env file explicitly in start command
 const envPath = path.join(process.cwd(), '.env');
 if (fs.existsSync(envPath)) {

package/dist/http/api.js

@@ -13,8 +13,8 @@ import { MCPServerConfigSchema } from '../config/schemas.js';
 import { Construtor } from '../runtime/tools/factory.js';
 import { TaskRepository } from '../runtime/tasks/repository.js';
 import { DatabaseRegistry } from '../runtime/memory/trinity-db.js';
-import { testConnection, introspectSchema } from '../runtime/trinity-connector.js';
-import { Trinity } from '../runtime/trinity.js';
+import { testConnection, introspectSchema } from '../runtime/subagents/trinity/connector.js';
+import { Trinity } from '../runtime/subagents/trinity/trinity.js';
 import { ChronosRepository } from '../runtime/chronos/repository.js';
 import { ChronosWorker } from '../runtime/chronos/worker.js';
 import { createChronosJobRouter, createChronosConfigRouter } from './routers/chronos.js';
@@ -22,6 +22,7 @@ import { createSkillsRouter } from './routers/skills.js';
 import { createSmithsRouter } from './routers/smiths.js';
 import { createDangerRouter } from './routers/danger.js';
 import { createLinkRouter } from './routers/link.js';
+import { createAgentsRouter } from './routers/agents.js';
 import { getActiveEnvOverrides } from '../config/precedence.js';
 import { hotReloadConfig, getRestartRequiredChanges } from '../runtime/hot-reload.js';
 import { AuditRepository } from '../runtime/audit/repository.js';
@@ -55,6 +56,8 @@ export function createApiRouter(oracle, chronosWorker) {
     router.use('/danger', createDangerRouter());
     // Mount Link router (Documentation management)
     router.use('/link', createLinkRouter());
+    // Mount Agents metadata router
+    router.use('/agents', createAgentsRouter());
     // --- Session Management ---
     router.get('/sessions', async (req, res) => {
         try {

package/dist/http/routers/agents.js

@@ -0,0 +1,9 @@
+import { Router } from 'express';
+import { SubagentRegistry } from '../../runtime/subagents/registry.js';
+export function createAgentsRouter() {
+    const router = Router();
+    router.get('/metadata', (_req, res) => {
+        res.json({ agents: SubagentRegistry.getDisplayMetadata() });
+    });
+    return router;
+}

package/dist/http/routers/link.js

@@ -3,8 +3,8 @@ import multer from 'multer';
 import path from 'path';
 import fs from 'fs-extra';
 import { homedir } from 'os';
-import { LinkRepository } from '../../runtime/link-repository.js';
-import { LinkWorker } from '../../runtime/link-worker.js';
+import { LinkRepository } from '../../runtime/subagents/link/repository.js';
+import { LinkWorker } from '../../runtime/subagents/link/worker.js';
 import { ConfigManager } from '../../config/manager.js';
 const DOCS_PATH = path.join(homedir(), '.morpheus', 'docs');
 // Configure multer for file uploads

package/dist/runtime/chronos/repository.js

@@ -62,6 +62,7 @@ export class ChronosRepository {
         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');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN origin_session_id TEXT`, 'origin_session_id');
         const execInfo = this.db.pragma('table_info(chronos_executions)');
         const execCols = new Set(execInfo.map((c) => c.name));
         const addExecCol = (sql, col) => {
@@ -107,6 +108,7 @@ export class ChronosRepository {
             updated_at: row.updated_at,
             created_by: row.created_by,
             notify_channels,
+            origin_session_id: row.origin_session_id ?? null,
         };
     }
     deserializeExecution(row) {
@@ -132,9 +134,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, 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 ?? []));
+        timezone, next_run_at, last_run_at, enabled, created_at, updated_at, created_by, notify_channels, origin_session_id
+      ) 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 ?? []), input.origin_session_id ?? null);
         return this.getJob(id);
     }
     getJob(id) {

package/dist/runtime/chronos/worker.js

@@ -4,6 +4,7 @@ import { DisplayManager } from '../display.js';
 import { parseNextRun } from './parser.js';
 import { ChannelRegistry } from '../../channels/registry.js';
 import { AuditRepository } from '../audit/repository.js';
+import { SQLiteChatMessageHistory } from '../memory/sqlite.js';
 export class ChronosWorker {
     repo;
     oracle;
@@ -74,9 +75,27 @@ export class ChronosWorker {
         const display = DisplayManager.getInstance();
         const execId = randomUUID();
         display.log(`Job ${job.id} triggered — "${job.prompt.slice(0, 60)}"`, { source: 'Chronos' });
-        // Use the currently active Oracle session so Chronos executes in the
-        // user's conversation context — no session switching or isolation needed.
-        const activeSessionId = this.oracle.getCurrentSessionId() ?? 'default';
+        // Resolve session: prefer the session where the job was originally created,
+        // fall back to Oracle's current session, then to most recent active session.
+        const tmpHistory = new SQLiteChatMessageHistory({ sessionId: 'tmp' });
+        let activeSessionId;
+        try {
+            if (job.origin_session_id && tmpHistory.isSessionUsable(job.origin_session_id)) {
+                activeSessionId = job.origin_session_id;
+            }
+            else {
+                const oracleSession = this.oracle.getCurrentSessionId();
+                if (oracleSession && tmpHistory.isSessionUsable(oracleSession)) {
+                    activeSessionId = oracleSession;
+                }
+                else {
+                    activeSessionId = tmpHistory.getMostRecentSession() ?? 'default';
+                }
+            }
+        }
+        finally {
+            tmpHistory.close();
+        }
         this.repo.insertExecution({
             id: execId,
             job_id: job.id,
@@ -96,7 +115,7 @@ export class ChronosWorker {
             const taskOriginChannel = job.notify_channels.length === 1
                 ? job.notify_channels[0]
                 : 'chronos';
-            const taskContext = { origin_channel: taskOriginChannel, session_id: activeSessionId };
+            const taskContext = { origin_channel: taskOriginChannel, session_id: activeSessionId, source: 'chronos' };
             // Hard-block Chronos management tools during execution.
             ChronosWorker.isExecuting = true;
             const chronosStartMs = Date.now();
@@ -154,6 +173,10 @@ export class ChronosWorker {
         }
         else {
             for (const ch of job.notify_channels) {
+                // 'ui' has no adapter — it works by polling session messages from the DB.
+                // The response is already persisted via oracle.chat(), so skip silently.
+                if (ch === 'ui')
+                    continue;
                 const adapter = ChannelRegistry.get(ch);
                 if (adapter) {
                     await adapter.sendMessage(text).catch((err) => {

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

@@ -30,6 +30,7 @@ function makeJob(overrides = {}) {
         updated_at: Date.now() - 5000,
         created_by: 'ui',
         notify_channels: [],
+        origin_session_id: null,
         ...overrides,
     };
 }
@@ -91,7 +92,7 @@ describe('ChronosWorker.tick()', () => {
         await worker.tick();
         // Wait for fire-and-forget
         await new Promise((r) => setTimeout(r, 50));
-        expect(oracle.chat).toHaveBeenCalledWith(expect.stringContaining(job.prompt));
+        expect(oracle.chat).toHaveBeenCalledWith(expect.stringContaining(job.prompt), undefined, false, expect.objectContaining({ source: 'chronos' }));
         expect(repo.disableJob).toHaveBeenCalledWith(job.id);
         expect(repo.updateJob).not.toHaveBeenCalled();
     });
@@ -102,7 +103,7 @@ describe('ChronosWorker.tick()', () => {
         const worker = new ChronosWorker(repo, oracle);
         await worker.tick();
         await new Promise((r) => setTimeout(r, 50));
-        expect(oracle.chat).toHaveBeenCalledWith(expect.stringContaining(job.prompt));
+        expect(oracle.chat).toHaveBeenCalledWith(expect.stringContaining(job.prompt), undefined, false, expect.objectContaining({ source: 'chronos' }));
         expect(repo.disableJob).not.toHaveBeenCalled();
         expect(repo.updateJob).toHaveBeenCalledWith(job.id, expect.objectContaining({ next_run_at: expect.any(Number) }));
     });

package/dist/runtime/hot-reload.js

@@ -7,9 +7,9 @@
  */
 import { ConfigManager } from '../config/manager.js';
 import { DisplayManager } from './display.js';
-import { Apoc } from './apoc.js';
-import { Neo } from './neo.js';
-import { Trinity } from './trinity.js';
+import { Apoc } from './subagents/apoc.js';
+import { Neo } from './subagents/neo.js';
+import { Trinity } from './subagents/trinity/trinity.js';
 let currentOracle = null;
 /**
  * Register the current Oracle instance for hot-reload.

package/dist/runtime/memory/sqlite.js

@@ -847,6 +847,10 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             embedding_status = 'pending'
         WHERE id = ?
       `).run(now, now, sessionId);
+            // Remove channel/user bindings so channels don't route to an archived session
+            this.db.prepare(`
+        DELETE FROM user_channel_sessions WHERE session_id = ?
+      `).run(sessionId);
             // Exportar mensagens → texto
             const messages = this.db.prepare(`
         SELECT type, content
@@ -936,6 +940,10 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             deleted_at = ?
         WHERE id = ?
       `).run(now, sessionId);
+            // Remove channel/user bindings so channels don't route to a deleted session
+            this.db.prepare(`
+        DELETE FROM user_channel_sessions WHERE session_id = ?
+      `).run(sessionId);
         });
         tx(); // Executar a transação
     }
@@ -977,6 +985,14 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             this.db.prepare("INSERT INTO sessions (id, started_at, status) VALUES (?, ?, 'active')").run(sessionId, Date.now());
         }
     }
+    /**
+     * Checks whether a session exists and is usable (active or paused).
+     * Returns false for deleted, archived, or non-existent sessions.
+     */
+    isSessionUsable(sessionId) {
+        const row = this.db.prepare("SELECT status FROM sessions WHERE id = ?").get(sessionId);
+        return !!row && (row.status === 'active' || row.status === 'paused');
+    }
     /**
      * Validates that the target session exists and is usable (not archived/deleted).
      * No longer swaps active↔paused — sessions are independently usable from any channel.
@@ -1015,10 +1031,11 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
      */
     async listSessions() {
         const sessions = this.db.prepare(`
-      SELECT id, title, status, started_at
-      FROM sessions
-      WHERE status IN ('active', 'paused')
-      ORDER BY started_at DESC
+      SELECT s.id, s.title, s.status, s.started_at,
+             (SELECT MAX(m.created_at) FROM messages m WHERE m.session_id = s.id) AS last_message_at
+      FROM sessions s
+      WHERE s.status IN ('active', 'paused')
+      ORDER BY COALESCE(last_message_at, s.started_at) DESC
     `).all();
         return sessions;
     }
@@ -1028,8 +1045,11 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
      */
     async getUserChannelSession(channel, userId) {
         const result = this.db.prepare(`
-      SELECT session_id FROM user_channel_sessions
-      WHERE channel = ? AND user_id = ?
+      SELECT ucs.session_id
+      FROM user_channel_sessions ucs
+      JOIN sessions s ON s.id = ucs.session_id
+      WHERE ucs.channel = ? AND ucs.user_id = ?
+        AND s.status IN ('active', 'paused')
     `).get(channel, userId);
         return result ? result.session_id : null;
     }
@@ -1052,8 +1072,11 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
      */
     async listUserChannelSessions(channel) {
         const rows = this.db.prepare(`
-      SELECT user_id, session_id FROM user_channel_sessions
-      WHERE channel = ?
+      SELECT ucs.user_id, ucs.session_id
+      FROM user_channel_sessions ucs
+      JOIN sessions s ON s.id = ucs.session_id
+      WHERE ucs.channel = ?
+        AND s.status IN ('active', 'paused')
     `).all(channel);
         return rows.map(row => ({ userId: row.user_id, sessionId: row.session_id }));
     }
@@ -1075,9 +1098,12 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             return null;
         const placeholders = channels.map(() => '?').join(', ');
         const result = this.db.prepare(`
-      SELECT session_id FROM user_channel_sessions
-      WHERE channel IN (${placeholders})
-      ORDER BY updated_at DESC LIMIT 1
+      SELECT ucs.session_id
+      FROM user_channel_sessions ucs
+      JOIN sessions s ON s.id = ucs.session_id
+      WHERE ucs.channel IN (${placeholders})
+        AND s.status IN ('active', 'paused')
+      ORDER BY ucs.updated_at DESC LIMIT 1
     `).get(...channels);
         return result ? result.session_id : null;
     }

package/dist/runtime/oracle.js

@@ -5,12 +5,9 @@ import { ProviderError } from "./errors.js";
 import { DisplayManager } from "./display.js";
 import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
 import { SatiMemoryMiddleware } from "./memory/sati/index.js";
-import { Apoc } from "./apoc.js";
+import { Apoc, Neo, Trinity, Link, SubagentRegistry, emitToolAuditEvents } from "./subagents/index.js";
 import { TaskRequestContext } from "./tasks/context.js";
 import { TaskRepository } from "./tasks/repository.js";
-import { Neo } from "./neo.js";
-import { Trinity } from "./trinity.js";
-import { Link } from "./link.js";
 import { SmithDelegateTool } from "./tools/smith-tool.js";
 import { TaskQueryTool, chronosTools, timeVerifierTool } from "./tools/index.js";
 import { Construtor } from "./tools/factory.js";
@@ -20,12 +17,9 @@ import { SmithRegistry } from "./smiths/registry.js";
 import { AuditRepository } from "./audit/repository.js";
 import { SetupRepository } from './setup/repository.js';
 import { buildSetupTool } from './tools/setup-tool.js';
-import { emitToolAuditEvents } from "./subagent-utils.js";
+import { SmithDelegator } from "./smiths/delegator.js";
 import { PATHS } from "../config/paths.js";
 import { writeFileSync } from "fs";
-const ORACLE_DELEGATION_TOOLS = new Set([
-    'apoc_delegate', 'neo_delegate', 'trinity_delegate', 'smith_delegate', 'link_delegate',
-]);
 export class Oracle {
     provider;
     config;
@@ -40,6 +34,48 @@ export class Oracle {
         this.config = config || ConfigManager.getInstance().get();
         this.databasePath = overrides?.databasePath;
     }
+    /**
+     * Registers Smith in the SubagentRegistry if Smiths are configured and enabled.
+     * Smith is special — it uses a standalone tool (SmithDelegateTool) and SmithDelegator
+     * rather than implementing ISubagent, so we create a minimal registration.
+     */
+    registerSmithIfEnabled() {
+        const smithsConfig = ConfigManager.getInstance().getSmithsConfig();
+        if (!smithsConfig.enabled || smithsConfig.entries.length === 0)
+            return;
+        if (SubagentRegistry.get('smith'))
+            return; // already registered
+        const delegator = SmithDelegator.getInstance();
+        SubagentRegistry.register({
+            agentKey: 'smith', auditAgent: 'smith', label: 'Smith',
+            delegateToolName: 'smith_delegate', emoji: '🕶️', color: 'gray',
+            description: 'Remote DevKit execution',
+            colorClass: 'text-gray-500 dark:text-gray-400',
+            bgClass: 'bg-gray-50 dark:bg-zinc-900',
+            badgeClass: 'bg-gray-200 text-gray-700 dark:bg-gray-700/60 dark:text-gray-300',
+            instance: {
+                initialize: async () => { },
+                execute: async (task, context) => delegator.delegate('unknown', task, context),
+                reload: async () => { },
+                createDelegateTool: () => SmithDelegateTool,
+            },
+            hasDynamicDescription: false,
+            isMultiInstance: true,
+            executeTask: async (task) => {
+                let smithName = 'unknown';
+                if (task.context) {
+                    try {
+                        const parsed = JSON.parse(task.context);
+                        smithName = parsed.smith_name || parsed.smith || 'unknown';
+                    }
+                    catch {
+                        smithName = task.context;
+                    }
+                }
+                return delegator.delegate(smithName, task.input, task.context ?? undefined);
+            },
+        });
+    }
     buildDelegationFailureResponse() {
         return "Task enqueue could not be confirmed in the database. No task was created. Please retry.";
     }
@@ -115,13 +151,16 @@ export class Oracle {
         return valid;
     }
     hasDelegationToolCall(messages) {
+        const delegationTools = SubagentRegistry.getDelegationToolNames();
+        // Also include smith_delegate which may not be in registry if smiths are disabled
+        delegationTools.add('smith_delegate');
         for (const msg of messages) {
             if (!(msg instanceof AIMessage))
                 continue;
             const toolCalls = msg.tool_calls ?? [];
             if (!Array.isArray(toolCalls))
                 continue;
-            if (toolCalls.some((tc) => tc?.name === "apoc_delegate" || tc?.name === "neo_delegate" || tc?.name === "trinity_delegate" || tc?.name === "smith_delegate" || tc?.name === "link_delegate")) {
+            if (toolCalls.some((tc) => delegationTools.has(tc?.name))) {
                 return true;
             }
         }
@@ -152,27 +191,30 @@ export class Oracle {
         // Note: API Key validation is delegated to ProviderFactory or the Provider itself 
         // to allow for Environment Variable fallback supported by LangChain.
         try {
-            // Refresh Neo and Trinity tool catalogs so delegate descriptions contain runtime info.
-            // Fail-open: Oracle can still initialize even if catalog refresh fails.
-            await Neo.refreshDelegateCatalog().catch(() => { });
-            await Trinity.refreshDelegateCatalog().catch(() => { });
-            await Link.refreshDelegateCatalog().catch(() => { });
-            // Build tool list — conditionally include SmithDelegateTool based on config
+            // Ensure subagents are instantiated and self-registered before using the registry.
+            Apoc.getInstance();
+            Neo.getInstance();
+            Trinity.getInstance();
+            Link.getInstance();
+            // Register Smith in the registry if configured
+            this.registerSmithIfEnabled();
+            // Refresh dynamic tool catalogs so delegate descriptions contain runtime info.
+            await SubagentRegistry.refreshAllCatalogs();
             // Initialize setup repository (creates table if needed)
             SetupRepository.getInstance();
             const coreTools = [
                 buildSetupTool(),
                 TaskQueryTool,
-                Neo.getInstance().createDelegateTool(),
-                Apoc.getInstance().createDelegateTool(),
-                Trinity.getInstance().createDelegateTool(),
-                Link.getInstance().createDelegateTool(),
+                ...SubagentRegistry.getDelegationTools(),
                 createLoadSkillTool(),
                 timeVerifierTool,
                 ...chronosTools,
             ];
+            // Smith's tool is already included via SubagentRegistry.getDelegationTools()
+            // if registerSmithIfEnabled() registered it. Only add it if Smith is enabled
+            // but NOT yet in the registry (shouldn't happen, but defensive).
             const smithsConfig = ConfigManager.getInstance().getSmithsConfig();
-            if (smithsConfig.enabled && smithsConfig.entries.length > 0) {
+            if (smithsConfig.enabled && smithsConfig.entries.length > 0 && !SubagentRegistry.get('smith')) {
                 coreTools.push(SmithDelegateTool);
             }
             this.provider = await ProviderFactory.create(this.config.llm, coreTools);
@@ -225,12 +267,14 @@ export class Oracle {
                 provider: isTelephonist ? this.config.audio?.provider : this.config.llm.provider,
                 model: isTelephonist ? this.config.audio?.model : this.config.llm.model
             };
-            // Inject source metadata for automated origins (webhook, chronos)
-            if (taskContext?.origin_channel === 'webhook') {
-                userMessage.source_metadata = { source: 'webhook' };
-            }
-            else if (taskContext?.origin_channel === 'chronos') {
-                userMessage.source_metadata = { source: 'chronos' };
+            // Inject source metadata for automated origins (webhook, chronos).
+            // Prefer explicit taskContext.source (set by Chronos even when origin_channel
+            // points to a specific notification channel like 'telegram').
+            const messageSource = taskContext?.source ?? (taskContext?.origin_channel === 'webhook' ? 'webhook'
+                : taskContext?.origin_channel === 'chronos' ? 'chronos'
+                    : null);
+            if (messageSource) {
+                userMessage.source_metadata = { source: messageSource };
             }
             // Attach extra usage (e.g. from Audio) to the user message to be persisted
             if (extraUsage) {
@@ -465,10 +509,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
             }
             messages.push(...previousMessages);
             messages.push(userMessage);
-            Apoc.setSessionId(currentSessionId);
-            Neo.setSessionId(currentSessionId);
-            Trinity.setSessionId(currentSessionId);
-            Link.setSessionId(currentSessionId);
+            SubagentRegistry.setAllSessionIds(currentSessionId);
             const invokeContext = {
                 origin_channel: taskContext?.origin_channel ?? "api",
                 session_id: taskContext?.session_id ?? currentSessionId ?? "default",
@@ -514,8 +555,10 @@ Use it to inform your response and tool selection (if needed), but do not assume
             // Emit tool_call audit events for Oracle's independent tool calls.
             // Delegation tools (apoc/neo/trinity/smith/skill/link) are already audited
             // inside buildDelegationTool or the task system — skip them here.
+            const delegationToolNames = SubagentRegistry.getDelegationToolNames();
+            delegationToolNames.add('smith_delegate');
             emitToolAuditEvents(newGeneratedMessages, currentSessionId ?? 'default', 'oracle', {
-                skipTools: ORACLE_DELEGATION_TOOLS,
+                skipTools: delegationToolNames,
             });
             // Inject provider/model metadata and duration into all new AI messages
             for (const msg of newGeneratedMessages) {
@@ -694,24 +737,16 @@ Use it to inform your response and tool selection (if needed), but do not assume
         }
         // Reload MCP tool cache from servers (slow path)
         await Construtor.reload();
-        await Neo.refreshDelegateCatalog().catch(() => { });
-        await Trinity.refreshDelegateCatalog().catch(() => { });
-        await Link.refreshDelegateCatalog().catch(() => { });
+        await SubagentRegistry.refreshAllCatalogs();
         this.provider = await ProviderFactory.create(this.config.llm, [
             buildSetupTool(),
             TaskQueryTool,
-            Neo.getInstance().createDelegateTool(),
-            Apoc.getInstance().createDelegateTool(),
-            Trinity.getInstance().createDelegateTool(),
-            Link.getInstance().createDelegateTool(),
+            ...SubagentRegistry.getDelegationTools(),
             createLoadSkillTool(),
             timeVerifierTool,
             ...chronosTools,
         ]);
-        await Neo.getInstance().reload();
-        await Apoc.getInstance().reload();
-        await Trinity.getInstance().reload();
-        await Link.getInstance().reload();
-        this.display.log(`Oracle and Neo tools reloaded`, { source: 'Oracle' });
+        await SubagentRegistry.reloadAll();
+        this.display.log(`Oracle and subagent tools reloaded`, { source: 'Oracle' });
     }
 }

package/dist/runtime/{apoc.js → subagents/apoc.js}

@@ -1,12 +1,13 @@
 import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
-import { ConfigManager } from "../config/manager.js";
-import { ProviderFactory } from "./providers/factory.js";
-import { ProviderError } from "./errors.js";
-import { DisplayManager } from "./display.js";
+import { ConfigManager } from "../../config/manager.js";
+import { ProviderFactory } from "../providers/factory.js";
+import { ProviderError } from "../errors.js";
+import { DisplayManager } from "../display.js";
 import { buildDevKit } from "morpheus-devkit";
 import { instrumentDevKitTools } from "./devkit-instrument.js";
-import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from "./subagent-utils.js";
-import { buildDelegationTool } from "./tools/delegation-utils.js";
+import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from "./utils.js";
+import { buildDelegationTool } from "../tools/delegation-utils.js";
+import { SubagentRegistry } from "./registry.js";
 /**
  * Apoc is a subagent of Oracle specialized in devtools operations.
  * It receives delegated tasks from Oracle and executes them using DevKit tools
@@ -36,6 +37,18 @@ export class Apoc {
     static getInstance(config) {
         if (!Apoc.instance) {
             Apoc.instance = new Apoc(config);
+            SubagentRegistry.register({
+                agentKey: 'apoc', auditAgent: 'apoc', label: 'Apoc',
+                delegateToolName: 'apoc_delegate', emoji: '🧑‍🔬', color: 'amber',
+                description: 'Filesystem, shell & browser',
+                colorClass: 'text-amber-600 dark:text-amber-400',
+                bgClass: 'bg-amber-50 dark:bg-amber-900/10',
+                badgeClass: 'bg-amber-100 text-amber-700 dark:bg-amber-900/40 dark:text-amber-300',
+                instance: Apoc.instance,
+                hasDynamicDescription: false,
+                isMultiInstance: false,
+                setSessionId: (id) => Apoc.setSessionId(id),
+            });
         }
         return Apoc.instance;
     }

package/dist/runtime/{devkit-instrument.js → subagents/devkit-instrument.js}

@@ -1,4 +1,4 @@
-import { AuditRepository } from './audit/repository.js';
+import { AuditRepository } from '../audit/repository.js';
 /**
  * Wraps a StructuredTool to record audit events on each invocation.
  * The `getSessionId` getter is called at invocation time so it reflects

package/dist/runtime/subagents/index.js

@@ -0,0 +1,12 @@
+// Re-exports for convenient external access
+export { Apoc } from './apoc.js';
+export { Neo } from './neo.js';
+export { Trinity } from './trinity/trinity.js';
+export { Link } from './link/link.js';
+export { SubagentRegistry, SYSTEM_AGENTS } from './registry.js';
+export { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from './utils.js';
+export { LinkRepository } from './link/repository.js';
+export { LinkWorker } from './link/worker.js';
+export { LinkSearch } from './link/search.js';
+export { instrumentDevKitTools } from './devkit-instrument.js';
+export { testConnection, introspectSchema, executeQuery } from './trinity/connector.js';