morpheus-cli 0.9.5 → 0.9.7

package/dist/runtime/link.js

@@ -0,0 +1,295 @@
+import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
+import { z } from "zod";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { ConfigManager } from '../config/manager.js';
+import { LinkRepository } from './link-repository.js';
+import { LinkSearch } from './link-search.js';
+import { ProviderFactory } from './providers/factory.js';
+import { ProviderError } from './errors.js';
+import { DisplayManager } from './display.js';
+import { TaskRequestContext } from './tasks/context.js';
+import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from './subagent-utils.js';
+import { buildDelegationTool } from './tools/delegation-utils.js';
+const LINK_BASE_DESCRIPTION = `Delegate to Link, the documentation specialist subagent.
+
+Link has access to indexed user documents (PDFs, Markdown, TXT, DOCX) stored in ~/.morpheus/docs.
+It uses an LLM to search, reason over, and synthesize answers from document content.
+
+Use this tool when the user asks about information that might be in their uploaded documents.
+Input should be a natural language query or question about the user's documentation.`;
+function buildDocumentCatalogSection(repository) {
+    try {
+        const docs = repository.listDocuments('indexed');
+        if (docs.length === 0) {
+            return '\n\nIndexed documents: none currently indexed.';
+        }
+        const lines = docs.map((d) => `- ${d.filename} (${d.chunk_count} chunks)`);
+        return `\n\nIndexed documents:\n${lines.join('\n')}`;
+    }
+    catch {
+        return '\n\nIndexed documents: unable to retrieve list.';
+    }
+}
+/**
+ * Link - Documentation Specialist Subagent
+ *
+ * Provides RAG (Retrieval-Augmented Generation) capabilities over user documents.
+ * Uses a ReactAgent with an LLM to reason over search results and synthesize answers.
+ */
+export class Link {
+    static instance = null;
+    static currentSessionId = undefined;
+    static _delegateTool = null;
+    config;
+    agentConfig;
+    repository;
+    search;
+    agent;
+    display = DisplayManager.getInstance();
+    constructor(config) {
+        this.config = config;
+        this.agentConfig = ConfigManager.getInstance().getLinkConfig();
+        this.repository = LinkRepository.getInstance();
+        this.search = LinkSearch.getInstance();
+    }
+    static getInstance(config) {
+        if (!Link.instance) {
+            if (!config) {
+                config = ConfigManager.getInstance().get();
+            }
+            Link.instance = new Link(config);
+        }
+        return Link.instance;
+    }
+    static resetInstance() {
+        Link.instance = null;
+        Link._delegateTool = null;
+    }
+    static setSessionId(id) {
+        Link.currentSessionId = id;
+    }
+    /**
+     * Build the internal search tool that the ReactAgent will use.
+     */
+    buildTools() {
+        const search = this.search;
+        const repository = this.repository;
+        const agentConfig = this.agentConfig;
+        const searchTool = new DynamicStructuredTool({
+            name: 'link_search_documents',
+            description: 'Search ALL indexed user documents using hybrid vector + keyword search. Returns the most relevant document chunks for a given query. Use this for broad searches when you don\'t know which document contains the answer.',
+            schema: z.object({
+                query: z.string().describe('The search query to find relevant document passages'),
+                limit: z.number().optional().describe('Maximum number of results to return (default: max_results from config)'),
+            }),
+            func: async ({ query, limit }) => {
+                const maxResults = limit ?? agentConfig.max_results;
+                const threshold = agentConfig.score_threshold;
+                const results = await search.search(query, maxResults, threshold);
+                if (results.length === 0) {
+                    return `No relevant documents found for query: "${query}"`;
+                }
+                const formatted = results
+                    .map((r, i) => `[${i + 1}] Source: ${r.filename} (chunk ${r.position}, score: ${r.score.toFixed(3)})\n${r.content}`)
+                    .join('\n\n---\n\n');
+                return `Found ${results.length} relevant passages:\n\n${formatted}`;
+            },
+        });
+        const listDocumentsTool = new DynamicStructuredTool({
+            name: 'link_list_documents',
+            description: 'List indexed documents. Use this to find documents by filename before searching within a specific one. Supports optional name filter (case-insensitive partial match).',
+            schema: z.object({
+                name_filter: z.string().optional().describe('Optional partial filename to filter by (case-insensitive). E.g. "CV", "contrato", "readme"'),
+            }),
+            func: async ({ name_filter }) => {
+                const docs = repository.listDocuments('indexed');
+                if (docs.length === 0) {
+                    return 'No indexed documents found.';
+                }
+                let filtered = docs;
+                if (name_filter) {
+                    const lower = name_filter.toLowerCase();
+                    filtered = docs.filter(d => d.filename.toLowerCase().includes(lower));
+                }
+                if (filtered.length === 0) {
+                    const allNames = docs.map(d => `- ${d.filename}`).join('\n');
+                    return `No documents matching "${name_filter}". Available documents:\n${allNames}`;
+                }
+                const lines = filtered.map(d => `- [${d.id}] ${d.filename} (${d.chunk_count} chunks)`);
+                return `Found ${filtered.length} document(s):\n${lines.join('\n')}`;
+            },
+        });
+        const searchInDocumentTool = new DynamicStructuredTool({
+            name: 'link_search_in_document',
+            description: 'Search within a SPECIFIC document by its ID. Use this when you know which document to search (e.g. after using link_list_documents to find it). More precise than link_search_documents for targeted queries.',
+            schema: z.object({
+                document_id: z.string().describe('The document ID to search within (get this from link_list_documents)'),
+                query: z.string().describe('The search query to find relevant passages within this document'),
+                limit: z.number().optional().describe('Maximum number of results (default: max_results from config)'),
+            }),
+            func: async ({ document_id, query, limit }) => {
+                const doc = repository.getDocument(document_id);
+                if (!doc) {
+                    return `Document not found: ${document_id}`;
+                }
+                const maxResults = limit ?? agentConfig.max_results;
+                const threshold = agentConfig.score_threshold;
+                const results = await search.searchInDocument(query, document_id, maxResults, threshold);
+                if (results.length === 0) {
+                    return `No relevant passages found in "${doc.filename}" for query: "${query}"`;
+                }
+                const formatted = results
+                    .map((r, i) => `[${i + 1}] (chunk ${r.position}, score: ${r.score.toFixed(3)})\n${r.content}`)
+                    .join('\n\n---\n\n');
+                return `Found ${results.length} passages in "${doc.filename}":\n\n${formatted}`;
+            },
+        });
+        return [listDocumentsTool, searchTool, searchInDocumentTool];
+    }
+    async initialize() {
+        this.repository.initialize();
+        await this.search.initialize();
+        const linkConfig = this.agentConfig;
+        const personality = linkConfig.personality || 'documentation_specialist';
+        const tools = this.buildTools();
+        // Update delegate tool description with current document catalog
+        if (Link._delegateTool) {
+            const full = `${LINK_BASE_DESCRIPTION}${buildDocumentCatalogSection(this.repository)}`;
+            Link._delegateTool.description = full;
+        }
+        this.display.log(`Link initialized with personality: ${personality}.`, { source: 'Link' });
+        try {
+            this.agent = await ProviderFactory.create(linkConfig, tools);
+        }
+        catch (err) {
+            throw new ProviderError(linkConfig.provider, err, 'Link subagent initialization failed');
+        }
+    }
+    /**
+     * Search documents for relevant information (used internally by search tool and HTTP API).
+     */
+    async searchDocuments(query, limit) {
+        const maxResults = limit ?? this.agentConfig.max_results;
+        const threshold = this.agentConfig.score_threshold;
+        const results = await this.search.search(query, maxResults, threshold);
+        return {
+            results: results.map(r => ({
+                chunk_id: r.chunk_id,
+                content: r.content,
+                document_id: r.document_id,
+                filename: r.filename,
+                position: r.position,
+                score: r.score,
+            })),
+            total: results.length,
+        };
+    }
+    /**
+     * Execute a query using the LLM-powered ReactAgent.
+     */
+    async execute(task, context, sessionId, taskContext) {
+        const linkConfig = this.agentConfig;
+        if (!this.agent) {
+            await this.initialize();
+        }
+        this.display.log(`Executing delegated task in Link: ${task.slice(0, 80)}...`, {
+            source: 'Link',
+        });
+        const personality = linkConfig.personality || 'documentation_specialist';
+        const systemMessage = new SystemMessage(`
+You are Link, ${personality === 'documentation_specialist' ? 'a documentation specialist and knowledge synthesizer' : personality}, a subagent in Morpheus.
+
+You have access to the user's indexed documents via the link_search_documents tool.
+
+Rules:
+1. ALWAYS search the documents before answering. Never answer from general knowledge alone when documents may contain relevant information.
+2. Synthesize search results into a clear, natural response. Do not just dump raw chunks.
+3. Cite sources by filename when referencing specific information (e.g., "According to readme.md, ...").
+4. If no relevant documents are found, clearly state that no matching documentation was found.
+5. NEVER fabricate or invent document content. Only report what the search actually returns.
+6. If the query is ambiguous, search with multiple relevant terms to maximize coverage.
+7. Keep responses concise and focused on the user's question.
+8. Respond in the language requested by the user. If not explicit, use the dominant language of the task/context.
+
+## Tool Selection Strategy
+- When the user refers to a SPECIFIC document (by name or partial name like "meu currículo", "CV", "contrato"):
+  1. First call **link_list_documents** with a name filter to find the document ID.
+  2. Then call **link_search_in_document** with that document ID for a targeted search.
+- When the user asks a general question without referencing a specific document:
+  - Use **link_search_documents** for a broad search across all documents.
+- When unsure which document contains the answer, start with **link_search_documents**, then narrow down with **link_search_in_document** if results point to a specific file.
+
+${context ? `Context:\n${context}` : ''}
+    `);
+        const userMessage = new HumanMessage(task);
+        const messages = [systemMessage, userMessage];
+        try {
+            const invokeContext = {
+                origin_channel: taskContext?.origin_channel ?? 'api',
+                session_id: taskContext?.session_id ?? sessionId ?? 'default',
+                origin_message_id: taskContext?.origin_message_id,
+                origin_user_id: taskContext?.origin_user_id,
+            };
+            const inputCount = messages.length;
+            const startMs = Date.now();
+            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }, { recursionLimit: 25 }));
+            const durationMs = Date.now() - startMs;
+            const lastMessage = response.messages[response.messages.length - 1];
+            const content = typeof lastMessage.content === 'string'
+                ? lastMessage.content
+                : JSON.stringify(lastMessage.content);
+            const rawUsage = extractRawUsage(lastMessage);
+            const stepCount = response.messages.filter((m) => m instanceof AIMessage).length;
+            const targetSession = sessionId ?? Link.currentSessionId ?? 'link';
+            await persistAgentMessage('link', content, linkConfig, targetSession, rawUsage, durationMs);
+            emitToolAuditEvents(response.messages.slice(inputCount), targetSession, 'link');
+            this.display.log('Link task completed.', { source: 'Link' });
+            return buildAgentResult(content, linkConfig, rawUsage, durationMs, stepCount);
+        }
+        catch (err) {
+            throw new ProviderError(linkConfig.provider, err, 'Link task execution failed');
+        }
+    }
+    /**
+     * Create the delegation tool for Oracle.
+     */
+    createDelegateTool() {
+        if (!Link._delegateTool) {
+            Link._delegateTool = buildDelegationTool({
+                name: 'link_delegate',
+                description: LINK_BASE_DESCRIPTION,
+                agentKey: 'link',
+                agentLabel: 'Link',
+                auditAgent: 'link',
+                isSync: () => ConfigManager.getInstance().getLinkConfig().execution_mode === 'sync',
+                notifyText: '📚 Link is searching your documentation...',
+                executeSync: (task, context, sessionId, ctx) => Link.getInstance().execute(task, context, sessionId, {
+                    origin_channel: ctx?.origin_channel ?? 'api',
+                    session_id: sessionId,
+                    origin_message_id: ctx?.origin_message_id,
+                    origin_user_id: ctx?.origin_user_id,
+                }),
+            });
+        }
+        return Link._delegateTool;
+    }
+    /**
+     * Refresh the delegate tool description with current document catalog.
+     */
+    static async refreshDelegateCatalog() {
+        if (Link._delegateTool) {
+            try {
+                const repository = LinkRepository.getInstance();
+                const full = `${LINK_BASE_DESCRIPTION}${buildDocumentCatalogSection(repository)}`;
+                Link._delegateTool.description = full;
+            }
+            catch { /* non-critical */ }
+        }
+    }
+    async reload() {
+        this.config = ConfigManager.getInstance().get();
+        this.agentConfig = ConfigManager.getInstance().getLinkConfig();
+        this.agent = undefined;
+        await this.initialize();
+    }
+}

package/dist/runtime/memory/sati/service.js

@@ -97,7 +97,7 @@ export class SatiService {
                 console.warn('[SatiService] Failed to persist input log:', e);
             }
             const satiStartMs = Date.now();
-            const response = await agent.invoke({ messages }, { recursionLimit: 50 });
+            const response = await agent.invoke({ messages }, { recursionLimit: 10 });
             const satiDurationMs = Date.now() - satiStartMs;
             const lastMessage = response.messages[response.messages.length - 1];
             let content = lastMessage.content.toString();

package/dist/runtime/memory/sqlite.js

@@ -130,6 +130,14 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
           embedding_status TEXT CHECK (embedding_status IN ('none', 'pending', 'embedded', 'failed')) NOT NULL DEFAULT 'none'
         );
 
+        CREATE TABLE IF NOT EXISTS user_channel_sessions (
+          channel TEXT NOT NULL,
+          user_id TEXT NOT NULL,
+          session_id TEXT NOT NULL,
+          updated_at INTEGER NOT NULL,
+          PRIMARY KEY (channel, user_id)
+        );
+
         CREATE TABLE IF NOT EXISTS model_pricing (
           provider TEXT NOT NULL,
           model TEXT NOT NULL,
@@ -957,6 +965,50 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     `).all();
         return sessions;
     }
+    /**
+     * Gets the session ID for a specific channel+user combination.
+     * Returns null if not found.
+     */
+    async getUserChannelSession(channel, userId) {
+        const result = this.db.prepare(`
+      SELECT session_id FROM user_channel_sessions
+      WHERE channel = ? AND user_id = ?
+    `).get(channel, userId);
+        return result ? result.session_id : null;
+    }
+    /**
+     * Sets or updates the session ID for a specific channel+user.
+     * Uses INSERT ... ON CONFLICT for upsert behavior.
+     */
+    async setUserChannelSession(channel, userId, sessionId) {
+        this.db.prepare(`
+      INSERT INTO user_channel_sessions (channel, user_id, session_id, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(channel, user_id) DO UPDATE SET
+        session_id = excluded.session_id,
+        updated_at = excluded.updated_at
+    `).run(channel, userId, sessionId, Date.now());
+    }
+    /**
+     * Lists all user sessions for a channel.
+     * Returns an array of {userId, sessionId} objects.
+     */
+    async listUserChannelSessions(channel) {
+        const rows = this.db.prepare(`
+      SELECT user_id, session_id FROM user_channel_sessions
+      WHERE channel = ?
+    `).all(channel);
+        return rows.map(row => ({ userId: row.user_id, sessionId: row.session_id }));
+    }
+    /**
+     * Removes the session mapping for a channel+user.
+     */
+    async deleteUserChannelSession(channel, userId) {
+        this.db.prepare(`
+      DELETE FROM user_channel_sessions
+      WHERE channel = ? AND user_id = ?
+    `).run(channel, userId);
+    }
     /**
      * Closes the database connection.
      * Should be called when the history object is no longer needed.

package/dist/runtime/neo.js

@@ -137,7 +137,7 @@ ${context ? `Context:\n${context}` : ""}
             };
             const inputCount = messages.length;
             const startMs = Date.now();
-            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }, { recursionLimit: 50 }));
+            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }, { recursionLimit: 10 }));
             const durationMs = Date.now() - startMs;
             const lastMessage = response.messages[response.messages.length - 1];
             const content = typeof lastMessage.content === "string"

package/dist/runtime/oracle.js

@@ -10,19 +10,21 @@ 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";
 import { MCPManager } from "../config/mcp-manager.js";
-import { SkillRegistry, SkillExecuteTool, SkillDelegateTool, updateSkillToolDescriptions } from "./skills/index.js";
+import { SkillRegistry, createLoadSkillTool } from "./skills/index.js";
 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 { PATHS } from "../config/paths.js";
+import { writeFileSync } from "fs";
 const ORACLE_DELEGATION_TOOLS = new Set([
-    'apoc_delegate', 'neo_delegate', 'trinity_delegate', 'smith_delegate',
-    'skill_delegate', 'skill_execute',
+    'apoc_delegate', 'neo_delegate', 'trinity_delegate', 'smith_delegate', 'link_delegate',
 ]);
 export class Oracle {
     provider;
@@ -119,7 +121,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" || tc?.name === "trinity_delegate" || tc?.name === "smith_delegate")) {
+            if (toolCalls.some((tc) => tc?.name === "apoc_delegate" || tc?.name === "neo_delegate" || tc?.name === "trinity_delegate" || tc?.name === "smith_delegate" || tc?.name === "link_delegate")) {
                 return true;
             }
         }
@@ -154,7 +156,7 @@ export class Oracle {
             // Fail-open: Oracle can still initialize even if catalog refresh fails.
             await Neo.refreshDelegateCatalog().catch(() => { });
             await Trinity.refreshDelegateCatalog().catch(() => { });
-            updateSkillToolDescriptions();
+            await Link.refreshDelegateCatalog().catch(() => { });
             // Build tool list — conditionally include SmithDelegateTool based on config
             // Initialize setup repository (creates table if needed)
             SetupRepository.getInstance();
@@ -164,8 +166,8 @@ export class Oracle {
                 Neo.getInstance().createDelegateTool(),
                 Apoc.getInstance().createDelegateTool(),
                 Trinity.getInstance().createDelegateTool(),
-                SkillExecuteTool,
-                SkillDelegateTool,
+                Link.getInstance().createDelegateTool(),
+                createLoadSkillTool(),
                 timeVerifierTool,
                 ...chronosTools,
             ];
@@ -245,11 +247,14 @@ Do NOT proceed with other tasks until all required fields have been collected an
 `;
                 }
             }
-            const systemMessage = new SystemMessage(`${setupBlock}You are ${this.config.agent.name}, ${this.config.agent.personality}, the Oracle.
+            const systemMessage = new SystemMessage(`
+${setupBlock}
+
+You are ${this.config.agent.name}, ${this.config.agent.personality}, the Oracle.
 
 You are an orchestrator and task router.
 
-## Date & Time Resolution — MANDATORY
+## Date & Time Resolution — MANDATORY ##
 
 You **MUST** call "time_verifier" before answering or delegating ANY request that depends on the current date or time.
 This includes — but is not limited to — **two categories**:
@@ -269,7 +274,7 @@ This includes — but is not limited to — **two categories**:
 **NEVER assume or invent a date. NEVER guess "today is [date]".**
 Always call time_verifier first, then use the resolved date in your tool call or delegation prompt.
 
-Rules:
+## Rules: ##
 1. For conversation-only requests (greetings, conceptual explanation, memory follow-up, statements of fact, sharing personal information), answer directly. DO NOT create tasks or delegate for simple statements like "I have two cats" or "My name is John". Sati will automatically memorize facts in the background ( **ALWAYS** use SATI Memories to review or retrieve these facts if needed).
 **NEVER** Create data, use SATI memories to response on informal conversation or say that dont know abaout the awsor if the answer is in the memories. Always use the memories as source of truth for user facts, preferences, stable context and informal conversation. Use tools only for execution, verification or when external/system state is required.*
 2. For requests that require execution, verification, external/system state, or non-trivial operations, evaluate the available tools and choose the best one.
@@ -282,9 +287,42 @@ Rules:
 9. Avoid duplicate delegations to the same tool or agent.
 10. After enqueuing all required delegated tasks for the current message, stop calling tools and return a concise acknowledgement.
 11. If a delegation is rejected as "not atomic", immediately split into smaller delegations and retry.
-12. When the user message contains @neo, @apoc, or @trinity (case-insensitive), delegate to that specific agent. The mention is an explicit routing directive — respect it even if another agent might also handle the request.
+12. When the user message contains @link, @neo, @apoc, or @trinity (case-insensitive), delegate to that specific agent. The mention is an explicit routing directive — respect it even if another agent might also handle the request.
+13. Smiths also have names and could be called by @smithname — respect this as an explicit routing directive as well.
+
+## Delegation quality ##
+- Write delegation input in the same language requested by the user.
+- Include clear objective and constraints.
+- Include OS-aware guidance for network checks when relevant.
+- Use Sati memories only as context to complement the task, never as source of truth for dynamic data.
+- Use Sati memories to fill missing stable context fields (for example: city, timezone, language, currency, preferred units).
+- If Sati memory is conflicting or uncertain for a required field, ask one short clarification before delegating.
+- When completing missing fields from Sati, include explicit assumptions in delegation context using the format: "Assumption from Sati: key=value".
+- Never infer sensitive data from Sati memories (credentials, legal identifiers, health details, financial account data).
+- When assumptions were used, mention them briefly in the user-facing response and allow correction.
+- break the request into multiple delegations if it contains multiple independent actions.
+- Set a single task per delegation tool call. Do not combine multiple actions into one delegation, as it complicates execution and error handling.
+- If user requested N independent actions, produce N delegated tasks (or direct answers), each one singular and tool-scoped.
+- If use a delegation dont use the sati or messages history to answer directly in the same response. Just response with the delegations.
+Example 1:
+ask: "Tell me my account balance and do a ping on google.com"
+good:
+- delegate to "neo_delegate" with task "Check account balance using morpheus analytics MCP and return the result."
+- delegate to "apoc_delegate" with task "Ping google.com using the network diagnostics MCP and return reachability status. Use '-n' flag for Windows and '-c' for Linux/macOS."
+bad:
+- delegate to "neo_delegate" with task "Check account balance using morpheus analytics MCP and ping google.com using the network diagnostics MCP, then return both results." (combines two independent actions into one delegation, which is not atomic and complicates execution and error handling)
+
+Example 2:
+ask: "I have two cats" or "My name is John"
+good:
+- Answer directly acknowledging the fact. Do NOT delegate.
+bad:
+- delegate to "neo_delegate" or "apoc_delegate" to save the fact. (Sati handles this automatically in the background)
 
-## Chronos Channel Routing
+--------------------------------------------------
+          CHRONOS SCHEDULING RULES 
+--------------------------------------------------
+## Chronos Channel Routing ##
 When calling chronos_schedule, set notify_channels based on the user's message:
 - User mentions a specific channel (e.g., "no Discord", "no Telegram", "on Discord", "me avise pelo Discord"): set notify_channels to that channel — e.g. ["discord"] or ["telegram"].
 - User says "all channels", "todos os canais", "em todos os canais": set notify_channels to [] (empty = broadcast to all active channels).
@@ -339,38 +377,33 @@ Behavior rules for Chronos execution context:
 - **Action / task prompts** (e.g., "executar npm build", "verificar se o servidor está online", "enviar relatório"): execute normally using the appropriate tools.
 - NEVER re-schedule or create new Chronos jobs from within a Chronos execution.
 
-Delegation quality:
-- Write delegation input in the same language requested by the user.
-- Include clear objective and constraints.
-- Include OS-aware guidance for network checks when relevant.
-- Use Sati memories only as context to complement the task, never as source of truth for dynamic data.
-- Use Sati memories to fill missing stable context fields (for example: city, timezone, language, currency, preferred units).
-- If Sati memory is conflicting or uncertain for a required field, ask one short clarification before delegating.
-- When completing missing fields from Sati, include explicit assumptions in delegation context using the format: "Assumption from Sati: key=value".
-- Never infer sensitive data from Sati memories (credentials, legal identifiers, health details, financial account data).
-- When assumptions were used, mention them briefly in the user-facing response and allow correction.
-- break the request into multiple delegations if it contains multiple independent actions.
-- Set a single task per delegation tool call. Do not combine multiple actions into one delegation, as it complicates execution and error handling.
-- If user requested N independent actions, produce N delegated tasks (or direct answers), each one singular and tool-scoped.
-- If use a delegation dont use the sati or messages history to answer directly in the same response. Just response with the delegations.
-Example 1:
-ask: "Tell me my account balance and do a ping on google.com"
-good:
-- delegate to "neo_delegate" with task "Check account balance using morpheus analytics MCP and return the result."
-- delegate to "apoc_delegate" with task "Ping google.com using the network diagnostics MCP and return reachability status. Use '-n' flag for Windows and '-c' for Linux/macOS."
-bad:
-- delegate to "neo_delegate" with task "Check account balance using morpheus analytics MCP and ping google.com using the network diagnostics MCP, then return both results." (combines two independent actions into one delegation, which is not atomic and complicates execution and error handling)
+---------------------
+LINK DELEGATION RULES
+---------------------
+When delegating to Link:
+- Include the user's original request and intent.
+- Include a clear objective for what the Link agent should achieve.
+- **NEVER inject Sati memories, assumptions, or pre-existing knowledge into the search query.** Link searches documents — the query must reflect ONLY what the user asked, not what you already know or assume.
+- If the user asks "qual empresa trabalho atualmente?", delegate as-is: "Find the user's current company in their CV." Do NOT add specific names, values, or context from Sati memories to the query.
+- Sati context may be included ONLY as a separate "context for interpretation" section, clearly separated from the search objective, so Link can use it to interpret results — never to filter or bias the search itself.
+- Constraints such as response length, specific documents to search, or resources to avoid may be included.
 
-Example 2:
-ask: "I have two cats" or "My name is John"
-good:
-- Answer directly acknowledging the fact. Do NOT delegate.
-bad:
-- delegate to "neo_delegate" or "apoc_delegate" to save the fact. (Sati handles this automatically in the background)
 
+---------------------
+        SKILLS
+---------------------
 ${SkillRegistry.getInstance().getSystemPromptSection()}
+
+---------------------
+        SMITHS
+---------------------
 ${SmithRegistry.getInstance().getSystemPromptSection()}
 `);
+            //save the system prompt on ~/.morpheus/system_prompt.txt for debugging and prompt engineering purposes
+            try {
+                writeFileSync(`${PATHS.root}/system_prompt.txt`, String(systemMessage.content), 'utf-8');
+            }
+            catch { }
             // Resolve the authoritative session ID for this call.
             // Priority: explicit taskContext > current history instance > fallback.
             const currentSessionId = taskContext?.session_id
@@ -421,6 +454,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
             Apoc.setSessionId(currentSessionId);
             Neo.setSessionId(currentSessionId);
             Trinity.setSessionId(currentSessionId);
+            Link.setSessionId(currentSessionId);
             const invokeContext = {
                 origin_channel: taskContext?.origin_channel ?? "api",
                 session_id: taskContext?.session_id ?? currentSessionId ?? "default",
@@ -431,7 +465,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
             let syncDelegationCount = 0;
             const oracleStartMs = Date.now();
             const response = await TaskRequestContext.run(invokeContext, async () => {
-                const agentResponse = await this.provider.invoke({ messages }, { recursionLimit: 50 });
+                const agentResponse = await this.provider.invoke({ messages }, { recursionLimit: 10 });
                 contextDelegationAcks = TaskRequestContext.getDelegationAcks();
                 syncDelegationCount = TaskRequestContext.getSyncDelegationCount();
                 return agentResponse;
@@ -464,7 +498,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
             const startNewMessagesIndex = messages.length;
             const newGeneratedMessages = response.messages.slice(startNewMessagesIndex);
             // Emit tool_call audit events for Oracle's independent tool calls.
-            // Delegation tools (apoc/neo/trinity/smith/skill) are already audited
+            // Delegation tools (apoc/neo/trinity/smith/skill/link) are already audited
             // inside buildDelegationTool or the task system — skip them here.
             emitToolAuditEvents(newGeneratedMessages, currentSessionId ?? 'default', 'oracle', {
                 skipTools: ORACLE_DELEGATION_TOOLS,
@@ -648,19 +682,22 @@ Use it to inform your response and tool selection (if needed), but do not assume
         await Construtor.reload();
         await Neo.refreshDelegateCatalog().catch(() => { });
         await Trinity.refreshDelegateCatalog().catch(() => { });
-        updateSkillToolDescriptions();
+        await Link.refreshDelegateCatalog().catch(() => { });
         this.provider = await ProviderFactory.create(this.config.llm, [
             buildSetupTool(),
             TaskQueryTool,
             Neo.getInstance().createDelegateTool(),
             Apoc.getInstance().createDelegateTool(),
             Trinity.getInstance().createDelegateTool(),
-            SkillExecuteTool,
-            SkillDelegateTool,
+            Link.getInstance().createDelegateTool(),
+            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' });
     }
 }