memory-mimir 1.0.0

package/dist/index.js

@@ -0,0 +1,905 @@
+/**
+ * memory-mimir: OpenClaw plugin entry point.
+ *
+ * Replaces OpenClaw's built-in file-backed memory with Mimir
+ * as a full long-term memory backend (graph + vector + BM25).
+ */
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { Type } from "@sinclair/typebox";
+import { MimirClient, MimirError } from "./mimir-client.js";
+import { formatSearchResults } from "./formatter.js";
+import { migrate, hasExistingData, hasLocalMemories } from "./migration.js";
+const CAPTURE_STATE_DIR = path.join(os.homedir(), ".openclaw");
+const CAPTURE_STATE_FILE = path.join(CAPTURE_STATE_DIR, "memory-mimir-capture.json");
+function loadCaptureState() {
+    try {
+        const data = fs.readFileSync(CAPTURE_STATE_FILE, "utf8");
+        const parsed = JSON.parse(data);
+        if (Array.isArray(parsed.ingestedHashes)) {
+            return { ingestedHashes: parsed.ingestedHashes };
+        }
+    }
+    catch {
+        // File doesn't exist or is corrupt — start fresh.
+    }
+    return { ingestedHashes: [] };
+}
+function saveCaptureState(state) {
+    try {
+        fs.mkdirSync(CAPTURE_STATE_DIR, { recursive: true });
+        fs.writeFileSync(CAPTURE_STATE_FILE, JSON.stringify(state));
+    }
+    catch {
+        // Best-effort — don't crash if write fails.
+    }
+}
+/** Stable hash for a parsed message — used to skip already-ingested messages. */
+function hashMsg(role, content) {
+    return crypto
+        .createHash("sha256")
+        .update(role + "\x00" + content)
+        .digest("hex")
+        .slice(0, 16);
+}
+function resolveConfig(pluginConfig) {
+    return {
+        mimirUrl: pluginConfig.mimirUrl ??
+            process.env.MIMIR_URL ??
+            "https://api.allinmimir.com",
+        apiKey: pluginConfig.apiKey ?? process.env.MIMIR_API_KEY ?? "",
+        userId: pluginConfig.userId ?? process.env.MIMIR_USER_ID ?? "",
+        groupId: pluginConfig.groupId ?? process.env.MIMIR_GROUP_ID ?? "",
+        autoRecall: pluginConfig.autoRecall ??
+            process.env.MIMIR_AUTO_RECALL !== "false",
+        autoCapture: pluginConfig.autoCapture ??
+            process.env.MIMIR_AUTO_CAPTURE !== "false",
+        maxRecallTokens: parsePositiveInt(pluginConfig.maxRecallTokens, 500),
+        maxRecallItems: parsePositiveInt(pluginConfig.maxRecallItems, 8),
+    };
+}
+function parsePositiveInt(value, fallback) {
+    if (value === undefined || value === null)
+        return fallback;
+    const n = Math.floor(value);
+    return n > 0 ? n : fallback;
+}
+// ─── Keyword Extraction (no LLM) ───────────────────────────
+const STOP_WORDS = new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "can",
+    "shall",
+    "must",
+    "need",
+    "dare",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "and",
+    "but",
+    "or",
+    "nor",
+    "not",
+    "so",
+    "yet",
+    "both",
+    "either",
+    "neither",
+    "each",
+    "every",
+    "all",
+    "any",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "no",
+    "only",
+    "own",
+    "same",
+    "than",
+    "too",
+    "very",
+    "just",
+    "about",
+    "also",
+    "back",
+    "even",
+    "still",
+    "then",
+    "there",
+    "here",
+    "when",
+    "where",
+    "why",
+    "how",
+    "what",
+    "which",
+    "who",
+    "whom",
+    "this",
+    "that",
+    "these",
+    "those",
+    "it",
+    "its",
+    "i",
+    "me",
+    "my",
+    "we",
+    "our",
+    "you",
+    "your",
+    "he",
+    "she",
+    "him",
+    "her",
+    "they",
+    "them",
+    "their",
+    "if",
+    "up",
+    "out",
+    "please",
+    "tell",
+    "know",
+    "think",
+    "want",
+    "like",
+    "get",
+    "make",
+    "go",
+    "come",
+    "take",
+    "see",
+    "look",
+    "find",
+    "give",
+    "use",
+    "say",
+    "said",
+    "help",
+    "try",
+    "let",
+    "put",
+    "keep",
+    "start",
+    "remember",
+    "recall",
+    "mentioned",
+    "talked",
+    "discussed",
+]);
+/** Detect CJK characters in text. */
+function hasCJK(text) {
+    return /[\u4e00-\u9fff\u3400-\u4dbf\uF900-\uFAFF\u3040-\u309F\u30A0-\u30FF\uAC00-\uD7AF]/.test(text);
+}
+/**
+ * Extract plain text from a message content block (string or array).
+ * Handles mixed content: text, tool_use, tool_result, image, document.
+ * - text blocks: included as-is
+ * - tool_use: "[工具: name(args)]" so we know what was invoked
+ * - tool_result: recursively extract text (web fetch results, file reads, etc.)
+ * - image: "[图片]" placeholder — OpenClaw's reply will describe it
+ * - document: "[文档]" placeholder
+ */
+export function extractMessageText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        switch (block.type) {
+            case "text":
+                if (typeof block.text === "string")
+                    parts.push(block.text);
+                break;
+            case "tool_result": {
+                // Recursively extract nested text (e.g. WebFetch, Read results)
+                const inner = extractMessageText(block.content);
+                if (inner)
+                    parts.push(inner);
+                break;
+            }
+            case "tool_use":
+                // Record which tool was called so context isn't lost
+                if (typeof block.name === "string") {
+                    const args = block.input ? JSON.stringify(block.input) : "";
+                    parts.push(`[工具: ${block.name}(${args})]`);
+                }
+                break;
+            case "image":
+                parts.push("[图片]");
+                break;
+            case "document":
+                parts.push("[文档]");
+                break;
+        }
+    }
+    return parts.filter(Boolean).join("\n");
+}
+/** Extract searchable topics from user message — pure heuristic, no LLM.
+ *  For CJK text: pass first 200 chars directly (server has LLMTranslator + RuleAnalyzer).
+ *  For English: extract up to 8 non-stop-word tokens.
+ */
+export function extractKeywords(message) {
+    // CJK: pass raw text to server — it handles segmentation and translation
+    if (hasCJK(message)) {
+        return message.slice(0, 200).trim();
+    }
+    const words = message
+        .toLowerCase()
+        .replace(/[^\w\s'-]/g, " ")
+        .split(/\s+/)
+        .filter((w) => w.length > 2 && !STOP_WORDS.has(w));
+    const unique = [...new Set(words)].slice(0, 8);
+    return unique.join(" ");
+}
+/** Extract time range from user message using keyword matching.
+ *  Returns undefined if no temporal reference is found.
+ */
+export function extractTimeRange(message) {
+    const lower = message.toLowerCase();
+    const now = new Date();
+    const today = new Date(Date.UTC(now.getFullYear(), now.getMonth(), now.getDate()));
+    const rules = [
+        {
+            keywords: ["yesterday", "昨天"],
+            start: addDays(today, -1),
+            end: today,
+        },
+        {
+            keywords: ["day before yesterday", "前天"],
+            start: addDays(today, -2),
+            end: addDays(today, -1),
+        },
+        {
+            keywords: ["last week", "上周", "上个星期"],
+            start: addDays(today, -7),
+            end: today,
+        },
+        {
+            keywords: ["this week", "这周", "这个星期"],
+            start: addDays(today, -today.getUTCDay()),
+            end: addDays(today, 1),
+        },
+        {
+            keywords: ["last month", "上个月"],
+            start: addMonths(today, -1),
+            end: today,
+        },
+        {
+            keywords: ["this month", "这个月"],
+            start: new Date(Date.UTC(now.getFullYear(), now.getMonth(), 1)),
+            end: addDays(today, 1),
+        },
+        {
+            keywords: ["last year", "去年"],
+            start: addYears(today, -1),
+            end: today,
+        },
+        {
+            keywords: ["this year", "今年"],
+            start: new Date(Date.UTC(now.getFullYear(), 0, 1)),
+            end: addDays(today, 1),
+        },
+        {
+            keywords: ["today", "今天"],
+            start: today,
+            end: addDays(today, 1),
+        },
+    ];
+    for (const rule of rules) {
+        for (const kw of rule.keywords) {
+            if (lower.includes(kw)) {
+                return {
+                    start: rule.start.toISOString(),
+                    end: rule.end.toISOString(),
+                };
+            }
+        }
+    }
+    return undefined;
+}
+function addDays(date, days) {
+    const d = new Date(date.getTime());
+    d.setUTCDate(d.getUTCDate() + days);
+    return d;
+}
+function addMonths(date, months) {
+    const d = new Date(date.getTime());
+    d.setUTCMonth(d.getUTCMonth() + months);
+    return d;
+}
+function addYears(date, years) {
+    const d = new Date(date.getTime());
+    d.setUTCFullYear(d.getUTCFullYear() + years);
+    return d;
+}
+// ─── Plugin Definition ──────────────────────────────────────
+const memoryMimirPlugin = {
+    id: "memory-mimir",
+    name: "Memory (Mimir)",
+    description: "Mimir-powered long-term memory for OpenClaw",
+    kind: "memory",
+    configSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            mimirUrl: {
+                type: "string",
+                description: "Mimir server URL (e.g. http://localhost:8766)",
+            },
+            userId: {
+                type: "string",
+                description: "User ID for Mimir memory isolation",
+            },
+            groupId: { type: "string", description: "Group ID for memory scoping" },
+            autoRecall: {
+                type: "boolean",
+                description: "Auto-inject relevant memories before agent starts",
+            },
+            autoCapture: {
+                type: "boolean",
+                description: "Auto-capture conversations after agent ends",
+            },
+            maxRecallItems: {
+                type: "number",
+                description: "Maximum number of memory items to recall",
+            },
+            maxRecallTokens: {
+                type: "number",
+                description: "Maximum tokens for recalled memory context",
+            },
+        },
+    },
+    register(api) {
+        const rawCfg = resolveConfig(api.pluginConfig ?? {});
+        const client = new MimirClient({
+            url: rawCfg.mimirUrl,
+            apiKey: rawCfg.apiKey,
+        });
+        // Resolved config — userId/groupId may be filled in after /api/v1/me lookup
+        let cfg = rawCfg;
+        // If apiKey is set but userId is empty, auto-fetch from /api/v1/me
+        if (rawCfg.apiKey && !rawCfg.userId) {
+            client
+                .me()
+                .then((me) => {
+                cfg = { ...rawCfg, userId: me.user_id, groupId: me.group_id };
+                api.logger.info(`memory-mimir: authenticated as ${me.display_name} (user: ${me.user_id}, server: ${rawCfg.mimirUrl})`);
+            })
+                .catch((err) => {
+                api.logger.warn(`memory-mimir: failed to fetch identity from /api/v1/me: ${String(err)}`);
+            });
+        }
+        else {
+            api.logger.info(`memory-mimir: registered (user: ${rawCfg.userId}, server: ${rawCfg.mimirUrl})`);
+        }
+        // ════════════════════════════════════════════════════════
+        // Tools
+        // ════════════════════════════════════════════════════════
+        api.registerTool({
+            name: "mimir_search",
+            label: "Mimir Search",
+            description: "Search long-term memory for past conversations, facts, entities, and relationships. " +
+                "Use when the user asks about past events, people, or previously discussed topics.",
+            parameters: Type.Object({
+                query: Type.String({ description: "The search query" }),
+                types: Type.Optional(Type.String({
+                    description: "Comma-separated memory types: episode,entity,relation,event_log,foresight. Default: all.",
+                })),
+                startTime: Type.Optional(Type.String({
+                    description: "Filter results after this time (ISO 8601, e.g. 2026-02-25T00:00:00Z).",
+                })),
+                endTime: Type.Optional(Type.String({
+                    description: "Filter results before this time (ISO 8601, e.g. 2026-03-04T00:00:00Z).",
+                })),
+            }),
+            async execute(_toolCallId, params) {
+                const query = params.query;
+                const typesStr = params.types;
+                const memoryTypes = typesStr?.split(",").map((t) => t.trim()) ?? undefined;
+                const startTime = params.startTime;
+                const endTime = params.endTime;
+                try {
+                    const results = await client.search(cfg.userId, query, {
+                        groupId: cfg.groupId,
+                        memoryTypes,
+                        topK: 10,
+                        retrieveMethod: "agentic",
+                        startTime,
+                        endTime,
+                    });
+                    if (results.results.length === 0) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "No memories found matching your query.",
+                                },
+                            ],
+                            details: { count: 0 },
+                        };
+                    }
+                    const formatted = formatSearchResults(results, {
+                        maxItems: 10,
+                        maxChars: 4000,
+                    });
+                    return {
+                        content: [{ type: "text", text: formatted }],
+                        details: { count: results.results.length },
+                    };
+                }
+                catch (err) {
+                    const msg = err instanceof MimirError ? err.message : String(err);
+                    return {
+                        content: [{ type: "text", text: `Memory search failed: ${msg}` }],
+                        details: { error: msg },
+                    };
+                }
+            },
+        }, { name: "mimir_search" });
+        api.registerTool({
+            name: "mimir_store",
+            label: "Mimir Store",
+            description: "Store an important fact, preference, or note in long-term memory. " +
+                'Use when the user says "remember this" or shares important information.',
+            parameters: Type.Object({
+                content: Type.String({
+                    description: "The fact, preference, or note to remember",
+                }),
+            }),
+            async execute(_toolCallId, params) {
+                const content = params.content;
+                try {
+                    const result = await client.ingestNote(cfg.userId, content, {
+                        groupId: cfg.groupId,
+                    });
+                    const text = `Stored in memory. Extracted ${result.EpisodeCount} episode(s), ` +
+                        `${result.EntityCount} entity(ies), ${result.RelationCount} relation(s).`;
+                    return {
+                        content: [{ type: "text", text }],
+                        details: {
+                            episodes: result.EpisodeCount,
+                            entities: result.EntityCount,
+                        },
+                    };
+                }
+                catch (err) {
+                    const msg = err instanceof MimirError ? err.message : String(err);
+                    return {
+                        content: [
+                            { type: "text", text: `Failed to store memory: ${msg}` },
+                        ],
+                        details: { error: msg },
+                    };
+                }
+            },
+        }, { name: "mimir_store" });
+        api.registerTool({
+            name: "mimir_forget",
+            label: "Mimir Forget",
+            description: "Look up information in memory the user wants to forget. " +
+                "NOTE: Deletion is not yet implemented — this shows what would be affected.",
+            parameters: Type.Object({
+                query: Type.String({ description: "Description of what to forget" }),
+            }),
+            async execute(_toolCallId, params) {
+                const query = params.query?.trim();
+                if (!query || query.length > 1000) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "Error: query must be 1-1000 characters.",
+                            },
+                        ],
+                        details: { error: "invalid_query" },
+                    };
+                }
+                try {
+                    const results = await client.search(cfg.userId, query, {
+                        groupId: cfg.groupId,
+                        topK: 5,
+                    });
+                    if (results.results.length === 0) {
+                        return {
+                            content: [
+                                { type: "text", text: "No matching memories found." },
+                            ],
+                            details: { count: 0 },
+                        };
+                    }
+                    const preview = formatSearchResults(results, {
+                        maxItems: 5,
+                        maxChars: 2000,
+                    });
+                    const text = `Found ${results.results.length} matching item(s). ` +
+                        `Deletion is not yet supported.\n\n${preview}`;
+                    return {
+                        content: [{ type: "text", text }],
+                        details: { count: results.results.length },
+                    };
+                }
+                catch (err) {
+                    const msg = err instanceof MimirError ? err.message : String(err);
+                    return {
+                        content: [{ type: "text", text: `Forget lookup failed: ${msg}` }],
+                        details: { error: msg },
+                    };
+                }
+            },
+        }, { name: "mimir_forget" });
+        // ════════════════════════════════════════════════════════
+        // CLI Commands
+        // ════════════════════════════════════════════════════════
+        api.registerCli(({ program }) => {
+            const mimir = program
+                .command("mimir")
+                .description("Mimir memory plugin commands");
+            mimir
+                .command("setup")
+                .description("Configure memory-mimir with an API key from allinmimir.com")
+                .option("--api-key <key>", "Your Mimir API key (sk-mimir-...)")
+                .option("--url <url>", "Mimir server URL", "https://api.allinmimir.com")
+                .action(async (...args) => {
+                const opts = (args[0] ?? {});
+                const apiKey = opts["api-key"] || opts["apiKey"] || cfg.apiKey;
+                const mimirUrl = opts.url || cfg.mimirUrl;
+                if (!apiKey) {
+                    console.error(`Error: --api-key is required.`);
+                    console.error(`  Get your API key at https://allinmimir.com/dashboard`);
+                    console.error(`  Usage: openclaw mimir setup --api-key sk-mimir-xxx`);
+                    return;
+                }
+                console.log(`Validating API key...`);
+                const tempClient = new MimirClient({ url: mimirUrl, apiKey });
+                let identity;
+                try {
+                    identity = await tempClient.me();
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.error(`Error: ${msg}`);
+                    console.error(`  Check your API key or run: openclaw mimir setup --api-key sk-mimir-xxx`);
+                    return;
+                }
+                // Write to OpenClaw plugin config
+                const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
+                let ocConfig = {};
+                try {
+                    const data = fs.readFileSync(configPath, "utf8");
+                    ocConfig = JSON.parse(data);
+                }
+                catch {
+                    // Config doesn't exist yet — start fresh
+                }
+                const plugins = ocConfig.plugins ?? {};
+                const entries = plugins.entries ?? {};
+                const existing = entries["memory-mimir"] ?? {};
+                const pluginCfg = existing.config ?? {};
+                const updatedConfig = {
+                    ...ocConfig,
+                    plugins: {
+                        ...plugins,
+                        enabled: true,
+                        entries: {
+                            ...entries,
+                            "memory-mimir": {
+                                ...existing,
+                                enabled: true,
+                                config: {
+                                    ...pluginCfg,
+                                    apiKey,
+                                    mimirUrl,
+                                    userId: identity.user_id,
+                                    groupId: identity.group_id,
+                                    autoRecall: true,
+                                    autoCapture: true,
+                                },
+                            },
+                        },
+                    },
+                };
+                fs.mkdirSync(path.dirname(configPath), { recursive: true });
+                fs.writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2));
+                console.log();
+                console.log(`✓ Authenticated as: ${identity.display_name}`);
+                console.log(`  User ID:   ${identity.user_id}`);
+                console.log(`  Server:    ${mimirUrl}`);
+                console.log(`  Config:    ${configPath}`);
+                console.log();
+                console.log(`Restart OpenClaw to activate memory-mimir.`);
+            });
+            mimir
+                .command("migrate")
+                .description("Import existing OpenClaw/Claude Code memories into Mimir")
+                .argument("[path]", "Override memory directory path")
+                .option("--force", "Migrate even if user already has data")
+                .option("--background", "Run migration in the background (non-blocking)")
+                .action(async (...args) => {
+                const memoryDir = args[0];
+                const opts = (args[1] ?? {});
+                const healthy = await client.health();
+                if (!healthy) {
+                    console.error(`Cannot reach Mimir at ${cfg.mimirUrl}. Run "openclaw mimir setup" first.`);
+                    return;
+                }
+                const existingData = await hasExistingData(client, cfg.userId);
+                if (existingData && !opts.force) {
+                    console.log(`User "${cfg.userId}" already has data in Mimir. Use --force to migrate anyway.`);
+                    return;
+                }
+                const runMigration = async () => {
+                    const result = await migrate(client, {
+                        userId: cfg.userId,
+                        groupId: cfg.groupId,
+                        memoryDir,
+                        onProgress: (current, total, filename) => {
+                            if (opts.background) {
+                                api.logger.info(`memory-mimir: migrating ${current}/${total}: ${filename}`);
+                            }
+                            else {
+                                console.log(`Migrating ${current}/${total}: ${filename}`);
+                            }
+                        },
+                    });
+                    const summary = `Migration: ${result.filesIngested}/${result.filesFound} files, ` +
+                        `${result.totalEpisodes} episodes, ${result.totalEntities} entities`;
+                    if (opts.background) {
+                        api.logger.info(`memory-mimir: ${summary}`);
+                        if (result.errors.length > 0) {
+                            api.logger.warn(`memory-mimir: migration errors: ${result.errors.join(", ")}`);
+                        }
+                    }
+                    else {
+                        console.log(`\nMigration Complete`);
+                        console.log(`─────────────────`);
+                        console.log(`Files found:    ${result.filesFound}`);
+                        console.log(`Files ingested: ${result.filesIngested}`);
+                        console.log(`Files failed:   ${result.filesFailed}`);
+                        console.log(`Episodes:       ${result.totalEpisodes}`);
+                        console.log(`Entities:       ${result.totalEntities}`);
+                        console.log(`Relations:      ${result.totalRelations}`);
+                        if (result.errors.length > 0) {
+                            console.log(`\nErrors:`);
+                            for (const err of result.errors) {
+                                console.log(`  - ${err}`);
+                            }
+                        }
+                    }
+                    return result;
+                };
+                if (opts.background) {
+                    console.log("Migration started in background. Check logs for progress.");
+                    // Fire and forget — don't await
+                    runMigration().catch((err) => {
+                        api.logger.error(`memory-mimir: background migration failed: ${String(err)}`);
+                    });
+                }
+                else {
+                    await runMigration();
+                }
+            });
+            mimir
+                .command("search")
+                .description("Search Mimir memory from the terminal")
+                .argument("<query>", "Search query")
+                .option("--limit <n>", "Max results", "10")
+                .action(async (...actionArgs) => {
+                const query = actionArgs[0];
+                const opts = (actionArgs[1] ?? {});
+                try {
+                    const results = await client.search(cfg.userId, query, {
+                        groupId: cfg.groupId,
+                        topK: parseInt(opts.limit, 10) || 10,
+                    });
+                    if (results.results.length === 0) {
+                        console.log("No results found.");
+                        return;
+                    }
+                    console.log(formatSearchResults(results, { maxItems: 10, maxChars: 4000 }));
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.error(`Search failed: ${msg}`);
+                }
+            });
+            mimir
+                .command("status")
+                .description("Show Mimir connection status and memory statistics")
+                .action(async () => {
+                const healthy = await client.health();
+                console.log(`Connection: ${healthy ? "OK" : "FAILED"}`);
+                if (!healthy) {
+                    console.log(`Cannot reach ${cfg.mimirUrl}`);
+                    return;
+                }
+                try {
+                    const episodeSearch = await client.search(cfg.userId, "*", {
+                        groupId: cfg.groupId,
+                        memoryTypes: ["episode"],
+                        topK: 1,
+                    });
+                    const entitySearch = await client.search(cfg.userId, "*", {
+                        groupId: cfg.groupId,
+                        memoryTypes: ["entity"],
+                        topK: 1,
+                    });
+                    console.log(`User:       ${cfg.userId}`);
+                    console.log(`Episodes:   ${episodeSearch.results.length > 0 ? "present" : "none"}`);
+                    console.log(`Entities:   ${entitySearch.results.length > 0 ? "present" : "none"}`);
+                    const localMemories = await hasLocalMemories();
+                    if (localMemories) {
+                        console.log();
+                        console.log(`Local memory files found. Run "openclaw mimir migrate" to import them.`);
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.log(`Stats unavailable: ${msg}`);
+                }
+            });
+        }, { commands: ["mimir"] });
+        // ════════════════════════════════════════════════════════
+        // Lifecycle Hooks
+        // ════════════════════════════════════════════════════════
+        // Auto-recall: inject relevant memories before agent starts
+        if (cfg.autoRecall) {
+            api.on("before_agent_start", async (event) => {
+                const prompt = event.prompt;
+                if (!prompt || prompt.length < 5)
+                    return;
+                try {
+                    const query = extractKeywords(prompt);
+                    if (!query)
+                        return;
+                    const timeRange = extractTimeRange(prompt);
+                    const results = await client.search(cfg.userId, query, {
+                        groupId: cfg.groupId,
+                        topK: cfg.maxRecallItems,
+                        retrieveMethod: "agentic",
+                        startTime: timeRange?.start,
+                        endTime: timeRange?.end,
+                    });
+                    if (results.results.length === 0) {
+                        api.logger.info(`memory-mimir: no memories found (query: ${query.slice(0, 60)})`);
+                        return;
+                    }
+                    api.logger.info(`memory-mimir: injecting ${results.results.length} memories into context`);
+                    const formatted = formatSearchResults(results, {
+                        maxItems: cfg.maxRecallItems,
+                        maxChars: cfg.maxRecallTokens * 4,
+                    });
+                    return {
+                        prependContext: `<memories>\n${formatted}\n</memories>`,
+                    };
+                }
+                catch (err) {
+                    api.logger.warn(`memory-mimir: recall failed: ${String(err)}`);
+                }
+            });
+        }
+        // Auto-capture: ingest conversation to Mimir after agent ends.
+        // Uses per-message content hashing to track what has already been ingested,
+        // so restarts and session compaction never cause re-ingestion or missed messages.
+        if (cfg.autoCapture) {
+            const CONTEXT_WINDOW = 4; // preceding (already-ingested) messages for LLM context
+            const savedState = loadCaptureState();
+            const ingestedHashes = new Set(savedState.ingestedHashes);
+            api.on("agent_end", async (event) => {
+                const messages = event.messages;
+                if (!messages || messages.length === 0)
+                    return;
+                try {
+                    const allParsed = [];
+                    for (const msg of messages) {
+                        if (!msg || typeof msg !== "object")
+                            continue;
+                        const role = msg.role;
+                        if (role !== "user" && role !== "assistant")
+                            continue;
+                        const content = extractMessageText(msg.content);
+                        if (!content || content.includes("<memories>"))
+                            continue;
+                        allParsed.push({
+                            role: role,
+                            sender_name: role === "user" ? cfg.userId : "assistant",
+                            content,
+                            hash: hashMsg(role, content),
+                        });
+                    }
+                    if (allParsed.length === 0)
+                        return;
+                    api.logger.info(`memory-mimir: session-end parsed=${allParsed.length}`);
+                    // Find the first new (not yet ingested) message.
+                    const firstNewIdx = allParsed.findIndex((m) => !ingestedHashes.has(m.hash));
+                    if (firstNewIdx === -1)
+                        return; // all already ingested
+                    // Include CONTEXT_WINDOW already-ingested messages for LLM context.
+                    const contextStart = Math.max(0, firstNewIdx - CONTEXT_WINDOW);
+                    const toSend = allParsed.slice(contextStart);
+                    const newCount = allParsed.length - firstNewIdx;
+                    // Mark only the new messages as ingested.
+                    for (let i = firstNewIdx; i < allParsed.length; i++) {
+                        ingestedHashes.add(allParsed[i].hash);
+                    }
+                    saveCaptureState({ ingestedHashes: [...ingestedHashes] });
+                    api.logger.info(`memory-mimir: capturing ${newCount} new messages (+${toSend.length - newCount} context)`);
+                    client
+                        .ingestSession(cfg.userId, toSend.map(({ role, sender_name, content }) => ({
+                        role,
+                        sender_name,
+                        content,
+                    })), { groupId: cfg.groupId })
+                        .then(() => {
+                        api.logger.info(`memory-mimir: captured ${toSend.length} messages`);
+                    })
+                        .catch((err) => {
+                        api.logger.warn(`memory-mimir: capture failed: ${String(err)}`);
+                    });
+                }
+                catch (err) {
+                    api.logger.warn(`memory-mimir: capture setup failed: ${String(err)}`);
+                }
+            });
+        }
+        // ════════════════════════════════════════════════════════
+        // Service
+        // ════════════════════════════════════════════════════════
+        api.registerService({
+            id: "memory-mimir",
+            start: () => {
+                api.logger.info(`memory-mimir: started (user: ${cfg.userId}, server: ${cfg.mimirUrl})`);
+            },
+            stop: () => {
+                api.logger.info("memory-mimir: stopped");
+            },
+        });
+    },
+};
+export default memoryMimirPlugin;
+//# sourceMappingURL=index.js.map