morpheus-cli 0.8.5 → 0.8.7

package/dist/runtime/oracle.js

@@ -10,9 +10,6 @@ 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 { TrinityDelegateTool } from "./tools/trinity-tool.js";
 import { SmithDelegateTool } from "./tools/smith-tool.js";
 import { TaskQueryTool, chronosTools, timeVerifierTool } from "./tools/index.js";
 import { Construtor } from "./tools/factory.js";
@@ -20,6 +17,11 @@ import { MCPManager } from "../config/mcp-manager.js";
 import { SkillRegistry, SkillExecuteTool, SkillDelegateTool, updateSkillToolDescriptions } from "./skills/index.js";
 import { SmithRegistry } from "./smiths/registry.js";
 import { AuditRepository } from "./audit/repository.js";
+import { emitToolAuditEvents } from "./subagent-utils.js";
+const ORACLE_DELEGATION_TOOLS = new Set([
+    'apoc_delegate', 'neo_delegate', 'trinity_delegate', 'smith_delegate',
+    'skill_delegate', 'skill_execute',
+]);
 export class Oracle {
     provider;
     config;
@@ -28,6 +30,8 @@ export class Oracle {
     taskRepository = TaskRepository.getInstance();
     databasePath;
     satiMiddleware = SatiMemoryMiddleware.getInstance();
+    /** Turn counter per session — tracks how many chat() calls have occurred per session ID. */
+    satiTurnCounters = new Map();
     constructor(config, overrides) {
         this.config = config || ConfigManager.getInstance().get();
         this.databasePath = overrides?.databasePath;
@@ -150,7 +154,16 @@ export class Oracle {
             await Trinity.refreshDelegateCatalog().catch(() => { });
             updateSkillToolDescriptions();
             // Build tool list — conditionally include SmithDelegateTool based on config
-            const coreTools = [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, SkillExecuteTool, SkillDelegateTool, timeVerifierTool, ...chronosTools];
+            const coreTools = [
+                TaskQueryTool,
+                Neo.getInstance().createDelegateTool(),
+                Apoc.getInstance().createDelegateTool(),
+                Trinity.getInstance().createDelegateTool(),
+                SkillExecuteTool,
+                SkillDelegateTool,
+                timeVerifierTool,
+                ...chronosTools,
+            ];
             const smithsConfig = ConfigManager.getInstance().getSmithsConfig();
             if (smithsConfig.enabled && smithsConfig.entries.length > 0) {
                 coreTools.push(SmithDelegateTool);
@@ -212,14 +225,25 @@ You are ${this.config.agent.name}, ${this.config.agent.personality}, the Oracle.
 
 You are an orchestrator and task router.
 
-If the user request contains ANY time-related expression
-(today, tomorrow, this week, next month, in 3 days, etc),
-you **MUST** call the tool "time_verifier" before answering or call another tool **ALWAYS**.
+## 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**:
 
-With the time_verify, you remake the user prompt.
+**Category A — Explicit temporal expressions** (pass the expression itself as 'text'):
+- Examples: "today", "tomorrow", "next week", "in 3 days", "this Friday", "at 20h"
+- PT: "hoje", "amanhã", "próxima semana", "em 3 dias", "na sexta"
+- Pass: '{ text: "<the expression>" }' → get resolved date → include it in the search/delegation
 
-Never assume dates.
-Always resolve temporal expressions using the tool.
+**Category B — Implicit temporal intent** (pass "hoje" as 'text' to anchor the search to now):
+- "próximo jogo do Flamengo" → next scheduled event AFTER today
+- "próximo episódio de X" → upcoming release AFTER today
+- "latest version of Y", "resultado mais recente", "quem está liderando agora"
+- Any query whose answer changes depending on what day it is today
+- Pass: '{ text: "hoje" }'  → get today's resolved date → include it in the search/delegation
+
+**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:
 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).
@@ -326,10 +350,14 @@ ${SmithRegistry.getInstance().getSystemPromptSection()}
             // Load existing history from database in reverse order (most recent first)
             let previousMessages = await this.history.getMessages();
             previousMessages = previousMessages.reverse();
+            // Propagate current session to Apoc so its token usage lands in the right session
+            const currentSessionId = (this.history instanceof SQLiteChatMessageHistory)
+                ? this.history.currentSessionId
+                : undefined;
             // Sati Middleware: Retrieval
             let memoryMessage = null;
             try {
-                memoryMessage = await this.satiMiddleware.beforeAgent(message, previousMessages);
+                memoryMessage = await this.satiMiddleware.beforeAgent(message, previousMessages, currentSessionId);
                 if (memoryMessage) {
                     this.display.log('Sati memory retrieved.', { source: 'Sati' });
                 }
@@ -354,10 +382,6 @@ Use it to inform your response and tool selection (if needed), but do not assume
             }
             messages.push(...previousMessages);
             messages.push(userMessage);
-            // Propagate current session to Apoc so its token usage lands in the right session
-            const currentSessionId = (this.history instanceof SQLiteChatMessageHistory)
-                ? this.history.currentSessionId
-                : undefined;
             Apoc.setSessionId(currentSessionId);
             Neo.setSessionId(currentSessionId);
             Trinity.setSessionId(currentSessionId);
@@ -403,7 +427,12 @@ Use it to inform your response and tool selection (if needed), but do not assume
             // New messages start after the inputs.
             const startNewMessagesIndex = messages.length;
             const newGeneratedMessages = response.messages.slice(startNewMessagesIndex);
-            // console.log('New generated messages', newGeneratedMessages);
+            // Emit tool_call audit events for Oracle's independent tool calls.
+            // Delegation tools (apoc/neo/trinity/smith/skill) are already audited
+            // inside buildDelegationTool or the task system — skip them here.
+            emitToolAuditEvents(newGeneratedMessages, currentSessionId ?? 'default', 'oracle', {
+                skipTools: ORACLE_DELEGATION_TOOLS,
+            });
             // Inject provider/model metadata and duration into all new AI messages
             for (const msg of newGeneratedMessages) {
                 msg.provider_metadata = {
@@ -491,8 +520,19 @@ Use it to inform your response and tool selection (if needed), but do not assume
             this.display.log('Response generated.', { source: 'Oracle' });
             // Sati Middleware: skip memory evaluation for delegation-only acknowledgements.
             if (!delegatedThisTurn && !blockedSyntheticDelegationAck) {
-                this.satiMiddleware.afterAgent(responseContent, [...previousMessages, userMessage], currentSessionId)
-                    .catch((e) => this.display.log(`Sati memory evaluation failed: ${e.message}`, { source: 'Sati' }));
+                const sessionKey = currentSessionId ?? 'default';
+                const turnCount = (this.satiTurnCounters.get(sessionKey) ?? 0) + 1;
+                this.satiTurnCounters.set(sessionKey, turnCount);
+                const satiCfg = ConfigManager.getInstance().getSatiConfig();
+                const evalInterval = satiCfg.evaluation_interval ?? 1;
+                const contextWindow = this.config.llm?.context_window ?? this.config.memory?.limit ?? 100;
+                const effectiveInterval = Math.min(evalInterval, contextWindow);
+                const shouldEval = turnCount % effectiveInterval === 0;
+                if (shouldEval) {
+                    this.display.log(`Sati eval triggered (turn ${turnCount}, effective interval ${effectiveInterval})`, { source: 'Sati', level: 'debug' });
+                    this.satiMiddleware.afterAgent(responseContent, [...previousMessages, userMessage], currentSessionId)
+                        .catch((e) => this.display.log(`Sati memory evaluation failed: ${e.message}`, { source: 'Sati' }));
+                }
             }
             return responseContent;
         }
@@ -604,7 +644,16 @@ Use it to inform your response and tool selection (if needed), but do not assume
         await Neo.refreshDelegateCatalog().catch(() => { });
         await Trinity.refreshDelegateCatalog().catch(() => { });
         updateSkillToolDescriptions();
-        this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, SkillExecuteTool, SkillDelegateTool, timeVerifierTool, ...chronosTools]);
+        this.provider = await ProviderFactory.create(this.config.llm, [
+            TaskQueryTool,
+            Neo.getInstance().createDelegateTool(),
+            Apoc.getInstance().createDelegateTool(),
+            Trinity.getInstance().createDelegateTool(),
+            SkillExecuteTool,
+            SkillDelegateTool,
+            timeVerifierTool,
+            ...chronosTools,
+        ]);
         await Neo.getInstance().reload();
         this.display.log(`Oracle and Neo tools reloaded`, { source: 'Oracle' });
     }

package/dist/runtime/skills/tool.js

@@ -8,6 +8,7 @@ import { TaskRequestContext } from "../tasks/context.js";
 import { DisplayManager } from "../display.js";
 import { SkillRegistry } from "./registry.js";
 import { executeKeymakerTask } from "../keymaker.js";
+import { AuditRepository } from "../audit/repository.js";
 // ============================================================================
 // skill_execute - Synchronous execution
 // ============================================================================
@@ -67,6 +68,30 @@ export const SkillExecuteTool = tool(async ({ skillName, objective }) => {
             source: "SkillExecuteTool",
             level: "info",
         });
+        // Emit audit events for sync execution (async path is handled by TaskWorker)
+        const audit = AuditRepository.getInstance();
+        if (result.usage && (result.usage.inputTokens > 0 || result.usage.outputTokens > 0)) {
+            audit.insert({
+                session_id: sessionId,
+                event_type: 'llm_call',
+                agent: 'keymaker',
+                provider: result.usage.provider,
+                model: result.usage.model,
+                input_tokens: result.usage.inputTokens,
+                output_tokens: result.usage.outputTokens,
+                duration_ms: result.usage.durationMs,
+                status: 'success',
+                metadata: { step_count: result.usage.stepCount },
+            });
+        }
+        audit.insert({
+            session_id: sessionId,
+            event_type: 'skill_executed',
+            agent: 'keymaker',
+            tool_name: skillName,
+            duration_ms: result.usage?.durationMs,
+            status: 'success',
+        });
         return result;
     }
     catch (err) {

package/dist/runtime/subagent-utils.js

@@ -0,0 +1,89 @@
+import { AIMessage, ToolMessage } from "@langchain/core/messages";
+import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
+import { AuditRepository } from "./audit/repository.js";
+/** Extract token usage from a LangChain message using 4-fallback chain. */
+export function extractRawUsage(lastMessage) {
+    return lastMessage.usage_metadata
+        ?? lastMessage.response_metadata?.usage
+        ?? lastMessage.response_metadata?.tokenUsage
+        ?? lastMessage.usage;
+}
+/** Persist an agent's AI message to SQLite with provider + agent metadata. */
+export async function persistAgentMessage(agentName, content, config, sessionId, rawUsage, durationMs) {
+    const history = new SQLiteChatMessageHistory({ sessionId });
+    try {
+        const persisted = new AIMessage(content);
+        if (rawUsage)
+            persisted.usage_metadata = rawUsage;
+        persisted.provider_metadata = { provider: config.provider, model: config.model };
+        persisted.agent_metadata = { agent: agentName };
+        persisted.duration_ms = durationMs;
+        await history.addMessage(persisted);
+    }
+    finally {
+        history.close();
+    }
+}
+/**
+ * Emit audit events for each tool call found in the given messages.
+ * Scans AIMessage.tool_calls and matches results from ToolMessage instances.
+ * - defaultEventType: 'tool_call' for DevKit/internal, 'mcp_tool' for MCP tools (default: 'tool_call')
+ * - skipTools: tool names to ignore entirely (e.g. delegation tools already audited elsewhere)
+ * - internalToolNames: tool names that should always use 'tool_call' even when defaultEventType is 'mcp_tool'
+ */
+export function emitToolAuditEvents(messages, sessionId, agent, opts) {
+    try {
+        const defaultEventType = opts?.defaultEventType ?? 'tool_call';
+        const skipTools = opts?.skipTools;
+        const internalToolNames = opts?.internalToolNames;
+        const toolResults = new Map();
+        for (const msg of messages) {
+            if (msg instanceof ToolMessage) {
+                const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+                toolResults.set(msg.tool_call_id, content);
+            }
+        }
+        for (const msg of messages) {
+            if (!(msg instanceof AIMessage))
+                continue;
+            const toolCalls = msg.tool_calls ?? [];
+            for (const tc of toolCalls) {
+                if (!tc?.name)
+                    continue;
+                if (skipTools?.has(tc.name))
+                    continue;
+                const result = tc.id ? toolResults.get(tc.id) : undefined;
+                const isError = typeof result === 'string' && /^error:/i.test(result.trim());
+                const eventType = internalToolNames?.has(tc.name) ? 'tool_call' : defaultEventType;
+                const meta = {};
+                if (tc.args && Object.keys(tc.args).length > 0)
+                    meta.args = tc.args;
+                if (result !== undefined)
+                    meta.result = result.length > 500 ? result.slice(0, 500) + '…' : result;
+                AuditRepository.getInstance().insert({
+                    session_id: sessionId,
+                    event_type: eventType,
+                    agent,
+                    tool_name: tc.name,
+                    status: isError ? 'error' : 'success',
+                    metadata: Object.keys(meta).length > 0 ? meta : undefined,
+                });
+            }
+        }
+    }
+    catch { /* non-critical */ }
+}
+/** Assemble an AgentResult from extracted usage data. */
+export function buildAgentResult(content, config, rawUsage, durationMs, stepCount) {
+    return {
+        output: content,
+        usage: {
+            provider: config.provider,
+            model: config.model,
+            inputTokens: rawUsage?.input_tokens ?? rawUsage?.prompt_tokens ?? 0,
+            outputTokens: rawUsage?.output_tokens ?? rawUsage?.completion_tokens ?? 0,
+            durationMs,
+            stepCount,
+        },
+    };
+}

package/dist/runtime/tasks/repository.js

@@ -188,6 +188,57 @@ export class TaskRepository {
         const rows = this.db.prepare(query).all(...params);
         return rows.map((row) => this.deserializeTask(row));
     }
+    countTasks(filters) {
+        const params = [];
+        let query = 'SELECT COUNT(*) as cnt FROM tasks WHERE 1=1';
+        if (filters?.status) {
+            query += ' AND status = ?';
+            params.push(filters.status);
+        }
+        if (filters?.agent) {
+            query += ' AND agent = ?';
+            params.push(filters.agent);
+        }
+        if (filters?.origin_channel) {
+            query += ' AND origin_channel = ?';
+            params.push(filters.origin_channel);
+        }
+        if (filters?.session_id) {
+            query += ' AND session_id = ?';
+            params.push(filters.session_id);
+        }
+        const row = this.db.prepare(query).get(...params);
+        return row.cnt;
+    }
+    listTasksPaginated(filters) {
+        const page = Math.max(1, filters?.page ?? 1);
+        const per_page = Math.min(100, Math.max(1, filters?.per_page ?? 20));
+        const offset = (page - 1) * per_page;
+        const total = this.countTasks(filters);
+        const total_pages = Math.ceil(total / per_page);
+        const params = [];
+        let query = 'SELECT * FROM tasks WHERE 1=1';
+        if (filters?.status) {
+            query += ' AND status = ?';
+            params.push(filters.status);
+        }
+        if (filters?.agent) {
+            query += ' AND agent = ?';
+            params.push(filters.agent);
+        }
+        if (filters?.origin_channel) {
+            query += ' AND origin_channel = ?';
+            params.push(filters.origin_channel);
+        }
+        if (filters?.session_id) {
+            query += ' AND session_id = ?';
+            params.push(filters.session_id);
+        }
+        query += ' ORDER BY created_at DESC LIMIT ? OFFSET ?';
+        params.push(per_page, offset);
+        const rows = this.db.prepare(query).all(...params);
+        return { data: rows.map((row) => this.deserializeTask(row)), total, page, per_page, total_pages };
+    }
     getStats() {
         const rows = this.db.prepare(`
       SELECT status, COUNT(*) as cnt

package/dist/runtime/tasks/worker.js

@@ -65,7 +65,12 @@ export class TaskWorker {
             switch (task.agent) {
                 case 'apoc': {
                     const apoc = Apoc.getInstance();
-                    result = await apoc.execute(task.input, task.context ?? undefined, task.session_id);
+                    result = await apoc.execute(task.input, task.context ?? undefined, task.session_id, {
+                        origin_channel: task.origin_channel,
+                        session_id: task.session_id,
+                        origin_message_id: task.origin_message_id ?? undefined,
+                        origin_user_id: task.origin_user_id ?? undefined,
+                    });
                     break;
                 }
                 case 'neo': {
@@ -80,7 +85,12 @@ export class TaskWorker {
                 }
                 case 'trinit': {
                     const trinity = Trinity.getInstance();
-                    result = await trinity.execute(task.input, task.context ?? undefined, task.session_id);
+                    result = await trinity.execute(task.input, task.context ?? undefined, task.session_id, {
+                        origin_channel: task.origin_channel,
+                        session_id: task.session_id,
+                        origin_message_id: task.origin_message_id ?? undefined,
+                        origin_user_id: task.origin_user_id ?? undefined,
+                    });
                     break;
                 }
                 case 'keymaker': {

package/dist/runtime/telephonist.js

@@ -2,16 +2,24 @@ import { GoogleGenAI } from '@google/genai';
 import OpenAI from 'openai';
 import { OpenRouter } from '@openrouter/sdk';
 import fs from 'fs';
+import { parseFile } from 'music-metadata';
 /**
- * Estimates audio duration in seconds based on file size and a typical bitrate.
- * Uses 32 kbps (4000 bytes/sec) as a conservative baseline for compressed audio (OGG, MP3, etc.).
- * This is an approximation — actual duration depends on encoding settings.
+ * Returns the actual audio duration in seconds by parsing the file header.
+ * Falls back to a size-based estimate (~32 kbps) if parsing fails.
  */
-function estimateAudioDurationSeconds(filePath) {
+async function getAudioDurationSeconds(filePath) {
+    try {
+        const metadata = await parseFile(filePath);
+        const duration = metadata.format.duration;
+        if (duration != null && duration > 0)
+            return Math.round(duration);
+    }
+    catch {
+        // fall through to estimate
+    }
     try {
         const stats = fs.statSync(filePath);
-        const bytesPerSecond = 4000; // ~32 kbps
-        return Math.round(stats.size / bytesPerSecond);
+        return Math.round(stats.size / 4000); // ~32 kbps fallback
     }
     catch {
         return 0;
@@ -57,7 +65,7 @@ class GeminiTelephonist {
             input_token_details: {
                 cache_read: usage?.cachedContentTokenCount ?? 0
             },
-            audio_duration_seconds: estimateAudioDurationSeconds(filePath)
+            audio_duration_seconds: await getAudioDurationSeconds(filePath)
         };
         return { text, usage: usageMetadata };
     }
@@ -91,7 +99,7 @@ class WhisperTelephonist {
             input_tokens: 0,
             output_tokens: 0,
             total_tokens: 0,
-            audio_duration_seconds: estimateAudioDurationSeconds(filePath)
+            audio_duration_seconds: await getAudioDurationSeconds(filePath)
         };
         return { text, usage: usageMetadata };
     }
@@ -148,7 +156,7 @@ class OpenRouterTelephonist {
             input_tokens: usage?.prompt_tokens ?? 0,
             output_tokens: usage?.completion_tokens ?? 0,
             total_tokens: usage?.total_tokens ?? 0,
-            audio_duration_seconds: estimateAudioDurationSeconds(filePath)
+            audio_duration_seconds: await getAudioDurationSeconds(filePath)
         };
         return { text, usage: usageMetadata };
     }

package/dist/runtime/tools/delegation-utils.js

@@ -0,0 +1,120 @@
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import { TaskRepository } from "../tasks/repository.js";
+import { TaskRequestContext } from "../tasks/context.js";
+import { compositeDelegationError, isLikelyCompositeDelegationTask } from "./delegation-guard.js";
+import { DisplayManager } from "../display.js";
+import { ChannelRegistry } from "../../channels/registry.js";
+import { AuditRepository } from "../audit/repository.js";
+/**
+ * Factory that builds a delegation StructuredTool for Apoc/Neo/Trinity.
+ * Handles: composite guard, sync branch (notify→execute→audit→increment),
+ * async branch (dedup→canEnqueue→createTask→setAck).
+ */
+export function buildDelegationTool(opts) {
+    const { name, agentKey, agentLabel, auditAgent, isSync, notifyText, executeSync, } = opts;
+    const toolInstance = tool(async ({ task, context }) => {
+        const display = DisplayManager.getInstance();
+        const source = `${agentLabel}DelegateTool`;
+        try {
+            if (isLikelyCompositeDelegationTask(task)) {
+                display.log(`${agentLabel} delegation rejected (non-atomic task): ${task.slice(0, 140)}`, {
+                    source,
+                    level: "warning",
+                });
+                return compositeDelegationError();
+            }
+            // ── Sync mode: execute inline and return result directly ──
+            if (isSync()) {
+                display.log(`${agentLabel} executing synchronously: ${task.slice(0, 80)}...`, {
+                    source,
+                    level: "info",
+                });
+                const ctx = TaskRequestContext.get();
+                const sessionId = ctx?.session_id ?? "default";
+                if (ctx?.origin_channel && ctx.origin_user_id && ctx.origin_channel !== 'api' && ctx.origin_channel !== 'ui') {
+                    ChannelRegistry.sendToUser(ctx.origin_channel, ctx.origin_user_id, notifyText)
+                        .catch(() => { });
+                }
+                try {
+                    const result = await executeSync(task, context, sessionId, ctx);
+                    TaskRequestContext.incrementSyncDelegation();
+                    display.log(`${agentLabel} sync execution completed.`, { source, level: "info" });
+                    if (result.usage) {
+                        AuditRepository.getInstance().insert({
+                            session_id: sessionId,
+                            event_type: 'llm_call',
+                            agent: auditAgent,
+                            provider: result.usage.provider,
+                            model: result.usage.model,
+                            input_tokens: result.usage.inputTokens,
+                            output_tokens: result.usage.outputTokens,
+                            duration_ms: result.usage.durationMs,
+                            status: 'success',
+                            metadata: { step_count: result.usage.stepCount, mode: 'sync' },
+                        });
+                    }
+                    return result.output;
+                }
+                catch (syncErr) {
+                    TaskRequestContext.incrementSyncDelegation();
+                    display.log(`${agentLabel} sync execution failed: ${syncErr.message}`, { source, level: "error" });
+                    return `❌ ${agentLabel} error: ${syncErr.message}`;
+                }
+            }
+            // ── Async mode (default): create background task ──
+            const existingAck = TaskRequestContext.findDuplicateDelegation(agentKey, task);
+            if (existingAck) {
+                display.log(`${agentLabel} delegation deduplicated. Reusing task ${existingAck.task_id}.`, {
+                    source,
+                    level: "info",
+                });
+                return `Task ${existingAck.task_id} already queued for ${existingAck.agent} execution.`;
+            }
+            if (!TaskRequestContext.canEnqueueDelegation()) {
+                display.log(`${agentLabel} delegation blocked by per-turn limit.`, { source, level: "warning" });
+                return "Delegation limit reached for this user turn. Split the request or wait for current tasks.";
+            }
+            const ctx = TaskRequestContext.get();
+            const repository = TaskRepository.getInstance();
+            const created = repository.createTask({
+                agent: agentKey,
+                input: task,
+                context: context ?? null,
+                origin_channel: ctx?.origin_channel ?? "api",
+                session_id: ctx?.session_id ?? "default",
+                origin_message_id: ctx?.origin_message_id ?? null,
+                origin_user_id: ctx?.origin_user_id ?? null,
+                max_attempts: 3,
+            });
+            TaskRequestContext.setDelegationAck({ task_id: created.id, agent: agentKey, task });
+            display.log(`${agentLabel} task created: ${created.id}`, {
+                source,
+                level: "info",
+                meta: {
+                    agent: created.agent,
+                    origin_channel: created.origin_channel,
+                    session_id: created.session_id,
+                    input: created.input,
+                },
+            });
+            return `Task ${created.id} queued for ${agentLabel} execution.`;
+        }
+        catch (err) {
+            display.log(`${source} error: ${err.message}`, { source, level: "error" });
+            return `${agentLabel} task enqueue failed: ${err.message}`;
+        }
+    }, {
+        name,
+        description: typeof opts.description === 'string' ? opts.description : opts.description(),
+        schema: z.object({
+            task: z.string().describe(`Clear task description **in the user's language**`),
+            context: z.string().optional().describe(`Optional context from the conversation **in the user's language**`),
+        }),
+    });
+    // If description is dynamic, expose an updater method on the tool instance
+    if (typeof opts.description === 'function') {
+        toolInstance._descriptionFn = opts.description;
+    }
+    return toolInstance;
+}

package/dist/runtime/tools/index.js

@@ -1,7 +1,5 @@
 // Export all tools from the tools module
 export * from './morpheus-tools.js';
-export * from './apoc-tool.js';
-export * from './neo-tool.js';
 export * from './smith-tool.js';
 export * from './chronos-tools.js';
 export * from './time-verify-tools.js';

package/dist/runtime/tools/time-verify-tools.js

@@ -115,17 +115,24 @@ export const timeVerifierTool = tool(async ({ text, timezone }) => {
 }, {
     name: "time_verifier",
     description: `
-Detects and resolves relative time expressions in user input.
-Supports multiple languages (English, Portuguese, Spanish).
-Use this tool whenever the user mentions words like:
-today, tomorrow, yesterday, this week, next week,
-hoje, amanhã, ontem, próxima semana,
-hoy, mañana, ayer, la próxima semana, etc.
+Resolves temporal expressions into concrete ISO dates anchored to the current date and timezone.
+Use this tool in TWO scenarios:
 
-Returns resolved ISO dates based on the current time and timezone configuration.
+1. EXPLICIT temporal expression — pass the expression itself as "text":
+   - "tomorrow at 9am", "next Friday", "in 3 days", "this week"
+   - "amanhã às 9h", "próxima sexta", "em 3 dias", "esta semana"
+
+2. IMPLICIT temporal query — the user asks about something whose answer depends on today's date,
+   but without stating a date explicitly. Pass "hoje" as text to resolve today's date:
+   - "próximo jogo do Flamengo" → you need today's date to search for games AFTER today
+   - "próximo episódio de X", "latest release", "resultado mais recente"
+   - Any "next", "upcoming", "latest", "current", "recent", "agora" query about real-world events
+
+After calling this tool, incorporate the resolved ISO date into your search query or delegation prompt
+so the agent knows the time context (e.g. "find Flamengo games after 2026-03-01").
     `,
     schema: z.object({
-        text: z.string().describe("User input text containing time expressions"),
+        text: z.string().describe('Temporal expression to resolve (e.g. "amanhã", "next Friday") — OR pass "hoje" to get today\'s date when the query has implicit temporal intent'),
         timezone: z.string().optional().describe("Optional timezone override. Defaults to system configuration."),
     }),
 });