morpheus-cli 0.4.15 → 0.5.0

package/dist/cli/commands/start.js

@@ -15,6 +15,9 @@ import { ProviderError } from '../../runtime/errors.js';
 import { HttpServer } from '../../http/server.js';
 import { getVersion } from '../utils/version.js';
 import { startSessionEmbeddingScheduler } from '../../runtime/session-embedding-scheduler.js';
+import { TaskWorker } from '../../runtime/tasks/worker.js';
+import { TaskNotifier } from '../../runtime/tasks/notifier.js';
+import { TaskDispatcher } from '../../runtime/tasks/dispatcher.js';
 export const startCommand = new Command('start')
     .description('Start the Morpheus agent')
     .option('--ui', 'Enable web UI', true)
@@ -119,6 +122,9 @@ export const startCommand = new Command('start')
         }
         const adapters = [];
         let httpServer;
+        const taskWorker = new TaskWorker();
+        const taskNotifier = new TaskNotifier();
+        const asyncTasksEnabled = config.runtime?.async_tasks?.enabled !== false;
         // Initialize Web UI
         if (options.ui && config.ui.enabled) {
             try {
@@ -139,6 +145,7 @@ export const startCommand = new Command('start')
                     await telegram.connect(config.channels.telegram.token, config.channels.telegram.allowedUsers || []);
                     // Wire Telegram adapter to webhook dispatcher for proactive notifications
                     WebhookDispatcher.setTelegramAdapter(telegram);
+                    TaskDispatcher.setTelegramAdapter(telegram);
                     adapters.push(telegram);
                 }
                 catch (e) {
@@ -151,6 +158,10 @@ export const startCommand = new Command('start')
         }
         // Start Background Services
         startSessionEmbeddingScheduler();
+        if (asyncTasksEnabled) {
+            taskWorker.start();
+            taskNotifier.start();
+        }
         // Handle graceful shutdown
         const shutdown = async (signal) => {
             display.stopSpinner();
@@ -161,6 +172,10 @@ export const startCommand = new Command('start')
             for (const adapter of adapters) {
                 await adapter.disconnect();
             }
+            if (asyncTasksEnabled) {
+                taskWorker.stop();
+                taskNotifier.stop();
+            }
             await clearPid();
             process.exit(0);
         };

package/dist/config/manager.js

@@ -85,6 +85,45 @@ export class ConfigManager {
                 timeout_ms: config.apoc.timeout_ms !== undefined ? resolveNumeric('MORPHEUS_APOC_TIMEOUT_MS', config.apoc.timeout_ms, 30_000) : 30_000
             };
         }
+        // Apply precedence to Neo config
+        const neoEnvVars = [
+            'MORPHEUS_NEO_PROVIDER',
+            'MORPHEUS_NEO_MODEL',
+            'MORPHEUS_NEO_TEMPERATURE',
+            'MORPHEUS_NEO_MAX_TOKENS',
+            'MORPHEUS_NEO_API_KEY',
+            'MORPHEUS_NEO_BASE_URL',
+            'MORPHEUS_NEO_CONTEXT_WINDOW',
+        ];
+        const hasNeoEnvOverrides = neoEnvVars.some((envVar) => process.env[envVar] !== undefined);
+        const resolveOptionalNumeric = (envVar, configValue, fallbackValue) => {
+            if (fallbackValue !== undefined) {
+                return resolveNumeric(envVar, configValue, fallbackValue);
+            }
+            if (process.env[envVar] !== undefined && process.env[envVar] !== '') {
+                const parsed = Number(process.env[envVar]);
+                if (!Number.isNaN(parsed)) {
+                    return parsed;
+                }
+            }
+            return configValue;
+        };
+        let neoConfig;
+        if (config.neo || hasNeoEnvOverrides) {
+            const neoProvider = resolveProvider('MORPHEUS_NEO_PROVIDER', config.neo?.provider, llmConfig.provider);
+            const neoBaseUrl = resolveString('MORPHEUS_NEO_BASE_URL', config.neo?.base_url, llmConfig.base_url || '');
+            const neoMaxTokensFallback = config.neo?.max_tokens ?? llmConfig.max_tokens;
+            const neoContextWindowFallback = config.neo?.context_window ?? llmConfig.context_window;
+            neoConfig = {
+                provider: neoProvider,
+                model: resolveModel(neoProvider, 'MORPHEUS_NEO_MODEL', config.neo?.model || llmConfig.model),
+                temperature: resolveNumeric('MORPHEUS_NEO_TEMPERATURE', config.neo?.temperature, llmConfig.temperature),
+                max_tokens: resolveOptionalNumeric('MORPHEUS_NEO_MAX_TOKENS', config.neo?.max_tokens, neoMaxTokensFallback),
+                api_key: resolveApiKey(neoProvider, 'MORPHEUS_NEO_API_KEY', config.neo?.api_key || llmConfig.api_key),
+                base_url: neoBaseUrl || undefined,
+                context_window: resolveOptionalNumeric('MORPHEUS_NEO_CONTEXT_WINDOW', config.neo?.context_window, neoContextWindowFallback),
+            };
+        }
         // 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'
@@ -128,6 +167,7 @@ export class ConfigManager {
             agent: agentConfig,
             llm: llmConfig,
             sati: satiConfig,
+            neo: neoConfig,
             apoc: apocConfig,
             audio: audioConfig,
             channels: channelsConfig,
@@ -185,4 +225,15 @@ export class ConfigManager {
             timeout_ms: 30_000
         };
     }
+    getNeoConfig() {
+        if (this.config.neo) {
+            return {
+                ...this.config.neo
+            };
+        }
+        // Fallback to main LLM config
+        return {
+            ...this.config.llm,
+        };
+    }
 }

package/dist/config/schemas.js

@@ -26,6 +26,7 @@ export const ApocConfigSchema = LLMConfigSchema.extend({
     working_dir: z.string().optional(),
     timeout_ms: z.number().int().positive().optional(),
 });
+export const NeoConfigSchema = LLMConfigSchema;
 export const WebhookConfigSchema = z.object({
     telegram_notify_all: z.boolean().optional(),
 }).optional();
@@ -37,12 +38,18 @@ export const ConfigSchema = z.object({
     }).default(DEFAULT_CONFIG.agent),
     llm: LLMConfigSchema.default(DEFAULT_CONFIG.llm),
     sati: SatiConfigSchema.optional(),
+    neo: NeoConfigSchema.optional(),
     apoc: ApocConfigSchema.optional(),
     webhooks: WebhookConfigSchema,
     audio: AudioConfigSchema.default(DEFAULT_CONFIG.audio),
     memory: z.object({
         limit: z.number().int().positive().optional(),
     }).default(DEFAULT_CONFIG.memory),
+    runtime: z.object({
+        async_tasks: z.object({
+            enabled: z.boolean().default(DEFAULT_CONFIG.runtime?.async_tasks.enabled ?? true),
+        }).default(DEFAULT_CONFIG.runtime?.async_tasks ?? { enabled: true }),
+    }).optional(),
     channels: z.object({
         telegram: z.object({
             enabled: z.boolean().default(false),

package/dist/devkit/tools/network.js

@@ -64,7 +64,7 @@ export function createNetworkTools(ctx) {
             });
         }, {
             name: 'ping',
-            description: 'Check if a host is reachable on a given port (TCP connect check).',
+            description: 'Preferred connectivity check tool. Verify if a host is reachable on a given port (TCP connect check). Use this instead of shell ping for routine reachability checks.',
             schema: z.object({
                 host: z.string().describe('Hostname or IP'),
                 port: z.number().int().optional().describe('Port to check, default 80'),

package/dist/http/api.js

@@ -11,6 +11,7 @@ import { z } from 'zod';
 import { MCPManager } from '../config/mcp-manager.js';
 import { MCPServerConfigSchema } from '../config/schemas.js';
 import { Construtor } from '../runtime/tools/factory.js';
+import { TaskRepository } from '../runtime/tasks/repository.js';
 async function readLastLines(filePath, n) {
     try {
         const content = await fs.readFile(filePath, 'utf8');
@@ -25,6 +26,7 @@ export function createApiRouter(oracle) {
     const router = Router();
     const configManager = ConfigManager.getInstance();
     const history = new SQLiteChatMessageHistory({ sessionId: 'api-reader' });
+    const taskRepository = TaskRepository.getInstance();
     // --- Session Management ---
     router.get('/sessions', async (req, res) => {
         try {
@@ -83,18 +85,76 @@ export function createApiRouter(oracle) {
         const { id } = req.params;
         const sessionHistory = new SQLiteChatMessageHistory({ sessionId: id, limit: 100 });
         try {
-            const messages = await sessionHistory.getMessages();
-            // Normalize messages for UI
-            const normalizedMessages = messages.map((msg) => {
-                const type = msg._getType ? msg._getType() : 'unknown';
+            const relatedSessionIds = id.startsWith('sati-evaluation-')
+                ? [id]
+                : [id, `sati-evaluation-${id}`];
+            const rows = await sessionHistory.getRawMessagesBySessionIds(relatedSessionIds, 200);
+            const normalizedMessages = rows.map((row) => {
+                let content = row.content;
+                let tool_calls;
+                let tool_name;
+                let tool_call_id;
+                if (row.type === 'ai') {
+                    try {
+                        const parsed = JSON.parse(row.content);
+                        if (parsed && typeof parsed === 'object') {
+                            if (Array.isArray(parsed.tool_calls)) {
+                                tool_calls = parsed.tool_calls;
+                            }
+                            if (typeof parsed.text === 'string') {
+                                content = parsed.text;
+                            }
+                        }
+                    }
+                    catch {
+                        // Keep raw content for legacy/plain-text messages.
+                    }
+                }
+                if (row.type === 'tool') {
+                    try {
+                        const parsed = JSON.parse(row.content);
+                        if (parsed && typeof parsed === 'object') {
+                            if (parsed.content !== undefined) {
+                                const parsedContent = parsed.content;
+                                content =
+                                    typeof parsedContent === 'string'
+                                        ? parsedContent
+                                        : JSON.stringify(parsedContent, null, 2);
+                            }
+                            if (typeof parsed.name === 'string') {
+                                tool_name = parsed.name;
+                            }
+                            if (typeof parsed.tool_call_id === 'string') {
+                                tool_call_id = parsed.tool_call_id;
+                            }
+                        }
+                    }
+                    catch {
+                        // Keep raw content for legacy/plain-text tool messages.
+                    }
+                }
+                const usage_metadata = row.total_tokens != null
+                    ? {
+                        input_tokens: row.input_tokens || 0,
+                        output_tokens: row.output_tokens || 0,
+                        total_tokens: row.total_tokens || 0,
+                        input_token_details: row.cache_read_tokens
+                            ? { cache_read: row.cache_read_tokens }
+                            : undefined,
+                    }
+                    : undefined;
                 return {
-                    type,
-                    content: msg.content,
-                    tool_calls: msg.tool_calls,
-                    usage_metadata: msg.usage_metadata
+                    session_id: row.session_id,
+                    created_at: row.created_at,
+                    type: row.type,
+                    content,
+                    tool_calls,
+                    tool_name,
+                    tool_call_id,
+                    usage_metadata,
                 };
             });
-            // Reverse to chronological order for UI
+            // Convert DESC to ASC for UI rendering
             res.json(normalizedMessages.reverse());
         }
         catch (err) {
@@ -117,13 +177,74 @@ export function createApiRouter(oracle) {
         try {
             const { message, sessionId } = parsed.data;
             await oracle.setSessionId(sessionId);
-            const response = await oracle.chat(message);
+            const response = await oracle.chat(message, undefined, false, {
+                origin_channel: 'ui',
+                session_id: sessionId,
+            });
             res.json({ response });
         }
         catch (err) {
             res.status(500).json({ error: err.message });
         }
     });
+    const TaskStatusSchema = z.enum(['pending', 'running', 'completed', 'failed', 'cancelled']);
+    const TaskAgentSchema = z.enum(['apoc', 'neo', 'trinit']);
+    const OriginChannelSchema = z.enum(['telegram', 'discord', 'ui', 'api', 'webhook', 'cli']);
+    router.get('/tasks', (req, res) => {
+        try {
+            const status = req.query.status;
+            const agent = req.query.agent;
+            const originChannel = req.query.origin_channel;
+            const sessionId = req.query.session_id;
+            const limit = req.query.limit;
+            const parsedStatus = typeof status === 'string' ? TaskStatusSchema.safeParse(status) : null;
+            const parsedAgent = typeof agent === 'string' ? TaskAgentSchema.safeParse(agent) : null;
+            const parsedOrigin = typeof originChannel === 'string' ? OriginChannelSchema.safeParse(originChannel) : null;
+            const tasks = taskRepository.listTasks({
+                status: parsedStatus?.success ? parsedStatus.data : undefined,
+                agent: parsedAgent?.success ? parsedAgent.data : undefined,
+                origin_channel: parsedOrigin?.success ? parsedOrigin.data : undefined,
+                session_id: typeof sessionId === 'string' ? sessionId : undefined,
+                limit: typeof limit === 'string' ? Math.max(1, Math.min(500, Number(limit) || 200)) : 200,
+            });
+            res.json(tasks);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.get('/tasks/stats', (req, res) => {
+        try {
+            res.json(taskRepository.getStats());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.get('/tasks/:id', (req, res) => {
+        try {
+            const task = taskRepository.getTaskById(req.params.id);
+            if (!task) {
+                return res.status(404).json({ error: 'Task not found' });
+            }
+            res.json(task);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.post('/tasks/:id/retry', (req, res) => {
+        try {
+            const ok = taskRepository.retryTask(req.params.id);
+            if (!ok) {
+                return res.status(404).json({ error: 'Failed task not found for retry' });
+            }
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // Legacy /session/reset (keep for backward compat or redirect to POST /sessions)
     router.post('/session/reset', async (req, res) => {
         try {
@@ -396,6 +517,52 @@ export function createApiRouter(oracle) {
             res.status(500).json({ error: error.message });
         }
     });
+    // Neo config endpoints
+    router.get('/config/neo', (req, res) => {
+        try {
+            const neoConfig = configManager.getNeoConfig();
+            res.json(neoConfig);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    router.post('/config/neo', async (req, res) => {
+        try {
+            const config = configManager.get();
+            await configManager.save({ ...config, neo: req.body });
+            const display = DisplayManager.getInstance();
+            display.log('Neo 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/neo', async (req, res) => {
+        try {
+            const config = configManager.get();
+            const { neo: _neo, ...restConfig } = config;
+            await configManager.save(restConfig);
+            const display = DisplayManager.getInstance();
+            display.log('Neo 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 });
+        }
+    });
     router.post('/config/apoc', async (req, res) => {
         try {
             const config = configManager.get();

package/dist/runtime/apoc.js

@@ -1,4 +1,4 @@
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
 import { ConfigManager } from "../config/manager.js";
 import { ProviderFactory } from "./providers/factory.js";
 import { ProviderError } from "./errors.js";
@@ -95,6 +95,11 @@ OPERATING RULES:
 3. Report clearly what was done and what the result was.
 4. If something fails, report the error and what you tried.
 5. Stay focused on the delegated task only.
+6. Respond in the language requested by the user. If not explicit, use the dominant language of the task/context.
+7. For connectivity checks, prefer the dedicated network tool "ping" (TCP reachability) instead of shell "ping".
+8. Only use shell ping when explicitly required by the user. If shell ping is needed, detect OS first:
+   - Windows: use "-n" (never use "-c")
+   - Linux/macOS: use "-c"
 
 
 ────────────────────────────────────────
@@ -216,27 +221,30 @@ ${context ? `CONTEXT FROM ORACLE:\n${context}` : ""}
         const messages = [systemMessage, userMessage];
         try {
             const response = await this.agent.invoke({ messages });
-            // Persist Apoc-generated messages so token usage is tracked in short-memory.db.
-            // Use the caller's session when provided, then the static session set by Oracle,
-            // otherwise fall back to 'apoc'.
+            // Persist one AI message per delegated task so usage can be parameterized later.
+            // Use task session id when provided.
             const apocConfig = this.config.apoc || this.config.llm;
-            const newMessages = response.messages.slice(messages.length);
-            if (newMessages.length > 0) {
-                const targetSession = sessionId ?? Apoc.currentSessionId ?? 'apoc';
-                const history = new SQLiteChatMessageHistory({ sessionId: targetSession });
-                for (const msg of newMessages) {
-                    msg.provider_metadata = {
-                        provider: apocConfig.provider,
-                        model: apocConfig.model,
-                    };
-                }
-                await history.addMessages(newMessages);
-                history.close();
-            }
             const lastMessage = response.messages[response.messages.length - 1];
             const content = typeof lastMessage.content === "string"
                 ? lastMessage.content
                 : JSON.stringify(lastMessage.content);
+            const targetSession = sessionId ?? Apoc.currentSessionId ?? "apoc";
+            const history = new SQLiteChatMessageHistory({ sessionId: targetSession });
+            try {
+                const persisted = new AIMessage(content);
+                persisted.usage_metadata = lastMessage.usage_metadata
+                    ?? lastMessage.response_metadata?.usage
+                    ?? lastMessage.response_metadata?.tokenUsage
+                    ?? lastMessage.usage;
+                persisted.provider_metadata = {
+                    provider: apocConfig.provider,
+                    model: apocConfig.model,
+                };
+                await history.addMessage(persisted);
+            }
+            finally {
+                history.close();
+            }
             this.display.log("Apoc task completed.", { source: "Apoc" });
             return content;
         }

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

@@ -220,7 +220,7 @@ export class SatiRepository {
         m.category as category,
         m.importance as importance,
         'long_term' as source_type,
-        (1 - vec_distance_cosine(v.embedding, ?)) * 1.7 as distance
+        (1 - vec_distance_cosine(v.embedding, ?)) * 0.8 as distance
       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
@@ -236,7 +236,7 @@ export class SatiRepository {
         'session' as category,
         'medium' as importance,
         'session_chunk' as source_type,
-        (1 - vec_distance_cosine(v.embedding, ?)) * 0.5 as distance
+        (1 - vec_distance_cosine(v.embedding, ?)) * 0.2 as distance
       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
@@ -431,6 +431,34 @@ export class SatiRepository {
             archived: Boolean(row.archived)
         };
     }
+    update(id, data) {
+        if (!this.db)
+            this.initialize();
+        const existing = this.db.prepare('SELECT * FROM long_term_memory WHERE id = ?').get(id);
+        if (!existing)
+            return null;
+        const setClauses = ['updated_at = @updated_at', 'version = version + 1'];
+        const params = { id, updated_at: new Date().toISOString() };
+        if (data.importance !== undefined) {
+            setClauses.push('importance = @importance');
+            params.importance = data.importance;
+        }
+        if (data.category !== undefined) {
+            setClauses.push('category = @category');
+            params.category = data.category;
+        }
+        if (data.summary !== undefined) {
+            setClauses.push('summary = @summary');
+            params.summary = data.summary;
+        }
+        if (data.details !== undefined) {
+            setClauses.push('details = @details');
+            params.details = data.details;
+        }
+        this.db.prepare(`UPDATE long_term_memory SET ${setClauses.join(', ')} WHERE id = @id`).run(params);
+        const updated = this.db.prepare('SELECT * FROM long_term_memory WHERE id = ?').get(id);
+        return updated ? this.mapRowToRecord(updated) : null;
+    }
     archiveMemory(id) {
         if (!this.db)
             this.initialize();

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

@@ -60,7 +60,6 @@ export class SatiService {
             const agent = await ProviderFactory.create(satiConfig, []);
             // 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),
@@ -68,7 +67,12 @@ export class SatiService {
             }));
             const inputPayload = {
                 recent_conversation: recentConversation,
-                existing_memory_summaries: existingSummaries
+                existing_memories: allMemories.map(m => ({
+                    id: m.id,
+                    category: m.category,
+                    importance: m.importance,
+                    summary: m.summary
+                }))
             };
             const messages = [
                 new SystemMessage(SATI_EVALUATION_PROMPT),
@@ -114,7 +118,7 @@ export class SatiService {
             }
             // Safe JSON parsing (handle markdown blocks if LLM wraps output)
             content = content.replace(/```json/g, '').replace(/```/g, '').trim();
-            let result = [];
+            let result = { inclusions: [], edits: [], deletions: [] };
             try {
                 result = JSON.parse(content);
             }
@@ -122,8 +126,10 @@ export class SatiService {
                 console.warn('[SatiService] Failed to parse JSON response:', content);
                 return;
             }
-            for (const item of result) {
-                if (item.should_store && item.summary && item.category && item.importance) {
+            const embeddingService = await EmbeddingService.getInstance();
+            // Process inclusions (new memories)
+            for (const item of (result.inclusions ?? [])) {
+                if (item.summary && item.category && item.importance) {
                     display.log(`Persisting new memory: [${item.category.toUpperCase()}] ${item.summary}`, { source: 'Sati' });
                     try {
                         const savedMemory = await this.repository.save({
@@ -134,22 +140,14 @@ export class SatiService {
                             hash: this.generateHash(item.summary),
                             source: 'conversation'
                         });
-                        // 🔥 GERAR EMBEDDING
-                        const embeddingService = await EmbeddingService.getInstance();
-                        const textForEmbedding = [
-                            savedMemory.summary,
-                            savedMemory.details ?? ''
-                        ].join(' ');
+                        const textForEmbedding = [savedMemory.summary, savedMemory.details ?? ''].join(' ');
                         const embedding = await embeddingService.generate(textForEmbedding);
                         display.log(`Generated embedding for memory ID ${savedMemory.id}`, { source: 'Sati', level: 'debug' });
-                        // 🔥 SALVAR EMBEDDING NO SQLITE_VEC
                         this.repository.upsertEmbedding(savedMemory.id, embedding);
-                        // 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
+                            // Duplicate detected by DB (hash collision) — expected
                         }
                         else {
                             throw saveError;
@@ -157,6 +155,39 @@ export class SatiService {
                     }
                 }
             }
+            // Process edits (update existing memories)
+            for (const edit of (result.edits ?? [])) {
+                if (!edit.id)
+                    continue;
+                const updated = this.repository.update(edit.id, {
+                    importance: edit.importance,
+                    summary: edit.summary,
+                    details: edit.details,
+                });
+                if (updated) {
+                    display.log(`Updated memory ${edit.id}: ${edit.reason ?? ''}`, { source: 'Sati' });
+                    if (edit.summary || edit.details) {
+                        const text = [updated.summary, updated.details ?? ''].join(' ');
+                        const embedding = await embeddingService.generate(text);
+                        this.repository.upsertEmbedding(updated.id, embedding);
+                    }
+                }
+                else {
+                    display.log(`Edit skipped — memory not found: ${edit.id}`, { source: 'Sati', level: 'warning' });
+                }
+            }
+            // Process deletions (archive memories)
+            for (const deletion of (result.deletions ?? [])) {
+                if (!deletion.id)
+                    continue;
+                const archived = this.repository.archiveMemory(deletion.id);
+                if (archived) {
+                    display.log(`Archived memory ${deletion.id}: ${deletion.reason ?? ''}`, { source: 'Sati' });
+                }
+                else {
+                    display.log(`Deletion skipped — memory not found: ${deletion.id}`, { source: 'Sati', level: 'warning' });
+                }
+            }
         }
         catch (error) {
             console.error('[SatiService] Evaluation failed:', error);