@scotthuang/engram 0.6.8 → 0.7.0

package/dist/index.js

@@ -1,1138 +0,0 @@
-/**
- * Engram Plugin - Main Entry
- *
- * 分层语义记忆系统 OpenClaw Plugin
- * kind: "memory" (exclusive slot)
- */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// OpenClaw Plugin API 没有提供类型定义，需要使用 any
-import { parseConfig } from "./config.js";
-import { RecallEngine } from "./recall.js";
-import { ProfileManager } from "./profile.js";
-import { VectorStore } from "./vector.js";
-import { ImageStore } from "./image-store.js";
-import { runSettlement, runMonthlySettle } from "./settle.js";
-import { logger } from "./logger.js";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { createRequire } from "node:module";
-const _require = createRequire(import.meta.url);
-const PKG_VERSION = _require("../package.json").version;
-// ---- 模块级单例（避免 OpenClaw 多次调用 register 时重复创建） ----
-let singletonVectorStore = null;
-let singletonRecallEngine = null;
-let singletonProfileManager = null;
-let singletonConfig = null;
-let singletonWorkspaceDir = null;
-let singletonImageStore = null;
-// ---- Auto-Settle 状态 ----
-let settleRunning = false; // 防止并发 settle
-/**
- * 获取本地日期字符串 (YYYY-MM-DD)
- * 使用本地时区而非 UTC，避免跨日期问题
- */
-function getLocalDateString() {
-    const now = new Date();
-    const year = now.getFullYear();
-    const month = String(now.getMonth() + 1).padStart(2, "0");
-    const day = String(now.getDate()).padStart(2, "0");
-    return `${year}-${month}-${day}`;
-}
-/**
- * 创建通用 LLM 调用函数（Anthropic Messages 格式）
- * 供 settle 流程使用，复用 condense 的 API 配置
- */
-function makeLlmCall(config) {
-    const apiKey = config.condense.apiKey || config.embedding.apiKey;
-    const baseUrl = config.condense.baseUrl || "https://api.minimaxi.com/anthropic";
-    const model = config.condense.model || config.settleModel || "MiniMax-M2.7-highspeed";
-    if (!apiKey)
-        return undefined;
-    return async (prompt, systemPrompt) => {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 60_000); // settle 允许 60s
-        try {
-            const response = await fetch(`${baseUrl}/v1/messages`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "x-api-key": apiKey,
-                    "anthropic-version": "2023-06-01",
-                },
-                body: JSON.stringify({
-                    model,
-                    system: systemPrompt || "",
-                    messages: [{ role: "user", content: prompt }],
-                    max_tokens: 4096,
-                    temperature: 0.3,
-                }),
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                throw new Error(`LLM API error: ${response.status}`);
-            }
-            const data = await response.json();
-            const textBlock = data.content?.find(b => b.type === "text");
-            return textBlock?.text?.trim() || "[]";
-        }
-        catch (err) {
-            clearTimeout(timeoutId);
-            throw err;
-        }
-    };
-}
-/**
- * 获取需要 settle 的日期列表
- * 扫描 short-term 目录，找出所有比今天早且未 settle 过的日期
- */
-async function getUnsettledDates(workspaceDir) {
-    const settleStateFile = path.join(workspaceDir, "memory-engram", ".last-settle");
-    const shortTermDir = path.join(workspaceDir, "memory-engram", "short-term");
-    const today = getLocalDateString();
-    // 读取上次 settle 日期
-    let lastSettleDate = "";
-    try {
-        lastSettleDate = (await fs.readFile(settleStateFile, "utf-8")).trim();
-        logger.info(`[engram:auto-settle] Last settle date: "${lastSettleDate}"`);
-    }
-    catch {
-        // 没有记录，视为从未 settle 过
-        logger.info(`[engram:auto-settle] No .last-settle file found, first time settle check`);
-    }
-    // 扫描 short-term 目录
-    try {
-        const files = await fs.readdir(shortTermDir);
-        const mdFiles = files.filter(f => f.endsWith(".md"));
-        const dates = mdFiles
-            .map(f => f.replace(".md", ""))
-            .filter(d => /^\d{4}-\d{2}-\d{2}$/.test(d))
-            .filter(d => d < today) // 只处理前几天的，今天的还在写入中
-            .filter(d => d > lastSettleDate) // 只处理上次 settle 之后的
-            .sort();
-        logger.info(`[engram:auto-settle] Scanned short-term: ${mdFiles.length} md files, ${dates.length} unsettled (today=${today}, lastSettle="${lastSettleDate}")`);
-        return dates;
-    }
-    catch {
-        logger.info(`[engram:auto-settle] short-term dir not found or empty`);
-        return [];
-    }
-}
-/**
- * 标记 settle 完成日期
- */
-async function markSettled(workspaceDir, date) {
-    const settleStateFile = path.join(workspaceDir, "memory-engram", ".last-settle");
-    await fs.mkdir(path.dirname(settleStateFile), { recursive: true });
-    await fs.writeFile(settleStateFile, date, "utf-8");
-    logger.info(`[engram:auto-settle] Marked settled: ${date} (wrote to ${settleStateFile})`);
-}
-// ---- 对话精简 Prompt（BM25 友好版）----
-const CONDENSE_SYSTEM_PROMPT = `你是一个对话记忆整理助手。请将原始对话精简提炼，输出格式需要同时满足：人类可读 + 关键词检索友好。
-
-## 核心原则
-**每个独立事件/话题必须单独输出一行**，不要过度合并！宁可多输出几行，也不要丢失信息。
-
-## 输出格式规则
-每条记录一行，格式：
-\`[时段] 主题词 | 关键实体 | 一句话摘要\`
-
-### 字段说明
-1. **[时段]**：从对话中提取的时间标签，如 [03-14 晚上]、[03-14 凌晨]（保留原样，用于检索"昨晚"等）
-2. **主题词**：2-4个核心动词/名词，空格分隔（如：备份 iCloud 同步）
-3. **关键实体**：涉及的具体名称/数字（如：1.9GB、musetalk、300505.SZ）
-4. **一句话摘要**：完整描述事件（20字以内）
-
-## 处理规则
-1. **每个事件单独一行**：不同话题必须分开，只有完全相同主题的连续对话才能合并
-2. **保留所有关键词**：股票代码、文件名、数字、路径、分支名、PR号等必须保留
-3. **保留时段标签**：每条记录必须带上 [MM-DD 时段] 前缀
-4. **过滤纯噪音**：只删除"好的"、"谢谢"这类纯确认词，有实质信息的都要保留
-5. **技术操作必须保留**：git操作、文件修改、代码审核、PR、安装软件等都是重要事件
-6. **行为/状态变化必须保留**：用户的行动（去睡觉、出门、到家、吃饭）、状态变化（累了、生病、开心）、意图声明（准备做XX、打算XX）、问候（早上好、晚安）不是噪音，必须作为独立行输出，主题词使用"作息"/"状态"/"出行"等分类
-
-## 示例
-输入：
-Scott [03-13 下午]: 帮我看下目前模拟盘的持仓
-Shadow [03-13 下午]: 📈 ScottK线分析账户 持仓：06181 200股 成本价675.0 当前价650.0 亏损5000 -3.7%
-Scott [03-13 下午]: 话说你的头像我可以在identify里面修改，那么我的头像能自定义吗？
-Shadow [03-13 下午]: 看了代码，目前不支持自定义用户头像，在 grouped-render.ts 里硬编码为默认SVG图标
-Scott [03-13 下午]: 帮我拉新的分支，我需要解决context-notice__icon没有写宽度的bug
-Shadow [03-13 下午]: 已创建分支 scotthuang/fix/dashboard-context-notice-icon-width 并提交修复
-
-输出：
-[03-13 下午] 模拟盘 持仓查询 | 06181 200股 675.0 650.0 -5000 -3.7% | 查看ScottK线账户持仓，小幅亏损
-[03-13 下午] OpenClaw 用户头像 自定义 | grouped-render.ts chat-avatar | 查看源码确认不支持用户自定义头像
-[03-13 下午] OpenClaw 修复 分支创建 | context-notice__icon width | 创建分支修复图标宽度bug
-
-只输出整理后的内容，不要解释。`;
-/**
- * 将对话内容按消息组分段
- * 每段大约 10-15 条消息，确保不超过指定字符数
- */
-function splitIntoChunks(content, maxCharsPerChunk = 5000) {
-    const lines = content.split("\n");
-    const chunks = [];
-    let currentChunk = [];
-    let currentLength = 0;
-    for (const line of lines) {
-        // 如果当前行是新消息的开始（以 Scott 或 Shadow 开头）
-        const isNewMessage = /^(Scott|Shadow)\s+\[/.test(line);
-        // 如果加上这行会超出限制，且当前已有内容，则先保存当前段
-        if (currentLength + line.length > maxCharsPerChunk && currentChunk.length > 0 && isNewMessage) {
-            chunks.push(currentChunk.join("\n"));
-            currentChunk = [];
-            currentLength = 0;
-        }
-        currentChunk.push(line);
-        currentLength += line.length + 1; // +1 for newline
-    }
-    // 保存最后一段
-    if (currentChunk.length > 0) {
-        chunks.push(currentChunk.join("\n"));
-    }
-    return chunks;
-}
-/**
- * 调用 LLM 精简单个段落
- */
-async function condenseChunk(content, apiKey, baseUrl, model) {
-    // 添加 30 秒超时，避免无限等待导致钩子卡住
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 30_000);
-    try {
-        const response = await fetch(`${baseUrl}/v1/messages`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "x-api-key": apiKey,
-                "anthropic-version": "2023-06-01",
-            },
-            body: JSON.stringify({
-                model,
-                system: CONDENSE_SYSTEM_PROMPT,
-                messages: [
-                    { role: "user", content },
-                ],
-                max_tokens: 4096,
-                temperature: 0.3,
-            }),
-            signal: controller.signal,
-        });
-        clearTimeout(timeoutId);
-        if (!response.ok) {
-            logger.error(`[engram] Condense chunk API error: ${response.status}`);
-            return null;
-        }
-        const data = await response.json();
-        // Anthropic Messages 格式：content 是数组，找 type=text 的块
-        const textBlock = data.content?.find(b => b.type === "text");
-        return textBlock?.text?.trim() || null;
-    }
-    catch (err) {
-        clearTimeout(timeoutId);
-        if (err instanceof Error && err.name === "AbortError") {
-            logger.error(`[engram] Condense chunk timeout after 30s`);
-        }
-        else {
-            logger.error(`[engram] Condense chunk failed: ${err}`);
-        }
-        return null;
-    }
-}
-/**
- * 调用字节 LLM 接口精简对话（Coding Plan）
- * 支持分段处理长文本，避免信息丢失
- */
-async function condenseSessionContent(content, config) {
-    // 优先使用 condense 配置，其次使用 embedding 配置，最后使用环境变量
-    const apiKey = config.condense.apiKey || config.embedding.apiKey || process.env.ARK_API_KEY || process.env.VOLCENGINE_API_KEY;
-    const baseUrl = config.condense.baseUrl || process.env.ARK_BASE_URL || "https://api.minimaxi.com/anthropic";
-    const model = config.condense.model || config.settleModel || "MiniMax-M2.7-highspeed";
-    if (!apiKey) {
-        logger.info("[engram] No API key for condense, skipping LLM condensation");
-        return null;
-    }
-    // 如果内容较短（<5000字符），直接处理
-    if (content.length < 5000) {
-        logger.info(`[engram] Content short (${content.length} chars), processing directly`);
-        return condenseChunk(content, apiKey, baseUrl, model);
-    }
-    // 长文本分段处理
-    const chunks = splitIntoChunks(content, 5000);
-    logger.info(`[engram] Content long (${content.length} chars), splitting into ${chunks.length} chunks`);
-    const results = [];
-    for (let i = 0; i < chunks.length; i++) {
-        logger.info(`[engram] Processing chunk ${i + 1}/${chunks.length} (${chunks[i].length} chars)`);
-        const result = await condenseChunk(chunks[i], apiKey, baseUrl, model);
-        if (result) {
-            results.push(result);
-            logger.info(`[engram] Chunk ${i + 1} condensed: ${result.split("\n").length} lines`);
-        }
-        // 避免请求过快
-        if (i < chunks.length - 1) {
-            await new Promise(resolve => setTimeout(resolve, 300));
-        }
-    }
-    if (results.length === 0) {
-        logger.info("[engram] All chunks failed");
-        return null;
-    }
-    const combined = results.join("\n");
-    // 后处理去重
-    const deduplicated = deduplicateCondensedLines(combined);
-    logger.info(`[engram] Condensed ${content.length} chars → ${combined.length} chars → ${deduplicated.length} chars (dedup), ${deduplicated.split("\n").length} lines`);
-    return deduplicated;
-}
-/**
- * 后处理去重：移除精简结果中的重复/相似行
- * 使用主题词重叠度判断相似性
- */
-function deduplicateCondensedLines(content) {
-    const lines = content.split("\n").filter(line => line.trim());
-    if (lines.length <= 1)
-        return content;
-    const result = [];
-    const seenTopics = new Set();
-    for (const line of lines) {
-        // 解析格式: [时段] 主题词 | 关键实体 | 摘要
-        const match = line.match(/^\[([^\]]+)\]\s*([^|]+)\|/);
-        if (!match) {
-            result.push(line);
-            continue;
-        }
-        const timePeriod = match[1].trim(); // 如 "03-17 晚上"
-        const topicWords = match[2].trim().split(/\s+/).filter(w => w.length > 0);
-        // 生成主题指纹：时段 + 排序后的主题词
-        const topicKey = `${timePeriod}:${topicWords.sort().join(",")}`;
-        // 检查是否与已有主题相似（主题词重叠度 > 60%）
-        let isDuplicate = false;
-        for (const seen of seenTopics) {
-            const [seenPeriod, seenWordsStr] = seen.split(":");
-            // 时段不同，不算重复
-            if (seenPeriod !== timePeriod)
-                continue;
-            const seenWords = seenWordsStr ? seenWordsStr.split(",") : [];
-            const overlap = topicWords.filter(w => seenWords.includes(w)).length;
-            const overlapRatio = overlap / Math.max(topicWords.length, seenWords.length, 1);
-            if (overlapRatio > 0.6) {
-                isDuplicate = true;
-                logger.info(`[engram] Dedup: skipping "${line.slice(0, 50)}..." (similar to existing)`);
-                break;
-            }
-        }
-        if (!isDuplicate) {
-            result.push(line);
-            seenTopics.add(topicKey);
-        }
-    }
-    logger.info(`[engram] Dedup: ${lines.length} lines → ${result.length} lines`);
-    return result.join("\n");
-}
-export default function register(api) {
-    const rawConfig = api.pluginConfig || {};
-    const workspaceDir = api.workspaceDir || process.env.HOME + "/.openclaw/workspace";
-    // ---- 使用单例模式初始化（只在第一次调用时创建） ----
-    if (!singletonConfig) {
-        singletonConfig = parseConfig(rawConfig);
-        singletonWorkspaceDir = workspaceDir;
-        // 初始化日志系统：传入 logDir 则按天写文件，否则仅 console 输出
-        logger.init(singletonConfig.logDir);
-        logger.info(`[engram] ========== Engram v${PKG_VERSION} loaded ==========`);
-        logger.info(`[engram] Initializing singletons (first register call)`);
-    }
-    const config = singletonConfig;
-    if (!singletonRecallEngine) {
-        singletonRecallEngine = new RecallEngine(workspaceDir, config);
-    }
-    const recallEngine = singletonRecallEngine;
-    if (!singletonProfileManager) {
-        singletonProfileManager = new ProfileManager(workspaceDir);
-    }
-    const profileManager = singletonProfileManager;
-    // 初始化向量存储（直接连接 LanceDB）
-    const lancedbDir = config.lancedbDir || path.join(workspaceDir, "memory-engram", "lancedb");
-    if (!singletonVectorStore && config.embedding.apiKey && config.embedding.baseUrl) {
-        singletonVectorStore = new VectorStore({
-            dbDir: lancedbDir,
-            embedding: config.embedding,
-            tableName: "memories",
-            halfLifeDays: config.halfLifeDays,
-        });
-        logger.info(`[engram] VectorStore singleton created`);
-    }
-    const vectorStore = singletonVectorStore;
-    // 注入向量搜索（只在第一次时注入）
-    if (vectorStore && !recallEngine.hasVectorSearch()) {
-        recallEngine.setVectorSearch(async (query, limit) => {
-            if (!vectorStore)
-                return [];
-            return vectorStore.search(query, limit);
-        });
-        // 注入记忆强化回调
-        recallEngine.setReinforceCallback(async (ids) => {
-            if (!vectorStore)
-                return;
-            await vectorStore.reinforce(ids);
-        });
-    }
-    if (!vectorStore && !config.embedding.apiKey) {
-        logger.info("[engram] No embedding config, vector search disabled");
-    }
-    // 初始化图片存储（始终启用，不依赖额外配置）
-    if (!singletonImageStore) {
-        singletonImageStore = new ImageStore(workspaceDir);
-        logger.info(`[engram] ImageStore singleton created`);
-    }
-    const imageStore = singletonImageStore;
-    // ---- Agent Tools ----
-    api.registerTool({
-        name: "memory_system_search",
-        label: "Memory Search",
-        description: "搜索记忆（短期+长期双路召回+画像增强）。用于查找用户偏好、历史事件、之前讨论的话题。",
-        parameters: {
-            type: "object",
-            properties: {
-                query: { type: "string", description: "搜索查询" },
-                limit: { type: "number", description: "最大返回数（默认使用配置值）" },
-            },
-            required: ["query"],
-        },
-        async execute(_toolCallId, params) {
-            const { query, limit } = params;
-            const { results, memoryContext } = await recallEngine.recall(query);
-            return {
-                content: [{ type: "text", text: results || "No relevant memories found." }],
-                details: { count: results.split("\n").length },
-            };
-        },
-    }, { name: "memory_system_search" });
-    api.registerTool({
-        name: "memory_system_profile",
-        label: "User Profile",
-        description: "查看或更新用户语义画像。",
-        parameters: {
-            type: "object",
-            properties: {
-                action: { type: "string", enum: ["get", "update"], description: "操作类型" },
-                dimension: { type: "string", description: "标签维度（update 时使用）" },
-                value: { type: "string", description: "标签值（update 时使用）" },
-            },
-            required: ["action"],
-        },
-        async execute(_toolCallId, params) {
-            const { action, dimension, value } = params;
-            const profile = await profileManager.load();
-            if (action === "get") {
-                const context = profileManager.getRecallContext(profile);
-                const fullTags = Object.entries(profile.tags)
-                    .map(([dim, tags]) => `- **${dim}**: ${tags.map(t => `${t.value}(${(t.confidence * 100).toFixed(0)}%)`).join(", ")}`)
-                    .join("\n");
-                return {
-                    content: [{
-                            type: "text",
-                            text: `${context}\n\n## 完整画像\n${fullTags || "(暂无标签)"}`,
-                        }],
-                };
-            }
-            if (action === "update" && dimension && value) {
-                profileManager.addTag(profile, dimension, value);
-                await profileManager.save(profile);
-                return {
-                    content: [{ type: "text", text: `Added tag: [${dimension}] ${value}` }],
-                };
-            }
-            return { content: [{ type: "text", text: "Invalid action or missing params." }] };
-        },
-    }, { name: "memory_system_profile" });
-    api.registerTool({
-        name: "memory_system_store",
-        label: "Memory Store",
-        description: "存储记忆到长期向量层。用于保存重要信息、用户偏好、关键决策等需要持久记住的内容。",
-        parameters: {
-            type: "object",
-            properties: {
-                text: { type: "string", description: "要存储的记忆文本" },
-                category: { type: "string", description: "分类（偏好、技术、家庭、健康、工作、决策等）" },
-            },
-            required: ["text"],
-        },
-        async execute(_toolCallId, params) {
-            const text = params.text;
-            const category = params.category || "通用";
-            if (!text || text.trim().length === 0) {
-                return { content: [{ type: "text", text: "Missing text parameter." }] };
-            }
-            try {
-                if (vectorStore) {
-                    // Agent 主动存储的记忆视为高重要度
-                    const result = await vectorStore.store(text.trim(), category, 0.7);
-                    if (result === "duplicate") {
-                        return { content: [{ type: "text", text: "⚠️ Similar memory already exists, skipped." }] };
-                    }
-                    return { content: [{ type: "text", text: "✅ Memory stored to vector DB." }] };
-                }
-                return { content: [{ type: "text", text: "Vector store not configured." }] };
-            }
-            catch (e) {
-                return { content: [{ type: "text", text: `Failed to store: ${e.message}` }] };
-            }
-        },
-    }, { name: "memory_system_store" });
-    api.registerTool({
-        name: "save_image",
-        label: "Save Image",
-        description: `将图片保存到记忆库。使用前必须先用 image 工具理解图片内容，获得描述后再调用本工具存储。
-
-工作流：
-1. 用户要求保存/记住某张图片时，先调用 image 工具查看图片内容
-2. 根据 image 工具返回的描述，提取场景、人物、实体等信息
-3. 调用本工具，传入图片路径、描述文本和实体关键词
-
-判断标准 — 仅在以下情况使用：
-- 用户明确说"记住/保存/存一下这张图"
-- 图片包含长期记忆价值（合照、名片、证件、重要截图等）
-
-不要使用的情况：
-- 用户只是让你"看看这张图上写了什么"（工作类，用完即弃）
-- 临时分析、提取文字、翻译图片内容等一次性任务`,
-        parameters: {
-            type: "object",
-            properties: {
-                imagePath: { type: "string", description: "图片文件的绝对路径" },
-                description: { type: "string", description: "图片内容的文字描述（场景、人物、实体等）" },
-                entities: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "图片中的关键实体（人名、地点、物品、品牌等）",
-                },
-                source: { type: "string", description: "来源渠道（如 wechat、screenshot 等），默认 unknown" },
-            },
-            required: ["imagePath", "description"],
-        },
-        async execute(_toolCallId, params) {
-            const { imagePath, description, entities, source } = params;
-            if (!imagePath || !description) {
-                return { content: [{ type: "text", text: "Missing imagePath or description." }] };
-            }
-            try {
-                // 1. 存储图片文件
-                const result = await imageStore.storeImage(imagePath, { source: source || "unknown" });
-                if (result.isDuplicate) {
-                    // 即使是重复图片，也更新描述（可能之前没有描述）
-                    await imageStore.updateMetadata(result.relativePath, {
-                        description: description.slice(0, 2000),
-                        entities: entities || [],
-                    });
-                    return {
-                        content: [{ type: "text", text: `图片已存在（重复），已更新描述。路径: ${result.relativePath}` }],
-                        details: { relativePath: result.relativePath, isDuplicate: true },
-                    };
-                }
-                // 2. 写入描述和实体
-                await imageStore.updateMetadata(result.relativePath, {
-                    description: description.slice(0, 2000),
-                    entities: entities || [],
-                });
-                logger.info(`[engram] save_image: stored ${result.relativePath}, description="${description.slice(0, 80)}..."`);
-                return {
-                    content: [{ type: "text", text: `✅ 图片已保存到记忆库。\n路径: ${result.relativePath}\n描述: ${description.slice(0, 100)}${description.length > 100 ? "..." : ""}` }],
-                    details: { relativePath: result.relativePath, isDuplicate: false },
-                };
-            }
-            catch (e) {
-                logger.error(`[engram] save_image failed: ${e}`);
-                return { content: [{ type: "text", text: `保存失败: ${e.message}` }] };
-            }
-        },
-    }, { name: "save_image" });
-    api.registerTool({
-        name: "search_images",
-        label: "Image Search",
-        description: "搜索用户的图片记忆。当用户明确要求查找、回忆某张图片时使用。输入搜索关键词，返回匹配的图片列表及描述。",
-        parameters: {
-            type: "object",
-            properties: {
-                query: { type: "string", description: "搜索关键词（如'微信合照'、'咖啡厅'、'团队合影'）" },
-                limit: { type: "number", description: "返回数量上限，默认5" },
-            },
-            required: ["query"],
-        },
-        async execute(_toolCallId, params) {
-            const { query, limit } = params;
-            if (!query || query.trim().length === 0) {
-                return { content: [{ type: "text", text: "Missing query parameter." }] };
-            }
-            try {
-                const results = await imageStore.searchByText(query.trim(), limit || 5);
-                if (results.length === 0) {
-                    return { content: [{ type: "text", text: "未找到匹配的图片。" }] };
-                }
-                const formatted = results.map((r, i) => `${i + 1}. [${r.date}] ${r.description}\n   关键词: ${r.entities.join(", ")}\n   路径: ${r.relativePath}\n   来源: ${r.source} | 相关度: ${r.score}`).join("\n\n");
-                return {
-                    content: [{ type: "text", text: `找到 ${results.length} 张匹配图片：\n\n${formatted}` }],
-                    details: { count: results.length, results },
-                };
-            }
-            catch (e) {
-                logger.error(`[engram] search_images failed: ${e}`);
-                return { content: [{ type: "text", text: `搜索失败: ${e.message}` }] };
-            }
-        },
-    }, { name: "search_images" });
-    // ---- Auto-Recall: before_prompt_build ----
-    // 黑名单：这些系统引导消息不需要记忆召回
-    // 黑名单：这些系统/自动化消息不需要记忆召回
-    const RECALL_BLACKLIST_PATTERNS = [
-        /^A new session was started via \/new or \/reset/i,
-        /^Run your Session Startup sequence/i,
-        /^Session Startup sequence/i,
-        /^Read HEARTBEAT\.md/i, // 心跳任务
-        /^Based on this conversation, generate a short/i, // 文件名生成
-    ];
-    /**
-     * 检查是否应该跳过记忆召回
-     */
-    function shouldSkipRecall(prompt) {
-        for (const pattern of RECALL_BLACKLIST_PATTERNS) {
-            if (pattern.test(prompt)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    api.on("before_agent_start", async (event) => {
-        const prompt = event.prompt || "";
-        logger.info(`[engram] before_agent_start triggered, prompt length=${prompt.length}, first200="${prompt.slice(0, 200)}"`);
-        if (prompt.length < 5)
-            return;
-        // 检查黑名单：系统引导消息不需要召回
-        if (shouldSkipRecall(prompt)) {
-            logger.info(`[engram] Skipping recall for system startup prompt`);
-            return;
-        }
-        // ---- Auto-Settle: 检查前几天是否有未沉淀的短期记忆 ----
-        // fire-and-forget，不阻塞当前对话
-        if (!settleRunning) {
-            (async () => {
-                try {
-                    const unsettledDates = await getUnsettledDates(workspaceDir);
-                    if (unsettledDates.length === 0)
-                        return;
-                    const llmCall = makeLlmCall(config);
-                    if (!llmCall) {
-                        logger.info(`[engram:auto-settle] No LLM config, skipping auto-settle`);
-                        return;
-                    }
-                    settleRunning = true;
-                    logger.info(`[engram:auto-settle] Found ${unsettledDates.length} unsettled date(s): [${unsettledDates.join(", ")}]`);
-                    for (const date of unsettledDates) {
-                        logger.info(`[engram:auto-settle] Running settlement for ${date}...`);
-                        try {
-                            const results = await runSettlement({
-                                workspaceDir,
-                                config,
-                                llmCall,
-                                vectorStore: vectorStore
-                                    ? (text, category, importance) => vectorStore.store(text, category, importance)
-                                    : undefined,
-                                vectorPrune: vectorStore
-                                    ? (threshold, maxPrune) => vectorStore.prune(threshold, maxPrune)
-                                    : undefined,
-                            }, date);
-                            logger.info(`[engram:auto-settle] Settlement for ${date} done: ${results.join(" | ")}`);
-                            await markSettled(workspaceDir, date);
-                        }
-                        catch (err) {
-                            logger.error(`[engram:auto-settle] Settlement for ${date} failed: ${err}`);
-                            // 不 markSettled，下次对话再重试
-                        }
-                    }
-                }
-                catch (err) {
-                    logger.error(`[engram:auto-settle] Auto-settle check failed: ${err}`);
-                }
-                finally {
-                    settleRunning = false;
-                }
-            })();
-        }
-        // ---- 纯图片消息检测：如果没有用户实际文字内容则跳过 recall ----
-        const hasMedia = prompt.includes("[media attached:");
-        // 去掉 [media attached: ...] 标记、系统图片指令、Conversation info 等元数据
-        let userText = prompt;
-        // 移除 [media attached: ...]（可能没有闭合 ]）
-        userText = userText.replace(/\[media attached:[^\]]*\]?/gi, "");
-        // 移除 "To send an image back..." 系统图片指令段落
-        userText = userText.replace(/To send an image back[^]*?Keep caption in the text body\./gi, "");
-        // 移除 "Conversation info (untrusted metadata):" 及后续内容
-        userText = userText.replace(/Conversation info \(untrusted metadata\):[^]*/gi, "");
-        // 移除 "Sender (untrusted metadata):" 及后续内容
-        userText = userText.replace(/Sender \(untrusted metadata\):[^]*/gi, "");
-        userText = userText.trim();
-        if (hasMedia && userText.length < 10) {
-            logger.info(`[engram] Image-only message detected (remaining text="${userText.slice(0, 50)}"), skipping recall`);
-            return;
-        }
-        try {
-            const cleanPrompt = cleanMessageText(prompt);
-            logger.info(`[engram] recall query (cleaned): "${cleanPrompt.slice(0, 100)}"`);
-            const { results, memoryContext } = await recallEngine.recall(cleanPrompt);
-            logger.info(`[engram] recall result: ${results ? results.split("\n").length : 0} lines, memoryContext length=${memoryContext?.length || 0}`);
-            if (!memoryContext)
-                return;
-            return { prependContext: memoryContext };
-        }
-        catch (err) {
-            logger.error(`[engram] Recall failed: ${err}`);
-        }
-    }, { priority: 5 });
-    // ---- Hooks: command:new / command:reset 即时沉淀 ----
-    // 在 /new 或 /reset 时，从上一轮 session 提取对话内容写入 short-term
-    // 注意：plugin hook 环境没有 LLM 调用能力，只能做原始消息转存
-    // 防重入：记录已处理过的 sessionId，避免重复处理同一个 session
-    const processedSessionIds = new Set();
-    // 防重入：记录正在处理的内容指纹，避免并发异步任务重复写入
-    const processingFingerprints = new Set();
-    // 防重入：记录已处理过的 sessionFile 路径（最强的去重）
-    const processedSessionFiles = new Set();
-    // ★★★ 文件锁：使用文件系统持久化锁状态，避免多实例问题 ★★★
-    const COMMAND_NEW_COOLDOWN_MS = 10_000; // 10秒冷却
-    /**
-     * 检查文件锁是否有效（10秒内）
-     * @returns true 如果锁有效（应该跳过），false 如果锁无效或过期（可以处理）
-     */
-    async function checkFileLock(lockFile) {
-        try {
-            const stat = await fs.stat(lockFile);
-            const age = Date.now() - stat.mtimeMs;
-            if (age < COMMAND_NEW_COOLDOWN_MS) {
-                logger.info(`[engram] File lock active (${Math.round((COMMAND_NEW_COOLDOWN_MS - age) / 1000)}s left), skipping`);
-                return true; // 锁有效，跳过
-            }
-        }
-        catch {
-            // 文件不存在，锁无效
-        }
-        return false; // 锁无效或过期，可以处理
-    }
-    /**
-     * 创建文件锁
-     */
-    async function createFileLock(lockFile) {
-        try {
-            await fs.mkdir(path.dirname(lockFile), { recursive: true });
-            await fs.writeFile(lockFile, Date.now().toString(), "utf-8");
-        }
-        catch (err) {
-            logger.error(`[engram] Failed to create file lock: ${err}`);
-        }
-    }
-    /**
-     * 清理消息文本：移除注入的 metadata 和 memory 标签
-     */
-    function cleanMessageText(raw) {
-        let text = raw;
-        // 移除 <relevant-memories>...</relevant-memories>
-        text = text.replace(/<relevant-memories>[\s\S]*?<\/relevant-memories>/g, "");
-        // 移除 Sender (untrusted metadata) blocks
-        text = text.replace(/Sender \(untrusted metadata\):\s*```json[\s\S]*?```/g, "");
-        // 移除 <inbound-context>...</inbound-context>
-        text = text.replace(/<inbound-context>[\s\S]*?<\/inbound-context>/g, "");
-        // 移除时间戳行如 [Tue 2026-03-17 04:38 GMT+8]
-        text = text.replace(/^\[.*?\]\s*/gm, "");
-        // 移除 XML 标签残留
-        text = text.replace(/<\/?[^>]+>/g, "");
-        return text.trim();
-    }
-    /**
-     * 从 session JSONL 文件提取 user/assistant 消息
-     * - 按时间顺序排列
-     * - 清理注入的 metadata/memory 标签
-     * - 连续相同角色的消息合并
-     * - 去掉命令（/开头）和过短的消息
-     */
-    /**
-     * 从 ISO 时间戳提取本地时间字符串（东八区 GMT+8）
-     * 返回格式：MM-DD 时段（凌晨/上午/下午/晚上）
-     *
-     * 时段划分：
-     * - 凌晨: 00:00-06:00
-     * - 上午: 06:00-12:00
-     * - 下午: 12:00-18:00
-     * - 晚上: 18:00-24:00
-     */
-    function formatTimestamp(isoTimestamp) {
-        try {
-            const d = new Date(isoTimestamp);
-            if (isNaN(d.getTime()))
-                return "";
-            // 转换为 GMT+8
-            const utc = d.getTime() + d.getTimezoneOffset() * 60000;
-            const gmt8 = new Date(utc + 8 * 3600000);
-            const month = String(gmt8.getMonth() + 1).padStart(2, "0");
-            const day = String(gmt8.getDate()).padStart(2, "0");
-            const hour = gmt8.getHours();
-            // 时段划分
-            let period;
-            if (hour < 6) {
-                period = "凌晨";
-            }
-            else if (hour < 12) {
-                period = "上午";
-            }
-            else if (hour < 18) {
-                period = "下午";
-            }
-            else {
-                period = "晚上";
-            }
-            return `${month}-${day} ${period}`;
-        }
-        catch {
-            return "";
-        }
-    }
-    async function extractMessagesFromSessionFile(sessionFilePath, messageCount = 50) {
-        try {
-            logger.info(`[engram] extractMessagesFromSessionFile: reading ${sessionFilePath}`);
-            const raw = await fs.readFile(sessionFilePath, "utf-8");
-            const lines = raw.trim().split("\n");
-            const messages = [];
-            for (const line of lines) {
-                try {
-                    const entry = JSON.parse(line);
-                    if (entry.type === "message" && entry.message) {
-                        const msg = entry.message;
-                        const role = msg.role;
-                        if (role !== "user" && role !== "assistant")
-                            continue;
-                        let text = "";
-                        if (Array.isArray(msg.content)) {
-                            text = msg.content
-                                .filter((c) => c.type === "text")
-                                .map((c) => c.text)
-                                .join("");
-                        }
-                        else if (typeof msg.content === "string") {
-                            text = msg.content;
-                        }
-                        if (!text)
-                            continue;
-                        text = cleanMessageText(text);
-                        if (!text)
-                            continue;
-                        // 跳过命令和过短/无意义消息
-                        if (text.startsWith("/"))
-                            continue;
-                        if (text.length < 3)
-                            continue;
-                        if (text === "HEARTBEAT_OK")
-                            continue;
-                        // 获取消息时间戳（优先用 entry.timestamp，其次 msg.timestamp）
-                        const rawTs = entry.timestamp || (msg.timestamp ? new Date(msg.timestamp).toISOString() : "");
-                        const ts = formatTimestamp(rawTs);
-                        // 过滤系统引导消息（/new /reset 触发的启动提示）
-                        if (text.includes("A new session was started via /new or /reset") ||
-                            text.includes("Run your Session Startup sequence") ||
-                            text.includes("read the required files before responding") ||
-                            text.includes("greet the user in your configured persona")) {
-                            logger.info(`[engram] Skipping system startup prompt message`);
-                            continue;
-                        }
-                        // 连续同角色消息合并（保留第一条的时间戳）
-                        if (messages.length > 0 && messages[messages.length - 1].role === role) {
-                            messages[messages.length - 1].text += "\n" + text;
-                        }
-                        else {
-                            messages.push({ role, text, timestamp: ts });
-                        }
-                    }
-                }
-                catch {
-                    // skip malformed lines
-                }
-            }
-            logger.info(`[engram] extractMessagesFromSessionFile: parsed ${messages.length} messages from ${lines.length} lines`);
-            if (messages.length === 0)
-                return null;
-            const recent = messages.slice(-messageCount);
-            const formatted = recent
-                .map((m) => {
-                const name = m.role === "user" ? "Scott" : "Shadow";
-                const timeTag = m.timestamp ? ` [${m.timestamp}]` : "";
-                return `${name}${timeTag}: ${m.text}`;
-            })
-                .join("\n\n");
-            return formatted;
-        }
-        catch (err) {
-            logger.error(`[engram] extractMessagesFromSessionFile: failed to read ${sessionFilePath}: ${err}`);
-            return null;
-        }
-    }
-    /**
-     * 尝试从主 sessionFile 或 .reset.* 备份文件提取内容
-     * 参考 openclaw 内置 session-memory hook 的 fallback 逻辑
-     */
-    async function getRecentSessionContentWithResetFallback(sessionFile, messageCount = 20) {
-        logger.info(`[engram] getRecentSessionContentWithResetFallback: sessionFile=${sessionFile}`);
-        // 先尝试主文件
-        const primary = await extractMessagesFromSessionFile(sessionFile, messageCount);
-        if (primary) {
-            logger.info(`[engram] getRecentSessionContentWithResetFallback: got content from primary file (${primary.length} chars)`);
-            return primary;
-        }
-        // fallback: 查找 .reset.* 后缀的备份文件
-        try {
-            const dir = path.dirname(sessionFile);
-            const base = path.basename(sessionFile);
-            const resetPrefix = `${base}.reset.`;
-            logger.info(`[engram] getRecentSessionContentWithResetFallback: looking for reset fallback in ${dir}, prefix=${resetPrefix}`);
-            const files = await fs.readdir(dir);
-            const resetCandidates = files.filter((n) => n.startsWith(resetPrefix)).sort();
-            if (resetCandidates.length === 0) {
-                logger.info(`[engram] getRecentSessionContentWithResetFallback: no reset fallback files found`);
-                return null;
-            }
-            const latestResetPath = path.join(dir, resetCandidates[resetCandidates.length - 1]);
-            logger.info(`[engram] getRecentSessionContentWithResetFallback: trying latest reset file: ${latestResetPath}`);
-            const fallback = await extractMessagesFromSessionFile(latestResetPath, messageCount);
-            if (fallback) {
-                logger.info(`[engram] getRecentSessionContentWithResetFallback: got content from reset fallback (${fallback.length} chars)`);
-            }
-            return fallback;
-        }
-        catch (fbErr) {
-            logger.error(`[engram] getRecentSessionContentWithResetFallback: reset fallback failed: ${fbErr}`);
-            return null;
-        }
-    }
-    api.registerHook(["command:new", "command:reset"], async (event) => {
-        try {
-            const date = getLocalDateString();
-            const timestamp = new Date().toLocaleTimeString("zh-CN", {
-                hour: "2-digit",
-                minute: "2-digit",
-            });
-            const shortTermDir = path.join(workspaceDir, "memory-engram", "short-term");
-            await fs.mkdir(shortTermDir, { recursive: true });
-            const filePath = path.join(shortTermDir, `${date}.md`);
-            logger.info(`[engram] command:${event.action} hook triggered, action=${event.action}, sessionKey=${event.sessionKey}`);
-            // ★★★ 文件锁：10秒内只处理一次（跨实例有效） ★★★
-            const lockFile = path.join(workspaceDir, "memory-engram", ".command-reset.lock");
-            if (await checkFileLock(lockFile)) {
-                return; // 锁有效，跳过
-            }
-            // 立即创建锁，防止并发
-            await createFileLock(lockFile);
-            logger.info(`[engram] File lock acquired, processing...`);
-            // 从 event.context 获取 previousSessionEntry（/new 触发前的旧 session）
-            const ctx = event.context || {};
-            // 重要：只使用 previousSessionEntry，不要 fallback 到 sessionEntry
-            // sessionEntry 是新创建的空 session，不需要处理
-            const prevEntry = ctx.previousSessionEntry;
-            // 如果没有 previousSessionEntry，说明这是一个全新的 session（没有历史），跳过
-            if (!prevEntry) {
-                logger.info(`[engram] No previousSessionEntry, this is a fresh session start, skipping`);
-                return;
-            }
-            const sessionFile = prevEntry.sessionFile;
-            const sessionId = prevEntry.sessionId;
-            // 如果没有 sessionId，也跳过
-            if (!sessionId) {
-                logger.info(`[engram] No sessionId in previousSessionEntry, skipping`);
-                return;
-            }
-            // ★★★ 最强去重：检查 sessionFile 是否已处理过 ★★★
-            if (sessionFile && processedSessionFiles.has(sessionFile)) {
-                logger.info(`[engram] SessionFile ${sessionFile} already processed, skipping`);
-                return;
-            }
-            // 防重入：检查是否已经处理过这个 session
-            if (processedSessionIds.has(sessionId)) {
-                logger.info(`[engram] Session ${sessionId} already processed, skipping`);
-                return;
-            }
-            // ★ 关键修复：立即标记为已处理，防止重复触发
-            processedSessionIds.add(sessionId);
-            if (sessionFile) {
-                processedSessionFiles.add(sessionFile);
-            }
-            logger.info(`[engram] Marked session ${sessionId} (file: ${sessionFile}) as processing (early lock)`);
-            logger.info(`[engram] context dump: previousSessionEntry=${JSON.stringify({
-                sessionId: sessionId,
-                sessionFile: sessionFile || null,
-                contextKeys: Object.keys(ctx),
-            })}`);
-            let sessionContent = null;
-            if (sessionFile) {
-                sessionContent = await getRecentSessionContentWithResetFallback(sessionFile);
-            }
-            else {
-                logger.info(`[engram] No sessionFile in previousSessionEntry, cannot extract session content`);
-            }
-            if (sessionContent) {
-                // 防重复：检查文件是否已包含相同内容
-                let existing = "";
-                try {
-                    existing = await fs.readFile(filePath, "utf-8");
-                }
-                catch { }
-                // 取 sessionContent 前 100 字符作为指纹
-                const fingerprint = sessionContent.slice(0, 100);
-                if (existing.includes(fingerprint)) {
-                    logger.info(`[engram] Duplicate detected, skipping write to short-term/${date}.md`);
-                }
-                else {
-                    // ---- 保存中间文件（staging）供调试 ----
-                    if (config.saveStagingFile !== false) {
-                        const stagingDir = path.join(workspaceDir, "memory-engram", "staging");
-                        await fs.mkdir(stagingDir, { recursive: true });
-                        const stagingPath = path.join(stagingDir, `${date}-${timestamp.replace(/:/g, "")}.md`);
-                        await fs.writeFile(stagingPath, sessionContent, "utf-8");
-                        logger.info(`[engram] Saved staging file: ${stagingPath} (${sessionContent.length} chars)`);
-                    }
-                    // ---- 异步执行 LLM 精简 + 保存 + BM25 重建 ----
-                    // 使用 fire-and-forget 模式，让钩子快速返回，避免阻塞 openclaw 事件循环
-                    const asyncSessionContent = sessionContent; // 捕获变量
-                    const asyncFilePath = filePath;
-                    const asyncTimestamp = timestamp;
-                    const asyncFingerprint = fingerprint;
-                    // ★ 异步任务启动前先检查指纹锁，防止并发任务
-                    if (processingFingerprints.has(asyncFingerprint)) {
-                        logger.info(`[engram] Content already being processed (fingerprint lock), skipping`);
-                    }
-                    else {
-                        processingFingerprints.add(asyncFingerprint);
-                        // 不 await，让它在后台执行
-                        (async () => {
-                            try {
-                                let contentToSave = asyncSessionContent;
-                                const condensed = await condenseSessionContent(asyncSessionContent, config);
-                                if (condensed) {
-                                    contentToSave = condensed;
-                                    logger.info(`[engram] [async] Using condensed content for short-term memory`);
-                                }
-                                else {
-                                    logger.info(`[engram] [async] Condense failed or disabled, saving raw content`);
-                                }
-                                // ★ 写入前再次检查文件，防止并发写入
-                                let existingNow = "";
-                                try {
-                                    existingNow = await fs.readFile(asyncFilePath, "utf-8");
-                                }
-                                catch { }
-                                if (existingNow.includes(asyncFingerprint)) {
-                                    logger.info(`[engram] [async] Duplicate detected before write, skipping`);
-                                    return;
-                                }
-                                const entry = `\n### ${asyncTimestamp} [对话记录]\n${contentToSave}\n`;
-                                await fs.appendFile(asyncFilePath, entry, "utf-8");
-                                logger.info(`[engram] [async] Saved ${contentToSave.length} chars of session content to short-term memory`);
-                                // Rebuild BM25 index after adding new entry
-                                await recallEngine.rebuildBM25();
-                                logger.info(`[engram] [async] BM25 index rebuilt after new entry added`);
-                            }
-                            catch (asyncErr) {
-                                logger.error(`[engram] [async] Background processing failed: ${asyncErr}`);
-                            }
-                            finally {
-                                // 无论成功失败，都释放指纹锁
-                                processingFingerprints.delete(asyncFingerprint);
-                            }
-                        })();
-                        logger.info(`[engram] Hook returning immediately, LLM condense + save running in background`);
-                    }
-                }
-            }
-            else {
-                // 没有对话内容，跳过写入（不再写无意义的 "Session reset" 垃圾）
-                // session 已在前面标记，无需再处理
-                logger.info(`[engram] No session content to save, skipping write`);
-            }
-        }
-        catch (err) {
-            logger.error(`[engram] Hook command:${event?.action ?? "new/reset"} failed: ${err}`);
-        }
-    }, {
-        name: "engram.command-session-reset",
-        description: "会话重置（/new 或 /reset）时提取上一轮对话写入短期记忆",
-    });
-    // ---- Hooks: session:compact:before 保底沉淀 ----
-    api.registerHook("session:compact:before", async (event) => {
-        try {
-            const date = new Date().toISOString().split("T")[0];
-            const shortTermDir = path.join(workspaceDir, "memory-engram", "short-term");
-            await fs.mkdir(shortTermDir, { recursive: true });
-            const filePath = path.join(shortTermDir, `${date}.md`);
-            const timestamp = new Date().toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit" });
-            const entry = `\n### ${timestamp} [系统]\nCompaction triggered, saving context at ${new Date().toISOString()}\n`;
-            await fs.appendFile(filePath, entry, "utf-8");
-            logger.info(`[engram] Pre-compaction save: ${date}`);
-        }
-        catch (err) {
-            logger.error(`[engram] Hook session:compact:before failed: ${err}`);
-        }
-    }, {
-        name: "engram.compact-before",
-        description: "Compaction 前保底保存重要信息",
-    });
-    // ---- Service: 启动初始化 ----
-    api.registerService({
-        id: "engram",
-        async start() {
-            if (vectorStore) {
-                await vectorStore.startup();
-            }
-            await recallEngine.startup();
-            logger.info(`[engram] Service started (workspace: ${workspaceDir})`);
-        },
-        async stop() {
-            logger.info("[engram] Service stopped");
-        },
-    });
-    // ---- CLI Commands ----
-    api.registerCli(({ program }) => {
-        const mem = program.command("memory-sys").description("Memory system commands");
-        mem.command("settle").description("Run daily settlement manually").action(async () => {
-            const results = await runSettlement({
-                workspaceDir,
-                config,
-                llmCall: makeLlmCall(config),
-                vectorStore: vectorStore ? (text, category, importance) => vectorStore.store(text, category, importance) : undefined,
-                vectorPrune: vectorStore ? (threshold, maxPrune) => vectorStore.prune(threshold, maxPrune) : undefined,
-            });
-            results.forEach(r => console.log(`  ${r}`));
-        });
-        mem.command("monthly-settle").description("Run monthly settle (selective vectorize + prune)").action(async () => {
-            console.log("Running monthly settlement...");
-            if (vectorStore) {
-                await vectorStore.startup();
-            }
-            const results = await runMonthlySettle({
-                workspaceDir,
-                config,
-                llmCall: makeLlmCall(config),
-                vectorStore: vectorStore ? (text, category, importance) => vectorStore.store(text, category, importance) : undefined,
-                vectorPrune: vectorStore ? (threshold, maxPrune) => vectorStore.prune(threshold, maxPrune) : undefined,
-            });
-            results.forEach(r => console.log(`  ${r}`));
-        });
-        mem.command("profile").description("Show user profile").action(async () => {
-            const profile = await profileManager.load();
-            const context = profileManager.getRecallContext(profile);
-            console.log(context || "(empty profile)");
-            console.log("\nFull tags:");
-            console.log(JSON.stringify(profile.tags, null, 2));
-        });
-        mem.command("stats").description("Show memory stats").action(async () => {
-            console.log(`Workspace: ${workspaceDir}`);
-            console.log(`Short-term days: ${config.shortTermDays}`);
-            console.log(`Half-life: ${config.halfLifeDays} days`);
-            // 可扩展更多统计
-        });
-    }, { commands: ["memory-sys"] });
-    logger.info("[engram] Plugin registered");
-}
-//# sourceMappingURL=index.js.map