morpheus-cli 0.9.32 → 0.9.33

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

@@ -12,6 +12,8 @@ const display = DisplayManager.getInstance();
 export class SatiService {
     repository;
     static instance;
+    cachedAgent = null;
+    cachedAgentConfigKey = null;
     constructor() {
         this.repository = SatiRepository.getInstance();
     }
@@ -59,9 +61,17 @@ export class SatiService {
             const satiConfig = ConfigManager.getInstance().getSatiConfig();
             if (!satiConfig)
                 return;
-            // Use the main provider factory to get an agent (Reusing Zion configuration)
-            // We pass empty tools as Sati is a pure reasoning agent here
-            const agent = await ProviderFactory.create(satiConfig, []);
+            // Reuse cached agent when config hasn't changed to avoid per-call overhead
+            const configKey = `${satiConfig.provider}:${satiConfig.model}`;
+            let agent;
+            if (this.cachedAgent && this.cachedAgentConfigKey === configKey) {
+                agent = this.cachedAgent;
+            }
+            else {
+                agent = await ProviderFactory.create(satiConfig, []);
+                this.cachedAgent = agent;
+                this.cachedAgentConfigKey = configKey;
+            }
             // Get existing memories for context (Simulated "Working Memory" or full list if small)
             const allMemories = this.repository.getAllMemories();
             // Map conversation to strict types and sanitize

package/dist/runtime/memory/sqlite.js

@@ -10,6 +10,48 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     lc_namespace = ["langchain", "stores", "message", "sqlite"];
     display = DisplayManager.getInstance();
     static migrationDone = false; // run migrations only once per process
+    // ---------------------------------------------------------------------------
+    // In-memory message cache — eliminates repeated SQLite reads for active sessions
+    // Key: sessionId  Value: { messages (DESC order, newest first), touchedAt, limit }
+    // ---------------------------------------------------------------------------
+    static _cache = new Map();
+    static _CACHE_MAX_SESSIONS = 50;
+    static _CACHE_TTL_MS = 30 * 60 * 1000; // 30 minutes
+    /** Populate or replace a cache entry, evicting LRU if over capacity. */
+    static _setCacheEntry(sessionId, messages, limit) {
+        if (!sessionId)
+            return;
+        if (SQLiteChatMessageHistory._cache.size >= SQLiteChatMessageHistory._CACHE_MAX_SESSIONS) {
+            let oldestKey = '';
+            let oldestTime = Infinity;
+            for (const [k, v] of SQLiteChatMessageHistory._cache) {
+                if (v.touchedAt < oldestTime) {
+                    oldestTime = v.touchedAt;
+                    oldestKey = k;
+                }
+            }
+            if (oldestKey)
+                SQLiteChatMessageHistory._cache.delete(oldestKey);
+        }
+        SQLiteChatMessageHistory._cache.set(sessionId, { messages: [...messages], touchedAt: Date.now(), limit });
+    }
+    /** Remove a session from the cache (used on clear()). */
+    static invalidateCacheForSession(sessionId) {
+        SQLiteChatMessageHistory._cache.delete(sessionId);
+    }
+    /** Prepend new messages (newest-first order) to an existing cache entry. */
+    static _appendToCache(sessionId, newMessages) {
+        if (!sessionId || newMessages.length === 0)
+            return;
+        const entry = SQLiteChatMessageHistory._cache.get(sessionId);
+        if (!entry)
+            return; // session not cached — will be populated on next read
+        // newMessages is in chronological order (oldest first); reverse so newest goes first
+        const newestFirst = [...newMessages].reverse();
+        const merged = [...newestFirst, ...entry.messages];
+        entry.messages = merged.slice(0, entry.limit);
+        entry.touchedAt = Date.now();
+    }
     db;
     sessionId;
     limit;
@@ -281,6 +323,21 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
      */
     async getMessages() {
         try {
+            // -----------------------------------------------------------------------
+            // Cache fast-path: return cached messages if session is warm and not stale
+            // -----------------------------------------------------------------------
+            if (this.sessionId) {
+                const cached = SQLiteChatMessageHistory._cache.get(this.sessionId);
+                if (cached) {
+                    const isStale = Date.now() - cached.touchedAt > SQLiteChatMessageHistory._CACHE_TTL_MS;
+                    if (!isStale) {
+                        cached.touchedAt = Date.now();
+                        return [...cached.messages]; // defensive copy
+                    }
+                    // Stale — evict and fall through to DB
+                    SQLiteChatMessageHistory._cache.delete(this.sessionId);
+                }
+            }
             // Fetch new columns
             const stmt = this.db.prepare(`SELECT type, content, input_tokens, output_tokens, total_tokens, cache_read_tokens, provider, model
          FROM messages
@@ -358,7 +415,10 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             // Messages are in DESC order (newest first) here — orphans appear at the tail.
             // Remove trailing ToolMessages and AIMessages with tool_calls that have no
             // matching ToolMessage response (i.e. incomplete tool-call groups at the boundary).
-            return this.sanitizeMessageWindow(mapped);
+            const result = this.sanitizeMessageWindow(mapped);
+            // Populate cache for subsequent reads in this session
+            SQLiteChatMessageHistory._setCacheEntry(this.sessionId, result, this.limit ?? 100);
+            return result;
         }
         catch (error) {
             // Check if it's a database lock error
@@ -459,6 +519,8 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             }
             const stmt = this.db.prepare("INSERT INTO messages (session_id, type, content, created_at, input_tokens, output_tokens, total_tokens, cache_read_tokens, provider, model, audio_duration_seconds, agent, duration_ms, source) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
             stmt.run(this.sessionId, type, finalContent, Date.now(), inputTokens, outputTokens, totalTokens, cacheReadTokens, provider, model, audioDurationSeconds, agent, durationMs, source);
+            // Update in-memory cache so the next getMessages() call is a cache hit
+            SQLiteChatMessageHistory._appendToCache(this.sessionId, [message]);
             // Verificar se a sessão tem título e definir automaticamente se necessário
             await this.setSessionTitleIfNeeded();
         }
@@ -517,6 +579,8 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         });
         try {
             insertAll(messages);
+            // Update in-memory cache so the next getMessages() call is a cache hit
+            SQLiteChatMessageHistory._appendToCache(this.sessionId, messages);
             await this.setSessionTitleIfNeeded();
         }
         catch (error) {
@@ -743,6 +807,7 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         try {
             const stmt = this.db.prepare("DELETE FROM messages WHERE session_id = ?");
             stmt.run(this.sessionId);
+            SQLiteChatMessageHistory._cache.delete(this.sessionId);
         }
         catch (error) {
             // Check for database lock errors

package/dist/runtime/oracle.js

@@ -19,7 +19,7 @@ import { SetupRepository } from './setup/repository.js';
 import { buildSetupTool } from './tools/setup-tool.js';
 import { SmithDelegator } from "./smiths/delegator.js";
 import { PATHS } from "../config/paths.js";
-import { writeFileSync } from "fs";
+import { writeFile } from "fs/promises";
 export class Oracle {
     provider;
     config;
@@ -200,6 +200,13 @@ export class Oracle {
             this.registerSmithIfEnabled();
             // Refresh dynamic tool catalogs so delegate descriptions contain runtime info.
             await SubagentRegistry.refreshAllCatalogs();
+            // Eagerly initialize subagents so first delegation doesn't pay init cost.
+            await Promise.allSettled([
+                Apoc.getInstance().initialize(),
+                Neo.getInstance().initialize(),
+                Trinity.getInstance().initialize(),
+                Link.getInstance().initialize(),
+            ]);
             // Initialize setup repository (creates table if needed)
             SetupRepository.getInstance();
             const coreTools = [
@@ -459,10 +466,7 @@ ${SkillRegistry.getInstance().getSystemPromptSection()}
 ${SmithRegistry.getInstance().getSystemPromptSection()}
 `);
             //save the system prompt on ~/.morpheus/system_prompt.txt for debugging and prompt engineering purposes
-            try {
-                writeFileSync(`${PATHS.root}/system_prompt.txt`, String(systemMessage.content), 'utf-8');
-            }
-            catch { }
+            writeFile(`${PATHS.root}/system_prompt.txt`, String(systemMessage.content), 'utf-8').catch(() => { });
             // Resolve the authoritative session ID for this call.
             // Priority: explicit taskContext > current history instance > fallback.
             const currentSessionId = taskContext?.session_id
@@ -482,13 +486,20 @@ ${SmithRegistry.getInstance().getSystemPromptSection()}
             // Load existing history from database in reverse order (most recent first)
             let previousMessages = await callHistory.getMessages();
             previousMessages = previousMessages.reverse();
-            // Sati Middleware: Retrieval
+            // Sati Middleware: Retrieval (with 3s timeout to avoid blocking the response)
             let memoryMessage = null;
             try {
-                memoryMessage = await this.satiMiddleware.beforeAgent(message, previousMessages, currentSessionId);
+                const satiTimeout = new Promise((resolve) => setTimeout(() => resolve(null), 3000));
+                memoryMessage = await Promise.race([
+                    this.satiMiddleware.beforeAgent(message, previousMessages, currentSessionId),
+                    satiTimeout,
+                ]);
                 if (memoryMessage) {
                     this.display.log('Sati memory retrieved.', { source: 'Sati' });
                 }
+                else if (memoryMessage === null) {
+                    // Could be timeout or no memories found — either way, proceed
+                }
             }
             catch (e) {
                 // Fail open - do not disrupt main flow

package/dist/runtime/tasks/event-bus.js

@@ -0,0 +1,11 @@
+import { EventEmitter } from 'events';
+/**
+ * Singleton event bus for task lifecycle events.
+ * Emitted by TaskWorker, consumed by TaskNotifier for immediate dispatch.
+ *
+ * Events:
+ *   'task:ready' (taskId: string) — task is completed/failed/cancelled and ready to notify
+ */
+class TaskEventBus extends EventEmitter {
+}
+export const taskEventBus = new TaskEventBus();

package/dist/runtime/tasks/notifier.js

@@ -1,20 +1,20 @@
 import { DisplayManager } from '../display.js';
 import { TaskDispatcher } from './dispatcher.js';
 import { TaskRepository } from './repository.js';
+import { taskEventBus } from './event-bus.js';
 export class TaskNotifier {
-    pollIntervalMs;
     maxAttempts;
     staleSendingMs;
-    notificationGraceMs;
+    recoveryPollMs;
     repository = TaskRepository.getInstance();
     display = DisplayManager.getInstance();
     timer = null;
-    running = false;
+    inFlight = new Set(); // task IDs currently being dispatched
     constructor(opts) {
-        this.pollIntervalMs = opts?.pollIntervalMs ?? 1200;
         this.maxAttempts = opts?.maxAttempts ?? 5;
         this.staleSendingMs = opts?.staleSendingMs ?? 30_000;
-        this.notificationGraceMs = opts?.notificationGraceMs ?? 2000;
+        // Slow poll only for orphan recovery (process restarts, crash scenarios)
+        this.recoveryPollMs = opts?.recoveryPollMs ?? 30_000;
     }
     start() {
         if (this.timer)
@@ -26,43 +26,69 @@ export class TaskNotifier {
                 level: 'warning',
             });
         }
+        // Primary path: event-driven — fires immediately when TaskWorker completes a task
+        taskEventBus.on('task:ready', (taskId) => {
+            this.dispatchById(taskId);
+        });
+        // Fallback path: slow poll for orphaned tasks (e.g. completed before notifier started,
+        // or process restarted mid-notification)
         this.timer = setInterval(() => {
-            void this.tick();
-        }, this.pollIntervalMs);
-        this.display.log('Task notifier started.', { source: 'TaskNotifier' });
+            void this.recoveryTick();
+        }, this.recoveryPollMs);
+        this.display.log('Task notifier started (event-driven + 30s recovery poll).', { source: 'TaskNotifier' });
     }
     stop() {
+        taskEventBus.removeAllListeners('task:ready');
         if (this.timer) {
             clearInterval(this.timer);
             this.timer = null;
-            this.display.log('Task notifier stopped.', { source: 'TaskNotifier' });
         }
+        this.display.log('Task notifier stopped.', { source: 'TaskNotifier' });
     }
-    async tick() {
-        if (this.running)
+    /**
+     * Event-driven dispatch: called immediately when a task is marked complete/failed.
+     * Uses claimNotificationById to atomically claim — prevents double-dispatch with recovery poll.
+     */
+    dispatchById(taskId) {
+        if (this.inFlight.has(taskId))
             return;
-        this.running = true;
-        try {
-            const task = this.repository.claimNextNotificationCandidate(this.notificationGraceMs);
+        this.inFlight.add(taskId);
+        const task = this.repository.claimNotificationById(taskId);
+        if (!task) {
+            // Already claimed by recovery poll or another path
+            this.inFlight.delete(taskId);
+            return;
+        }
+        void this.dispatch(task).finally(() => this.inFlight.delete(taskId));
+    }
+    /**
+     * Fallback recovery: picks up any orphaned completed tasks not yet notified.
+     */
+    async recoveryTick() {
+        // Drain all pending orphans in one recovery sweep
+        while (true) {
+            const task = this.repository.claimNextNotificationCandidate(0);
             if (!task)
-                return;
-            try {
-                await TaskDispatcher.onTaskFinished(task);
-                this.repository.markNotificationSent(task.id);
-            }
-            catch (err) {
-                const latest = this.repository.getTaskById(task.id);
-                const attempts = (latest?.notify_attempts ?? 0) + 1;
-                const retry = attempts < this.maxAttempts;
-                this.repository.markNotificationFailed(task.id, err?.message ?? String(err), retry);
-                this.display.log(`Task notification failed (${task.id}): ${err?.message ?? err}`, {
-                    source: 'TaskNotifier',
-                    level: retry ? 'warning' : 'error',
-                });
-            }
+                break;
+            if (this.inFlight.has(task.id))
+                break; // already being dispatched via event
+            await this.dispatch(task);
         }
-        finally {
-            this.running = false;
+    }
+    async dispatch(task) {
+        try {
+            await TaskDispatcher.onTaskFinished(task);
+            this.repository.markNotificationSent(task.id);
+        }
+        catch (err) {
+            const latest = this.repository.getTaskById(task.id);
+            const attempts = (latest?.notify_attempts ?? 0) + 1;
+            const retry = attempts < this.maxAttempts;
+            this.repository.markNotificationFailed(task.id, err?.message ?? String(err), retry);
+            this.display.log(`Task notification failed (${task.id}): ${err?.message ?? err}`, {
+                source: 'TaskNotifier',
+                level: retry ? 'warning' : 'error',
+            });
         }
     }
 }

package/dist/runtime/tasks/repository.js

@@ -393,6 +393,27 @@ export class TaskRepository {
     `).run(now, now, now - staleMs);
         return result.changes;
     }
+    /**
+     * Atomically claim a specific task for notification by ID.
+     * Returns the task record if successfully claimed, null if already claimed or not eligible.
+     */
+    claimNotificationById(taskId) {
+        const tx = this.db.transaction(() => {
+            const changed = this.db.prepare(`
+        UPDATE tasks
+        SET notify_status = 'sending',
+            notify_last_error = NULL,
+            updated_at = ?
+        WHERE id = ?
+          AND status IN ('completed', 'failed', 'cancelled')
+          AND notify_status = 'pending'
+      `).run(Date.now(), taskId);
+            if (changed.changes === 0)
+                return null;
+            return this.getTaskById(taskId);
+        });
+        return tx();
+    }
     claimNextNotificationCandidate(minFinishedAgeMs = 0) {
         const now = Date.now();
         const tx = this.db.transaction(() => {

package/dist/runtime/tasks/worker.js

@@ -3,6 +3,7 @@ import { DisplayManager } from '../display.js';
 import { SubagentRegistry } from '../subagents/registry.js';
 import { TaskRepository } from './repository.js';
 import { AuditRepository } from '../audit/repository.js';
+import { taskEventBus } from './event-bus.js';
 export class TaskWorker {
     workerId;
     pollIntervalMs;
@@ -38,13 +39,14 @@ export class TaskWorker {
         }
     }
     tick() {
-        if (this.activeTasks.size >= this.maxConcurrent)
-            return;
-        const task = this.repository.claimNextPending(this.workerId);
-        if (!task)
-            return;
-        this.activeTasks.add(task.id);
-        this.executeTask(task).finally(() => this.activeTasks.delete(task.id));
+        // Claim as many tasks as concurrency allows per tick
+        while (this.activeTasks.size < this.maxConcurrent) {
+            const task = this.repository.claimNextPending(this.workerId);
+            if (!task)
+                break;
+            this.activeTasks.add(task.id);
+            this.executeTask(task).finally(() => this.activeTasks.delete(task.id));
+        }
     }
     async executeTask(task) {
         const audit = AuditRepository.getInstance();
@@ -94,6 +96,7 @@ export class TaskWorker {
                 });
             }
             this.display.log(`Task completed: ${task.id}`, { source: 'TaskWorker', level: 'success' });
+            taskEventBus.emit('task:ready', task.id);
         }
         catch (err) {
             const latest = this.repository.getTaskById(task.id);
@@ -116,6 +119,7 @@ export class TaskWorker {
                 metadata: { error: errorMessage },
             });
             this.display.log(`Task failed: ${task.id} (${errorMessage})`, { source: 'TaskWorker', level: 'error' });
+            taskEventBus.emit('task:ready', task.id);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "morpheus-cli",
-  "version": "0.9.32",
+  "version": "0.9.33",
   "description": "Morpheus is a local AI agent for developers, running as a CLI daemon that connects to LLMs, local tools, and MCPs, enabling interaction via Terminal, Telegram, and Discord. Inspired by the character Morpheus from *The Matrix*, the project acts as an intelligent orchestrator, bridging the gap between the developer and complex systems.",
   "bin": {
     "morpheus": "./bin/morpheus.js"