morpheus-cli 0.2.0 → 0.2.3

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

@@ -0,0 +1,58 @@
+import { AIMessage } from "@langchain/core/messages";
+import { SatiService } from "./service.js";
+import { DisplayManager } from "../../display.js";
+const display = DisplayManager.getInstance();
+export class SatiMemoryMiddleware {
+    service;
+    static instance;
+    constructor() {
+        this.service = SatiService.getInstance();
+    }
+    static getInstance() {
+        if (!SatiMemoryMiddleware.instance) {
+            SatiMemoryMiddleware.instance = new SatiMemoryMiddleware();
+        }
+        return SatiMemoryMiddleware.instance;
+    }
+    async beforeAgent(currentMessage, history) {
+        try {
+            // Extract recent messages content strings for context
+            const recentText = history.slice(-10).map(m => m.content.toString());
+            display.log(`[Sati] Searching memories for: "${currentMessage.substring(0, 50)}${currentMessage.length > 50 ? '...' : ''}"`, { source: 'Sati' });
+            const result = await this.service.recover(currentMessage, recentText);
+            if (result.relevant_memories.length === 0) {
+                display.log('[Sati] No relevant memories found', { source: 'Sati' });
+                return null;
+            }
+            const memoryContext = result.relevant_memories
+                .map(m => `- [${m.category.toUpperCase()}] ${m.summary}`)
+                .join('\n');
+            display.log(`[Sati] Retrieved ${result.relevant_memories.length} memories.`, { source: 'Sati' });
+            return new AIMessage(`
+                ### LONG-TERM MEMORY (SATI)
+                The following information was retrieved from previous sessions. Use it if relevant:
+
+                ${memoryContext}
+            `);
+        }
+        catch (error) {
+            display.log(`[SatiMiddleware] Error in beforeAgent: ${error}`, { source: 'Sati' });
+            // Fail open: return null so execution continues without memory
+            return null;
+        }
+    }
+    async afterAgent(generatedResponse, history) {
+        try {
+            await this.service.evaluateAndPersist([
+                ...history.slice(-5).map(m => ({
+                    role: m._getType() === 'human' ? 'user' : 'assistant',
+                    content: m.content.toString()
+                })),
+                { role: 'assistant', content: generatedResponse }
+            ]);
+        }
+        catch (error) {
+            console.error('[SatiMiddleware] Error in afterAgent:', error);
+        }
+    }
+}

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

@@ -0,0 +1,226 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import { homedir } from 'os';
+import fs from 'fs-extra';
+import { randomUUID } from 'crypto'; // Available in recent Node versions
+export class SatiRepository {
+    db = null;
+    dbPath;
+    static instance;
+    constructor(dbPath) {
+        this.dbPath = dbPath || path.join(homedir(), '.morpheus', 'memory', 'santi-memory.db');
+    }
+    static getInstance(dbPath) {
+        if (!SatiRepository.instance) {
+            SatiRepository.instance = new SatiRepository(dbPath);
+        }
+        return SatiRepository.instance;
+    }
+    initialize() {
+        try {
+            // Ensure directory exists
+            fs.ensureDirSync(path.dirname(this.dbPath));
+            // Connect to database
+            this.db = new Database(this.dbPath, { timeout: 5000 });
+            this.db.pragma('journal_mode = WAL');
+            // Create schema
+            this.createSchema();
+        }
+        catch (error) {
+            console.error(`[SatiRepository] Failed to initialize database: ${error}`);
+            throw error;
+        }
+    }
+    createSchema() {
+        if (!this.db)
+            throw new Error("DB not initialized");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS long_term_memory (
+        id TEXT PRIMARY KEY,
+        category TEXT NOT NULL,
+        importance TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        details TEXT,
+        hash TEXT NOT NULL UNIQUE,
+        source TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        last_accessed_at TEXT,
+        access_count INTEGER DEFAULT 0,
+        version INTEGER DEFAULT 1,
+        archived INTEGER DEFAULT 0
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memory_category ON long_term_memory(category);
+      CREATE INDEX IF NOT EXISTS idx_memory_importance ON long_term_memory(importance);
+      CREATE INDEX IF NOT EXISTS idx_memory_archived ON long_term_memory(archived);
+
+      -- FTS5 Virtual Table for semantic-like keyword search
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(summary, content='long_term_memory', content_rowid='rowid');
+
+      -- Triggers to sync FTS
+      CREATE TRIGGER IF NOT EXISTS memory_ai AFTER INSERT ON long_term_memory BEGIN
+        INSERT INTO memory_fts(rowid, summary) VALUES (new.rowid, new.summary);
+      END;
+      CREATE TRIGGER IF NOT EXISTS memory_ad AFTER DELETE ON long_term_memory BEGIN
+        INSERT INTO memory_fts(memory_fts, rowid, summary) VALUES('delete', old.rowid, old.summary);
+      END;
+      CREATE TRIGGER IF NOT EXISTS memory_au AFTER UPDATE ON long_term_memory BEGIN
+        INSERT INTO memory_fts(memory_fts, rowid, summary) VALUES('delete', old.rowid, old.summary);
+        INSERT INTO memory_fts(rowid, summary) VALUES (new.rowid, new.summary);
+      END;
+    `);
+    }
+    async save(record) {
+        if (!this.db)
+            this.initialize();
+        const now = new Date().toISOString();
+        const fullRecord = {
+            id: randomUUID(),
+            ...record,
+            created_at: new Date(now),
+            updated_at: new Date(now),
+            access_count: 0,
+            version: 1,
+            archived: false
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO long_term_memory (
+        id, category, importance, summary, details, hash, source, 
+        created_at, updated_at, last_accessed_at, access_count, version, archived
+      ) VALUES (
+        @id, @category, @importance, @summary, @details, @hash, @source,
+        @created_at, @updated_at, @last_accessed_at, @access_count, @version, @archived
+      )
+      ON CONFLICT(hash) DO UPDATE SET
+        importance = excluded.importance,
+        access_count = long_term_memory.access_count + 1,
+        last_accessed_at = excluded.updated_at,
+        updated_at = excluded.updated_at,
+        details = excluded.details
+    `);
+        // SQLite expects 0/1 for boolean and NULL for undefined
+        const params = {
+            ...fullRecord,
+            details: fullRecord.details || null,
+            source: fullRecord.source || null,
+            created_at: now,
+            updated_at: now,
+            last_accessed_at: now, // Set accessing time on save/update
+            archived: 0
+        };
+        stmt.run(params);
+        return fullRecord;
+    }
+    findByHash(hash) {
+        if (!this.db)
+            this.initialize();
+        const row = this.db.prepare('SELECT * FROM long_term_memory WHERE hash = ?').get(hash);
+        return row ? this.mapRowToRecord(row) : null;
+    }
+    search(query, limit = 5) {
+        if (!this.db)
+            this.initialize();
+        // Sanitize query for FTS5: remove characters that break FTS5 syntax
+        // Keep only alphanumeric, spaces, and safe punctuation (comma, period, hyphen)
+        // const safeQuery = query.replace(/[^a-zA-Z0-9\s,.\-]/g, "").trim();
+        // if (!safeQuery) {
+        //     console.warn('[SatiRepository] Empty query after sanitization');
+        //     return this.getFallbackMemories(limit);
+        // }
+        // try {
+        //     // Try FTS5 search first
+        //     const stmt = this.db!.prepare(`
+        //         SELECT m.* 
+        //         FROM long_term_memory m
+        //         JOIN memory_fts f ON m.rowid = f.rowid
+        //         WHERE memory_fts MATCH ? AND m.archived = 0
+        //         ORDER BY rank
+        //         LIMIT ?
+        //     `);
+        //     const rows = stmt.all(safeQuery, limit) as any[];
+        //     if (rows.length > 0) {
+        //         console.log(`[SatiRepository] FTS5 found ${rows.length} memories for: "${safeQuery}"`);
+        //         return rows.map(this.mapRowToRecord);
+        //     }
+        //     // Fallback: try LIKE search
+        //     console.log(`[SatiRepository] FTS5 returned no results, trying LIKE search for: "${safeQuery}"`);
+        //     const likeStmt = this.db!.prepare(`
+        //         SELECT * FROM long_term_memory
+        //         WHERE (summary LIKE ? OR details LIKE ?) 
+        //         AND archived = 0
+        //         ORDER BY importance DESC, access_count DESC
+        //         LIMIT ?
+        //     `);
+        //     const likePattern = `%${safeQuery}%`;
+        //     const likeRows = likeStmt.all(likePattern, likePattern, limit) as any[];
+        //     if (likeRows.length > 0) {
+        //         console.log(`[SatiRepository] LIKE search found ${likeRows.length} memories`);
+        //         return likeRows.map(this.mapRowToRecord);
+        //     }
+        //     // Final fallback: return most important/accessed memories
+        //     console.log('[SatiRepository] No search results, returning most important memories');
+        //     return this.getFallbackMemories(limit);
+        // } catch (e) {
+        //     console.warn(`[SatiRepository] Search failed for query "${query}": ${e}`);
+        //     return this.getFallbackMemories(limit);
+        // }
+        return this.getFallbackMemories(limit);
+    }
+    getFallbackMemories(limit) {
+        if (!this.db)
+            return [];
+        const stmt = this.db.prepare(`
+        SELECT * FROM long_term_memory
+        WHERE archived = 0
+        ORDER BY 
+            CASE importance
+                WHEN 'critical' THEN 1
+                WHEN 'high' THEN 2
+                WHEN 'medium' THEN 3
+                WHEN 'low' THEN 4
+            END,
+            access_count DESC,
+            created_at DESC
+        LIMIT ?
+    `);
+        const rows = stmt.all(limit);
+        return rows.map(this.mapRowToRecord);
+    }
+    getAllMemories() {
+        if (!this.db)
+            this.initialize();
+        const rows = this.db.prepare('SELECT * FROM long_term_memory WHERE archived = 0 ORDER BY created_at DESC').all();
+        return rows.map(this.mapRowToRecord);
+    }
+    mapRowToRecord(row) {
+        return {
+            id: row.id,
+            category: row.category,
+            importance: row.importance,
+            summary: row.summary,
+            details: row.details,
+            hash: row.hash,
+            source: row.source,
+            created_at: new Date(row.created_at),
+            updated_at: new Date(row.updated_at),
+            last_accessed_at: row.last_accessed_at ? new Date(row.last_accessed_at) : undefined,
+            access_count: row.access_count,
+            version: row.version,
+            archived: Boolean(row.archived)
+        };
+    }
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+    archiveMemory(id) {
+        if (!this.db)
+            this.initialize();
+        const stmt = this.db.prepare('UPDATE long_term_memory SET archived = 1 WHERE id = ?');
+        const result = stmt.run(id);
+        return result.changes > 0;
+    }
+}

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

@@ -0,0 +1,142 @@
+import { SatiRepository } from './repository.js';
+import { ConfigManager } from '../../../config/manager.js';
+import { ProviderFactory } from '../../providers/factory.js';
+import { SystemMessage, HumanMessage, ToolMessage } from "@langchain/core/messages";
+import { SATI_EVALUATION_PROMPT } from './system-prompts.js';
+import { createHash } from 'crypto';
+import { DisplayManager } from '../../display.js';
+import { SQLiteChatMessageHistory } from '../sqlite.js';
+const display = DisplayManager.getInstance();
+export class SatiService {
+    repository;
+    static instance;
+    constructor() {
+        this.repository = SatiRepository.getInstance();
+    }
+    static getInstance() {
+        if (!SatiService.instance) {
+            SatiService.instance = new SatiService();
+        }
+        return SatiService.instance;
+    }
+    async initialize() {
+        this.repository.initialize();
+    }
+    async recover(currentMessage, recentMessages) {
+        const santiConfig = ConfigManager.getInstance().getSatiConfig();
+        const memoryLimit = santiConfig.memory_limit || 1000;
+        // Use the current message as the primary search query
+        // We could enhance this by extracting keywords from the last few messages
+        // but for FR-004 we start with user input.
+        const memories = this.repository.search(currentMessage, memoryLimit);
+        return {
+            relevant_memories: memories.map(m => ({
+                summary: m.summary,
+                category: m.category,
+                importance: m.importance
+            }))
+        };
+    }
+    async evaluateAndPersist(conversation) {
+        try {
+            const santiConfig = ConfigManager.getInstance().getSatiConfig();
+            if (!santiConfig)
+                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(santiConfig, []);
+            // Get existing memories for context (Simulated "Working Memory" or full list if small)
+            const allMemories = this.repository.getAllMemories();
+            const existingSummaries = allMemories.slice(0, 50).map(m => m.summary);
+            // Map conversation to strict types and sanitize
+            const recentConversation = conversation.map(c => ({
+                role: (c.role === 'human' ? 'user' : c.role),
+                content: c.content
+            }));
+            const inputPayload = {
+                recent_conversation: recentConversation,
+                existing_memory_summaries: existingSummaries
+            };
+            const messages = [
+                new SystemMessage(SATI_EVALUATION_PROMPT),
+                new HumanMessage(JSON.stringify(inputPayload, null, 2))
+            ];
+            const history = new SQLiteChatMessageHistory({ sessionId: 'sati-evaluation' });
+            try {
+                const inputMsg = new ToolMessage({
+                    content: JSON.stringify(inputPayload, null, 2),
+                    tool_call_id: `sati-input-${Date.now()}`,
+                    name: 'sati_evaluation_input'
+                });
+                inputMsg.provider_metadata = {
+                    provider: santiConfig.provider,
+                    model: santiConfig.model
+                };
+                await history.addMessage(inputMsg);
+            }
+            catch (e) {
+                console.warn('[SatiService] Failed to persist input log:', e);
+            }
+            const response = await agent.invoke({ messages });
+            const lastMessage = response.messages[response.messages.length - 1];
+            let content = lastMessage.content.toString();
+            try {
+                const outputToolMsg = new ToolMessage({
+                    content: content,
+                    tool_call_id: `sati-output-${Date.now()}`,
+                    name: 'sati_evaluation_output'
+                });
+                if (lastMessage.usage_metadata) {
+                    outputToolMsg.usage_metadata = lastMessage.usage_metadata;
+                }
+                outputToolMsg.provider_metadata = {
+                    provider: santiConfig.provider,
+                    model: santiConfig.model
+                };
+                await history.addMessage(outputToolMsg);
+            }
+            catch (e) {
+                console.warn('[SatiService] Failed to persist output log:', e);
+            }
+            // Safe JSON parsing (handle markdown blocks if LLM wraps output)
+            content = content.replace(/```json/g, '').replace(/```/g, '').trim();
+            let result;
+            try {
+                result = JSON.parse(content);
+            }
+            catch (e) {
+                console.warn('[SatiService] Failed to parse JSON response:', content);
+                return;
+            }
+            if (result.should_store && result.summary && result.category && result.importance) {
+                display.log(`Persisting new memory: [${result.category.toUpperCase()}] ${result.summary}`, { source: 'Sati' });
+                try {
+                    await this.repository.save({
+                        summary: result.summary,
+                        category: result.category,
+                        importance: result.importance,
+                        details: result.reason,
+                        hash: this.generateHash(result.summary),
+                        source: 'conversation' // Could track actual session ID here if available
+                    });
+                    // Quiet success - logging handled by repository/middleware if needed, or verbose debug
+                }
+                catch (saveError) {
+                    if (saveError.message && saveError.message.includes('UNIQUE constraint failed')) {
+                        // Duplicate detected by DB (Hash collision)
+                        // This is expected given T012 logic
+                    }
+                    else {
+                        throw saveError;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('[SatiService] Evaluation failed:', error);
+        }
+    }
+    generateHash(content) {
+        return createHash('sha256').update(content.trim().toLowerCase()).digest('hex');
+    }
+}

package/dist/runtime/memory/sati/system-prompts.js

@@ -0,0 +1,42 @@
+export const SATI_EVALUATION_PROMPT = `You are **Sati**, an autonomous background memory manager for an AI assistant.
+Your goal is to analyze the conversation interaction and decide if any **Persistent Long-Term Memory** should be stored.
+
+### INPUT DATA
+You will receive:
+1. A list of recent messages (USER and ASSISTANT).
+2. A list of ALREADY EXISTING memory summaries (to avoid duplicates).
+
+### MEMORY CATEGORIES
+Classify any new memory into one of these types:
+- **preference**: User preferences (e.g., "I like dark mode", "Use TypeScript").
+- **project**: Details about the user's projects, architecture, or tech stack.
+- **identity**: Facts about the user's identity, role, or background.
+- **constraint**: Hard rules the user wants you to follow (e.g., "Never use single quotes").
+- **context**: General context that is useful for the long term.
+- **personal_data**: Non-sensitive personal info (e.g., birthday, location).
+- **languages**: User's spoken or programming languages.
+- **favorite_things**: Favorites (movies, books, etc.).
+- **relationships**: Mention of colleagues, family, or friends.
+- **pets**: Info about user's pets.
+- **naming**: Naming conventions the user prefers.
+- **professional_profile**: Job title, industry, skills.
+
+### CRITICAL RULES
+1. **NO SECRETS**: NEVER store API keys, passwords, credit cards, or private tokens. If found, ignore them explicitly.
+2. **NO DUPLICATES**: If the information is already covered by the \`existing_memory_summaries\`, DO NOT store it again.
+3. **NO CHIT-CHAT**: Do not store trivial conversation like "Hello", "Thanks", "How are you?".
+4. **IMPORTANCE**: Assign 'low', 'medium', or 'high' importance. Store only 'medium' or 'high' unless it's a specific user preference (which is always important).
+
+### TOP IMPORTANT GUIDELINES
+5. **OBEY THE USER**: If the user explicitly states something should be remembered, it must be stored with at least 'medium' importance.
+
+### OUTPUT FORMAT
+You MUST respond with a valid JSON object matching the \`ISatiEvaluationOutput\` interface:
+{
+  "should_store": boolean,
+  "category": "category_name" | null,
+  "importance": "low" | "medium" | "high" | null,
+  "summary": "Concise factual statement" | null,
+  "reason": "Why you decided to store or not store"
+}
+`;

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

@@ -0,0 +1 @@
+export {};

package/dist/runtime/memory/sqlite.js

@@ -140,7 +140,11 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     async getMessages() {
         try {
             // Fetch new columns
-            const stmt = this.db.prepare("SELECT type, content, input_tokens, output_tokens, total_tokens, cache_read_tokens, provider, model FROM messages WHERE session_id = ? ORDER BY id ASC LIMIT ?");
+            const stmt = this.db.prepare(`SELECT type, content, input_tokens, output_tokens, total_tokens, cache_read_tokens, provider, model
+         FROM messages
+         WHERE session_id = ?
+         ORDER BY id DESC
+         LIMIT ?`);
             const rows = stmt.all(this.sessionId, this.limit);
             return rows.map((row) => {
                 let msg;

package/dist/runtime/migration.js

@@ -1,5 +1,6 @@
 import fs from 'fs-extra';
 import path from 'path';
+import yaml from 'js-yaml';
 import { PATHS } from '../config/paths.js';
 import { DisplayManager } from './display.js';
 export async function migrateConfigFile() {
@@ -17,7 +18,6 @@ export async function migrateConfigFile() {
         catch (err) {
             display.log(`Failed to migrate config.yaml to zaion.yaml: ${err.message}`, { source: 'Zaion', level: 'warning' });
         }
-        return;
     }
     if (legacyExists && newExists) {
         display.log('Both config.yaml and zaion.yaml exist. Using zaion.yaml and leaving config.yaml in place.', {
@@ -25,4 +25,56 @@ export async function migrateConfigFile() {
             level: 'warning'
         });
     }
+    // Migrate memory.limit to llm.context_window
+    await migrateContextWindow();
+}
+/**
+ * Migrates memory.limit to llm.context_window
+ * Creates backup before modifying config
+ */
+async function migrateContextWindow() {
+    const display = DisplayManager.getInstance();
+    const configPath = PATHS.config;
+    try {
+        // Check if config file exists
+        if (!await fs.pathExists(configPath)) {
+            return; // No config to migrate
+        }
+        // Read current config
+        const configContent = await fs.readFile(configPath, 'utf8');
+        const config = yaml.load(configContent);
+        // Check if migration is needed
+        const hasOldField = config?.memory?.limit !== undefined;
+        const hasNewField = config?.llm?.context_window !== undefined;
+        // Already migrated or nothing to migrate
+        if (!hasOldField || hasNewField) {
+            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.llm) {
+            config.llm = {};
+        }
+        config.llm.context_window = config.memory.limit;
+        delete config.memory.limit;
+        // If memory object is now empty, keep it but with undefined limit for backward compat
+        if (Object.keys(config.memory || {}).length === 0) {
+            config.memory = {};
+        }
+        // Write migrated config
+        const migratedYaml = yaml.dump(config);
+        await fs.writeFile(configPath, migratedYaml, 'utf8');
+        display.log('Migrated memory.limit → llm.context_window', { source: 'Migration', level: 'info' });
+    }
+    catch (error) {
+        // Fail open: log error but don't crash
+        display.log(`Config migration failed: ${error.message}. System will use defaults.`, {
+            source: 'Migration',
+            level: 'warning'
+        });
+    }
 }

package/dist/runtime/oracle.js

@@ -5,12 +5,14 @@ import { ConfigManager } from "../config/manager.js";
 import { ProviderError } from "./errors.js";
 import { DisplayManager } from "./display.js";
 import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
+import { SatiMemoryMiddleware } from "./memory/sati/index.js";
 export class Oracle {
     provider;
     config;
     history;
     display = DisplayManager.getInstance();
     databasePath;
+    satiMiddleware = SatiMemoryMiddleware.getInstance();
     constructor(config, overrides) {
         this.config = config || ConfigManager.getInstance().get();
         this.databasePath = overrides?.databasePath;
@@ -32,10 +34,12 @@ export class Oracle {
                 throw new Error("Provider factory returned undefined");
             }
             // Initialize persistent memory with SQLite
+            const contextWindow = this.config.llm?.context_window ?? this.config.memory?.limit ?? 100;
+            this.display.log(`Using context window: ${contextWindow} messages`, { source: 'Oracle' });
             this.history = new SQLiteChatMessageHistory({
                 sessionId: "default",
                 databasePath: this.databasePath,
-                limit: this.config.memory?.limit || 100, // Fallback purely defensive if config type allows optional
+                limit: contextWindow,
             });
         }
         catch (err) {
@@ -181,13 +185,29 @@ You do not speculate when verification is possible.
 You maintain intent until resolution.
 
       `);
-            // Load existing history from database
-            const previousMessages = await this.history.getMessages();
+            // Load existing history from database in reverse order (most recent first)
+            let previousMessages = await this.history.getMessages();
+            previousMessages = previousMessages.reverse();
+            // Sati Middleware: Retrieval
+            let memoryMessage = null;
+            try {
+                memoryMessage = await this.satiMiddleware.beforeAgent(message, previousMessages);
+                if (memoryMessage) {
+                    this.display.log('Sati memory retrieved.', { source: 'Sati' });
+                }
+            }
+            catch (e) {
+                // Fail open - do not disrupt main flow
+                this.display.log(`Sati memory retrieval failed: ${e.message}`, { source: 'Sati' });
+            }
             const messages = [
-                systemMessage,
-                ...previousMessages,
-                userMessage
+                systemMessage
             ];
+            if (memoryMessage) {
+                messages.push(memoryMessage);
+            }
+            messages.push(...previousMessages);
+            messages.push(userMessage);
             const response = await this.provider.invoke({ messages });
             // Identify new messages generated during the interaction
             // The `messages` array passed to invoke had length `messages.length`
@@ -195,6 +215,7 @@ You maintain intent until resolution.
             // New messages start after the inputs.
             const startNewMessagesIndex = messages.length;
             const newGeneratedMessages = response.messages.slice(startNewMessagesIndex);
+            // console.log('New generated messages', newGeneratedMessages);
             // Persist User Message first
             await this.history.addMessage(userMessage);
             // Persist all new intermediate tool calls and responses
@@ -208,7 +229,11 @@ You maintain intent until resolution.
             }
             this.display.log('Response generated.', { source: 'Oracle' });
             const lastMessage = response.messages[response.messages.length - 1];
-            return (typeof lastMessage.content === 'string') ? lastMessage.content : JSON.stringify(lastMessage.content);
+            const responseContent = (typeof lastMessage.content === 'string') ? lastMessage.content : JSON.stringify(lastMessage.content);
+            // Sati Middleware: Evaluation (Fire and forget)
+            this.satiMiddleware.afterAgent(responseContent, [...previousMessages, userMessage])
+                .catch((e) => this.display.log(`Sati memory evaluation failed: ${e.message}`, { source: 'Sati' }));
+            return responseContent;
         }
         catch (err) {
             throw new ProviderError(this.config.llm.provider, err, "Chat request failed");

package/dist/runtime/santi/contracts.js

@@ -0,0 +1 @@
+export {};