morpheus-cli 0.8.0 → 0.8.3

package/dist/runtime/neo.js

@@ -30,13 +30,13 @@ export class Neo {
         Neo.instance = null;
     }
     static async refreshDelegateCatalog() {
-        const mcpTools = await Construtor.create();
+        const mcpTools = await Construtor.create(() => Neo.currentSessionId);
         updateNeoDelegateToolDescription(mcpTools);
     }
     async initialize() {
         const neoConfig = this.config.neo || this.config.llm;
         const personality = this.config.neo?.personality || 'analytical_engineer';
-        const mcpTools = await Construtor.create();
+        const mcpTools = await Construtor.create(() => Neo.currentSessionId);
         const tools = [...mcpTools, ...morpheusTools];
         updateNeoDelegateToolDescription(mcpTools);
         this.display.log(`Neo initialized with ${tools.length} tools (personality: ${personality}).`, { source: "Neo" });
@@ -89,30 +89,46 @@ ${context ? `Context:\n${context}` : ""}
                 origin_message_id: taskContext?.origin_message_id,
                 origin_user_id: taskContext?.origin_user_id,
             };
+            const startMs = Date.now();
             const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }));
+            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 = lastMessage.usage_metadata
+                ?? lastMessage.response_metadata?.usage
+                ?? lastMessage.response_metadata?.tokenUsage
+                ?? lastMessage.usage;
+            const inputTokens = rawUsage?.input_tokens ?? 0;
+            const outputTokens = rawUsage?.output_tokens ?? 0;
+            const stepCount = response.messages.filter((m) => m instanceof AIMessage).length;
             const targetSession = sessionId ?? Neo.currentSessionId ?? "neo";
             const history = new SQLiteChatMessageHistory({ sessionId: targetSession });
             try {
                 const persisted = new AIMessage(content);
-                persisted.usage_metadata = lastMessage.usage_metadata
-                    ?? lastMessage.response_metadata?.usage
-                    ?? lastMessage.response_metadata?.tokenUsage
-                    ?? lastMessage.usage;
-                persisted.provider_metadata = {
-                    provider: neoConfig.provider,
-                    model: neoConfig.model,
-                };
+                if (rawUsage)
+                    persisted.usage_metadata = rawUsage;
+                persisted.provider_metadata = { provider: neoConfig.provider, model: neoConfig.model };
+                persisted.agent_metadata = { agent: 'neo' };
+                persisted.duration_ms = durationMs;
                 await history.addMessage(persisted);
             }
             finally {
                 history.close();
             }
             this.display.log("Neo task completed.", { source: "Neo" });
-            return content;
+            return {
+                output: content,
+                usage: {
+                    provider: neoConfig.provider,
+                    model: neoConfig.model,
+                    inputTokens,
+                    outputTokens,
+                    durationMs,
+                    stepCount,
+                },
+            };
         }
         catch (err) {
             throw new ProviderError(neoConfig.provider, err, "Neo task execution failed");

package/dist/runtime/oracle.js

@@ -19,6 +19,7 @@ import { Construtor } from "./tools/factory.js";
 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";
 export class Oracle {
     provider;
     config;
@@ -368,12 +369,34 @@ Use it to inform your response and tool selection (if needed), but do not assume
             };
             let contextDelegationAcks = [];
             let syncDelegationCount = 0;
+            const oracleStartMs = Date.now();
             const response = await TaskRequestContext.run(invokeContext, async () => {
                 const agentResponse = await this.provider.invoke({ messages });
                 contextDelegationAcks = TaskRequestContext.getDelegationAcks();
                 syncDelegationCount = TaskRequestContext.getSyncDelegationCount();
                 return agentResponse;
             });
+            const oracleDurationMs = Date.now() - oracleStartMs;
+            // Emit llm_call audit event for Oracle's own invocation
+            try {
+                const lastMsg = response.messages[response.messages.length - 1];
+                const rawUsage = lastMsg.usage_metadata
+                    ?? lastMsg.response_metadata?.usage
+                    ?? lastMsg.response_metadata?.tokenUsage
+                    ?? lastMsg.usage;
+                AuditRepository.getInstance().insert({
+                    session_id: currentSessionId ?? 'default',
+                    event_type: 'llm_call',
+                    agent: 'oracle',
+                    provider: this.config.llm.provider,
+                    model: this.config.llm.model,
+                    input_tokens: rawUsage?.input_tokens ?? rawUsage?.prompt_tokens ?? 0,
+                    output_tokens: rawUsage?.output_tokens ?? rawUsage?.completion_tokens ?? 0,
+                    duration_ms: oracleDurationMs,
+                    status: 'success',
+                });
+            }
+            catch { /* non-critical */ }
             // Identify new messages generated during the interaction
             // The `messages` array passed to invoke had length `messages.length`
             // The `response.messages` contains the full state.
@@ -381,12 +404,16 @@ 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);
             // console.log('New generated messages', newGeneratedMessages);
-            // Inject provider/model metadata into all new messages
+            // Inject provider/model metadata and duration into all new AI messages
             for (const msg of newGeneratedMessages) {
                 msg.provider_metadata = {
                     provider: this.config.llm.provider,
                     model: this.config.llm.model
                 };
+                msg.agent_metadata = { agent: 'oracle' };
+                if (msg instanceof AIMessage) {
+                    msg.duration_ms = oracleDurationMs;
+                }
             }
             let responseContent;
             const toolDelegationAcks = this.extractDelegationAcksFromMessages(newGeneratedMessages);

package/dist/runtime/smiths/connection.js

@@ -145,6 +145,13 @@ export class SmithConnection {
             }
         });
     }
+    /** Returns true if the given entry differs from what this connection was created with */
+    hasEntryChanged(entry) {
+        return (entry.host !== this.entry.host ||
+            entry.port !== this.entry.port ||
+            entry.auth_token !== this.entry.auth_token ||
+            (entry.tls ?? false) !== (this.entry.tls ?? false));
+    }
     /** Register a handler for incoming messages */
     onMessage(handler) {
         this.messageHandlers.push(handler);

package/dist/runtime/smiths/delegator.js

@@ -98,14 +98,14 @@ export class SmithDelegator {
     async delegate(smithName, task, context) {
         const smith = this.registry.get(smithName);
         if (!smith) {
-            return `❌ Smith '${smithName}' not found. Available: ${this.registry.list().map(s => s.name).join(', ') || 'none'}`;
+            return { output: `❌ Smith '${smithName}' not found. Available: ${this.registry.list().map(s => s.name).join(', ') || 'none'}` };
         }
         if (smith.state !== 'online') {
-            return `❌ Smith '${smithName}' is ${smith.state}. Cannot delegate.`;
+            return { output: `❌ Smith '${smithName}' is ${smith.state}. Cannot delegate.` };
         }
         const connection = this.registry.getConnection(smithName);
         if (!connection || !connection.connected) {
-            return `❌ No active connection to Smith '${smithName}'.`;
+            return { output: `❌ No active connection to Smith '${smithName}'.` };
         }
         this.display.log(`Delegating to Smith '${smithName}': ${task.slice(0, 100)}...`, {
             source: 'SmithDelegator',
@@ -116,7 +116,7 @@ export class SmithDelegator {
             // Build proxy tools for this Smith's capabilities
             const proxyTools = this.buildProxyTools(smithName);
             if (proxyTools.length === 0) {
-                return `❌ Smith '${smithName}' has no available tools.`;
+                return { output: `❌ Smith '${smithName}' has no available tools.` };
             }
             // Create a fresh ReactAgent with proxy tools
             const config = ConfigManager.getInstance().get();
@@ -134,25 +134,31 @@ Respond in the same language as the task.`);
                 ? `Context: ${context}\n\nTask: ${task}`
                 : task;
             const messages = [systemMessage, new HumanMessage(userContent)];
+            const startMs = Date.now();
             const response = await agent.invoke({ messages });
+            const durationMs = Date.now() - startMs;
             // Extract final response
             const lastMessage = response.messages[response.messages.length - 1];
             const content = typeof lastMessage.content === 'string'
                 ? lastMessage.content
                 : JSON.stringify(lastMessage.content);
+            const rawUsage = lastMessage.usage_metadata
+                ?? lastMessage.response_metadata?.usage
+                ?? lastMessage.response_metadata?.tokenUsage
+                ?? lastMessage.usage;
+            const inputTokens = rawUsage?.input_tokens ?? 0;
+            const outputTokens = rawUsage?.output_tokens ?? 0;
+            const stepCount = response.messages.filter((m) => m instanceof AIMessage).length;
             // Persist token usage to session history
             try {
                 const history = new SQLiteChatMessageHistory({ sessionId: 'smith' });
                 try {
                     const persisted = new AIMessage(content);
-                    persisted.usage_metadata = lastMessage.usage_metadata
-                        ?? lastMessage.response_metadata?.usage
-                        ?? lastMessage.response_metadata?.tokenUsage
-                        ?? lastMessage.usage;
-                    persisted.provider_metadata = {
-                        provider: llmConfig.provider,
-                        model: llmConfig.model,
-                    };
+                    if (rawUsage)
+                        persisted.usage_metadata = rawUsage;
+                    persisted.provider_metadata = { provider: llmConfig.provider, model: llmConfig.model };
+                    persisted.agent_metadata = { agent: 'smith' };
+                    persisted.duration_ms = durationMs;
                     await history.addMessage(persisted);
                 }
                 finally {
@@ -166,14 +172,24 @@ Respond in the same language as the task.`);
                 source: 'SmithDelegator',
                 level: 'info',
             });
-            return content;
+            return {
+                output: content,
+                usage: {
+                    provider: llmConfig.provider,
+                    model: llmConfig.model,
+                    inputTokens,
+                    outputTokens,
+                    durationMs,
+                    stepCount,
+                },
+            };
         }
         catch (err) {
             this.display.log(`Smith delegation error: ${err.message}`, {
                 source: 'SmithDelegator',
                 level: 'error',
             });
-            return `❌ Smith '${smithName}' delegation failed: ${err.message}`;
+            return { output: `❌ Smith '${smithName}' delegation failed: ${err.message}` };
         }
     }
     /**

package/dist/runtime/smiths/registry.js

@@ -193,7 +193,7 @@ export class SmithRegistry extends EventEmitter {
      * Hot-reload Smiths from current config.
      * - Connects new entries that aren't yet registered
      * - Disconnects entries that were removed from config
-     * - Leaves existing connections untouched
+     * - Reconnects existing entries whose connection details changed (host/port/tls/auth_token)
      */
     async reload() {
         const config = ConfigManager.getInstance().getSmithsConfig();
@@ -223,9 +223,20 @@ export class SmithRegistry extends EventEmitter {
                 });
             }
         }
-        // Add new Smiths from config
+        // Add new Smiths or reconnect existing ones whose connection details changed
         for (const entry of config.entries) {
-            if (!currentNames.has(entry.name)) {
+            const isNew = !currentNames.has(entry.name);
+            const existingConn = this.connections.get(entry.name);
+            const changed = !isNew && existingConn && existingConn.hasEntryChanged(entry);
+            if (isNew || changed) {
+                if (changed && existingConn) {
+                    await existingConn.disconnect().catch(() => { });
+                    this.connections.delete(entry.name);
+                    this.smiths.delete(entry.name);
+                    this.display.log(`Smith '${entry.name}' reconnecting with updated config (hot-reload)`, {
+                        source: 'SmithRegistry', level: 'info',
+                    });
+                }
                 this.register(entry);
                 const connection = new SmithConnection(entry, this);
                 this.connections.set(entry.name, connection);
@@ -235,7 +246,7 @@ export class SmithRegistry extends EventEmitter {
                     });
                 });
                 added.push(entry.name);
-                this.display.log(`Smith '${entry.name}' added and connecting (hot-reload)`, {
+                this.display.log(`Smith '${entry.name}' ${isNew ? 'added and connecting' : 'reconnecting'} (hot-reload)`, {
                     source: 'SmithRegistry', level: 'info',
                 });
             }

package/dist/runtime/tasks/repository.js

@@ -62,6 +62,12 @@ export class TaskRepository {
         addColumn(`ALTER TABLE tasks ADD COLUMN notified_at INTEGER`, 'notified_at');
         addColumn(`ALTER TABLE tasks ADD COLUMN notify_after_at INTEGER`, 'notify_after_at');
         addColumn(`ALTER TABLE tasks ADD COLUMN ack_sent INTEGER NOT NULL DEFAULT 0`, 'ack_sent');
+        addColumn(`ALTER TABLE tasks ADD COLUMN provider TEXT`, 'provider');
+        addColumn(`ALTER TABLE tasks ADD COLUMN model TEXT`, 'model');
+        addColumn(`ALTER TABLE tasks ADD COLUMN input_tokens INTEGER NOT NULL DEFAULT 0`, 'input_tokens');
+        addColumn(`ALTER TABLE tasks ADD COLUMN output_tokens INTEGER NOT NULL DEFAULT 0`, 'output_tokens');
+        addColumn(`ALTER TABLE tasks ADD COLUMN duration_ms INTEGER`, 'duration_ms');
+        addColumn(`ALTER TABLE tasks ADD COLUMN step_count INTEGER NOT NULL DEFAULT 0`, 'step_count');
         this.db.exec(`
       UPDATE tasks
       SET
@@ -244,7 +250,7 @@ export class TaskRepository {
         });
         return tx();
     }
-    markCompleted(id, output) {
+    markCompleted(id, output, usage) {
         const now = Date.now();
         const normalizedOutput = (output ?? '').trim();
         this.db.prepare(`
@@ -256,9 +262,15 @@ export class TaskRepository {
           updated_at = ?,
           notify_status = 'pending',
           notify_last_error = NULL,
-          notified_at = NULL
+          notified_at = NULL,
+          provider = COALESCE(?, provider),
+          model = COALESCE(?, model),
+          input_tokens = COALESCE(?, input_tokens),
+          output_tokens = COALESCE(?, output_tokens),
+          duration_ms = COALESCE(?, duration_ms),
+          step_count = COALESCE(?, step_count)
       WHERE id = ? AND status != 'cancelled'
-    `).run(normalizedOutput.length > 0 ? normalizedOutput : 'Task completed without output.', now, now, id);
+    `).run(normalizedOutput.length > 0 ? normalizedOutput : 'Task completed without output.', now, now, usage?.provider ?? null, usage?.model ?? null, usage?.inputTokens ?? null, usage?.outputTokens ?? null, usage?.durationMs ?? null, usage?.stepCount ?? null, id);
     }
     markFailed(id, error) {
         const now = Date.now();

package/dist/runtime/tasks/worker.js

@@ -6,6 +6,7 @@ import { Trinity } from '../trinity.js';
 import { executeKeymakerTask } from '../keymaker.js';
 import { SmithDelegator } from '../smiths/delegator.js';
 import { TaskRepository } from './repository.js';
+import { AuditRepository } from '../audit/repository.js';
 export class TaskWorker {
     workerId;
     pollIntervalMs;
@@ -50,17 +51,26 @@ export class TaskWorker {
         this.executeTask(task).finally(() => this.activeTasks.delete(task.id));
     }
     async executeTask(task) {
+        const audit = AuditRepository.getInstance();
+        audit.insert({
+            session_id: task.session_id,
+            task_id: task.id,
+            event_type: 'task_created',
+            agent: task.agent === 'trinit' ? 'trinity' : task.agent,
+            status: 'success',
+            metadata: { agent: task.agent, input_preview: task.input.slice(0, 200) },
+        });
         try {
-            let output;
+            let result;
             switch (task.agent) {
                 case 'apoc': {
                     const apoc = Apoc.getInstance();
-                    output = await apoc.execute(task.input, task.context ?? undefined, task.session_id);
+                    result = await apoc.execute(task.input, task.context ?? undefined, task.session_id);
                     break;
                 }
                 case 'neo': {
                     const neo = Neo.getInstance();
-                    output = await neo.execute(task.input, task.context ?? undefined, task.session_id, {
+                    result = await neo.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,
@@ -70,7 +80,7 @@ export class TaskWorker {
                 }
                 case 'trinit': {
                     const trinity = Trinity.getInstance();
-                    output = await trinity.execute(task.input, task.context ?? undefined, task.session_id);
+                    result = await trinity.execute(task.input, task.context ?? undefined, task.session_id);
                     break;
                 }
                 case 'keymaker': {
@@ -86,7 +96,7 @@ export class TaskWorker {
                             skillName = task.context;
                         }
                     }
-                    output = await executeKeymakerTask(skillName, task.input, {
+                    result = await executeKeymakerTask(skillName, task.input, {
                         origin_channel: task.origin_channel,
                         session_id: task.session_id,
                         origin_message_id: task.origin_message_id ?? undefined,
@@ -107,15 +117,68 @@ export class TaskWorker {
                         }
                     }
                     const delegator = SmithDelegator.getInstance();
-                    const result = await delegator.delegate(smithName, task.input, task.context ?? undefined);
-                    output = typeof result === 'string' ? result : JSON.stringify(result);
+                    result = await delegator.delegate(smithName, task.input, task.context ?? undefined);
                     break;
                 }
                 default: {
                     throw new Error(`Unknown task agent: ${task.agent}`);
                 }
             }
-            this.repository.markCompleted(task.id, output);
+            this.repository.markCompleted(task.id, result.output, result.usage ? {
+                provider: result.usage.provider,
+                model: result.usage.model,
+                inputTokens: result.usage.inputTokens,
+                outputTokens: result.usage.outputTokens,
+                durationMs: result.usage.durationMs,
+                stepCount: result.usage.stepCount,
+            } : undefined);
+            const agentName = (task.agent === 'trinit' ? 'trinity' : task.agent);
+            // Emit task_completed audit event
+            audit.insert({
+                session_id: task.session_id,
+                task_id: task.id,
+                event_type: 'task_completed',
+                agent: agentName,
+                duration_ms: result.usage?.durationMs,
+                status: 'success',
+            });
+            // Emit llm_call audit event if usage data is present (not keymaker skills)
+            if (result.usage && (result.usage.inputTokens > 0 || result.usage.outputTokens > 0)) {
+                audit.insert({
+                    session_id: task.session_id,
+                    task_id: task.id,
+                    event_type: 'llm_call',
+                    agent: agentName,
+                    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 },
+                });
+            }
+            // Emit skill_executed for keymaker
+            if (task.agent === 'keymaker') {
+                let skillName = 'unknown';
+                if (task.context) {
+                    try {
+                        skillName = JSON.parse(task.context).skill || task.context;
+                    }
+                    catch {
+                        skillName = task.context;
+                    }
+                }
+                audit.insert({
+                    session_id: task.session_id,
+                    task_id: task.id,
+                    event_type: 'skill_executed',
+                    agent: 'keymaker',
+                    tool_name: skillName,
+                    duration_ms: result.usage?.durationMs,
+                    status: 'success',
+                });
+            }
             this.display.log(`Task completed: ${task.id}`, { source: 'TaskWorker', level: 'success' });
         }
         catch (err) {
@@ -130,6 +193,14 @@ export class TaskWorker {
                 return;
             }
             this.repository.markFailed(task.id, errorMessage);
+            audit.insert({
+                session_id: task.session_id,
+                task_id: task.id,
+                event_type: 'task_completed',
+                agent: (task.agent === 'trinit' ? 'trinity' : task.agent),
+                status: 'error',
+                metadata: { error: errorMessage },
+            });
             this.display.log(`Task failed: ${task.id} (${errorMessage})`, { source: 'TaskWorker', level: 'error' });
         }
     }

package/dist/runtime/tools/apoc-tool.js

@@ -7,6 +7,7 @@ import { DisplayManager } from "../display.js";
 import { ConfigManager } from "../../config/manager.js";
 import { Apoc } from "../apoc.js";
 import { ChannelRegistry } from "../../channels/registry.js";
+import { AuditRepository } from "../audit/repository.js";
 /**
  * Returns true when Apoc is configured to execute synchronously (inline).
  */
@@ -56,7 +57,21 @@ export const ApocDelegateTool = tool(async ({ task, context }) => {
                     source: "ApocDelegateTool",
                     level: "info",
                 });
-                return result;
+                if (result.usage) {
+                    AuditRepository.getInstance().insert({
+                        session_id: sessionId,
+                        event_type: 'llm_call',
+                        agent: 'apoc',
+                        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) {
                 // Still count as sync delegation so Oracle passes through the error message

package/dist/runtime/tools/factory.js

@@ -1,6 +1,39 @@
 import { DisplayManager } from "../display.js";
 import { MCPToolCache } from "./cache.js";
+import { AuditRepository } from "../audit/repository.js";
 const display = DisplayManager.getInstance();
+function instrumentMcpTool(tool, serverName, getSessionId) {
+    const original = tool._call.bind(tool);
+    tool._call = async function (input, runManager) {
+        const startMs = Date.now();
+        const sessionId = getSessionId() ?? 'unknown';
+        try {
+            const result = await original(input, runManager);
+            AuditRepository.getInstance().insert({
+                session_id: sessionId,
+                event_type: 'mcp_tool',
+                agent: 'neo',
+                tool_name: `${serverName}/${tool.name}`,
+                duration_ms: Date.now() - startMs,
+                status: 'success',
+            });
+            return result;
+        }
+        catch (err) {
+            AuditRepository.getInstance().insert({
+                session_id: sessionId,
+                event_type: 'mcp_tool',
+                agent: 'neo',
+                tool_name: `${serverName}/${tool.name}`,
+                duration_ms: Date.now() - startMs,
+                status: 'error',
+                metadata: { error: err?.message ?? String(err) },
+            });
+            throw err;
+        }
+    };
+    return tool;
+}
 export class Construtor {
     /**
      * Probe MCP servers by checking cache stats.
@@ -21,13 +54,20 @@ export class Construtor {
      * Get MCP tools from cache (fast path).
      * If cache is not loaded, loads it first.
      * Tools are cached and returned instantly on subsequent calls.
+     * If getSessionId is provided, tools are wrapped with audit instrumentation.
      */
-    static async create() {
+    static async create(getSessionId) {
         const cache = MCPToolCache.getInstance();
         await cache.ensureLoaded();
         const tools = cache.getTools();
         display.log(`Returning ${tools.length} cached MCP tools`, { level: 'debug', source: 'Construtor' });
-        return tools;
+        if (!getSessionId)
+            return tools;
+        // Wrap each tool with audit tracking; derive server name from tool name prefix
+        return tools.map(tool => {
+            const serverName = tool.serverName ?? tool.name.split('_')[0] ?? 'mcp';
+            return instrumentMcpTool(tool, serverName, getSessionId);
+        });
     }
     /**
      * Force reload MCP tools from servers (slow path).

package/dist/runtime/tools/neo-tool.js

@@ -7,6 +7,7 @@ import { DisplayManager } from "../display.js";
 import { ConfigManager } from "../../config/manager.js";
 import { Neo } from "../neo.js";
 import { ChannelRegistry } from "../../channels/registry.js";
+import { AuditRepository } from "../audit/repository.js";
 const NEO_BUILTIN_CAPABILITIES = `
 Neo built-in capabilities (always available — no MCP required):
 • Config: morpheus_config_query, morpheus_config_update — read/write Morpheus configuration (LLM, channels, UI, etc.)
@@ -89,7 +90,21 @@ export const NeoDelegateTool = tool(async ({ task, context }) => {
                     source: "NeoDelegateTool",
                     level: "info",
                 });
-                return result;
+                if (result.usage) {
+                    AuditRepository.getInstance().insert({
+                        session_id: sessionId,
+                        event_type: 'llm_call',
+                        agent: 'neo',
+                        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) {
                 // Still count as sync delegation so Oracle passes through the error message

package/dist/runtime/tools/smith-tool.js

@@ -7,6 +7,7 @@ import { ConfigManager } from "../../config/manager.js";
 import { SmithDelegator } from "../smiths/delegator.js";
 import { SmithRegistry } from "../smiths/registry.js";
 import { ChannelRegistry } from "../../channels/registry.js";
+import { AuditRepository } from "../audit/repository.js";
 /**
  * Returns true when Smiths are configured in sync mode (inline execution).
  */
@@ -39,9 +40,10 @@ export const SmithDelegateTool = tool(async ({ smith, task, context }) => {
                 level: "info",
             });
             const ctx = TaskRequestContext.get();
+            const sessionId = ctx?.session_id ?? 'default';
             // Notify originating channel
             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, `🤖 Smith '${smith}' is executing your request...`)
+                ChannelRegistry.sendToUser(ctx.origin_channel, ctx.origin_user_id, `🕶️ Smith '${smith}' is executing your request...`)
                     .catch(() => { });
             }
             try {
@@ -52,7 +54,21 @@ export const SmithDelegateTool = tool(async ({ smith, task, context }) => {
                     source: "SmithDelegateTool",
                     level: "info",
                 });
-                return result;
+                if (result.usage) {
+                    AuditRepository.getInstance().insert({
+                        session_id: sessionId,
+                        event_type: 'llm_call',
+                        agent: 'smith',
+                        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: { smith_name: smith, step_count: result.usage.stepCount, mode: 'sync' },
+                    });
+                }
+                return result.output;
             }
             catch (syncErr) {
                 TaskRequestContext.incrementSyncDelegation();