morpheus-cli 0.9.41 → 0.9.51

package/dist/channels/discord.js

@@ -331,7 +331,7 @@ export class DiscordAdapter {
                         this.display.startActivity('telephonist', 'Synthesizing TTS...');
                         const ttsApiKey = getUsableApiKey(ttsConfig.apiKey) ||
                             getUsableApiKey(config.audio.apiKey) ||
-                            (config.llm.provider === (ttsConfig.provider === 'google' ? 'gemini' : ttsConfig.provider)
+                            (config.llm.provider === ttsConfig.provider
                                 ? getUsableApiKey(config.llm.api_key) : undefined);
                         const ttsResult = await this.ttsTelephonist.synthesize(response, ttsApiKey || '', ttsConfig.voice, ttsConfig.style_prompt);
                         ttsFilePath = ttsResult.filePath;

package/dist/channels/telegram.js

@@ -1921,7 +1921,7 @@ How can I assist you today?`;
                 this.display.startActivity('telephonist', 'Synthesizing TTS...');
                 const ttsApiKey = getUsableApiKey(ttsConfig.apiKey) ||
                     getUsableApiKey(config.audio.apiKey) ||
-                    (config.llm.provider === (ttsConfig.provider === 'google' ? 'gemini' : ttsConfig.provider)
+                    (config.llm.provider === ttsConfig.provider
                         ? getUsableApiKey(config.llm.api_key) : undefined);
                 const ttsResult = await this.ttsTelephonist.synthesize(response, ttsApiKey || '', ttsConfig.voice, ttsConfig.style_prompt);
                 ttsFilePath = ttsResult.filePath;

package/dist/config/manager.js

@@ -162,6 +162,7 @@ export class ConfigManager {
                 enabled_archived_sessions: resolveBoolean('MORPHEUS_SATI_ENABLED_ARCHIVED_SESSIONS', config.sati.enabled_archived_sessions, true),
                 similarity_threshold: resolveNumeric('MORPHEUS_SATI_SIMILARITY_THRESHOLD', config.sati.similarity_threshold, 0.9),
                 evaluation_interval: resolveNumeric('MORPHEUS_SATI_EVALUATION_INTERVAL', config.sati.evaluation_interval, 1),
+                chunk_size: resolveNumeric('MORPHEUS_SATI_CHUNK_SIZE', config.sati.chunk_size, 500),
             };
         }
         // Apply precedence to Apoc config
@@ -282,13 +283,13 @@ export class ConfigManager {
         }
         // Apply precedence to audio config
         const audioProvider = resolveString('MORPHEUS_AUDIO_PROVIDER', config.audio.provider, DEFAULT_CONFIG.audio.provider);
-        // AudioProvider uses 'google' but resolveApiKey expects LLMProvider which uses 'gemini'
-        const audioProviderForKey = (audioProvider === 'google' ? 'gemini' : audioProvider);
+        // AudioProvider uses 'gemini' which maps to LLMProvider 'gemini' (already compatible)
+        const audioProviderForKey = audioProvider;
         // TTS config
         const ttsDefaults = DEFAULT_CONFIG.audio.tts;
         const ttsCfg = config.audio.tts;
         const ttsProvider = resolveString('MORPHEUS_AUDIO_TTS_PROVIDER', ttsCfg?.provider, ttsDefaults.provider);
-        const ttsProviderForKey = (ttsProvider === 'google' ? 'gemini' : ttsProvider);
+        const ttsProviderForKey = ttsProvider;
         const ttsConfig = {
             enabled: resolveBoolean('MORPHEUS_AUDIO_TTS_ENABLED', ttsCfg?.enabled, ttsDefaults.enabled),
             provider: ttsProvider,
@@ -449,14 +450,16 @@ export class ConfigManager {
     getSatiConfig() {
         if (this.config.sati) {
             return {
-                memory_limit: 10, // Default if undefined
+                memory_limit: 10,
+                chunk_size: 500,
                 ...this.config.sati
             };
         }
         // Fallback to main LLM config
         return {
             ...this.config.llm,
-            memory_limit: 10 // Default fallback
+            memory_limit: 10,
+            chunk_size: 500,
         };
     }
     getApocConfig() {

package/dist/config/schemas.js

@@ -2,14 +2,14 @@ import { z } from 'zod';
 import { DEFAULT_CONFIG } from '../types/config.js';
 export const TtsConfigSchema = z.object({
     enabled: z.boolean().default(false),
-    provider: z.enum(['openai', 'google']).default('google'),
+    provider: z.enum(['openai', 'gemini']).default('gemini'),
     model: z.string().min(1).default('gemini-2.5-flash-preview-tts'),
     voice: z.string().min(1).default('Kore'),
     apiKey: z.string().optional(),
     style_prompt: z.string().optional(),
 });
 export const AudioConfigSchema = z.object({
-    provider: z.enum(['google', 'openai', 'openrouter', 'ollama']).default(DEFAULT_CONFIG.audio.provider),
+    provider: z.enum(['gemini', 'openai', 'openrouter', 'ollama']).default(DEFAULT_CONFIG.audio.provider),
     model: z.string().min(1).default(DEFAULT_CONFIG.audio.model),
     enabled: z.boolean().default(DEFAULT_CONFIG.audio.enabled),
     apiKey: z.string().optional(),
@@ -30,8 +30,11 @@ export const LLMConfigSchema = z.object({
 export const SatiConfigSchema = LLMConfigSchema.extend({
     memory_limit: z.number().int().positive().optional(),
     enabled_archived_sessions: z.boolean().default(true),
-    similarity_threshold: z.number().min(0).max(1).default(0.9),
+    similarity_threshold: z.number().min(0).max(1).default(0.7),
     evaluation_interval: z.number().int().min(1).default(1),
+    chunk_size: z.number().int().positive().default(500),
+    session_chunk_limit: z.number().int().positive().optional(),
+    max_memory_tokens: z.number().int().positive().optional(),
 });
 export const ApocConfigSchema = LLMConfigSchema.extend({
     working_dir: z.string().optional(),

package/dist/runtime/__tests__/manual_start_verify.js

@@ -12,7 +12,7 @@ const mockConfig = {
     ui: { enabled: false, port: 3333 },
     logging: { enabled: false, level: 'info', retention: '1d' },
     audio: {
-        provider: 'google',
+        provider: 'gemini',
         model: 'gemini-2.5-flash-lite',
         enabled: false,
         maxDurationSeconds: 60,

package/dist/runtime/__tests__/telephonist-tts.test.js

@@ -12,10 +12,10 @@ describe('createTtsTelephonist', () => {
         expect(telephonist).toBeDefined();
         expect(typeof telephonist.synthesize).toBe('function');
     });
-    it('returns an instance with synthesize() for google provider', () => {
+    it('returns an instance with synthesize() for gemini provider', () => {
         const telephonist = createTtsTelephonist({
             enabled: true,
-            provider: 'google',
+            provider: 'gemini',
             model: 'gemini-2.5-flash',
             voice: 'Kore',
         });

package/dist/runtime/hot-reload.js

@@ -9,6 +9,7 @@ import { ConfigManager } from '../config/manager.js';
 import { DisplayManager } from './display.js';
 import { SubagentRegistry } from './subagents/registry.js';
 import { SkillRegistry } from './skills/index.js';
+import { SQLiteChatMessageHistory } from './memory/sqlite.js';
 let currentOracle = null;
 /**
  * Register the current Oracle instance for hot-reload.
@@ -51,6 +52,10 @@ export async function hotReloadConfig() {
         const agentNames = SubagentRegistry.getAll().map(r => r.label);
         reinitialized.push(...agentNames);
         display.log(`Subagents reloaded: ${agentNames.join(', ')}`, { source: 'HotReload', level: 'info' });
+        // 4. Clear message cache to prevent stale tool_calls causing Gemini 400 errors
+        // This ensures the next chat() call re-fetches from DB with proper sanitization
+        SQLiteChatMessageHistory.clearCache();
+        display.log('Message cache cleared', { source: 'HotReload', level: 'info' });
         return {
             success: true,
             reinitialized,

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

@@ -2,6 +2,7 @@ import { AIMessage } from "@langchain/core/messages";
 import { SatiService } from "./service.js";
 import { DisplayManager } from "../../display.js";
 import { AuditRepository } from "../../audit/repository.js";
+import { ConfigManager } from "../../../config/manager.js";
 const display = DisplayManager.getInstance();
 export class SatiMemoryMiddleware {
     service;
@@ -38,10 +39,21 @@ export class SatiMemoryMiddleware {
                 display.log('No relevant memories found', { source: 'Sati' });
                 return null;
             }
-            const memoryContext = result.relevant_memories
+            // Apply token budget: stop adding memories once we exceed the char limit.
+            const satiConfig = ConfigManager.getInstance().getSatiConfig();
+            const maxMemoryChars = (satiConfig.max_memory_tokens ?? 3000) * 4;
+            let usedChars = 0;
+            const budgetedMemories = result.relevant_memories.filter(m => {
+                const cost = m.summary.length + m.category.length + 20;
+                if (usedChars + cost > maxMemoryChars)
+                    return false;
+                usedChars += cost;
+                return true;
+            });
+            const memoryContext = budgetedMemories
                 .map(m => `- [${m.category.toUpperCase()}] ${m.summary}`)
                 .join('\n');
-            display.log(`Retrieved ${result.relevant_memories.length} memories.`, { source: 'Sati' });
+            display.log(`Retrieved ${budgetedMemories.length}/${result.relevant_memories.length} memories (budget: ~${Math.round(usedChars / 4)} tokens).`, { source: 'Sati' });
             return new AIMessage(`
                 ### LONG-TERM MEMORY (SATI)
                 The following information was retrieved from previous sessions. Use it if relevant:

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

@@ -209,19 +209,24 @@ export class SatiRepository {
     searchUnifiedVector(embedding, limit) {
         if (!this.db)
             return [];
-        const SIMILARITY_THRESHOLD = ConfigManager.getInstance().getSatiConfig().similarity_threshold ?? 0.9;
+        const satiConfig = ConfigManager.getInstance().getSatiConfig();
+        const SIMILARITY_THRESHOLD = satiConfig.similarity_threshold ?? 0.7;
+        // Fetch a larger candidate pool so post-filtering still has enough results.
+        // weighted_score is used for ranking; cosine_similarity is used for threshold filtering.
+        const candidateLimit = limit * 10;
         const stmt = this.db.prepare(`
     SELECT *
     FROM (
       -- LONG TERM MEMORY
-      SELECT 
+      SELECT
         m.id as id,
         m.summary as summary,
         m.details as details,
         m.category as category,
         m.importance as importance,
         'long_term' as source_type,
-        (1 - vec_distance_cosine(v.embedding, ?)) * 0.8 as distance
+        (1 - vec_distance_cosine(v.embedding, ?)) as cosine_similarity,
+        (1 - vec_distance_cosine(v.embedding, ?)) * 0.8 as weighted_score
       FROM memory_vec v
       JOIN memory_embedding_map map ON map.vec_rowid = v.rowid
       JOIN long_term_memory m ON m.id = map.memory_id
@@ -230,42 +235,35 @@ export class SatiRepository {
       UNION ALL
 
       -- SESSION CHUNKS
-      SELECT 
+      SELECT
         sc.id as id,
         sc.content as summary,
         sc.content as details,
         'session' as category,
         'medium' as importance,
         'session_chunk' as source_type,
-        (1 - vec_distance_cosine(v.embedding, ?)) * 0.2 as distance
+        (1 - vec_distance_cosine(v.embedding, ?)) as cosine_similarity,
+        (1 - vec_distance_cosine(v.embedding, ?)) * 0.2 as weighted_score
       FROM session_vec v
       JOIN session_embedding_map map ON map.vec_rowid = v.rowid
       JOIN session_chunks sc ON sc.id = map.session_chunk_id
     )
-    ORDER BY distance ASC
+    ORDER BY weighted_score DESC
     LIMIT ?
   `);
-        const rows = stmt.all(new Float32Array(embedding), new Float32Array(embedding), limit);
-        // console.log(
-        //   `[SatiRepository] Unified vector search returned ${rows.length} raw results`
-        // );
-        // console each row
-        // rows.forEach((row, index) => {
-        //   console.log(`[SatiRepository] Row ${index + 1}:`, row);
-        // });
-        // Note: the SQL query already computes distance as (1 - cosine_distance) * weight,
-        // so higher values mean higher similarity. Use distance directly as similarity score.
-        const ranked = rows
-            .map(r => ({
-            ...r,
-            similarity: 1 - r.distance
-        }))
-            .sort((a, b) => b.similarity - a.similarity);
-        const filtered = ranked
-            .filter(r => r.similarity >= SIMILARITY_THRESHOLD)
-            .sort((a, b) => b.similarity - a.similarity);
-        this.display.log(`🧠 Unified vector search retornou ${filtered.length} resultados`, { source: 'Sati', level: 'debug' });
-        return filtered.map(r => ({
+        const rows = stmt.all(new Float32Array(embedding), new Float32Array(embedding), new Float32Array(embedding), new Float32Array(embedding), candidateLimit);
+        // Filter by raw cosine similarity (not the weighted score) so the threshold
+        // is independent of the long-term vs. session-chunk weighting.
+        const filtered = rows.filter(r => r.cosine_similarity >= SIMILARITY_THRESHOLD);
+        // Cap session chunks to avoid flooding from large archived sessions.
+        const chunkCap = satiConfig.session_chunk_limit ?? Math.ceil(limit * 0.3);
+        const longTerm = filtered.filter(r => r.source_type === 'long_term');
+        const chunks = filtered.filter(r => r.source_type === 'session_chunk');
+        const combined = [...longTerm, ...chunks.slice(0, chunkCap)]
+            .sort((a, b) => b.weighted_score - a.weighted_score)
+            .slice(0, limit);
+        this.display.log(`🧠 Unified vector search: ${filtered.length} acima do threshold (${longTerm.length} long-term, ${Math.min(chunks.length, chunkCap)} chunks) → ${combined.length} retornados`, { source: 'Sati', level: 'debug' });
+        return combined.map(r => ({
             id: r.id,
             summary: r.summary,
             details: r.details,
@@ -374,7 +372,7 @@ export class SatiRepository {
             this.display.log('🧵  Tentando fallback LIKE...', { source: 'Sati', level: 'debug' });
             const likeStmt = this.db.prepare(`
       SELECT * FROM long_term_memory
-      WHERE (summary LIKE ? OR details LIKE ?) 
+      WHERE (summary LIKE ? OR details LIKE ?)
       AND archived = 0
       ORDER BY importance DESC, access_count DESC
       LIMIT ?

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

@@ -8,6 +8,7 @@ const SHORT_DB_PATH = path.join(homedir(), '.morpheus', 'memory', 'short-memory.
 const SATI_DB_PATH = path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db');
 const EMBEDDING_DIM = 384;
 const BATCH_LIMIT = 5;
+const PARALLEL_CHUNKS = 50;
 export async function runSessionEmbeddingWorker() {
     const display = DisplayManager.getInstance();
     // display.log('🚀 Iniciando worker de embeddings de sessões...', { source: 'SessionEmbeddingWorker' });
@@ -62,15 +63,22 @@ export async function runSessionEmbeddingWorker() {
           (session_chunk_id, vec_rowid)
           VALUES (?, ?)
         `);
-                    for (const chunk of chunks) {
-                        display.log(`   ↳ Embedding chunk ${chunk.id}`, { source: 'SessionEmbeddingWorker' });
-                        const embedding = await embeddingService.generate(chunk.content);
-                        if (!embedding || embedding.length !== EMBEDDING_DIM) {
-                            throw new Error(`Embedding inválido. Esperado ${EMBEDDING_DIM}, recebido ${embedding?.length}`);
+                    display.log(`   ↳ Processando ${chunks.length} chunks em paralelo (${PARALLEL_CHUNKS})...`, { source: 'SessionEmbeddingWorker' });
+                    for (let i = 0; i < chunks.length; i += PARALLEL_CHUNKS) {
+                        const batch = chunks.slice(i, i + PARALLEL_CHUNKS);
+                        const batchEmbeddings = await Promise.all(batch.map(async (chunk) => {
+                            const embedding = await embeddingService.generate(chunk.content);
+                            return { chunkId: chunk.id, embedding };
+                        }));
+                        for (const { chunkId, embedding } of batchEmbeddings) {
+                            if (!embedding || embedding.length !== EMBEDDING_DIM) {
+                                throw new Error(`Embedding inválido. Esperado ${EMBEDDING_DIM}, recebido ${embedding?.length}`);
+                            }
+                            const result = insertVec.run(new Float32Array(embedding));
+                            const vecRowId = result.lastInsertRowid;
+                            insertMap.run(chunkId, vecRowId);
                         }
-                        const result = insertVec.run(new Float32Array(embedding));
-                        const vecRowId = result.lastInsertRowid;
-                        insertMap.run(chunk.id, vecRowId);
+                        display.log(`   ↳ Batch ${Math.floor(i / PARALLEL_CHUNKS) + 1}/${Math.ceil(chunks.length / PARALLEL_CHUNKS)} concluído`, { source: 'SessionEmbeddingWorker' });
                     }
                     // ✅ finalizar sessão
                     shortDb.prepare(`

package/dist/runtime/memory/sqlite.js

@@ -3,6 +3,7 @@ import { HumanMessage, AIMessage, SystemMessage, ToolMessage } from "@langchain/
 import Database from "better-sqlite3";
 import fs from "fs-extra";
 import * as path from "path";
+import { ConfigManager } from "../../config/manager.js";
 import { PATHS } from "../../config/paths.js";
 import { randomUUID } from 'crypto';
 import { DisplayManager } from "../display.js";
@@ -39,6 +40,10 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     static invalidateCacheForSession(sessionId) {
         SQLiteChatMessageHistory._cache.delete(sessionId);
     }
+    /** Clear the entire message cache. Called during hot-reload to prevent stale tool_calls. */
+    static clearCache() {
+        SQLiteChatMessageHistory._cache.clear();
+    }
     /** Prepend new messages (newest-first order) to an existing cache entry. */
     static _appendToCache(sessionId, newMessages) {
         if (!sessionId || newMessages.length === 0)
@@ -201,11 +206,11 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
           ('openai', 'gpt-3.5-turbo', 0.5, 1.5),
           ('openai', 'o1', 15.0, 60.0),
           ('openai', 'o1-mini', 3.0, 12.0),
-          ('google', 'gemini-2.5-flash', 0.15, 0.6),
-          ('google', 'gemini-2.5-flash-lite', 0.075, 0.3),
-          ('google', 'gemini-2.0-flash', 0.1, 0.4),
-          ('google', 'gemini-1.5-pro', 1.25, 5.0),
-          ('google', 'gemini-1.5-flash', 0.075, 0.3);
+          ('gemini', 'gemini-2.5-flash', 0.15, 0.6),
+          ('gemini', 'gemini-2.5-flash-lite', 0.075, 0.3),
+          ('gemini', 'gemini-2.0-flash', 0.1, 0.4),
+          ('gemini', 'gemini-1.5-pro', 1.25, 5.0),
+          ('gemini', 'gemini-1.5-flash', 0.075, 0.3);
 
         CREATE TABLE IF NOT EXISTS model_presets (
           id          TEXT PRIMARY KEY,
@@ -281,6 +286,17 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         catch (error) {
             console.warn(`[SQLite] model_pricing migration failed: ${error}`);
         }
+        // Migration: rename 'google' provider to 'gemini' for consistency
+        // This ensures existing model_pricing records work with the unified 'gemini' provider
+        try {
+            const result = this.db.prepare("UPDATE model_pricing SET provider = 'gemini' WHERE provider = 'google'").run();
+            if (result.changes > 0) {
+                console.log(`[SQLite] Migrated ${result.changes} model_pricing records from 'google' to 'gemini'`);
+            }
+        }
+        catch (error) {
+            console.warn(`[SQLite] google->gemini migration failed: ${error}`);
+        }
         // Ensure model_presets table exists for databases created before this feature
         try {
             this.db.exec(`
@@ -1031,7 +1047,7 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
           );
           CREATE INDEX IF NOT EXISTS idx_session_chunks_session_id ON session_chunks(session_id);
         `);
-                const chunks = this.chunkText(sessionText);
+                const chunks = this.chunkText(sessionText, ConfigManager.getInstance().getSatiConfig().chunk_size ?? 500);
                 const now = Date.now();
                 const insert = dbSati.prepare(`
           INSERT INTO session_chunks (id, session_id, chunk_index, content, created_at)

package/dist/runtime/migration.js

@@ -29,6 +29,8 @@ export async function migrateConfigFile() {
     await migrateContextWindow();
     // Migrate santi -> sati
     await migrateSantiToSati();
+    // Migrate google -> gemini in audio and tts providers
+    await migrateGoogleToGemini();
 }
 /**
  * Migrates memory.limit to llm.context_window
@@ -118,3 +120,46 @@ async function migrateSantiToSati() {
         });
     }
 }
+/**
+ * Migrates audio.provider and audio.tts.provider from 'google' to 'gemini'
+ * Ensures consistency across the system (LLMs and audio use 'gemini' as provider)
+ */
+async function migrateGoogleToGemini() {
+    const display = DisplayManager.getInstance();
+    const configPath = PATHS.config;
+    try {
+        if (!await fs.pathExists(configPath)) {
+            return;
+        }
+        const configContent = await fs.readFile(configPath, 'utf8');
+        const config = yaml.load(configContent);
+        // Check if migration is needed
+        const needsMigration = config?.audio?.provider === 'google' ||
+            config?.audio?.tts?.provider === 'google';
+        if (!needsMigration) {
+            return;
+        }
+        // Create backup before migration
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupPath = `${configPath}.backup-${timestamp}`;
+        await fs.copy(configPath, backupPath);
+        display.log(`Created config backup: ${backupPath}`, { source: 'Migration', level: 'info' });
+        // Perform migration
+        if (config?.audio?.provider === 'google') {
+            config.audio.provider = 'gemini';
+        }
+        if (config?.audio?.tts?.provider === 'google') {
+            config.audio.tts.provider = 'gemini';
+        }
+        // Write migrated config
+        const migratedYaml = yaml.dump(config);
+        await fs.writeFile(configPath, migratedYaml, 'utf8');
+        display.log('Migrated audio providers: google → gemini', { source: 'Migration', level: 'info' });
+    }
+    catch (error) {
+        display.log(`Config migration (google->gemini) failed: ${error.message}`, {
+            source: 'Migration',
+            level: 'warning'
+        });
+    }
+}

package/dist/runtime/oracle.js

@@ -765,5 +765,8 @@ Use it to inform your response and tool selection (if needed), but do not assume
         ]);
         await SubagentRegistry.reloadAll();
         this.display.log(`Oracle and subagent tools reloaded`, { source: 'Oracle' });
+        // Clear message cache to prevent stale tool_calls from causing Gemini 400 errors
+        SQLiteChatMessageHistory.clearCache();
+        this.display.log(`Message cache cleared after tool reload`, { source: 'Oracle' });
     }
 }

package/dist/runtime/subagents/apoc.js

@@ -73,8 +73,8 @@ Use this tool when the user asks for ANY of the following:
                 delegateToolName: 'apoc_delegate', emoji: '🧑‍🔬', color: 'amber',
                 description: 'Filesystem, shell & browser',
                 colorClass: 'text-amber-600 dark:text-amber-400',
-                bgClass: 'bg-amber-50 dark:bg-amber-900/10',
-                badgeClass: 'bg-amber-100 text-amber-700 dark:bg-amber-900/40 dark:text-amber-300',
+                bgClass: 'bg-amber-50 dark:bg-amber-900/30',
+                badgeClass: 'bg-amber-100 text-amber-700 dark:bg-amber-800 dark:text-amber-200',
                 instance: Apoc.instance,
                 hasDynamicDescription: true,
                 isMultiInstance: false,

package/dist/runtime/subagents/link/link.js

@@ -64,8 +64,8 @@ export class Link {
                 delegateToolName: 'link_delegate', emoji: '🕵️‍♂️', color: 'indigo',
                 description: 'Document search & RAG',
                 colorClass: 'text-indigo-600 dark:text-indigo-400',
-                bgClass: 'bg-indigo-50 dark:bg-indigo-900/10',
-                badgeClass: 'bg-indigo-100 text-indigo-700 dark:bg-indigo-900/40 dark:text-indigo-300',
+                bgClass: 'bg-indigo-50 dark:bg-indigo-900/30',
+                badgeClass: 'bg-indigo-100 text-indigo-700 dark:bg-indigo-800 dark:text-indigo-200',
                 instance: Link.instance,
                 hasDynamicDescription: true,
                 isMultiInstance: false,

package/dist/runtime/subagents/link/worker.js

@@ -294,13 +294,13 @@ export class LinkWorker {
     }
     /**
      * Generate embeddings for chunks using Sati's EmbeddingService.
+     * Processes chunks in parallel batches for better performance.
      */
     async generateEmbeddings(chunks) {
         if (!this.embeddingService) {
             this.embeddingService = await EmbeddingService.getInstance();
         }
         const embeddings = [];
-        // Process in batches to avoid memory issues
         const batchSize = 50;
         for (let i = 0; i < chunks.length; i += batchSize) {
             const batch = chunks.slice(i, i + batchSize);
@@ -309,6 +309,7 @@ export class LinkWorker {
                 return { chunk_id: chunk.id, embedding };
             }));
             embeddings.push(...batchEmbeddings);
+            this.display.log(`Generated embeddings: batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(chunks.length / batchSize)} (${embeddings.length}/${chunks.length})`, { source: 'Link', level: 'debug' });
         }
         // Store embeddings in database
         this.repository.createEmbeddings(embeddings);

package/dist/runtime/subagents/neo.js

@@ -67,8 +67,8 @@ export class Neo {
                 delegateToolName: 'neo_delegate', emoji: '🥷', color: 'violet',
                 description: 'MCP tool orchestration',
                 colorClass: 'text-violet-600 dark:text-violet-400',
-                bgClass: 'bg-violet-50 dark:bg-violet-900/10',
-                badgeClass: 'bg-purple-100 text-purple-700 dark:bg-purple-900/40 dark:text-purple-300',
+                bgClass: 'bg-violet-50 dark:bg-violet-900/30',
+                badgeClass: 'bg-purple-100 text-purple-700 dark:bg-purple-800 dark:text-purple-200',
                 instance: Neo.instance,
                 hasDynamicDescription: true,
                 isMultiInstance: false,
@@ -161,8 +161,10 @@ ${context ? `Context:\n${context}` : ""}
             const stepCount = response.messages.filter((m) => m instanceof AIMessage).length;
             const targetSession = sessionId ?? Neo.currentSessionId ?? "neo";
             await persistAgentMessage('neo', content, neoConfig, targetSession, rawUsage, durationMs);
+            // MCP tools are already audited inline by instrumentMcpTool (with timing + args/result).
+            // Only emit audit events here for internal Morpheus tools (not MCP tools).
             emitToolAuditEvents(response.messages.slice(inputCount), targetSession, 'neo', {
-                defaultEventType: 'mcp_tool',
+                defaultEventType: undefined, // skip MCP tools — audited by instrumentMcpTool
                 internalToolNames: MORPHEUS_TOOL_NAMES,
             });
             this.display.log("Neo task completed.", { source: "Neo" });

package/dist/runtime/subagents/registry.js

@@ -8,32 +8,32 @@ export const SYSTEM_AGENTS = [
         delegateToolName: '', emoji: '🔮', color: 'blue',
         description: 'Root orchestrator',
         colorClass: 'text-blue-600 dark:text-blue-400',
-        bgClass: 'bg-blue-50 dark:bg-blue-900/10',
-        badgeClass: 'bg-blue-100 text-blue-700 dark:bg-blue-900/40 dark:text-blue-300',
+        bgClass: 'bg-blue-50 dark:bg-blue-900/30',
+        badgeClass: 'bg-blue-100 text-blue-700 dark:bg-blue-800 dark:text-blue-200',
     },
     {
         agentKey: 'chronos', auditAgent: 'chronos', label: 'Chronos',
         delegateToolName: '', emoji: '⏰', color: 'orange',
         description: 'Temporal scheduler',
         colorClass: 'text-orange-600 dark:text-orange-400',
-        bgClass: 'bg-orange-50 dark:bg-orange-900/10',
-        badgeClass: 'bg-orange-100 text-orange-700 dark:bg-orange-900/40 dark:text-orange-300',
+        bgClass: 'bg-orange-50 dark:bg-orange-900/30',
+        badgeClass: 'bg-orange-100 text-orange-700 dark:bg-orange-800 dark:text-orange-200',
     },
     {
         agentKey: 'sati', auditAgent: 'sati', label: 'Sati',
         delegateToolName: '', emoji: '🧠', color: 'emerald',
         description: 'Long-term memory',
         colorClass: 'text-emerald-600 dark:text-emerald-400',
-        bgClass: 'bg-emerald-50 dark:bg-emerald-900/10',
-        badgeClass: 'bg-emerald-100 text-emerald-700 dark:bg-emerald-900/40 dark:text-emerald-300',
+        bgClass: 'bg-emerald-50 dark:bg-emerald-900/30',
+        badgeClass: 'bg-emerald-100 text-emerald-700 dark:bg-emerald-800 dark:text-emerald-200',
     },
     {
         agentKey: 'telephonist', auditAgent: 'telephonist', label: 'Telephonist',
         delegateToolName: '', emoji: '📞', color: 'rose',
         description: 'Audio transcription',
         colorClass: 'text-rose-600 dark:text-rose-400',
-        bgClass: 'bg-rose-50 dark:bg-rose-900/10',
-        badgeClass: 'bg-rose-100 text-rose-700 dark:bg-rose-900/40 dark:text-rose-300',
+        bgClass: 'bg-rose-50 dark:bg-rose-900/30',
+        badgeClass: 'bg-rose-100 text-rose-700 dark:bg-rose-800 dark:text-rose-200',
     },
 ];
 /**

package/dist/runtime/subagents/trinity/trinity.js

@@ -58,8 +58,8 @@ export class Trinity {
                 delegateToolName: 'trinity_delegate', emoji: '👩‍💻', color: 'teal',
                 description: 'Database specialist',
                 colorClass: 'text-teal-600 dark:text-teal-400',
-                bgClass: 'bg-teal-50 dark:bg-teal-900/10',
-                badgeClass: 'bg-teal-100 text-teal-700 dark:bg-teal-900/40 dark:text-teal-300',
+                bgClass: 'bg-teal-50 dark:bg-teal-900/30',
+                badgeClass: 'bg-teal-100 text-teal-700 dark:bg-teal-800 dark:text-teal-200',
                 instance: Trinity.instance,
                 hasDynamicDescription: true,
                 isMultiInstance: false,

package/dist/runtime/subagents/utils.js

@@ -55,6 +55,8 @@ export function emitToolAuditEvents(messages, sessionId, agent, opts) {
                 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;
+                if (!eventType)
+                    continue; // no event type assigned — caller opted out for this tool
                 const meta = {};
                 if (tc.args && Object.keys(tc.args).length > 0)
                     meta.args = tc.args;

package/dist/runtime/telephonist.js

@@ -170,14 +170,14 @@ class OpenRouterTelephonist {
  * based on the audio provider configuration.
  *
  * Supported providers:
- * - google:     Google Gemini (native audio file upload)
+ * - gemini:     Google Gemini (native audio file upload)
  * - openai:     OpenAI Whisper API (/audio/transcriptions)
  * - openrouter: OpenRouter SDK with input_audio (multimodal models)
  * - ollama:     Ollama local Whisper via OpenAI-compatible endpoint
  */
 export function createTelephonist(config) {
     switch (config.provider) {
-        case 'google':
+        case 'gemini':
             return new GeminiTelephonist(config.model);
         case 'openai':
             return new WhisperTelephonist(config.model);
@@ -188,7 +188,7 @@ export function createTelephonist(config) {
             // Requires a Whisper model loaded: `ollama pull whisper`
             return new WhisperTelephonist(config.model, (config.base_url || 'http://localhost:11434') + '/v1');
         default:
-            throw new Error(`Unsupported audio provider: '${config.provider}'. Supported: google, openai, openrouter, ollama.`);
+            throw new Error(`Unsupported audio provider: '${config.provider}'. Supported: gemini, openai, openrouter, ollama.`);
     }
 }
 // ─── TTS Implementations ─────────────────────────────────────────────────────
@@ -334,16 +334,16 @@ class GeminiTtsTelephonist {
 }
 /**
  * Factory that creates an ITelephonist with TTS (synthesize) support.
- * Supports providers: openai, google.
+ * Supports providers: openai, gemini.
  */
 export function createTtsTelephonist(config) {
     switch (config.provider) {
         case 'openai':
             return new OpenAITtsTelephonist(config.model, config.voice);
-        case 'google':
+        case 'gemini':
             return new GeminiTtsTelephonist(config.model, config.voice);
         default:
-            throw new Error(`Unsupported TTS provider: '${config.provider}'. Supported: openai, google.`);
+            throw new Error(`Unsupported TTS provider: '${config.provider}'. Supported: openai, gemini.`);
     }
 }
 // ─── Legacy export for backward compatibility ─────────────────────────────────