morpheus-cli 0.9.11 → 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

@@ -21,6 +21,36 @@ function escapeHtml(text) {
         .replace(/</g, '&lt;')
         .replace(/>/g, '&gt;');
 }
+/** Telegram callback_data has a 64-byte limit. Truncate if needed. */
+function safeCallbackData(data, prefix) {
+    const MAX_CALLBACK_DATA = 64;
+    const full = `${prefix}${data}`;
+    if (full.length > MAX_CALLBACK_DATA) {
+        // Truncate and add hash suffix to identify original
+        const hash = data.slice(-8);
+        return `${prefix}${data.slice(0, MAX_CALLBACK_DATA - prefix.length - 8)}${hash}`;
+    }
+    return full;
+}
+/** Safely reply to a message, handling Telegram API errors gracefully. */
+async function safeReply(ctx, text, options) {
+    try {
+        await ctx.reply(text, options);
+    }
+    catch (error) {
+        // Common errors: message not found, chat not found, bot blocked, etc.
+        const msg = error?.description || error?.message || 'Unknown error';
+        if (msg.includes('message to reply not found') ||
+            msg.includes('chat not found') ||
+            msg.includes('bot was blocked') ||
+            msg.includes('user is deactivated')) {
+            // Silently ignore - user may have blocked bot or message expired
+            return;
+        }
+        // Log other errors but don't crash
+        console.error('[Telegram] Reply error:', msg);
+    }
+}
 /** Strips HTML tags and unescapes entities for plain-text Telegram fallback. */
 function stripHtmlTags(html) {
     return html
@@ -405,19 +435,31 @@ export class TelegramAdapter {
                 }
             });
             this.bot.action('confirm_new_session', async (ctx) => {
-                await this.handleApproveNewSessionCommand(ctx, ctx.from.username || ctx.from.first_name);
-                if (ctx.updateType === 'callback_query') {
-                    ctx.answerCbQuery();
-                    ctx.deleteMessage().catch(() => { });
+                try {
+                    await this.handleApproveNewSessionCommand(ctx, ctx.from.username || ctx.from.first_name);
+                    if (ctx.updateType === 'callback_query') {
+                        ctx.answerCbQuery().catch(() => { });
+                        ctx.deleteMessage().catch(() => { });
+                    }
+                    await safeReply(ctx, "New session created.");
+                }
+                catch (error) {
+                    console.error('[Telegram] confirm_new_session error:', error.message);
+                    ctx.answerCbQuery(`Error: ${error.message}`).catch(() => { });
                 }
-                ctx.reply("New session created.");
             });
             this.bot.action('cancel_new_session', async (ctx) => {
-                if (ctx.updateType === 'callback_query') {
-                    ctx.answerCbQuery();
-                    ctx.deleteMessage().catch(() => { });
+                try {
+                    if (ctx.updateType === 'callback_query') {
+                        ctx.answerCbQuery().catch(() => { });
+                        ctx.deleteMessage().catch(() => { });
+                    }
+                    await safeReply(ctx, "New session cancelled.");
+                }
+                catch (error) {
+                    console.error('[Telegram] cancel_new_session error:', error.message);
+                    ctx.answerCbQuery(`Error: ${error.message}`).catch(() => { });
                 }
-                ctx.reply("New session cancelled.");
             });
             this.bot.action(/^switch_session_/, async (ctx) => {
                 const callbackQuery = ctx.callbackQuery;
@@ -425,7 +467,7 @@ export class TelegramAdapter {
                 const sessionId = typeof data === 'string' ? data.replace('switch_session_', '') : '';
                 const userId = ctx.from.id.toString();
                 if (!sessionId || sessionId === '') {
-                    await ctx.answerCbQuery('Invalid session ID');
+                    await ctx.answerCbQuery('Invalid session ID').catch(() => { });
                     return;
                 }
                 try {
@@ -436,34 +478,40 @@ export class TelegramAdapter {
                     // Update user-channel session mapping
                     await this.history.setUserChannelSession(this.channel, userId, sessionId);
                     this.userSessions.set(userId, sessionId);
-                    await ctx.answerCbQuery();
+                    await ctx.answerCbQuery().catch(() => { });
                     // Remove the previous message and send confirmation
                     if (ctx.updateType === 'callback_query') {
                         ctx.deleteMessage().catch(() => { });
                     }
-                    ctx.reply(`✅ Switched to session ID: ${sessionId}`);
+                    await safeReply(ctx, `✅ Switched to session ID: ${sessionId}`);
                 }
                 catch (error) {
-                    await ctx.answerCbQuery(`Error switching session: ${error.message}`, { show_alert: true });
+                    await ctx.answerCbQuery(`Error switching session: ${error.message}`, { show_alert: true }).catch(() => { });
                 }
             });
             // --- Archive Flow ---
             this.bot.action(/^ask_archive_session_/, async (ctx) => {
-                const data = ctx.callbackQuery.data;
-                const sessionId = data.replace('ask_archive_session_', '');
-                // Fetch session title for better UX (optional, but nice) - for now just use ID
-                await ctx.reply(`⚠️ *ARCHIVE SESSION?*\n\nAre you sure you want to archive session \`${escMd(sessionId)}\`?\n\nIt will be moved to long\\-term memory \\(SATI\\) and removed from the active list\\. This action cannot be easily undone via Telegram\\.`, {
-                    parse_mode: 'MarkdownV2',
-                    reply_markup: {
-                        inline_keyboard: [
-                            [
-                                { text: '✅ Yes, Archive', callback_data: `confirm_archive_session_${sessionId}` },
-                                { text: '❌ Cancel', callback_data: 'cancel_session_action' }
+                try {
+                    const data = ctx.callbackQuery.data;
+                    const sessionId = data.replace('ask_archive_session_', '');
+                    // Fetch session title for better UX (optional, but nice) - for now just use ID
+                    await ctx.reply(`⚠️ *ARCHIVE SESSION?*\n\nAre you sure you want to archive session \`${escMd(sessionId)}\`?\n\nIt will be moved to long\\-term memory \\(SATI\\) and removed from the active list\\. This action cannot be easily undone via Telegram\\.`, {
+                        parse_mode: 'MarkdownV2',
+                        reply_markup: {
+                            inline_keyboard: [
+                                [
+                                    { text: '✅ Yes, Archive', callback_data: safeCallbackData(sessionId, 'confirm_archive_session_') },
+                                    { text: '❌ Cancel', callback_data: 'cancel_session_action' }
+                                ]
                             ]
-                        ]
-                    }
-                });
-                await ctx.answerCbQuery();
+                        }
+                    });
+                    await ctx.answerCbQuery().catch(() => { });
+                }
+                catch (error) {
+                    console.error('[Telegram] ask_archive_session error:', error.message);
+                    ctx.answerCbQuery(`Error: ${error.message}`).catch(() => { });
+                }
             });
             this.bot.action(/^confirm_archive_session_/, async (ctx) => {
                 const data = ctx.callbackQuery.data;
@@ -478,32 +526,38 @@ export class TelegramAdapter {
                         await this.history.deleteUserChannelSession(this.channel, userId);
                         this.userSessions.delete(userId);
                     }
-                    await ctx.answerCbQuery('Session archived successfully');
+                    await ctx.answerCbQuery('Session archived successfully').catch(() => { });
                     if (ctx.updateType === 'callback_query') {
                         ctx.deleteMessage().catch(() => { });
                     }
-                    await ctx.reply(`✅ Session \`${escMd(sessionId)}\` has been archived and moved to long\\-term memory\\.`, { parse_mode: 'MarkdownV2' });
+                    await safeReply(ctx, `✅ Session \`${escMd(sessionId)}\` has been archived and moved to long\\-term memory\\.`, { parse_mode: 'MarkdownV2' });
                 }
                 catch (error) {
-                    await ctx.answerCbQuery(`Error archiving: ${error.message}`, { show_alert: true });
+                    await ctx.answerCbQuery(`Error archiving: ${error.message}`, { show_alert: true }).catch(() => { });
                 }
             });
             // --- Delete Flow ---
             this.bot.action(/^ask_delete_session_/, async (ctx) => {
-                const data = ctx.callbackQuery.data;
-                const sessionId = data.replace('ask_delete_session_', '');
-                await ctx.reply(`🚫 *DELETE SESSION?*\n\nAre you sure you want to PERMANENTLY DELETE session \`${escMd(sessionId)}\`?\n\nThis action is *IRREVERSIBLE*\\. All data will be lost\\.`, {
-                    parse_mode: 'MarkdownV2',
-                    reply_markup: {
-                        inline_keyboard: [
-                            [
-                                { text: '🗑️ Yes, DELETE PERMANENTLY', callback_data: `confirm_delete_session_${sessionId}` },
-                                { text: '❌ Cancel', callback_data: 'cancel_session_action' }
+                try {
+                    const data = ctx.callbackQuery.data;
+                    const sessionId = data.replace('ask_delete_session_', '');
+                    await ctx.reply(`🚫 *DELETE SESSION?*\n\nAre you sure you want to PERMANENTLY DELETE session \`${escMd(sessionId)}\`?\n\nThis action is *IRREVERSIBLE*\\. All data will be lost\\.`, {
+                        parse_mode: 'MarkdownV2',
+                        reply_markup: {
+                            inline_keyboard: [
+                                [
+                                    { text: '🗑️ Yes, DELETE PERMANENTLY', callback_data: safeCallbackData(sessionId, 'confirm_delete_session_') },
+                                    { text: '❌ Cancel', callback_data: 'cancel_session_action' }
+                                ]
                             ]
-                        ]
-                    }
-                });
-                await ctx.answerCbQuery();
+                        }
+                    });
+                    await ctx.answerCbQuery().catch(() => { });
+                }
+                catch (error) {
+                    console.error('[Telegram] ask_delete_session error:', error.message);
+                    ctx.answerCbQuery(`Error: ${error.message}`).catch(() => { });
+                }
             });
             this.bot.action(/^confirm_delete_session_/, async (ctx) => {
                 const data = ctx.callbackQuery.data;
@@ -518,169 +572,205 @@ export class TelegramAdapter {
                         await this.history.deleteUserChannelSession(this.channel, userId);
                         this.userSessions.delete(userId);
                     }
-                    await ctx.answerCbQuery('Session deleted successfully');
+                    await ctx.answerCbQuery('Session deleted successfully').catch(() => { });
                     if (ctx.updateType === 'callback_query') {
                         ctx.deleteMessage().catch(() => { });
                     }
-                    await ctx.reply(`🗑️ Session \`${escMd(sessionId)}\` has been permanently deleted\\.`, { parse_mode: 'MarkdownV2' });
+                    await safeReply(ctx, `🗑️ Session \`${escMd(sessionId)}\` has been permanently deleted\\.`, { parse_mode: 'MarkdownV2' });
                 }
                 catch (error) {
-                    await ctx.answerCbQuery(`Error deleting: ${error.message}`, { show_alert: true });
+                    await ctx.answerCbQuery(`Error deleting: ${error.message}`, { show_alert: true }).catch(() => { });
                 }
             });
             // --- Cancel Action ---
             this.bot.action('cancel_session_action', async (ctx) => {
-                await ctx.answerCbQuery('Action cancelled');
-                if (ctx.updateType === 'callback_query') {
-                    ctx.deleteMessage().catch(() => { });
+                try {
+                    await ctx.answerCbQuery('Action cancelled').catch(() => { });
+                    if (ctx.updateType === 'callback_query') {
+                        ctx.deleteMessage().catch(() => { });
+                    }
+                    await safeReply(ctx, 'Action cancelled.');
+                }
+                catch (error) {
+                    console.error('[Telegram] cancel_session_action error:', error.message);
+                    ctx.answerCbQuery(`Error: ${error.message}`).catch(() => { });
                 }
-                await ctx.reply('Action cancelled.');
             });
             this.bot.action(/^toggle_mcp_/, async (ctx) => {
                 const data = ctx.callbackQuery.data;
                 // format: toggle_mcp_enable_<name> or toggle_mcp_disable_<name>
                 const match = data.match(/^toggle_mcp_(enable|disable)_(.+)$/);
                 if (!match) {
-                    await ctx.answerCbQuery('Invalid action');
+                    await ctx.answerCbQuery('Invalid action').catch(() => { });
                     return;
                 }
                 const [, action, serverName] = match;
                 const enable = action === 'enable';
                 try {
                     await MCPManager.setServerEnabled(serverName, enable);
-                    await ctx.answerCbQuery(`${enable ? '✅ Enabled' : '❌ Disabled'}: ${serverName}`);
+                    await ctx.answerCbQuery(`${enable ? '✅ Enabled' : '❌ Disabled'}: ${serverName}`).catch(() => { });
                     if (ctx.updateType === 'callback_query') {
                         ctx.deleteMessage().catch(() => { });
                     }
                     const user = ctx.from?.username || ctx.from?.first_name || 'unknown';
                     this.display.log(`MCP '${serverName}' ${enable ? 'enabled' : 'disabled'} by @${user}`, { source: 'Telegram', level: 'info' });
                     await this.handleMcpListCommand(ctx, user);
-                    await ctx.reply(`⚠️ Use /mcpreload for the changes to take effect.`);
+                    await safeReply(ctx, `⚠️ Use /mcpreload for the changes to take effect.`);
                 }
                 catch (error) {
-                    await ctx.answerCbQuery('Failed to update MCP');
-                    await ctx.reply(`❌ Failed to ${enable ? 'enable' : 'disable'} MCP '${serverName}': ${error.message}`);
+                    await ctx.answerCbQuery('Failed to update MCP').catch(() => { });
+                    await safeReply(ctx, `❌ Failed to ${enable ? 'enable' : 'disable'} MCP '${serverName}': ${error.message}`);
                 }
             });
             // --- Trinity DB Test Connection ---
             this.bot.action(/^test_trinity_db_/, async (ctx) => {
-                const data = ctx.callbackQuery.data;
-                const id = parseInt(data.replace('test_trinity_db_', ''), 10);
-                if (isNaN(id)) {
-                    await ctx.answerCbQuery('Invalid ID');
-                    return;
-                }
-                await ctx.answerCbQuery('Testing connection…');
                 try {
-                    const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
-                    const { testConnection } = await import('../runtime/trinity-connector.js');
-                    const db = DatabaseRegistry.getInstance().getDatabase(id);
-                    if (!db) {
-                        await ctx.reply('❌ Database not found.');
+                    const data = ctx.callbackQuery.data;
+                    const id = parseInt(data.replace('test_trinity_db_', ''), 10);
+                    if (isNaN(id)) {
+                        await ctx.answerCbQuery('Invalid ID').catch(() => { });
                         return;
                     }
-                    const ok = await testConnection(db);
-                    await ctx.reply(ok
-                        ? `✅ <b>${escapeHtml(db.name)}</b>: connection successful.`
-                        : `❌ <b>${escapeHtml(db.name)}</b>: connection failed.`, { parse_mode: 'HTML' });
+                    await ctx.answerCbQuery('Testing connection…').catch(() => { });
+                    try {
+                        const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+                        const { testConnection } = await import('../runtime/subagents/trinity/connector.js');
+                        const db = DatabaseRegistry.getInstance().getDatabase(id);
+                        if (!db) {
+                            await safeReply(ctx, '❌ Database not found.');
+                            return;
+                        }
+                        const ok = await testConnection(db);
+                        await safeReply(ctx, ok
+                            ? `✅ <b>${escapeHtml(db.name)}</b>: connection successful.`
+                            : `❌ <b>${escapeHtml(db.name)}</b>: connection failed.`, { parse_mode: 'HTML' });
+                    }
+                    catch (e) {
+                        await safeReply(ctx, `❌ Error testing connection: ${escapeHtml(e.message)}`, { parse_mode: 'HTML' });
+                    }
                 }
-                catch (e) {
-                    await ctx.reply(`❌ Error testing connection: ${escapeHtml(e.message)}`, { parse_mode: 'HTML' });
+                catch (error) {
+                    console.error('[Telegram] test_trinity_db error:', error.message);
+                    ctx.answerCbQuery(`Error: ${error.message}`).catch(() => { });
                 }
             });
             // --- Trinity DB Refresh Schema ---
             this.bot.action(/^refresh_trinity_db_schema_/, async (ctx) => {
-                const data = ctx.callbackQuery.data;
-                const id = parseInt(data.replace('refresh_trinity_db_schema_', ''), 10);
-                if (isNaN(id)) {
-                    await ctx.answerCbQuery('Invalid ID');
-                    return;
-                }
-                await ctx.answerCbQuery('Refreshing schema…');
                 try {
-                    const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
-                    const { introspectSchema } = await import('../runtime/trinity-connector.js');
-                    const { Trinity } = await import('../runtime/trinity.js');
-                    const registry = DatabaseRegistry.getInstance();
-                    const db = registry.getDatabase(id);
-                    if (!db) {
-                        await ctx.reply('❌ Database not found.');
+                    const data = ctx.callbackQuery.data;
+                    const id = parseInt(data.replace('refresh_trinity_db_schema_', ''), 10);
+                    if (isNaN(id)) {
+                        await ctx.answerCbQuery('Invalid ID').catch(() => { });
                         return;
                     }
-                    const schema = await introspectSchema(db);
-                    registry.updateSchema(id, JSON.stringify(schema, null, 2));
-                    await Trinity.refreshDelegateCatalog().catch(() => { });
-                    const tableNames = schema.databases
-                        ? schema.databases.flatMap((d) => d.tables.map((t) => `${d.name}.${t.name}`))
-                        : schema.tables.map((t) => t.name);
-                    const count = tableNames.length;
-                    await ctx.reply(`🔄 <b>${escapeHtml(db.name)}</b>: schema refreshed — ${count} ${count === 1 ? 'table' : 'tables'}.`, { parse_mode: 'HTML' });
+                    await ctx.answerCbQuery('Refreshing schema…').catch(() => { });
+                    try {
+                        const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.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) {
+                            await safeReply(ctx, '❌ Database not found.');
+                            return;
+                        }
+                        const schema = await introspectSchema(db);
+                        registry.updateSchema(id, JSON.stringify(schema, null, 2));
+                        await Trinity.refreshDelegateCatalog().catch(() => { });
+                        const tableNames = schema.databases
+                            ? schema.databases.flatMap((d) => d.tables.map((t) => `${d.name}.${t.name}`))
+                            : schema.tables.map((t) => t.name);
+                        const count = tableNames.length;
+                        await safeReply(ctx, `🔄 <b>${escapeHtml(db.name)}</b>: schema refreshed — ${count} ${count === 1 ? 'table' : 'tables'}.`, { parse_mode: 'HTML' });
+                    }
+                    catch (e) {
+                        await safeReply(ctx, `❌ Error refreshing schema: ${escapeHtml(e.message)}`, { parse_mode: 'HTML' });
+                    }
                 }
-                catch (e) {
-                    await ctx.reply(`❌ Error refreshing schema: ${escapeHtml(e.message)}`, { parse_mode: 'HTML' });
+                catch (error) {
+                    console.error('[Telegram] refresh_trinity_db_schema error:', error.message);
+                    ctx.answerCbQuery(`Error: ${error.message}`).catch(() => { });
                 }
             });
             // --- Trinity DB Delete Flow ---
             this.bot.action(/^ask_trinity_db_delete_/, async (ctx) => {
-                const data = ctx.callbackQuery.data;
-                const id = parseInt(data.replace('ask_trinity_db_delete_', ''), 10);
-                if (isNaN(id)) {
-                    await ctx.answerCbQuery('Invalid ID');
-                    return;
-                }
                 try {
-                    const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
-                    const db = DatabaseRegistry.getInstance().getDatabase(id);
-                    if (!db) {
-                        await ctx.answerCbQuery('Database not found');
+                    const data = ctx.callbackQuery.data;
+                    const id = parseInt(data.replace('ask_trinity_db_delete_', ''), 10);
+                    if (isNaN(id)) {
+                        await ctx.answerCbQuery('Invalid ID').catch(() => { });
                         return;
                     }
-                    await ctx.answerCbQuery();
-                    await ctx.reply(`⚠️ Delete <b>${escapeHtml(db.name)}</b> (${escapeHtml(db.type)}) from Trinity?\n\nThe actual database won't be affected — only this registration will be removed.`, {
-                        parse_mode: 'HTML',
-                        reply_markup: {
-                            inline_keyboard: [
-                                [
-                                    { text: '🗑️ Yes, delete', callback_data: `confirm_trinity_db_delete_${id}` },
-                                    { text: 'Cancel', callback_data: 'cancel_trinity_db_delete' },
+                    try {
+                        const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+                        const db = DatabaseRegistry.getInstance().getDatabase(id);
+                        if (!db) {
+                            await ctx.answerCbQuery('Database not found').catch(() => { });
+                            return;
+                        }
+                        await ctx.answerCbQuery().catch(() => { });
+                        await ctx.reply(`⚠️ Delete <b>${escapeHtml(db.name)}</b> (${escapeHtml(db.type)}) from Trinity?\n\nThe actual database won't be affected — only this registration will be removed.`, {
+                            parse_mode: 'HTML',
+                            reply_markup: {
+                                inline_keyboard: [
+                                    [
+                                        { text: '🗑️ Yes, delete', callback_data: `confirm_trinity_db_delete_${id}` },
+                                        { text: 'Cancel', callback_data: 'cancel_trinity_db_delete' },
+                                    ],
                                 ],
-                            ],
-                        },
-                    });
+                            },
+                        });
+                    }
+                    catch (e) {
+                        await ctx.answerCbQuery(`Error: ${e.message}`, { show_alert: true }).catch(() => { });
+                    }
                 }
-                catch (e) {
-                    await ctx.answerCbQuery(`Error: ${e.message}`, { show_alert: true });
+                catch (error) {
+                    console.error('[Telegram] ask_trinity_db_delete error:', error.message);
+                    ctx.answerCbQuery(`Error: ${error.message}`).catch(() => { });
                 }
             });
             this.bot.action(/^confirm_trinity_db_delete_/, async (ctx) => {
-                const data = ctx.callbackQuery.data;
-                const id = parseInt(data.replace('confirm_trinity_db_delete_', ''), 10);
-                if (isNaN(id)) {
-                    await ctx.answerCbQuery('Invalid ID');
-                    return;
+                try {
+                    const data = ctx.callbackQuery.data;
+                    const id = parseInt(data.replace('confirm_trinity_db_delete_', ''), 10);
+                    if (isNaN(id)) {
+                        await ctx.answerCbQuery('Invalid ID').catch(() => { });
+                        return;
+                    }
+                    try {
+                        const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
+                        const registry = DatabaseRegistry.getInstance();
+                        const db = registry.getDatabase(id);
+                        const name = db?.name ?? `#${id}`;
+                        const deleted = registry.deleteDatabase(id);
+                        await ctx.answerCbQuery(deleted ? '🗑️ Deleted' : 'Not found').catch(() => { });
+                        if (ctx.updateType === 'callback_query')
+                            ctx.deleteMessage().catch(() => { });
+                        const user = ctx.from?.username || ctx.from?.first_name || 'unknown';
+                        this.display.log(`Trinity DB '${name}' deleted by @${user}`, { source: 'Telegram', level: 'info' });
+                        await safeReply(ctx, deleted ? `🗑️ <b>${escapeHtml(name)}</b> removed from Trinity.` : `❌ Database #${id} not found.`, { parse_mode: 'HTML' });
+                    }
+                    catch (e) {
+                        await ctx.answerCbQuery(`Error: ${e.message}`, { show_alert: true }).catch(() => { });
+                    }
                 }
+                catch (error) {
+                    console.error('[Telegram] confirm_trinity_db_delete error:', error.message);
+                    ctx.answerCbQuery(`Error: ${error.message}`).catch(() => { });
+                }
+            });
+            this.bot.action('cancel_trinity_db_delete', async (ctx) => {
                 try {
-                    const { DatabaseRegistry } = await import('../runtime/memory/trinity-db.js');
-                    const registry = DatabaseRegistry.getInstance();
-                    const db = registry.getDatabase(id);
-                    const name = db?.name ?? `#${id}`;
-                    const deleted = registry.deleteDatabase(id);
-                    await ctx.answerCbQuery(deleted ? '🗑️ Deleted' : 'Not found');
+                    await ctx.answerCbQuery('Cancelled').catch(() => { });
                     if (ctx.updateType === 'callback_query')
                         ctx.deleteMessage().catch(() => { });
-                    const user = ctx.from?.username || ctx.from?.first_name || 'unknown';
-                    this.display.log(`Trinity DB '${name}' deleted by @${user}`, { source: 'Telegram', level: 'info' });
-                    await ctx.reply(deleted ? `🗑️ <b>${escapeHtml(name)}</b> removed from Trinity.` : `❌ Database #${id} not found.`, { parse_mode: 'HTML' });
                 }
-                catch (e) {
-                    await ctx.answerCbQuery(`Error: ${e.message}`, { show_alert: true });
+                catch (error) {
+                    console.error('[Telegram] cancel_trinity_db_delete error:', error.message);
+                    ctx.answerCbQuery(`Error: ${error.message}`).catch(() => { });
                 }
             });
-            this.bot.action('cancel_trinity_db_delete', async (ctx) => {
-                await ctx.answerCbQuery('Cancelled');
-                if (ctx.updateType === 'callback_query')
-                    ctx.deleteMessage().catch(() => { });
-            });
             this.bot.launch().catch((err) => {
                 if (this.isConnected) {
                     this.display.log(`Telegram bot error: ${err}`, { source: 'Telegram', level: 'error' });
@@ -1244,16 +1334,16 @@ export class TelegramAdapter {
                 if (!isCurrent) {
                     sessionButtons.push({
                         text: `➡️ Switch`,
-                        callback_data: `switch_session_${session.id}`
+                        callback_data: safeCallbackData(session.id, 'switch_session_')
                     });
                 }
                 sessionButtons.push({
                     text: `📂 Archive`,
-                    callback_data: `ask_archive_session_${session.id}`
+                    callback_data: safeCallbackData(session.id, 'ask_archive_session_')
                 });
                 sessionButtons.push({
                     text: `🗑️ Delete`,
-                    callback_data: `ask_delete_session_${session.id}`
+                    callback_data: safeCallbackData(session.id, 'ask_delete_session_')
                 });
                 keyboard.push(sessionButtons);
             }

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