openclaw-cortex-memory 0.1.0-Alpha.1

package/dist/index.js

@@ -0,0 +1,1871 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enable = enable;
+exports.disable = disable;
+exports.getStatus = getStatus;
+exports.unregister = unregister;
+exports.register = register;
+/// <reference types="node" />
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const ts_engine_1 = require("./src/engine/ts_engine");
+const read_store_1 = require("./src/store/read_store");
+const write_store_1 = require("./src/store/write_store");
+const session_sync_1 = require("./src/sync/session_sync");
+const session_end_1 = require("./src/session/session_end");
+const rule_store_1 = require("./src/rules/rule_store");
+const reflector_1 = require("./src/reflect/reflector");
+const ERROR_CODES = {
+    CONNECTION_REFUSED: {
+        code: "E001",
+        message: "Cannot connect to the memory service",
+        suggestion: "The Python backend may not be running. Try restarting the OpenClaw gateway."
+    },
+    TIMEOUT: {
+        code: "E002",
+        message: "The memory service is not responding",
+        suggestion: "The service may be overloaded. Wait a moment and try again."
+    },
+    NOT_FOUND: {
+        code: "E003",
+        message: "Memory not found",
+        suggestion: "The requested memory may have been deleted or never existed."
+    },
+    INVALID_INPUT: {
+        code: "E004",
+        message: "Invalid input provided",
+        suggestion: "Please check your input parameters and try again."
+    },
+    SERVICE_ERROR: {
+        code: "E005",
+        message: "The memory service encountered an error",
+        suggestion: "Check the service logs for details or try restarting the gateway."
+    },
+    PLUGIN_DISABLED: {
+        code: "E006",
+        message: "Cortex Memory plugin is disabled",
+        suggestion: "Enable the plugin using 'openclaw plugins enable cortex-memory' or check openclaw.json"
+    }
+};
+const SENSITIVE_KEYS = ["API_KEY", "SECRET", "TOKEN", "PASSWORD", "APIKEY"];
+const PLUGIN_ID = "openclaw-cortex-memory";
+const MIN_OPENCLAW_VERSION = "2026.3.8";
+const MAX_OPENCLAW_VERSION = "2027.0.0";
+const defaultConfig = {
+    autoSync: true,
+    autoReflect: false,
+    enabled: true,
+    fallbackToBuiltin: true,
+    engineMode: "ts",
+};
+let autoSearchCacheBySession = new Map();
+const AUTO_SEARCH_CACHE_TTL = 60000;
+const MAX_AUTO_SEARCH_CACHE_SESSIONS = 200;
+let config = null;
+let logger;
+let pythonProcess = null;
+let isShuttingDown = false;
+let isInitializing = false;
+let isRegistered = false;
+let isEnabled = false;
+let api = null;
+let builtinMemory = null;
+let registeredTools = [];
+let registeredHooks = [];
+let registeredFallbackTools = [];
+const registeredHookHandlers = new Map();
+let configWatchInterval = null;
+let autoReflectInterval = null;
+let lastAutoReflectArchiveMarker = "";
+let lastAutoReflectRunAt = 0;
+let configPath = null;
+let pythonStartPromise = null;
+let processHandlersRegistered = false;
+let pythonPidFilePath = null;
+let memoryEngine = null;
+function shouldUsePythonRuntime() {
+    return false;
+}
+function getMemoryRoot() {
+    const projectRoot = findProjectRoot();
+    return config?.dbPath ? path.resolve(config.dbPath) : path.join(projectRoot, "data", "memory");
+}
+function getArchiveMarker() {
+    try {
+        const archivePath = path.join(getMemoryRoot(), "sessions", "archive", "sessions.jsonl");
+        if (!fs.existsSync(archivePath)) {
+            return "missing";
+        }
+        const stats = fs.statSync(archivePath);
+        return `${stats.size}:${stats.mtimeMs}`;
+    }
+    catch {
+        return "error";
+    }
+}
+function getSessionCachedAutoSearch(sessionId) {
+    clearStaleAutoSearchCache();
+    const cache = autoSearchCacheBySession.get(sessionId);
+    if (!cache) {
+        return null;
+    }
+    return {
+        query: cache.query,
+        results: cache.results,
+        ageSeconds: Math.floor((Date.now() - cache.timestamp) / 1000),
+    };
+}
+function resolveEngine() {
+    if (!config) {
+        throw new Error("Configuration not loaded");
+    }
+    const selectedMode = "ts";
+    if (memoryEngine && memoryEngine.mode === "ts") {
+        return memoryEngine;
+    }
+    const projectRoot = findProjectRoot();
+    const memoryRoot = getMemoryRoot();
+    const readStore = (0, read_store_1.createReadStore)({
+        projectRoot,
+        dbPath: config.dbPath,
+        logger,
+    });
+    const writeStore = (0, write_store_1.createWriteStore)({
+        projectRoot,
+        dbPath: config.dbPath,
+        logger,
+    });
+    const sessionSync = (0, session_sync_1.createSessionSync)({
+        projectRoot,
+        dbPath: config.dbPath,
+        logger,
+        writeStore,
+    });
+    const sessionEnd = (0, session_end_1.createSessionEnd)({
+        projectRoot,
+        dbPath: config.dbPath,
+        logger,
+        syncMemory: sessionSync.syncMemory,
+    });
+    const ruleStore = (0, rule_store_1.createRuleStore)({
+        projectRoot,
+        dbPath: config.dbPath,
+        logger,
+    });
+    const reflector = (0, reflector_1.createReflector)({
+        projectRoot,
+        dbPath: config.dbPath,
+        logger,
+        ruleStore,
+    });
+    memoryEngine = (0, ts_engine_1.createTsEngine)({
+        readStore,
+        writeStore,
+        sessionSync,
+        sessionEnd,
+        reflector,
+        memoryRoot,
+        getCachedAutoSearch: getSessionCachedAutoSearch,
+        resolveSessionId: (context, payload) => resolveSessionId(context, payload),
+        normalizeIncomingMessage,
+        setSessionAutoSearchCache,
+        defaultAutoSync: config.autoSync ?? true,
+        autoReflect: config.autoReflect ?? false,
+        logger,
+    });
+    return memoryEngine;
+}
+function clearStaleAutoSearchCache(now = Date.now()) {
+    for (const [sessionId, cache] of autoSearchCacheBySession.entries()) {
+        if ((now - cache.timestamp) >= AUTO_SEARCH_CACHE_TTL) {
+            autoSearchCacheBySession.delete(sessionId);
+        }
+    }
+}
+function setSessionAutoSearchCache(sessionId, query, results) {
+    const now = Date.now();
+    clearStaleAutoSearchCache(now);
+    autoSearchCacheBySession.set(sessionId, {
+        sessionId,
+        query,
+        results,
+        timestamp: now,
+    });
+    if (autoSearchCacheBySession.size > MAX_AUTO_SEARCH_CACHE_SESSIONS) {
+        const oldest = [...autoSearchCacheBySession.values()].sort((a, b) => a.timestamp - b.timestamp)[0];
+        if (oldest) {
+            autoSearchCacheBySession.delete(oldest.sessionId);
+        }
+    }
+}
+function createConsoleLogger() {
+    return {
+        debug: (message, ...args) => console.debug(`[CortexMemory] ${message}`, ...args),
+        info: (message, ...args) => console.log(`[CortexMemory] ${message}`, ...args),
+        warn: (message, ...args) => console.warn(`[CortexMemory] ${message}`, ...args),
+        error: (message, ...args) => console.error(`[CortexMemory] ${message}`, ...args),
+    };
+}
+function sanitizeForLogging(obj) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const isSensitive = SENSITIVE_KEYS.some(k => key.toUpperCase().includes(k));
+        if (isSensitive) {
+            sanitized[key] = "***REDACTED***";
+        }
+        else if (typeof value === "object" && value !== null) {
+            sanitized[key] = sanitizeForLogging(value);
+        }
+        else {
+            sanitized[key] = value;
+        }
+    }
+    return sanitized;
+}
+function asRecord(value) {
+    if (typeof value === "object" && value !== null) {
+        return value;
+    }
+    return null;
+}
+function firstString(values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function normalizeIncomingMessage(payload) {
+    const data = asRecord(payload);
+    if (!data) {
+        return null;
+    }
+    const message = asRecord(data.message);
+    const eventData = asRecord(data.data);
+    const update = asRecord(data.update);
+    const updateMessage = update ? asRecord(update.message) : null;
+    const role = firstString([
+        data.role,
+        data.fromRole,
+        data.senderRole,
+        message?.role,
+        eventData?.role,
+        updateMessage?.role,
+    ]) || "user";
+    const source = firstString([
+        data.source,
+        data.platform,
+        data.channel,
+        data.provider,
+        message?.source,
+        eventData?.source,
+    ]) || "message";
+    let text = firstString([
+        data.content,
+        data.text,
+        data.body,
+        data.prompt,
+        data.message,
+        message?.content,
+        message?.text,
+        message?.body,
+        eventData?.content,
+        eventData?.text,
+        updateMessage?.text,
+        updateMessage?.caption,
+    ]);
+    if (!text && Array.isArray(data.messages)) {
+        const merged = data.messages
+            .map(item => {
+            if (typeof item === "string")
+                return item;
+            const msgObj = asRecord(item);
+            if (!msgObj)
+                return "";
+            return firstString([msgObj.content, msgObj.text, msgObj.body]) || "";
+        })
+            .filter(Boolean)
+            .join("\n");
+        text = merged.trim() || undefined;
+    }
+    if (!text) {
+        return null;
+    }
+    return { text, role, source };
+}
+function resolveSessionId(context, payload) {
+    const fromContext = typeof context.sessionId === "string" ? context.sessionId.trim() : "";
+    if (fromContext)
+        return fromContext;
+    const data = asRecord(payload);
+    const dataChat = data ? asRecord(data.chat) : null;
+    const message = data ? asRecord(data.message) : null;
+    const messageChat = message ? asRecord(message.chat) : null;
+    const eventData = data ? asRecord(data.data) : null;
+    const eventChat = eventData ? asRecord(eventData.chat) : null;
+    const update = data ? asRecord(data.update) : null;
+    const updateMessage = update ? asRecord(update.message) : null;
+    const updateChat = updateMessage ? asRecord(updateMessage.chat) : null;
+    const direct = firstString([
+        data?.sessionId,
+        data?.session_id,
+        data?.conversationId,
+        data?.conversation_id,
+        data?.threadId,
+        data?.thread_id,
+        message?.sessionId,
+        eventData?.sessionId,
+    ]);
+    if (direct)
+        return direct;
+    const chatId = firstString([
+        data?.chatId,
+        data?.chat_id,
+        dataChat?.id,
+        messageChat?.id,
+        eventChat?.id,
+        updateChat?.id,
+    ]);
+    if (chatId)
+        return `chat:${chatId}`;
+    return `fallback:${context.workspaceId || "default"}:${context.agentId || "agent"}`;
+}
+function compareVersions(a, b) {
+    const partsA = a.split(".").map(Number);
+    const partsB = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+        const valA = partsA[i] || 0;
+        const valB = partsB[i] || 0;
+        if (valA < valB)
+            return -1;
+        if (valA > valB)
+            return 1;
+    }
+    return 0;
+}
+async function checkOpenClawVersion() {
+    try {
+        const version = process.env.OPENCLAW_VERSION;
+        if (version) {
+            if (compareVersions(version, MIN_OPENCLAW_VERSION) < 0) {
+                throw new Error(`Incompatible OpenClaw version: ${version}. Minimum required: ${MIN_OPENCLAW_VERSION}`);
+            }
+            if (compareVersions(version, MAX_OPENCLAW_VERSION) >= 0) {
+                throw new Error(`Incompatible OpenClaw version: ${version}. Maximum supported: <${MAX_OPENCLAW_VERSION}`);
+            }
+            logger.info(`OpenClaw version check passed: ${version}`);
+        }
+        else {
+            logger.warn("Could not determine OpenClaw version, proceeding with caution");
+        }
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        logger.warn(`Version check warning: ${message}`);
+    }
+}
+function findProjectRoot() {
+    if (api && api.rootDir) {
+        return api.rootDir;
+    }
+    let current = process.cwd();
+    while (current !== path.dirname(current)) {
+        if (fs.existsSync(path.join(current, "openclaw.plugin.json")) &&
+            fs.existsSync(path.join(current, "package.json"))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    throw new Error("Cannot find project root directory");
+}
+function findOpenClawConfig() {
+    const possiblePaths = [
+        path.join(process.cwd(), "openclaw.json"),
+        path.join(process.env.USERPROFILE || process.env.HOME || "", ".openclaw", "openclaw.json"),
+        path.join(process.env.OPENCLAW_BASE_PATH || "", "openclaw.json"),
+    ];
+    for (const p of possiblePaths) {
+        if (fs.existsSync(p)) {
+            return p;
+        }
+    }
+    return null;
+}
+function loadPluginEnabledState() {
+    if (!configPath || !fs.existsSync(configPath)) {
+        return true;
+    }
+    try {
+        const content = fs.readFileSync(configPath, "utf-8");
+        const openclawConfig = JSON.parse(content);
+        const pluginEntry = openclawConfig?.plugins?.entries?.[PLUGIN_ID];
+        if (pluginEntry && typeof pluginEntry === "object") {
+            return pluginEntry.enabled !== false;
+        }
+        const legacyPluginConfig = openclawConfig?.plugins?.["cortex-memory"];
+        return legacyPluginConfig?.enabled !== false;
+    }
+    catch (e) {
+        logger.warn(`Failed to load config state: ${e}`);
+        return true;
+    }
+}
+function startConfigWatcher() {
+    if (configWatchInterval) {
+        clearInterval(configWatchInterval);
+    }
+    let lastEnabledState = isEnabled;
+    configWatchInterval = setInterval(() => {
+        const newState = loadPluginEnabledState();
+        if (newState !== lastEnabledState) {
+            lastEnabledState = newState;
+            if (newState && !isEnabled) {
+                logger.info("Detected config change: enabling Cortex Memory plugin");
+                enable();
+            }
+            else if (!newState && isEnabled) {
+                logger.info("Detected config change: disabling Cortex Memory plugin");
+                disable();
+            }
+        }
+    }, 5000);
+}
+function stopConfigWatcher() {
+    if (configWatchInterval) {
+        clearInterval(configWatchInterval);
+        configWatchInterval = null;
+    }
+}
+function startAutoReflectScheduler() {
+    if (!config?.autoReflect || autoReflectInterval) {
+        return;
+    }
+    autoReflectInterval = setInterval(() => {
+        if (!isEnabled) {
+            return;
+        }
+        const schedulerContext = {
+            agentId: "cortex-memory-scheduler",
+            workspaceId: "system",
+        };
+        const marker = getArchiveMarker();
+        const now = Date.now();
+        if (marker === "missing" || marker === "error") {
+            return;
+        }
+        if (marker === lastAutoReflectArchiveMarker) {
+            return;
+        }
+        if (now - lastAutoReflectRunAt < 5 * 60 * 1000) {
+            return;
+        }
+        resolveEngine().reflectMemory({}, schedulerContext)
+            .then(result => {
+            if (result.success) {
+                lastAutoReflectArchiveMarker = marker;
+                lastAutoReflectRunAt = now;
+                logger.info("Scheduled reflection complete");
+            }
+            else {
+                logger.warn(`Auto-reflect failed: ${result.error ?? "unknown_error"}`);
+            }
+        })
+            .catch(error => logger.warn(`Auto-reflect failed: ${String(error)}`));
+    }, 5 * 60 * 1000);
+}
+function stopAutoReflectScheduler() {
+    if (autoReflectInterval) {
+        clearInterval(autoReflectInterval);
+        autoReflectInterval = null;
+    }
+}
+function validateConfig(cfg) {
+    const errors = [];
+    if (!cfg.embedding?.provider || !cfg.embedding?.model) {
+        errors.push("embedding.provider and embedding.model are required. Please configure them in openclaw.json");
+    }
+    if (!cfg.embedding?.apiKey || !cfg.embedding?.baseURL) {
+        errors.push("embedding.apiKey and embedding.baseURL are required. Please configure third-party embedding endpoint credentials.");
+    }
+    if (!cfg.llm?.provider || !cfg.llm?.model) {
+        errors.push("llm.provider and llm.model are required. Please configure them in openclaw.json");
+    }
+    if (!cfg.llm?.apiKey || !cfg.llm?.baseURL) {
+        errors.push("llm.apiKey and llm.baseURL are required. Please configure third-party LLM endpoint credentials.");
+    }
+    if (!cfg.reranker?.model) {
+        errors.push("reranker.model is required. Please configure it in openclaw.json");
+    }
+    if (!cfg.reranker?.apiKey || !cfg.reranker?.baseURL) {
+        errors.push("reranker.apiKey and reranker.baseURL are required. Please configure third-party reranker endpoint credentials.");
+    }
+    return errors;
+}
+function getApiHostAndPort() {
+    const parsed = new URL(getBaseUrl());
+    const host = parsed.hostname || "127.0.0.1";
+    const port = Number(parsed.port || (parsed.protocol === "https:" ? 443 : 80));
+    return { host, port };
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function isPortListening(host, port, timeoutMs = 700) {
+    return new Promise(resolve => {
+        const socket = new net.Socket();
+        let settled = false;
+        const finalize = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            resolve(value);
+        };
+        socket.setTimeout(timeoutMs);
+        socket.once("connect", () => finalize(true));
+        socket.once("timeout", () => finalize(false));
+        socket.once("error", () => finalize(false));
+        socket.connect(port, host);
+    });
+}
+function writePythonPid(pid) {
+    if (!pythonPidFilePath)
+        return;
+    try {
+        fs.writeFileSync(pythonPidFilePath, String(pid), "utf-8");
+    }
+    catch (e) {
+        logger.warn(`Failed to write Python pid file: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+function clearPythonPidFile() {
+    if (!pythonPidFilePath)
+        return;
+    try {
+        if (fs.existsSync(pythonPidFilePath)) {
+            fs.unlinkSync(pythonPidFilePath);
+        }
+    }
+    catch (e) {
+        logger.warn(`Failed to clear Python pid file: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+function readPythonPid() {
+    if (!pythonPidFilePath || !fs.existsSync(pythonPidFilePath))
+        return null;
+    try {
+        const raw = fs.readFileSync(pythonPidFilePath, "utf-8").trim();
+        const pid = Number(raw);
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function killProcessByPid(pid) {
+    if (!pid)
+        return;
+    try {
+        if (process.platform === "win32") {
+            (0, child_process_1.execSync)(`taskkill /pid ${pid} /f /t`, { stdio: "ignore" });
+            return;
+        }
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch { }
+        try {
+            process.kill(-pid, "SIGTERM");
+        }
+        catch { }
+        setTimeout(() => {
+            try {
+                process.kill(pid, "SIGKILL");
+            }
+            catch { }
+            try {
+                process.kill(-pid, "SIGKILL");
+            }
+            catch { }
+        }, 2000);
+    }
+    catch (e) {
+        logger.warn(`Failed to kill process ${pid}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+function freePortWithSystemTools(port) {
+    try {
+        if (process.platform === "win32") {
+            const output = (0, child_process_1.execSync)(`netstat -ano | findstr :${port}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] });
+            const pids = output
+                .split(/\r?\n/)
+                .filter(line => line.includes("LISTENING"))
+                .map(line => {
+                const parts = line.trim().split(/\s+/);
+                return Number(parts[parts.length - 1]);
+            })
+                .filter(pid => Number.isInteger(pid) && pid > 0);
+            for (const pid of pids) {
+                killProcessByPid(pid);
+            }
+            return;
+        }
+        const output = (0, child_process_1.execSync)(`sh -lc "lsof -ti tcp:${port} 2>/dev/null || true"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] });
+        const pids = output
+            .split(/\r?\n/)
+            .map(line => Number(line.trim()))
+            .filter(pid => Number.isInteger(pid) && pid > 0);
+        for (const pid of pids) {
+            killProcessByPid(pid);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+async function checkPortInUse() {
+    const apiUrl = getBaseUrl();
+    try {
+        const response = await fetch(`${apiUrl}/health`, { signal: AbortSignal.timeout(1000) });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function startPythonService() {
+    if (pythonStartPromise) {
+        return pythonStartPromise;
+    }
+    pythonStartPromise = startPythonServiceInternal().finally(() => {
+        pythonStartPromise = null;
+    });
+    return pythonStartPromise;
+}
+async function startPythonServiceInternal() {
+    if (!config) {
+        throw new Error("Configuration not loaded");
+    }
+    const projectRoot = findProjectRoot();
+    pythonPidFilePath = path.join(projectRoot, ".cortex-memory-python.pid");
+    const { host, port } = getApiHostAndPort();
+    const stalePid = readPythonPid();
+    if (stalePid && (!pythonProcess || pythonProcess.pid !== stalePid)) {
+        logger.info(`Found stale Python pid ${stalePid}, trying to stop it...`);
+        killProcessByPid(stalePid);
+        await sleep(800);
+        clearPythonPidFile();
+    }
+    const healthyRunning = await checkPortInUse();
+    if (healthyRunning) {
+        logger.info("Python service already running, shutting down old instance...");
+        await shutdownPythonApi();
+        await sleep(1000);
+    }
+    const occupied = await isPortListening(host, port);
+    if (occupied) {
+        logger.warn(`Port ${port} is still occupied after graceful shutdown, forcing cleanup...`);
+        freePortWithSystemTools(port);
+        await sleep(1000);
+    }
+    if (await isPortListening(host, port)) {
+        throw new Error(`Port ${port} is already in use by another process. Please stop that process and retry.`);
+    }
+    const venvDir = path.join(projectRoot, "venv");
+    const pythonCmd = process.platform === "win32"
+        ? path.join(venvDir, "Scripts", "python.exe")
+        : path.join(venvDir, "bin", "python");
+    if (!fs.existsSync(pythonCmd)) {
+        throw new Error("Python environment not found. Please run 'npm install' first.");
+    }
+    const errors = validateConfig(config);
+    if (errors.length > 0) {
+        throw new Error(`Configuration errors:\n${errors.join("\n")}`);
+    }
+    logger.info("Starting Cortex Memory Python service...");
+    const env = {
+        ...process.env,
+        CORTEX_MEMORY_EMBEDDING_PROVIDER: config.embedding.provider,
+        CORTEX_MEMORY_EMBEDDING_MODEL: config.embedding.model,
+        CORTEX_MEMORY_LLM_PROVIDER: config.llm.provider,
+        CORTEX_MEMORY_LLM_MODEL: config.llm.model,
+        CORTEX_MEMORY_RERANKER_PROVIDER: config.reranker.provider || "",
+        CORTEX_MEMORY_RERANKER_MODEL: config.reranker.model,
+        CORTEX_MEMORY_DB_PATH: config.dbPath || path.join(process.env.USERPROFILE || process.env.HOME || "", ".openclaw", "agents", "main", "lancedb_store"),
+    };
+    if (config.embedding.apiKey) {
+        env.CORTEX_MEMORY_EMBEDDING_API_KEY = config.embedding.apiKey;
+    }
+    if (config.embedding.baseURL) {
+        env.CORTEX_MEMORY_EMBEDDING_BASE_URL = config.embedding.baseURL;
+    }
+    if (config.embedding.dimensions) {
+        env.CORTEX_MEMORY_EMBEDDING_DIMENSIONS = String(config.embedding.dimensions);
+    }
+    if (config.llm.apiKey) {
+        env.CORTEX_MEMORY_LLM_API_KEY = config.llm.apiKey;
+    }
+    if (config.llm.baseURL) {
+        env.CORTEX_MEMORY_LLM_BASE_URL = config.llm.baseURL;
+    }
+    if (config.reranker.apiKey) {
+        env.CORTEX_MEMORY_RERANKER_API_KEY = config.reranker.apiKey;
+    }
+    if (config.reranker.baseURL) {
+        env.CORTEX_MEMORY_RERANKER_ENDPOINT = config.reranker.baseURL;
+    }
+    return new Promise((resolve, reject) => {
+        pythonProcess = (0, child_process_1.spawn)(pythonCmd, ["-m", "api.server"], {
+            cwd: projectRoot,
+            detached: false,
+            windowsHide: true,
+            env: { ...env, PYTHONWARNINGS: "ignore::RuntimeWarning" },
+        });
+        if (pythonProcess.pid) {
+            writePythonPid(pythonProcess.pid);
+        }
+        let started = false;
+        let stderrBuffer = "";
+        let settled = false;
+        let startupTimeout = null;
+        const resolveOnce = () => {
+            if (settled)
+                return;
+            settled = true;
+            started = true;
+            if (startupTimeout) {
+                clearTimeout(startupTimeout);
+                startupTimeout = null;
+            }
+            resolve();
+        };
+        const rejectOnce = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (startupTimeout) {
+                clearTimeout(startupTimeout);
+                startupTimeout = null;
+            }
+            reject(error);
+        };
+        pythonProcess.stdout?.on("data", (data) => {
+            const output = data.toString();
+            if (!output.toLowerCase().includes("key") && !output.toLowerCase().includes("token")) {
+                logger.info(`[Python] ${output.trim()}`);
+            }
+            if (output.includes("Cortex Memory API started") || output.includes("Application startup complete")) {
+                resolveOnce();
+            }
+        });
+        pythonProcess.stderr?.on("data", (data) => {
+            const output = data.toString();
+            stderrBuffer += output;
+            if (!output.toLowerCase().includes("key") && !output.toLowerCase().includes("token")) {
+                logger.warn(`[Python] ${output.trim()}`);
+            }
+            if (output.includes("Cortex Memory API started") ||
+                output.includes("Application startup complete") ||
+                output.includes("Uvicorn running on")) {
+                resolveOnce();
+            }
+        });
+        pythonProcess.on("error", (error) => {
+            logger.error("Failed to start Python service:", error.message);
+            rejectOnce(error);
+        });
+        pythonProcess.on("exit", (code) => {
+            clearPythonPidFile();
+            pythonProcess = null;
+            if (!started && code !== 0 && !isShuttingDown) {
+                rejectOnce(new Error(`Python service exited with code ${code}. Stderr: ${stderrBuffer.slice(-500)}`));
+            }
+        });
+        startupTimeout = setTimeout(() => {
+            if (!started) {
+                const tail = stderrBuffer ? `\nLast stderr: ${stderrBuffer.slice(-500)}` : "";
+                killPythonProcess();
+                rejectOnce(new Error(`Timeout waiting for Python service to start (300s)${tail}`));
+            }
+        }, 300000);
+    });
+}
+async function shutdownPythonApi() {
+    const apiUrl = getBaseUrl();
+    try {
+        await fetch(`${apiUrl}/shutdown`, { method: "POST", signal: AbortSignal.timeout(2000) });
+        await new Promise(resolve => setTimeout(resolve, 500));
+    }
+    catch {
+        // ignore
+    }
+}
+function killPythonProcess() {
+    const directPid = pythonProcess?.pid ?? null;
+    const pidFromFile = readPythonPid();
+    const pid = directPid || pidFromFile;
+    if (!pid)
+        return;
+    try {
+        killProcessByPid(pid);
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        logger.warn(`Failed to kill Python process: ${message}`);
+    }
+    finally {
+        pythonProcess = null;
+        clearPythonPidFile();
+    }
+}
+async function stopPythonServiceAsync() {
+    if (pythonStartPromise) {
+        try {
+            await pythonStartPromise;
+        }
+        catch {
+            // ignore
+        }
+    }
+    await shutdownPythonApi();
+    killPythonProcess();
+}
+function stopPythonService() {
+    stopPythonServiceAsync();
+}
+function getBaseUrl() {
+    return config?.apiUrl ?? "http://127.0.0.1:8765";
+}
+async function waitForService(maxAttempts = 30) {
+    const apiUrl = getBaseUrl();
+    for (let i = 0; i < maxAttempts; i++) {
+        try {
+            const response = await fetch(`${apiUrl}/health`, { signal: AbortSignal.timeout(1000) });
+            if (response.ok)
+                return;
+        }
+        catch { }
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    throw new Error("Service failed to become ready");
+}
+function formatApiError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const lower = message.toLowerCase();
+    if (lower.includes("econnrefused") || lower.includes("enotfound") || lower.includes("fetch failed")) {
+        const err = ERROR_CODES.CONNECTION_REFUSED;
+        return `${err.message} (${err.code}). ${err.suggestion}`;
+    }
+    if (lower.includes("abort") || lower.includes("timed out")) {
+        const err = ERROR_CODES.TIMEOUT;
+        return `${err.message} (${err.code}). ${err.suggestion}`;
+    }
+    if (lower.includes("404") || lower.includes("not found")) {
+        const err = ERROR_CODES.NOT_FOUND;
+        return `${err.message} (${err.code}). ${err.suggestion}`;
+    }
+    if (lower.includes("400") || lower.includes("invalid")) {
+        const err = ERROR_CODES.INVALID_INPUT;
+        return `${err.message} (${err.code}). ${err.suggestion}`;
+    }
+    const err = ERROR_CODES.SERVICE_ERROR;
+    return `${err.message} (${err.code}). Details: ${message}`;
+}
+const pendingRequests = new Map();
+const requestDebounceMs = 100;
+function getRequestKey(endpoint, method, body) {
+    const bodyHash = body ? JSON.stringify(body).slice(0, 100) : "";
+    return `${method}:${endpoint}:${bodyHash}`;
+}
+async function apiCallWithRetry(endpoint, method = "GET", body, options) {
+    const { maxRetries = 3, baseDelay = 1000, timeout = 30000, skipDebounce = false } = options || {};
+    if (!skipDebounce) {
+        const requestKey = getRequestKey(endpoint, method, body);
+        const pending = pendingRequests.get(requestKey);
+        if (pending) {
+            logger.debug(`Reusing pending request for ${endpoint}`);
+            return pending.promise;
+        }
+        const requestPromise = apiCallInternal(endpoint, method, body, maxRetries, baseDelay, timeout)
+            .finally(() => {
+            setTimeout(() => pendingRequests.delete(requestKey), requestDebounceMs);
+        });
+        pendingRequests.set(requestKey, {
+            promise: requestPromise
+        });
+        return await requestPromise;
+    }
+    return apiCallInternal(endpoint, method, body, maxRetries, baseDelay, timeout);
+}
+async function apiCallInternal(endpoint, method, body, maxRetries, baseDelay, timeout) {
+    let lastError = null;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await apiCall(endpoint, method, body, timeout);
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            const isRetryable = lastError.message.includes("E001") ||
+                lastError.message.includes("E002") ||
+                lastError.message.includes("timeout") ||
+                lastError.message.includes("ECONNREFUSED") ||
+                lastError.message.includes("ENOTFOUND");
+            if (attempt < maxRetries - 1 && isRetryable) {
+                const delay = baseDelay * Math.pow(2, attempt);
+                logger.warn(`API call failed (attempt ${attempt + 1}/${maxRetries}), retrying in ${delay}ms: ${lastError.message.split(".")[0]}`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+    }
+    throw lastError;
+}
+async function apiCall(endpoint, method = "GET", body, timeout = 30000) {
+    const url = `${getBaseUrl()}${endpoint}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const options = {
+        method,
+        headers: { "Content-Type": "application/json" },
+        signal: controller.signal,
+    };
+    if (body)
+        options.body = JSON.stringify(body);
+    try {
+        const response = await fetch(url, options);
+        const text = await response.text();
+        if (!response.ok) {
+            try {
+                const errorData = JSON.parse(text);
+                throw new Error(errorData.error || errorData.detail || `HTTP ${response.status}`);
+            }
+            catch {
+                throw new Error(`HTTP ${response.status}: ${text || response.statusText}`);
+            }
+        }
+        if (!text)
+            return {};
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            throw new Error("Invalid JSON response");
+        }
+    }
+    catch (error) {
+        throw new Error(formatApiError(error));
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+async function searchMemoryWithFallback(args, context) {
+    if (!args || !args.query) {
+        logger.error(`search_memory called with invalid args: ${JSON.stringify(args)}`);
+        return { success: false, error: ERROR_CODES.INVALID_INPUT.message + " Missing 'query' parameter.", errorCode: ERROR_CODES.INVALID_INPUT.code };
+    }
+    if (!isEnabled) {
+        if (config?.fallbackToBuiltin && builtinMemory) {
+            logger.info("Using builtin memory (plugin disabled)");
+            try {
+                const results = await builtinMemory.search(args.query, args.top_k || 3);
+                return { success: true, data: results };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return { success: false, error: `Builtin memory error: ${message}` };
+            }
+        }
+        return { success: false, error: ERROR_CODES.PLUGIN_DISABLED.message, errorCode: ERROR_CODES.PLUGIN_DISABLED.code };
+    }
+    try {
+        const result = await apiCallWithRetry("/search", "POST", {
+            query: args.query,
+            top_k: args.top_k || 3,
+        });
+        return { success: true, data: result.results };
+    }
+    catch (error) {
+        const message = formatApiError(error);
+        logger.error(`search_memory failed: ${message}`);
+        return { success: false, error: message };
+    }
+}
+async function storeEventWithFallback(args, context) {
+    if (!isEnabled) {
+        if (config?.fallbackToBuiltin && builtinMemory) {
+            logger.info("Using builtin memory (plugin disabled)");
+            try {
+                const id = await builtinMemory.store(args.summary, {
+                    entities: args.entities,
+                    outcome: args.outcome,
+                    relations: args.relations
+                });
+                return { success: true, data: { event_id: id } };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return { success: false, error: `Builtin memory error: ${message}` };
+            }
+        }
+        return { success: false, error: ERROR_CODES.PLUGIN_DISABLED.message, errorCode: ERROR_CODES.PLUGIN_DISABLED.code };
+    }
+    try {
+        const result = await apiCallWithRetry("/event", "POST", {
+            summary: args.summary,
+            entities: args.entities,
+            outcome: args.outcome,
+            relations: args.relations,
+        });
+        return { success: true, data: result };
+    }
+    catch (error) {
+        const message = formatApiError(error);
+        logger.error(`store_event failed: ${message}`);
+        return { success: false, error: message };
+    }
+}
+async function queryGraph(args, _context) {
+    if (!args || !args.entity) {
+        logger.error(`query_graph called with invalid args: ${JSON.stringify(args)}`);
+        return { success: false, error: ERROR_CODES.INVALID_INPUT.message + " Missing 'entity' parameter.", errorCode: ERROR_CODES.INVALID_INPUT.code };
+    }
+    if (!isEnabled) {
+        return { success: false, error: ERROR_CODES.PLUGIN_DISABLED.message, errorCode: ERROR_CODES.PLUGIN_DISABLED.code };
+    }
+    try {
+        const result = await apiCallWithRetry("/graph/query", "POST", { entity: args.entity });
+        return { success: true, data: result.graph };
+    }
+    catch (error) {
+        const message = formatApiError(error);
+        logger.error(`query_graph failed: ${message}`);
+        return { success: false, error: message };
+    }
+}
+async function getHotContext(args, _context) {
+    if (!isEnabled) {
+        return { success: false, error: ERROR_CODES.PLUGIN_DISABLED.message, errorCode: ERROR_CODES.PLUGIN_DISABLED.code };
+    }
+    try {
+        const limit = typeof args.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : 20;
+        const result = await apiCallWithRetry(`/hot-context?limit=${limit}`, "GET");
+        return { success: true, data: result.context };
+    }
+    catch (error) {
+        const message = formatApiError(error);
+        logger.error(`get_hot_context failed: ${message}`);
+        return { success: false, error: message };
+    }
+}
+async function getAutoContext(args, context) {
+    if (!isEnabled) {
+        return { success: false, error: ERROR_CODES.PLUGIN_DISABLED.message, errorCode: ERROR_CODES.PLUGIN_DISABLED.code };
+    }
+    const now = Date.now();
+    const result = {};
+    const sessionId = resolveSessionId(context);
+    clearStaleAutoSearchCache(now);
+    const sessionCache = autoSearchCacheBySession.get(sessionId);
+    if (sessionCache) {
+        result.auto_search = {
+            query: sessionCache.query,
+            results: sessionCache.results,
+            age_seconds: Math.floor((now - sessionCache.timestamp) / 1000),
+        };
+    }
+    if (args.include_hot !== false) {
+        try {
+            const hotResult = await apiCallWithRetry("/hot-context", "GET");
+            result.hot_context = hotResult.context;
+        }
+        catch (error) {
+            logger.debug(`Failed to get hot context: ${formatApiError(error)}`);
+        }
+    }
+    if (!result.auto_search && !result.hot_context) {
+        return {
+            success: true,
+            data: {
+                message: "No session-scoped auto-search results cached and hot context unavailable",
+                suggestion: "Send a user message in this session or call get_hot_context."
+            }
+        };
+    }
+    return { success: true, data: result };
+}
+async function reflectMemory(_args, _context) {
+    if (!isEnabled) {
+        return { success: false, error: ERROR_CODES.PLUGIN_DISABLED.message, errorCode: ERROR_CODES.PLUGIN_DISABLED.code };
+    }
+    try {
+        await apiCallWithRetry("/reflect", "POST", undefined, {
+            timeout: 120000,
+            maxRetries: 2,
+        });
+        return { success: true };
+    }
+    catch (error) {
+        const message = formatApiError(error);
+        logger.error(`reflect_memory failed: ${message}`);
+        return { success: false, error: message };
+    }
+}
+async function syncMemory(_args, _context) {
+    if (!isEnabled) {
+        return { success: false, error: ERROR_CODES.PLUGIN_DISABLED.message, errorCode: ERROR_CODES.PLUGIN_DISABLED.code };
+    }
+    try {
+        await apiCallWithRetry("/sync", "POST", undefined, {
+            timeout: 300000,
+            maxRetries: 2,
+        });
+        return { success: true };
+    }
+    catch (error) {
+        const message = formatApiError(error);
+        logger.error(`sync_memory failed: ${message}`);
+        return { success: false, error: message };
+    }
+}
+async function promoteMemory(_args, _context) {
+    if (!isEnabled) {
+        return { success: false, error: ERROR_CODES.PLUGIN_DISABLED.message, errorCode: ERROR_CODES.PLUGIN_DISABLED.code };
+    }
+    try {
+        await apiCallWithRetry("/promote", "POST", undefined, {
+            timeout: 120000,
+            maxRetries: 2,
+        });
+        return { success: true };
+    }
+    catch (error) {
+        const message = formatApiError(error);
+        logger.error(`promote_memory failed: ${message}`);
+        return { success: false, error: message };
+    }
+}
+async function deleteMemory(args, _context) {
+    if (!isEnabled) {
+        if (config?.fallbackToBuiltin && builtinMemory) {
+            try {
+                const success = await builtinMemory.delete(args.memory_id);
+                return { success };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return { success: false, error: `Builtin memory error: ${message}` };
+            }
+        }
+        return { success: false, error: ERROR_CODES.PLUGIN_DISABLED.message, errorCode: ERROR_CODES.PLUGIN_DISABLED.code };
+    }
+    try {
+        await apiCallWithRetry(`/memory/${args.memory_id}`, "DELETE");
+        return { success: true };
+    }
+    catch (error) {
+        const message = formatApiError(error);
+        logger.error(`delete_memory failed: ${message}`);
+        return { success: false, error: message };
+    }
+}
+async function updateMemory(args, _context) {
+    if (!isEnabled) {
+        return { success: false, error: ERROR_CODES.PLUGIN_DISABLED.message, errorCode: ERROR_CODES.PLUGIN_DISABLED.code };
+    }
+    try {
+        await apiCallWithRetry(`/memory/${args.memory_id}`, "PATCH", {
+            text: args.text,
+            type: args.type,
+            weight: args.weight,
+        });
+        return { success: true };
+    }
+    catch (error) {
+        const message = formatApiError(error);
+        logger.error(`update_memory failed: ${message}`);
+        return { success: false, error: message };
+    }
+}
+async function cleanupMemories(args, _context) {
+    if (!isEnabled) {
+        return { success: false, error: ERROR_CODES.PLUGIN_DISABLED.message, errorCode: ERROR_CODES.PLUGIN_DISABLED.code };
+    }
+    try {
+        const result = await apiCallWithRetry("/cleanup", "POST", {
+            days_old: args.days_old || 90,
+            memory_type: args.memory_type,
+        });
+        return { success: true, data: { deletedCount: result.deleted_count } };
+    }
+    catch (error) {
+        const message = formatApiError(error);
+        logger.error(`cleanup_memories failed: ${message}`);
+        return { success: false, error: message };
+    }
+}
+async function runDiagnostics(_args, _context) {
+    if (!isEnabled) {
+        return {
+            success: true,
+            data: {
+                status: "disabled",
+                message: "Cortex Memory plugin is disabled",
+                suggestion: "Enable the plugin using 'openclaw plugins enable cortex-memory'"
+            }
+        };
+    }
+    try {
+        const result = await apiCallWithRetry("/doctor", "GET");
+        return { success: true, data: result };
+    }
+    catch (error) {
+        const message = formatApiError(error);
+        logger.error(`diagnostics failed: ${message}`);
+        return { success: false, error: message };
+    }
+}
+async function getPluginStatus(_args, _context) {
+    return {
+        success: true,
+        data: {
+            enabled: isEnabled,
+            service_running: pythonProcess !== null,
+            fallback_enabled: config?.fallbackToBuiltin ?? true,
+            builtin_memory_available: builtinMemory !== null,
+            engine_mode: config?.engineMode ?? "python",
+        }
+    };
+}
+async function onMessagePythonHandler(payload, context) {
+    if (!isEnabled)
+        return;
+    const normalized = normalizeIncomingMessage(payload);
+    if (!normalized)
+        return;
+    const { text, role, source } = normalized;
+    const sessionId = resolveSessionId(context, payload);
+    try {
+        const writeResult = await apiCallWithRetry("/write", "POST", {
+            text,
+            source,
+            role,
+            session_id: sessionId
+        });
+        if (writeResult.status === "ok") {
+            logger.info(`Stored ${role} message for session ${sessionId}`);
+        }
+        else {
+            logger.debug(`Write skipped for session ${sessionId}: ${writeResult.reason || writeResult.status || "unknown"}`);
+        }
+    }
+    catch (error) {
+        logger.warn(`Failed to store message: ${formatApiError(error)}`);
+    }
+    if (role === "user" && text.length > 5) {
+        try {
+            const searchResult = await apiCallWithRetry("/search", "POST", {
+                query: text,
+                top_k: 3,
+                session_id: sessionId,
+            });
+            if (searchResult.results && searchResult.results.length > 0) {
+                setSessionAutoSearchCache(sessionId, text, searchResult.results);
+                logger.info(`Auto-search cached ${searchResult.results.length} results for context`);
+            }
+            else if (searchResult.skipped) {
+                logger.debug(`Auto-search skipped for session ${sessionId}: ${searchResult.reason || "query filtered"}`);
+            }
+        }
+        catch (error) {
+            logger.debug(`Auto-search skipped: ${formatApiError(error)}`);
+        }
+    }
+}
+async function onSessionEndPythonHandler(payload, context) {
+    if (!isEnabled)
+        return;
+    const sessionId = resolveSessionId(context, payload);
+    try {
+        const endResult = await apiCallWithRetry("/session-end", "POST", {
+            session_id: sessionId,
+            sync_records: config?.autoSync ?? true,
+        });
+        logger.info(`Session ${sessionId} ended, generated ${endResult.events_generated} events`);
+    }
+    catch (error) {
+        logger.warn(`Failed to end session: ${formatApiError(error)}`);
+    }
+}
+async function onTimerPythonHandler(payload, _context) {
+    if (!isEnabled)
+        return;
+    const data = payload;
+    const action = data.action;
+    try {
+        if (action === "sync") {
+            await apiCallWithRetry("/sync", "POST", undefined, {
+                timeout: 300000,
+                maxRetries: 2,
+            });
+            logger.info("Scheduled sync complete");
+        }
+        else if (action === "reflect" || (config?.autoReflect && !action)) {
+            await apiCallWithRetry("/reflect", "POST", undefined, {
+                timeout: 120000,
+                maxRetries: 2,
+            });
+            logger.info("Scheduled reflection complete");
+        }
+        else if (action === "promote") {
+            await apiCallWithRetry("/promote", "POST", undefined, {
+                timeout: 120000,
+                maxRetries: 2,
+            });
+            logger.info("Scheduled promotion complete");
+        }
+    }
+    catch (error) {
+        logger.warn(`Timer action failed: ${formatApiError(error)}`);
+    }
+}
+async function onMessageHandler(payload, context) {
+    await resolveEngine().onMessage(payload, context);
+}
+async function onSessionEndHandler(payload, context) {
+    await resolveEngine().onSessionEnd(payload, context);
+}
+async function onTimerHandler(payload, context) {
+    await resolveEngine().onTimer(payload, context);
+}
+function registerTools() {
+    if (!api)
+        return;
+    const tools = [
+        {
+            name: "search_memory",
+            description: "Search long-term memory for relevant information",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search query" },
+                    top_k: { type: "integer", description: "Number of results to return" },
+                },
+                required: ["query"],
+                additionalProperties: false,
+            },
+            execute: async (params) => {
+                const args = params.args || params;
+                return resolveEngine().searchMemory(args, params.context);
+            },
+        },
+        {
+            name: "store_event",
+            description: "Store a new event in memory",
+            parameters: {
+                type: "object",
+                properties: {
+                    summary: { type: "string", description: "Event summary" },
+                    entities: {
+                        type: "array",
+                        description: "Involved entities",
+                        items: { type: "string" }
+                    },
+                    outcome: { type: "string", description: "Event outcome" },
+                    relations: {
+                        type: "array",
+                        description: "Entity relationships",
+                        items: { type: "string" }
+                    },
+                },
+                required: ["summary"],
+                additionalProperties: false,
+            },
+            execute: async (params) => {
+                const args = params.args || params;
+                return resolveEngine().storeEvent(args, params.context);
+            },
+        },
+        {
+            name: "query_graph",
+            description: "Query memory graph for entity relationships",
+            parameters: {
+                type: "object",
+                properties: {
+                    entity: { type: "string", description: "Entity name" }
+                },
+                required: ["entity"],
+                additionalProperties: false,
+            },
+            execute: async (params) => {
+                const args = params.args || params;
+                return resolveEngine().queryGraph(args, params.context);
+            },
+        },
+        {
+            name: "get_hot_context",
+            description: "Get hot memory context for current session",
+            parameters: {
+                type: "object",
+                properties: {
+                    limit: { type: "integer", description: "Maximum number of hot context items" }
+                },
+                required: [],
+                additionalProperties: false,
+            },
+            execute: async (params) => {
+                const args = params.args || params;
+                return resolveEngine().getHotContext(args, params.context);
+            },
+        },
+        {
+            name: "get_auto_context",
+            description: "Get relevant memories based on recent messages",
+            parameters: {
+                type: "object",
+                properties: {
+                    include_hot: { type: "boolean", description: "Include hot context" }
+                },
+                required: [],
+                additionalProperties: false,
+            },
+            execute: async (params) => {
+                const args = params.args || params;
+                return resolveEngine().getAutoContext(args, params.context);
+            },
+        },
+        {
+            name: "reflect_memory",
+            description: "Convert events into semantic knowledge",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+                additionalProperties: false,
+            },
+            execute: async (params) => {
+                const args = params.args || params;
+                return resolveEngine().reflectMemory(args, params.context);
+            },
+        },
+        {
+            name: "sync_memory",
+            description: "Import historical session data into memory",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+                additionalProperties: false,
+            },
+            execute: async (params) => {
+                const args = params.args || params;
+                return resolveEngine().syncMemory(args, params.context);
+            },
+        },
+        {
+            name: "delete_memory",
+            description: "Delete a memory by ID",
+            parameters: {
+                type: "object",
+                properties: {
+                    memory_id: { type: "string", description: "Memory ID" }
+                },
+                required: ["memory_id"],
+                additionalProperties: false,
+            },
+            execute: async (params) => {
+                const args = params.args || params;
+                return resolveEngine().deleteMemory(args, params.context);
+            },
+        },
+        {
+            name: "diagnostics",
+            description: "Check memory system status",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+                additionalProperties: false,
+            },
+            execute: async (params) => {
+                const args = params.args || params;
+                return resolveEngine().runDiagnostics(args, params.context);
+            },
+        },
+    ];
+    for (const tool of tools) {
+        api.registerTool(tool);
+        registeredTools.push(tool.name);
+    }
+}
+function unregisterTools() {
+    if (!api || !api.unregisterTool)
+        return;
+    for (const name of registeredTools) {
+        try {
+            api.unregisterTool(name);
+        }
+        catch (e) {
+            logger.warn(`Failed to unregister tool ${name}: ${e}`);
+        }
+    }
+    registeredTools = [];
+}
+function registerHooks() {
+    if (!api)
+        return;
+    const hooks = [
+        { event: "message_received", handler: onMessageHandler },
+        { event: "session_end", handler: onSessionEndHandler },
+    ];
+    for (const hook of hooks) {
+        try {
+            if (typeof api.on === 'function') {
+                api.on(hook.event, hook.handler);
+                registeredHooks.push(hook.event);
+                registeredHookHandlers.set(hook.event, hook.handler);
+            }
+            else if (typeof api.registerHook === "function") {
+                api.registerHook({ event: hook.event, handler: hook.handler });
+                registeredHooks.push(hook.event);
+                registeredHookHandlers.set(hook.event, hook.handler);
+            }
+            else {
+                logger.warn(`No supported hook registration API found, skipping ${hook.event}`);
+            }
+        }
+        catch (e) {
+            logger.error(`Failed to register hook ${hook.event}: ${e instanceof Error ? e.message : String(e)}`);
+            throw e;
+        }
+    }
+}
+function unregisterHooks() {
+    if (!api)
+        return;
+    for (const event of registeredHooks) {
+        try {
+            const handler = registeredHookHandlers.get(event);
+            if (api.off && handler) {
+                api.off(event, handler);
+            }
+            else if (api.unregisterHook) {
+                api.unregisterHook(event);
+            }
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    registeredHooks = [];
+    registeredHookHandlers.clear();
+}
+function setupProcessHandlers() {
+    if (processHandlersRegistered) {
+        return;
+    }
+    processHandlersRegistered = true;
+    const gracefulShutdown = (signal) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        logger.info(`Received ${signal}, shutting down...`);
+        stopConfigWatcher();
+        if (!shouldUsePythonRuntime()) {
+            process.exit(0);
+            return;
+        }
+        shutdownPythonApi().then(() => {
+            killPythonProcess();
+            process.exit(0);
+        }).catch(() => {
+            killPythonProcess();
+            process.exit(0);
+        });
+    };
+    process.on("exit", () => {
+        killPythonProcess();
+        stopConfigWatcher();
+    });
+    process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+    process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+    process.on("uncaughtException", (err) => {
+        logger.error("Uncaught exception:", err.message);
+        killPythonProcess();
+        stopConfigWatcher();
+        process.exit(1);
+    });
+}
+async function enable() {
+    if (isEnabled) {
+        logger.info("Cortex Memory plugin is already enabled");
+        return;
+    }
+    logger.info("Enabling Cortex Memory plugin...");
+    try {
+        unregisterFallbackTools();
+        if (shouldUsePythonRuntime()) {
+            await startPythonService();
+            await waitForService();
+        }
+        isEnabled = true;
+        registerTools();
+        registerHooks();
+        startAutoReflectScheduler();
+        logger.info("Cortex Memory plugin enabled successfully");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to enable Cortex Memory plugin: ${message}`);
+        throw error;
+    }
+}
+async function disable() {
+    if (!isEnabled) {
+        logger.info("Cortex Memory plugin is already disabled");
+        return;
+    }
+    logger.info("Disabling Cortex Memory plugin...");
+    unregisterHooks();
+    unregisterTools();
+    unregisterFallbackTools();
+    stopAutoReflectScheduler();
+    if (shouldUsePythonRuntime()) {
+        await stopPythonServiceAsync();
+    }
+    isEnabled = false;
+    memoryEngine = null;
+    if (config?.fallbackToBuiltin && builtinMemory) {
+        logger.info("Falling back to OpenClaw builtin memory system");
+        registerFallbackTools();
+    }
+    logger.info("Cortex Memory plugin disabled successfully");
+}
+function registerFallbackTools() {
+    if (!api || !builtinMemory)
+        return;
+    api.registerTool({
+        name: "search_memory",
+        description: "Search memory (using builtin system - Cortex Memory disabled)",
+        parameters: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search query" },
+                top_k: { type: "integer", description: "Number of results" },
+            },
+            required: ["query"],
+            additionalProperties: false,
+        },
+        execute: async ({ args, context }) => searchMemoryWithFallback(args, context),
+    });
+    registeredFallbackTools.push("search_memory");
+    api.registerTool({
+        name: "store_event",
+        description: "Store event (using builtin system - Cortex Memory disabled)",
+        parameters: {
+            type: "object",
+            properties: {
+                summary: { type: "string", description: "Event summary" },
+            },
+            required: ["summary"],
+            additionalProperties: false,
+        },
+        execute: async ({ args, context }) => storeEventWithFallback(args, context),
+    });
+    registeredFallbackTools.push("store_event");
+    api.registerTool({
+        name: "cortex_memory_status",
+        description: "Get the current status of the Cortex Memory plugin",
+        parameters: {
+            type: "object",
+            properties: {},
+            required: [],
+            additionalProperties: false,
+        },
+        execute: async ({ args, context }) => getPluginStatus(args, context),
+    });
+    registeredFallbackTools.push("cortex_memory_status");
+}
+function unregisterFallbackTools() {
+    if (!api || !api.unregisterTool)
+        return;
+    for (const name of registeredFallbackTools) {
+        try {
+            api.unregisterTool(name);
+        }
+        catch (e) {
+            logger.warn(`Failed to unregister fallback tool ${name}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    registeredFallbackTools = [];
+}
+function getStatus() {
+    return {
+        enabled: isEnabled,
+        serviceRunning: pythonProcess !== null
+    };
+}
+async function unregister() {
+    logger.info("Unregistering Cortex Memory plugin...");
+    stopConfigWatcher();
+    stopAutoReflectScheduler();
+    unregisterHooks();
+    unregisterTools();
+    unregisterFallbackTools();
+    if (shouldUsePythonRuntime()) {
+        await stopPythonServiceAsync();
+    }
+    else {
+        killPythonProcess();
+    }
+    isEnabled = false;
+    isInitializing = false;
+    isRegistered = false;
+    api = null;
+    config = null;
+    autoSearchCacheBySession.clear();
+    builtinMemory = null;
+    memoryEngine = null;
+    registeredTools = [];
+    registeredHooks = [];
+    registeredFallbackTools = [];
+    registeredHookHandlers.clear();
+    stopAutoReflectScheduler();
+    configPath = null;
+    logger.info("Cortex Memory plugin unregistered successfully");
+}
+function register(pluginApi, userConfig) {
+    if (isInitializing || isRegistered) {
+        return;
+    }
+    isInitializing = true;
+    api = pluginApi;
+    logger = api.getLogger?.() || createConsoleLogger();
+    const apiPluginConfig = api.pluginConfig || {};
+    const openclawConfig = api.config || {};
+    const pluginEntry = openclawConfig?.plugins?.entries?.[PLUGIN_ID];
+    const pluginConfig = Object.keys(apiPluginConfig).length > 0 ? apiPluginConfig : (pluginEntry?.config || {});
+    const effectiveConfig = userConfig || pluginConfig || {};
+    const embeddingConfigRaw = (effectiveConfig.embedding || { provider: "openai-compatible", model: "" });
+    const llmConfigRaw = (effectiveConfig.llm || { provider: "openai", model: "" });
+    const rerankerConfigRaw = (effectiveConfig.reranker || { provider: "", model: "" });
+    const embeddingConfig = {
+        ...embeddingConfigRaw,
+        baseURL: embeddingConfigRaw.baseURL ?? embeddingConfigRaw.baseUrl,
+    };
+    const llmConfig = {
+        ...llmConfigRaw,
+        baseURL: llmConfigRaw.baseURL ?? llmConfigRaw.baseUrl,
+    };
+    const rerankerConfig = {
+        ...rerankerConfigRaw,
+        baseURL: rerankerConfigRaw.baseURL ?? rerankerConfigRaw.baseUrl,
+    };
+    config = {
+        embedding: embeddingConfig,
+        llm: llmConfig,
+        reranker: rerankerConfig,
+        dbPath: effectiveConfig.dbPath,
+        autoSync: effectiveConfig.autoSync ?? defaultConfig.autoSync,
+        autoReflect: effectiveConfig.autoReflect ?? defaultConfig.autoReflect,
+        enabled: effectiveConfig.enabled ?? defaultConfig.enabled,
+        fallbackToBuiltin: effectiveConfig.fallbackToBuiltin ?? defaultConfig.fallbackToBuiltin,
+        apiUrl: effectiveConfig.apiUrl ?? "http://127.0.0.1:8765",
+        engineMode: "ts",
+    };
+    memoryEngine = null;
+    if (api.getBuiltinMemory) {
+        try {
+            builtinMemory = api.getBuiltinMemory();
+            logger.info("OpenClaw builtin memory system available for fallback");
+        }
+        catch (e) {
+            logger.warn(`Failed to get builtin memory: ${e instanceof Error ? e.message : String(e)}`);
+            builtinMemory = null;
+        }
+    }
+    const safeConfig = sanitizeForLogging({
+        embedding: { provider: config.embedding.provider, model: config.embedding.model },
+        llm: { provider: config.llm.provider, model: config.llm.model },
+        reranker: { model: config.reranker.model },
+        enabled: config.enabled,
+        fallbackToBuiltin: config.fallbackToBuiltin,
+        engineMode: config.engineMode,
+    });
+    checkOpenClawVersion().catch(e => logger.warn(`Version check failed: ${e}`));
+    configPath = findOpenClawConfig();
+    if (configPath) {
+        logger.info(`Found OpenClaw config at: ${configPath}`);
+    }
+    setupProcessHandlers();
+    startConfigWatcher();
+    const initialEnabled = loadPluginEnabledState();
+    isEnabled = config.enabled !== false && initialEnabled;
+    isInitializing = false;
+    isRegistered = true;
+    logger.info("Cortex Memory plugin registered successfully");
+    logger.info(`Cortex Memory engine mode: ${resolveEngine().mode}`);
+    if (isEnabled) {
+        registerTools();
+        registerHooks();
+        startAutoReflectScheduler();
+        initializeAsync().catch(error => {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error(`Failed to initialize Cortex Memory: ${message}`);
+            if (config?.fallbackToBuiltin && builtinMemory) {
+                unregisterHooks();
+                unregisterTools();
+                logger.info("Falling back to builtin memory");
+                isEnabled = false;
+                registerFallbackTools();
+            }
+        });
+    }
+    else if (config?.fallbackToBuiltin && builtinMemory) {
+        registerFallbackTools();
+    }
+}
+async function initializeAsync() {
+    if (!shouldUsePythonRuntime()) {
+        return;
+    }
+    await startPythonService();
+    await waitForService();
+    logger.info("Cortex Memory Python service started successfully");
+}
+//# sourceMappingURL=index.js.map