morpheus-cli 0.1.11 → 0.2.2

package/README.md

@@ -80,9 +80,9 @@ Morpheus is built with **Node.js** and **TypeScript**, using **LangChain** as th
 
 ### Core Components
 
-- **Runtime (`src/runtime/`)**: The heart of the application. Manages the agent lifecycle, provider instantiation, and command execution.
+- **Runtime (`src/runtime/`)**: The heart of the application. Manages the Oracle (agent) lifecycle, provider instantiation, and command execution.
 - **CLI (`src/cli/`)**: Built with `commander`, handles user interaction, configuration, and daemon control (`start`, `stop`, `status`).
-- **Configuration (`src/config/`)**: Singleton-based configuration manager using `zod` for validation and `js-yaml` for persistence (`~/.morpheus/config.yaml`).
+- **Configuration (`src/config/`)**: Singleton-based configuration manager using `zod` for validation and `js-yaml` for persistence (`~/.morpheus/zaion.yaml`).
 - **Channels (`src/channels/`)**: Adapters for external communication. Currently supports Telegram (`telegraf`) with strict user whitelisting.
 
 ## Features
@@ -115,6 +115,12 @@ When enabled:
 ### 🧩 MCP Support (Model Context Protocol)
 Full integration with [Model Context Protocol](https://modelcontextprotocol.io/), allowing Morpheus to use standardized tools from any MCP-compatible server.
 
+### 🧠 Sati (Long-Term Memory)
+Morpheus features a dedicated middleware system called **Sati** (Mindfulness) that provides long-term memory capabilities.
+-   **Automated Storage**: Automatically extracts and saves preferences, project details, and facts from conversations.
+-   **Contextual Retrieval**: Injects relevant memories into the context based on your current query.
+-   **Data Privacy**: Stored in a local, independent SQLite database (`santi-memory.db`), ensuring sensitive data is handled securely and reducing context window usage.
+
 ### 📊 Usage Analytics
 Track your token usage across different providers and models directly from the Web UI. View detailed breakdowns of input/output tokens and message counts to monitor costs and activity.
 
@@ -169,7 +175,7 @@ npm start -- status
 
 ### 4. Configuration
 
-The configuration file is located at `~/.morpheus/config.yaml`. You can edit it manually or use the `morpheus config` command.
+The configuration file is located at `~/.morpheus/zaion.yaml`. You can edit it manually or use the `morpheus config` command.
 
 ```yaml
 agent:
@@ -179,9 +185,12 @@ llm:
   provider: "openai" # options: openai, anthropic, ollama, gemini
   model: "gpt-4-turbo"
   temperature: 0.7
+  context_window: 100 # Number of messages to load into LLM context
   api_key: "sk-..."
-memory:
-  limit: 100 # Number of messages to retain in context
+santi: # Optional: Sati (Long-Term Memory) specific settings
+  provider: "openai" # defaults to llm.provider
+  model: "gpt-4o"
+  memory_limit: 1000 # Number of messages/items to retrieve
 channels:
   telegram:
     enabled: true

package/dist/cli/commands/doctor.js

@@ -23,8 +23,30 @@ export const doctorCommand = new Command('doctor')
     // 2. Check Configuration
     try {
         if (await fs.pathExists(PATHS.config)) {
-            await ConfigManager.getInstance().load();
+            const config = await ConfigManager.getInstance().load();
             console.log(chalk.green('✓') + ' Configuration: Valid');
+            // Check context window configuration
+            const contextWindow = config.llm?.context_window;
+            const deprecatedLimit = config.memory?.limit;
+            if (contextWindow !== undefined) {
+                if (typeof contextWindow === 'number' && contextWindow > 0) {
+                    console.log(chalk.green('✓') + ` LLM context window: ${contextWindow} messages`);
+                }
+                else {
+                    console.log(chalk.red('✗') + ` LLM context window has invalid value, using default: 100 messages`);
+                    allPassed = false;
+                }
+            }
+            else {
+                console.log(chalk.yellow('⚠') + ' LLM context window not configured, using default: 100 messages');
+            }
+            // Check for deprecated field
+            if (deprecatedLimit !== undefined && contextWindow === undefined) {
+                console.log(chalk.yellow('⚠') + ' Deprecated config detected: \'memory.limit\' should be migrated to \'llm.context_window\'. Will auto-migrate on next start.');
+            }
+            else if (deprecatedLimit !== undefined && contextWindow !== undefined) {
+                console.log(chalk.yellow('⚠') + ' Found both \'memory.limit\' and \'llm.context_window\'. Remove \'memory.limit\' from config.');
+            }
         }
         else {
             console.log(chalk.yellow('!') + ' Configuration: Missing (will be created on start)');
@@ -58,6 +80,19 @@ export const doctorCommand = new Command('doctor')
         console.log(chalk.red('✗') + ` Logs: Cannot write to ${PATHS.logs}`);
         allPassed = false;
     }
+    // 5. Check Sati Memory DB
+    try {
+        const satiDbPath = path.join(PATHS.memory, 'santi-memory.db');
+        if (await fs.pathExists(satiDbPath)) {
+            console.log(chalk.green('✓') + ' Sati Memory: Database exists');
+        }
+        else {
+            console.log(chalk.yellow('!') + ' Sati Memory: Database not initialized (will be created on start)');
+        }
+    }
+    catch (error) {
+        console.log(chalk.red('✗') + ` Sati Memory: Check failed (${error.message})`);
+    }
     console.log(chalk.gray('================'));
     if (allPassed) {
         console.log(chalk.green('Diagnostics Passed. You are ready to run Morpheus!'));

package/dist/cli/commands/init.js

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import { ConfigManager } from '../../config/manager.js';
 import { renderBanner } from '../utils/render.js';
 import { DisplayManager } from '../../runtime/display.js';
+import { SatiRepository } from '../../runtime/memory/sati/repository.js';
 // import { scaffold } from '../../runtime/scaffold.js';
 export const initCommand = new Command('init')
     .description('Initialize Morpheus configuration')
@@ -74,6 +75,89 @@ export const initCommand = new Command('init')
         if (apiKey) {
             await configManager.set('llm.api_key', apiKey);
         }
+        // Context Window Configuration
+        const contextWindow = await input({
+            message: 'Context Window Size (number of messages to send to LLM):',
+            default: currentConfig.llm.context_window?.toString() || '100',
+            validate: (val) => (!isNaN(Number(val)) && Number(val) > 0) || 'Must be a positive number'
+        });
+        await configManager.set('llm.context_window', Number(contextWindow));
+        // Santi (Memory Agent) Configuration
+        display.log(chalk.blue('\nSati (Memory Agent) Configuration'));
+        const configureSanti = await select({
+            message: 'Configure Sati separately?',
+            choices: [
+                { name: 'No (Use main LLM settings)', value: 'no' },
+                { name: 'Yes', value: 'yes' },
+            ],
+            default: 'no',
+        });
+        let santiProvider = provider;
+        let santiModel = model;
+        let santiApiKey = apiKey;
+        // If using main settings and no new key provided, use existing if available
+        if (configureSanti === 'no' && !santiApiKey && hasExistingKey) {
+            santiApiKey = currentConfig.llm.api_key;
+        }
+        if (configureSanti === 'yes') {
+            santiProvider = await select({
+                message: 'Select Sati LLM Provider:',
+                choices: [
+                    { name: 'OpenAI', value: 'openai' },
+                    { name: 'Anthropic', value: 'anthropic' },
+                    { name: 'Ollama', value: 'ollama' },
+                    { name: 'Google Gemini', value: 'gemini' },
+                ],
+                default: currentConfig.santi?.provider || provider,
+            });
+            let defaultSantiModel = 'gpt-3.5-turbo';
+            switch (santiProvider) {
+                case 'openai':
+                    defaultSantiModel = 'gpt-4o';
+                    break;
+                case 'anthropic':
+                    defaultSantiModel = 'claude-3-5-sonnet-20240620';
+                    break;
+                case 'ollama':
+                    defaultSantiModel = 'llama3';
+                    break;
+                case 'gemini':
+                    defaultSantiModel = 'gemini-pro';
+                    break;
+            }
+            if (santiProvider === currentConfig.santi?.provider) {
+                defaultSantiModel = currentConfig.santi?.model || defaultSantiModel;
+            }
+            santiModel = await input({
+                message: 'Enter Sati Model Name:',
+                default: defaultSantiModel,
+            });
+            const hasExistingSantiKey = !!currentConfig.santi?.api_key;
+            const santiKeyMsg = hasExistingSantiKey
+                ? 'Enter Sati API Key (leave empty to preserve existing):'
+                : 'Enter Sati API Key:';
+            const keyInput = await password({ message: santiKeyMsg });
+            if (keyInput) {
+                santiApiKey = keyInput;
+            }
+            else if (hasExistingSantiKey) {
+                santiApiKey = currentConfig.santi?.api_key;
+            }
+            else {
+                santiApiKey = undefined; // Ensure we don't accidentally carry over invalid state
+            }
+        }
+        const memoryLimit = await input({
+            message: 'Sati Memory Retrieval Limit (messages):',
+            default: currentConfig.santi?.memory_limit?.toString() || '1000',
+            validate: (val) => !isNaN(Number(val)) && Number(val) > 0 || 'Must be a positive number'
+        });
+        await configManager.set('santi.provider', santiProvider);
+        await configManager.set('santi.model', santiModel);
+        await configManager.set('santi.memory_limit', Number(memoryLimit));
+        if (santiApiKey) {
+            await configManager.set('santi.api_key', santiApiKey);
+        }
         // Audio Configuration
         const audioEnabled = await confirm({
             message: 'Enable Audio Transcription? (Requires Gemini)',
@@ -152,6 +236,14 @@ export const initCommand = new Command('init')
                 await configManager.set('channels.telegram.allowedUsers', allowedUsers);
             }
         }
+        // Initialize Sati Memory (Long-term memory)
+        try {
+            SatiRepository.getInstance().initialize();
+            display.log(chalk.green('Long-term memory initialized.'));
+        }
+        catch (e) {
+            display.log(chalk.yellow(`Warning: Could not initialize long-term memory: ${e.message}`));
+        }
         display.log(chalk.green('\nConfiguration saved successfully!'));
         display.log(chalk.cyan(`Run 'morpheus start' to launch ${name}.`));
     }

package/dist/cli/commands/start.js

@@ -11,6 +11,7 @@ import { PATHS } from '../../config/paths.js';
 import { Oracle } from '../../runtime/oracle.js';
 import { ProviderError } from '../../runtime/errors.js';
 import { HttpServer } from '../../http/server.js';
+import { getVersion } from '../utils/version.js';
 export const startCommand = new Command('start')
     .description('Start the Morpheus agent')
     .option('--ui', 'Enable web UI', true)
@@ -19,7 +20,7 @@ export const startCommand = new Command('start')
     .action(async (options) => {
     const display = DisplayManager.getInstance();
     try {
-        renderBanner();
+        renderBanner(getVersion());
         await scaffold(); // Ensure env exists
         // Cleanup stale PID first
         await checkStalePid();

package/dist/cli/index.js

@@ -1,7 +1,4 @@
 import { Command } from 'commander';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
 import { startCommand } from './commands/start.js';
 import { stopCommand } from './commands/stop.js';
 import { statusCommand } from './commands/status.js';
@@ -9,20 +6,7 @@ import { configCommand } from './commands/config.js';
 import { doctorCommand } from './commands/doctor.js';
 import { initCommand } from './commands/init.js';
 import { scaffold } from '../runtime/scaffold.js';
-// Helper to read package.json version
-const getVersion = () => {
-    try {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = dirname(__filename);
-        // Assuming dist/cli/index.js -> package.json is 2 levels up
-        const pkgPath = join(__dirname, '../../package.json');
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-        return pkg.version;
-    }
-    catch (e) {
-        return '0.1.0';
-    }
-};
+import { getVersion } from './utils/version.js';
 export async function cli() {
     const program = new Command();
     program

package/dist/cli/utils/render.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import figlet from 'figlet';
-export function renderBanner() {
+export function renderBanner(version) {
     const art = figlet.textSync('Morpheus', {
         font: 'Standard',
         horizontalLayout: 'default',
@@ -8,4 +8,5 @@ export function renderBanner() {
     });
     console.log(chalk.cyanBright(art));
     console.log(chalk.gray('  The Local-First AI Agent specialized in Coding\n'));
+    console.log(chalk.gray(`  v${version || 'unknown'}\n`));
 }

package/dist/cli/utils/version.js

@@ -0,0 +1,16 @@
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+export const getVersion = () => {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        // Assuming dist/cli/index.js -> package.json is 2 levels up
+        const pkgPath = join(__dirname, '../../../package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version;
+    }
+    catch (e) {
+        return '0.1.0';
+    }
+};

package/dist/config/manager.js

@@ -54,4 +54,20 @@ export class ConfigManager {
         await fs.writeFile(PATHS.config, yaml.dump(valid), 'utf8');
         this.config = valid;
     }
+    getLLMConfig() {
+        return this.config.llm;
+    }
+    getSantiConfig() {
+        if (this.config.santi) {
+            return {
+                memory_limit: 10, // Default if undefined
+                ...this.config.santi
+            };
+        }
+        // Fallback to main LLM config
+        return {
+            ...this.config.llm,
+            memory_limit: 10 // Default fallback
+        };
+    }
 }

package/dist/config/schemas.js

@@ -7,22 +7,28 @@ export const AudioConfigSchema = z.object({
     maxDurationSeconds: z.number().default(DEFAULT_CONFIG.audio.maxDurationSeconds),
     supportedMimeTypes: z.array(z.string()).default(DEFAULT_CONFIG.audio.supportedMimeTypes),
 });
+export const LLMConfigSchema = z.object({
+    provider: z.enum(['openai', 'anthropic', 'ollama', 'gemini']).default(DEFAULT_CONFIG.llm.provider),
+    model: z.string().min(1).default(DEFAULT_CONFIG.llm.model),
+    temperature: z.number().min(0).max(1).default(DEFAULT_CONFIG.llm.temperature),
+    max_tokens: z.number().int().positive().optional(),
+    api_key: z.string().optional(),
+    context_window: z.number().int().positive().optional(),
+});
+export const SantiConfigSchema = LLMConfigSchema.extend({
+    memory_limit: z.number().int().positive().optional(),
+});
 // Zod Schema matching MorpheusConfig interface
 export const ConfigSchema = z.object({
     agent: z.object({
         name: z.string().default(DEFAULT_CONFIG.agent.name),
         personality: z.string().default(DEFAULT_CONFIG.agent.personality),
     }).default(DEFAULT_CONFIG.agent),
-    llm: z.object({
-        provider: z.enum(['openai', 'anthropic', 'ollama', 'gemini']).default(DEFAULT_CONFIG.llm.provider),
-        model: z.string().min(1).default(DEFAULT_CONFIG.llm.model),
-        temperature: z.number().min(0).max(1).default(DEFAULT_CONFIG.llm.temperature),
-        max_tokens: z.number().int().positive().optional(),
-        api_key: z.string().optional(),
-    }).default(DEFAULT_CONFIG.llm),
+    llm: LLMConfigSchema.default(DEFAULT_CONFIG.llm),
+    santi: SantiConfigSchema.optional(),
     audio: AudioConfigSchema.default(DEFAULT_CONFIG.audio),
     memory: z.object({
-        limit: z.number().int().positive().default(DEFAULT_CONFIG.memory.limit),
+        limit: z.number().int().positive().optional(),
     }).default(DEFAULT_CONFIG.memory),
     channels: z.object({
         telegram: z.object({
@@ -56,6 +62,7 @@ export const MCPServerConfigSchema = z.discriminatedUnion('transport', [
     z.object({
         transport: z.literal('http'),
         url: z.string().url('Valid URL is required for http transport'),
+        headers: z.record(z.string(), z.string()).optional().default({}),
         args: z.array(z.string()).optional().default([]),
         env: z.record(z.string(), z.string()).optional().default({}),
         _comment: z.string().optional(),

package/dist/http/api.js

@@ -113,6 +113,52 @@ export function createApiRouter() {
             }
         }
     });
+    // Sati config endpoints
+    router.get('/config/sati', (req, res) => {
+        try {
+            const satiConfig = configManager.getSantiConfig();
+            res.json(satiConfig);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/config/sati', async (req, res) => {
+        try {
+            const config = configManager.get();
+            await configManager.save({ ...config, santi: req.body });
+            const display = DisplayManager.getInstance();
+            display.log('Sati configuration updated via UI', {
+                source: 'Zaion',
+                level: 'info'
+            });
+            res.json({ success: true });
+        }
+        catch (error) {
+            if (error.name === 'ZodError') {
+                res.status(400).json({ error: 'Validation failed', details: error.errors });
+            }
+            else {
+                res.status(500).json({ error: error.message });
+            }
+        }
+    });
+    router.delete('/config/sati', async (req, res) => {
+        try {
+            const config = configManager.get();
+            const { santi, ...restConfig } = config;
+            await configManager.save(restConfig);
+            const display = DisplayManager.getInstance();
+            display.log('Sati configuration removed via UI (falling back to Oracle config)', {
+                source: 'Zaion',
+                level: 'info'
+            });
+            res.json({ success: true });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
     // Keep PUT for backward compatibility if needed, or remove. 
     // Tasks says Implement POST. I'll remove PUT to avoid confusion or redirect it.
     router.put('/config', async (req, res) => {

package/dist/runtime/__tests__/manual_santi_verify.js

@@ -0,0 +1,55 @@
+import { Santi } from "../santi/santi.js";
+import { ConfigManager } from "../../config/manager.js";
+import * as path from "path";
+import { homedir } from "os";
+async function main() {
+    console.log("Starting Santi Manual Verification...");
+    // 1. Check DB isolation
+    const santiDbPath = path.join(homedir(), ".morpheus", "memory", "santi-memory.db");
+    const shortDbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+    console.log(`Checking DB paths: \n- ${santiDbPath}\n- ${shortDbPath}`);
+    // 2. Initialize Santi
+    const santi = new Santi();
+    console.log("Santi initialized.");
+    // 3. Test Recovery (should be empty or have data if prev run)
+    let memories = await santi.recover("test");
+    console.log(`Initial recovery "test": ${memories.length} items`);
+    // 4. Manually add memory via internal store (reflection hack for test)
+    console.log("Injecting test memory...");
+    // @ts-ignore
+    santi.store.addMemory({
+        category: 'preference',
+        importance: 'high',
+        summary: 'The user loves manual testing scripts.',
+        hash: 'manual-test-hash',
+        source: 'manual_test'
+    });
+    // 5. Test Recovery again
+    memories = await santi.recover("loves manual testing");
+    console.log(`Recovery after injection "loves manual testing": ${memories.length} items`);
+    if (memories.length > 0 && memories[0].summary.includes("loves manual testing")) {
+        console.log("✅ Recovery SUCCESS");
+    }
+    else {
+        console.error("❌ Recovery FAILED");
+    }
+    // 6. Test Evaluate (Mocking messages)
+    // This requires LLM config to be present. 
+    // We skip this in manual test if no config, but logging will show warning.
+    if (ConfigManager.getInstance().get().llm) {
+        console.log("Testing Evaluate (dry run with LLM)...");
+        // This will assume valid LLM config
+        /*
+        await santi.evaluate([
+            new HumanMessage("My name is Morpheus Tester."),
+            new AIMessage("Nice to meet you.")
+        ]);
+        */
+        console.log("Evaluate test skipped to avoid api cost, but code is in place.");
+    }
+    else {
+        console.log("Skipping Evaluate test (no LLM config).");
+    }
+    console.log("Verification Complete.");
+}
+main().catch(console.error);

package/dist/runtime/display.js

@@ -80,6 +80,9 @@ export class DisplayManager {
             else if (options.source === 'Oracle') {
                 color = chalk.hex('#FFA500');
             }
+            else if (options.source === 'Sati') {
+                color = chalk.hex('#00ff22');
+            }
             else if (options.source === 'Telephonist') {
                 color = chalk.hex('#b902b9');
             }

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

@@ -0,0 +1,71 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SatiRepository } from '../repository.js';
+import fs from 'fs-extra';
+import path from 'path';
+describe('SatiRepository', () => {
+    const dbPath = path.join(process.cwd(), 'test-memory.db');
+    let repo;
+    beforeEach(() => {
+        // Reset singleton instance for testing
+        SatiRepository.instance = null;
+        repo = SatiRepository.getInstance(dbPath);
+        repo.initialize();
+    });
+    afterEach(() => {
+        try {
+            repo.close();
+        }
+        catch (e) { }
+        if (fs.existsSync(dbPath)) {
+            try {
+                fs.unlinkSync(dbPath);
+                fs.rmdirSync(path.dirname(dbPath)); // cleanup dir if possible/empty
+            }
+            catch (e) { }
+        }
+    });
+    it('should save and retrieve memory', async () => {
+        const mem = {
+            category: 'preference',
+            importance: 'high',
+            summary: 'Test Memory',
+            hash: '123',
+            source: 'test'
+        };
+        await repo.save(mem);
+        const result = repo.findByHash('123');
+        expect(result).not.toBeNull();
+        expect(result?.summary).toBe('Test Memory');
+    });
+    it('should deduplicate (update) on hash collision', async () => {
+        const mem1 = {
+            category: 'preference',
+            importance: 'medium',
+            summary: 'Test Memory v1',
+            hash: 'abc',
+            source: 'test'
+        };
+        await repo.save(mem1);
+        const mem2 = {
+            category: 'preference',
+            importance: 'high',
+            summary: 'Test Memory v2', // Summary logic might not update summary field in my query
+            // Let's check my query in repository.ts:
+            // ON CONFLICT(hash) DO UPDATE SET importance..., details... but NOT summary.
+            // If hash is same, summary implies same content usually.
+            // But here I test that fields ARE updated.
+            hash: 'abc',
+            source: 'test',
+            details: 'updated details'
+        };
+        await repo.save(mem2);
+        const result = repo.findByHash('abc');
+        expect(result).not.toBeNull();
+        expect(result?.importance).toBe('high');
+        expect(result?.details).toBe('updated details');
+        // Since my query did not update summary (it assumed hash=summary match), summary should stay v1.
+        expect(result?.summary).toBe('Test Memory v1');
+        // Access count should increment
+        expect(result?.access_count).toBeGreaterThan(0);
+    });
+});

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

@@ -0,0 +1,99 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { SatiService } from '../service.js';
+import { SatiRepository } from '../repository.js';
+import { ProviderFactory } from '../../../providers/factory.js';
+// Mock ConfigManager
+vi.mock('../../../../config/manager.js', () => ({
+    ConfigManager: {
+        getInstance: vi.fn().mockReturnValue({
+            get: vi.fn().mockReturnValue({ llm: { provider: 'test' } })
+        })
+    }
+}));
+// Mock ProviderFactory
+vi.mock('../../../providers/factory.js', () => ({
+    ProviderFactory: {
+        create: vi.fn()
+    }
+}));
+// Mock the repository module
+vi.mock('../repository.js', () => {
+    const SatiRepositoryMock = {
+        getInstance: vi.fn(),
+    };
+    return { SatiRepository: SatiRepositoryMock };
+});
+describe('SatiService', () => {
+    let service;
+    let mockRepo;
+    let mockAgent;
+    beforeEach(() => {
+        vi.resetAllMocks();
+        // Setup mock repository instance
+        mockRepo = {
+            initialize: vi.fn(),
+            search: vi.fn(),
+            save: vi.fn(),
+            getAllMemories: vi.fn().mockReturnValue([]),
+        };
+        SatiRepository.getInstance.mockReturnValue(mockRepo);
+        // Setup mock agent
+        mockAgent = {
+            invoke: vi.fn()
+        };
+        ProviderFactory.create.mockResolvedValue(mockAgent);
+        service = SatiService.getInstance();
+        service.repository = mockRepo;
+    });
+    describe('recover', () => {
+        it('should recover memories calling repository with limit', async () => {
+            mockRepo.search.mockReturnValue([
+                { summary: 'Memory 1', category: 'preference', importance: 'high' },
+                { summary: 'Memory 2', category: 'project', importance: 'medium' }
+            ]);
+            const result = await service.recover('hello world', []);
+            expect(mockRepo.search).toHaveBeenCalledWith('hello world', 5);
+            expect(result.relevant_memories).toHaveLength(2);
+            expect(result.relevant_memories[0].summary).toBe('Memory 1');
+        });
+        it('should return empty list when no memories found', async () => {
+            mockRepo.search.mockReturnValue([]);
+            const result = await service.recover('unknown', []);
+            expect(mockRepo.search).toHaveBeenCalledWith('unknown', 5);
+            expect(result.relevant_memories).toEqual([]);
+        });
+    });
+    describe('evaluateAndPersist', () => {
+        it('should parse LLM response and persist memory', async () => {
+            mockAgent.invoke.mockResolvedValue({
+                messages: [{
+                        content: JSON.stringify({
+                            should_store: true,
+                            category: 'preference',
+                            importance: 'high',
+                            summary: 'User likes TypeScript',
+                            reason: 'User stated preference'
+                        })
+                    }]
+            });
+            await service.evaluateAndPersist([{ role: 'user', content: 'I like TypeScript' }]);
+            expect(mockRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                summary: 'User likes TypeScript',
+                category: 'preference',
+                importance: 'high'
+            }));
+        });
+        it('should not persist if should_store is false', async () => {
+            mockAgent.invoke.mockResolvedValue({
+                messages: [{
+                        content: JSON.stringify({
+                            should_store: false,
+                            reason: 'Chit chat'
+                        })
+                    }]
+            });
+            await service.evaluateAndPersist([{ role: 'user', content: 'Hi' }]);
+            expect(mockRepo.save).not.toHaveBeenCalled();
+        });
+    });
+});