morpheus-cli 0.5.0 → 0.5.1

package/dist/http/api.js

@@ -12,6 +12,9 @@ import { MCPManager } from '../config/mcp-manager.js';
 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';
 async function readLastLines(filePath, n) {
     try {
         const content = await fs.readFile(filePath, 'utf8');
@@ -745,6 +748,225 @@ export function createApiRouter(oracle) {
         // Redirect to POST logic or just reuse
         res.status(307).redirect(307, '/api/config');
     });
+    // ─── Trinity Config ────────────────────────────────────────────────────────
+    router.get('/config/trinity', (req, res) => {
+        try {
+            const trinityConfig = configManager.getTrinityConfig();
+            res.json(trinityConfig);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/config/trinity', async (req, res) => {
+        try {
+            const config = configManager.get();
+            await configManager.save({ ...config, trinity: req.body });
+            const display = DisplayManager.getInstance();
+            display.log('Trinity configuration updated via UI', { source: 'Zaion', level: 'info' });
+            res.json({ success: true });
+        }
+        catch (error) {
+            if (error.name === 'ZodError') {
+                res.status(400).json({ error: 'Validation failed', details: error.errors });
+            }
+            else {
+                res.status(500).json({ error: error.message });
+            }
+        }
+    });
+    router.delete('/config/trinity', async (req, res) => {
+        try {
+            const config = configManager.get();
+            const { trinity: _trinity, ...restConfig } = config;
+            await configManager.save(restConfig);
+            const display = DisplayManager.getInstance();
+            display.log('Trinity configuration removed via UI (falling back to Oracle config)', {
+                source: 'Zaion',
+                level: 'info',
+            });
+            res.json({ success: true });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    // ─── Trinity Databases CRUD ─────────────────────────────────────────────────
+    const DatabaseCreateSchema = z.object({
+        name: z.string().min(1).max(100),
+        type: z.enum(['postgresql', 'mysql', 'sqlite', 'mongodb']),
+        host: z.string().optional().nullable(),
+        port: z.number().int().positive().optional().nullable(),
+        database_name: z.string().optional().nullable(),
+        username: z.string().optional().nullable(),
+        password: z.string().optional().nullable(),
+        connection_string: z.string().optional().nullable(),
+        allow_read: z.boolean().optional(),
+        allow_insert: z.boolean().optional(),
+        allow_update: z.boolean().optional(),
+        allow_delete: z.boolean().optional(),
+        allow_ddl: z.boolean().optional(),
+    });
+    router.get('/trinity/databases', (req, res) => {
+        try {
+            const registry = DatabaseRegistry.getInstance();
+            const databases = registry.listDatabases().map((db) => ({
+                ...db,
+                password: db.password ? '***' : null,
+                connection_string: db.connection_string ? '***' : null,
+            }));
+            res.json(databases);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.get('/trinity/databases/:id', (req, res) => {
+        try {
+            const id = parseInt(req.params.id);
+            if (isNaN(id))
+                return res.status(400).json({ error: 'Invalid id' });
+            const registry = DatabaseRegistry.getInstance();
+            const db = registry.getDatabase(id);
+            if (!db)
+                return res.status(404).json({ error: 'Database not found' });
+            res.json({
+                ...db,
+                password: db.password ? '***' : null,
+                connection_string: db.connection_string ? '***' : null,
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/trinity/databases', async (req, res) => {
+        const parsed = DatabaseCreateSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
+        }
+        try {
+            const registry = DatabaseRegistry.getInstance();
+            const db = registry.createDatabase(parsed.data);
+            // Test connection
+            let connectionOk = false;
+            try {
+                connectionOk = await testConnection(db);
+            }
+            catch { /* ignore */ }
+            // Introspect schema if connection successful
+            if (connectionOk) {
+                try {
+                    const schema = await introspectSchema(db);
+                    registry.updateSchema(db.id, JSON.stringify(schema, null, 2));
+                    await Trinity.refreshDelegateCatalog().catch(() => { });
+                }
+                catch { /* ignore schema errors */ }
+            }
+            const refreshed = registry.getDatabase(db.id);
+            res.status(201).json({
+                ...refreshed,
+                password: refreshed.password ? '***' : null,
+                connection_string: refreshed.connection_string ? '***' : null,
+                connection_ok: connectionOk,
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.put('/trinity/databases/:id', async (req, res) => {
+        const id = parseInt(req.params.id);
+        if (isNaN(id))
+            return res.status(400).json({ error: 'Invalid id' });
+        const parsed = DatabaseCreateSchema.partial().safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
+        }
+        try {
+            const registry = DatabaseRegistry.getInstance();
+            const updated = registry.updateDatabase(id, parsed.data);
+            if (!updated)
+                return res.status(404).json({ error: 'Database not found' });
+            // Re-test and re-introspect
+            let connectionOk = false;
+            try {
+                connectionOk = await testConnection(updated);
+            }
+            catch { /* ignore */ }
+            if (connectionOk) {
+                try {
+                    const schema = await introspectSchema(updated);
+                    registry.updateSchema(id, JSON.stringify(schema, null, 2));
+                    await Trinity.refreshDelegateCatalog().catch(() => { });
+                }
+                catch { /* ignore */ }
+            }
+            const refreshed = registry.getDatabase(id);
+            res.json({
+                ...refreshed,
+                password: refreshed.password ? '***' : null,
+                connection_string: refreshed.connection_string ? '***' : null,
+                connection_ok: connectionOk,
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.delete('/trinity/databases/:id', (req, res) => {
+        const id = parseInt(req.params.id);
+        if (isNaN(id))
+            return res.status(400).json({ error: 'Invalid id' });
+        try {
+            const registry = DatabaseRegistry.getInstance();
+            const deleted = registry.deleteDatabase(id);
+            if (!deleted)
+                return res.status(404).json({ error: 'Database not found' });
+            Trinity.refreshDelegateCatalog().catch(() => { });
+            res.json({ success: true });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/trinity/databases/:id/refresh-schema', async (req, res) => {
+        const id = parseInt(req.params.id);
+        if (isNaN(id))
+            return res.status(400).json({ error: 'Invalid id' });
+        try {
+            const registry = DatabaseRegistry.getInstance();
+            const db = registry.getDatabase(id);
+            if (!db)
+                return res.status(404).json({ error: 'Database not found' });
+            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);
+            res.json({ success: true, tables: tableNames, databases: schema.databases?.length });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/trinity/databases/:id/test', async (req, res) => {
+        const id = parseInt(req.params.id);
+        if (isNaN(id))
+            return res.status(400).json({ error: 'Invalid id' });
+        try {
+            const registry = DatabaseRegistry.getInstance();
+            const db = registry.getDatabase(id);
+            if (!db)
+                return res.status(404).json({ error: 'Database not found' });
+            const ok = await testConnection(db);
+            res.json({ success: ok, status: ok ? 'connected' : 'failed' });
+        }
+        catch (error) {
+            res.json({ success: false, status: 'error', error: error.message });
+        }
+    });
     router.get('/logs', async (req, res) => {
         try {
             await fs.ensureDir(PATHS.logs);

package/dist/runtime/memory/session-embedding-worker.js

@@ -10,7 +10,7 @@ const EMBEDDING_DIM = 384;
 const BATCH_LIMIT = 5;
 export async function runSessionEmbeddingWorker() {
     const display = DisplayManager.getInstance();
-    display.log('🚀 Iniciando worker de embeddings de sessões...', { source: 'SessionEmbeddingWorker' });
+    // display.log('🚀 Iniciando worker de embeddings de sessões...', { source: 'SessionEmbeddingWorker' });
     const shortDb = new Database(SHORT_DB_PATH);
     const satiDb = new Database(SATI_DB_PATH);
     shortDb.pragma('journal_mode = WAL');
@@ -27,7 +27,7 @@ export async function runSessionEmbeddingWorker() {
       LIMIT ?
     `).all(BATCH_LIMIT);
         if (sessions.length === 0) {
-            display.log('✅ Nenhuma sessão pendente.', { level: 'debug', source: 'SessionEmbeddingWorker' });
+            // display.log('✅ Nenhuma sessão pendente.', { level: 'debug', source: 'SessionEmbeddingWorker' });
             break;
         }
         for (const session of sessions) {
@@ -90,5 +90,5 @@ export async function runSessionEmbeddingWorker() {
             }
         }
     }
-    display.log('🏁 Worker finalizado.', { source: 'SessionEmbeddingWorker' });
+    // display.log('🏁 Worker finalizado.', { source: 'SessionEmbeddingWorker' });
 }

package/dist/runtime/memory/trinity-db.js

@@ -0,0 +1,203 @@
+import Database from 'better-sqlite3';
+import fs from 'fs-extra';
+import path from 'path';
+import { homedir } from 'os';
+import { encrypt, decrypt, canEncrypt } from '../trinity-crypto.js';
+function safeDecrypt(value) {
+    if (!value)
+        return null;
+    try {
+        return decrypt(value);
+    }
+    catch {
+        return null;
+    }
+}
+function rowToRecord(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        type: row.type,
+        host: row.host,
+        port: row.port,
+        database_name: row.database_name,
+        username: row.username,
+        password: safeDecrypt(row.password_encrypted),
+        connection_string: safeDecrypt(row.connection_string_encrypted),
+        schema_json: row.schema_json,
+        schema_updated_at: row.schema_updated_at,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        allow_read: row.allow_read === 1,
+        allow_insert: row.allow_insert === 1,
+        allow_update: row.allow_update === 1,
+        allow_delete: row.allow_delete === 1,
+        allow_ddl: row.allow_ddl === 1,
+    };
+}
+export class DatabaseRegistry {
+    static instance = null;
+    db;
+    constructor() {
+        const dbPath = path.join(homedir(), '.morpheus', 'memory', 'trinity.db');
+        fs.ensureDirSync(path.dirname(dbPath));
+        this.db = new Database(dbPath, { timeout: 5000 });
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.ensureTable();
+        this.ensureMigrations();
+    }
+    static getInstance() {
+        if (!DatabaseRegistry.instance) {
+            DatabaseRegistry.instance = new DatabaseRegistry();
+        }
+        return DatabaseRegistry.instance;
+    }
+    ensureTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS databases (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        type TEXT NOT NULL,
+        host TEXT,
+        port INTEGER,
+        database_name TEXT,
+        username TEXT,
+        password_encrypted TEXT,
+        connection_string_encrypted TEXT,
+        schema_json TEXT,
+        schema_updated_at INTEGER,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        allow_read INTEGER NOT NULL DEFAULT 1,
+        allow_insert INTEGER NOT NULL DEFAULT 0,
+        allow_update INTEGER NOT NULL DEFAULT 0,
+        allow_delete INTEGER NOT NULL DEFAULT 0,
+        allow_ddl INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+    }
+    /** Add new columns to existing databases table (migration) */
+    ensureMigrations() {
+        const existingCols = this.db.pragma('table_info(databases)').map((c) => c.name);
+        const addIfMissing = (col, def) => {
+            if (!existingCols.includes(col)) {
+                this.db.exec(`ALTER TABLE databases ADD COLUMN ${col} ${def}`);
+            }
+        };
+        addIfMissing('allow_read', 'INTEGER NOT NULL DEFAULT 1');
+        addIfMissing('allow_insert', 'INTEGER NOT NULL DEFAULT 0');
+        addIfMissing('allow_update', 'INTEGER NOT NULL DEFAULT 0');
+        addIfMissing('allow_delete', 'INTEGER NOT NULL DEFAULT 0');
+        addIfMissing('allow_ddl', 'INTEGER NOT NULL DEFAULT 0');
+    }
+    listDatabases() {
+        const rows = this.db.prepare('SELECT * FROM databases ORDER BY name ASC').all();
+        return rows.map(rowToRecord);
+    }
+    getDatabase(id) {
+        const row = this.db.prepare('SELECT * FROM databases WHERE id = ?').get(id);
+        return row ? rowToRecord(row) : null;
+    }
+    getDatabaseByName(name) {
+        const row = this.db.prepare('SELECT * FROM databases WHERE name = ?').get(name);
+        return row ? rowToRecord(row) : null;
+    }
+    createDatabase(data) {
+        if ((data.password || data.connection_string) && !canEncrypt()) {
+            throw new Error('MORPHEUS_SECRET must be set to store database credentials. ' +
+                'Add MORPHEUS_SECRET to your environment before saving credentials.');
+        }
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      INSERT INTO databases (
+        name, type, host, port, database_name, username,
+        password_encrypted, connection_string_encrypted,
+        schema_json, schema_updated_at,
+        allow_read, allow_insert, allow_update, allow_delete, allow_ddl,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const result = stmt.run(data.name, data.type, data.host ?? null, data.port ?? null, data.database_name ?? null, data.username ?? null, data.password ? encrypt(data.password) : null, data.connection_string ? encrypt(data.connection_string) : null, data.allow_read !== false ? 1 : 0, data.allow_insert ? 1 : 0, data.allow_update ? 1 : 0, data.allow_delete ? 1 : 0, data.allow_ddl ? 1 : 0, now, now);
+        return this.getDatabase(result.lastInsertRowid);
+    }
+    updateDatabase(id, data) {
+        const existing = this.getDatabase(id);
+        if (!existing)
+            return null;
+        if ((data.password || data.connection_string) && !canEncrypt()) {
+            throw new Error('MORPHEUS_SECRET must be set to update database credentials.');
+        }
+        const now = Date.now();
+        // Build dynamic update
+        const fields = [];
+        const values = [];
+        if (data.name !== undefined) {
+            fields.push('name = ?');
+            values.push(data.name);
+        }
+        if (data.type !== undefined) {
+            fields.push('type = ?');
+            values.push(data.type);
+        }
+        if (data.host !== undefined) {
+            fields.push('host = ?');
+            values.push(data.host);
+        }
+        if (data.port !== undefined) {
+            fields.push('port = ?');
+            values.push(data.port);
+        }
+        if (data.database_name !== undefined) {
+            fields.push('database_name = ?');
+            values.push(data.database_name);
+        }
+        if (data.username !== undefined) {
+            fields.push('username = ?');
+            values.push(data.username);
+        }
+        if (data.password !== undefined) {
+            fields.push('password_encrypted = ?');
+            values.push(data.password ? encrypt(data.password) : null);
+        }
+        if (data.connection_string !== undefined) {
+            fields.push('connection_string_encrypted = ?');
+            values.push(data.connection_string ? encrypt(data.connection_string) : null);
+        }
+        if (data.allow_read !== undefined) {
+            fields.push('allow_read = ?');
+            values.push(data.allow_read ? 1 : 0);
+        }
+        if (data.allow_insert !== undefined) {
+            fields.push('allow_insert = ?');
+            values.push(data.allow_insert ? 1 : 0);
+        }
+        if (data.allow_update !== undefined) {
+            fields.push('allow_update = ?');
+            values.push(data.allow_update ? 1 : 0);
+        }
+        if (data.allow_delete !== undefined) {
+            fields.push('allow_delete = ?');
+            values.push(data.allow_delete ? 1 : 0);
+        }
+        if (data.allow_ddl !== undefined) {
+            fields.push('allow_ddl = ?');
+            values.push(data.allow_ddl ? 1 : 0);
+        }
+        if (fields.length === 0)
+            return existing;
+        fields.push('updated_at = ?');
+        values.push(now);
+        values.push(id);
+        this.db.prepare(`UPDATE databases SET ${fields.join(', ')} WHERE id = ?`).run(...values);
+        return this.getDatabase(id);
+    }
+    deleteDatabase(id) {
+        const result = this.db.prepare('DELETE FROM databases WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    updateSchema(id, schemaJson) {
+        const now = Date.now();
+        this.db.prepare('UPDATE databases SET schema_json = ?, schema_updated_at = ?, updated_at = ? WHERE id = ?').run(schemaJson, now, now, id);
+    }
+}

package/dist/runtime/neo.js

@@ -4,7 +4,7 @@ import { ProviderFactory } from "./providers/factory.js";
 import { ProviderError } from "./errors.js";
 import { DisplayManager } from "./display.js";
 import { Construtor } from "./tools/factory.js";
-import { ConfigQueryTool, ConfigUpdateTool, DiagnosticTool, MessageCountTool, TokenUsageTool, ProviderModelUsageTool, } from "./tools/index.js";
+import { morpheusTools } from "./tools/index.js";
 import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
 import { TaskRequestContext } from "./tasks/context.js";
 import { updateNeoDelegateToolDescription } from "./tools/neo-tool.js";
@@ -31,30 +31,13 @@ export class Neo {
     }
     static async refreshDelegateCatalog() {
         const mcpTools = await Construtor.create();
-        const catalogTools = [
-            ...mcpTools,
-            ConfigQueryTool,
-            ConfigUpdateTool,
-            DiagnosticTool,
-            MessageCountTool,
-            TokenUsageTool,
-            ProviderModelUsageTool
-        ];
-        updateNeoDelegateToolDescription(catalogTools);
+        updateNeoDelegateToolDescription(mcpTools);
     }
     async initialize() {
         const neoConfig = this.config.neo || this.config.llm;
         const mcpTools = await Construtor.create();
-        const tools = [
-            ...mcpTools,
-            ConfigQueryTool,
-            ConfigUpdateTool,
-            DiagnosticTool,
-            MessageCountTool,
-            TokenUsageTool,
-            ProviderModelUsageTool
-        ];
-        updateNeoDelegateToolDescription(tools);
+        const tools = [...mcpTools, ...morpheusTools];
+        updateNeoDelegateToolDescription(mcpTools);
         this.display.log(`Neo initialized with ${tools.length} tools.`, { source: "Neo" });
         try {
             this.agent = await ProviderFactory.create(neoConfig, tools);
@@ -78,13 +61,20 @@ You execute tasks using MCP and internal tools.
 Focus on verifiable execution and return objective results.
 
 Rules:
-1. Use tools whenever task depends on external/system state.
-2. Validate outputs before final answer.
-3. If blocked, explain what is missing.
+1. Use tools whenever the task depends on external/system state.
+2. Validate outputs before giving a final answer.
+3. If blocked, explain exactly what is missing — tool name, permission, or missing input.
 4. Keep output concise and actionable.
 5. Respond in the language requested by the user. If not explicit, use the dominant language of the task/context.
-6. For connectivity checks, prefer the dedicated network "ping" tool semantics (reachability) and avoid forcing shell flags.
-7. If delegating shell ping to Apoc is explicitly required, include OS-aware guidance: Windows uses "-n", Linux/macOS uses "-c".
+6. For connectivity checks, prefer dedicated network "ping" tool semantics and avoid forcing shell flags.
+7. If shell ping is required, include OS-aware guidance: Windows uses "-n", Linux/macOS uses "-c".
+
+CRITICAL — NEVER FABRICATE DATA:
+- If none of your available tools can retrieve the requested information, respond EXACTLY with:
+  "I do not have the required tool to fetch this data. Cannot retrieve: [describe what was requested]. Available tools: [list your actual tool names]."
+- NEVER generate fake records, fake IDs, fake names, fake statuses, or fake values of any kind.
+- If a tool call fails or returns empty results, report the actual result — do not substitute invented data.
+- An honest "I cannot retrieve this" is always correct. A fabricated answer is never acceptable.
 
 ${context ? `Context:\n${context}` : ""}
     `);

package/dist/runtime/oracle.js

@@ -9,9 +9,12 @@ import { Apoc } from "./apoc.js";
 import { TaskRequestContext } from "./tasks/context.js";
 import { TaskRepository } from "./tasks/repository.js";
 import { Neo } from "./neo.js";
+import { Trinity } from "./trinity.js";
 import { NeoDelegateTool } from "./tools/neo-tool.js";
 import { ApocDelegateTool } from "./tools/apoc-tool.js";
-import { TaskQueryTool } from "./tools/task-query-tool.js";
+import { TrinityDelegateTool } from "./tools/trinity-tool.js";
+import { TaskQueryTool } from "./tools/index.js";
+import { MCPManager } from "../config/mcp-manager.js";
 export class Oracle {
     provider;
     config;
@@ -41,9 +44,9 @@ export class Oracle {
         const hasCreationClaim = /(as\s+tarefas?\s+foram\s+criadas|tarefa\s+criada|nova\s+tarefa\s+criada|deleguei|delegado|delegada|tasks?\s+created|task\s+created|queued\s+for|agendei|agendado|agendada|foi\s+agendad)/i.test(raw);
         if (!hasCreationClaim)
             return false;
-        const hasAgentMention = /\b(apoc|neo|trinit)\b/i.test(raw);
+        const hasAgentMention = /\b(apoc|neo|trinit|trinity)\b/i.test(raw);
         const hasUuid = /\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}\b/.test(raw);
-        const hasAgentListLine = /(?:\*|-)?.{0,8}(apoc|neo|trinit)\s*[:：]/i.test(raw);
+        const hasAgentListLine = /(?:\*|-)?.{0,8}(apoc|neo|trinit|trinity)\s*[:：]/i.test(raw);
         return hasCreationClaim && (hasAgentMention || hasUuid || hasAgentListLine);
     }
     buildDelegationAck(acks) {
@@ -66,7 +69,7 @@ export class Oracle {
     }
     extractDelegationAcksFromMessages(messages) {
         const acks = [];
-        const regex = /Task\s+([0-9a-fA-F-]{36})\s+(?:queued|already queued)\s+for\s+(Apoc|Neo|apoc|neo)\s+execution/i;
+        const regex = /Task\s+([0-9a-fA-F-]{36})\s+(?:queued|already queued)\s+for\s+(Apoc|Neo|Trinity|apoc|neo|trinity)\s+execution/i;
         for (const msg of messages) {
             if (!(msg instanceof ToolMessage))
                 continue;
@@ -105,7 +108,7 @@ export class Oracle {
             const toolCalls = msg.tool_calls ?? [];
             if (!Array.isArray(toolCalls))
                 continue;
-            if (toolCalls.some((tc) => tc?.name === "apoc_delegate" || tc?.name === "neo_delegate")) {
+            if (toolCalls.some((tc) => tc?.name === "apoc_delegate" || tc?.name === "neo_delegate" || tc?.name === "trinity_delegate")) {
                 return true;
             }
         }
@@ -122,10 +125,11 @@ 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 tool catalog so neo_delegate description contains runtime tools list.
+            // 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(() => { });
-            this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool]);
+            await Trinity.refreshDelegateCatalog().catch(() => { });
+            this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool]);
             if (!this.provider) {
                 throw new Error("Provider factory returned undefined");
             }
@@ -137,6 +141,8 @@ export class Oracle {
                 databasePath: this.databasePath,
                 limit: contextWindow,
             });
+            // Register reload callback so MCPManager.reloadAgents() can trigger a full tool reload.
+            MCPManager.registerReloadCallback(() => this.reloadTools());
         }
         catch (err) {
             if (err instanceof ProviderError)
@@ -250,6 +256,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
                 : undefined;
             Apoc.setSessionId(currentSessionId);
             Neo.setSessionId(currentSessionId);
+            Trinity.setSessionId(currentSessionId);
             const invokeContext = {
                 origin_channel: taskContext?.origin_channel ?? "api",
                 session_id: taskContext?.session_id ?? currentSessionId ?? "default",
@@ -440,7 +447,8 @@ Use it to inform your response and tool selection (if needed), but do not assume
             throw new Error("Oracle not initialized. Call initialize() first.");
         }
         await Neo.refreshDelegateCatalog().catch(() => { });
-        this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool]);
+        await Trinity.refreshDelegateCatalog().catch(() => { });
+        this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool]);
         await Neo.getInstance().reload();
         this.display.log(`Oracle and Neo tools reloaded`, { source: 'Oracle' });
     }

package/dist/runtime/session-embedding-scheduler.js

@@ -3,7 +3,7 @@ import { DisplayManager } from './display.js';
 const INTERVAL_MS = 60_000 * 5; // 5 minutos
 export function startSessionEmbeddingScheduler() {
     const display = DisplayManager.getInstance();
-    display.log('🕒 Scheduler de embeddings iniciado', { source: 'SessionEmbeddingScheduler' });
+    display.log('Scheduler embeddings started.', { source: 'SessionEmbeddingScheduler' });
     // roda imediatamente na inicialização
     runSessionEmbeddingWorker().catch(console.error);
     let isRunning = false;

package/dist/runtime/tasks/dispatcher.js

@@ -19,6 +19,27 @@ 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
+            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}`);
+                        }
+                        catch (err) {
+                            TaskDispatcher.display.log(`Failed to send Telegram notification for webhook "${webhook.name}": ${err.message}`, { source: 'TaskDispatcher', level: 'error' });
+                        }
+                    }
+                    else {
+                        TaskDispatcher.display.log(`Telegram notification skipped for webhook "${webhook.name}" — adapter not connected.`, { source: 'TaskDispatcher', level: 'warning' });
+                    }
+                }
+            }
             return;
         }
         if (task.origin_channel === 'ui') {

package/dist/runtime/tasks/worker.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'crypto';
 import { DisplayManager } from '../display.js';
 import { Apoc } from '../apoc.js';
 import { Neo } from '../neo.js';
+import { Trinity } from '../trinity.js';
 import { TaskRepository } from './repository.js';
 export class TaskWorker {
     workerId;
@@ -69,7 +70,9 @@ export class TaskWorker {
                     break;
                 }
                 case 'trinit': {
-                    throw new Error('Trinit executor is not implemented yet.');
+                    const trinity = Trinity.getInstance();
+                    output = await trinity.execute(task.input, task.context ?? undefined, task.session_id);
+                    break;
                 }
                 default: {
                     throw new Error(`Unknown task agent: ${task.agent}`);