morpheus-cli 0.8.6 → 0.8.8

package/dist/runtime/chronos/repository.js

@@ -156,6 +156,41 @@ export class ChronosRepository {
         const rows = this.db.prepare(query).all(...params);
         return rows.map((r) => this.deserializeJob(r));
     }
+    countJobs(filters) {
+        const params = [];
+        let query = 'SELECT COUNT(*) as cnt FROM chronos_jobs WHERE 1=1';
+        if (filters?.enabled !== undefined) {
+            query += ' AND enabled = ?';
+            params.push(filters.enabled ? 1 : 0);
+        }
+        if (filters?.created_by) {
+            query += ' AND created_by = ?';
+            params.push(filters.created_by);
+        }
+        const row = this.db.prepare(query).get(...params);
+        return row.cnt;
+    }
+    listJobsPaginated(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.countJobs(filters);
+        const total_pages = Math.ceil(total / per_page);
+        const params = [];
+        let query = 'SELECT * FROM chronos_jobs WHERE 1=1';
+        if (filters?.enabled !== undefined) {
+            query += ' AND enabled = ?';
+            params.push(filters.enabled ? 1 : 0);
+        }
+        if (filters?.created_by) {
+            query += ' AND created_by = ?';
+            params.push(filters.created_by);
+        }
+        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((r) => this.deserializeJob(r)), total, page, per_page, total_pages };
+    }
     updateJob(id, patch) {
         const now = Date.now();
         const sets = ['updated_at = ?'];

package/dist/runtime/keymaker.js

@@ -8,7 +8,7 @@ import { Construtor } from "./tools/factory.js";
 import { morpheusTools } from "./tools/index.js";
 import { SkillRegistry } from "./skills/registry.js";
 import { TaskRequestContext } from "./tasks/context.js";
-import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
+import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from "./subagent-utils.js";
 /**
  * Keymaker is a specialized agent for executing skills.
  * "The one who opens any door" - has access to ALL tools:
@@ -122,38 +122,14 @@ CRITICAL — NEVER FABRICATE DATA:
             const content = typeof lastMessage.content === "string"
                 ? lastMessage.content
                 : JSON.stringify(lastMessage.content);
-            // Persist message with token usage metadata (like Trinity/Neo/Apoc)
             const keymakerConfig = this.config.keymaker || this.config.llm;
             const targetSession = taskContext?.session_id ?? "keymaker";
-            const rawUsage = lastMessage.usage_metadata
-                ?? lastMessage.response_metadata?.usage
-                ?? lastMessage.response_metadata?.tokenUsage
-                ?? lastMessage.usage;
-            const history = new SQLiteChatMessageHistory({ sessionId: targetSession });
-            try {
-                const persisted = new AIMessage(content);
-                if (rawUsage)
-                    persisted.usage_metadata = rawUsage;
-                persisted.provider_metadata = { provider: keymakerConfig.provider, model: keymakerConfig.model };
-                persisted.agent_metadata = { agent: 'keymaker' };
-                persisted.duration_ms = durationMs;
-                await history.addMessage(persisted);
-            }
-            finally {
-                history.close();
-            }
+            const rawUsage = extractRawUsage(lastMessage);
+            const stepCount = response.messages.filter((m) => m instanceof AIMessage).length;
+            await persistAgentMessage('keymaker', content, keymakerConfig, targetSession, rawUsage, durationMs);
+            emitToolAuditEvents(response.messages.slice(2), targetSession, 'keymaker');
             this.display.log(`Keymaker completed skill "${this.skillName}" execution`, { source: "Keymaker" });
-            return {
-                output: content,
-                usage: {
-                    provider: keymakerConfig.provider,
-                    model: keymakerConfig.model,
-                    inputTokens: rawUsage?.input_tokens ?? 0,
-                    outputTokens: rawUsage?.output_tokens ?? 0,
-                    durationMs,
-                    stepCount: response.messages.filter((m) => m instanceof AIMessage).length,
-                },
-            };
+            return buildAgentResult(content, keymakerConfig, rawUsage, durationMs, stepCount);
         }
         catch (err) {
             this.display.log(`Keymaker execution error: ${err.message}`, { source: "Keymaker", level: "error" });

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

@@ -413,6 +413,43 @@ export class SatiRepository {
         const rows = this.db.prepare('SELECT * FROM long_term_memory WHERE archived = 0 ORDER BY created_at DESC').all();
         return rows.map(this.mapRowToRecord);
     }
+    buildMemoryFilterQuery(filters) {
+        const params = [];
+        let where = 'WHERE archived = 0';
+        if (filters?.category) {
+            where += ' AND category = ?';
+            params.push(filters.category);
+        }
+        if (filters?.importance) {
+            where += ' AND importance = ?';
+            params.push(filters.importance);
+        }
+        if (filters?.search) {
+            where += ' AND (summary LIKE ? OR details LIKE ? OR category LIKE ?)';
+            const pattern = `%${filters.search}%`;
+            params.push(pattern, pattern, pattern);
+        }
+        return { where, params };
+    }
+    countMemories(filters) {
+        if (!this.db)
+            this.initialize();
+        const { where, params } = this.buildMemoryFilterQuery(filters);
+        const row = this.db.prepare(`SELECT COUNT(*) as cnt FROM long_term_memory ${where}`).get(...params);
+        return row.cnt;
+    }
+    getMemoriesPaginated(filters) {
+        if (!this.db)
+            this.initialize();
+        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.countMemories(filters);
+        const total_pages = Math.ceil(total / per_page);
+        const { where, params } = this.buildMemoryFilterQuery(filters);
+        const rows = this.db.prepare(`SELECT * FROM long_term_memory ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, per_page, offset);
+        return { data: rows.map(this.mapRowToRecord), total, page, per_page, total_pages };
+    }
     mapRowToRecord(row) {
         return {
             id: row.id,

package/dist/runtime/memory/sqlite.js

@@ -204,6 +204,19 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         catch (error) {
             console.warn(`[SQLite] Migration check failed: ${error}`);
         }
+        // Migrate model_pricing table
+        try {
+            const pricingInfo = this.db.pragma('table_info(model_pricing)');
+            const pricingCols = new Set(pricingInfo.map(c => c.name));
+            if (!pricingCols.has('audio_cost_per_second')) {
+                this.db.exec('ALTER TABLE model_pricing ADD COLUMN audio_cost_per_second REAL');
+                // Seed Whisper pricing: $0.006/minute = $0.0001/second
+                this.db.prepare('INSERT OR IGNORE INTO model_pricing (provider, model, input_price_per_1m, output_price_per_1m, audio_cost_per_second) VALUES (?, ?, ?, ?, ?)').run('openai', 'whisper-1', 0, 0, 0.0001);
+            }
+        }
+        catch (error) {
+            console.warn(`[SQLite] model_pricing migration failed: ${error}`);
+        }
     }
     /**
      * Retrieves all messages for the current session from the database.
@@ -301,7 +314,7 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         }
         try {
             const placeholders = sessionIds.map(() => '?').join(', ');
-            const stmt = this.db.prepare(`SELECT id, session_id, type, content, created_at, input_tokens, output_tokens, total_tokens, cache_read_tokens, provider, model, agent, duration_ms
+            const stmt = this.db.prepare(`SELECT id, session_id, type, content, created_at, input_tokens, output_tokens, total_tokens, cache_read_tokens, provider, model, agent, duration_ms, audio_duration_seconds
          FROM messages
          WHERE session_id IN (${placeholders})
          ORDER BY id DESC
@@ -648,11 +661,11 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     }
     // --- Model Pricing CRUD ---
     listModelPricing() {
-        const rows = this.db.prepare('SELECT provider, model, input_price_per_1m, output_price_per_1m FROM model_pricing ORDER BY provider, model').all();
+        const rows = this.db.prepare('SELECT provider, model, input_price_per_1m, output_price_per_1m, audio_cost_per_second FROM model_pricing ORDER BY provider, model').all();
         return rows;
     }
     upsertModelPricing(entry) {
-        this.db.prepare('INSERT INTO model_pricing (provider, model, input_price_per_1m, output_price_per_1m) VALUES (?, ?, ?, ?) ON CONFLICT(provider, model) DO UPDATE SET input_price_per_1m = excluded.input_price_per_1m, output_price_per_1m = excluded.output_price_per_1m').run(entry.provider, entry.model, entry.input_price_per_1m, entry.output_price_per_1m);
+        this.db.prepare('INSERT INTO model_pricing (provider, model, input_price_per_1m, output_price_per_1m, audio_cost_per_second) VALUES (?, ?, ?, ?, ?) ON CONFLICT(provider, model) DO UPDATE SET input_price_per_1m = excluded.input_price_per_1m, output_price_per_1m = excluded.output_price_per_1m, audio_cost_per_second = excluded.audio_cost_per_second').run(entry.provider, entry.model, entry.input_price_per_1m, entry.output_price_per_1m, entry.audio_cost_per_second ?? null);
     }
     deleteModelPricing(provider, model) {
         const result = this.db.prepare('DELETE FROM model_pricing WHERE provider = ? AND model = ?').run(provider, model);

package/dist/runtime/neo.js

@@ -5,12 +5,50 @@ import { ProviderError } from "./errors.js";
 import { DisplayManager } from "./display.js";
 import { Construtor } from "./tools/factory.js";
 import { morpheusTools } from "./tools/index.js";
-import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
 import { TaskRequestContext } from "./tasks/context.js";
-import { updateNeoDelegateToolDescription } from "./tools/neo-tool.js";
+import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from "./subagent-utils.js";
+import { buildDelegationTool } from "./tools/delegation-utils.js";
+// Internal Morpheus tools get 'tool_call' event type; MCP tools get 'mcp_tool'
+const MORPHEUS_TOOL_NAMES = new Set(morpheusTools.map((t) => t.name));
+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.)
+• Diagnostics: diagnostic_check — full system health report (config, databases, LLM provider, logs)
+• Analytics: message_count, token_usage, provider_model_usage — message counts and token/cost usage stats
+• Tasks: task_query — look up task status by id or session
+• MCP Management: mcp_list, mcp_manage — list/add/update/delete/enable/disable MCP servers; use action "reload" to reload tools across all agents after config changes
+• Webhooks: webhook_list, webhook_manage — create/update/delete webhooks; create returns api_key`.trim();
+const NEO_BASE_DESCRIPTION = `Delegate execution to Neo asynchronously.
+
+This tool creates a background task and returns an acknowledgement with task id.
+Use it for any request that requires Neo's built-in capabilities or a runtime MCP tool listed below.
+Each delegated task must contain one atomic objective.
+
+${NEO_BUILTIN_CAPABILITIES}`;
+function normalizeDescription(text) {
+    if (!text)
+        return "No description";
+    return text.replace(/\s+/g, " ").trim();
+}
+function buildCatalogSection(mcpTools) {
+    if (mcpTools.length === 0) {
+        return "\n\nRuntime MCP tools: none currently loaded.";
+    }
+    const maxItems = 500;
+    const lines = mcpTools.slice(0, maxItems).map((t) => {
+        const desc = normalizeDescription(t.description).slice(0, 120);
+        return `- ${t.name}: ${desc}`;
+    });
+    const hidden = mcpTools.length - lines.length;
+    if (hidden > 0) {
+        lines.push(`- ... and ${hidden} more tools`);
+    }
+    return `\n\nRuntime MCP tools:\n${lines.join("\n")}`;
+}
 export class Neo {
     static instance = null;
     static currentSessionId = undefined;
+    static _delegateTool = null;
     agent;
     config;
     display = DisplayManager.getInstance();
@@ -28,17 +66,25 @@ export class Neo {
     }
     static resetInstance() {
         Neo.instance = null;
+        Neo._delegateTool = null;
     }
     static async refreshDelegateCatalog() {
         const mcpTools = await Construtor.create(() => Neo.currentSessionId);
-        updateNeoDelegateToolDescription(mcpTools);
+        if (Neo._delegateTool) {
+            const full = `${NEO_BASE_DESCRIPTION}${buildCatalogSection(mcpTools)}`;
+            Neo._delegateTool.description = full;
+        }
     }
     async initialize() {
         const neoConfig = this.config.neo || this.config.llm;
         const personality = this.config.neo?.personality || 'analytical_engineer';
         const mcpTools = await Construtor.create(() => Neo.currentSessionId);
         const tools = [...mcpTools, ...morpheusTools];
-        updateNeoDelegateToolDescription(mcpTools);
+        // Update delegate tool description with current catalog
+        if (Neo._delegateTool) {
+            const full = `${NEO_BASE_DESCRIPTION}${buildCatalogSection(mcpTools)}`;
+            Neo._delegateTool.description = full;
+        }
         this.display.log(`Neo initialized with ${tools.length} tools (personality: ${personality}).`, { source: "Neo" });
         try {
             this.agent = await ProviderFactory.create(neoConfig, tools);
@@ -89,6 +135,7 @@ ${context ? `Context:\n${context}` : ""}
                 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 }));
             const durationMs = Date.now() - startMs;
@@ -96,44 +143,41 @@ ${context ? `Context:\n${context}` : ""}
             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 rawUsage = extractRawUsage(lastMessage);
             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);
-                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();
-            }
+            await persistAgentMessage('neo', content, neoConfig, targetSession, rawUsage, durationMs);
+            emitToolAuditEvents(response.messages.slice(inputCount), targetSession, 'neo', {
+                defaultEventType: 'mcp_tool',
+                internalToolNames: MORPHEUS_TOOL_NAMES,
+            });
             this.display.log("Neo task completed.", { source: "Neo" });
-            return {
-                output: content,
-                usage: {
-                    provider: neoConfig.provider,
-                    model: neoConfig.model,
-                    inputTokens,
-                    outputTokens,
-                    durationMs,
-                    stepCount,
-                },
-            };
+            return buildAgentResult(content, neoConfig, rawUsage, durationMs, stepCount);
         }
         catch (err) {
             throw new ProviderError(neoConfig.provider, err, "Neo task execution failed");
         }
     }
+    createDelegateTool() {
+        if (!Neo._delegateTool) {
+            Neo._delegateTool = buildDelegationTool({
+                name: "neo_delegate",
+                description: NEO_BASE_DESCRIPTION,
+                agentKey: "neo",
+                agentLabel: "Neo",
+                auditAgent: "neo",
+                isSync: () => ConfigManager.getInstance().get().neo?.execution_mode === 'sync',
+                notifyText: '🥷 Neo is executing your request...',
+                executeSync: (task, context, sessionId, ctx) => Neo.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 Neo._delegateTool;
+    }
     async reload() {
         this.config = ConfigManager.getInstance().get();
         this.agent = undefined;

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;
@@ -152,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);
@@ -416,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 = {
@@ -628,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/smiths/delegator.js

@@ -7,6 +7,8 @@ import { ConfigManager } from '../../config/manager.js';
 import { ProviderFactory } from '../providers/factory.js';
 import { buildDevKit } from '../../devkit/index.js';
 import { SQLiteChatMessageHistory } from '../memory/sqlite.js';
+import { AuditRepository } from '../audit/repository.js';
+import { TaskRequestContext } from '../tasks/context.js';
 /**
  * SmithDelegator — delegates natural-language tasks to a specific Smith.
  *
@@ -70,6 +72,25 @@ export class SmithDelegator {
             connection.onMessage(progressHandler);
             try {
                 const result = await connection.sendTask(taskId, localTool.name, args);
+                // Audit the remote tool execution — data already available from Smith's response
+                const sessionId = TaskRequestContext.get()?.session_id ?? 'smith';
+                const resultStr = result.data !== undefined
+                    ? (typeof result.data === 'string' ? result.data : JSON.stringify(result.data))
+                    : result.error;
+                const meta = { smith: smithName };
+                if (args && Object.keys(args).length > 0)
+                    meta.args = args;
+                if (resultStr)
+                    meta.result = resultStr.length > 500 ? resultStr.slice(0, 500) + '…' : resultStr;
+                AuditRepository.getInstance().insert({
+                    session_id: sessionId,
+                    event_type: 'tool_call',
+                    agent: 'smith',
+                    tool_name: `${smithName}/${localTool.name}`,
+                    duration_ms: result.duration_ms,
+                    status: result.success ? 'success' : 'error',
+                    metadata: meta,
+                });
                 if (result.success) {
                     return typeof result.data === 'string'
                         ? result.data

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