morpheus-cli 0.4.14 → 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";
@@ -41,7 +41,7 @@ export class Apoc {
     }
     async initialize() {
         const apocConfig = this.config.apoc || this.config.llm;
-        console.log(`Apoc configuration: ${JSON.stringify(apocConfig)}`);
+        // console.log(`Apoc configuration: ${JSON.stringify(apocConfig)}`);
         const working_dir = this.config.apoc?.working_dir || process.cwd();
         const timeout_ms = this.config.apoc?.timeout_ms || 30_000;
         // Import all devkit tool factories (side-effect registration)
@@ -95,21 +95,125 @@ 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"
+
+
+────────────────────────────────────────
+BROWSER AUTOMATION PROTOCOL
+────────────────────────────────────────
+
+When using browser tools (browser_navigate, browser_get_dom, browser_click, browser_fill), follow this protocol exactly.
+
+GENERAL PRINCIPLES
+- Never guess selectors.
+- Never assume page state.
+- Always verify page transitions.
+- Always extract evidence of success.
+- If required user data is missing, STOP and return to Oracle immediately.
+
+PHASE 1 — Navigation
+1. ALWAYS call browser_navigate first.
+2. Use:
+   - wait_until: "networkidle0" for SPAs or JS-heavy pages.
+   - wait_until: "domcontentloaded" for simple pages.
+3. After navigation, confirm current_url and title.
+4. If navigation fails, report the error and stop.
+
+PHASE 2 — DOM Inspection (MANDATORY BEFORE ACTION)
+1. ALWAYS call browser_get_dom before browser_click or browser_fill.
+2. Identify stable selectors (prefer id > name > role > unique class).
+3. Understand page structure and expected flow before interacting.
+4. Never click or fill blindly.
+
+PHASE 3 — Interaction
+When clicking:
+- Prefer stable selectors.
+- If ambiguous, refine selector.
+- Use visible text only if selector is unstable.
+
+When filling:
+- Confirm correct input field via DOM.
+- Fill field.
+- Submit using press_enter OR clicking submit button.
+
+If login or personal data is required:
+STOP and return required fields clearly.
+
+PHASE 4 — State Verification (MANDATORY)
+After ANY interaction:
+1. Call browser_get_dom again.
+2. Verify URL change or content change.
+3. Confirm success or detect error message.
+
+If expected change did not occur:
+- Reinspect DOM.
+- Attempt one justified alternative.
+- If still failing, report failure clearly.
+
+Maximum 2 attempts per step.
+Never assume success.
+
+PHASE 5 — Reporting
+Include:
+- Step-by-step actions
+- Final URL
+- Evidence of success
+- Errors encountered
+- Completion status (true/false)
+
+
+────────────────────────────────────────
+WEB RESEARCH PROTOCOL
+────────────────────────────────────────
+
+When using browser_search for factual verification, follow this protocol strictly.
+
+PHASE 1 — Query Design
+1. Identify core entity, information type, and time constraint.
+2. Build a precise search query.
+3. If time-sensitive, include the current year.
+
+PHASE 2 — Source Discovery
+1. Call browser_search.
+2. Collect results.
+3. Prioritize:
+   - Official sources
+   - Major authoritative publications
+4. Reformulate query if necessary.
+
+PHASE 3 — Source Validation (MANDATORY)
+1. Open at least 3 distinct URLs with browser_navigate.
+2. Read actual page content.
+3. NEVER rely only on search snippets.
+4. Ignore inaccessible pages.
+
+PHASE 4 — Cross-Verification
+1. Extract relevant information from each source.
+2. Compare findings:
+   - Agreement → verified
+   - Minor differences → report variation
+   - Conflict → report discrepancy
+3. Require confirmation from at least 2 reliable sources.
+4. If not confirmed, state clearly:
+   "Information could not be confidently verified."
+
+PHASE 5 — Structured Report
+Include:
+- Direct answer
+- Short explanation
+- Source URLs
+- Confidence level (High / Medium / Low)
+
+ANTI-HALLUCINATION RULES
+- Never answer from prior knowledge without verification.
+- Never stop after reading only one source.
+- Treat time-sensitive information as volatile.
+
 
-BROWSER WORKFLOW RULES (when using browser tools):
-1. ALWAYS call browser_navigate first to load the page.
-2. ALWAYS call browser_get_dom before browser_click or browser_fill to inspect the page structure and choose the correct CSS selectors. Never guess selectors — analyze the DOM.
-3. Analyze the DOM to identify interactive elements (inputs, buttons, links), their selectors (id, class, name), and the page flow.
-4. If the task requires information you don't have (e.g. email, password, form fields, personal data), DO NOT proceed. Instead, immediately return to Oracle with a clear message listing exactly what information is needed from the user. Example: "To complete the login form I need: email address and password."
-5. After clicking or filling, call browser_get_dom again to verify the page changed as expected.
-6. Report what was done, the final URL, and any relevant content extracted.
-
-SEARCH & FACT-CHECKING RULES (when using browser_search to answer factual questions):
-1. Call browser_search first to get a list of relevant sources.
-2. ALWAYS open at least 3 of the returned URLs with browser_navigate to read the actual content. Do not rely solely on the snippet — snippets may be outdated or incomplete.
-3. Cross-reference the information across the sources. If they agree, report the fact with confidence. If they disagree, report all versions found and indicate the discrepancy.
-4. Prefer authoritative sources (official team sites, major sports outlets, official event pages) over aggregators.
-5. Include the source URLs in your final report so Oracle can pass them to the user.
 
 ${context ? `CONTEXT FROM ORACLE:\n${context}` : ""}
     `);
@@ -117,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();